ember-source 4.9.0-alpha.2 → 4.9.0-alpha.4

package/dist/ember.debug.js

@@ -6,7 +6,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   4.9.0-alpha.2
+ * @version   4.9.0-alpha.4
  */
 /* eslint-disable no-var */
 
@@ -364,7 +364,7 @@ define("@ember/-internals/container/index", ["exports", "@ember/-internals/owner
   function wrapManagerInDeprecationProxy(manager) {
     var validator = {
       set(_obj, prop) {
-        throw new Error(`You attempted to set "${prop}" on a factory manager created by container#factoryFor. A factory manager is a read-only construct.`);
+        throw new Error(`You attempted to set "${String(prop)}" on a factory manager created by container#factoryFor. A factory manager is a read-only construct.`);
       }
 
     }; // Note:
@@ -4153,7 +4153,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       (true && !(_element !== null) && (0, _debug.assert)(`Cannot call \`readDOMAttr\` on ${this} which does not have an element`, _element !== null));
       var element = _element;
       var isSVG = element.namespaceURI === "http://www.w3.org/2000/svg"
-      /* SVG */
+      /* Namespace.SVG */
       ;
       var {
         type,
@@ -6254,7 +6254,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
         (true && !(owner.hasRegistration(`engine:${name}`)) && (0, _debug.assert)(`You used \`{{mount '${name}'}}\`, but the engine '${name}' can not be found.`, owner.hasRegistration(`engine:${name}`)));
         lastName = name;
         lastDef = (0, _runtime.curry)(0
-        /* Component */
+        /* CurriedType.Component */
         , new MountDefinition(name), owner, captured, true);
         return lastDef;
       } else {
@@ -6337,7 +6337,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
 
           var args = (0, _runtime.createCapturedArgs)(named, _runtime.EMPTY_POSITIONAL);
           definition = (0, _runtime.curry)(0
-          /* Component */
+          /* CurriedType.Component */
           , new OutletComponentDefinition(state), (_b = (_a = outletState === null || outletState === void 0 ? void 0 : outletState.render) === null || _a === void 0 ? void 0 : _a.owner) !== null && _b !== void 0 ? _b : owner, args, true);
         } else {
           definition = null;
@@ -6965,7 +6965,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       var definition = createRootOutlet(view);
 
       this._appendDefinition(view, (0, _runtime.curry)(0
-      /* Component */
+      /* CurriedType.Component */
       , definition, view.owner, null, true), target);
     }
 
@@ -6973,7 +6973,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       var definition = new RootComponentDefinition(view);
 
       this._appendDefinition(view, (0, _runtime.curry)(0
-      /* Component */
+      /* CurriedType.Component */
       , definition, this._owner, null, true), target);
     }
 
@@ -7742,9 +7742,9 @@ define("@ember/-internals/meta/lib/meta", ["exports", "@ember/-internals/utils",
       }
 
       this.pushListener(eventName, target, method, once ? 1
-      /* ONCE */
+      /* ListenerKind.ONCE */
       : 0
-      /* ADD */
+      /* ListenerKind.ADD */
       , sync);
     }
     /** @internal */
@@ -7758,7 +7758,7 @@ define("@ember/-internals/meta/lib/meta", ["exports", "@ember/-internals/utils",
       }
 
       this.pushListener(eventName, target, method, 2
-      /* REMOVE */
+      /* ListenerKind.REMOVE */
       );
     }
 
@@ -7782,7 +7782,7 @@ define("@ember/-internals/meta/lib/meta", ["exports", "@ember/-internals/utils",
       if (i === -1) {
         (true && !(!(this.isPrototypeMeta(this.source) && typeof method === 'function')) && (0, _debug.assert)('You cannot add function listeners to prototypes. Convert the listener to a string listener, or add it to the instance instead.', !(this.isPrototypeMeta(this.source) && typeof method === 'function')));
         (true && !(!(!this.isPrototypeMeta(this.source) && typeof method === 'function' && kind === 2
-        /* REMOVE */
+        /* ListenerKind.REMOVE */
         )) && (0, _debug.assert)('You attempted to remove a function listener which did not exist on the instance, which means you may have attempted to remove it before it was added.', !(!this.isPrototypeMeta(this.source) && typeof method === 'function' && kind === 2)));
         listeners.push({
           event,
@@ -7797,16 +7797,16 @@ define("@ember/-internals/meta/lib/meta", ["exports", "@ember/-internals/utils",
         // want to splice it out entirely so we don't hold onto a reference.
 
         if (kind === 2
-        /* REMOVE */
+        /* ListenerKind.REMOVE */
         && listener.kind !== 2
-        /* REMOVE */
+        /* ListenerKind.REMOVE */
         ) {
           listeners.splice(i, 1);
         } else {
           (true && !(!(listener.kind === 0
-          /* ADD */
+          /* ListenerKind.ADD */
           && kind === 0
-          /* ADD */
+          /* ListenerKind.ADD */
           && listener.sync !== sync)) && (0, _debug.assert)(`You attempted to add an observer for the same method on '${event.split(':')[0]}' twice to ${target} as both sync and async. Observers must be either sync or async, they cannot be both. This is likely a mistake, you should either remove the code that added the observer a second time, or update it to always be sync or async. The method was ${String(method)}.`, !(listener.kind === 0 && kind === 0 && listener.sync !== sync))); // update own listener
 
           listener.kind = kind;
@@ -7933,9 +7933,9 @@ define("@ember/-internals/meta/lib/meta", ["exports", "@ember/-internals/utils",
           // REMOVE listeners are placeholders that tell us not to
           // inherit, so they never match. Only ADD and ONCE can match.
           if (listener.event === eventName && (listener.kind === 0
-          /* ADD */
+          /* ListenerKind.ADD */
           || listener.kind === 1
-          /* ONCE */
+          /* ListenerKind.ONCE */
           )) {
             if (result === undefined) {
               // we create this array only after we've found a listener that
@@ -7944,7 +7944,7 @@ define("@ember/-internals/meta/lib/meta", ["exports", "@ember/-internals/utils",
             }
 
             result.push(listener.target, listener.method, listener.kind === 1
-            /* ONCE */
+            /* ListenerKind.ONCE */
             );
           }
         }
@@ -7970,9 +7970,9 @@ define("@ember/-internals/meta/lib/meta", ["exports", "@ember/-internals/utils",
           // REMOVE listeners are placeholders that tell us not to
           // inherit, so they never match. Only ADD and ONCE can match.
           if ((listener.kind === 0
-          /* ADD */
+          /* ListenerKind.ADD */
           || listener.kind === 1
-          /* ONCE */
+          /* ListenerKind.ONCE */
           ) && listener.event.indexOf(':change') !== -1) {
             if (result === undefined) {
               // we create this array only after we've found a listener that
@@ -16441,65 +16441,10 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       (0, _utils.setEmberArray)(this);
     },
 
-    /**
-      __Required.__ You must implement this method to apply this mixin.
-         Your array must support the `length` property. Your replace methods should
-      set this property whenever it changes.
-         @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`.
-      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
-      let arr = ['a', 'b', 'c', 'd'];
-         arr.objectAt(0);   // 'a'
-      arr.objectAt(3);   // 'd'
-      arr.objectAt(-1);  // undefined
-      arr.objectAt(4);   // undefined
-      arr.objectAt(5);   // undefined
-      ```
-         @method objectAt
-      @param {Number} idx The index of the item to return.
-      @return {*} item at index or undefined
-      @public
-    */
-
-    /**
-      This returns the objects at the specified indexes, using `objectAt`.
-         ```javascript
-      let arr = ['a', 'b', 'c', 'd'];
-         arr.objectsAt([0, 1, 2]);  // ['a', 'b', 'c']
-      arr.objectsAt([2, 3, 4]);  // ['c', 'd', undefined]
-      ```
-         @method objectsAt
-      @param {Array} indexes An array of indexes of items to return.
-      @return {Array}
-      @public
-     */
     objectsAt(indexes) {
       return indexes.map(idx => (0, _metal.objectAt)(this, idx));
     },
 
-    /**
-      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
-      let peopleToMoon = ['Armstrong', 'Aldrin'];
-         peopleToMoon.get('[]'); // ['Armstrong', 'Aldrin']
-         peopleToMoon.set('[]', ['Collins']); // ['Collins']
-      peopleToMoon.get('[]'); // ['Collins']
-      ```
-         @property []
-      @return this
-      @public
-    */
     '[]': nonEnumerableComputed({
       get() {
         return this;
@@ -16511,55 +16456,14 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       }
 
     }),
-
-    /**
-      The first object in the array, or `undefined` if the array is empty.
-         ```javascript
-      let vowels = ['a', 'e', 'i', 'o', 'u'];
-      vowels.firstObject; // 'a'
-         vowels.shiftObject();
-      vowels.firstObject; // 'e'
-         vowels.reverseObjects();
-      vowels.firstObject; // 'u'
-         vowels.clear();
-      vowels.firstObject; // undefined
-      ```
-         @property firstObject
-      @return {Object | undefined} The first object in the array
-      @public
-    */
     firstObject: nonEnumerableComputed(function () {
       return (0, _metal.objectAt)(this, 0);
     }).readOnly(),
-
-    /**
-      The last object in the array, or `undefined` if the array is empty.
-         @property lastObject
-      @return {Object | undefined} The last object in the array
-      @public
-    */
     lastObject: nonEnumerableComputed(function () {
       return (0, _metal.objectAt)(this, this.length - 1);
     }).readOnly(),
 
     // Add any extra methods to EmberArray that are native to the built-in Array.
-
-    /**
-      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
-      let arr = ['red', 'green', 'blue'];
-         arr.slice(0);       // ['red', 'green', 'blue']
-      arr.slice(0, 2);    // ['red', 'green']
-      arr.slice(1, 100);  // ['green', 'blue']
-      ```
-         @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
-      @public
-    */
     slice(beginIndex, endIndex) {
       if (beginIndex === void 0) {
         beginIndex = 0;
@@ -16589,70 +16493,10 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return ret;
     },
 
-    /**
-      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
-      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
-      let arr = ['a', 'b', 'c', 'd', 'a'];
-         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 newPerson = { name: 'Tom' };
-      people = [newPerson, ...people, newPerson];
-         people.indexOf(newPerson);     //  0
-      people.indexOf(newPerson, 1);  //  3
-      people.indexOf(newPerson, -4); //  0
-      people.indexOf(newPerson, 10); // -1
-      ```
-         @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
-      @public
-    */
     indexOf(object, startAt) {
       return indexOf(this, object, startAt, false);
     },
 
-    /**
-      Returns the index of the given `object`'s last occurrence.
-         - 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.
-      - If it's negative, it is taken as the offset from the end
-      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
-      let arr = ['a', 'b', 'c', 'd', 'a'];
-         arr.lastIndexOf('a');       //  4
-      arr.lastIndexOf('z');       // -1
-      arr.lastIndexOf('a', 2);    //  0
-      arr.lastIndexOf('a', -1);   //  4
-      arr.lastIndexOf('a', -3);   //  0
-      arr.lastIndexOf('b', 3);    //  1
-      arr.lastIndexOf('a', 100);  //  4
-      ```
-         @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)`
-      @return {Number} The last index of the `object` in the array or -1
-      if not found
-      @public
-    */
     lastIndexOf(object, startAt) {
       var len = this.length;
 
@@ -16673,44 +16517,6 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return -1;
     },
 
-    /**
-      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
-      parameters are optional):
-         ```javascript
-      function(item, index, array);
-      ```
-         - `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
-      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
-      let foods = [
-        { name: 'apple', eaten: false },
-        { name: 'banana', eaten: false },
-        { name: 'carrot', eaten: false }
-      ];
-         foods.forEach((food) => food.eaten = true);
-         let output = '';
-      foods.forEach((item, index, array) =>
-        output += `${index + 1}/${array.length} ${item.name}\n`;
-      );
-      console.log(output);
-      // 1/3 apple
-      // 2/3 banana
-      // 3/3 carrot
-      ```
-         @method forEach
-      @param {Function} callback The callback to execute
-      @param {Object} [target] The target object to use
-      @return {Object} receiver
-      @public
-    */
     forEach(callback, target) {
       if (target === void 0) {
         target = null;
@@ -16727,70 +16533,12 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return this;
     },
 
-    /**
-      Alias for `mapBy`.
-         Returns the value of the named
-      property on all items in the enumeration.
-         ```javascript
-      let people = [{name: 'Joe'}, {name: 'Matt'}];
-         people.getEach('name');
-      // ['Joe', 'Matt'];
-         people.getEach('nonexistentProperty');
-      // [undefined, undefined];
-      ```
-         @method getEach
-      @param {String} key name of the property
-      @return {Array} The mapped array.
-      @public
-    */
     getEach: mapBy,
 
-    /**
-      Sets the value on the named property for each member. This is more
-      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
-      let people = [{name: 'Joe'}, {name: 'Matt'}];
-         people.setEach('zipCode', '10011');
-      // [{name: 'Joe', zipCode: '10011'}, {name: 'Matt', zipCode: '10011'}];
-      ```
-         @method setEach
-      @param {String} key The key to set
-      @param {Object} value The object to set
-      @return {Object} receiver
-      @public
-    */
     setEach(key, value) {
       return this.forEach(item => (0, _object.set)(item, key, value));
     },
 
-    /**
-      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
-      parameters are optional):
-         ```javascript
-      function(item, index, array);
-      let arr = [1, 2, 3, 4, 5, 6];
-         arr.map(element => element * element);
-      // [1, 4, 9, 16, 25, 36];
-         arr.map((element, index) => element + index);
-      // [1, 3, 5, 7, 9, 11];
-      ```
-         - `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
-      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
-      @param {Function} callback The callback to execute
-      @param {Object} [target] The target object to use
-      @return {Array} The mapped array.
-      @public
-    */
     map(callback, target) {
       if (target === void 0) {
         target = null;
@@ -16802,67 +16550,8 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return ret;
     },
 
-    /**
-      Similar to map, this specialized function returns the value of the named
-      property on all items in the enumeration.
-         ```javascript
-      let people = [{name: 'Joe'}, {name: 'Matt'}];
-         people.mapBy('name');
-      // ['Joe', 'Matt'];
-         people.mapBy('unknownProperty');
-      // [undefined, undefined];
-      ```
-         @method mapBy
-      @param {String} key name of the property
-      @return {Array} The mapped array.
-      @public
-    */
     mapBy,
 
-    /**
-      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
-      function(item, index, array);
-      ```
-         - `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
-      in the results, and `false` otherwise.
-         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 }];
-      ```
-         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
-      function isAdultAndEngineer(person) {
-        return person.age > 18 && this.engineering;
-      }
-         class AdultsCollection {
-        engineering = false;
-           constructor(opts = {}) {
-          super(...arguments);
-             this.engineering = opts.engineering;
-          this.people = Ember.A([{ name: 'John', age: 14 }, { name: 'Joan', age: 45 }]);
-        }
-      }
-         let collection = new AdultsCollection({ engineering: true });
-      collection.people.filter(isAdultAndEngineer, { target: collection });
-      ```
-         @method filter
-      @param {Function} callback The callback to execute
-      @param {Object} [target] The target object to use
-      @return {Array} A filtered array.
-      @public
-    */
     filter(callback, target) {
       if (target === void 0) {
         target = null;
@@ -16878,38 +16567,6 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return ret;
     },
 
-    /**
-      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
-      parameters are optional):
-         ```javascript
-      function(item, index, array);
-      ```
-         - *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
-      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
-      const food = [
-        { food: 'apple', isFruit: true },
-        { food: 'bread', isFruit: false },
-        { food: 'banana', isFruit: true }
-      ];
-      const nonFruits = food.reject(function(thing) {
-        return thing.isFruit;
-      }); // [{food: 'bread', isFruit: false}]
-      ```
-         @method reject
-      @param {Function} callback The callback to execute
-      @param {Object} [target] The target object to use
-      @return {Array} A rejected array.
-      @public
-    */
     reject(callback, target) {
       if (target === void 0) {
         target = null;
@@ -16922,85 +16579,16 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       });
     },
 
-    /**
-      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
-      let things = Ember.A([{ food: 'apple', isFruit: true }, { food: 'beans', isFruit: false }]);
-         things.filterBy('food', 'beans'); // [{ food: 'beans', isFruit: false }]
-      things.filterBy('isFruit'); // [{ food: 'apple', isFruit: true }]
-      ```
-         @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));
     },
 
-    /**
-      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
-        let food = [
-          { name: "apple", isFruit: true },
-          { name: "carrot", isFruit: false },
-          { name: "bread", isFruit: false },
-        ];
-        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
-      @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
-      parameters are optional):
-         ```javascript
-      function(item, index, array);
-      ```
-         - `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`
-      otherwise.
-         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
-      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(({ id }) => id == 3); // [{ id: 3, name: 'Melanie' }]
-      ```
-         @method find
-      @param {Function} callback The callback to execute
-      @param {Object} [target] The target object to use
-      @return {Object} Found item or `undefined`.
-      @public
-    */
     find(callback, target) {
       if (target === void 0) {
         target = null;
@@ -17010,63 +16598,12 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return find(this, callback, target);
     },
 
-    /**
-      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
-      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('name', 'Melanie'); // { id: 3, name: 'Melanie', isTom: false }
-      users.findBy('isTom'); // { id: 2, name: 'Tom', isTom: true }
-      ```
-         @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() {
       // @ts-expect-error TS doesn't like the ...arguments spread here.
       var callback = iter(...arguments);
       return find(this, callback);
     },
 
-    /**
-      Returns `true` if the passed function returns true for every item in the
-      enumeration. This corresponds with the `Array.prototype.every()` method defined in ES5.
-         The callback method should have the following signature:
-         ```javascript
-      function(item, index, array);
-      ```
-         - `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
-      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
-      function isAdult(person) {
-        return person.age > 18;
-      };
-         const people = Ember.A([{ name: 'John', age: 24 }, { name: 'Joan', age: 45 }]);
-      const areAllAdults = people.every(isAdult);
-      ```
-         @method every
-      @param {Function} callback The callback to execute
-      @param {Object} [target] The target object to use
-      @return {Boolean}
-      @public
-    */
     every(callback, target) {
       if (target === void 0) {
         target = null;
@@ -17076,76 +16613,12 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return every(this, callback, target);
     },
 
-    /**
-      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
-      on any empty array.
-      ```javascript
-      class Language {
-        constructor(name, isProgrammingLanguage) {
-          this.name = name;
-          this.programmingLanguage = isProgrammingLanguage;
-        }
-      }
-         const compiledLanguages = [
-        new Language('Java', true),
-        new Language('Go', true),
-        new Language('Rust', true)
-      ]
-         const languagesKnownByMe = [
-        new Language('Javascript', true),
-        new Language('English', false),
-        new Language('Ruby', true)
-      ]
-         compiledLanguages.isEvery('programmingLanguage'); // true
-      languagesKnownByMe.isEvery('programmingLanguage'); // false
-      ```
-         @method isEvery
-      @param {String} key the property to test
-      @param {String} [value] optional value to test against. Defaults to `true`
-      @return {Boolean}
-      @since 1.3.0
-      @public
-    */
     isEvery() {
       // @ts-expect-error TS doesn't like the ...arguments spread here.
       var callback = iter(...arguments);
       return every(this, callback);
     },
 
-    /**
-      The any() method executes the callback function once for each element
-      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
-      function(item, index, array);
-      ```
-         - `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
-      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
-      let includesManager = people.any(this.findPersonInManagersList, this);
-         let includesStockHolder = people.any(person => {
-        return this.findPersonInStockHoldersList(person)
-      });
-         if (includesManager || includesStockHolder) {
-        Paychecks.addBiggerBonus();
-      }
-      ```
-         @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
-      @public
-    */
     any(callback, target) {
       if (target === void 0) {
         target = null;
@@ -17155,73 +16628,12 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return any(this, callback, target);
     },
 
-    /**
-      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
-      const food = [
-        { food: 'apple', isFruit: true },
-        { food: 'bread', isFruit: false },
-        { food: 'banana', isFruit: true }
-      ];
-         food.isAny('isFruit'); // true
-      ```
-         @method isAny
-      @param {String} key the property to test
-      @param {String} [value] optional value to test against. Defaults to `true`
-      @return {Boolean}
-      @since 1.3.0
-      @public
-    */
     isAny() {
       // @ts-expect-error TS doesn't like us using arguments like this
       var callback = iter(...arguments);
       return any(this, callback);
     },
 
-    /**
-      This will combine the values of the array into a single value. It
-      is a useful way to collect a summary value from an array. This
-      corresponds to the `reduce()` method defined in JavaScript 1.8.
-         The callback method you provide should have the following signature (all
-      parameters are optional):
-         ```javascript
-      function(previousValue, item, index, array);
-      ```
-         - `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
-      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
-      pass a target object to set as this for the callback. It's part of the
-      spec. Sorry.
-         Example Usage:
-         ```javascript
-        let numbers = [1, 2, 3, 4, 5];
-           numbers.reduce(function(summation, current) {
-          return summation + current;
-        }); // 15 (1 + 2 + 3 + 4 + 5)
-           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) {
-          return truthValue && current;
-        }); // false (true && false && false)
-      ```
-         @method reduce
-      @param {Function} callback The callback to execute
-      @param {Object} initialValue Initial value for the reduce
-      @return {Object} The reduced value.
-      @public
-    */
     // FIXME: When called without initialValue, behavior does not match native behavior
     reduce(callback, initialValue) {
       (true && !(typeof callback === 'function') && (0, _debug.assert)('`reduce` expects a function as first argument.', typeof callback === 'function'));
@@ -17232,30 +16644,6 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return ret;
     },
 
-    /**
-      Invokes the named method on every object in the receiver that
-      implements it. This method corresponds to the implementation in
-      Prototype 1.6.
-         ```javascript
-      class Person {
-        name = null;
-           constructor(name) {
-          this.name = name;
-        }
-           greet(prefix='Hello') {
-          return `${prefix} ${this.name}`;
-        }
-      }
-         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
-      @param {String} methodName the name of the method
-      @param {Object...} args optional arguments to pass as well.
-      @return {Array} return values from calling invoke.
-      @public
-    */
     invoke(methodName) {
       for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key3 = 1; _key3 < _len2; _key3++) {
         args[_key3 - 1] = arguments[_key3];
@@ -17271,80 +16659,18 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return ret;
     },
 
-    /**
-      Simply converts the object into a genuine array. The order is not
-      guaranteed. Corresponds to the method implemented by Prototype.
-         @method toArray
-      @return {Array} the object as an array.
-      @public
-    */
     toArray() {
       return this.map(item => item);
     },
 
-    /**
-      Returns a copy of the array with all `null` and `undefined` elements removed.
-         ```javascript
-      let arr = ['a', null, 'c', undefined];
-      arr.compact();  // ['a', 'c']
-      ```
-         @method compact
-      @return {Array} the array without null and undefined elements.
-      @public
-    */
     compact() {
       return this.filter(value => value != null);
     },
 
-    /**
-      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
-      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
-      [1, 2, 3].includes(2);     // true
-      [1, 2, 3].includes(4);     // false
-      [1, 2, 3].includes(3, 2);  // true
-      [1, 2, 3].includes(3, 3);  // false
-      [1, 2, 3].includes(3, -1); // true
-      [1, 2, 3].includes(1, -1); // false
-      [1, 2, 3].includes(1, -4); // true
-      [1, 2, NaN].includes(NaN); // true
-      ```
-         @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.
-      @public
-    */
     includes(object, startAt) {
       return indexOf(this, object, startAt, true) !== -1;
     },
 
-    /**
-      Sorts the array by the keys specified in the argument.
-         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');
-     // [{name: 'blue', weight: 500}, {name: 'green', weight: 600}, {name: 'red', weight: 500}]
-        colors.sortBy('weight', 'name');
-     // [{name: 'blue', weight: 500}, {name: 'red', weight: 500}, {name: 'green', weight: 600}]
-     ```
-         @method sortBy
-      @param {String} property name(s) to sort on
-      @return {Array} The sorted array.
-      @since 1.2.0
-      @public
-    */
     sortBy() {
       var sortKeys = arguments;
       return this.toArray().sort((a, b) => {
@@ -17364,53 +16690,14 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       });
     },
 
-    /**
-      Returns a new array that contains only unique values. The default
-      implementation returns an array regardless of the receiver type.
-         ```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
-      @return {EmberArray}
-      @public
-    */
     uniq() {
       return uniqBy(this);
     },
 
-    /**
-      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
-      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];
-      arr.uniqBy(Math.floor);  // [2.2, 3.2];
-      ```
-         @method uniqBy
-      @param {String,Function} key
-      @return {EmberArray}
-      @public
-    */
     uniqBy(key) {
       return uniqBy(this, key);
     },
 
-    /**
-      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
-      let arr = ['a', 'b', 'a', 'c'];
-      arr.without('a');  // ['b', 'c']
-      ```
-         @method without
-      @param {Object} value
-      @return {EmberArray}
-      @public
-    */
     without(value) {
       if (!this.includes(value)) {
         return this; // nothing to do
@@ -17424,35 +16711,6 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
   });
 
   var MutableArray = _mixin.default.create(EmberArray, _mutable.default, {
-    /**
-      __Required.__ You must implement this method to apply this mixin.
-         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
-      @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
-        the array, starting at *idx*.
-      @param {EmberArray} [objects] An optional array of zero or more objects that should be
-        inserted into the array at *idx*
-      @public
-    */
-
-    /**
-      Remove all elements from the array. This is useful if you
-      want to reuse an existing array without having to recreate it.
-         ```javascript
-      let colors = ['red', 'green', 'blue'];
-         colors.length;  // 3
-      colors.clear(); // []
-      colors.length;  // 0
-      ```
-         @method clear
-      @return {Array} An empty Array.
-      @public
-    */
     clear() {
       var len = this.length;
 
@@ -17464,92 +16722,24 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return this;
     },
 
-    /**
-      This will use the primitive `replace()` method to insert an object at the
-      specified index.
-         ```javascript
-      let colors = ['red', 'green', 'blue'];
-         colors.insertAt(2, 'yellow');  // ['red', 'green', 'yellow', 'blue']
-      colors.insertAt(5, 'orange');  // Error: Index out of range
-      ```
-         @method insertAt
-      @param {Number} idx index of insert the object at.
-      @param {Object} object object to insert
-      @return {EmberArray} receiver
-      @public
-    */
     insertAt(idx, object) {
       insertAt(this, idx, object);
       return this;
     },
 
-    /**
-      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
-      length this method will throw an assertion.
-         ```javascript
-      let colors = ['red', '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
-      @param {Number} start index, start of range
-      @param {Number} len length of passing range
-      @return {EmberArray} receiver
-      @public
-    */
     removeAt(start, len) {
       return removeAt(this, start, len);
     },
 
-    /**
-      Push the object onto the end of the array. Works just like `push()` but it
-      is KVO-compliant.
-         ```javascript
-      let colors = ['red', 'green'];
-         colors.pushObject('black');     // ['red', 'green', 'black']
-      colors.pushObject(['yellow']);  // ['red', 'green', ['yellow']]
-      ```
-         @method pushObject
-      @param {*} obj object to push
-      @return object same object passed as a param
-      @public
-    */
     pushObject(obj) {
       return insertAt(this, this.length, obj);
     },
 
-    /**
-      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
-      let colors = ['red'];
-         colors.pushObjects(['yellow', 'orange']);  // ['red', 'yellow', 'orange']
-      ```
-         @method pushObjects
-      @param {Array} objects the objects to add
-      @return {MutableArray} receiver
-      @public
-    */
     pushObjects(objects) {
       this.replace(this.length, 0, objects);
       return this;
     },
 
-    /**
-      Pop object from array or nil if none are left. Works just like `pop()` but
-      it is KVO-compliant.
-         ```javascript
-      let colors = ['red', 'green', 'blue'];
-         colors.popObject();   // 'blue'
-      console.log(colors);  // ['red', 'green']
-      ```
-         @method popObject
-      @return object
-      @public
-    */
     popObject() {
       var len = this.length;
 
@@ -17562,18 +16752,6 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return ret;
     },
 
-    /**
-      Shift an object from start of array or nil if none are left. Works just
-      like `shift()` but it is KVO-compliant.
-         ```javascript
-      let colors = ['red', 'green', 'blue'];
-         colors.shiftObject();  // 'red'
-      console.log(colors);   // ['green', 'blue']
-      ```
-         @method shiftObject
-      @return object
-      @public
-    */
     shiftObject() {
       if (this.length === 0) {
         return null;
@@ -17584,48 +16762,15 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return ret;
     },
 
-    /**
-      Unshift an object to start of array. Works just like `unshift()` but it is
-      KVO-compliant.
-         ```javascript
-      let colors = ['red'];
-         colors.unshiftObject('yellow');    // ['yellow', 'red']
-      colors.unshiftObject(['black']);   // [['black'], 'yellow', 'red']
-      ```
-         @method unshiftObject
-      @param {*} obj object to unshift
-      @return object same object passed as a param
-      @public
-    */
     unshiftObject(obj) {
       return insertAt(this, 0, obj);
     },
 
-    /**
-      Adds the named objects to the beginning of the array. Defers notifying
-      observers until all objects have been added.
-         ```javascript
-      let colors = ['red'];
-         colors.unshiftObjects(['black', 'white']);   // ['black', 'white', 'red']
-      colors.unshiftObjects('yellow'); // Type Error: 'undefined' is not a function
-      ```
-         @method unshiftObjects
-      @param {Enumerable} objects the objects to add
-      @return {EmberArray} receiver
-      @public
-    */
     unshiftObjects(objects) {
       this.replace(0, 0, objects);
       return this;
     },
 
-    /**
-      Reverse objects in the array. Works just like `reverse()` but it is
-      KVO-compliant.
-         @method reverseObjects
-      @return {EmberArray} receiver
-       @public
-    */
     reverseObjects() {
       var len = this.length;
 
@@ -17638,20 +16783,6 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return this;
     },
 
-    /**
-      Replace all the receiver's content with content of the argument.
-      If argument is an empty array receiver will be cleared.
-         ```javascript
-      let colors = ['red', 'green', 'blue'];
-         colors.setObjects(['black', 'white']);  // ['black', 'white']
-      colors.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
-      @public
-    */
     setObjects(objects) {
       if (objects.length === 0) {
         return this.clear();
@@ -17662,19 +16793,6 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return this;
     },
 
-    /**
-      Remove all occurrences of an object in the array.
-         ```javascript
-      let cities = ['Chicago', 'Berlin', 'Lima', 'Chicago'];
-         cities.removeObject('Chicago');  // ['Berlin', 'Lima']
-      cities.removeObject('Lima');     // ['Berlin']
-      cities.removeObject('Tokyo')     // ['Berlin']
-      ```
-         @method removeObject
-      @param {*} obj object to remove
-      @return {EmberArray} receiver
-      @public
-    */
     removeObject(obj) {
       var loc = this.length || 0;
 
@@ -17689,13 +16807,6 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return this;
     },
 
-    /**
-      Removes each object in the passed array from the receiver.
-         @method removeObjects
-      @param {EmberArray} objects the objects to remove
-      @return {EmberArray} receiver
-      @public
-    */
     removeObjects(objects) {
       (0, _metal.beginPropertyChanges)();
 
@@ -17708,19 +16819,6 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return this;
     },
 
-    /**
-      Push the object onto the end of the array if it is not already
-      present in the array.
-         ```javascript
-      let cities = ['Chicago', 'Berlin'];
-         cities.addObject('Lima');    // ['Chicago', 'Berlin', 'Lima']
-      cities.addObject('Berlin');  // ['Chicago', 'Berlin', 'Lima']
-      ```
-         @method addObject
-      @param {*} obj object to add, if not already present
-      @return {EmberArray} receiver
-      @public
-    */
     addObject(obj) {
       var included = this.includes(obj);
 
@@ -17731,13 +16829,6 @@ define("@ember/array/index", ["exports", "@ember/-internals/metal", "@ember/-int
       return this;
     },
 
-    /**
-      Adds each object in the passed array to the receiver.
-         @method addObjects
-      @param {EmberArray} objects the objects to add.
-      @return {EmberArray} receiver
-      @public
-    */
     addObjects(objects) {
       (0, _metal.beginPropertyChanges)();
       objects.forEach(obj => this.addObject(obj));
@@ -17910,17 +17001,6 @@ define("@ember/array/proxy", ["exports", "@ember/-internals/metal", "@ember/obje
     willDestroy() {
       this._removeArrangedContentArrayObserver();
     }
-    /**
-      Should actually retrieve the object at the specified index from the
-      content. You can override this method in subclasses to transform the
-      content item to something new.
-         This method will only be called if content is non-`null`.
-         @method objectAtContent
-      @param {Number} idx The index to retrieve.
-      @return {Object} the value or undefined if none found
-      @public
-    */
-
 
     objectAtContent(idx) {
       var arrangedContent = (0, _object.get)(this, 'arrangedContent');
@@ -17934,19 +17014,6 @@ define("@ember/array/proxy", ["exports", "@ember/-internals/metal", "@ember/obje
       (true && !((0, _object.get)(this, 'arrangedContent') === (0, _object.get)(this, 'content')) && (0, _debug.assert)('Mutating an arranged ArrayProxy is not allowed', (0, _object.get)(this, 'arrangedContent') === (0, _object.get)(this, 'content')));
       this.replaceContent(idx, amt, objects);
     }
-    /**
-      Should actually replace the specified objects on the content array.
-      You can override this method in subclasses to transform the content item
-      into something new.
-         This method will only be called if content is non-`null`.
-         @method replaceContent
-      @param {Number} idx The starting index
-      @param {Number} amt The number of items to remove from the content.
-      @param {Array} objects Optional array of objects to insert.
-      @return {void}
-      @public
-    */
-
 
     replaceContent(idx, amt, objects) {
       var content = (0, _object.get)(this, 'content');
@@ -18115,13 +17182,6 @@ define("@ember/array/proxy", ["exports", "@ember/-internals/metal", "@ember/obje
   }
 
   ArrayProxy.reopen(_mutable.default, {
-    /**
-      The array that the proxy pretends to be. In the default `ArrayProxy`
-      implementation, this and `content` are the same. Subclasses of `ArrayProxy`
-      can override this property to provide things like sorting and filtering.
-         @property arrangedContent
-      @public
-    */
     arrangedContent: (0, _metal.alias)('content')
   });
   var _default = ArrayProxy;
@@ -18307,20 +17367,6 @@ define("@ember/controller/index", ["exports", "@ember/-internals/owner", "@ember
     /* ducktype as a controller */
     isController: true,
     concatenatedProperties: ['queryParams'],
-
-    /**
-      The object to which actions from the view should be sent.
-         For example, when a Handlebars template uses the `{{action}}` helper,
-      it will attempt to send the action to the view's controller's `target`.
-         By default, the value of the target property is set to the router, and
-      is injected when a controller is instantiated. This injection is applied
-      as part of the application's initialization process. In most cases the
-      `target` property will automatically be set to the logical consumer of
-      actions for the controller.
-         @property target
-      @default null
-      @public
-    */
     target: null,
     store: null,
 
@@ -18335,12 +17381,6 @@ define("@ember/controller/index", ["exports", "@ember/-internals/owner", "@ember
       }
     },
 
-    /**
-      The controller's current model. When retrieving or modifying a controller's
-      model, this property should be used instead of the `content` property.
-         @property model
-      @public
-    */
     model: (0, _object.computed)({
       get() {
         return this[MODEL];
@@ -18351,30 +17391,6 @@ define("@ember/controller/index", ["exports", "@ember/-internals/owner", "@ember
       }
 
     }),
-
-    /**
-      Defines which query parameters the controller accepts.
-      If you give the names `['category','page']` it will bind
-      the values of these query parameters to the variables
-      `this.category` and `this.page`.
-         By default, query parameters are parsed as strings. This
-      may cause unexpected behavior if a query parameter is used with `toggleProperty`,
-      because the initial value set for `param=false` will be the string `"false"`, which is truthy.
-         To avoid this, you may specify that the query parameter should be parsed as a boolean
-      by using the following verbose form with a `type` property:
-      ```javascript
-        queryParams: [{
-          category: {
-            type: 'boolean'
-          }
-        }]
-      ```
-      Available values for the `type` parameter are `'boolean'`, `'number'`, `'array'`, and `'string'`.
-      If query param type is not specified, it will default to `'string'`.
-         @for Ember.ControllerMixin
-      @property queryParams
-      @public
-    */
     queryParams: null,
 
     /**
@@ -18414,67 +17430,6 @@ define("@ember/controller/index", ["exports", "@ember/-internals/owner", "@ember
       delegate(prop, value);
     },
 
-    /**
-      Transition the application into another route. The route may
-      be either a single route or route path:
-         ```javascript
-      aController.transitionToRoute('blogPosts');
-      aController.transitionToRoute('blogPosts.recentEntries');
-      ```
-         Optionally supply a model for the route in question. The model
-      will be serialized into the URL using the `serialize` hook of
-      the route:
-         ```javascript
-      aController.transitionToRoute('blogPost', aPost);
-      ```
-         If a literal is passed (such as a number or a string), it will
-      be treated as an identifier instead. In this case, the `model`
-      hook of the route will be triggered:
-         ```javascript
-      aController.transitionToRoute('blogPost', 1);
-      ```
-         Multiple models will be applied last to first recursively up the
-      route tree.
-         ```app/router.js
-      Router.map(function() {
-        this.route('blogPost', { path: ':blogPostId' }, function() {
-          this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
-        });
-      });
-      ```
-         ```javascript
-      aController.transitionToRoute('blogComment', aPost, aComment);
-      aController.transitionToRoute('blogComment', 1, 13);
-      ```
-         It is also possible to pass a URL (a string that starts with a
-      `/`).
-         ```javascript
-      aController.transitionToRoute('/');
-      aController.transitionToRoute('/blog/post/1/comment/13');
-      aController.transitionToRoute('/blog/posts?sort=title');
-      ```
-         An options hash with a `queryParams` property may be provided as
-      the final argument to add query parameters to the destination URL.
-         ```javascript
-      aController.transitionToRoute('blogPost', 1, {
-        queryParams: { showComments: 'true' }
-      });
-         // if you just want to transition the query parameters without changing the route
-      aController.transitionToRoute({ queryParams: { sort: 'date' } });
-      ```
-         See also [replaceRoute](/ember/release/classes/Ember.ControllerMixin/methods/replaceRoute?anchor=replaceRoute).
-         @for Ember.ControllerMixin
-      @method transitionToRoute
-      @deprecated Use transitionTo from the Router service instead.
-      @param {String} [name] the name of the route or a URL
-      @param {...Object} models the model(s) or identifier(s) to be used
-        while transitioning to the route.
-      @param {Object} [options] optional hash with a queryParams property
-        containing a mapping of query parameters
-      @return {Transition} the transition object associated with this
-        attempted transition
-      @public
-    */
     transitionToRoute() {
       var _a;
 
@@ -18493,57 +17448,6 @@ define("@ember/controller/index", ["exports", "@ember/-internals/owner", "@ember
       return method.apply(target, (0, _internals2.prefixRouteNameArg)(this, args));
     },
 
-    /**
-      Transition into another route while replacing the current URL, if possible.
-      This will replace the current history entry instead of adding a new one.
-      Beside that, it is identical to `transitionToRoute` in all other respects.
-         ```javascript
-      aController.replaceRoute('blogPosts');
-      aController.replaceRoute('blogPosts.recentEntries');
-      ```
-         Optionally supply a model for the route in question. The model
-      will be serialized into the URL using the `serialize` hook of
-      the route:
-         ```javascript
-      aController.replaceRoute('blogPost', aPost);
-      ```
-         If a literal is passed (such as a number or a string), it will
-      be treated as an identifier instead. In this case, the `model`
-      hook of the route will be triggered:
-         ```javascript
-      aController.replaceRoute('blogPost', 1);
-      ```
-         Multiple models will be applied last to first recursively up the
-      route tree.
-         ```app/router.js
-      Router.map(function() {
-        this.route('blogPost', { path: ':blogPostId' }, function() {
-          this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
-        });
-      });
-      ```
-         ```
-      aController.replaceRoute('blogComment', aPost, aComment);
-      aController.replaceRoute('blogComment', 1, 13);
-      ```
-         It is also possible to pass a URL (a string that starts with a
-      `/`).
-         ```javascript
-      aController.replaceRoute('/');
-      aController.replaceRoute('/blog/post/1/comment/13');
-      ```
-         @for Ember.ControllerMixin
-      @method replaceRoute
-      @deprecated Use replaceWith from the Router service instead.
-      @param {String} [name] the name of the route or a URL
-      @param {...Object} models the model(s) or identifier(s) to be used
-      while transitioning to the route.
-      @param {Object} [options] optional hash with a queryParams property
-      containing a mapping of query parameters
-      @return {Transition} the transition object associated with this
-        attempted transition
-      @public
-    */
     replaceRoute() {
       var _a;
 
@@ -18681,7 +17585,7 @@ define("@ember/debug/container-debug-adapter", ["exports", "@ember/string", "@em
 
   _exports.default = ContainerDebugAdapter;
 });
-define("@ember/debug/data-adapter", ["exports", "@ember/-internals/owner", "@ember/runloop", "@ember/object", "@ember/string", "@ember/application/namespace", "@ember/array", "@glimmer/validator"], function (_exports, _owner, _runloop, _object, _string, _namespace, _array, _validator) {
+define("@ember/debug/data-adapter", ["exports", "@ember/-internals/owner", "@ember/runloop", "@ember/object", "@ember/string", "@ember/application/namespace", "@ember/array", "@glimmer/validator", "@ember/debug"], function (_exports, _owner, _runloop, _object, _string, _namespace, _array, _validator, _debug) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -18695,6 +17599,11 @@ define("@ember/debug/data-adapter", ["exports", "@ember/-internals/owner", "@emb
         fn(item);
       }
     } else {
+      // SAFETY: this cast required to work this way to interop between TS 4.8
+      // and 4.9. When we drop support for 4.8, it will narrow correctly via the
+      // use of the `in` operator above. (Preferably we will solve this by just
+      // switching to require `Symbol.iterator` instead.)
+      (0, _debug.assert)('', typeof arr.forEach === 'function');
       arr.forEach(fn);
     }
   }
@@ -18780,7 +17689,7 @@ define("@ember/debug/data-adapter", ["exports", "@ember/-internals/owner", "@emb
         (0, _validator.consumeTag)((0, _validator.tagFor)(records, '[]'));
 
         if (hasBeenAccessed === true) {
-          onChange();
+          (0, _runloop.next)(onChange);
         } else {
           hasBeenAccessed = true;
         }
@@ -25349,58 +24258,10 @@ define("@ember/object/observable", ["exports", "@ember/-internals/meta", "@ember
   @module @ember/object/observable
   */
   var Observable = _mixin.default.create({
-    /**
-      Retrieves the value of a property from the object.
-         This method is usually similar to using `object[keyName]` or `object.keyName`,
-      however it supports both computed properties and the unknownProperty
-      handler.
-         Because `get` unifies the syntax for accessing all these kinds
-      of properties, it can make many refactorings easier, such as replacing a
-      simple property with a computed property, or vice versa.
-         ### Computed Properties
-         Computed properties are methods defined with the `property` modifier
-      declared at the end, such as:
-         ```javascript
-      import { computed } from '@ember/object';
-         fullName: computed('firstName', 'lastName', function() {
-        return this.get('firstName') + ' ' + this.get('lastName');
-      })
-      ```
-         When you call `get` on a computed property, the function will be
-      called and the return value will be returned instead of the function
-      itself.
-         ### Unknown Properties
-         Likewise, if you try to call `get` on a property whose value is
-      `undefined`, the `unknownProperty()` method will be called on the object.
-      If this method returns any value other than `undefined`, it will be returned
-      instead. This allows you to implement "virtual" properties that are
-      not defined upfront.
-         @method get
-      @param {String} keyName The property to retrieve
-      @return {Object} The property value or undefined.
-      @public
-    */
     get(keyName) {
       return (0, _object.get)(this, keyName);
     },
 
-    /**
-      To get the values of multiple properties at once, call `getProperties`
-      with a list of strings or an array:
-         ```javascript
-      record.getProperties('firstName', 'lastName', 'zipCode');
-      // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
-      ```
-         is equivalent to:
-         ```javascript
-      record.getProperties(['firstName', 'lastName', 'zipCode']);
-      // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
-      ```
-         @method getProperties
-      @param {String...|Array} list of keys to get
-      @return {Object}
-      @public
-    */
     getProperties() {
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
@@ -25409,57 +24270,10 @@ define("@ember/object/observable", ["exports", "@ember/-internals/meta", "@ember
       return (0, _object.getProperties)(this, ...args);
     },
 
-    /**
-      Sets the provided key or path to the value.
-         ```javascript
-      record.set("key", value);
-      ```
-         This method is generally very similar to calling `object["key"] = value` or
-      `object.key = value`, except that it provides support for computed
-      properties, the `setUnknownProperty()` method and property observers.
-         ### Computed Properties
-         If you try to set a value on a key that has a computed property handler
-      defined (see the `get()` method for an example), then `set()` will call
-      that method, passing both the value and key instead of simply changing
-      the value itself. This is useful for those times when you need to
-      implement a property that is composed of one or more member
-      properties.
-         ### Unknown Properties
-         If you try to set a value on a key that is undefined in the target
-      object, then the `setUnknownProperty()` handler will be called instead. This
-      gives you an opportunity to implement complex "virtual" properties that
-      are not predefined on the object. If `setUnknownProperty()` returns
-      undefined, then `set()` will simply set the value on the object.
-         ### Property Observers
-         In addition to changing the property, `set()` will also register a property
-      change with the object. Unless you have placed this call inside of a
-      `beginPropertyChanges()` and `endPropertyChanges(),` any "local" observers
-      (i.e. observer methods declared on the same object), will be called
-      immediately. Any "remote" observers (i.e. observer methods declared on
-      another object) will be placed in a queue and called at a later time in a
-      coalesced manner.
-         @method set
-      @param {String} keyName The property to set
-      @param {Object} value The value to set or `null`.
-      @return {Object} The passed value
-      @public
-    */
     set(keyName, value) {
       return (0, _object.set)(this, keyName, value);
     },
 
-    /**
-      Sets a list of properties at once. These properties are set inside
-      a single `beginPropertyChanges` and `endPropertyChanges` batch, so
-      observers will be buffered.
-         ```javascript
-      record.setProperties({ firstName: 'Charles', lastName: 'Jolley' });
-      ```
-         @method setProperties
-      @param {Object} hash the hash of keys and values to set
-      @return {Object} The passed in hash
-      @public
-    */
     setProperties(hash) {
       return (0, _object.setProperties)(this, hash);
     },
@@ -25499,104 +24313,16 @@ define("@ember/object/observable", ["exports", "@ember/-internals/meta", "@ember
       return this;
     },
 
-    /**
-      Notify the observer system that a property has just changed.
-         Sometimes you need to change a value directly or indirectly without
-      actually calling `get()` or `set()` on it. In this case, you can use this
-      method instead. Calling this method will notify all observers that the
-      property has potentially changed value.
-         @method notifyPropertyChange
-      @param {String} keyName The property key to be notified about.
-      @return {Observable}
-      @public
-    */
     notifyPropertyChange(keyName) {
       (0, _metal.notifyPropertyChange)(this, keyName);
       return this;
     },
 
-    /**
-      Adds an observer on a property.
-         This is the core method used to register an observer for a property.
-         Once you call this method, any time the key's value is set, your observer
-      will be notified. Note that the observers are triggered any time the
-      value is set, regardless of whether it has actually changed. Your
-      observer should be prepared to handle that.
-         There are two common invocation patterns for `.addObserver()`:
-         - Passing two arguments:
-        - the name of the property to observe (as a string)
-        - the function to invoke (an actual function)
-      - Passing three arguments:
-        - the name of the property to observe (as a string)
-        - the target object (will be used to look up and invoke a
-          function on)
-        - the name of the function to invoke on the target object
-          (as a string).
-         ```app/components/my-component.js
-      import Component from '@ember/component';
-         export default Component.extend({
-        init() {
-          this._super(...arguments);
-             // the following are equivalent:
-             // using three arguments
-          this.addObserver('foo', this, 'fooDidChange');
-             // using two arguments
-          this.addObserver('foo', (...args) => {
-            this.fooDidChange(...args);
-          });
-        },
-           fooDidChange() {
-          // your custom logic code
-        }
-      });
-      ```
-         ### Observer Methods
-         Observer methods have the following signature:
-         ```app/components/my-component.js
-      import Component from '@ember/component';
-         export default Component.extend({
-        init() {
-          this._super(...arguments);
-          this.addObserver('foo', this, 'fooDidChange');
-        },
-           fooDidChange(sender, key, value, rev) {
-          // your code
-        }
-      });
-      ```
-         The `sender` is the object that changed. The `key` is the property that
-      changes. The `value` property is currently reserved and unused. The `rev`
-      is the last property revision of the object when it changed, which you can
-      use to detect if the key value has really changed or not.
-         Usually you will not need the value or revision parameters at
-      the end. In this case, it is common to write observer methods that take
-      only a sender and key value as parameters or, if you aren't interested in
-      any of these values, to write an observer that has no parameters at all.
-         @method addObserver
-      @param {String} key The key to observe
-      @param {Object} target The target object to invoke
-      @param {String|Function} method The method to invoke
-      @param {Boolean} sync Whether the observer is sync or not
-      @return {Observable}
-      @public
-    */
     addObserver(key, target, method, sync) {
       (0, _metal.addObserver)(this, key, target, method, sync);
       return this;
     },
 
-    /**
-      Remove an observer you have previously registered on this object. Pass
-      the same key, target, and method you passed to `addObserver()` and your
-      target will no longer receive notifications.
-         @method removeObserver
-      @param {String} key The key to observe
-      @param {Object} target The target object to invoke
-      @param {String|Function} method The method to invoke
-      @param {Boolean} sync Whether the observer is async or not
-      @return {Observable}
-      @public
-    */
     removeObserver(key, target, method, sync) {
       (0, _metal.removeObserver)(this, key, target, method, sync);
       return this;
@@ -25616,18 +24342,6 @@ define("@ember/object/observable", ["exports", "@ember/-internals/meta", "@ember
       return (0, _metal.hasListeners)(this, `${key}:change`);
     },
 
-    /**
-      Set the value of a property to the current value plus some amount.
-         ```javascript
-      person.incrementProperty('age');
-      team.incrementProperty('score', 2);
-      ```
-         @method incrementProperty
-      @param {String} keyName The name of the property to increment
-      @param {Number} increment The amount to increment by. Defaults to 1
-      @return {Number} The new property value
-      @public
-    */
     incrementProperty(keyName, increment) {
       if (increment === void 0) {
         increment = 1;
@@ -25637,18 +24351,6 @@ define("@ember/object/observable", ["exports", "@ember/-internals/meta", "@ember
       return (0, _object.set)(this, keyName, (parseFloat((0, _object.get)(this, keyName)) || 0) + increment);
     },
 
-    /**
-      Set the value of a property to the current value minus some amount.
-         ```javascript
-      player.decrementProperty('lives');
-      orc.decrementProperty('health', 5);
-      ```
-         @method decrementProperty
-      @param {String} keyName The name of the property to decrement
-      @param {Number} decrement The amount to decrement by. Defaults to 1
-      @return {Number} The new property value
-      @public
-    */
     decrementProperty(keyName, decrement) {
       if (decrement === void 0) {
         decrement = 1;
@@ -25658,31 +24360,10 @@ define("@ember/object/observable", ["exports", "@ember/-internals/meta", "@ember
       return (0, _object.set)(this, keyName, ((0, _object.get)(this, keyName) || 0) - decrement);
     },
 
-    /**
-      Set the value of a boolean property to the opposite of its
-      current value.
-         ```javascript
-      starship.toggleProperty('warpDriveEngaged');
-      ```
-         @method toggleProperty
-      @param {String} keyName The name of the property to toggle
-      @return {Boolean} The new property value
-      @public
-    */
     toggleProperty(keyName) {
       return (0, _object.set)(this, keyName, !(0, _object.get)(this, keyName));
     },
 
-    /**
-      Returns the cached value of a computed property, if it exists.
-      This allows you to inspect the value of a computed property
-      without accidentally invoking it if it is intended to be
-      generated lazily.
-         @method cacheFor
-      @param {String} keyName
-      @return {Object} The cached value of the computed property, if any
-      @public
-    */
     cacheFor(keyName) {
       var meta = (0, _meta.peekMeta)(this);
 
@@ -25753,66 +24434,15 @@ define("@ember/object/promise-proxy-mixin", ["exports", "@ember/object", "@ember
   }
 
   var PromiseProxyMixin = _mixin.default.create({
-    /**
-      If the proxied promise is rejected this will contain the reason
-      provided.
-         @property reason
-      @default null
-      @public
-    */
     reason: null,
-
-    /**
-      Once the proxied promise has settled this will become `false`.
-         @property isPending
-      @default true
-      @public
-    */
     isPending: (0, _object.computed)('isSettled', function () {
       return !(0, _object.get)(this, 'isSettled');
     }).readOnly(),
-
-    /**
-      Once the proxied promise has settled this will become `true`.
-         @property isSettled
-      @default false
-      @public
-    */
     isSettled: (0, _object.computed)('isRejected', 'isFulfilled', function () {
       return (0, _object.get)(this, 'isRejected') || (0, _object.get)(this, 'isFulfilled');
     }).readOnly(),
-
-    /**
-      Will become `true` if the proxied promise is rejected.
-         @property isRejected
-      @default false
-      @public
-    */
     isRejected: false,
-
-    /**
-      Will become `true` if the proxied promise is fulfilled.
-         @property isFulfilled
-      @default false
-      @public
-    */
     isFulfilled: false,
-
-    /**
-      The promise whose fulfillment value is being proxied by this object.
-         This property must be specified upon creation, and should not be
-      changed once created.
-         Example:
-         ```javascript
-      import ObjectProxy from '@ember/object/proxy';
-      import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
-         ObjectProxy.extend(PromiseProxyMixin).create({
-        promise: <thenable>
-      });
-      ```
-         @property promise
-      @public
-    */
     promise: (0, _object.computed)({
       get() {
         throw new _error.default("PromiseProxy's promise must be set");
@@ -25823,37 +24453,8 @@ define("@ember/object/promise-proxy-mixin", ["exports", "@ember/object", "@ember
       }
 
     }),
-
-    /**
-      An alias to the proxied promise's `then`.
-         See RSVP.Promise.then.
-         @method then
-      @param {Function} callback
-      @return {RSVP.Promise}
-      @public
-    */
     then: promiseAlias('then'),
-
-    /**
-      An alias to the proxied promise's `catch`.
-         See RSVP.Promise.catch.
-         @method catch
-      @param {Function} callback
-      @return {RSVP.Promise}
-      @since 1.3.0
-      @public
-    */
     catch: promiseAlias('catch'),
-
-    /**
-      An alias to the proxied promise's `finally`.
-         See RSVP.Promise.finally.
-         @method finally
-      @param {Function} callback
-      @return {RSVP.Promise}
-      @since 1.3.0
-      @public
-    */
     finally: promiseAlias('finally')
   });
 
@@ -28310,7 +26911,7 @@ define("@ember/routing/route", ["exports", "@ember/-internals/container", "@embe
         var [name] = params;
         (true && !(name) && (0, _debug.assert)('has name', name));
 
-        if (name in model) {
+        if (typeof model === 'object' && name in model) {
           object[name] = (0, _object.get)(model, name);
         } else if (/_id$/.test(name)) {
           object[name] = (0, _object.get)(model, 'id');
@@ -53111,7 +51712,7 @@ define("ember/version", ["exports"], function (_exports) {
     value: true
   });
   _exports.default = void 0;
-  var _default = "4.9.0-alpha.2";
+  var _default = "4.9.0-alpha.4";
   _exports.default = _default;
 });
 define("route-recognizer", ["exports"], function (_exports) {