ember-source 4.5.0-beta.1 → 4.6.0-alpha.3

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.5.0-beta.1
+ * @version   4.6.0-alpha.3
  */
 /* eslint-disable no-var */
 
@@ -1390,7 +1390,7 @@ define("@ember/-internals/error-handling/index", ["exports"], function (_exports
     onerror = handler;
   }
 
-  var dispatchOverride; // allows testing adapter to override dispatch
+  var dispatchOverride = null; // allows testing adapter to override dispatch
 
   function getDispatchOverride() {
     return dispatchOverride;
@@ -5178,14 +5178,25 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     return string.replace(badChars, escapeChar);
   }
   /**
-    Mark a string as safe for unescaped output with Ember templates. If you
-    return HTML from a helper, use this function to
-    ensure Ember's rendering layer does not escape the HTML.
+    Use this method to indicate that a string should be rendered as HTML
+    when the string is used in a template. To say this another way,
+    strings marked with `htmlSafe` will not be HTML escaped.
+  
+    A word of warning -   The `htmlSafe` method does not make the string safe;
+    it only tells the framework to treat the string as if it is safe to render
+    as HTML. If a string contains user inputs or other untrusted
+    data, you must sanitize the string before using the `htmlSafe` method.
+    Otherwise your code is vulnerable to
+    [Cross-Site Scripting](https://owasp.org/www-community/attacks/DOM_Based_XSS).
+    There are many open source sanitization libraries to choose from,
+    both for front end and server-side sanitization.
   
     ```javascript
     import { htmlSafe } from '@ember/template';
   
-    htmlSafe('<div>someString</div>')
+    const someTrustedOrSanitizedString = "<div>Hello!</div>"
+  
+    htmlSafe(someTrustedorSanitizedString)
     ```
   
     @method htmlSafe
@@ -7434,7 +7445,9 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       return value;
     }
 
-  } // This wrapper logic prevents us from rerendering in case of a hard failure
+  }
+
+  var NO_OP = () => {}; // This wrapper logic prevents us from rerendering in case of a hard failure
   // during render. This prevents infinite revalidation type loops from occuring,
   // and ensures that errors are not swallowed by subsequent follow on failures.
 
@@ -7542,10 +7555,6 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     }
   }
 
-  function K() {
-    /* noop */
-  }
-
   var renderSettledDeferred = null;
   /*
     Returns a promise which will resolve when rendering has settled. Settled in
@@ -7564,7 +7573,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
 
       if (!(0, _runloop._getCurrentRunLoop)()) {
         // ensure a runloop has been kicked off
-        _runloop._backburner.schedule('actions', null, K);
+        _runloop._backburner.schedule('actions', null, NO_OP);
       }
     }
 
@@ -7593,7 +7602,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
         }
 
         loops++;
-        return _runloop._backburner.join(null, K);
+        return _runloop._backburner.join(null, NO_OP);
       }
     }
 
@@ -8901,10 +8910,6 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
   _exports.tracked = tracked;
   _exports.trySet = trySet;
 
-  /**
-  @module @ember/object
-  */
-
   /*
     The event system uses a series of nested hashes to store listeners on an
     object. When a listener is registered, or when an event arrives, these
@@ -9583,6 +9588,12 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
     } else {
       return array.objectAt(index);
     }
+  } // Ideally, we'd use MutableArray.detect but for unknown reasons this causes
+  // the node tests to fail strangely.
+
+
+  function isMutableArray(obj) {
+    return obj != null && typeof obj.replace === 'function';
   }
 
   function replace(array, start, deleteCount, items) {
@@ -9590,10 +9601,11 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
       items = EMPTY_ARRAY;
     }
 
-    if (Array.isArray(array)) {
-      replaceInNativeArray(array, start, deleteCount, items);
-    } else {
+    if (isMutableArray(array)) {
       array.replace(start, deleteCount, items);
+    } else {
+      (true && !(Array.isArray(array)) && (0, _debug.assert)('Can only replace content of a native array or MutableArray', Array.isArray(array)));
+      replaceInNativeArray(array, start, deleteCount, items);
     }
   }
 
@@ -12229,7 +12241,10 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
 
 
     keys() {
-      return _keys(this);
+      var keys = _keys(this);
+
+      (true && !(keys) && (0, _debug.assert)('[BUG] Missing keys for mixin!', keys));
+      return keys;
     }
     /** @internal */
 
@@ -12323,8 +12338,8 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
     if (mixin.properties) {
       var props = Object.keys(mixin.properties);
 
-      for (var i = 0; i < props.length; i++) {
-        ret.add(props[i]);
+      for (var prop of props) {
+        ret.add(prop);
       }
     } else if (mixin.mixins) {
       mixin.mixins.forEach(x => _keys(x, ret, seen));
@@ -17067,9 +17082,6 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
   _exports.default = void 0;
   _exports.triggerEvent = triggerEvent;
 
-  /**
-  @module @ember/routing
-  */
   function defaultDidTransition(infos) {
     updatePaths(this);
 
@@ -19529,9 +19541,10 @@ define("@ember/-internals/runtime/lib/compare", ["exports", "@ember/-internals/r
   //                                              SSt  `------'`
 
   function spaceship(a, b) {
-    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);
+    // SAFETY: `Math.sign` always returns `-1` for negative, `0` for zero, and `1`
+    // for positive numbers. (The extra precision is useful for the way we use
+    // this in the context of `compare`.)
+    return Math.sign(a - b);
   }
   /**
    @module @ember/utils
@@ -20119,15 +20132,15 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
 
   var identityFunction = item => item;
 
-  function uniqBy(array, key) {
-    if (key === void 0) {
-      key = identityFunction;
+  function uniqBy(array, keyOrFunc) {
+    if (keyOrFunc === void 0) {
+      keyOrFunc = identityFunction;
     }
 
     (true && !(isArray(array)) && (0, _debug.assert)(`first argument passed to \`uniqBy\` should be array`, isArray(array)));
     var ret = A();
     var seen = new Set();
-    var getter = typeof key === 'function' ? key : item => (0, _metal.get)(item, key);
+    var getter = typeof keyOrFunc === 'function' ? keyOrFunc : item => (0, _metal.get)(item, keyOrFunc);
     array.forEach(item => {
       var val = getter(item);
 
@@ -20139,8 +20152,13 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     return ret;
   }
 
-  function iter(key, value) {
-    var valueProvided = arguments.length === 2;
+  function iter() {
+    for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+
+    var valueProvided = args.length === 2;
+    var [key, value] = args;
     return valueProvided ? item => value === (0, _metal.get)(item, key) : item => Boolean((0, _metal.get)(item, key));
   }
 
@@ -20148,6 +20166,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     var len = array.length;
 
     for (var index = startAt; index < len; index++) {
+      // SAFETY: Because we're checking the index this value should always be set.
       var item = (0, _metal.objectAt)(array, index);
 
       if (predicate(item, index, array)) {
@@ -20159,17 +20178,29 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
   }
 
   function find(array, callback, target) {
+    if (target === void 0) {
+      target = null;
+    }
+
     var predicate = callback.bind(target);
     var index = findIndex(array, predicate, 0);
     return index === -1 ? undefined : (0, _metal.objectAt)(array, index);
   }
 
   function any(array, callback, target) {
+    if (target === void 0) {
+      target = null;
+    }
+
     var predicate = callback.bind(target);
     return findIndex(array, predicate, 0) !== -1;
   }
 
   function every(array, callback, target) {
+    if (target === void 0) {
+      target = null;
+    }
+
     var cb = callback.bind(target);
 
     var predicate = (item, index, array) => !cb(item, index, array);
@@ -20194,12 +20225,8 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
   }
 
   function removeAt(array, index, len) {
-    if (len === void 0) {
-      len = 1;
-    }
-
     (true && !(index > -1 && index < array.length) && (0, _debug.assert)(`\`removeAt\` index provided is out of range`, index > -1 && index < array.length));
-    (0, _metal.replace)(array, index, len, EMPTY_ARRAY);
+    (0, _metal.replace)(array, index, len !== null && len !== void 0 ? len : 1, EMPTY_ARRAY);
     return array;
   }
 
@@ -20238,24 +20265,24 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
   */
 
 
-  function isArray(_obj) {
-    var obj = _obj;
-
+  function isArray(obj) {
     if (true
     /* DEBUG */
-    && typeof _obj === 'object' && _obj !== null) {
-      var possibleProxyContent = _obj[_metal.PROXY_CONTENT];
+    && typeof obj === 'object' && obj !== null) {
+      // SAFETY: Property read checks are safe if it's an object
+      var possibleProxyContent = obj[_metal.PROXY_CONTENT];
 
       if (possibleProxyContent !== undefined) {
         obj = possibleProxyContent;
       }
-    }
+    } // SAFETY: Property read checks are safe if it's an object
+
 
     if (!obj || obj.setInterval) {
       return false;
     }
 
-    if (Array.isArray(obj) || ArrayMixin.detect(obj)) {
+    if (Array.isArray(obj) || EmberArray.detect(obj)) {
       return true;
     }
 
@@ -20263,7 +20290,8 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
 
     if ('array' === type) {
       return true;
-    }
+    } // SAFETY: Property read checks are safe if it's an object
+
 
     var length = obj.length;
 
@@ -20281,54 +20309,17 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
   */
 
 
-  function nonEnumerableComputed() {
-    var property = (0, _metal.computed)(...arguments);
+  function nonEnumerableComputed(callback) {
+    var property = (0, _metal.computed)(callback);
     property.enumerable = false;
     return property;
   }
 
   function mapBy(key) {
     return this.map(next => (0, _metal.get)(next, key));
-  } // ..........................................................
-  // ARRAY
-  //
-
-  /**
-    This mixin implements Observer-friendly Array-like behavior. It is not a
-    concrete implementation, but it can be used up by other classes that want
-    to appear like arrays.
-  
-    For example, ArrayProxy is a concrete class that can be instantiated to
-    implement array-like behavior. This class uses the Array Mixin by way of
-    the MutableArray mixin, which allows observable changes to be made to the
-    underlying array.
-  
-    This mixin defines methods specifically for collections that provide
-    index-ordered access to their contents. When you are designing code that
-    needs to accept any kind of Array-like object, you should use these methods
-    instead of Array primitives because these will properly notify observers of
-    changes to the array.
-  
-    Although these methods are efficient, they do add a layer of indirection to
-    your application so it is a good idea to use them only when you need the
-    flexibility of using both true JavaScript arrays and "virtual" arrays such
-    as controllers and collections.
-  
-    You can use the methods defined in this module to access and modify array
-    contents in an observable-friendly way. You can also be notified whenever
-    the membership of an array changes by using `.observes('myArray.[]')`.
-  
-    To support `EmberArray` in your own class, you must override two
-    primitives to use it: `length()` and `objectAt()`.
-  
-    @class EmberArray
-    @uses Enumerable
-    @since Ember 0.9.0
-    @public
-  */
-
+  }
 
-  var ArrayMixin = _metal.Mixin.create(_enumerable.default, {
+  var EmberArray = _metal.Mixin.create(_enumerable.default, {
     init() {
       this._super(...arguments);
 
@@ -20337,28 +20328,28 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
 
     /**
       __Required.__ You must implement this method to apply this mixin.
-       Your array must support the `length` property. Your replace methods should
+         Your array must support the `length` property. Your replace methods should
       set this property whenever it changes.
-       @property {Number} length
+         @property {Number} length
       @public
     */
 
     /**
       Returns the object at the given `index`. If the given `index` is negative
       or is greater or equal than the array length, returns `undefined`.
-       This is one of the primitives you must implement to support `EmberArray`.
+         This is one of the primitives you must implement to support `EmberArray`.
       If your object supports retrieving the value of an array item using `get()`
       (i.e. `myArray.get(0)`), then you do not need to implement this method
       yourself.
-       ```javascript
+         ```javascript
       let arr = ['a', 'b', 'c', 'd'];
-       arr.objectAt(0);   // 'a'
+         arr.objectAt(0);   // 'a'
       arr.objectAt(3);   // 'd'
       arr.objectAt(-1);  // undefined
       arr.objectAt(4);   // undefined
       arr.objectAt(5);   // undefined
       ```
-       @method objectAt
+         @method objectAt
       @param {Number} idx The index of the item to return.
       @return {*} item at index or undefined
       @public
@@ -20366,12 +20357,12 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
 
     /**
       This returns the objects at the specified indexes, using `objectAt`.
-       ```javascript
+         ```javascript
       let arr = ['a', 'b', 'c', 'd'];
-       arr.objectsAt([0, 1, 2]);  // ['a', 'b', 'c']
+         arr.objectsAt([0, 1, 2]);  // ['a', 'b', 'c']
       arr.objectsAt([2, 3, 4]);  // ['c', 'd', undefined]
       ```
-       @method objectsAt
+         @method objectsAt
       @param {Array} indexes An array of indexes of items to return.
       @return {Array}
       @public
@@ -20384,13 +20375,13 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       This is the handler for the special array content property. If you get
       this property, it will return this. If you set this property to a new
       array, it will replace the current content.
-       ```javascript
+         ```javascript
       let peopleToMoon = ['Armstrong', 'Aldrin'];
-       peopleToMoon.get('[]'); // ['Armstrong', 'Aldrin']
-       peopleToMoon.set('[]', ['Collins']); // ['Collins']
+         peopleToMoon.get('[]'); // ['Armstrong', 'Aldrin']
+         peopleToMoon.set('[]', ['Collins']); // ['Collins']
       peopleToMoon.get('[]'); // ['Collins']
       ```
-       @property []
+         @property []
       @return this
       @public
     */
@@ -20399,7 +20390,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
         return this;
       },
 
-      set(key, value) {
+      set(_key, value) {
         this.replace(0, this.length, value);
         return this;
       }
@@ -20408,17 +20399,17 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
 
     /**
       The first object in the array, or `undefined` if the array is empty.
-       ```javascript
+         ```javascript
       let vowels = ['a', 'e', 'i', 'o', 'u'];
       vowels.firstObject; // 'a'
-       vowels.shiftObject();
+         vowels.shiftObject();
       vowels.firstObject; // 'e'
-       vowels.reverseObjects();
+         vowels.reverseObjects();
       vowels.firstObject; // 'u'
-       vowels.clear();
+         vowels.clear();
       vowels.firstObject; // undefined
       ```
-       @property firstObject
+         @property firstObject
       @return {Object | undefined} The first object in the array
       @public
     */
@@ -20428,7 +20419,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
 
     /**
       The last object in the array, or `undefined` if the array is empty.
-       @property lastObject
+         @property lastObject
       @return {Object | undefined} The last object in the array
       @public
     */
@@ -20442,13 +20433,13 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       Returns a new array that is a slice of the receiver. This implementation
       uses the observable array methods to retrieve the objects for the new
       slice.
-       ```javascript
+         ```javascript
       let arr = ['red', 'green', 'blue'];
-       arr.slice(0);       // ['red', 'green', 'blue']
+         arr.slice(0);       // ['red', 'green', 'blue']
       arr.slice(0, 2);    // ['red', 'green']
       arr.slice(1, 100);  // ['green', 'blue']
       ```
-       @method slice
+         @method slice
       @param {Number} beginIndex (Optional) index to begin slicing from.
       @param {Number} endIndex (Optional) index to end the slice at (but not included).
       @return {Array} New array with specified slice
@@ -20466,13 +20457,17 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
         beginIndex = length + beginIndex;
       }
 
+      var validatedEndIndex;
+
       if (endIndex === undefined || endIndex > length) {
-        endIndex = length;
+        validatedEndIndex = length;
       } else if (endIndex < 0) {
-        endIndex = length + endIndex;
+        validatedEndIndex = length + endIndex;
+      } else {
+        validatedEndIndex = endIndex;
       }
 
-      while (beginIndex < endIndex) {
+      while (beginIndex < validatedEndIndex) {
         ret[ret.length] = (0, _metal.objectAt)(this, beginIndex++);
       }
 
@@ -20482,29 +20477,29 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Used to determine the passed object's first occurrence in the array.
       Returns the index if found, -1 if no match is found.
-       The optional `startAt` argument can be used to pass a starting
+         The optional `startAt` argument can be used to pass a starting
       index to search from, effectively slicing the searchable portion
       of the array. If it's negative it will add the array length to
       the startAt value passed in as the index to search from. If less
       than or equal to `-1 * array.length` the entire array is searched.
-       ```javascript
+         ```javascript
       let arr = ['a', 'b', 'c', 'd', 'a'];
-       arr.indexOf('a');       //  0
+         arr.indexOf('a');       //  0
       arr.indexOf('z');       // -1
       arr.indexOf('a', 2);    //  4
       arr.indexOf('a', -1);   //  4, equivalent to indexOf('a', 4)
       arr.indexOf('a', -100); //  0, searches entire array
       arr.indexOf('b', 3);    // -1
       arr.indexOf('a', 100);  // -1
-       let people = [{ name: 'Zoey' }, { name: 'Bob' }]
+         let people = [{ name: 'Zoey' }, { name: 'Bob' }]
       let newPerson = { name: 'Tom' };
       people = [newPerson, ...people, newPerson];
-       people.indexOf(newPerson);     //  0
+         people.indexOf(newPerson);     //  0
       people.indexOf(newPerson, 1);  //  3
       people.indexOf(newPerson, -4); //  0
       people.indexOf(newPerson, 10); // -1
       ```
-       @method indexOf
+         @method indexOf
       @param {Object} object the item to search for
       @param {Number} startAt optional starting location to search, default 0
       @return {Number} index or -1 if not found
@@ -20516,7 +20511,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
 
     /**
       Returns the index of the given `object`'s last occurrence.
-       - If no `startAt` argument is given, the search starts from
+         - If no `startAt` argument is given, the search starts from
       the last position.
       - If it's greater than or equal to the length of the array,
       the search starts from the last position.
@@ -20524,10 +20519,10 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       of the array i.e. `startAt + array.length`.
       - If it's any other positive number, will search backwards
       from that index of the array.
-       Returns -1 if no match is found.
-       ```javascript
+         Returns -1 if no match is found.
+         ```javascript
       let arr = ['a', 'b', 'c', 'd', 'a'];
-       arr.lastIndexOf('a');       //  4
+         arr.lastIndexOf('a');       //  4
       arr.lastIndexOf('z');       // -1
       arr.lastIndexOf('a', 2);    //  0
       arr.lastIndexOf('a', -1);   //  4
@@ -20535,7 +20530,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       arr.lastIndexOf('b', 3);    //  1
       arr.lastIndexOf('a', 100);  //  4
       ```
-       @method lastIndexOf
+         @method lastIndexOf
       @param {Object} object the item to search for
       @param {Number} startAt optional starting location to search from
       backwards, defaults to `(array.length - 1)`
@@ -20567,26 +20562,26 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       Iterates through the array, calling the passed function on each
       item. This method corresponds to the `forEach()` method defined in
       JavaScript 1.6.
-       The callback method you provide should have the following signature (all
+         The callback method you provide should have the following signature (all
       parameters are optional):
-       ```javascript
+         ```javascript
       function(item, index, array);
       ```
-       - `item` is the current item in the iteration.
+         - `item` is the current item in the iteration.
       - `index` is the current index in the iteration.
       - `array` is the array itself.
-       Note that in addition to a callback, you can also pass an optional target
+         Note that in addition to a callback, you can also pass an optional target
       object that will be set as `this` on the context. This is a good way
       to give your iterator function access to the current object.
-       Example Usage:
-       ```javascript
+         Example Usage:
+         ```javascript
       let foods = [
         { name: 'apple', eaten: false },
         { name: 'banana', eaten: false },
         { name: 'carrot', eaten: false }
       ];
-       foods.forEach((food) => food.eaten = true);
-       let output = '';
+         foods.forEach((food) => food.eaten = true);
+         let output = '';
       foods.forEach((item, index, array) =>
         output += `${index + 1}/${array.length} ${item.name}\n`;
       );
@@ -20595,7 +20590,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       // 2/3 banana
       // 3/3 carrot
       ```
-       @method forEach
+         @method forEach
       @param {Function} callback The callback to execute
       @param {Object} [target] The target object to use
       @return {Object} receiver
@@ -20619,16 +20614,16 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
 
     /**
       Alias for `mapBy`.
-       Returns the value of the named
+         Returns the value of the named
       property on all items in the enumeration.
-       ```javascript
+         ```javascript
       let people = [{name: 'Joe'}, {name: 'Matt'}];
-       people.getEach('name');
+         people.getEach('name');
       // ['Joe', 'Matt'];
-       people.getEach('nonexistentProperty');
+         people.getEach('nonexistentProperty');
       // [undefined, undefined];
       ```
-       @method getEach
+         @method getEach
       @param {String} key name of the property
       @return {Array} The mapped array.
       @public
@@ -20640,12 +20635,12 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       ergonomic than using other methods defined on this helper. If the object
       implements Observable, the value will be changed to `set(),` otherwise
       it will be set directly. `null` objects are skipped.
-       ```javascript
+         ```javascript
       let people = [{name: 'Joe'}, {name: 'Matt'}];
-       people.setEach('zipCode', '10011');
+         people.setEach('zipCode', '10011');
       // [{name: 'Joe', zipCode: '10011'}, {name: 'Matt', zipCode: '10011'}];
       ```
-       @method setEach
+         @method setEach
       @param {String} key The key to set
       @param {Object} value The object to set
       @return {Object} receiver
@@ -20658,24 +20653,24 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Maps all of the items in the enumeration to another value, returning
       a new array. This method corresponds to `map()` defined in JavaScript 1.6.
-       The callback method you provide should have the following signature (all
+         The callback method you provide should have the following signature (all
       parameters are optional):
-       ```javascript
+         ```javascript
       function(item, index, array);
       let arr = [1, 2, 3, 4, 5, 6];
-       arr.map(element => element * element);
+         arr.map(element => element * element);
       // [1, 4, 9, 16, 25, 36];
-       arr.map((element, index) => element + index);
+         arr.map((element, index) => element + index);
       // [1, 3, 5, 7, 9, 11];
       ```
-       - `item` is the current item in the iteration.
+         - `item` is the current item in the iteration.
       - `index` is the current index in the iteration.
       - `array` is the array itself.
-       It should return the mapped value.
-       Note that in addition to a callback, you can also pass an optional target
+         It should return the mapped value.
+         Note that in addition to a callback, you can also pass an optional target
       object that will be set as `this` on the context. This is a good way
       to give your iterator function access to the current object.
-       @method map
+         @method map
       @param {Function} callback The callback to execute
       @param {Object} [target] The target object to use
       @return {Array} The mapped array.
@@ -20695,14 +20690,14 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Similar to map, this specialized function returns the value of the named
       property on all items in the enumeration.
-       ```javascript
+         ```javascript
       let people = [{name: 'Joe'}, {name: 'Matt'}];
-       people.mapBy('name');
+         people.mapBy('name');
       // ['Joe', 'Matt'];
-       people.mapBy('unknownProperty');
+         people.mapBy('unknownProperty');
       // [undefined, undefined];
       ```
-       @method mapBy
+         @method mapBy
       @param {String} key name of the property
       @return {Array} The mapped array.
       @public
@@ -20712,42 +20707,42 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Returns a new array with all of the items in the enumeration that the provided
       callback function returns true for. This method corresponds to [Array.prototype.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter).
-       The callback method should have the following signature:
-       ```javascript
+         The callback method should have the following signature:
+         ```javascript
       function(item, index, array);
       ```
-       - `item` is the current item in the iteration.
+         - `item` is the current item in the iteration.
       - `index` is the current index in the iteration.
       - `array` is the array itself.
-       All parameters are optional. The function should return `true` to include the item
+         All parameters are optional. The function should return `true` to include the item
       in the results, and `false` otherwise.
-       Example:
-       ```javascript
+         Example:
+         ```javascript
       function isAdult(person) {
         return person.age > 18;
       };
-       let people = Ember.A([{ name: 'John', age: 14 }, { name: 'Joan', age: 45 }]);
-       people.filter(isAdult); // returns [{ name: 'Joan', age: 45 }];
+         let people = Ember.A([{ name: 'John', age: 14 }, { name: 'Joan', age: 45 }]);
+         people.filter(isAdult); // returns [{ name: 'Joan', age: 45 }];
       ```
-       Note that in addition to a callback, you can pass an optional target object
+         Note that in addition to a callback, you can pass an optional target object
       that will be set as `this` on the context. This is a good way to give your
       iterator function access to the current object. For example:
-       ```javascript
+         ```javascript
       function isAdultAndEngineer(person) {
         return person.age > 18 && this.engineering;
       }
-       class AdultsCollection {
+         class AdultsCollection {
         engineering = false;
-         constructor(opts = {}) {
+           constructor(opts = {}) {
           super(...arguments);
-           this.engineering = opts.engineering;
+             this.engineering = opts.engineering;
           this.people = Ember.A([{ name: 'John', age: 14 }, { name: 'Joan', age: 45 }]);
         }
       }
-       let collection = new AdultsCollection({ engineering: true });
+         let collection = new AdultsCollection({ engineering: true });
       collection.people.filter(isAdultAndEngineer, { target: collection });
       ```
-       @method filter
+         @method filter
       @param {Function} callback The callback to execute
       @param {Object} [target] The target object to use
       @return {Array} A filtered array.
@@ -20771,20 +20766,20 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Returns an array with all of the items in the enumeration where the passed
       function returns false. This method is the inverse of filter().
-       The callback method you provide should have the following signature (all
+         The callback method you provide should have the following signature (all
       parameters are optional):
-       ```javascript
+         ```javascript
       function(item, index, array);
       ```
-       - *item* is the current item in the iteration.
+         - *item* is the current item in the iteration.
       - *index* is the current index in the iteration
       - *array* is the array itself.
-       It should return a falsey value to include the item in the results.
-       Note that in addition to a callback, you can also pass an optional target
+         It should return a falsey value to include the item in the results.
+         Note that in addition to a callback, you can also pass an optional target
       object that will be set as "this" on the context. This is a good way
       to give your iterator function access to the current object.
-       Example Usage:
-       ```javascript
+         Example Usage:
+         ```javascript
       const food = [
         { food: 'apple', isFruit: true },
         { food: 'bread', isFruit: false },
@@ -20794,7 +20789,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
         return thing.isFruit;
       }); // [{food: 'bread', isFruit: false}]
       ```
-       @method reject
+         @method reject
       @param {Function} callback The callback to execute
       @param {Object} [target] The target object to use
       @return {Array} A rejected array.
@@ -20807,6 +20802,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
 
       (true && !(typeof callback === 'function') && (0, _debug.assert)('`reject` expects a function as first argument.', typeof callback === 'function'));
       return this.filter(function () {
+        // @ts-expect-error TS doesn't like us using arguments like this
         return !callback.apply(target, arguments);
       });
     },
@@ -20815,19 +20811,20 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       Filters the array by the property and an optional value. If a value is given, it returns
       the items that have said value for the property. If not, it returns all the items that
       have a truthy value for the property.
-       Example Usage:
-       ```javascript
+         Example Usage:
+         ```javascript
       let things = Ember.A([{ food: 'apple', isFruit: true }, { food: 'beans', isFruit: false }]);
-       things.filterBy('food', 'beans'); // [{ food: 'beans', isFruit: false }]
+         things.filterBy('food', 'beans'); // [{ food: 'beans', isFruit: false }]
       things.filterBy('isFruit'); // [{ food: 'apple', isFruit: true }]
       ```
-       @method filterBy
+         @method filterBy
       @param {String} key the property to test
       @param {*} [value] optional value to test against.
       @return {Array} filtered array
       @public
     */
     filterBy() {
+      // @ts-expect-error TS doesn't like the ...arguments spread here.
       return this.filter(iter(...arguments));
     },
 
@@ -20835,8 +20832,8 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       Returns an array with the items that do not have truthy values for the provided key.
       You can pass an optional second argument with a target value to reject for the key.
       Otherwise this will reject objects where the provided property evaluates to false.
-       Example Usage:
-       ```javascript
+         Example Usage:
+         ```javascript
         let food = [
           { name: "apple", isFruit: true },
           { name: "carrot", isFruit: false },
@@ -20845,44 +20842,45 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
         food.rejectBy('isFruit'); // [{ name: "carrot", isFruit: false }, { name: "bread", isFruit: false }]
         food.rejectBy('name', 'carrot'); // [{ name: "apple", isFruit: true }}, { name: "bread", isFruit: false }]
       ```
-       @method rejectBy
+         @method rejectBy
       @param {String} key the property to test
       @param {*} [value] optional value to test against.
       @return {Array} rejected array
       @public
     */
     rejectBy() {
+      // @ts-expect-error TS doesn't like the ...arguments spread here.
       return this.reject(iter(...arguments));
     },
 
     /**
       Returns the first item in the array for which the callback returns true.
       This method is similar to the `find()` method defined in ECMAScript 2015.
-       The callback method you provide should have the following signature (all
+         The callback method you provide should have the following signature (all
       parameters are optional):
-       ```javascript
+         ```javascript
       function(item, index, array);
       ```
-       - `item` is the current item in the iteration.
+         - `item` is the current item in the iteration.
       - `index` is the current index in the iteration.
       - `array` is the array itself.
-       It should return the `true` to include the item in the results, `false`
+         It should return the `true` to include the item in the results, `false`
       otherwise.
-       Note that in addition to a callback, you can also pass an optional target
+         Note that in addition to a callback, you can also pass an optional target
       object that will be set as `this` on the context. This is a good way
       to give your iterator function access to the current object.
-       Example Usage:
-       ```javascript
+         Example Usage:
+         ```javascript
       let users = [
         { id: 1, name: 'Yehuda' },
         { id: 2, name: 'Tom' },
         { id: 3, name: 'Melanie' },
         { id: 4, name: 'Leah' }
       ];
-       users.find((user) => user.name == 'Tom'); // [{ id: 2, name: 'Tom' }]
+         users.find((user) => user.name == 'Tom'); // [{ id: 2, name: 'Tom' }]
       users.find(({ id }) => id == 3); // [{ id: 3, name: 'Melanie' }]
       ```
-       @method find
+         @method find
       @param {Function} callback The callback to execute
       @param {Object} [target] The target object to use
       @return {Object} Found item or `undefined`.
@@ -20901,52 +20899,54 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       Returns the first item with a property matching the passed value. You
       can pass an optional second argument with the target value. Otherwise
       this will match any property that evaluates to `true`.
-       This method works much like the more generic `find()` method.
-       Usage Example:
-       ```javascript
+         This method works much like the more generic `find()` method.
+         Usage Example:
+         ```javascript
       let users = [
         { id: 1, name: 'Yehuda', isTom: false },
         { id: 2, name: 'Tom', isTom: true },
         { id: 3, name: 'Melanie', isTom: false },
         { id: 4, name: 'Leah', isTom: false }
       ];
-       users.findBy('id', 4); // { id: 4, name: 'Leah', isTom: false }
+         users.findBy('id', 4); // { id: 4, name: 'Leah', isTom: false }
       users.findBy('name', 'Melanie'); // { id: 3, name: 'Melanie', isTom: false }
       users.findBy('isTom'); // { id: 2, name: 'Tom', isTom: true }
       ```
-       @method findBy
+         @method findBy
       @param {String} key the property to test
       @param {String} [value] optional value to test against.
       @return {Object} found item or `undefined`
       @public
     */
     findBy() {
-      return find(this, iter(...arguments));
+      // @ts-expect-error TS doesn't like the ...arguments spread here.
+      var callback = iter(...arguments);
+      return find(this, callback);
     },
 
     /**
       Returns `true` if the passed function returns true for every item in the
       enumeration. This corresponds with the `Array.prototype.every()` method defined in ES5.
-       The callback method should have the following signature:
-       ```javascript
+         The callback method should have the following signature:
+         ```javascript
       function(item, index, array);
       ```
-       - `item` is the current item in the iteration.
+         - `item` is the current item in the iteration.
       - `index` is the current index in the iteration.
       - `array` is the array itself.
-       All params are optional. The method should return `true` or `false`.
-       Note that in addition to a callback, you can also pass an optional target
+         All params are optional. The method should return `true` or `false`.
+         Note that in addition to a callback, you can also pass an optional target
       object that will be set as `this` on the context. This is a good way
       to give your iterator function access to the current object.
-       Usage example:
-       ```javascript
+         Usage example:
+         ```javascript
       function isAdult(person) {
         return person.age > 18;
       };
-       const people = Ember.A([{ name: 'John', age: 24 }, { name: 'Joan', age: 45 }]);
+         const people = Ember.A([{ name: 'John', age: 24 }, { name: 'Joan', age: 45 }]);
       const areAllAdults = people.every(isAdult);
       ```
-       @method every
+         @method every
       @param {Function} callback The callback to execute
       @param {Object} [target] The target object to use
       @return {Boolean}
@@ -20965,7 +20965,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       Returns `true` if the passed property resolves to the value of the second
       argument for all items in the array. This method is often simpler/faster
       than using a callback.
-       Note that like the native `Array.every`, `isEvery` will return true when called
+         Note that like the native `Array.every`, `isEvery` will return true when called
       on any empty array.
       ```javascript
       class Language {
@@ -20974,20 +20974,20 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
           this.programmingLanguage = isProgrammingLanguage;
         }
       }
-       const compiledLanguages = [
+         const compiledLanguages = [
         new Language('Java', true),
         new Language('Go', true),
         new Language('Rust', true)
       ]
-       const languagesKnownByMe = [
+         const languagesKnownByMe = [
         new Language('Javascript', true),
         new Language('English', false),
         new Language('Ruby', true)
       ]
-       compiledLanguages.isEvery('programmingLanguage'); // true
+         compiledLanguages.isEvery('programmingLanguage'); // true
       languagesKnownByMe.isEvery('programmingLanguage'); // false
       ```
-       @method isEvery
+         @method isEvery
       @param {String} key the property to test
       @param {String} [value] optional value to test against. Defaults to `true`
       @return {Boolean}
@@ -20995,7 +20995,9 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       @public
     */
     isEvery() {
-      return every(this, iter(...arguments));
+      // @ts-expect-error TS doesn't like the ...arguments spread here.
+      var callback = iter(...arguments);
+      return every(this, callback);
     },
 
     /**
@@ -21003,27 +21005,27 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       present in the array until it finds the one where callback returns a truthy
       value (i.e. `true`). If such an element is found, any() immediately returns
       true. Otherwise, any() returns false.
-       ```javascript
+         ```javascript
       function(item, index, array);
       ```
-       - `item` is the current item in the iteration.
+         - `item` is the current item in the iteration.
       - `index` is the current index in the iteration.
       - `array` is the array object itself.
-       Note that in addition to a callback, you can also pass an optional target
+         Note that in addition to a callback, you can also pass an optional target
       object that will be set as `this` on the context. It can be a good way
       to give your iterator function access to an object in cases where an ES6
       arrow function would not be appropriate.
-       Usage Example:
-       ```javascript
+         Usage Example:
+         ```javascript
       let includesManager = people.any(this.findPersonInManagersList, this);
-       let includesStockHolder = people.any(person => {
+         let includesStockHolder = people.any(person => {
         return this.findPersonInStockHoldersList(person)
       });
-       if (includesManager || includesStockHolder) {
+         if (includesManager || includesStockHolder) {
         Paychecks.addBiggerBonus();
       }
       ```
-       @method any
+         @method any
       @param {Function} callback The callback to execute
       @param {Object} [target] The target object to use
       @return {Boolean} `true` if the passed function returns `true` for any item
@@ -21042,16 +21044,16 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       Returns `true` if the passed property resolves to the value of the second
       argument for any item in the array. This method is often simpler/faster
       than using a callback.
-       Example usage:
-       ```javascript
+         Example usage:
+         ```javascript
       const food = [
         { food: 'apple', isFruit: true },
         { food: 'bread', isFruit: false },
         { food: 'banana', isFruit: true }
       ];
-       food.isAny('isFruit'); // true
+         food.isAny('isFruit'); // true
       ```
-       @method isAny
+         @method isAny
       @param {String} key the property to test
       @param {String} [value] optional value to test against. Defaults to `true`
       @return {Boolean}
@@ -21059,44 +21061,47 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       @public
     */
     isAny() {
-      return any(this, iter(...arguments));
+      // @ts-expect-error TS doesn't like us using arguments like this
+      var callback = iter(...arguments);
+      return any(this, callback);
     },
 
     /**
       This will combine the values of the array into a single value. It
       is a useful way to collect a summary value from an array. This
       corresponds to the `reduce()` method defined in JavaScript 1.8.
-       The callback method you provide should have the following signature (all
+         The callback method you provide should have the following signature (all
       parameters are optional):
-       ```javascript
+         ```javascript
       function(previousValue, item, index, array);
       ```
-       - `previousValue` is the value returned by the last call to the iterator.
+         - `previousValue` is the value returned by the last call to the iterator.
       - `item` is the current item in the iteration.
       - `index` is the current index in the iteration.
       - `array` is the array itself.
-       Return the new cumulative value.
-       In addition to the callback you can also pass an `initialValue`. An error
+         Return the new cumulative value.
+         In addition to the callback you can also pass an `initialValue`. An error
       will be raised if you do not pass an initial value and the enumerator is
       empty.
-       Note that unlike the other methods, this method does not allow you to
+         Note that unlike the other methods, this method does not allow you to
       pass a target object to set as this for the callback. It's part of the
       spec. Sorry.
-       Example Usage:
-       ```javascript
+         Example Usage:
+         ```javascript
         let numbers = [1, 2, 3, 4, 5];
-         numbers.reduce(function(summation, current) {
+           numbers.reduce(function(summation, current) {
           return summation + current;
         }); // 15 (1 + 2 + 3 + 4 + 5)
-         numbers.reduce(function(summation, current) {
+           numbers.reduce(function(summation, current) {
           return summation + current;
         }, -15); // 0 (-15 + 1 + 2 + 3 + 4 + 5)
-          let binaryValues = [true, false, false];
-         binaryValues.reduce(function(truthValue, current) {
+     
+        let binaryValues = [true, false, false];
+           binaryValues.reduce(function(truthValue, current) {
           return truthValue && current;
         }); // false (true && false && false)
       ```
-       @method reduce
+         @method reduce
       @param {Function} callback The callback to execute
       @param {Object} initialValue Initial value for the reduce
       @return {Object} The reduced value.
@@ -21116,40 +21121,45 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       Invokes the named method on every object in the receiver that
       implements it. This method corresponds to the implementation in
       Prototype 1.6.
-       ```javascript
+         ```javascript
       class Person {
         name = null;
-         constructor(name) {
+           constructor(name) {
           this.name = name;
         }
-         greet(prefix='Hello') {
+           greet(prefix='Hello') {
           return `${prefix} ${this.name}`;
         }
       }
-       let people = [new Person('Joe'), new Person('Matt')];
-       people.invoke('greet'); // ['Hello Joe', 'Hello Matt']
+         let people = [new Person('Joe'), new Person('Matt')];
+         people.invoke('greet'); // ['Hello Joe', 'Hello Matt']
       people.invoke('greet', 'Bonjour'); // ['Bonjour Joe', 'Bonjour Matt']
       ```
-       @method invoke
+         @method invoke
       @param {String} methodName the name of the method
       @param {Object...} args optional arguments to pass as well.
       @return {Array} return values from calling invoke.
       @public
     */
     invoke(methodName) {
-      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        args[_key - 1] = arguments[_key];
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key3 = 1; _key3 < _len2; _key3++) {
+        args[_key3 - 1] = arguments[_key3];
       }
 
-      var ret = A();
-      this.forEach(item => ret.push(item[methodName]?.(...args)));
+      var ret = A(); // SAFETY: This is not entirely safe and the code will not work with Ember proxies
+
+      this.forEach(item => {
+        var _a, _b;
+
+        return ret.push((_b = (_a = item)[methodName]) === null || _b === void 0 ? void 0 : _b.call(_a, ...args));
+      });
       return ret;
     },
 
     /**
       Simply converts the object into a genuine array. The order is not
       guaranteed. Corresponds to the method implemented by Prototype.
-       @method toArray
+         @method toArray
       @return {Array} the object as an array.
       @public
     */
@@ -21159,11 +21169,11 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
 
     /**
       Returns a copy of the array with all `null` and `undefined` elements removed.
-       ```javascript
+         ```javascript
       let arr = ['a', null, 'c', undefined];
       arr.compact();  // ['a', 'c']
       ```
-       @method compact
+         @method compact
       @return {Array} the array without null and undefined elements.
       @public
     */
@@ -21174,13 +21184,13 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Used to determine if the array contains the passed object.
       Returns `true` if found, `false` otherwise.
-       The optional `startAt` argument can be used to pass a starting
+         The optional `startAt` argument can be used to pass a starting
       index to search from, effectively slicing the searchable portion
       of the array. If it's negative it will add the array length to
       the startAt value passed in as the index to search from. If less
       than or equal to `-1 * array.length` the entire array is searched.
-       This method has the same behavior of JavaScript's [Array.includes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes).
-       ```javascript
+         This method has the same behavior of JavaScript's [Array.includes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes).
+         ```javascript
       [1, 2, 3].includes(2);     // true
       [1, 2, 3].includes(4);     // false
       [1, 2, 3].includes(3, 2);  // true
@@ -21190,7 +21200,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       [1, 2, 3].includes(1, -4); // true
       [1, 2, NaN].includes(NaN); // true
       ```
-       @method includes
+         @method includes
       @param {Object} object The object to search for.
       @param {Number} startAt optional starting location to search, default 0
       @return {Boolean} `true` if object is found in the array.
@@ -21202,19 +21212,19 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
 
     /**
       Sorts the array by the keys specified in the argument.
-       You may provide multiple arguments to sort by multiple properties.
-       ```javascript
+         You may provide multiple arguments to sort by multiple properties.
+         ```javascript
      let colors = [
        { name: 'red', weight: 500 },
        { name: 'green', weight: 600 },
        { name: 'blue', weight: 500 }
       ];
-      colors.sortBy('name');
+        colors.sortBy('name');
      // [{name: 'blue', weight: 500}, {name: 'green', weight: 600}, {name: 'red', weight: 500}]
-      colors.sortBy('weight', 'name');
+        colors.sortBy('weight', 'name');
      // [{name: 'blue', weight: 500}, {name: 'red', weight: 500}, {name: 'green', weight: 600}]
      ```
-       @method sortBy
+         @method sortBy
       @param {String} property name(s) to sort on
       @return {Array} The sorted array.
       @since 1.2.0
@@ -21242,12 +21252,12 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Returns a new array that contains only unique values. The default
       implementation returns an array regardless of the receiver type.
-       ```javascript
+         ```javascript
       let arr = ['a', 'a', 'b', 'b'];
       arr.uniq();  // ['a', 'b']
       ```
-       This only works on primitive data types, e.g. Strings, Numbers, etc.
-       @method uniq
+         This only works on primitive data types, e.g. Strings, Numbers, etc.
+         @method uniq
       @return {EmberArray}
       @public
     */
@@ -21258,13 +21268,13 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Returns a new array that contains only items containing a unique property value.
       The default implementation returns an array regardless of the receiver type.
-       ```javascript
+         ```javascript
       let arr = [{ value: 'a' }, { value: 'a' }, { value: 'b' }, { value: 'b' }];
       arr.uniqBy('value');  // [{ value: 'a' }, { value: 'b' }]
-       let arr = [2.2, 2.1, 3.2, 3.3];
+         let arr = [2.2, 2.1, 3.2, 3.3];
       arr.uniqBy(Math.floor);  // [2.2, 3.2];
       ```
-       @method uniqBy
+         @method uniqBy
       @param {String,Function} key
       @return {EmberArray}
       @public
@@ -21277,11 +21287,11 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       Returns a new array that excludes the passed value. The default
       implementation returns an array regardless of the receiver type.
       If the receiver does not contain the value it returns the original array.
-       ```javascript
+         ```javascript
       let arr = ['a', 'b', 'a', 'c'];
       arr.without('a');  // ['b', 'c']
       ```
-       @method without
+         @method without
       @param {Object} value
       @return {EmberArray}
       @public
@@ -21297,36 +21307,15 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     }
 
   });
-  /**
-    This mixin defines the API for modifying array-like objects. These methods
-    can be applied only to a collection that keeps its items in an ordered set.
-    It builds upon the Array mixin and adds methods to modify the array.
-    One concrete implementations of this class include ArrayProxy.
-  
-    It is important to use the methods in this class to modify arrays so that
-    changes are observable. This allows the binding system in Ember to function
-    correctly.
-  
-  
-    Note that an Array can change even if it does not implement this mixin.
-    For example, one might implement a SparseArray that cannot be directly
-    modified, but if its underlying enumerable changes, it will change also.
-  
-    @class MutableArray
-    @uses EmberArray
-    @uses MutableEnumerable
-    @public
-  */
 
-
-  var MutableArray = _metal.Mixin.create(ArrayMixin, _mutable_enumerable.default, {
+  var MutableArray = _metal.Mixin.create(EmberArray, _mutable_enumerable.default, {
     /**
       __Required.__ You must implement this method to apply this mixin.
-       This is one of the primitives you must implement to support `Array`.
+         This is one of the primitives you must implement to support `Array`.
       You should replace amt objects started at idx with the objects in the
       passed array.
-       Note that this method is expected to validate the type(s) of objects that it expects.
-       @method replace
+         Note that this method is expected to validate the type(s) of objects that it expects.
+         @method replace
       @param {Number} idx Starting index in the array to replace. If
         idx >= length, then append to the end of the array.
       @param {Number} amt Number of elements that should be removed from
@@ -21339,13 +21328,13 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Remove all elements from the array. This is useful if you
       want to reuse an existing array without having to recreate it.
-       ```javascript
+         ```javascript
       let colors = ['red', 'green', 'blue'];
-       colors.length;  // 3
+         colors.length;  // 3
       colors.clear(); // []
       colors.length;  // 0
       ```
-       @method clear
+         @method clear
       @return {Array} An empty Array.
       @public
     */
@@ -21363,12 +21352,12 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       This will use the primitive `replace()` method to insert an object at the
       specified index.
-       ```javascript
+         ```javascript
       let colors = ['red', 'green', 'blue'];
-       colors.insertAt(2, 'yellow');  // ['red', 'green', 'yellow', 'blue']
+         colors.insertAt(2, 'yellow');  // ['red', 'green', 'yellow', 'blue']
       colors.insertAt(5, 'orange');  // Error: Index out of range
       ```
-       @method insertAt
+         @method insertAt
       @param {Number} idx index of insert the object at.
       @param {Object} object object to insert
       @return {EmberArray} receiver
@@ -21382,15 +21371,15 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Remove an object at the specified index using the `replace()` primitive
       method. You can pass either a single index, or a start and a length.
-       If you pass a start and length that is beyond the
+         If you pass a start and length that is beyond the
       length this method will throw an assertion.
-       ```javascript
+         ```javascript
       let colors = ['red', 'green', 'blue', 'yellow', 'orange'];
-       colors.removeAt(0);     // ['green', 'blue', 'yellow', 'orange']
+         colors.removeAt(0);     // ['green', 'blue', 'yellow', 'orange']
       colors.removeAt(2, 2);  // ['green', 'blue']
       colors.removeAt(4, 2);  // Error: Index out of range
       ```
-       @method removeAt
+         @method removeAt
       @param {Number} start index, start of range
       @param {Number} len length of passing range
       @return {EmberArray} receiver
@@ -21403,12 +21392,12 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Push the object onto the end of the array. Works just like `push()` but it
       is KVO-compliant.
-       ```javascript
+         ```javascript
       let colors = ['red', 'green'];
-       colors.pushObject('black');     // ['red', 'green', 'black']
+         colors.pushObject('black');     // ['red', 'green', 'black']
       colors.pushObject(['yellow']);  // ['red', 'green', ['yellow']]
       ```
-       @method pushObject
+         @method pushObject
       @param {*} obj object to push
       @return object same object passed as a param
       @public
@@ -21420,13 +21409,13 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Add the objects in the passed array to the end of the array. Defers
       notifying observers of the change until all objects are added.
-       ```javascript
+         ```javascript
       let colors = ['red'];
-       colors.pushObjects(['yellow', 'orange']);  // ['red', 'yellow', 'orange']
+         colors.pushObjects(['yellow', 'orange']);  // ['red', 'yellow', 'orange']
       ```
-       @method pushObjects
-      @param {EmberArray} objects the objects to add
-      @return {EmberArray} receiver
+         @method pushObjects
+      @param {Array} objects the objects to add
+      @return {MutableArray} receiver
       @public
     */
     pushObjects(objects) {
@@ -21437,12 +21426,12 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Pop object from array or nil if none are left. Works just like `pop()` but
       it is KVO-compliant.
-       ```javascript
+         ```javascript
       let colors = ['red', 'green', 'blue'];
-       colors.popObject();   // 'blue'
+         colors.popObject();   // 'blue'
       console.log(colors);  // ['red', 'green']
       ```
-       @method popObject
+         @method popObject
       @return object
       @public
     */
@@ -21461,12 +21450,12 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Shift an object from start of array or nil if none are left. Works just
       like `shift()` but it is KVO-compliant.
-       ```javascript
+         ```javascript
       let colors = ['red', 'green', 'blue'];
-       colors.shiftObject();  // 'red'
+         colors.shiftObject();  // 'red'
       console.log(colors);   // ['green', 'blue']
       ```
-       @method shiftObject
+         @method shiftObject
       @return object
       @public
     */
@@ -21483,12 +21472,12 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Unshift an object to start of array. Works just like `unshift()` but it is
       KVO-compliant.
-       ```javascript
+         ```javascript
       let colors = ['red'];
-       colors.unshiftObject('yellow');    // ['yellow', 'red']
+         colors.unshiftObject('yellow');    // ['yellow', 'red']
       colors.unshiftObject(['black']);   // [['black'], 'yellow', 'red']
       ```
-       @method unshiftObject
+         @method unshiftObject
       @param {*} obj object to unshift
       @return object same object passed as a param
       @public
@@ -21500,12 +21489,12 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Adds the named objects to the beginning of the array. Defers notifying
       observers until all objects have been added.
-       ```javascript
+         ```javascript
       let colors = ['red'];
-       colors.unshiftObjects(['black', 'white']);   // ['black', 'white', 'red']
+         colors.unshiftObjects(['black', 'white']);   // ['black', 'white', 'red']
       colors.unshiftObjects('yellow'); // Type Error: 'undefined' is not a function
       ```
-       @method unshiftObjects
+         @method unshiftObjects
       @param {Enumerable} objects the objects to add
       @return {EmberArray} receiver
       @public
@@ -21518,7 +21507,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Reverse objects in the array. Works just like `reverse()` but it is
       KVO-compliant.
-       @method reverseObjects
+         @method reverseObjects
       @return {EmberArray} receiver
        @public
     */
@@ -21537,12 +21526,12 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Replace all the receiver's content with content of the argument.
       If argument is an empty array receiver will be cleared.
-       ```javascript
+         ```javascript
       let colors = ['red', 'green', 'blue'];
-       colors.setObjects(['black', 'white']);  // ['black', 'white']
+         colors.setObjects(['black', 'white']);  // ['black', 'white']
       colors.setObjects([]);                  // []
       ```
-       @method setObjects
+         @method setObjects
       @param {EmberArray} objects array whose content will be used for replacing
           the content of the receiver
       @return {EmberArray} receiver with the new content
@@ -21560,13 +21549,13 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
 
     /**
       Remove all occurrences of an object in the array.
-       ```javascript
+         ```javascript
       let cities = ['Chicago', 'Berlin', 'Lima', 'Chicago'];
-       cities.removeObject('Chicago');  // ['Berlin', 'Lima']
+         cities.removeObject('Chicago');  // ['Berlin', 'Lima']
       cities.removeObject('Lima');     // ['Berlin']
       cities.removeObject('Tokyo')     // ['Berlin']
       ```
-       @method removeObject
+         @method removeObject
       @param {*} obj object to remove
       @return {EmberArray} receiver
       @public
@@ -21587,7 +21576,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
 
     /**
       Removes each object in the passed array from the receiver.
-       @method removeObjects
+         @method removeObjects
       @param {EmberArray} objects the objects to remove
       @return {EmberArray} receiver
       @public
@@ -21596,6 +21585,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
       (0, _metal.beginPropertyChanges)();
 
       for (var i = objects.length - 1; i >= 0; i--) {
+        // SAFETY: Due to the loop structure we know this will always exist.
         this.removeObject(objects[i]);
       }
 
@@ -21606,12 +21596,12 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     /**
       Push the object onto the end of the array if it is not already
       present in the array.
-       ```javascript
+         ```javascript
       let cities = ['Chicago', 'Berlin'];
-       cities.addObject('Lima');    // ['Chicago', 'Berlin', 'Lima']
+         cities.addObject('Lima');    // ['Chicago', 'Berlin', 'Lima']
       cities.addObject('Berlin');  // ['Chicago', 'Berlin', 'Lima']
       ```
-       @method addObject
+         @method addObject
       @param {*} obj object to add, if not already present
       @return {EmberArray} receiver
       @public
@@ -21628,7 +21618,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
 
     /**
       Adds each object in the passed array to the receiver.
-       @method addObjects
+         @method addObjects
       @param {EmberArray} objects the objects to add.
       @return {EmberArray} receiver
       @public
@@ -21641,62 +21631,6 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     }
 
   });
-  /**
-    Creates an `Ember.NativeArray` from an Array-like object.
-    Does not modify the original object's contents. `A()` is not needed if
-    `EmberENV.EXTEND_PROTOTYPES` is `true` (the default value). However,
-    it is recommended that you use `A()` when creating addons for
-    ember or when you can not guarantee that `EmberENV.EXTEND_PROTOTYPES`
-    will be `true`.
-  
-    Example
-  
-    ```app/components/my-component.js
-    import Component from '@ember/component';
-    import { A } from '@ember/array';
-  
-    export default Component.extend({
-      tagName: 'ul',
-      classNames: ['pagination'],
-  
-      init() {
-        this._super(...arguments);
-  
-        if (!this.get('content')) {
-          this.set('content', A());
-          this.set('otherContent', A([1,2,3]));
-        }
-      }
-    });
-    ```
-  
-    @method A
-    @static
-    @for @ember/array
-    @return {Ember.NativeArray}
-    @public
-  */
-  // Add Ember.Array to Array.prototype. Remove methods with native
-  // implementations and supply some more optimized versions of generic methods
-  // because they are so common.
-
-  /**
-  @module ember
-  */
-
-  /**
-    The NativeArray mixin contains the properties needed to make the native
-    Array support MutableArray and all of its dependent APIs. Unless you
-    have `EmberENV.EXTEND_PROTOTYPES` or `EmberENV.EXTEND_PROTOTYPES.Array` set to
-    false, this will be applied automatically. Otherwise you can apply the mixin
-    at anytime by calling `Ember.NativeArray.apply(Array.prototype)`.
-  
-    @class Ember.NativeArray
-    @uses MutableArray
-    @uses Observable
-    @public
-  */
-
 
   _exports.MutableArray = MutableArray;
 
@@ -21722,6 +21656,7 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
   _exports.NativeArray = NativeArray;
   var ignore = ['length'];
   NativeArray.keys().forEach(methodName => {
+    // SAFETY: It's safe to read unknown properties from an object
     if (Array.prototype[methodName]) {
       ignore.push(methodName);
     }
@@ -21734,22 +21669,25 @@ define("@ember/-internals/runtime/lib/mixins/array", ["exports", "@ember/-intern
     NativeArray.apply(Array.prototype, true);
 
     _exports.A = A = function (arr) {
-      (true && !(!(this instanceof A)) && (0, _debug.assert)('You cannot create an Ember Array with `new A()`, please update to calling A as a function: `A()`', !(this instanceof A)));
+      (true && !(!(this instanceof A)) && (0, _debug.assert)('You cannot create an Ember Array with `new A()`, please update to calling A as a function: `A()`', !(this instanceof A))); // SAFTEY: Since we are extending prototypes all true native arrays are Ember NativeArrays
+
       return arr || [];
     };
   } else {
     _exports.A = A = function (arr) {
       (true && !(!(this instanceof A)) && (0, _debug.assert)('You cannot create an Ember Array with `new A()`, please update to calling A as a function: `A()`', !(this instanceof A)));
 
-      if (!arr) {
-        arr = [];
+      if ((0, _utils.isEmberArray)(arr)) {
+        // SAFETY: If it's a true native array and it is also an EmberArray then it should be an Ember NativeArray
+        return arr;
+      } else {
+        // SAFETY: This will return an NativeArray but TS can't infer that.
+        return NativeArray.apply(arr !== null && arr !== void 0 ? arr : []);
       }
-
-      return ArrayMixin.detect(arr) ? arr : NativeArray.apply(arr);
     };
   }
 
-  var _default = ArrayMixin;
+  var _default = EmberArray;
   _exports.default = _default;
 });
 define("@ember/-internals/runtime/lib/mixins/comparable", ["exports", "@ember/-internals/metal"], function (_exports, _metal) {
@@ -23057,7 +22995,7 @@ define("@ember/-internals/runtime/lib/system/array_proxy", ["exports", "@ember/-
          @method replaceContent
       @param {Number} idx The starting index
       @param {Number} amt The number of items to remove from the content.
-      @param {EmberArray} objects Optional array of objects to insert.
+      @param {Array} objects Optional array of objects to insert.
       @return {void}
       @public
     */
@@ -23065,9 +23003,9 @@ define("@ember/-internals/runtime/lib/system/array_proxy", ["exports", "@ember/-
 
     replaceContent(idx, amt, objects) {
       var content = (0, _metal.get)(this, 'content');
-      (true && !(content) && (0, _debug.assert)('[BUG] Called objectAtContent without content', content));
+      (true && !(content) && (0, _debug.assert)('[BUG] Called replaceContent without content', content));
       (true && !(isMutable(content)) && (0, _debug.assert)('Mutating a non-mutable array is not allowed', isMutable(content)));
-      content.replace(idx, amt, objects);
+      (0, _metal.replace)(content, idx, amt, objects);
     } // Overriding objectAt is not supported.
 
 
@@ -23156,7 +23094,12 @@ define("@ember/-internals/runtime/lib/system/array_proxy", ["exports", "@ember/-
       if (arrangedContent && !arrangedContent.isDestroyed) {
         // @ts-expect-error This check is still good for ensuring correctness
         (true && !(arrangedContent !== this) && (0, _debug.assert)("Can't set ArrayProxy's content to itself", arrangedContent !== this));
-        (true && !((0, _array.isArray)(arrangedContent) || arrangedContent.isDestroyed) && (0, _debug.assert)(`ArrayProxy expects an Array or ArrayProxy, but you passed ${typeof arrangedContent}`, (0, _array.isArray)(arrangedContent) || arrangedContent.isDestroyed));
+        (true && !(function (arr) {
+          return Array.isArray(arr) || _array.default.detect(arr);
+        }(arrangedContent)) && (0, _debug.assert)(`ArrayProxy expects a native Array, EmberArray, or ArrayProxy, but you passed ${typeof arrangedContent}`, function (arr) {
+          return Array.isArray(arr) || _array.default.detect(arr);
+        }(arrangedContent)));
+        (true && !(!arrangedContent.isDestroyed) && (0, _debug.assert)('ArrayProxy expected its contents to not be destroyed', !arrangedContent.isDestroyed));
         (0, _metal.addArrayObserver)(arrangedContent, this, ARRAY_OBSERVER_MAPPING);
         this._arrangedContent = arrangedContent;
       }
@@ -28119,6 +28062,9 @@ define("@ember/application/lib/application", ["exports", "@ember/-internals/util
 
   }
 
+  Application.initializer = (0, _engine.buildInitializerMethod)('initializers', 'initializer');
+  Application.instanceInitializer = (0, _engine.buildInitializerMethod)('instanceInitializers', 'instance initializer');
+
   function commonSetupRegistry(registry) {
     registry.register('router:main', _routing.Router);
     registry.register('-view-registry:main', {
@@ -28324,8 +28270,8 @@ define("@ember/canary-features/index", ["exports", "@ember/-internals/environmen
     @public
   */
   var DEFAULT_FEATURES = {
-    EMBER_LIBRARIES_ISREGISTERED: false,
-    EMBER_IMPROVED_INSTRUMENTATION: false,
+    EMBER_LIBRARIES_ISREGISTERED: null,
+    EMBER_IMPROVED_INSTRUMENTATION: null,
     EMBER_UNIQUE_ID_HELPER: true,
     EMBER_DEFAULT_HELPER_MANAGER: true
   };
@@ -28499,31 +28445,21 @@ define("@ember/controller/lib/controller_mixin", ["exports", "@ember/-internals/
   });
   _exports.default = void 0;
   var MODEL = (0, _utils.symbol)('MODEL');
-  /**
-  @module ember
-  */
-
-  /**
-    @class ControllerMixin
-    @namespace Ember
-    @uses Ember.ActionHandler
-    @private
-  */
 
-  var _default = _metal.Mixin.create(_runtime.ActionHandler, {
+  var ControllerMixin = _metal.Mixin.create(_runtime.ActionHandler, {
     /* ducktype as a controller */
     isController: true,
 
     /**
       The object to which actions from the view should be sent.
-       For example, when a Handlebars template uses the `{{action}}` helper,
+         For example, when a Handlebars template uses the `{{action}}` helper,
       it will attempt to send the action to the view's controller's `target`.
-       By default, the value of the target property is set to the router, and
+         By default, the value of the target property is set to the router, and
       is injected when a controller is instantiated. This injection is applied
       as part of the application's initialization process. In most cases the
       `target` property will automatically be set to the logical consumer of
       actions for the controller.
-       @property target
+         @property target
       @default null
       @public
     */
@@ -28533,7 +28469,7 @@ define("@ember/controller/lib/controller_mixin", ["exports", "@ember/-internals/
     /**
       The controller's current model. When retrieving or modifying a controller's
       model, this property should be used instead of the `content` property.
-       @property model
+         @property model
       @public
     */
     model: (0, _metal.computed)({
@@ -28541,13 +28477,14 @@ define("@ember/controller/lib/controller_mixin", ["exports", "@ember/-internals/
         return this[MODEL];
       },
 
-      set(key, value) {
+      set(_key, value) {
         return this[MODEL] = value;
       }
 
     })
   });
 
+  var _default = ControllerMixin;
   _exports.default = _default;
 });
 define("@ember/debug/container-debug-adapter", ["exports", "@ember/-internals/extension-support"], function (_exports, _extensionSupport) {
@@ -29620,6 +29557,7 @@ define("@ember/engine/index", ["exports", "@ember/engine/lib/engine-parent", "@e
   Object.defineProperty(_exports, "__esModule", {
     value: true
   });
+  _exports.buildInitializerMethod = buildInitializerMethod;
   _exports.default = void 0;
   Object.defineProperty(_exports, "getEngineParent", {
     enumerable: true,
@@ -30045,6 +29983,8 @@ define("@ember/engine/index", ["exports", "@ember/engine/lib/engine-parent", "@e
     };
     return ResolverClass.create(props);
   }
+  /** @internal */
+
 
   function buildInitializerMethod(bucketName, humanName) {
     return function (initializer) {
@@ -31241,8 +31181,12 @@ define("@ember/object/index", ["exports", "@ember/debug", "@ember/-internals/met
   */
   var BINDINGS_MAP = new WeakMap();
 
+  function hasProto(obj) {
+    return obj != null && obj.constructor !== undefined && typeof obj.constructor.proto === 'function';
+  }
+
   function setupAction(target, key, actionFn) {
-    if (target.constructor !== undefined && typeof target.constructor.proto === 'function') {
+    if (hasProto(target)) {
       target.constructor.proto();
     }
 
@@ -31252,6 +31196,7 @@ define("@ember/object/index", ["exports", "@ember/debug", "@ember/-internals/met
       target.actions = parentActions ? Object.assign({}, parentActions) : {};
     }
 
+    (true && !(target.actions != null) && (0, _debug.assert)("[BUG] Somehow the target doesn't have actions!", target.actions != null));
     target.actions[key] = actionFn;
     return {
       get() {
@@ -31275,13 +31220,17 @@ define("@ember/object/index", ["exports", "@ember/debug", "@ember/-internals/met
     };
   }
 
-  function action(target, key, desc) {
+  function action() {
     var actionFn;
 
-    if (!(0, _metal.isElementDescriptor)([target, key, desc])) {
-      actionFn = target;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    if (!(0, _metal.isElementDescriptor)(args)) {
+      actionFn = args[0];
 
-      var decorator = function (target, key, desc, meta, isClassicDecorator) {
+      var decorator = function (target, key, _desc, _meta, isClassicDecorator) {
         (true && !(isClassicDecorator) && (0, _debug.assert)('The @action decorator may only be passed a method when used in classic classes. You should decorate methods directly in native classes', isClassicDecorator));
         (true && !(typeof actionFn === 'function') && (0, _debug.assert)('The action() decorator must be passed a method when used in classic classes', typeof actionFn === 'function'));
         return setupAction(target, key, actionFn);
@@ -31291,10 +31240,13 @@ define("@ember/object/index", ["exports", "@ember/debug", "@ember/-internals/met
       return decorator;
     }
 
-    actionFn = desc.value;
-    (true && !(typeof actionFn === 'function') && (0, _debug.assert)('The @action decorator must be applied to methods when used in native classes', typeof actionFn === 'function'));
+    var [target, key, desc] = args;
+    actionFn = desc === null || desc === void 0 ? void 0 : desc.value;
+    (true && !(typeof actionFn === 'function') && (0, _debug.assert)('The @action decorator must be applied to methods when used in native classes', typeof actionFn === 'function')); // SAFETY: TS types are weird with decorators. This should work.
+
     return setupAction(target, key, actionFn);
-  }
+  } // SAFETY: TS types are weird with decorators. This should work.
+
 
   (0, _metal.setClassicDecorator)(action);
 });
@@ -31350,8 +31302,7 @@ define("@ember/object/lib/computed/computed_macros", ["exports", "@ember/-intern
       expandedProperties.push(entry);
     }
 
-    for (var i = 0; i < properties.length; i++) {
-      var property = properties[i];
+    for (var property of properties) {
       (true && !(property.indexOf(' ') < 0) && (0, _debug.assert)(`Dependent keys passed to \`${predicateName}\` computed macro can't have spaces.`, property.indexOf(' ') < 0));
       (0, _metal.expandProperties)(property, extractProperty);
     }
@@ -31360,23 +31311,26 @@ define("@ember/object/lib/computed/computed_macros", ["exports", "@ember/-intern
   }
 
   function generateComputedWithPredicate(name, predicate) {
-    return function () {
-      for (var _len = arguments.length, properties = new Array(_len), _key = 0; _key < _len; _key++) {
-        properties[_key] = arguments[_key];
+    return function (dependentKey) {
+      for (var _len = arguments.length, additionalDependentKeys = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        additionalDependentKeys[_key - 1] = arguments[_key];
       }
 
+      var properties = [dependentKey, ...additionalDependentKeys];
       (true && !(!(0, _metal.isElementDescriptor)(properties)) && (0, _debug.assert)(`You attempted to use @${name} as a decorator directly, but it requires at least one dependent key parameter`, !(0, _metal.isElementDescriptor)(properties)));
       var dependentKeys = expandPropertiesToArray(name, properties);
       var computedFunc = (0, _metal.computed)(...dependentKeys, function () {
         var lastIdx = dependentKeys.length - 1;
 
         for (var i = 0; i < lastIdx; i++) {
+          // SAFETY: `i` is derived from the length of `dependentKeys`
           var value = (0, _metal.get)(this, dependentKeys[i]);
 
           if (!predicate(value)) {
             return value;
           }
-        }
+        } // SAFETY: `lastIdx` is derived from the length of `dependentKeys`
+
 
         return (0, _metal.get)(this, dependentKeys[lastIdx]);
       });
@@ -32137,7 +32091,7 @@ define("@ember/object/lib/computed/computed_macros", ["exports", "@ember/-intern
     });
   }
 });
-define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/debug", "@ember/-internals/metal", "@ember/-internals/runtime"], function (_exports, _debug, _metal, _runtime) {
+define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/debug", "@ember/-internals/metal", "@ember/-internals/runtime", "@ember/-internals/runtime/lib/mixins/array"], function (_exports, _debug, _metal, _runtime, _array) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -32161,6 +32115,10 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
   /**
   @module @ember/object
   */
+  function isNativeOrEmberArray(obj) {
+    return Array.isArray(obj) || _array.default.detect(obj);
+  }
+
   function reduceMacro(dependentKey, callback, initialValue, name) {
     (true && !(!/[[\]{}]/g.test(dependentKey)) && (0, _debug.assert)(`Dependent key passed to \`${name}\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey)));
     return (0, _metal.computed)(`${dependentKey}.[]`, function () {
@@ -32188,7 +32146,7 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
     return (0, _metal.computed)(dependentKey, ...additionalDependentKeys, function () {
       var value = (0, _metal.get)(this, propertyName);
 
-      if ((0, _runtime.isArray)(value)) {
+      if (isNativeOrEmberArray(value)) {
         return (0, _runtime.A)(callback.call(this, value));
       } else {
         return (0, _runtime.A)();
@@ -32360,95 +32318,25 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
     (true && !(!(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))) && (0, _debug.assert)('You attempted to use @min as a decorator directly, but it requires a `dependentKey` parameter', !(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))));
     return reduceMacro(dependentKey, (min, item) => Math.min(min, item), Infinity, 'min');
   }
-  /**
-    Returns an array mapped via the callback
-  
-    The callback method you provide should have the following signature:
-    - `item` is the current item in the iteration.
-    - `index` is the integer index of the current item in the iteration.
-  
-    ```javascript
-    function mapCallback(item, index);
-    ```
-  
-    Example:
-  
-    ```javascript
-    import { set } from '@ember/object';
-    import { map } from '@ember/object/computed';
-  
-    class Hamster {
-      constructor(chores) {
-        set(this, 'chores', chores);
-      }
-  
-      @map('chores', function(chore, index) {
-        return `${chore.toUpperCase()}!`;
-      })
-      excitingChores;
-    });
-  
-    let hamster = new Hamster(['clean', 'write more unit tests']);
-  
-    hamster.excitingChores; // ['CLEAN!', 'WRITE MORE UNIT TESTS!']
-    ```
-  
-    You can optionally pass an array of additional dependent keys as the second
-    parameter to the macro, if your map function relies on any external values:
-  
-    ```javascript
-    import { set } from '@ember/object';
-    import { map } from '@ember/object/computed';
-  
-    class Hamster {
-      shouldUpperCase = false;
-  
-      constructor(chores) {
-        set(this, 'chores', chores);
-      }
-  
-      @map('chores', ['shouldUpperCase'], function(chore, index) {
-        if (this.shouldUpperCase) {
-          return `${chore.toUpperCase()}!`;
-        } else {
-          return `${chore}!`;
-        }
-      })
-      excitingChores;
-    }
-  
-    let hamster = new Hamster(['clean', 'write more unit tests']);
-  
-    hamster.excitingChores; // ['clean!', 'write more unit tests!']
-  
-    set(hamster, 'shouldUpperCase', true);
-    hamster.excitingChores; // ['CLEAN!', 'WRITE MORE UNIT TESTS!']
-    ```
-  
-    @method map
-    @for @ember/object/computed
-    @static
-    @param {String} dependentKey
-    @param {Array} [additionalDependentKeys] optional array of additional
-    dependent keys
-    @param {Function} callback
-    @return {ComputedProperty} an array mapped via the callback
-    @public
-  */
-
 
-  function map(dependentKey, additionalDependentKeys, callback) {
+  function map(dependentKey, additionalDependentKeysOrCallback, callback) {
     (true && !(!(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))) && (0, _debug.assert)('You attempted to use @map as a decorator directly, but it requires atleast `dependentKey` and `callback` parameters', !(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))));
+    (true && !(typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function') && (0, _debug.assert)('The final parameter provided to map must be a callback function', typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function'));
+    (true && !(Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function') && (0, _debug.assert)('The second parameter provided to map must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function'));
+    var additionalDependentKeys;
 
-    if (callback === undefined && typeof additionalDependentKeys === 'function') {
-      callback = additionalDependentKeys;
+    if (typeof additionalDependentKeysOrCallback === 'function') {
+      callback = additionalDependentKeysOrCallback;
       additionalDependentKeys = [];
+    } else {
+      additionalDependentKeys = additionalDependentKeysOrCallback;
     }
 
-    (true && !(typeof callback === 'function') && (0, _debug.assert)('The final parameter provided to map must be a callback function', typeof callback === 'function'));
-    (true && !(Array.isArray(additionalDependentKeys)) && (0, _debug.assert)('The second parameter provided to map must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeys)));
+    var cCallback = callback;
+    (true && !(cCallback) && (0, _debug.assert)('[BUG] Missing callback', cCallback));
     return arrayMacro(dependentKey, additionalDependentKeys, function (value) {
-      return value.map(callback, this);
+      // This is so dumb...
+      return Array.isArray(value) ? value.map(cCallback, this) : value.map(cCallback, this);
     });
   }
   /**
@@ -32507,125 +32395,24 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
     (true && !(!/[[\]{}]/g.test(dependentKey)) && (0, _debug.assert)(`Dependent key passed to \`mapBy\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey)));
     return map(`${dependentKey}.@each.${propertyKey}`, item => (0, _metal.get)(item, propertyKey));
   }
-  /**
-    Filters the array by the callback.
-  
-    The callback method you provide should have the following signature:
-    - `item` is the current item in the iteration.
-    - `index` is the integer index of the current item in the iteration.
-    - `array` is the dependant array itself.
-  
-    ```javascript
-    function filterCallback(item, index, array);
-    ```
-  
-    Example:
-  
-    ```javascript
-    import { set } from '@ember/object';
-    import { filter } from '@ember/object/computed';
-  
-    class Hamster {
-      constructor(chores) {
-        set(this, 'chores', chores);
-      }
-  
-      @filter('chores', function(chore, index, array) {
-        return !chore.done;
-      })
-      remainingChores;
-    }
-  
-    let hamster = Hamster.create([
-      { name: 'cook', done: true },
-      { name: 'clean', done: true },
-      { name: 'write more unit tests', done: false }
-    ]);
-  
-    hamster.remainingChores; // [{name: 'write more unit tests', done: false}]
-    ```
-  
-    You can also use `@each.property` in your dependent key, the callback will
-    still use the underlying array:
-  
-    ```javascript
-    import { set } from '@ember/object';
-    import { filter } from '@ember/object/computed';
-  
-    class Hamster {
-      constructor(chores) {
-        set(this, 'chores', chores);
-      }
-  
-      @filter('chores.@each.done', function(chore, index, array) {
-        return !chore.done;
-      })
-      remainingChores;
-    }
-  
-    let hamster = new Hamster([
-      { name: 'cook', done: true },
-      { name: 'clean', done: true },
-      { name: 'write more unit tests', done: false }
-    ]);
-    hamster.remainingChores; // [{name: 'write more unit tests', done: false}]
-  
-    set(hamster.chores[2], 'done', true);
-    hamster.remainingChores; // []
-    ```
-  
-    Finally, you can optionally pass an array of additional dependent keys as the
-    second parameter to the macro, if your filter function relies on any external
-    values:
-  
-    ```javascript
-    import { filter } from '@ember/object/computed';
-  
-    class Hamster {
-      constructor(chores) {
-        set(this, 'chores', chores);
-      }
-  
-      doneKey = 'finished';
-  
-      @filter('chores', ['doneKey'], function(chore, index, array) {
-        return !chore[this.doneKey];
-      })
-      remainingChores;
-    }
-  
-    let hamster = new Hamster([
-      { name: 'cook', finished: true },
-      { name: 'clean', finished: true },
-      { name: 'write more unit tests', finished: false }
-    ]);
-  
-    hamster.remainingChores; // [{name: 'write more unit tests', finished: false}]
-    ```
-  
-    @method filter
-    @for @ember/object/computed
-    @static
-    @param {String} dependentKey
-    @param {Array} [additionalDependentKeys] optional array of additional dependent keys
-    @param {Function} callback
-    @return {ComputedProperty} the filtered array
-    @public
-  */
 
-
-  function filter(dependentKey, additionalDependentKeys, callback) {
+  function filter(dependentKey, additionalDependentKeysOrCallback, callback) {
     (true && !(!(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))) && (0, _debug.assert)('You attempted to use @filter as a decorator directly, but it requires atleast `dependentKey` and `callback` parameters', !(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))));
+    (true && !(typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function') && (0, _debug.assert)('The final parameter provided to filter must be a callback function', typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function'));
+    (true && !(Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function') && (0, _debug.assert)('The second parameter provided to filter must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function'));
+    var additionalDependentKeys;
 
-    if (callback === undefined && typeof additionalDependentKeys === 'function') {
-      callback = additionalDependentKeys;
+    if (typeof additionalDependentKeysOrCallback === 'function') {
+      callback = additionalDependentKeysOrCallback;
       additionalDependentKeys = [];
+    } else {
+      additionalDependentKeys = additionalDependentKeysOrCallback;
     }
 
-    (true && !(typeof callback === 'function') && (0, _debug.assert)('The final parameter provided to filter must be a callback function', typeof callback === 'function'));
-    (true && !(Array.isArray(additionalDependentKeys)) && (0, _debug.assert)('The second parameter provided to filter must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeys)));
+    var cCallback = callback;
     return arrayMacro(dependentKey, additionalDependentKeys, function (value) {
-      return value.filter(callback, this);
+      // This is a really silly way to keep TS happy
+      return Array.isArray(value) ? value.filter(cCallback, this) : value.filter(cCallback, this);
     });
   }
   /**
@@ -32716,19 +32503,20 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
   */
 
 
-  function uniq() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
+  function uniq(dependentKey) {
+    for (var _len = arguments.length, additionalDependentKeys = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      additionalDependentKeys[_key - 1] = arguments[_key];
     }
 
     (true && !(!(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))) && (0, _debug.assert)('You attempted to use @uniq/@union as a decorator directly, but it requires atleast one dependent key parameter', !(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))));
+    var args = [dependentKey, ...additionalDependentKeys];
     return multiArrayMacro(args, function (dependentKeys) {
       var uniq = (0, _runtime.A)();
       var seen = new Set();
       dependentKeys.forEach(dependentKey => {
         var value = (0, _metal.get)(this, dependentKey);
 
-        if ((0, _runtime.isArray)(value)) {
+        if (isNativeOrEmberArray(value)) {
           value.forEach(item => {
             if (!seen.has(item)) {
               seen.add(item);
@@ -32784,7 +32572,7 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
     (true && !(!/[[\]{}]/g.test(dependentKey)) && (0, _debug.assert)(`Dependent key passed to \`uniqBy\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey)));
     return (0, _metal.computed)(`${dependentKey}.[]`, function () {
       var list = (0, _metal.get)(this, dependentKey);
-      return (0, _runtime.isArray)(list) ? (0, _runtime.uniqBy)(list, propertyKey) : (0, _runtime.A)();
+      return isNativeOrEmberArray(list) ? (0, _runtime.uniqBy)(list, propertyKey) : (0, _runtime.A)();
     }).readOnly();
   }
   /**
@@ -32873,24 +32661,26 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
 
   _exports.union = union;
 
-  function intersect() {
-    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-      args[_key2] = arguments[_key2];
+  function intersect(dependentKey) {
+    for (var _len2 = arguments.length, additionalDependentKeys = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      additionalDependentKeys[_key2 - 1] = arguments[_key2];
     }
 
     (true && !(!(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))) && (0, _debug.assert)('You attempted to use @intersect as a decorator directly, but it requires atleast one dependent key parameter', !(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))));
+    var args = [dependentKey, ...additionalDependentKeys];
     return multiArrayMacro(args, function (dependentKeys) {
       var arrays = dependentKeys.map(dependentKey => {
         var array = (0, _metal.get)(this, dependentKey);
-        return (0, _runtime.isArray)(array) ? array : [];
+        return Array.isArray(array) ? array : [];
       });
-      var results = arrays.pop().filter(candidate => {
-        for (var i = 0; i < arrays.length; i++) {
+      var firstArray = arrays.pop();
+      (true && !(firstArray) && (0, _debug.assert)('Attempted to apply multiArrayMacro for intersect without any dependentKeys', firstArray));
+      var results = firstArray.filter(candidate => {
+        for (var array of arrays) {
           var found = false;
-          var array = arrays[i];
 
-          for (var j = 0; j < array.length; j++) {
-            if (array[j] === candidate) {
+          for (var item of array) {
+            if (item === candidate) {
               found = true;
               break;
             }
@@ -32959,12 +32749,12 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
       var setA = (0, _metal.get)(this, setAProperty);
       var setB = (0, _metal.get)(this, setBProperty);
 
-      if (!(0, _runtime.isArray)(setA)) {
+      if (!isNativeOrEmberArray(setA)) {
         return (0, _runtime.A)();
       }
 
-      if (!(0, _runtime.isArray)(setB)) {
-        return (0, _runtime.A)(setA);
+      if (!isNativeOrEmberArray(setB)) {
+        return setA;
       }
 
       return setA.filter(x => setB.indexOf(x) === -1);
@@ -33003,12 +32793,13 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
   */
 
 
-  function collect() {
-    for (var _len3 = arguments.length, dependentKeys = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-      dependentKeys[_key3] = arguments[_key3];
+  function collect(dependentKey) {
+    for (var _len3 = arguments.length, additionalDependentKeys = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      additionalDependentKeys[_key3 - 1] = arguments[_key3];
     }
 
     (true && !(!(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))) && (0, _debug.assert)('You attempted to use @collect as a decorator directly, but it requires atleast one dependent key parameter', !(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))));
+    var dependentKeys = [dependentKey, ...additionalDependentKeys];
     return multiArrayMacro(dependentKeys, function () {
       var res = dependentKeys.map(key => {
         var val = (0, _metal.get)(this, key);
@@ -33017,148 +32808,8 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
       return (0, _runtime.A)(res);
     }, 'collect');
   }
-  /**
-    A computed property which returns a new array with all the properties from the
-    first dependent array sorted based on a property or sort function. The sort
-    macro can be used in two different ways:
-  
-    1. By providing a sort callback function
-    2. By providing an array of keys to sort the array
-  
-    In the first form, the callback method you provide should have the following
-    signature:
-  
-    ```javascript
-    function sortCallback(itemA, itemB);
-    ```
-  
-    - `itemA` the first item to compare.
-    - `itemB` the second item to compare.
-  
-    This function should return negative number (e.g. `-1`) when `itemA` should
-    come before `itemB`. It should return positive number (e.g. `1`) when `itemA`
-    should come after `itemB`. If the `itemA` and `itemB` are equal this function
-    should return `0`.
-  
-    Therefore, if this function is comparing some numeric values, simple `itemA -
-    itemB` or `itemA.get( 'foo' ) - itemB.get( 'foo' )` can be used instead of
-    series of `if`.
-  
-    Example:
-  
-    ```javascript
-    import { set } from '@ember/object';
-    import { sort } from '@ember/object/computed';
-  
-    class ToDoList {
-      constructor(todos) {
-        set(this, 'todos', todos);
-      }
-  
-      // using a custom sort function
-      @sort('todos', function(a, b){
-        if (a.priority > b.priority) {
-          return 1;
-        } else if (a.priority < b.priority) {
-          return -1;
-        }
-  
-        return 0;
-      })
-      priorityTodos;
-    }
-  
-    let todoList = new ToDoList([
-      { name: 'Unit Test', priority: 2 },
-      { name: 'Documentation', priority: 3 },
-      { name: 'Release', priority: 1 }
-    ]);
-  
-    todoList.priorityTodos; // [{ name:'Release', priority:1 }, { name:'Unit Test', priority:2 }, { name:'Documentation', priority:3 }]
-    ```
-  
-    You can also optionally pass an array of additional dependent keys as the
-    second parameter, if your sort function is dependent on additional values that
-    could changes:
-  
-    ```js
-    import EmberObject, { set } from '@ember/object';
-    import { sort } from '@ember/object/computed';
-  
-    class ToDoList {
-      sortKey = 'priority';
-  
-      constructor(todos) {
-        set(this, 'todos', todos);
-      }
-  
-      // using a custom sort function
-      @sort('todos', ['sortKey'], function(a, b){
-        if (a[this.sortKey] > b[this.sortKey]) {
-          return 1;
-        } else if (a[this.sortKey] < b[this.sortKey]) {
-          return -1;
-        }
-  
-        return 0;
-      })
-      sortedTodos;
-    });
-  
-    let todoList = new ToDoList([
-      { name: 'Unit Test', priority: 2 },
-      { name: 'Documentation', priority: 3 },
-      { name: 'Release', priority: 1 }
-    ]);
-  
-    todoList.priorityTodos; // [{ name:'Release', priority:1 }, { name:'Unit Test', priority:2 }, { name:'Documentation', priority:3 }]
-    ```
-  
-    In the second form, you should provide the key of the array of sort values as
-    the second parameter:
-  
-    ```javascript
-    import { set } from '@ember/object';
-    import { sort } from '@ember/object/computed';
-  
-    class ToDoList {
-      constructor(todos) {
-        set(this, 'todos', todos);
-      }
-  
-      // using standard ascending sort
-      todosSorting = ['name'];
-      @sort('todos', 'todosSorting') sortedTodos;
-  
-      // using descending sort
-      todosSortingDesc = ['name:desc'];
-      @sort('todos', 'todosSortingDesc') sortedTodosDesc;
-    }
-  
-    let todoList = new ToDoList([
-      { name: 'Unit Test', priority: 2 },
-      { name: 'Documentation', priority: 3 },
-      { name: 'Release', priority: 1 }
-    ]);
-  
-    todoList.sortedTodos; // [{ name:'Documentation', priority:3 }, { name:'Release', priority:1 }, { name:'Unit Test', priority:2 }]
-    todoList.sortedTodosDesc; // [{ name:'Unit Test', priority:2 }, { name:'Release', priority:1 }, { name:'Documentation', priority:3 }]
-    ```
-  
-    @method sort
-    @for @ember/object/computed
-    @static
-    @param {String} itemsKey
-    @param {String|Function|Array} sortDefinitionOrDependentKeys The key of the sort definition (an array of sort properties),
-    the sort function, or an array of additional dependent keys
-    @param {Function?} sortDefinition the sort function (when used with additional dependent keys)
-    @return {ComputedProperty} computes a new sorted array based on the sort
-    property array or callback function
-    @public
-  */
-
 
-  function sort(itemsKey, additionalDependentKeys, sortDefinition) {
+  function sort(itemsKey, additionalDependentKeysOrDefinition, sortDefinition) {
     (true && !(!(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))) && (0, _debug.assert)('You attempted to use @sort as a decorator directly, but it requires atleast an `itemsKey` parameter', !(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))));
 
     if (true
@@ -33167,25 +32818,31 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
       var argumentsValid = false;
 
       if (arguments.length === 2) {
-        argumentsValid = typeof itemsKey === 'string' && (typeof additionalDependentKeys === 'string' || typeof additionalDependentKeys === 'function');
+        argumentsValid = typeof itemsKey === 'string' && (typeof additionalDependentKeysOrDefinition === 'string' || typeof additionalDependentKeysOrDefinition === 'function');
       }
 
       if (arguments.length === 3) {
-        argumentsValid = typeof itemsKey === 'string' && Array.isArray(additionalDependentKeys) && typeof sortDefinition === 'function';
+        argumentsValid = typeof itemsKey === 'string' && Array.isArray(additionalDependentKeysOrDefinition) && typeof sortDefinition === 'function';
       }
 
       (true && !(argumentsValid) && (0, _debug.assert)('The `sort` computed macro can either be used with an array of sort properties or with a sort function. If used with an array of sort properties, it must receive exactly two arguments: the key of the array to sort, and the key of the array of sort properties. If used with a sort function, it may receive up to three arguments: the key of the array to sort, an optional additional array of dependent keys for the computed property, and the sort function.', argumentsValid));
     }
 
-    if (sortDefinition === undefined && !Array.isArray(additionalDependentKeys)) {
-      sortDefinition = additionalDependentKeys;
+    var additionalDependentKeys;
+    var sortDefinitionOrString;
+
+    if (Array.isArray(additionalDependentKeysOrDefinition)) {
+      additionalDependentKeys = additionalDependentKeysOrDefinition;
+      sortDefinitionOrString = sortDefinition;
+    } else {
       additionalDependentKeys = [];
+      sortDefinitionOrString = additionalDependentKeysOrDefinition;
     }
 
-    if (typeof sortDefinition === 'function') {
-      return customSort(itemsKey, additionalDependentKeys, sortDefinition);
+    if (typeof sortDefinitionOrString === 'function') {
+      return customSort(itemsKey, additionalDependentKeys, sortDefinitionOrString);
     } else {
-      return propertySort(itemsKey, sortDefinition);
+      return propertySort(itemsKey, sortDefinitionOrString);
     }
   }
 
@@ -33200,12 +32857,16 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
   function propertySort(itemsKey, sortPropertiesKey) {
     var cp = (0, _metal.autoComputed)(function (key) {
       var sortProperties = (0, _metal.get)(this, sortPropertiesKey);
-      (true && !((0, _runtime.isArray)(sortProperties) && sortProperties.every(s => typeof s === 'string')) && (0, _debug.assert)(`The sort definition for '${key}' on ${this} must be a function or an array of strings`, (0, _runtime.isArray)(sortProperties) && sortProperties.every(s => typeof s === 'string')));
+      (true && !(function (arr) {
+        return isNativeOrEmberArray(arr) && arr.every(s => typeof s === 'string');
+      }(sortProperties)) && (0, _debug.assert)(`The sort definition for '${key}' on ${this} must be a function or an array of strings`, function (arr) {
+        return isNativeOrEmberArray(arr) && arr.every(s => typeof s === 'string');
+      }(sortProperties)));
       var itemsKeyIsAtThis = itemsKey === '@this';
       var normalizedSortProperties = normalizeSortProperties(sortProperties);
       var items = itemsKeyIsAtThis ? this : (0, _metal.get)(this, itemsKey);
 
-      if (!(0, _runtime.isArray)(items)) {
+      if (!isNativeOrEmberArray(items)) {
         return (0, _runtime.A)();
       }
 
@@ -33219,17 +32880,20 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
   }
 
   function normalizeSortProperties(sortProperties) {
-    return sortProperties.map(p => {
+    var callback = p => {
       var [prop, direction] = p.split(':');
-      direction = direction || 'asc';
+      direction = direction || 'asc'; // SAFETY: There will always be at least one value returned by split
+
       return [prop, direction];
-    });
+    }; // This nonsense is necessary since technically the two map implementations diverge.
+
+
+    return Array.isArray(sortProperties) ? sortProperties.map(callback) : sortProperties.map(callback);
   }
 
   function sortByNormalizedSortProperties(items, normalizedSortProperties) {
     return (0, _runtime.A)(items.slice().sort((itemA, itemB) => {
-      for (var i = 0; i < normalizedSortProperties.length; i++) {
-        var [prop, direction] = normalizedSortProperties[i];
+      for (var [prop, direction] of normalizedSortProperties) {
         var result = (0, _runtime.compare)((0, _metal.get)(itemA, prop), (0, _metal.get)(itemB, prop));
 
         if (result !== 0) {
@@ -34712,7 +34376,7 @@ define("@ember/test/adapter", ["exports", "ember-testing"], function (_exports,
     value: true
   });
   _exports.default = void 0;
-  var _default = _emberTesting.Test.Adapter;
+  var _default = _emberTesting.Adapter;
   _exports.default = _default;
 });
 define("@ember/test/index", ["exports", "require"], function (_exports, _require) {
@@ -52620,50 +52284,34 @@ define("ember-testing/lib/adapters/adapter", ["exports", "@ember/-internals/runt
   });
   _exports.default = void 0;
 
-  function K() {
-    return this;
-  }
-  /**
-   @module @ember/test
-  */
-
-  /**
-    The primary purpose of this class is to create hooks that can be implemented
-    by an adapter for various test frameworks.
-  
-    @class TestAdapter
-    @public
-  */
-
-
-  var _default = _runtime.Object.extend({
+  var Adapter = _runtime.Object.extend({
     /**
       This callback will be called whenever an async operation is about to start.
-       Override this to call your framework's methods that handle async
+         Override this to call your framework's methods that handle async
       operations.
-       @public
+         @public
       @method asyncStart
     */
-    asyncStart: K,
+    asyncStart() {},
 
     /**
       This callback will be called whenever an async operation has completed.
-       @public
+         @public
       @method asyncEnd
     */
-    asyncEnd: K,
+    asyncEnd() {},
 
     /**
       Override this method with your testing framework's false assertion.
       This function is called whenever an exception occurs causing the testing
       promise to fail.
-       QUnit example:
-       ```javascript
+         QUnit example:
+         ```javascript
         exception: function(error) {
           ok(false, error);
         };
       ```
-       @public
+         @public
       @method exception
       @param {String} error The exception to be raised.
     */
@@ -52673,6 +52321,7 @@ define("ember-testing/lib/adapters/adapter", ["exports", "@ember/-internals/runt
 
   });
 
+  var _default = Adapter;
   _exports.default = _default;
 });
 define("ember-testing/lib/adapters/qunit", ["exports", "@ember/-internals/utils", "ember-testing/lib/adapters/adapter"], function (_exports, _utils, _adapter) {
@@ -52684,27 +52333,17 @@ define("ember-testing/lib/adapters/qunit", ["exports", "@ember/-internals/utils"
   _exports.default = void 0;
 
   /* globals QUnit */
+  function isVeryOldQunit(obj) {
+    return obj != null && typeof obj.stop === 'function';
+  }
 
-  /**
-     @module ember
-  */
-
-  /**
-    This class implements the methods defined by TestAdapter for the
-    QUnit testing framework.
-  
-    @class QUnitAdapter
-    @namespace Ember.Test
-    @extends TestAdapter
-    @public
-  */
-  var _default = _adapter.default.extend({
+  var QUnitAdapter = _adapter.default.extend({
     init() {
       this.doneCallbacks = [];
     },
 
     asyncStart() {
-      if (typeof QUnit.stop === 'function') {
+      if (isVeryOldQunit(QUnit)) {
         // very old QUnit version
         // eslint-disable-next-line qunit/no-qunit-stop
         QUnit.stop();
@@ -52717,7 +52356,7 @@ define("ember-testing/lib/adapters/qunit", ["exports", "@ember/-internals/utils"
       // checking for QUnit.stop here (even though we _need_ QUnit.start) because
       // QUnit.start() still exists in QUnit 2.x (it just throws an error when calling
       // inside a test context)
-      if (typeof QUnit.stop === 'function') {
+      if (isVeryOldQunit(QUnit)) {
         QUnit.start();
       } else {
         var done = this.doneCallbacks.pop(); // This can be null if asyncStart() was called outside of a test
@@ -52734,9 +52373,10 @@ define("ember-testing/lib/adapters/qunit", ["exports", "@ember/-internals/utils"
 
   });
 
+  var _default = QUnitAdapter;
   _exports.default = _default;
 });
-define("ember-testing/lib/ext/application", ["@ember/application", "ember-testing/lib/setup_for_testing", "ember-testing/lib/test/helpers", "ember-testing/lib/test/promise", "ember-testing/lib/test/run", "ember-testing/lib/test/on_inject_helpers", "ember-testing/lib/test/adapter"], function (_application, _setup_for_testing, _helpers, _promise, _run, _on_inject_helpers, _adapter) {
+define("ember-testing/lib/ext/application", ["@ember/application", "ember-testing/lib/setup_for_testing", "ember-testing/lib/test/helpers", "ember-testing/lib/test/promise", "ember-testing/lib/test/run", "ember-testing/lib/test/on_inject_helpers", "ember-testing/lib/test/adapter", "@ember/debug"], function (_application, _setup_for_testing, _helpers, _promise, _run, _on_inject_helpers, _adapter, _debug) {
   "use strict";
 
   _application.default.reopen({
@@ -52745,7 +52385,7 @@ define("ember-testing/lib/ext/application", ["@ember/application", "ember-testin
      are created once you call `injectTestHelpers` on your `Application`
      instance. The included helpers are also available on the `window` object by
      default, but can be used from this object on the individual application also.
-       @property testHelpers
+         @property testHelpers
       @type {Object}
       @default {}
       @public
@@ -52755,9 +52395,9 @@ define("ember-testing/lib/ext/application", ["@ember/application", "ember-testin
     /**
      This property will contain the original methods that were registered
      on the `helperContainer` before `injectTestHelpers` is called.
-      When `removeTestHelpers` is called, these methods are restored to the
+        When `removeTestHelpers` is called, these methods are restored to the
      `helperContainer`.
-       @property originalMethods
+         @property originalMethods
       @type {Object}
       @default {}
       @private
@@ -52769,7 +52409,7 @@ define("ember-testing/lib/ext/application", ["@ember/application", "ember-testin
     This property indicates whether or not this application is currently in
     testing mode. This is set when `setupForTesting` is called on the current
     application.
-     @property testing
+       @property testing
     @type {Boolean}
     @default false
     @since 1.3.0
@@ -52784,11 +52424,11 @@ define("ember-testing/lib/ext/application", ["@ember/application", "ember-testin
       (preventing both accidental leaking of state between tests and interference
       with your testing framework). `setupForTesting` should only be called after
       setting a custom `router` class (for example `App.Router = Router.extend(`).
-       Example:
-       ```
+         Example:
+         ```
       App.setupForTesting();
       ```
-       @method setupForTesting
+         @method setupForTesting
       @public
     */
     setupForTesting() {
@@ -52802,7 +52442,7 @@ define("ember-testing/lib/ext/application", ["@ember/application", "ember-testin
     /**
       This will be used as the container to inject the test helpers into. By
       default the helpers are injected into `window`.
-       @property helperContainer
+         @property helperContainer
       @type {Object} The object to be used for test helpers.
       @default window
       @since 1.2.0
@@ -52816,13 +52456,13 @@ define("ember-testing/lib/ext/application", ["@ember/application", "ember-testin
       to `window`. If a function of the same name has already been defined it will be cached
       (so that it can be reset if the helper is removed with `unregisterHelper` or
       `removeTestHelpers`).
-       Any callbacks registered with `onInjectHelpers` will be called once the
+         Any callbacks registered with `onInjectHelpers` will be called once the
       helpers have been injected.
-       Example:
+         Example:
       ```
       App.injectTestHelpers();
       ```
-       @method injectTestHelpers
+         @method injectTestHelpers
       @public
     */
     injectTestHelpers(helperContainer) {
@@ -52843,8 +52483,11 @@ define("ember-testing/lib/ext/application", ["@ember/application", "ember-testin
       this.testHelpers = {};
 
       for (var name in _helpers.helpers) {
-        this.originalMethods[name] = this.helperContainer[name];
-        this.testHelpers[name] = this.helperContainer[name] = helper(this, name);
+        // SAFETY: It is safe to access a property on an object
+        this.originalMethods[name] = this.helperContainer[name]; // SAFETY: It is not quite as safe to do this, but it _seems_ to be ok.
+
+        this.testHelpers[name] = this.helperContainer[name] = helper(this, name); // SAFETY: We checked that it exists
+
         protoWrap(_promise.default.prototype, name, helper(this, name), _helpers.helpers[name].meta.wait);
       }
 
@@ -52854,11 +52497,11 @@ define("ember-testing/lib/ext/application", ["@ember/application", "ember-testin
     /**
       This removes all helpers that have been registered, and resets and functions
       that were overridden by the helpers.
-       Example:
-       ```javascript
+         Example:
+         ```javascript
       App.removeTestHelpers();
       ```
-       @public
+         @public
       @method removeTestHelpers
     */
     removeTestHelpers() {
@@ -52867,7 +52510,8 @@ define("ember-testing/lib/ext/application", ["@ember/application", "ember-testin
       }
 
       for (var name in _helpers.helpers) {
-        this.helperContainer[name] = this.originalMethods[name];
+        this.helperContainer[name] = this.originalMethods[name]; // SAFETY: This is a weird thing, but it's not technically unsafe here.
+
         delete _promise.default.prototype[name];
         delete this.testHelpers[name];
         delete this.originalMethods[name];
@@ -52880,6 +52524,7 @@ define("ember-testing/lib/ext/application", ["@ember/application", "ember-testin
 
 
   function protoWrap(proto, name, callback, isAsync) {
+    // SAFETY: This isn't entirely safe, but it _seems_ to be ok.
     proto[name] = function () {
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
@@ -52888,6 +52533,7 @@ define("ember-testing/lib/ext/application", ["@ember/application", "ember-testin
       if (isAsync) {
         return callback.apply(this, args);
       } else {
+        // SAFETY: This is not actually safe.
         return this.then(function () {
           return callback.apply(this, args);
         });
@@ -52896,8 +52542,10 @@ define("ember-testing/lib/ext/application", ["@ember/application", "ember-testin
   }
 
   function helper(app, name) {
-    var fn = _helpers.helpers[name].method;
-    var meta = _helpers.helpers[name].meta;
+    var helper = _helpers.helpers[name];
+    (true && !(helper) && (0, _debug.assert)(`[BUG] Missing helper: ${name}`, helper));
+    var fn = helper.method;
+    var meta = helper.meta;
 
     if (!meta.wait) {
       return function () {
@@ -52961,7 +52609,7 @@ define("ember-testing/lib/helpers", ["ember-testing/lib/test/helpers", "ember-te
   (0, _helpers.registerHelper)('currentURL', _current_url.default);
   (0, _helpers.registerHelper)('resumeTest', _pause_test.resumeTest);
 });
-define("ember-testing/lib/helpers/and_then", ["exports"], function (_exports) {
+define("ember-testing/lib/helpers/and_then", ["exports", "@ember/debug"], function (_exports, _debug) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -52970,10 +52618,12 @@ define("ember-testing/lib/helpers/and_then", ["exports"], function (_exports) {
   _exports.default = andThen;
 
   function andThen(app, callback) {
-    return app.testHelpers.wait(callback(app));
+    var wait = app.testHelpers['wait'];
+    (true && !(wait) && (0, _debug.assert)('[BUG] Missing wait helper', wait));
+    return wait(callback(app));
   }
 });
-define("ember-testing/lib/helpers/current_path", ["exports", "@ember/-internals/metal"], function (_exports, _metal) {
+define("ember-testing/lib/helpers/current_path", ["exports", "@ember/-internals/metal", "@ember/-internals/routing", "@ember/debug"], function (_exports, _metal, _routing, _debug) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -53004,12 +52654,15 @@ define("ember-testing/lib/helpers/current_path", ["exports", "@ember/-internals/
   @public
   */
   function currentPath(app) {
+    (true && !(app.__container__) && (0, _debug.assert)('[BUG] app.__container__ is not set', app.__container__));
+
     var routingService = app.__container__.lookup('service:-routing');
 
+    (true && !(routingService instanceof _routing.RoutingService) && (0, _debug.assert)('[BUG] service:-routing is not a RoutingService', routingService instanceof _routing.RoutingService));
     return (0, _metal.get)(routingService, 'currentPath');
   }
 });
-define("ember-testing/lib/helpers/current_route_name", ["exports", "@ember/-internals/metal"], function (_exports, _metal) {
+define("ember-testing/lib/helpers/current_route_name", ["exports", "@ember/-internals/metal", "@ember/-internals/routing", "@ember/debug"], function (_exports, _metal, _routing, _debug) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -53039,12 +52692,15 @@ define("ember-testing/lib/helpers/current_route_name", ["exports", "@ember/-inte
   @public
   */
   function currentRouteName(app) {
+    (true && !(app.__container__) && (0, _debug.assert)('[BUG] app.__container__ is not set', app.__container__));
+
     var routingService = app.__container__.lookup('service:-routing');
 
+    (true && !(routingService instanceof _routing.RoutingService) && (0, _debug.assert)('[BUG] service:-routing is not a RoutingService', routingService instanceof _routing.RoutingService));
     return (0, _metal.get)(routingService, 'currentRouteName');
   }
 });
-define("ember-testing/lib/helpers/current_url", ["exports", "@ember/-internals/metal"], function (_exports, _metal) {
+define("ember-testing/lib/helpers/current_url", ["exports", "@ember/-internals/metal", "@ember/debug", "@ember/routing/router"], function (_exports, _metal, _debug, _router) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -53075,9 +52731,14 @@ define("ember-testing/lib/helpers/current_url", ["exports", "@ember/-internals/m
   @public
   */
   function currentURL(app) {
+    (true && !(app.__container__) && (0, _debug.assert)('[BUG] app.__container__ is not set', app.__container__));
+
     var router = app.__container__.lookup('router:main');
 
-    return (0, _metal.get)(router, 'location').getURL();
+    (true && !(router instanceof _router.default) && (0, _debug.assert)('[BUG] router:main is not a Router', router instanceof _router.default));
+    var location = (0, _metal.get)(router, 'location');
+    (true && !(typeof location !== 'string') && (0, _debug.assert)('[BUG] location is still a string', typeof location !== 'string'));
+    return location.getURL();
   }
 });
 define("ember-testing/lib/helpers/pause_test", ["exports", "@ember/-internals/runtime", "@ember/debug"], function (_exports, _runtime, _debug) {
@@ -53152,7 +52813,7 @@ define("ember-testing/lib/helpers/pause_test", ["exports", "@ember/-internals/ru
     }, 'TestAdapter paused promise');
   }
 });
-define("ember-testing/lib/helpers/visit", ["exports", "@ember/runloop"], function (_exports, _runloop) {
+define("ember-testing/lib/helpers/visit", ["exports", "@ember/debug", "@ember/routing/router", "@ember/runloop"], function (_exports, _debug, _router, _runloop) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -53179,18 +52840,24 @@ define("ember-testing/lib/helpers/visit", ["exports", "@ember/runloop"], functio
     @public
   */
   function visit(app, url) {
+    (true && !(app.__container__) && (0, _debug.assert)('[BUG] Missing container', app.__container__));
+
     var router = app.__container__.lookup('router:main');
 
+    (true && !(router instanceof _router.default) && (0, _debug.assert)('[BUG] router:main is not a Router', router instanceof _router.default));
     var shouldHandleURL = false;
     app.boot().then(() => {
+      (true && !(typeof router.location !== 'string') && (0, _debug.assert)('[BUG] router.location is still a string', typeof router.location !== 'string'));
       router.location.setURL(url);
 
       if (shouldHandleURL) {
+        (true && !(app.__deprecatedInstance__) && (0, _debug.assert)("[BUG] __deprecatedInstance__ isn't set", app.__deprecatedInstance__));
         (0, _runloop.run)(app.__deprecatedInstance__, 'handleURL', url);
       }
     });
 
     if (app._readinessDeferrals > 0) {
+      // SAFETY: This should be safe, though it is odd.
       router.initialURL = url;
       (0, _runloop.run)(app, 'advanceReadiness');
       delete router.initialURL;
@@ -53198,10 +52865,12 @@ define("ember-testing/lib/helpers/visit", ["exports", "@ember/runloop"], functio
       shouldHandleURL = true;
     }
 
-    return app.testHelpers.wait();
+    var wait = app.testHelpers['wait'];
+    (true && !(wait) && (0, _debug.assert)('[BUG] missing wait helper', wait));
+    return wait();
   }
 });
-define("ember-testing/lib/helpers/wait", ["exports", "ember-testing/lib/test/waiters", "@ember/-internals/runtime", "@ember/runloop", "ember-testing/lib/test/pending_requests"], function (_exports, _waiters, _runtime, _runloop, _pending_requests) {
+define("ember-testing/lib/helpers/wait", ["exports", "ember-testing/lib/test/waiters", "@ember/-internals/runtime", "@ember/runloop", "ember-testing/lib/test/pending_requests", "@ember/debug", "@ember/routing/router"], function (_exports, _waiters, _runtime, _runloop, _pending_requests, _debug, _router) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -53245,8 +52914,11 @@ define("ember-testing/lib/helpers/wait", ["exports", "ember-testing/lib/test/wai
   */
   function wait(app, value) {
     return new _runtime.RSVP.Promise(function (resolve) {
-      var router = app.__container__.lookup('router:main'); // Every 10ms, poll for the async thing to have finished
+      (true && !(app.__container__) && (0, _debug.assert)('[BUG] Missing container', app.__container__));
+
+      var router = app.__container__.lookup('router:main');
 
+      (true && !(router instanceof _router.default) && (0, _debug.assert)('[BUG] Expected router:main to be a subclass of Ember Router', router instanceof _router.default)); // Every 10ms, poll for the async thing to have finished
 
       var watcher = setInterval(() => {
         // 1. If the router is loading, keep polling
@@ -53282,9 +52954,9 @@ define("ember-testing/lib/initializers", ["@ember/application"], function (_appl
   "use strict";
 
   var name = 'deferReadiness in `testing` mode';
-  (0, _application.onLoad)('Ember.Application', function (Application) {
-    if (!Application.initializers[name]) {
-      Application.initializer({
+  (0, _application.onLoad)('Ember.Application', function (ApplicationClass) {
+    if (!ApplicationClass.initializers[name]) {
+      ApplicationClass.initializer({
         name: name,
 
         initialize(application) {
@@ -53355,7 +53027,7 @@ define("ember-testing/lib/test", ["exports", "ember-testing/lib/test/helpers", "
   var Test = {
     /**
       Hash containing all known test helpers.
-       @property _helpers
+         @property _helpers
       @private
       @since 1.7.0
     */
@@ -53438,7 +53110,8 @@ define("ember-testing/lib/test/adapter", ["exports", "@ember/-internals/error-ha
   }
 
   function adapterDispatch(error) {
-    adapter.exception(error);
+    adapter.exception(error); // @ts-expect-error Normally unreachable
+
     console.error(error.stack); // eslint-disable-line no-console
   }
 });
@@ -53581,7 +53254,9 @@ define("ember-testing/lib/test/helpers", ["exports", "ember-testing/lib/test/pro
 
 
   function unregisterHelper(name) {
-    delete helpers[name];
+    delete helpers[name]; // SAFETY: This isn't necessarily a safe thing to do, but in terms of the immediate types here
+    // it won't error.
+
     delete _promise.default.prototype[name];
   }
 });
@@ -53630,8 +53305,8 @@ define("ember-testing/lib/test/on_inject_helpers", ["exports"], function (_expor
   }
 
   function invokeInjectHelpersCallbacks(app) {
-    for (var i = 0; i < callbacks.length; i++) {
-      callbacks[i](app);
+    for (var callback of callbacks) {
+      callback(app);
     }
   }
 });
@@ -53680,22 +53355,17 @@ define("ember-testing/lib/test/promise", ["exports", "@ember/-internals/runtime"
   _exports.getLastPromise = getLastPromise;
   _exports.promise = promise;
   _exports.resolve = resolve;
-  var lastPromise;
+  var lastPromise = null;
 
   class TestPromise extends _runtime.RSVP.Promise {
-    constructor() {
-      super(...arguments);
+    constructor(executor, label) {
+      super(executor, label);
       lastPromise = this;
     }
 
-    then(_onFulfillment) {
-      var onFulfillment = typeof _onFulfillment === 'function' ? result => isolate(_onFulfillment, result) : undefined;
-
-      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        args[_key - 1] = arguments[_key];
-      }
-
-      return super.then(onFulfillment, ...args);
+    then(onFulfilled, onRejected, label) {
+      var normalizedOnFulfilled = typeof onFulfilled === 'function' ? result => isolate(onFulfilled, result) : undefined;
+      return super.then(normalizedOnFulfilled, onRejected, label);
     }
 
   }
@@ -53747,10 +53417,10 @@ define("ember-testing/lib/test/promise", ["exports", "@ember/-internals/runtime"
   // 3. Return the last promise created during method
 
 
-  function isolate(onFulfillment, result) {
+  function isolate(onFulfilled, result) {
     // Reset lastPromise for nested helpers
     lastPromise = null;
-    var value = onFulfillment(result);
+    var value = onFulfilled(result);
     var promise = lastPromise;
     lastPromise = null; // If the method returned a promise
     // return that promise. If not,
@@ -53794,55 +53464,25 @@ define("ember-testing/lib/test/waiters", ["exports"], function (_exports) {
   */
   var contexts = [];
   var callbacks = [];
-  /**
-     This allows ember-testing to play nicely with other asynchronous
-     events, such as an application that is waiting for a CSS3
-     transition or an IndexDB transaction. The waiter runs periodically
-     after each async helper (i.e. `click`, `andThen`, `visit`, etc) has executed,
-     until the returning result is truthy. After the waiters finish, the next async helper
-     is executed and the process repeats.
-  
-     For example:
-  
-     ```javascript
-     import { registerWaiter } from '@ember/test';
-  
-     registerWaiter(function() {
-       return myPendingTransactions() === 0;
-     });
-     ```
-     The `context` argument allows you to optionally specify the `this`
-     with which your callback will be invoked.
-  
-     For example:
-  
-     ```javascript
-     import { registerWaiter } from '@ember/test';
-  
-     registerWaiter(MyDB, MyDB.hasPendingTransactions);
-     ```
-  
-     @public
-     @for @ember/test
-     @static
-     @method registerWaiter
-     @param {Object} context (optional)
-     @param {Function} callback
-     @since 1.2.0
-  */
 
-  function registerWaiter(context, callback) {
+  function registerWaiter() {
+    var checkedCallback;
+    var checkedContext;
+
     if (arguments.length === 1) {
-      callback = context;
-      context = null;
+      checkedContext = null;
+      checkedCallback = arguments.length <= 0 ? undefined : arguments[0];
+    } else {
+      checkedContext = arguments.length <= 0 ? undefined : arguments[0];
+      checkedCallback = arguments.length <= 1 ? undefined : arguments[1];
     }
 
-    if (indexOf(context, callback) > -1) {
+    if (indexOf(checkedContext, checkedCallback) > -1) {
       return;
     }
 
-    contexts.push(context);
-    callbacks.push(callback);
+    contexts.push(checkedContext);
+    callbacks.push(checkedCallback);
   }
   /**
      `unregisterWaiter` is used to unregister a callback that was
@@ -53899,7 +53539,7 @@ define("ember-testing/lib/test/waiters", ["exports"], function (_exports) {
 
     for (var i = 0; i < callbacks.length; i++) {
       var context = contexts[i];
-      var callback = callbacks[i];
+      var callback = callbacks[i]; // SAFETY: The loop ensures that this exists
 
       if (!callback.call(context)) {
         return true;
@@ -54405,7 +54045,7 @@ define("ember/version", ["exports"], function (_exports) {
     value: true
   });
   _exports.default = void 0;
-  var _default = "4.5.0-beta.1";
+  var _default = "4.6.0-alpha.3";
   _exports.default = _default;
 });
 define("route-recognizer", ["exports"], function (_exports) {