ember-source 4.0.0-beta.9 → 4.0.0

package/docs/data.json

@@ -3,7 +3,7 @@
     "name": "The Ember API",
     "description": "The Ember API: a framework for building ambitious web applications",
     "url": "https://emberjs.com/",
-    "version": "4.0.0-beta.9"
+    "version": "4.0.0"
   },
   "files": {
     "node_modules/rsvp/lib/rsvp/promise/all.js": {
@@ -2001,7 +2001,7 @@
       "namespaces": {},
       "tag": "module",
       "file": "packages/@ember/-internals/runtime/lib/system/array_proxy.js",
-      "line": 42
+      "line": 43
     },
     "@ember/enumerable": {
       "name": "@ember/enumerable",
@@ -3030,7 +3030,7 @@
       "module": "@ember/array",
       "namespace": "",
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 185,
+      "line": 179,
       "description": "This mixin implements Observer-friendly Array-like behavior. It is not a\nconcrete implementation, but it can be used up by other classes that want\nto appear like arrays.\n\nFor example, ArrayProxy is a concrete class that can be instantiated to\nimplement array-like behavior. This class uses the Array Mixin by way of\nthe MutableArray mixin, which allows observable changes to be made to the\nunderlying array.\n\nThis mixin defines methods specifically for collections that provide\nindex-ordered access to their contents. When you are designing code that\nneeds to accept any kind of Array-like object, you should use these methods\ninstead of Array primitives because these will properly notify observers of\nchanges to the array.\n\nAlthough these methods are efficient, they do add a layer of indirection to\nyour application so it is a good idea to use them only when you need the\nflexibility of using both true JavaScript arrays and \"virtual\" arrays such\nas controllers and collections.\n\nYou can use the methods defined in this module to access and modify array\ncontents in an observable-friendly way. You can also be notified whenever\nthe membership of an array changes by using `.observes('myArray.[]')`.\n\nTo support `EmberArray` in your own class, you must override two\nprimitives to use it: `length()` and `objectAt()`.",
       "uses": [
         "Enumerable"
@@ -3053,7 +3053,7 @@
       "module": "@ember/array",
       "namespace": "",
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1527,
+      "line": 1326,
       "description": "This mixin defines the API for modifying array-like objects. These methods\ncan be applied only to a collection that keeps its items in an ordered set.\nIt builds upon the Array mixin and adds methods to modify the array.\nOne concrete implementations of this class include ArrayProxy.\n\nIt is important to use the methods in this class to modify arrays so that\nchanges are observable. This allows the binding system in Ember to function\ncorrectly.\n\n\nNote that an Array can change even if it does not implement this mixin.\nFor example, one might implement a SparseArray that cannot be directly\nmodified, but if its underlying enumerable changes, it will change also.",
       "uses": [
         "EmberArray",
@@ -3073,7 +3073,7 @@
       "module": "ember",
       "namespace": "",
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1948,
+      "line": 1747,
       "description": "The NativeArray mixin contains the properties needed to make the native\nArray support MutableArray and all of its dependent APIs. Unless you\nhave `EmberENV.EXTEND_PROTOTYPES` or `EmberENV.EXTEND_PROTOTYPES.Array` set to\nfalse, this will be applied automatically. Otherwise you can apply the mixin\nat anytime by calling `Ember.NativeArray.apply(Array.prototype)`.",
       "uses": [
         "MutableArray",
@@ -3259,7 +3259,7 @@
       "module": "@ember/array",
       "namespace": "",
       "file": "packages/@ember/-internals/runtime/lib/system/array_proxy.js",
-      "line": 42,
+      "line": 43,
       "description": "An ArrayProxy wraps any other object that implements `Array` and/or\n`MutableArray,` forwarding all requests. This makes it very useful for\na number of binding use cases or other cases where being able to swap\nout the underlying array is useful.\n\nA simple example of usage:\n\n```javascript\nimport { A } from '@ember/array';\nimport ArrayProxy from '@ember/array/proxy';\n\nlet pets = ['dog', 'cat', 'fish'];\nlet ap = ArrayProxy.create({ content: A(pets) });\n\nap.get('firstObject');                        // 'dog'\nap.set('content', ['amoeba', 'paramecium']);\nap.get('firstObject');                        // 'amoeba'\n```\n\nThis class can also be useful as a layer to transform the contents of\nan array, as they are accessed. This can be done by overriding\n`objectAtContent`:\n\n```javascript\nimport { A } from '@ember/array';\nimport ArrayProxy from '@ember/array/proxy';\n\nlet pets = ['dog', 'cat', 'fish'];\nlet ap = ArrayProxy.create({\n    content: A(pets),\n    objectAtContent: function(idx) {\n        return this.get('content').objectAt(idx).toUpperCase();\n    }\n});\n\nap.get('firstObject'); // . 'DOG'\n```\n\nWhen overriding this class, it is important to place the call to\n`_super` *after* setting `content` so the internal observers have\na chance to fire properly:\n\n```javascript\nimport { A } from '@ember/array';\nimport ArrayProxy from '@ember/array/proxy';\n\nexport default ArrayProxy.extend({\n  init() {\n    this.set('content', A(['dog', 'cat', 'fish']));\n    this._super(...arguments);\n  }\n});\n```",
       "extends": "EmberObject",
       "uses": [
@@ -10640,7 +10640,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 111,
+      "line": 105,
       "description": "Returns true if the passed object is an array or Array-like.\n\nObjects are considered Array-like if any of the following are true:\n\n  - the object is a native Array\n  - the object has an objectAt property\n  - the object is an Object, and has a length property\n\nUnlike `typeOf` this method returns true even if the passed object is\nnot formally an array but appears to be array-like (i.e. implements `Array`)\n\n```javascript\nimport { isArray } from '@ember/array';\nimport ArrayProxy from '@ember/array/proxy';\n\nisArray();                                      // false\nisArray([]);                                    // true\nisArray(ArrayProxy.create({ content: [] }));    // true\n```",
       "itemtype": "method",
       "name": "isArray",
@@ -10663,7 +10663,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 224,
+      "line": 218,
       "description": "__Required.__ You must implement this method to apply this mixin.\n\nYour array must support the `length` property. Your replace methods should\nset this property whenever it changes.",
       "itemtype": "property",
       "name": "length",
@@ -10675,7 +10675,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 234,
+      "line": 228,
       "description": "Returns the object at the given `index`. If the given `index` is negative\nor is greater or equal than the array length, returns `undefined`.\n\nThis is one of the primitives you must implement to support `EmberArray`.\nIf your object supports retrieving the value of an array item using `get()`\n(i.e. `myArray.get(0)`), then you do not need to implement this method\nyourself.\n\n```javascript\nlet arr = ['a', 'b', 'c', 'd'];\n\narr.objectAt(0);   // 'a'\narr.objectAt(3);   // 'd'\narr.objectAt(-1);  // undefined\narr.objectAt(4);   // undefined\narr.objectAt(5);   // undefined\n```",
       "itemtype": "method",
       "name": "objectAt",
@@ -10697,7 +10697,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 259,
+      "line": 253,
       "description": "This returns the objects at the specified indexes, using `objectAt`.\n\n```javascript\nlet arr = ['a', 'b', 'c', 'd'];\n\narr.objectsAt([0, 1, 2]);  // ['a', 'b', 'c']\narr.objectsAt([2, 3, 4]);  // ['c', 'd', undefined]\n```",
       "itemtype": "method",
       "name": "objectsAt",
@@ -10719,7 +10719,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 278,
+      "line": 272,
       "description": "This is the handler for the special array content property. If you get\nthis property, it will return this. If you set this property to a new\narray, it will replace the current content.\n\n```javascript\nlet peopleToMoon = ['Armstrong', 'Aldrin'];\n\npeopleToMoon.get('[]'); // ['Armstrong', 'Aldrin']\n\npeopleToMoon.set('[]', ['Collins']); // ['Collins']\npeopleToMoon.get('[]'); // ['Collins']\n```",
       "itemtype": "property",
       "name": "[]",
@@ -10733,7 +10733,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 306,
+      "line": 300,
       "description": "The first object in the array, or `undefined` if the array is empty.\n\n```javascript\nlet vowels = ['a', 'e', 'i', 'o', 'u'];\nvowels.firstObject; // 'a'\n\nvowels.shiftObject();\nvowels.firstObject; // 'e'\n\nvowels.reverseObjects();\nvowels.firstObject; // 'u'\n\nvowels.clear();\nvowels.firstObject; // undefined\n```",
       "itemtype": "property",
       "name": "firstObject",
@@ -10748,7 +10748,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 331,
+      "line": 325,
       "description": "The last object in the array, or `undefined` if the array is empty.",
       "itemtype": "property",
       "name": "lastObject",
@@ -10763,7 +10763,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 343,
+      "line": 337,
       "description": "Returns a new array that is a slice of the receiver. This implementation\nuses the observable array methods to retrieve the objects for the new\nslice.\n\n```javascript\nlet arr = ['red', 'green', 'blue'];\n\narr.slice(0);       // ['red', 'green', 'blue']\narr.slice(0, 2);    // ['red', 'green']\narr.slice(1, 100);  // ['green', 'blue']\n```",
       "itemtype": "method",
       "name": "slice",
@@ -10790,7 +10790,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 383,
+      "line": 377,
       "description": "Used to determine the passed object's first occurrence in the array.\nReturns the index if found, -1 if no match is found.\n\nThe optional `startAt` argument can be used to pass a starting\nindex to search from, effectively slicing the searchable portion\nof the array. If it's negative it will add the array length to\nthe startAt value passed in as the index to search from. If less\nthan or equal to `-1 * array.length` the entire array is searched.\n\n```javascript\nlet arr = ['a', 'b', 'c', 'd', 'a'];\n\narr.indexOf('a');       //  0\narr.indexOf('z');       // -1\narr.indexOf('a', 2);    //  4\narr.indexOf('a', -1);   //  4, equivalent to indexOf('a', 4)\narr.indexOf('a', -100); //  0, searches entire array\narr.indexOf('b', 3);    // -1\narr.indexOf('a', 100);  // -1\n\nlet people = [{ name: 'Zoey' }, { name: 'Bob' }]\nlet newPerson = { name: 'Tom' };\npeople = [newPerson, ...people, newPerson];\n\npeople.indexOf(newPerson);     //  0\npeople.indexOf(newPerson, 1);  //  3\npeople.indexOf(newPerson, -4); //  0\npeople.indexOf(newPerson, 10); // -1\n```",
       "itemtype": "method",
       "name": "indexOf",
@@ -10817,7 +10817,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 425,
+      "line": 419,
       "description": "Returns the index of the given `object`'s last occurrence.\n\n- If no `startAt` argument is given, the search starts from\nthe last position.\n- If it's greater than or equal to the length of the array,\nthe search starts from the last position.\n- If it's negative, it is taken as the offset from the end\nof the array i.e. `startAt + array.length`.\n- If it's any other positive number, will search backwards\nfrom that index of the array.\n\nReturns -1 if no match is found.\n\n```javascript\nlet arr = ['a', 'b', 'c', 'd', 'a'];\n\narr.lastIndexOf('a');       //  4\narr.lastIndexOf('z');       // -1\narr.lastIndexOf('a', 2);    //  0\narr.lastIndexOf('a', -1);   //  4\narr.lastIndexOf('a', -3);   //  0\narr.lastIndexOf('b', 3);    //  1\narr.lastIndexOf('a', 100);  //  4\n```",
       "itemtype": "method",
       "name": "lastIndexOf",
@@ -10844,140 +10844,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 483,
-      "description": "Adds an array observer to the receiving array. The array observer object\nnormally must implement two methods:\n\n* `willChange(observedObj, start, removeCount, addCount)` - This method will be\n  called just before the array is modified.\n* `didChange(observedObj, start, removeCount, addCount)` - This method will be\n  called just after the array is modified.\n\nBoth callbacks will be passed the observed object, starting index of the\nchange as well as a count of the items to be removed and added. You can use\nthese callbacks to optionally inspect the array during the change, clear\ncaches, or do any other bookkeeping necessary.\n\nIn addition to passing a target, you can also include an options hash\nwhich you can use to override the method names that will be invoked on the\ntarget.",
-      "itemtype": "method",
-      "name": "addArrayObserver",
-      "params": [
-        {
-          "name": "target",
-          "description": "The observer object.",
-          "type": "Object"
-        },
-        {
-          "name": "opts",
-          "description": "Optional hash of configuration options including\n  `willChange` and `didChange` option.",
-          "type": "Object"
-        }
-      ],
-      "return": {
-        "description": "receiver",
-        "type": "EmberArray"
-      },
-      "access": "public",
-      "tagname": "",
-      "example": [
-        "\n    import Service from '@ember/service';\n\n    export default Service.extend({\n      data: Ember.A(),\n\n      init() {\n        this._super(...arguments);\n\n        this.data.addArrayObserver(this, {\n          willChange: 'dataWillChange',\n          didChange: 'dataDidChange'\n        });\n      },\n\n      dataWillChange(array, start, removeCount, addCount) {\n        console.log('array will change', array, start, removeCount, addCount);\n      },\n\n      dataDidChange(array, start, removeCount, addCount) {\n        console.log('array did change', array, start, removeCount, addCount);\n      }\n    });"
-      ],
-      "class": "EmberArray",
-      "module": "@ember/array"
-    },
-    {
-      "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 536,
-      "description": "Removes an array observer from the object if the observer is current\nregistered. Calling this method multiple times with the same object will\nhave no effect.",
-      "itemtype": "method",
-      "name": "removeArrayObserver",
-      "params": [
-        {
-          "name": "target",
-          "description": "The object observing the array.",
-          "type": "Object"
-        },
-        {
-          "name": "opts",
-          "description": "Optional hash of configuration options including\n  `willChange` and `didChange` option.",
-          "type": "Object"
-        }
-      ],
-      "return": {
-        "description": "receiver",
-        "type": "EmberArray"
-      },
-      "access": "public",
-      "tagname": "",
-      "class": "EmberArray",
-      "module": "@ember/array"
-    },
-    {
-      "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 552,
-      "description": "Becomes true whenever the array currently has observers watching changes\non the array.\n\n```javascript\nlet arr = [1, 2, 3, 4, 5];\narr.hasArrayObservers; // false\n\narr.addArrayObserver(this, {\n  willChange() {\n    console.log('willChange');\n  }\n});\narr.hasArrayObservers; // true\n```",
-      "itemtype": "property",
-      "name": "hasArrayObservers",
-      "type": "Boolean",
-      "access": "public",
-      "tagname": "",
-      "class": "EmberArray",
-      "module": "@ember/array"
-    },
-    {
-      "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 579,
-      "description": "If you are implementing an object that supports `EmberArray`, call this\nmethod just before the array content changes to notify any observers and\ninvalidate any related properties. Pass the starting index of the change\nas well as a delta of the amounts to change.\n\n```app/components/show-post.js\nimport Component from '@ember/component';\nimport EmberObject from '@ember/object';\n\nconst Post = EmberObject.extend({\n  body: '',\n  save() {}\n})\n\nexport default Component.extend({\n  attemptsToModify: 0,\n  successfulModifications: 0,\n  posts: null,\n\n  init() {\n    this._super(...arguments);\n\n    this.posts = [1, 2, 3].map(i => Post.create({ body: i }));\n    this.posts.addArrayObserver(this, {\n      willChange() {\n        this.incrementProperty('attemptsToModify');\n      },\n      didChange() {\n        this.incrementProperty('successfulModifications');\n      }\n    });\n  },\n\n  actions: {\n    editPost(post, newContent) {\n      let oldContent = post.body,\n          postIndex = this.posts.indexOf(post);\n\n      this.posts.arrayContentWillChange(postIndex, 0, 0); // attemptsToModify = 1\n      post.set('body', newContent);\n\n      post.save()\n        .then(response => {\n          this.posts.arrayContentDidChange(postIndex, 0, 0); // successfulModifications = 1\n        })\n        .catch(error => {\n          post.set('body', oldContent);\n        })\n    }\n  }\n});\n```",
-      "itemtype": "method",
-      "name": "arrayContentWillChange",
-      "params": [
-        {
-          "name": "startIdx",
-          "description": "The starting index in the array that will change.",
-          "type": "Number"
-        },
-        {
-          "name": "removeAmt",
-          "description": "The number of items that will be removed. If you\n  pass `null` assumes 0",
-          "type": "Number"
-        },
-        {
-          "name": "addAmt",
-          "description": "The number of items that will be added. If you\n  pass `null` assumes 0.",
-          "type": "Number"
-        }
-      ],
-      "return": {
-        "description": "receiver",
-        "type": "EmberArray"
-      },
-      "access": "public",
-      "tagname": "",
-      "class": "EmberArray",
-      "module": "@ember/array"
-    },
-    {
-      "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 646,
-      "description": "If you are implementing an object that supports `EmberArray`, call this\nmethod just after the array content changes to notify any observers and\ninvalidate any related properties. Pass the starting index of the change\nas well as a delta of the amounts to change.\n\n```javascript\nlet arr = [1, 2, 3, 4, 5];\n\narr.copyWithin(-2); // [1, 2, 3, 1, 2]\n// arr.lastObject = 5\narr.arrayContentDidChange(3, 2, 2);\n// arr.lastObject = 2\n```",
-      "itemtype": "method",
-      "name": "arrayContentDidChange",
-      "params": [
-        {
-          "name": "startIdx",
-          "description": "The starting index in the array that did change.",
-          "type": "Number"
-        },
-        {
-          "name": "removeAmt",
-          "description": "The number of items that were removed. If you\n  pass `null` assumes 0",
-          "type": "Number"
-        },
-        {
-          "name": "addAmt",
-          "description": "The number of items that were added. If you\n  pass `null` assumes 0.",
-          "type": "Number"
-        }
-      ],
-      "return": {
-        "description": "receiver",
-        "type": "EmberArray"
-      },
-      "access": "public",
-      "tagname": "",
-      "class": "EmberArray",
-      "module": "@ember/array"
-    },
-    {
-      "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 674,
+      "line": 473,
       "description": "Iterates through the array, calling the passed function on each\nitem. This method corresponds to the `forEach()` method defined in\nJavaScript 1.6.\n\nThe callback method you provide should have the following signature (all\nparameters are optional):\n\n```javascript\nfunction(item, index, array);\n```\n\n- `item` is the current item in the iteration.\n- `index` is the current index in the iteration.\n- `array` is the array itself.\n\nNote that in addition to a callback, you can also pass an optional target\nobject that will be set as `this` on the context. This is a good way\nto give your iterator function access to the current object.\n\nExample Usage:\n\n```javascript\nlet foods = [\n  { name: 'apple', eaten: false },\n  { name: 'banana', eaten: false },\n  { name: 'carrot', eaten: false }\n];\n\nfoods.forEach((food) => food.eaten = true);\n\nlet output = '';\nfoods.forEach((item, index, array) =>\n  output += `${index + 1}/${array.length} ${item.name}\\n`;\n);\nconsole.log(output);\n// 1/3 apple\n// 2/3 banana\n// 3/3 carrot\n```",
       "itemtype": "method",
       "name": "forEach",
@@ -11005,7 +10872,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 734,
+      "line": 533,
       "description": "Alias for `mapBy`.\n\nReturns the value of the named\nproperty on all items in the enumeration.\n\n```javascript\nlet people = [{name: 'Joe'}, {name: 'Matt'}];\n\npeople.getEach('name');\n// ['Joe', 'Matt'];\n\npeople.getEach('nonexistentProperty');\n// [undefined, undefined];\n```",
       "itemtype": "method",
       "name": "getEach",
@@ -11027,7 +10894,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 757,
+      "line": 556,
       "description": "Sets the value on the named property for each member. This is more\nergonomic than using other methods defined on this helper. If the object\nimplements Observable, the value will be changed to `set(),` otherwise\nit will be set directly. `null` objects are skipped.\n\n```javascript\nlet people = [{name: 'Joe'}, {name: 'Matt'}];\n\npeople.setEach('zipCode', '10011');\n// [{name: 'Joe', zipCode: '10011'}, {name: 'Matt', zipCode: '10011'}];\n```",
       "itemtype": "method",
       "name": "setEach",
@@ -11054,7 +10921,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 780,
+      "line": 579,
       "description": "Maps all of the items in the enumeration to another value, returning\na new array. This method corresponds to `map()` defined in JavaScript 1.6.\n\nThe callback method you provide should have the following signature (all\nparameters are optional):\n\n```javascript\nfunction(item, index, array);\nlet arr = [1, 2, 3, 4, 5, 6];\n\narr.map(element => element * element);\n// [1, 4, 9, 16, 25, 36];\n\narr.map((element, index) => element + index);\n// [1, 3, 5, 7, 9, 11];\n```\n\n- `item` is the current item in the iteration.\n- `index` is the current index in the iteration.\n- `array` is the array itself.\n\nIt should return the mapped value.\n\nNote that in addition to a callback, you can also pass an optional target\nobject that will be set as `this` on the context. This is a good way\nto give your iterator function access to the current object.",
       "itemtype": "method",
       "name": "map",
@@ -11082,7 +10949,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 824,
+      "line": 623,
       "description": "Similar to map, this specialized function returns the value of the named\nproperty on all items in the enumeration.\n\n```javascript\nlet people = [{name: 'Joe'}, {name: 'Matt'}];\n\npeople.mapBy('name');\n// ['Joe', 'Matt'];\n\npeople.mapBy('unknownProperty');\n// [undefined, undefined];\n```",
       "itemtype": "method",
       "name": "mapBy",
@@ -11104,7 +10971,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 845,
+      "line": 644,
       "description": "Returns a new array with all of the items in the enumeration that the provided\ncallback 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).\n\nThe callback method should have the following signature:\n\n```javascript\nfunction(item, index, array);\n```\n\n- `item` is the current item in the iteration.\n- `index` is the current index in the iteration.\n- `array` is the array itself.\n\nAll parameters are optional. The function should return `true` to include the item\nin the results, and `false` otherwise.\n\nExample:\n\n```javascript\nfunction isAdult(person) {\n  return person.age > 18;\n};\n\nlet people = Ember.A([{ name: 'John', age: 14 }, { name: 'Joan', age: 45 }]);\n\npeople.filter(isAdult); // returns [{ name: 'Joan', age: 45 }];\n```\n\nNote that in addition to a callback, you can pass an optional target object\nthat will be set as `this` on the context. This is a good way to give your\niterator function access to the current object. For example:\n\n```javascript\nfunction isAdultAndEngineer(person) {\n  return person.age > 18 && this.engineering;\n}\n\nclass AdultsCollection {\n  engineering = false;\n\n  constructor(opts = {}) {\n    super(...arguments);\n\n    this.engineering = opts.engineering;\n    this.people = Ember.A([{ name: 'John', age: 14 }, { name: 'Joan', age: 45 }]);\n  }\n}\n\nlet collection = new AdultsCollection({ engineering: true });\ncollection.people.filter(isAdultAndEngineer, { target: collection });\n```",
       "itemtype": "method",
       "name": "filter",
@@ -11132,7 +10999,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 918,
+      "line": 717,
       "description": "Returns an array with all of the items in the enumeration where the passed\nfunction returns false. This method is the inverse of filter().\n\nThe callback method you provide should have the following signature (all\nparameters are optional):\n\n```javascript\nfunction(item, index, array);\n```\n\n- *item* is the current item in the iteration.\n- *index* is the current index in the iteration\n- *array* is the array itself.\n\nIt should return a falsey value to include the item in the results.\n\nNote that in addition to a callback, you can also pass an optional target\nobject that will be set as \"this\" on the context. This is a good way\nto give your iterator function access to the current object.\n\nExample Usage:\n\n```javascript\nconst food = [\n  { food: 'apple', isFruit: true },\n  { food: 'bread', isFruit: false },\n  { food: 'banana', isFruit: true }\n];\nconst nonFruits = food.reject(function(thing) {\n  return thing.isFruit;\n}); // [{food: 'bread', isFruit: false}]\n```",
       "itemtype": "method",
       "name": "reject",
@@ -11160,7 +11027,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 965,
+      "line": 764,
       "description": "Filters the array by the property and an optional value. If a value is given, it returns\nthe items that have said value for the property. If not, it returns all the items that\nhave a truthy value for the property.\n\nExample Usage:\n\n```javascript\nlet things = Ember.A([{ food: 'apple', isFruit: true }, { food: 'beans', isFruit: false }]);\n\nthings.filterBy('food', 'beans'); // [{ food: 'beans', isFruit: false }]\nthings.filterBy('isFruit'); // [{ food: 'apple', isFruit: true }]\n```",
       "itemtype": "method",
       "name": "filterBy",
@@ -11188,7 +11055,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 989,
+      "line": 788,
       "description": "Returns an array with the items that do not have truthy values for the provided key.\nYou can pass an optional second argument with a target value to reject for the key.\nOtherwise this will reject objects where the provided property evaluates to false.\n\nExample Usage:\n\n```javascript\n  let food = [\n    { name: \"apple\", isFruit: true },\n    { name: \"carrot\", isFruit: false },\n    { name: \"bread\", isFruit: false },\n  ];\n  food.rejectBy('isFruit'); // [{ name: \"carrot\", isFruit: false }, { name: \"bread\", isFruit: false }]\n  food.rejectBy('name', 'carrot'); // [{ name: \"apple\", isFruit: true }}, { name: \"bread\", isFruit: false }]\n```",
       "itemtype": "method",
       "name": "rejectBy",
@@ -11216,7 +11083,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1016,
+      "line": 815,
       "description": "Returns the first item in the array for which the callback returns true.\nThis method is similar to the `find()` method defined in ECMAScript 2015.\n\nThe callback method you provide should have the following signature (all\nparameters are optional):\n\n```javascript\nfunction(item, index, array);\n```\n\n- `item` is the current item in the iteration.\n- `index` is the current index in the iteration.\n- `array` is the array itself.\n\nIt should return the `true` to include the item in the results, `false`\notherwise.\n\nNote that in addition to a callback, you can also pass an optional target\nobject that will be set as `this` on the context. This is a good way\nto give your iterator function access to the current object.\n\nExample Usage:\n\n```javascript\nlet users = [\n  { id: 1, name: 'Yehuda' },\n  { id: 2, name: 'Tom' },\n  { id: 3, name: 'Melanie' },\n  { id: 4, name: 'Leah' }\n];\n\nusers.find((user) => user.name == 'Tom'); // [{ id: 2, name: 'Tom' }]\nusers.find(({ id }) => id == 3); // [{ id: 3, name: 'Melanie' }]\n```",
       "itemtype": "method",
       "name": "find",
@@ -11244,7 +11111,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1063,
+      "line": 862,
       "description": "Returns the first item with a property matching the passed value. You\ncan pass an optional second argument with the target value. Otherwise\nthis will match any property that evaluates to `true`.\n\nThis method works much like the more generic `find()` method.\n\nUsage Example:\n\n```javascript\nlet users = [\n  { id: 1, name: 'Yehuda', isTom: false },\n  { id: 2, name: 'Tom', isTom: true },\n  { id: 3, name: 'Melanie', isTom: false },\n  { id: 4, name: 'Leah', isTom: false }\n];\n\nusers.findBy('id', 4); // { id: 4, name: 'Leah', isTom: false }\nusers.findBy('name', 'Melanie'); // { id: 3, name: 'Melanie', isTom: false }\nusers.findBy('isTom'); // { id: 2, name: 'Tom', isTom: true }\n```",
       "itemtype": "method",
       "name": "findBy",
@@ -11272,7 +11139,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1095,
+      "line": 894,
       "description": "Returns `true` if the passed function returns true for every item in the\nenumeration. This corresponds with the `Array.prototype.every()` method defined in ES5.\n\nThe callback method should have the following signature:\n\n```javascript\nfunction(item, index, array);\n```\n\n- `item` is the current item in the iteration.\n- `index` is the current index in the iteration.\n- `array` is the array itself.\n\nAll params are optional. The method should return `true` or `false`.\n\nNote that in addition to a callback, you can also pass an optional target\nobject that will be set as `this` on the context. This is a good way\nto give your iterator function access to the current object.\n\nUsage example:\n\n```javascript\nfunction isAdult(person) {\n  return person.age > 18;\n};\n\nconst people = Ember.A([{ name: 'John', age: 24 }, { name: 'Joan', age: 45 }]);\nconst areAllAdults = people.every(isAdult);\n```",
       "itemtype": "method",
       "name": "every",
@@ -11300,7 +11167,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1137,
+      "line": 936,
       "description": "Returns `true` if the passed property resolves to the value of the second\nargument for all items in the array. This method is often simpler/faster\nthan using a callback.\n\nNote that like the native `Array.every`, `isEvery` will return true when called\non any empty array.\n```javascript\nclass Language {\n  constructor(name, isProgrammingLanguage) {\n    this.name = name;\n    this.programmingLanguage = isProgrammingLanguage;\n  }\n}\n\nconst compiledLanguages = [\n  new Language('Java', true),\n  new Language('Go', true),\n  new Language('Rust', true)\n]\n\nconst languagesKnownByMe = [\n  new Language('Javascript', true),\n  new Language('English', false),\n  new Language('Ruby', true)\n]\n\ncompiledLanguages.isEvery('programmingLanguage'); // true\nlanguagesKnownByMe.isEvery('programmingLanguage'); // false\n```",
       "itemtype": "method",
       "name": "isEvery",
@@ -11329,7 +11196,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1179,
+      "line": 978,
       "description": "The any() method executes the callback function once for each element\npresent in the array until it finds the one where callback returns a truthy\nvalue (i.e. `true`). If such an element is found, any() immediately returns\ntrue. Otherwise, any() returns false.\n\n```javascript\nfunction(item, index, array);\n```\n\n- `item` is the current item in the iteration.\n- `index` is the current index in the iteration.\n- `array` is the array object itself.\n\nNote that in addition to a callback, you can also pass an optional target\nobject that will be set as `this` on the context. It can be a good way\nto give your iterator function access to an object in cases where an ES6\narrow function would not be appropriate.\n\nUsage Example:\n\n```javascript\nlet includesManager = people.any(this.findPersonInManagersList, this);\n\nlet includesStockHolder = people.any(person => {\n  return this.findPersonInStockHoldersList(person)\n});\n\nif (includesManager || includesStockHolder) {\n  Paychecks.addBiggerBonus();\n}\n```",
       "itemtype": "method",
       "name": "any",
@@ -11357,7 +11224,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1223,
+      "line": 1022,
       "description": "Returns `true` if the passed property resolves to the value of the second\nargument for any item in the array. This method is often simpler/faster\nthan using a callback.\n\nExample usage:\n\n```javascript\nconst food = [\n  { food: 'apple', isFruit: true },\n  { food: 'bread', isFruit: false },\n  { food: 'banana', isFruit: true }\n];\n\nfood.isAny('isFruit'); // true\n```",
       "itemtype": "method",
       "name": "isAny",
@@ -11386,7 +11253,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1251,
+      "line": 1050,
       "description": "This will combine the values of the array into a single value. It\nis a useful way to collect a summary value from an array. This\ncorresponds to the `reduce()` method defined in JavaScript 1.8.\n\nThe callback method you provide should have the following signature (all\nparameters are optional):\n\n```javascript\nfunction(previousValue, item, index, array);\n```\n\n- `previousValue` is the value returned by the last call to the iterator.\n- `item` is the current item in the iteration.\n- `index` is the current index in the iteration.\n- `array` is the array itself.\n\nReturn the new cumulative value.\n\nIn addition to the callback you can also pass an `initialValue`. An error\nwill be raised if you do not pass an initial value and the enumerator is\nempty.\n\nNote that unlike the other methods, this method does not allow you to\npass a target object to set as this for the callback. It's part of the\nspec. Sorry.\n\nExample Usage:\n\n```javascript\n  let numbers = [1, 2, 3, 4, 5];\n\n  numbers.reduce(function(summation, current) {\n    return summation + current;\n  }); // 15 (1 + 2 + 3 + 4 + 5)\n\n  numbers.reduce(function(summation, current) {\n    return summation + current;\n  }, -15); // 0 (-15 + 1 + 2 + 3 + 4 + 5)\n\n\n  let binaryValues = [true, false, false];\n\n  binaryValues.reduce(function(truthValue, current) {\n    return truthValue && current;\n  }); // false (true && false && false)\n```",
       "itemtype": "method",
       "name": "reduce",
@@ -11413,7 +11280,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1317,
+      "line": 1116,
       "description": "Invokes the named method on every object in the receiver that\nimplements it. This method corresponds to the implementation in\nPrototype 1.6.\n\n```javascript\nclass Person {\n  name = null;\n\n  constructor(name) {\n    this.name = name;\n  }\n\n  greet(prefix='Hello') {\n    return `${prefix} ${this.name}`;\n  }\n}\n\nlet people = [new Person('Joe'), new Person('Matt')];\n\npeople.invoke('greet'); // ['Hello Joe', 'Hello Matt']\npeople.invoke('greet', 'Bonjour'); // ['Bonjour Joe', 'Bonjour Matt']\n```",
       "itemtype": "method",
       "name": "invoke",
@@ -11440,7 +11307,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1355,
+      "line": 1154,
       "description": "Simply converts the object into a genuine array. The order is not\nguaranteed. Corresponds to the method implemented by Prototype.",
       "itemtype": "method",
       "name": "toArray",
@@ -11455,7 +11322,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1367,
+      "line": 1166,
       "description": "Returns a copy of the array with all `null` and `undefined` elements removed.\n\n```javascript\nlet arr = ['a', null, 'c', undefined];\narr.compact();  // ['a', 'c']\n```",
       "itemtype": "method",
       "name": "compact",
@@ -11470,7 +11337,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1383,
+      "line": 1182,
       "description": "Used to determine if the array contains the passed object.\nReturns `true` if found, `false` otherwise.\n\nThe optional `startAt` argument can be used to pass a starting\nindex to search from, effectively slicing the searchable portion\nof the array. If it's negative it will add the array length to\nthe startAt value passed in as the index to search from. If less\nthan or equal to `-1 * array.length` the entire array is searched.\n\nThis method has the same behavior of JavaScript's [Array.includes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes).\n\n```javascript\n[1, 2, 3].includes(2);     // true\n[1, 2, 3].includes(4);     // false\n[1, 2, 3].includes(3, 2);  // true\n[1, 2, 3].includes(3, 3);  // false\n[1, 2, 3].includes(3, -1); // true\n[1, 2, 3].includes(1, -1); // false\n[1, 2, 3].includes(1, -4); // true\n[1, 2, NaN].includes(NaN); // true\n```",
       "itemtype": "method",
       "name": "includes",
@@ -11497,7 +11364,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1416,
+      "line": 1215,
       "description": "Sorts the array by the keys specified in the argument.\n\nYou may provide multiple arguments to sort by multiple properties.\n\n```javascript\n   let colors = [\n { name: 'red', weight: 500 },\n { name: 'green', weight: 600 },\n { name: 'blue', weight: 500 }\n];\n\n   colors.sortBy('name');\n   // [{name: 'blue', weight: 500}, {name: 'green', weight: 600}, {name: 'red', weight: 500}]\n\n   colors.sortBy('weight', 'name');\n   // [{name: 'blue', weight: 500}, {name: 'red', weight: 500}, {name: 'green', weight: 600}]\n   ```",
       "itemtype": "method",
       "name": "sortBy",
@@ -11520,7 +11387,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1460,
+      "line": 1259,
       "description": "Returns a new array that contains only unique values. The default\nimplementation returns an array regardless of the receiver type.\n\n```javascript\nlet arr = ['a', 'a', 'b', 'b'];\narr.uniq();  // ['a', 'b']\n```\n\nThis only works on primitive data types, e.g. Strings, Numbers, etc.",
       "itemtype": "method",
       "name": "uniq",
@@ -11535,7 +11402,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1479,
+      "line": 1278,
       "description": "Returns a new array that contains only items containing a unique property value.\nThe default implementation returns an array regardless of the receiver type.\n\n```javascript\nlet arr = [{ value: 'a' }, { value: 'a' }, { value: 'b' }, { value: 'b' }];\narr.uniqBy('value');  // [{ value: 'a' }, { value: 'b' }]\n\nlet arr = [2.2, 2.1, 3.2, 3.3];\narr.uniqBy(Math.floor);  // [2.2, 3.2];\n```",
       "itemtype": "method",
       "name": "uniqBy",
@@ -11557,7 +11424,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1501,
+      "line": 1300,
       "description": "Returns a new array that excludes the passed value. The default\nimplementation returns an array regardless of the receiver type.\nIf the receiver does not contain the value it returns the original array.\n\n```javascript\nlet arr = ['a', 'b', 'a', 'c'];\narr.without('a');  // ['b', 'c']\n```",
       "itemtype": "method",
       "name": "without",
@@ -11579,8 +11446,8 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1549,
-      "description": "__Required.__ You must implement this method to apply this mixin.\n\nThis is one of the primitives you must implement to support `Array`.\nYou should replace amt objects started at idx with the objects in the\npassed array. You should also call `this.arrayContentDidChange()`\n\nNote that this method is expected to validate the type(s) of objects that it expects.",
+      "line": 1348,
+      "description": "__Required.__ You must implement this method to apply this mixin.\n\nThis is one of the primitives you must implement to support `Array`.\nYou should replace amt objects started at idx with the objects in the\npassed array.\n\nNote that this method is expected to validate the type(s) of objects that it expects.",
       "itemtype": "method",
       "name": "replace",
       "params": [
@@ -11607,7 +11474,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1568,
+      "line": 1367,
       "description": "Remove all elements from the array. This is useful if you\nwant to reuse an existing array without having to recreate it.\n\n```javascript\nlet colors = ['red', 'green', 'blue'];\n\ncolors.length;  // 3\ncolors.clear(); // []\ncolors.length;  // 0\n```",
       "itemtype": "method",
       "name": "clear",
@@ -11622,7 +11489,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1594,
+      "line": 1393,
       "description": "This will use the primitive `replace()` method to insert an object at the\nspecified index.\n\n```javascript\nlet colors = ['red', 'green', 'blue'];\n\ncolors.insertAt(2, 'yellow');  // ['red', 'green', 'yellow', 'blue']\ncolors.insertAt(5, 'orange');  // Error: Index out of range\n```",
       "itemtype": "method",
       "name": "insertAt",
@@ -11649,7 +11516,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1616,
+      "line": 1415,
       "description": "Remove an object at the specified index using the `replace()` primitive\nmethod. You can pass either a single index, or a start and a length.\n\nIf you pass a start and length that is beyond the\nlength this method will throw an assertion.\n\n```javascript\nlet colors = ['red', 'green', 'blue', 'yellow', 'orange'];\n\ncolors.removeAt(0);     // ['green', 'blue', 'yellow', 'orange']\ncolors.removeAt(2, 2);  // ['green', 'blue']\ncolors.removeAt(4, 2);  // Error: Index out of range\n```",
       "itemtype": "method",
       "name": "removeAt",
@@ -11676,7 +11543,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1641,
+      "line": 1440,
       "description": "Push the object onto the end of the array. Works just like `push()` but it\nis KVO-compliant.\n\n```javascript\nlet colors = ['red', 'green'];\n\ncolors.pushObject('black');     // ['red', 'green', 'black']\ncolors.pushObject(['yellow']);  // ['red', 'green', ['yellow']]\n```",
       "itemtype": "method",
       "name": "pushObject",
@@ -11697,7 +11564,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1661,
+      "line": 1460,
       "description": "Add the objects in the passed array to the end of the array. Defers\nnotifying observers of the change until all objects are added.\n\n```javascript\nlet colors = ['red'];\n\ncolors.pushObjects(['yellow', 'orange']);  // ['red', 'yellow', 'orange']\n```",
       "itemtype": "method",
       "name": "pushObjects",
@@ -11719,7 +11586,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1681,
+      "line": 1480,
       "description": "Pop object from array or nil if none are left. Works just like `pop()` but\nit is KVO-compliant.\n\n```javascript\nlet colors = ['red', 'green', 'blue'];\n\ncolors.popObject();   // 'blue'\nconsole.log(colors);  // ['red', 'green']\n```",
       "itemtype": "method",
       "name": "popObject",
@@ -11733,7 +11600,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1707,
+      "line": 1506,
       "description": "Shift an object from start of array or nil if none are left. Works just\nlike `shift()` but it is KVO-compliant.\n\n```javascript\nlet colors = ['red', 'green', 'blue'];\n\ncolors.shiftObject();  // 'red'\nconsole.log(colors);   // ['green', 'blue']\n```",
       "itemtype": "method",
       "name": "shiftObject",
@@ -11747,7 +11614,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1732,
+      "line": 1531,
       "description": "Unshift an object to start of array. Works just like `unshift()` but it is\nKVO-compliant.\n\n```javascript\nlet colors = ['red'];\n\ncolors.unshiftObject('yellow');    // ['yellow', 'red']\ncolors.unshiftObject(['black']);   // [['black'], 'yellow', 'red']\n```",
       "itemtype": "method",
       "name": "unshiftObject",
@@ -11768,7 +11635,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1752,
+      "line": 1551,
       "description": "Adds the named objects to the beginning of the array. Defers notifying\nobservers until all objects have been added.\n\n```javascript\nlet colors = ['red'];\n\ncolors.unshiftObjects(['black', 'white']);   // ['black', 'white', 'red']\ncolors.unshiftObjects('yellow'); // Type Error: 'undefined' is not a function\n```",
       "itemtype": "method",
       "name": "unshiftObjects",
@@ -11790,7 +11657,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1773,
+      "line": 1572,
       "description": "Reverse objects in the array. Works just like `reverse()` but it is\nKVO-compliant.",
       "itemtype": "method",
       "name": "reverseObjects",
@@ -11805,7 +11672,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1792,
+      "line": 1591,
       "description": "Replace all the receiver's content with content of the argument.\nIf argument is an empty array receiver will be cleared.\n\n```javascript\nlet colors = ['red', 'green', 'blue'];\n\ncolors.setObjects(['black', 'white']);  // ['black', 'white']\ncolors.setObjects([]);                  // []\n```",
       "itemtype": "method",
       "name": "setObjects",
@@ -11827,7 +11694,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1819,
+      "line": 1618,
       "description": "Remove all occurrences of an object in the array.\n\n```javascript\nlet cities = ['Chicago', 'Berlin', 'Lima', 'Chicago'];\n\ncities.removeObject('Chicago');  // ['Berlin', 'Lima']\ncities.removeObject('Lima');     // ['Berlin']\ncities.removeObject('Tokyo')     // ['Berlin']\n```",
       "itemtype": "method",
       "name": "removeObject",
@@ -11849,7 +11716,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1847,
+      "line": 1646,
       "description": "Removes each object in the passed array from the receiver.",
       "itemtype": "method",
       "name": "removeObjects",
@@ -11871,7 +11738,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1864,
+      "line": 1663,
       "description": "Push the object onto the end of the array if it is not already\npresent in the array.\n\n```javascript\nlet cities = ['Chicago', 'Berlin'];\n\ncities.addObject('Lima');    // ['Chicago', 'Berlin', 'Lima']\ncities.addObject('Berlin');  // ['Chicago', 'Berlin', 'Lima']\n```",
       "itemtype": "method",
       "name": "addObject",
@@ -11893,7 +11760,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1890,
+      "line": 1689,
       "description": "Adds each object in the passed array to the receiver.",
       "itemtype": "method",
       "name": "addObjects",
@@ -11915,7 +11782,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/array.js",
-      "line": 1906,
+      "line": 1705,
       "description": "Creates an `Ember.NativeArray` from an Array-like object.\nDoes not modify the original object's contents. `A()` is not needed if\n`EmberENV.EXTEND_PROTOTYPES` is `true` (the default value). However,\nit is recommended that you use `A()` when creating addons for\nember or when you can not guarantee that `EmberENV.EXTEND_PROTOTYPES`\nwill be `true`.\n\nExample\n\n```app/components/my-component.js\nimport Component from '@ember/component';\nimport { A } from '@ember/array';\n\nexport default Component.extend({\n  tagName: 'ul',\n  classNames: ['pagination'],\n\n  init() {\n    this._super(...arguments);\n\n    if (!this.get('content')) {\n      this.set('content', A());\n      this.set('otherContent', A([1,2,3]));\n    }\n  }\n});\n```",
       "itemtype": "method",
       "name": "A",
@@ -12917,7 +12784,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/system/array_proxy.js",
-      "line": 140,
+      "line": 141,
       "description": "The content array. Must be an object that implements `Array` and/or\n`MutableArray.`",
       "itemtype": "property",
       "name": "content",
@@ -12929,7 +12796,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/system/array_proxy.js",
-      "line": 149,
+      "line": 150,
       "description": "Should actually retrieve the object at the specified index from the\ncontent. You can override this method in subclasses to transform the\ncontent item to something new.\n\nThis method will only be called if content is non-`null`.",
       "itemtype": "method",
       "name": "objectAtContent",
@@ -12951,7 +12818,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/system/array_proxy.js",
-      "line": 175,
+      "line": 176,
       "description": "Should actually replace the specified objects on the content array.\nYou can override this method in subclasses to transform the content item\ninto something new.\n\nThis method will only be called if content is non-`null`.",
       "itemtype": "method",
       "name": "replaceContent",
@@ -12983,7 +12850,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/system/array_proxy.js",
-      "line": 345,
+      "line": 346,
       "description": "The array that the proxy pretends to be. In the default `ArrayProxy`\nimplementation, this and `content` are the same. Subclasses of `ArrayProxy`\ncan override this property to provide things like sorting and filtering.",
       "itemtype": "property",
       "name": "arrangedContent",