ember-source 4.5.0-alpha.5 → 4.6.0-alpha.2

package/dist/ember.debug.js

@@ -6,7 +6,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   4.5.0-alpha.5
+ * @version   4.6.0-alpha.2
  */
 /* eslint-disable no-var */
 
@@ -5178,14 +5178,25 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     return string.replace(badChars, escapeChar);
   }
   /**
-    Mark a string as safe for unescaped output with Ember templates. If you
-    return HTML from a helper, use this function to
-    ensure Ember's rendering layer does not escape the HTML.
+    Use this method to indicate that a string should be rendered as HTML
+    when the string is used in a template. To say this another way,
+    strings marked with `htmlSafe` will not be HTML escaped.
+  
+    A word of warning -   The `htmlSafe` method does not make the string safe;
+    it only tells the framework to treat the string as if it is safe to render
+    as HTML. If a string contains user inputs or other untrusted
+    data, you must sanitize the string before using the `htmlSafe` method.
+    Otherwise your code is vulnerable to
+    [Cross-Site Scripting](https://owasp.org/www-community/attacks/DOM_Based_XSS).
+    There are many open source sanitization libraries to choose from,
+    both for front end and server-side sanitization.
   
     ```javascript
     import { htmlSafe } from '@ember/template';
   
-    htmlSafe('<div>someString</div>')
+    const someTrustedOrSanitizedString = "<div>Hello!</div>"
+  
+    htmlSafe(someTrustedorSanitizedString)
     ```
   
     @method htmlSafe
@@ -7434,7 +7445,9 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       return value;
     }
 
-  } // This wrapper logic prevents us from rerendering in case of a hard failure
+  }
+
+  var NO_OP = () => {}; // This wrapper logic prevents us from rerendering in case of a hard failure
   // during render. This prevents infinite revalidation type loops from occuring,
   // and ensures that errors are not swallowed by subsequent follow on failures.
 
@@ -7542,10 +7555,6 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     }
   }
 
-  function K() {
-    /* noop */
-  }
-
   var renderSettledDeferred = null;
   /*
     Returns a promise which will resolve when rendering has settled. Settled in
@@ -7564,7 +7573,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
 
       if (!(0, _runloop._getCurrentRunLoop)()) {
         // ensure a runloop has been kicked off
-        _runloop._backburner.schedule('actions', null, K);
+        _runloop._backburner.schedule('actions', null, NO_OP);
       }
     }
 
@@ -7593,7 +7602,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
         }
 
         loops++;
-        return _runloop._backburner.join(null, K);
+        return _runloop._backburner.join(null, NO_OP);
       }
     }
 
@@ -8901,10 +8910,6 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
   _exports.tracked = tracked;
   _exports.trySet = trySet;
 
-  /**
-  @module @ember/object
-  */
-
   /*
     The event system uses a series of nested hashes to store listeners on an
     object. When a listener is registered, or when an event arrives, these
@@ -17067,9 +17072,6 @@ define("@ember/-internals/routing/lib/system/router", ["exports", "@ember/-inter
   _exports.default = void 0;
   _exports.triggerEvent = triggerEvent;
 
-  /**
-  @module @ember/routing
-  */
   function defaultDidTransition(infos) {
     updatePaths(this);
 
@@ -28499,31 +28501,21 @@ define("@ember/controller/lib/controller_mixin", ["exports", "@ember/-internals/
   });
   _exports.default = void 0;
   var MODEL = (0, _utils.symbol)('MODEL');
-  /**
-  @module ember
-  */
-
-  /**
-    @class ControllerMixin
-    @namespace Ember
-    @uses Ember.ActionHandler
-    @private
-  */
 
-  var _default = _metal.Mixin.create(_runtime.ActionHandler, {
+  var ControllerMixin = _metal.Mixin.create(_runtime.ActionHandler, {
     /* ducktype as a controller */
     isController: true,
 
     /**
       The object to which actions from the view should be sent.
-       For example, when a Handlebars template uses the `{{action}}` helper,
+         For example, when a Handlebars template uses the `{{action}}` helper,
       it will attempt to send the action to the view's controller's `target`.
-       By default, the value of the target property is set to the router, and
+         By default, the value of the target property is set to the router, and
       is injected when a controller is instantiated. This injection is applied
       as part of the application's initialization process. In most cases the
       `target` property will automatically be set to the logical consumer of
       actions for the controller.
-       @property target
+         @property target
       @default null
       @public
     */
@@ -28533,7 +28525,7 @@ define("@ember/controller/lib/controller_mixin", ["exports", "@ember/-internals/
     /**
       The controller's current model. When retrieving or modifying a controller's
       model, this property should be used instead of the `content` property.
-       @property model
+         @property model
       @public
     */
     model: (0, _metal.computed)({
@@ -28541,13 +28533,14 @@ define("@ember/controller/lib/controller_mixin", ["exports", "@ember/-internals/
         return this[MODEL];
       },
 
-      set(key, value) {
+      set(_key, value) {
         return this[MODEL] = value;
       }
 
     })
   });
 
+  var _default = ControllerMixin;
   _exports.default = _default;
 });
 define("@ember/debug/container-debug-adapter", ["exports", "@ember/-internals/extension-support"], function (_exports, _extensionSupport) {
@@ -31350,8 +31343,7 @@ define("@ember/object/lib/computed/computed_macros", ["exports", "@ember/-intern
       expandedProperties.push(entry);
     }
 
-    for (var i = 0; i < properties.length; i++) {
-      var property = properties[i];
+    for (var property of properties) {
       (true && !(property.indexOf(' ') < 0) && (0, _debug.assert)(`Dependent keys passed to \`${predicateName}\` computed macro can't have spaces.`, property.indexOf(' ') < 0));
       (0, _metal.expandProperties)(property, extractProperty);
     }
@@ -31360,23 +31352,26 @@ define("@ember/object/lib/computed/computed_macros", ["exports", "@ember/-intern
   }
 
   function generateComputedWithPredicate(name, predicate) {
-    return function () {
-      for (var _len = arguments.length, properties = new Array(_len), _key = 0; _key < _len; _key++) {
-        properties[_key] = arguments[_key];
+    return function (dependentKey) {
+      for (var _len = arguments.length, additionalDependentKeys = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        additionalDependentKeys[_key - 1] = arguments[_key];
       }
 
+      var properties = [dependentKey, ...additionalDependentKeys];
       (true && !(!(0, _metal.isElementDescriptor)(properties)) && (0, _debug.assert)(`You attempted to use @${name} as a decorator directly, but it requires at least one dependent key parameter`, !(0, _metal.isElementDescriptor)(properties)));
       var dependentKeys = expandPropertiesToArray(name, properties);
       var computedFunc = (0, _metal.computed)(...dependentKeys, function () {
         var lastIdx = dependentKeys.length - 1;
 
         for (var i = 0; i < lastIdx; i++) {
+          // SAFETY: `i` is derived from the length of `dependentKeys`
           var value = (0, _metal.get)(this, dependentKeys[i]);
 
           if (!predicate(value)) {
             return value;
           }
-        }
+        } // SAFETY: `lastIdx` is derived from the length of `dependentKeys`
+
 
         return (0, _metal.get)(this, dependentKeys[lastIdx]);
       });
@@ -32137,7 +32132,7 @@ define("@ember/object/lib/computed/computed_macros", ["exports", "@ember/-intern
     });
   }
 });
-define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/debug", "@ember/-internals/metal", "@ember/-internals/runtime"], function (_exports, _debug, _metal, _runtime) {
+define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/debug", "@ember/-internals/metal", "@ember/-internals/runtime", "@ember/-internals/runtime/lib/mixins/array"], function (_exports, _debug, _metal, _runtime, _array) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -32161,6 +32156,10 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
   /**
   @module @ember/object
   */
+  function isNativeOrEmberArray(obj) {
+    return Array.isArray(obj) || _array.default.detect(obj);
+  }
+
   function reduceMacro(dependentKey, callback, initialValue, name) {
     (true && !(!/[[\]{}]/g.test(dependentKey)) && (0, _debug.assert)(`Dependent key passed to \`${name}\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey)));
     return (0, _metal.computed)(`${dependentKey}.[]`, function () {
@@ -32188,7 +32187,7 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
     return (0, _metal.computed)(dependentKey, ...additionalDependentKeys, function () {
       var value = (0, _metal.get)(this, propertyName);
 
-      if ((0, _runtime.isArray)(value)) {
+      if (isNativeOrEmberArray(value)) {
         return (0, _runtime.A)(callback.call(this, value));
       } else {
         return (0, _runtime.A)();
@@ -32360,95 +32359,25 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
     (true && !(!(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))) && (0, _debug.assert)('You attempted to use @min as a decorator directly, but it requires a `dependentKey` parameter', !(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))));
     return reduceMacro(dependentKey, (min, item) => Math.min(min, item), Infinity, 'min');
   }
-  /**
-    Returns an array mapped via the callback
-  
-    The callback method you provide should have the following signature:
-    - `item` is the current item in the iteration.
-    - `index` is the integer index of the current item in the iteration.
-  
-    ```javascript
-    function mapCallback(item, index);
-    ```
-  
-    Example:
-  
-    ```javascript
-    import { set } from '@ember/object';
-    import { map } from '@ember/object/computed';
-  
-    class Hamster {
-      constructor(chores) {
-        set(this, 'chores', chores);
-      }
-  
-      @map('chores', function(chore, index) {
-        return `${chore.toUpperCase()}!`;
-      })
-      excitingChores;
-    });
-  
-    let hamster = new Hamster(['clean', 'write more unit tests']);
-  
-    hamster.excitingChores; // ['CLEAN!', 'WRITE MORE UNIT TESTS!']
-    ```
-  
-    You can optionally pass an array of additional dependent keys as the second
-    parameter to the macro, if your map function relies on any external values:
-  
-    ```javascript
-    import { set } from '@ember/object';
-    import { map } from '@ember/object/computed';
-  
-    class Hamster {
-      shouldUpperCase = false;
-  
-      constructor(chores) {
-        set(this, 'chores', chores);
-      }
-  
-      @map('chores', ['shouldUpperCase'], function(chore, index) {
-        if (this.shouldUpperCase) {
-          return `${chore.toUpperCase()}!`;
-        } else {
-          return `${chore}!`;
-        }
-      })
-      excitingChores;
-    }
-  
-    let hamster = new Hamster(['clean', 'write more unit tests']);
-  
-    hamster.excitingChores; // ['clean!', 'write more unit tests!']
-  
-    set(hamster, 'shouldUpperCase', true);
-    hamster.excitingChores; // ['CLEAN!', 'WRITE MORE UNIT TESTS!']
-    ```
-  
-    @method map
-    @for @ember/object/computed
-    @static
-    @param {String} dependentKey
-    @param {Array} [additionalDependentKeys] optional array of additional
-    dependent keys
-    @param {Function} callback
-    @return {ComputedProperty} an array mapped via the callback
-    @public
-  */
-
 
-  function map(dependentKey, additionalDependentKeys, callback) {
+  function map(dependentKey, additionalDependentKeysOrCallback, callback) {
     (true && !(!(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))) && (0, _debug.assert)('You attempted to use @map as a decorator directly, but it requires atleast `dependentKey` and `callback` parameters', !(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))));
+    (true && !(typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function') && (0, _debug.assert)('The final parameter provided to map must be a callback function', typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function'));
+    (true && !(Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function') && (0, _debug.assert)('The second parameter provided to map must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function'));
+    var additionalDependentKeys;
 
-    if (callback === undefined && typeof additionalDependentKeys === 'function') {
-      callback = additionalDependentKeys;
+    if (typeof additionalDependentKeysOrCallback === 'function') {
+      callback = additionalDependentKeysOrCallback;
       additionalDependentKeys = [];
+    } else {
+      additionalDependentKeys = additionalDependentKeysOrCallback;
     }
 
-    (true && !(typeof callback === 'function') && (0, _debug.assert)('The final parameter provided to map must be a callback function', typeof callback === 'function'));
-    (true && !(Array.isArray(additionalDependentKeys)) && (0, _debug.assert)('The second parameter provided to map must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeys)));
+    var cCallback = callback;
+    (true && !(cCallback) && (0, _debug.assert)('[BUG] Missing callback', cCallback));
     return arrayMacro(dependentKey, additionalDependentKeys, function (value) {
-      return value.map(callback, this);
+      // This is so dumb...
+      return Array.isArray(value) ? value.map(cCallback, this) : value.map(cCallback, this);
     });
   }
   /**
@@ -32507,125 +32436,24 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
     (true && !(!/[[\]{}]/g.test(dependentKey)) && (0, _debug.assert)(`Dependent key passed to \`mapBy\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey)));
     return map(`${dependentKey}.@each.${propertyKey}`, item => (0, _metal.get)(item, propertyKey));
   }
-  /**
-    Filters the array by the callback.
-  
-    The callback method you provide should have the following signature:
-    - `item` is the current item in the iteration.
-    - `index` is the integer index of the current item in the iteration.
-    - `array` is the dependant array itself.
-  
-    ```javascript
-    function filterCallback(item, index, array);
-    ```
-  
-    Example:
-  
-    ```javascript
-    import { set } from '@ember/object';
-    import { filter } from '@ember/object/computed';
-  
-    class Hamster {
-      constructor(chores) {
-        set(this, 'chores', chores);
-      }
-  
-      @filter('chores', function(chore, index, array) {
-        return !chore.done;
-      })
-      remainingChores;
-    }
-  
-    let hamster = Hamster.create([
-      { name: 'cook', done: true },
-      { name: 'clean', done: true },
-      { name: 'write more unit tests', done: false }
-    ]);
-  
-    hamster.remainingChores; // [{name: 'write more unit tests', done: false}]
-    ```
-  
-    You can also use `@each.property` in your dependent key, the callback will
-    still use the underlying array:
-  
-    ```javascript
-    import { set } from '@ember/object';
-    import { filter } from '@ember/object/computed';
-  
-    class Hamster {
-      constructor(chores) {
-        set(this, 'chores', chores);
-      }
-  
-      @filter('chores.@each.done', function(chore, index, array) {
-        return !chore.done;
-      })
-      remainingChores;
-    }
-  
-    let hamster = new Hamster([
-      { name: 'cook', done: true },
-      { name: 'clean', done: true },
-      { name: 'write more unit tests', done: false }
-    ]);
-    hamster.remainingChores; // [{name: 'write more unit tests', done: false}]
-  
-    set(hamster.chores[2], 'done', true);
-    hamster.remainingChores; // []
-    ```
-  
-    Finally, you can optionally pass an array of additional dependent keys as the
-    second parameter to the macro, if your filter function relies on any external
-    values:
-  
-    ```javascript
-    import { filter } from '@ember/object/computed';
-  
-    class Hamster {
-      constructor(chores) {
-        set(this, 'chores', chores);
-      }
-  
-      doneKey = 'finished';
-  
-      @filter('chores', ['doneKey'], function(chore, index, array) {
-        return !chore[this.doneKey];
-      })
-      remainingChores;
-    }
-  
-    let hamster = new Hamster([
-      { name: 'cook', finished: true },
-      { name: 'clean', finished: true },
-      { name: 'write more unit tests', finished: false }
-    ]);
-  
-    hamster.remainingChores; // [{name: 'write more unit tests', finished: false}]
-    ```
-  
-    @method filter
-    @for @ember/object/computed
-    @static
-    @param {String} dependentKey
-    @param {Array} [additionalDependentKeys] optional array of additional dependent keys
-    @param {Function} callback
-    @return {ComputedProperty} the filtered array
-    @public
-  */
 
-
-  function filter(dependentKey, additionalDependentKeys, callback) {
+  function filter(dependentKey, additionalDependentKeysOrCallback, callback) {
     (true && !(!(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))) && (0, _debug.assert)('You attempted to use @filter as a decorator directly, but it requires atleast `dependentKey` and `callback` parameters', !(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))));
+    (true && !(typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function') && (0, _debug.assert)('The final parameter provided to filter must be a callback function', typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function'));
+    (true && !(Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function') && (0, _debug.assert)('The second parameter provided to filter must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function'));
+    var additionalDependentKeys;
 
-    if (callback === undefined && typeof additionalDependentKeys === 'function') {
-      callback = additionalDependentKeys;
+    if (typeof additionalDependentKeysOrCallback === 'function') {
+      callback = additionalDependentKeysOrCallback;
       additionalDependentKeys = [];
+    } else {
+      additionalDependentKeys = additionalDependentKeysOrCallback;
     }
 
-    (true && !(typeof callback === 'function') && (0, _debug.assert)('The final parameter provided to filter must be a callback function', typeof callback === 'function'));
-    (true && !(Array.isArray(additionalDependentKeys)) && (0, _debug.assert)('The second parameter provided to filter must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeys)));
+    var cCallback = callback;
     return arrayMacro(dependentKey, additionalDependentKeys, function (value) {
-      return value.filter(callback, this);
+      // This is a really silly way to keep TS happy
+      return Array.isArray(value) ? value.filter(cCallback, this) : value.filter(cCallback, this);
     });
   }
   /**
@@ -32716,19 +32544,20 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
   */
 
 
-  function uniq() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
+  function uniq(dependentKey) {
+    for (var _len = arguments.length, additionalDependentKeys = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      additionalDependentKeys[_key - 1] = arguments[_key];
     }
 
     (true && !(!(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))) && (0, _debug.assert)('You attempted to use @uniq/@union as a decorator directly, but it requires atleast one dependent key parameter', !(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))));
+    var args = [dependentKey, ...additionalDependentKeys];
     return multiArrayMacro(args, function (dependentKeys) {
       var uniq = (0, _runtime.A)();
       var seen = new Set();
       dependentKeys.forEach(dependentKey => {
         var value = (0, _metal.get)(this, dependentKey);
 
-        if ((0, _runtime.isArray)(value)) {
+        if (isNativeOrEmberArray(value)) {
           value.forEach(item => {
             if (!seen.has(item)) {
               seen.add(item);
@@ -32784,7 +32613,7 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
     (true && !(!/[[\]{}]/g.test(dependentKey)) && (0, _debug.assert)(`Dependent key passed to \`uniqBy\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey)));
     return (0, _metal.computed)(`${dependentKey}.[]`, function () {
       var list = (0, _metal.get)(this, dependentKey);
-      return (0, _runtime.isArray)(list) ? (0, _runtime.uniqBy)(list, propertyKey) : (0, _runtime.A)();
+      return isNativeOrEmberArray(list) ? (0, _runtime.uniqBy)(list, propertyKey) : (0, _runtime.A)();
     }).readOnly();
   }
   /**
@@ -32873,24 +32702,26 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
 
   _exports.union = union;
 
-  function intersect() {
-    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-      args[_key2] = arguments[_key2];
+  function intersect(dependentKey) {
+    for (var _len2 = arguments.length, additionalDependentKeys = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      additionalDependentKeys[_key2 - 1] = arguments[_key2];
     }
 
     (true && !(!(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))) && (0, _debug.assert)('You attempted to use @intersect as a decorator directly, but it requires atleast one dependent key parameter', !(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))));
+    var args = [dependentKey, ...additionalDependentKeys];
     return multiArrayMacro(args, function (dependentKeys) {
       var arrays = dependentKeys.map(dependentKey => {
         var array = (0, _metal.get)(this, dependentKey);
-        return (0, _runtime.isArray)(array) ? array : [];
+        return Array.isArray(array) ? array : [];
       });
-      var results = arrays.pop().filter(candidate => {
-        for (var i = 0; i < arrays.length; i++) {
+      var firstArray = arrays.pop();
+      (true && !(firstArray) && (0, _debug.assert)('Attempted to apply multiArrayMacro for intersect without any dependentKeys', firstArray));
+      var results = firstArray.filter(candidate => {
+        for (var array of arrays) {
           var found = false;
-          var array = arrays[i];
 
-          for (var j = 0; j < array.length; j++) {
-            if (array[j] === candidate) {
+          for (var item of array) {
+            if (item === candidate) {
               found = true;
               break;
             }
@@ -32959,11 +32790,11 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
       var setA = (0, _metal.get)(this, setAProperty);
       var setB = (0, _metal.get)(this, setBProperty);
 
-      if (!(0, _runtime.isArray)(setA)) {
+      if (!isNativeOrEmberArray(setA)) {
         return (0, _runtime.A)();
       }
 
-      if (!(0, _runtime.isArray)(setB)) {
+      if (!isNativeOrEmberArray(setB)) {
         return (0, _runtime.A)(setA);
       }
 
@@ -33003,12 +32834,13 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
   */
 
 
-  function collect() {
-    for (var _len3 = arguments.length, dependentKeys = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-      dependentKeys[_key3] = arguments[_key3];
+  function collect(dependentKey) {
+    for (var _len3 = arguments.length, additionalDependentKeys = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      additionalDependentKeys[_key3 - 1] = arguments[_key3];
     }
 
     (true && !(!(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))) && (0, _debug.assert)('You attempted to use @collect as a decorator directly, but it requires atleast one dependent key parameter', !(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))));
+    var dependentKeys = [dependentKey, ...additionalDependentKeys];
     return multiArrayMacro(dependentKeys, function () {
       var res = dependentKeys.map(key => {
         var val = (0, _metal.get)(this, key);
@@ -33017,148 +32849,8 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
       return (0, _runtime.A)(res);
     }, 'collect');
   }
-  /**
-    A computed property which returns a new array with all the properties from the
-    first dependent array sorted based on a property or sort function. The sort
-    macro can be used in two different ways:
-  
-    1. By providing a sort callback function
-    2. By providing an array of keys to sort the array
-  
-    In the first form, the callback method you provide should have the following
-    signature:
-  
-    ```javascript
-    function sortCallback(itemA, itemB);
-    ```
-  
-    - `itemA` the first item to compare.
-    - `itemB` the second item to compare.
-  
-    This function should return negative number (e.g. `-1`) when `itemA` should
-    come before `itemB`. It should return positive number (e.g. `1`) when `itemA`
-    should come after `itemB`. If the `itemA` and `itemB` are equal this function
-    should return `0`.
-  
-    Therefore, if this function is comparing some numeric values, simple `itemA -
-    itemB` or `itemA.get( 'foo' ) - itemB.get( 'foo' )` can be used instead of
-    series of `if`.
-  
-    Example:
-  
-    ```javascript
-    import { set } from '@ember/object';
-    import { sort } from '@ember/object/computed';
-  
-    class ToDoList {
-      constructor(todos) {
-        set(this, 'todos', todos);
-      }
-  
-      // using a custom sort function
-      @sort('todos', function(a, b){
-        if (a.priority > b.priority) {
-          return 1;
-        } else if (a.priority < b.priority) {
-          return -1;
-        }
-  
-        return 0;
-      })
-      priorityTodos;
-    }
-  
-    let todoList = new ToDoList([
-      { name: 'Unit Test', priority: 2 },
-      { name: 'Documentation', priority: 3 },
-      { name: 'Release', priority: 1 }
-    ]);
-  
-    todoList.priorityTodos; // [{ name:'Release', priority:1 }, { name:'Unit Test', priority:2 }, { name:'Documentation', priority:3 }]
-    ```
-  
-    You can also optionally pass an array of additional dependent keys as the
-    second parameter, if your sort function is dependent on additional values that
-    could changes:
-  
-    ```js
-    import EmberObject, { set } from '@ember/object';
-    import { sort } from '@ember/object/computed';
-  
-    class ToDoList {
-      sortKey = 'priority';
-  
-      constructor(todos) {
-        set(this, 'todos', todos);
-      }
-  
-      // using a custom sort function
-      @sort('todos', ['sortKey'], function(a, b){
-        if (a[this.sortKey] > b[this.sortKey]) {
-          return 1;
-        } else if (a[this.sortKey] < b[this.sortKey]) {
-          return -1;
-        }
-  
-        return 0;
-      })
-      sortedTodos;
-    });
-  
-    let todoList = new ToDoList([
-      { name: 'Unit Test', priority: 2 },
-      { name: 'Documentation', priority: 3 },
-      { name: 'Release', priority: 1 }
-    ]);
-  
-    todoList.priorityTodos; // [{ name:'Release', priority:1 }, { name:'Unit Test', priority:2 }, { name:'Documentation', priority:3 }]
-    ```
-  
-    In the second form, you should provide the key of the array of sort values as
-    the second parameter:
-  
-    ```javascript
-    import { set } from '@ember/object';
-    import { sort } from '@ember/object/computed';
-  
-    class ToDoList {
-      constructor(todos) {
-        set(this, 'todos', todos);
-      }
-  
-      // using standard ascending sort
-      todosSorting = ['name'];
-      @sort('todos', 'todosSorting') sortedTodos;
-  
-      // using descending sort
-      todosSortingDesc = ['name:desc'];
-      @sort('todos', 'todosSortingDesc') sortedTodosDesc;
-    }
-  
-    let todoList = new ToDoList([
-      { name: 'Unit Test', priority: 2 },
-      { name: 'Documentation', priority: 3 },
-      { name: 'Release', priority: 1 }
-    ]);
-  
-    todoList.sortedTodos; // [{ name:'Documentation', priority:3 }, { name:'Release', priority:1 }, { name:'Unit Test', priority:2 }]
-    todoList.sortedTodosDesc; // [{ name:'Unit Test', priority:2 }, { name:'Release', priority:1 }, { name:'Documentation', priority:3 }]
-    ```
-  
-    @method sort
-    @for @ember/object/computed
-    @static
-    @param {String} itemsKey
-    @param {String|Function|Array} sortDefinitionOrDependentKeys The key of the sort definition (an array of sort properties),
-    the sort function, or an array of additional dependent keys
-    @param {Function?} sortDefinition the sort function (when used with additional dependent keys)
-    @return {ComputedProperty} computes a new sorted array based on the sort
-    property array or callback function
-    @public
-  */
 
-
-  function sort(itemsKey, additionalDependentKeys, sortDefinition) {
+  function sort(itemsKey, additionalDependentKeysOrDefinition, sortDefinition) {
     (true && !(!(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))) && (0, _debug.assert)('You attempted to use @sort as a decorator directly, but it requires atleast an `itemsKey` parameter', !(0, _metal.isElementDescriptor)(Array.prototype.slice.call(arguments))));
 
     if (true
@@ -33167,25 +32859,31 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
       var argumentsValid = false;
 
       if (arguments.length === 2) {
-        argumentsValid = typeof itemsKey === 'string' && (typeof additionalDependentKeys === 'string' || typeof additionalDependentKeys === 'function');
+        argumentsValid = typeof itemsKey === 'string' && (typeof additionalDependentKeysOrDefinition === 'string' || typeof additionalDependentKeysOrDefinition === 'function');
       }
 
       if (arguments.length === 3) {
-        argumentsValid = typeof itemsKey === 'string' && Array.isArray(additionalDependentKeys) && typeof sortDefinition === 'function';
+        argumentsValid = typeof itemsKey === 'string' && Array.isArray(additionalDependentKeysOrDefinition) && typeof sortDefinition === 'function';
       }
 
       (true && !(argumentsValid) && (0, _debug.assert)('The `sort` computed macro can either be used with an array of sort properties or with a sort function. If used with an array of sort properties, it must receive exactly two arguments: the key of the array to sort, and the key of the array of sort properties. If used with a sort function, it may receive up to three arguments: the key of the array to sort, an optional additional array of dependent keys for the computed property, and the sort function.', argumentsValid));
     }
 
-    if (sortDefinition === undefined && !Array.isArray(additionalDependentKeys)) {
-      sortDefinition = additionalDependentKeys;
+    var additionalDependentKeys;
+    var sortDefinitionOrString;
+
+    if (Array.isArray(additionalDependentKeysOrDefinition)) {
+      additionalDependentKeys = additionalDependentKeysOrDefinition;
+      sortDefinitionOrString = sortDefinition;
+    } else {
       additionalDependentKeys = [];
+      sortDefinitionOrString = additionalDependentKeysOrDefinition;
     }
 
-    if (typeof sortDefinition === 'function') {
-      return customSort(itemsKey, additionalDependentKeys, sortDefinition);
+    if (typeof sortDefinitionOrString === 'function') {
+      return customSort(itemsKey, additionalDependentKeys, sortDefinitionOrString);
     } else {
-      return propertySort(itemsKey, sortDefinition);
+      return propertySort(itemsKey, sortDefinitionOrString);
     }
   }
 
@@ -33200,12 +32898,16 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
   function propertySort(itemsKey, sortPropertiesKey) {
     var cp = (0, _metal.autoComputed)(function (key) {
       var sortProperties = (0, _metal.get)(this, sortPropertiesKey);
-      (true && !((0, _runtime.isArray)(sortProperties) && sortProperties.every(s => typeof s === 'string')) && (0, _debug.assert)(`The sort definition for '${key}' on ${this} must be a function or an array of strings`, (0, _runtime.isArray)(sortProperties) && sortProperties.every(s => typeof s === 'string')));
+      (true && !(function (arr) {
+        return isNativeOrEmberArray(arr) && arr.every(s => typeof s === 'string');
+      }(sortProperties)) && (0, _debug.assert)(`The sort definition for '${key}' on ${this} must be a function or an array of strings`, function (arr) {
+        return isNativeOrEmberArray(arr) && arr.every(s => typeof s === 'string');
+      }(sortProperties)));
       var itemsKeyIsAtThis = itemsKey === '@this';
       var normalizedSortProperties = normalizeSortProperties(sortProperties);
       var items = itemsKeyIsAtThis ? this : (0, _metal.get)(this, itemsKey);
 
-      if (!(0, _runtime.isArray)(items)) {
+      if (!isNativeOrEmberArray(items)) {
         return (0, _runtime.A)();
       }
 
@@ -33219,17 +32921,20 @@ define("@ember/object/lib/computed/reduce_computed_macros", ["exports", "@ember/
   }
 
   function normalizeSortProperties(sortProperties) {
-    return sortProperties.map(p => {
+    var callback = p => {
       var [prop, direction] = p.split(':');
-      direction = direction || 'asc';
+      direction = direction || 'asc'; // SAFETY: There will always be at least one value returned by split
+
       return [prop, direction];
-    });
+    }; // This nonsense is necessary since technically the two map implementations diverge.
+
+
+    return Array.isArray(sortProperties) ? sortProperties.map(callback) : sortProperties.map(callback);
   }
 
   function sortByNormalizedSortProperties(items, normalizedSortProperties) {
     return (0, _runtime.A)(items.slice().sort((itemA, itemB) => {
-      for (var i = 0; i < normalizedSortProperties.length; i++) {
-        var [prop, direction] = normalizedSortProperties[i];
+      for (var [prop, direction] of normalizedSortProperties) {
         var result = (0, _runtime.compare)((0, _metal.get)(itemA, prop), (0, _metal.get)(itemB, prop));
 
         if (result !== 0) {
@@ -52620,9 +52325,6 @@ define("ember-testing/lib/adapters/adapter", ["exports", "@ember/-internals/runt
   });
   _exports.default = void 0;
 
-  function K() {
-    return this;
-  }
   /**
    @module @ember/test
   */
@@ -52634,8 +52336,6 @@ define("ember-testing/lib/adapters/adapter", ["exports", "@ember/-internals/runt
     @class TestAdapter
     @public
   */
-
-
   var _default = _runtime.Object.extend({
     /**
       This callback will be called whenever an async operation is about to start.
@@ -52644,14 +52344,14 @@ define("ember-testing/lib/adapters/adapter", ["exports", "@ember/-internals/runt
        @public
       @method asyncStart
     */
-    asyncStart: K,
+    asyncStart() {},
 
     /**
       This callback will be called whenever an async operation has completed.
        @public
       @method asyncEnd
     */
-    asyncEnd: K,
+    asyncEnd() {},
 
     /**
       Override this method with your testing framework's false assertion.
@@ -54405,7 +54105,7 @@ define("ember/version", ["exports"], function (_exports) {
     value: true
   });
   _exports.default = void 0;
-  var _default = "4.5.0-alpha.5";
+  var _default = "4.6.0-alpha.2";
   _exports.default = _default;
 });
 define("route-recognizer", ["exports"], function (_exports) {