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

package/dist/packages/@ember/-internals/runtime/lib/mixins/array.js

@@ -3,7 +3,7 @@
 */
 import { DEBUG } from '@glimmer/env';
 import { PROXY_CONTENT } from '@ember/-internals/metal';
-import { setEmberArray } from '@ember/-internals/utils';
+import { isEmberArray, setEmberArray } from '@ember/-internals/utils';
 import { get, set, objectAt, replaceInNativeArray, replace, computed, Mixin, beginPropertyChanges, endPropertyChanges } from '@ember/-internals/metal';
 import { assert } from '@ember/debug';
 import Enumerable from './enumerable';
@@ -16,11 +16,11 @@ const EMPTY_ARRAY = Object.freeze([]);
 
 const identityFunction = item => item;
 
-export function uniqBy(array, key = identityFunction) {
+export function uniqBy(array, keyOrFunc = identityFunction) {
   assert(`first argument passed to \`uniqBy\` should be array`, isArray(array));
   let ret = A();
   let seen = new Set();
-  let getter = typeof key === 'function' ? key : item => get(item, key);
+  let getter = typeof keyOrFunc === 'function' ? keyOrFunc : item => get(item, keyOrFunc);
   array.forEach(item => {
     let val = getter(item);
 
@@ -32,8 +32,9 @@ export function uniqBy(array, key = identityFunction) {
   return ret;
 }
 
-function iter(key, value) {
-  let valueProvided = arguments.length === 2;
+function iter(...args) {
+  let valueProvided = args.length === 2;
+  let [key, value] = args;
   return valueProvided ? item => value === get(item, key) : item => Boolean(get(item, key));
 }
 
@@ -41,6 +42,7 @@ function findIndex(array, predicate, startAt) {
   let len = array.length;
 
   for (let index = startAt; index < len; index++) {
+    // SAFETY: Because we're checking the index this value should always be set.
     let item = objectAt(array, index);
 
     if (predicate(item, index, array)) {
@@ -51,18 +53,18 @@ function findIndex(array, predicate, startAt) {
   return -1;
 }
 
-function find(array, callback, target) {
+function find(array, callback, target = null) {
   let predicate = callback.bind(target);
   let index = findIndex(array, predicate, 0);
   return index === -1 ? undefined : objectAt(array, index);
 }
 
-function any(array, callback, target) {
+function any(array, callback, target = null) {
   let predicate = callback.bind(target);
   return findIndex(array, predicate, 0) !== -1;
 }
 
-function every(array, callback, target) {
+function every(array, callback, target = null) {
   let cb = callback.bind(target);
 
   let predicate = (item, index, array) => !cb(item, index, array);
@@ -82,9 +84,9 @@ function indexOf(array, val, startAt = 0, withNaNCheck) {
   return findIndex(array, predicate, startAt);
 }
 
-export function removeAt(array, index, len = 1) {
+export function removeAt(array, index, len) {
   assert(`\`removeAt\` index provided is out of range`, index > -1 && index < array.length);
-  replace(array, index, len, EMPTY_ARRAY);
+  replace(array, index, len !== null && len !== void 0 ? len : 1, EMPTY_ARRAY);
   return array;
 }
 
@@ -123,22 +125,22 @@ function insertAt(array, index, item) {
 */
 
 
-export function isArray(_obj) {
-  let obj = _obj;
-
-  if (DEBUG && typeof _obj === 'object' && _obj !== null) {
-    let possibleProxyContent = _obj[PROXY_CONTENT];
+export function isArray(obj) {
+  if (DEBUG && typeof obj === 'object' && obj !== null) {
+    // SAFETY: Property read checks are safe if it's an object
+    let possibleProxyContent = obj[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;
   }
 
@@ -146,7 +148,8 @@ export function isArray(_obj) {
 
   if ('array' === type) {
     return true;
-  }
+  } // SAFETY: Property read checks are safe if it's an object
+
 
   let length = obj.length;
 
@@ -163,54 +166,17 @@ export function isArray(_obj) {
   new enumerable properties.
 */
 
-function nonEnumerableComputed() {
-  let property = computed(...arguments);
+function nonEnumerableComputed(callback) {
+  let property = computed(callback);
   property.enumerable = false;
   return property;
 }
 
 function mapBy(key) {
   return this.map(next => 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
-*/
-
+}
 
-const ArrayMixin = Mixin.create(Enumerable, {
+const EmberArray = Mixin.create(Enumerable, {
   init() {
     this._super(...arguments);
 
@@ -219,28 +185,28 @@ const ArrayMixin = Mixin.create(Enumerable, {
 
   /**
     __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
@@ -248,12 +214,12 @@ const ArrayMixin = Mixin.create(Enumerable, {
 
   /**
     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
@@ -266,13 +232,13 @@ const ArrayMixin = Mixin.create(Enumerable, {
     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
   */
@@ -281,7 +247,7 @@ const ArrayMixin = Mixin.create(Enumerable, {
       return this;
     },
 
-    set(key, value) {
+    set(_key, value) {
       this.replace(0, this.length, value);
       return this;
     }
@@ -290,17 +256,17 @@ const ArrayMixin = Mixin.create(Enumerable, {
 
   /**
     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
   */
@@ -310,7 +276,7 @@ const ArrayMixin = Mixin.create(Enumerable, {
 
   /**
     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
   */
@@ -324,13 +290,13 @@ const ArrayMixin = Mixin.create(Enumerable, {
     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
@@ -344,13 +310,17 @@ const ArrayMixin = Mixin.create(Enumerable, {
       beginIndex = length + beginIndex;
     }
 
+    let 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] = objectAt(this, beginIndex++);
     }
 
@@ -360,29 +330,29 @@ const ArrayMixin = Mixin.create(Enumerable, {
   /**
     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
@@ -394,7 +364,7 @@ const ArrayMixin = Mixin.create(Enumerable, {
 
   /**
     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.
@@ -402,10 +372,10 @@ const ArrayMixin = Mixin.create(Enumerable, {
     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
@@ -413,7 +383,7 @@ const ArrayMixin = Mixin.create(Enumerable, {
     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)`
@@ -445,26 +415,26 @@ const ArrayMixin = Mixin.create(Enumerable, {
     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`;
     );
@@ -473,7 +443,7 @@ const ArrayMixin = Mixin.create(Enumerable, {
     // 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
@@ -493,16 +463,16 @@ const ArrayMixin = Mixin.create(Enumerable, {
 
   /**
     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
@@ -514,12 +484,12 @@ const ArrayMixin = Mixin.create(Enumerable, {
     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
@@ -532,24 +502,24 @@ const ArrayMixin = Mixin.create(Enumerable, {
   /**
     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.
@@ -565,14 +535,14 @@ const ArrayMixin = Mixin.create(Enumerable, {
   /**
     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
@@ -582,42 +552,42 @@ const ArrayMixin = Mixin.create(Enumerable, {
   /**
     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.
@@ -637,20 +607,20 @@ const ArrayMixin = Mixin.create(Enumerable, {
   /**
     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 },
@@ -660,7 +630,7 @@ const ArrayMixin = Mixin.create(Enumerable, {
       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.
@@ -669,6 +639,7 @@ const ArrayMixin = Mixin.create(Enumerable, {
   reject(callback, target = null) {
     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);
     });
   },
@@ -677,19 +648,20 @@ const ArrayMixin = Mixin.create(Enumerable, {
     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));
   },
 
@@ -697,8 +669,8 @@ const ArrayMixin = Mixin.create(Enumerable, {
     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 },
@@ -707,44 +679,45 @@ const ArrayMixin = Mixin.create(Enumerable, {
       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`.
@@ -759,52 +732,54 @@ const ArrayMixin = Mixin.create(Enumerable, {
     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.
+    let 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}
@@ -819,7 +794,7 @@ const ArrayMixin = Mixin.create(Enumerable, {
     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 {
@@ -828,20 +803,20 @@ const ArrayMixin = Mixin.create(Enumerable, {
         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}
@@ -849,7 +824,9 @@ const ArrayMixin = Mixin.create(Enumerable, {
     @public
   */
   isEvery() {
-    return every(this, iter(...arguments));
+    // @ts-expect-error TS doesn't like the ...arguments spread here.
+    let callback = iter(...arguments);
+    return every(this, callback);
   },
 
   /**
@@ -857,27 +834,27 @@ const ArrayMixin = Mixin.create(Enumerable, {
     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
@@ -892,16 +869,16 @@ const ArrayMixin = Mixin.create(Enumerable, {
     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}
@@ -909,44 +886,47 @@ const ArrayMixin = Mixin.create(Enumerable, {
     @public
   */
   isAny() {
-    return any(this, iter(...arguments));
+    // @ts-expect-error TS doesn't like us using arguments like this
+    let 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.
@@ -966,36 +946,41 @@ const ArrayMixin = Mixin.create(Enumerable, {
     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, ...args) {
-    let ret = A();
-    this.forEach(item => ret.push(item[methodName]?.(...args)));
+    let 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
   */
@@ -1005,11 +990,11 @@ const ArrayMixin = Mixin.create(Enumerable, {
 
   /**
     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
   */
@@ -1020,13 +1005,13 @@ const ArrayMixin = Mixin.create(Enumerable, {
   /**
     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
@@ -1036,7 +1021,7 @@ const ArrayMixin = Mixin.create(Enumerable, {
     [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.
@@ -1048,19 +1033,19 @@ const ArrayMixin = Mixin.create(Enumerable, {
 
   /**
     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
@@ -1088,12 +1073,12 @@ const ArrayMixin = Mixin.create(Enumerable, {
   /**
     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
   */
@@ -1104,13 +1089,13 @@ const ArrayMixin = Mixin.create(Enumerable, {
   /**
     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
@@ -1123,11 +1108,11 @@ const ArrayMixin = Mixin.create(Enumerable, {
     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
@@ -1143,35 +1128,14 @@ const ArrayMixin = Mixin.create(Enumerable, {
   }
 
 });
-/**
-  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
-*/
-
-const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
+const MutableArray = Mixin.create(EmberArray, MutableEnumerable, {
   /**
     __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
@@ -1184,13 +1148,13 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
   /**
     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
   */
@@ -1208,12 +1172,12 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
   /**
     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
@@ -1227,15 +1191,15 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
   /**
     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
@@ -1248,12 +1212,12 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
   /**
     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
@@ -1265,13 +1229,13 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
   /**
     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) {
@@ -1282,12 +1246,12 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
   /**
     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
   */
@@ -1306,12 +1270,12 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
   /**
     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
   */
@@ -1328,12 +1292,12 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
   /**
     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
@@ -1345,12 +1309,12 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
   /**
     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
@@ -1363,7 +1327,7 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
   /**
     Reverse objects in the array. Works just like `reverse()` but it is
     KVO-compliant.
-     @method reverseObjects
+       @method reverseObjects
     @return {EmberArray} receiver
      @public
   */
@@ -1382,12 +1346,12 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
   /**
     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
@@ -1405,13 +1369,13 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
 
   /**
     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
@@ -1432,7 +1396,7 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
 
   /**
     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
@@ -1441,6 +1405,7 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
     beginPropertyChanges();
 
     for (let i = objects.length - 1; i >= 0; i--) {
+      // SAFETY: Due to the loop structure we know this will always exist.
       this.removeObject(objects[i]);
     }
 
@@ -1451,12 +1416,12 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
   /**
     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
@@ -1473,7 +1438,7 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
 
   /**
     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
@@ -1486,62 +1451,6 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
   }
 
 });
-/**
-  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
-*/
-
 let NativeArray = Mixin.create(MutableArray, Observable, {
   objectAt(idx) {
     return this[idx];
@@ -1558,6 +1467,7 @@ let NativeArray = Mixin.create(MutableArray, Observable, {
 
 const ignore = ['length'];
 NativeArray.keys().forEach(methodName => {
+  // SAFETY: It's safe to read unknown properties from an object
   if (Array.prototype[methodName]) {
     ignore.push(methodName);
   }
@@ -1569,20 +1479,23 @@ if (ENV.EXTEND_PROTOTYPES.Array) {
   NativeArray.apply(Array.prototype, true);
 
   A = function (arr) {
-    assert('You cannot create an Ember Array with `new A()`, please update to calling A as a function: `A()`', !(this instanceof A));
+    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 {
   A = function (arr) {
     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 (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);
   };
 }
 
 export { A, NativeArray, MutableArray };
-export default ArrayMixin;
+export default EmberArray;