ember-source 2.11.3 → 2.12.0.beta.1

data/dist/ember-template-compiler.js

@@ -6,11 +6,10 @@
  *            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   2.11.3
+ * @version   2.12.0-beta.1
  */
 
 var enifed, requireModule, Ember;
-var mainContext = this; // Used in ember-environment/lib/global.js
 
 (function() {
   var isNode = typeof window === 'undefined' &&
@@ -174,7 +173,7 @@ function defaults(obj, defaults) {
   return obj;
 }
 
-var babelHelpers = {
+babelHelpers = {
   classCallCheck: classCallCheck,
   inherits: inherits,
   taggedTemplateLiteralLoose: taggedTemplateLiteralLoose,
@@ -1733,7 +1732,7 @@ enifed('ember-debug/index', ['exports', 'ember-metal', 'ember-environment', 'emb
       if (typeof window !== 'undefined' && (isFirefox || isChrome) && window.addEventListener) {
         window.addEventListener('load', function () {
           if (document.documentElement && document.documentElement.dataset && !document.documentElement.dataset.emberExtension) {
-            var downloadURL;
+            var downloadURL = undefined;
 
             if (isChrome) {
               downloadURL = 'https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi';
@@ -2077,7 +2076,6 @@ enifed('ember-metal/alias', ['exports', 'ember-utils', 'ember-metal/debug', 'emb
   'use strict';
 
   exports.default = alias;
-  exports.AliasedProperty = AliasedProperty;
 
   var CONSUMED = {};
 
@@ -2085,66 +2083,75 @@ enifed('ember-metal/alias', ['exports', 'ember-utils', 'ember-metal/debug', 'emb
     return new AliasedProperty(altKey);
   }
 
-  function AliasedProperty(altKey) {
-    this.isDescriptor = true;
-    this.altKey = altKey;
-    this._dependentKeys = [altKey];
-  }
+  var AliasedProperty = (function (_Descriptor) {
+    babelHelpers.inherits(AliasedProperty, _Descriptor);
 
-  AliasedProperty.prototype = Object.create(_emberMetalProperties.Descriptor.prototype);
+    function AliasedProperty(altKey) {
+      babelHelpers.classCallCheck(this, AliasedProperty);
 
-  AliasedProperty.prototype.setup = function (obj, keyName) {
-    _emberMetalDebug.assert('Setting alias \'' + keyName + '\' on self', this.altKey !== keyName);
-    var meta = _emberMetalMeta.meta(obj);
-    if (meta.peekWatching(keyName)) {
-      _emberMetalDependent_keys.addDependentKeys(this, obj, keyName, meta);
+      _Descriptor.call(this);
+      this.isDescriptor = true;
+      this.altKey = altKey;
+      this._dependentKeys = [altKey];
     }
-  };
 
-  AliasedProperty.prototype.teardown = function (obj, keyName) {
-    var meta = _emberMetalMeta.meta(obj);
-    if (meta.peekWatching(keyName)) {
-      _emberMetalDependent_keys.removeDependentKeys(this, obj, keyName, meta);
-    }
-  };
+    AliasedProperty.prototype.setup = function setup(obj, keyName) {
+      _emberMetalDebug.assert('Setting alias \'' + keyName + '\' on self', this.altKey !== keyName);
+      var meta = _emberMetalMeta.meta(obj);
+      if (meta.peekWatching(keyName)) {
+        _emberMetalDependent_keys.addDependentKeys(this, obj, keyName, meta);
+      }
+    };
 
-  AliasedProperty.prototype.willWatch = function (obj, keyName) {
-    _emberMetalDependent_keys.addDependentKeys(this, obj, keyName, _emberMetalMeta.meta(obj));
-  };
+    AliasedProperty.prototype.teardown = function teardown(obj, keyName) {
+      var meta = _emberMetalMeta.meta(obj);
+      if (meta.peekWatching(keyName)) {
+        _emberMetalDependent_keys.removeDependentKeys(this, obj, keyName, meta);
+      }
+    };
 
-  AliasedProperty.prototype.didUnwatch = function (obj, keyName) {
-    _emberMetalDependent_keys.removeDependentKeys(this, obj, keyName, _emberMetalMeta.meta(obj));
-  };
+    AliasedProperty.prototype.willWatch = function willWatch(obj, keyName) {
+      _emberMetalDependent_keys.addDependentKeys(this, obj, keyName, _emberMetalMeta.meta(obj));
+    };
 
-  AliasedProperty.prototype.get = function AliasedProperty_get(obj, keyName) {
-    var ret = _emberMetalProperty_get.get(obj, this.altKey);
-    var meta = _emberMetalMeta.meta(obj);
-    var cache = meta.writableCache();
-    if (cache[keyName] !== CONSUMED) {
-      cache[keyName] = CONSUMED;
-      _emberMetalDependent_keys.addDependentKeys(this, obj, keyName, meta);
-    }
-    return ret;
-  };
+    AliasedProperty.prototype.didUnwatch = function didUnwatch(obj, keyName) {
+      _emberMetalDependent_keys.removeDependentKeys(this, obj, keyName, _emberMetalMeta.meta(obj));
+    };
 
-  AliasedProperty.prototype.set = function AliasedProperty_set(obj, keyName, value) {
-    return _emberMetalProperty_set.set(obj, this.altKey, value);
-  };
+    AliasedProperty.prototype.get = function get(obj, keyName) {
+      var ret = _emberMetalProperty_get.get(obj, this.altKey);
+      var meta = _emberMetalMeta.meta(obj);
+      var cache = meta.writableCache();
+      if (cache[keyName] !== CONSUMED) {
+        cache[keyName] = CONSUMED;
+        _emberMetalDependent_keys.addDependentKeys(this, obj, keyName, meta);
+      }
+      return ret;
+    };
 
-  AliasedProperty.prototype.readOnly = function () {
-    this.set = AliasedProperty_readOnlySet;
-    return this;
-  };
+    AliasedProperty.prototype.set = function set(obj, keyName, value) {
+      return _emberMetalProperty_set.set(obj, this.altKey, value);
+    };
+
+    AliasedProperty.prototype.readOnly = function readOnly() {
+      this.set = AliasedProperty_readOnlySet;
+      return this;
+    };
+
+    AliasedProperty.prototype.oneWay = function oneWay() {
+      this.set = AliasedProperty_oneWaySet;
+      return this;
+    };
+
+    return AliasedProperty;
+  })(_emberMetalProperties.Descriptor);
+
+  exports.AliasedProperty = AliasedProperty;
 
   function AliasedProperty_readOnlySet(obj, keyName, value) {
     throw new _emberMetalError.default('Cannot set read-only property \'' + keyName + '\' on object: ' + _emberUtils.inspect(obj));
   }
 
-  AliasedProperty.prototype.oneWay = function () {
-    this.set = AliasedProperty_oneWaySet;
-    return this;
-  };
-
   function AliasedProperty_oneWaySet(obj, keyName, value) {
     _emberMetalProperties.defineProperty(obj, keyName, null);
     return _emberMetalProperty_set.set(obj, keyName, value);
@@ -2168,41 +2175,44 @@ enifed('ember-metal/binding', ['exports', 'ember-utils', 'ember-console', 'ember
   // BINDING
   //
 
-  function Binding(toPath, fromPath) {
-    // Configuration
-    this._from = fromPath;
-    this._to = toPath;
-    this._oneWay = undefined;
+  var Binding = (function () {
+    function Binding(toPath, fromPath) {
+      babelHelpers.classCallCheck(this, Binding);
 
-    // State
-    this._direction = undefined;
-    this._readyToSync = undefined;
-    this._fromObj = undefined;
-    this._fromPath = undefined;
-    this._toObj = undefined;
-  }
+      // Configuration
+      this._from = fromPath;
+      this._to = toPath;
+      this._oneWay = undefined;
 
-  /**
-    @class Binding
-    @namespace Ember
-    @deprecated See http://emberjs.com/deprecations/v2.x#toc_ember-binding
-    @public
-  */
+      // State
+      this._direction = undefined;
+      this._readyToSync = undefined;
+      this._fromObj = undefined;
+      this._fromPath = undefined;
+      this._toObj = undefined;
+    }
+
+    /**
+      @class Binding
+      @namespace Ember
+      @deprecated See http://emberjs.com/deprecations/v2.x#toc_ember-binding
+      @public
+    */
 
-  Binding.prototype = {
     /**
       This copies the Binding so it can be connected to another object.
        @method copy
       @return {Ember.Binding} `this`
       @public
     */
-    copy: function () {
+
+    Binding.prototype.copy = function copy() {
       var copy = new Binding(this._to, this._from);
       if (this._oneWay) {
         copy._oneWay = true;
       }
       return copy;
-    },
+    };
 
     // ..........................................................
     // CONFIG
@@ -2220,10 +2230,11 @@ enifed('ember-metal/binding', ['exports', 'ember-utils', 'ember-console', 'ember
       @return {Ember.Binding} `this`
       @public
     */
-    from: function (path) {
+
+    Binding.prototype.from = function from(path) {
       this._from = path;
       return this;
-    },
+    };
 
     /**
       This will set the `to` property path to the specified value. It will not
@@ -2237,10 +2248,11 @@ enifed('ember-metal/binding', ['exports', 'ember-utils', 'ember-console', 'ember
       @return {Ember.Binding} `this`
       @public
     */
-    to: function (path) {
+
+    Binding.prototype.to = function to(path) {
       this._to = path;
       return this;
-    },
+    };
 
     /**
       Configures the binding as one way. A one-way binding will relay changes
@@ -2251,20 +2263,22 @@ enifed('ember-metal/binding', ['exports', 'ember-utils', 'ember-console', 'ember
       @return {Ember.Binding} `this`
       @public
     */
-    oneWay: function () {
+
+    Binding.prototype.oneWay = function oneWay() {
       this._oneWay = true;
       return this;
-    },
+    };
 
     /**
       @method toString
       @return {String} string representation of binding
       @public
     */
-    toString: function () {
+
+    Binding.prototype.toString = function toString() {
       var oneWay = this._oneWay ? '[oneWay]' : '';
       return 'Ember.Binding<' + _emberUtils.guidFor(this) + '>(' + this._from + ' -> ' + this._to + ')' + oneWay;
-    },
+    };
 
     // ..........................................................
     // CONNECT AND SYNC
@@ -2279,7 +2293,8 @@ enifed('ember-metal/binding', ['exports', 'ember-utils', 'ember-console', 'ember
       @return {Ember.Binding} `this`
       @public
     */
-    connect: function (obj) {
+
+    Binding.prototype.connect = function connect(obj) {
       _emberMetalDebug.assert('Must pass a valid object to Ember.Binding.connect()', !!obj);
 
       var fromObj = undefined,
@@ -2323,7 +2338,7 @@ enifed('ember-metal/binding', ['exports', 'ember-utils', 'ember-console', 'ember
       this._toObj = obj;
 
       return this;
-    },
+    };
 
     /**
       Disconnects the binding instance. Changes will no longer be relayed. You
@@ -2332,7 +2347,8 @@ enifed('ember-metal/binding', ['exports', 'ember-utils', 'ember-console', 'ember
       @return {Ember.Binding} `this`
       @public
     */
-    disconnect: function () {
+
+    Binding.prototype.disconnect = function disconnect() {
       _emberMetalDebug.assert('Must pass a valid object to Ember.Binding.disconnect()', !!this._toObj);
 
       // Remove an observer on the object so we're no longer notified of
@@ -2346,23 +2362,25 @@ enifed('ember-metal/binding', ['exports', 'ember-utils', 'ember-console', 'ember
 
       this._readyToSync = false; // Disable scheduled syncs...
       return this;
-    },
+    };
 
     // ..........................................................
     // PRIVATE
     //
 
     /* Called when the from side changes. */
-    fromDidChange: function (target) {
+
+    Binding.prototype.fromDidChange = function fromDidChange(target) {
       this._scheduleSync('fwd');
-    },
+    };
 
     /* Called when the to side changes. */
-    toDidChange: function (target) {
+
+    Binding.prototype.toDidChange = function toDidChange(target) {
       this._scheduleSync('back');
-    },
+    };
 
-    _scheduleSync: function (dir) {
+    Binding.prototype._scheduleSync = function _scheduleSync(dir) {
       var existingDir = this._direction;
 
       // If we haven't scheduled the binding yet, schedule it.
@@ -2376,9 +2394,11 @@ enifed('ember-metal/binding', ['exports', 'ember-utils', 'ember-console', 'ember
       if (existingDir === 'back' && dir === 'fwd') {
         this._direction = 'fwd';
       }
-    },
+    };
+
+    Binding.prototype._sync = function _sync() {
+      var _this = this;
 
-    _sync: function () {
       var log = _emberEnvironment.ENV.LOG_BINDINGS;
 
       var toObj = this._toObj;
@@ -2399,30 +2419,35 @@ enifed('ember-metal/binding', ['exports', 'ember-utils', 'ember-console', 'ember
 
       // If we're synchronizing from the remote object...
       if (direction === 'fwd') {
-        var fromValue = _emberMetalProperty_get.get(fromObj, fromPath);
-        if (log) {
-          _emberConsole.default.log(' ', this.toString(), '->', fromValue, fromObj);
-        }
-        if (this._oneWay) {
-          _emberMetalProperty_set.trySet(toObj, this._to, fromValue);
-        } else {
-          _emberMetalObserver._suspendObserver(toObj, this._to, this, 'toDidChange', function () {
-            _emberMetalProperty_set.trySet(toObj, this._to, fromValue);
-          });
-        }
-        // If we're synchronizing *to* the remote object.
-      } else if (direction === 'back') {
-          var toValue = _emberMetalProperty_get.get(toObj, this._to);
+        (function () {
+          var fromValue = _emberMetalProperty_get.get(fromObj, fromPath);
           if (log) {
-            _emberConsole.default.log(' ', this.toString(), '<-', toValue, toObj);
+            _emberConsole.default.log(' ', _this.toString(), '->', fromValue, fromObj);
           }
-          _emberMetalObserver._suspendObserver(fromObj, fromPath, this, 'fromDidChange', function () {
-            _emberMetalProperty_set.trySet(fromObj, fromPath, toValue);
-          });
+          if (_this._oneWay) {
+            _emberMetalProperty_set.trySet(toObj, _this._to, fromValue);
+          } else {
+            _emberMetalObserver._suspendObserver(toObj, _this._to, _this, 'toDidChange', function () {
+              _emberMetalProperty_set.trySet(toObj, this._to, fromValue);
+            });
+          }
+          // If we're synchronizing *to* the remote object.
+        })();
+      } else if (direction === 'back') {
+          (function () {
+            var toValue = _emberMetalProperty_get.get(toObj, _this._to);
+            if (log) {
+              _emberConsole.default.log(' ', _this.toString(), '<-', toValue, toObj);
+            }
+            _emberMetalObserver._suspendObserver(fromObj, fromPath, _this, 'fromDidChange', function () {
+              _emberMetalProperty_set.trySet(fromObj, fromPath, toValue);
+            });
+          })();
         }
-    }
+    };
 
-  };
+    return Binding;
+  })();
 
   function fireDeprecations(obj, toPath, fromPath, deprecateGlobal, deprecateOneWay, deprecateAlias) {
     var deprecateGlobalMessage = '`Ember.Binding` is deprecated. Since you' + ' are binding to a global consider using a service instead.';
@@ -2734,24 +2759,26 @@ enifed('ember-metal/chains', ['exports', 'ember-utils', 'ember-metal/property_ge
     return !(isObject(obj) && obj.isDescriptor && obj._volatile === false);
   }
 
-  function ChainWatchers() {
-    // chain nodes that reference a key in this obj by key
-    // we only create ChainWatchers when we are going to add them
-    // so create this upfront
-    this.chains = new _emberUtils.EmptyObject();
-  }
+  var ChainWatchers = (function () {
+    function ChainWatchers() {
+      babelHelpers.classCallCheck(this, ChainWatchers);
+
+      // chain nodes that reference a key in this obj by key
+      // we only create ChainWatchers when we are going to add them
+      // so create this upfront
+      this.chains = new _emberUtils.EmptyObject();
+    }
 
-  ChainWatchers.prototype = {
-    add: function (key, node) {
+    ChainWatchers.prototype.add = function add(key, node) {
       var nodes = this.chains[key];
       if (nodes === undefined) {
         this.chains[key] = [node];
       } else {
         nodes.push(node);
       }
-    },
+    };
 
-    remove: function (key, node) {
+    ChainWatchers.prototype.remove = function remove(key, node) {
       var nodes = this.chains[key];
       if (nodes) {
         for (var i = 0; i < nodes.length; i++) {
@@ -2761,9 +2788,9 @@ enifed('ember-metal/chains', ['exports', 'ember-utils', 'ember-metal/property_ge
           }
         }
       }
-    },
+    };
 
-    has: function (key, node) {
+    ChainWatchers.prototype.has = function has(key, node) {
       var nodes = this.chains[key];
       if (nodes) {
         for (var i = 0; i < nodes.length; i++) {
@@ -2773,24 +2800,25 @@ enifed('ember-metal/chains', ['exports', 'ember-utils', 'ember-metal/property_ge
         }
       }
       return false;
-    },
+    };
 
-    revalidateAll: function () {
+    ChainWatchers.prototype.revalidateAll = function revalidateAll() {
       for (var key in this.chains) {
         this.notify(key, true, undefined);
       }
-    },
+    };
 
-    revalidate: function (key) {
+    ChainWatchers.prototype.revalidate = function revalidate(key) {
       this.notify(key, true, undefined);
-    },
+    };
 
     // key: the string key that is part of a path changed
     // revalidate: boolean; the chains that are watching this value should revalidate
     // callback: function that will be called with the object and path that
     //           will be/are invalidated by this key change, depending on
     //           whether the revalidate flag is passed
-    notify: function (key, revalidate, callback) {
+
+    ChainWatchers.prototype.notify = function notify(key, revalidate, callback) {
       var nodes = this.chains[key];
       if (nodes === undefined || nodes.length === 0) {
         return;
@@ -2816,8 +2844,10 @@ enifed('ember-metal/chains', ['exports', 'ember-utils', 'ember-metal/property_ge
         var path = affected[i + 1];
         callback(obj, path);
       }
-    }
-  };
+    };
+
+    return ChainWatchers;
+  })();
 
   function makeChainWatcher() {
     return new ChainWatchers();
@@ -2851,71 +2881,50 @@ enifed('ember-metal/chains', ['exports', 'ember-utils', 'ember-metal/property_ge
   // A ChainNode watches a single key on an object. If you provide a starting
   // value for the key then the node won't actually watch it. For a root node
   // pass null for parent and key and object for value.
-  function ChainNode(parent, key, value) {
-    this._parent = parent;
-    this._key = key;
 
-    // _watching is true when calling get(this._parent, this._key) will
-    // return the value of this node.
-    //
-    // It is false for the root of a chain (because we have no parent)
-    // and for global paths (because the parent node is the object with
-    // the observer on it)
-    this._watching = value === undefined;
+  var ChainNode = (function () {
+    function ChainNode(parent, key, value) {
+      babelHelpers.classCallCheck(this, ChainNode);
 
-    this._chains = undefined;
-    this._object = undefined;
-    this.count = 0;
+      this._parent = parent;
+      this._key = key;
 
-    this._value = value;
-    this._paths = {};
-    if (this._watching) {
-      var obj = parent.value();
+      // _watching is true when calling get(this._parent, this._key) will
+      // return the value of this node.
+      //
+      // It is false for the root of a chain (because we have no parent)
+      // and for global paths (because the parent node is the object with
+      // the observer on it)
+      this._watching = value === undefined;
 
-      if (!isObject(obj)) {
-        return;
-      }
-
-      this._object = obj;
-
-      addChainWatcher(this._object, this._key, this);
-    }
-  }
+      this._chains = undefined;
+      this._object = undefined;
+      this.count = 0;
 
-  function lazyGet(obj, key) {
-    if (!isObject(obj)) {
-      return;
-    }
+      this._value = value;
+      this._paths = {};
+      if (this._watching) {
+        var obj = parent.value();
 
-    var meta = _emberMetalMeta.peekMeta(obj);
+        if (!isObject(obj)) {
+          return;
+        }
 
-    // check if object meant only to be a prototype
-    if (meta && meta.proto === obj) {
-      return;
-    }
+        this._object = obj;
 
-    // Use `get` if the return value is an EachProxy or an uncacheable value.
-    if (isVolatile(obj[key])) {
-      return _emberMetalProperty_get.get(obj, key);
-      // Otherwise attempt to get the cached value of the computed property
-    } else {
-        var cache = meta.readableCache();
-        if (cache) {
-          return _emberMetalComputed.cacheFor.get(cache, key);
-        }
+        addChainWatcher(this._object, this._key, this);
       }
-  }
+    }
 
-  ChainNode.prototype = {
-    value: function () {
+    ChainNode.prototype.value = function value() {
       if (this._value === undefined && this._watching) {
         var obj = this._parent.value();
         this._value = lazyGet(obj, this._key);
       }
       return this._value;
-    },
+    };
 
-    destroy: function () {
+    ChainNode.prototype.destroy = function destroy() {
       if (this._watching) {
         var obj = this._object;
         if (obj) {
@@ -2923,10 +2932,11 @@ enifed('ember-metal/chains', ['exports', 'ember-utils', 'ember-metal/property_ge
         }
         this._watching = false; // so future calls do nothing
       }
-    },
+    };
 
     // copies a top level object only
-    copy: function (obj) {
+
+    ChainNode.prototype.copy = function copy(obj) {
       var ret = new ChainNode(null, null, obj);
       var paths = this._paths;
       var path = undefined;
@@ -2939,11 +2949,12 @@ enifed('ember-metal/chains', ['exports', 'ember-utils', 'ember-metal/property_ge
         ret.add(path);
       }
       return ret;
-    },
+    };
 
     // called on the root node of a chain to setup watchers on the specified
     // path.
-    add: function (path) {
+
+    ChainNode.prototype.add = function add(path) {
       var paths = this._paths;
       paths[path] = (paths[path] || 0) + 1;
 
@@ -2951,11 +2962,12 @@ enifed('ember-metal/chains', ['exports', 'ember-utils', 'ember-metal/property_ge
       var tail = path.slice(key.length + 1);
 
       this.chain(key, tail);
-    },
+    };
 
     // called on the root node of a chain to teardown watcher on the specified
     // path
-    remove: function (path) {
+
+    ChainNode.prototype.remove = function remove(path) {
       var paths = this._paths;
       if (paths[path] > 0) {
         paths[path]--;
@@ -2965,9 +2977,9 @@ enifed('ember-metal/chains', ['exports', 'ember-utils', 'ember-metal/property_ge
       var tail = path.slice(key.length + 1);
 
       this.unchain(key, tail);
-    },
+    };
 
-    chain: function (key, path) {
+    ChainNode.prototype.chain = function chain(key, path) {
       var chains = this._chains;
       var node = undefined;
       if (chains === undefined) {
@@ -2988,9 +3000,9 @@ enifed('ember-metal/chains', ['exports', 'ember-utils', 'ember-metal/property_ge
         path = path.slice(key.length + 1);
         node.chain(key, path);
       }
-    },
+    };
 
-    unchain: function (key, path) {
+    ChainNode.prototype.unchain = function unchain(key, path) {
       var chains = this._chains;
       var node = chains[key];
 
@@ -3007,9 +3019,9 @@ enifed('ember-metal/chains', ['exports', 'ember-utils', 'ember-metal/property_ge
         chains[node._key] = undefined;
         node.destroy();
       }
-    },
+    };
 
-    notify: function (revalidate, affected) {
+    ChainNode.prototype.notify = function notify(revalidate, affected) {
       if (revalidate && this._watching) {
         var parentValue = this._parent.value();
 
@@ -3043,9 +3055,9 @@ enifed('ember-metal/chains', ['exports', 'ember-utils', 'ember-metal/property_ge
       if (affected && this._parent) {
         this._parent.populateAffected(this._key, 1, affected);
       }
-    },
+    };
 
-    populateAffected: function (path, depth, affected) {
+    ChainNode.prototype.populateAffected = function populateAffected(path, depth, affected) {
       if (this._key) {
         path = this._key + '.' + path;
       }
@@ -3057,8 +3069,34 @@ enifed('ember-metal/chains', ['exports', 'ember-utils', 'ember-metal/property_ge
           affected.push(this.value(), path);
         }
       }
+    };
+
+    return ChainNode;
+  })();
+
+  function lazyGet(obj, key) {
+    if (!isObject(obj)) {
+      return;
     }
-  };
+
+    var meta = _emberMetalMeta.peekMeta(obj);
+
+    // check if object meant only to be a prototype
+    if (meta && meta.proto === obj) {
+      return;
+    }
+
+    // Use `get` if the return value is an EachProxy or an uncacheable value.
+    if (isVolatile(obj[key])) {
+      return _emberMetalProperty_get.get(obj, key);
+      // Otherwise attempt to get the cached value of the computed property
+    } else {
+        var cache = meta.readableCache();
+        if (cache) {
+          return _emberMetalComputed.cacheFor.get(cache, key);
+        }
+      }
+  }
 
   function finishChains(obj) {
     // We only create meta if we really have to
@@ -3562,8 +3600,8 @@ enifed('ember-metal/computed', ['exports', 'ember-utils', 'ember-metal/debug', '
           this.setProperties({ firstName, lastName });
           return value;
         }
-      });
-    })
+      })
+    });
   
     let client = Person.create();
     client.get('firstName'); // 'Betty'
@@ -3922,31 +3960,39 @@ enifed("ember-metal/error", ["exports"], function (exports) {
   */
   "use strict";
 
-  exports.default = EmberError;
+  var EmberError = (function (_Error) {
+    babelHelpers.inherits(EmberError, _Error);
 
-  function EmberError(message) {
-    if (!(this instanceof EmberError)) {
-      return new EmberError(message);
-    }
+    function EmberError(message) {
+      babelHelpers.classCallCheck(this, EmberError);
 
-    var error = Error.call(this, message);
+      _Error.call(this);
 
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, EmberError);
-    } else {
-      this.stack = error.stack;
+      if (!(this instanceof EmberError)) {
+        return new EmberError(message);
+      }
+
+      var error = Error.call(this, message);
+
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, EmberError);
+      } else {
+        this.stack = error.stack;
+      }
+
+      this.description = error.description;
+      this.fileName = error.fileName;
+      this.lineNumber = error.lineNumber;
+      this.message = error.message;
+      this.name = error.name;
+      this.number = error.number;
+      this.code = error.code;
     }
 
-    this.description = error.description;
-    this.fileName = error.fileName;
-    this.lineNumber = error.lineNumber;
-    this.message = error.message;
-    this.name = error.name;
-    this.number = error.number;
-    this.code = error.code;
-  }
+    return EmberError;
+  })(Error);
 
-  EmberError.prototype = Object.create(Error.prototype);
+  exports.default = EmberError;
 });
 enifed('ember-metal/error_handler', ['exports', 'ember-console', 'ember-metal/testing'], function (exports, _emberConsole, _emberMetalTesting) {
   'use strict';
@@ -3954,7 +4000,6 @@ enifed('ember-metal/error_handler', ['exports', 'ember-console', 'ember-metal/te
   exports.getOnerror = getOnerror;
   exports.setOnerror = setOnerror;
   exports.dispatchError = dispatchError;
-  exports.getDispatchOverride = getDispatchOverride;
   exports.setDispatchOverride = setDispatchOverride;
 
   // To maintain stacktrace consistency across browsers
@@ -3962,7 +4007,7 @@ enifed('ember-metal/error_handler', ['exports', 'ember-console', 'ember-metal/te
     var stack = error.stack;
     var message = error.message;
 
-    if (stack && stack.indexOf(message) === -1) {
+    if (stack && !stack.includes(message)) {
       stack = message + '\n' + stack;
     }
 
@@ -3995,10 +4040,6 @@ enifed('ember-metal/error_handler', ['exports', 'ember-console', 'ember-metal/te
 
   // allows testing adapter to override dispatch
 
-  function getDispatchOverride() {
-    return dispatchOverride;
-  }
-
   function setDispatchOverride(handler) {
     dispatchOverride = handler;
   }
@@ -4729,6 +4770,9 @@ enifed('ember-metal/injected_property', ['exports', 'ember-utils', 'ember-metal/
   InjectedPropertyPrototype.teardown = ComputedPropertyPrototype.teardown;
 });
 enifed('ember-metal/instrumentation', ['exports', 'ember-environment', 'ember-metal/features'], function (exports, _emberEnvironment, _emberMetalFeatures) {
+  /* eslint no-console:off */
+  /* global console */
+
   'use strict';
 
   exports.instrument = instrument;
@@ -4865,8 +4909,8 @@ enifed('ember-metal/instrumentation', ['exports', 'ember-environment', 'ember-me
       result = payload;
     } finally {
       finalizer();
-      return result;
     }
+    return result;
   }
 
   function NOOP() {}
@@ -5186,8 +5230,6 @@ enifed('ember-metal/is_proxy', ['exports', 'ember-metal/meta'], function (export
 enifed('ember-metal/libraries', ['exports', 'ember-metal/debug', 'ember-metal/features'], function (exports, _emberMetalDebug, _emberMetalFeatures) {
   'use strict';
 
-  exports.Libraries = Libraries;
-
   /**
     Helper class that allows you to register your library with Ember.
   
@@ -5198,10 +5240,22 @@ enifed('ember-metal/libraries', ['exports', 'ember-metal/debug', 'ember-metal/fe
     @private
   */
 
-  function Libraries() {
-    this._registry = [];
-    this._coreLibIndex = 0;
-  }
+  var Libraries = (function () {
+    function Libraries() {
+      babelHelpers.classCallCheck(this, Libraries);
+
+      this._registry = [];
+      this._coreLibIndex = 0;
+    }
+
+    Libraries.prototype.isRegistered = function isRegistered(name) {
+      return !!this._getLibraryByName(name);
+    };
+
+    return Libraries;
+  })();
+
+  exports.Libraries = Libraries;
 
   Libraries.prototype = {
     constructor: Libraries,
@@ -5788,7 +5842,6 @@ enifed('ember-metal/meta', ['exports', 'ember-utils', 'ember-metal/features', 'e
   // Remove "use strict"; from transpiled module until
   // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
 
-  exports.Meta = Meta;
   exports.deleteMeta = deleteMeta;
   exports.meta = meta;
 
@@ -5858,144 +5911,282 @@ enifed('ember-metal/meta', ['exports', 'ember-utils', 'ember-metal/features', 'e
   var memberNames = Object.keys(members);
   var META_FIELD = '__ember_meta__';
 
-  function Meta(obj, parentMeta) {
-    var _this = this;
-
-    _emberMetalDebug.runInDebug(function () {
-      return counters.metaInstantiated++;
-    });
+  var Meta = (function () {
+    function Meta(obj, parentMeta) {
+      var _this = this;
 
-    this._cache = undefined;
-    this._weak = undefined;
-    this._watching = undefined;
-    this._mixins = undefined;
-    this._bindings = undefined;
-    this._values = undefined;
-    this._deps = undefined;
-    this._chainWatchers = undefined;
-    this._chains = undefined;
-    this._tag = undefined;
-    this._tags = undefined;
-
-    // initial value for all flags right now is false
-    // see FLAGS const for detailed list of flags used
-    this._flags = 0;
-
-    // used only internally
-    this.source = obj;
-
-    // when meta(obj).proto === obj, the object is intended to be only a
-    // prototype and doesn't need to actually be observable itself
-    this.proto = undefined;
-
-    // The next meta in our inheritance chain. We (will) track this
-    // explicitly instead of using prototypical inheritance because we
-    // have detailed knowledge of how each property should really be
-    // inherited, and we can optimize it much better than JS runtimes.
-    this.parent = parentMeta;
+      babelHelpers.classCallCheck(this, Meta);
 
-    if (true || false) {
-      this._lastRendered = undefined;
       _emberMetalDebug.runInDebug(function () {
-        _this._lastRenderedReferenceMap = undefined;
-        _this._lastRenderedTemplateMap = undefined;
+        return counters.metaInstantiated++;
       });
+
+      this._cache = undefined;
+      this._weak = undefined;
+      this._watching = undefined;
+      this._mixins = undefined;
+      this._bindings = undefined;
+      this._values = undefined;
+      this._deps = undefined;
+      this._chainWatchers = undefined;
+      this._chains = undefined;
+      this._tag = undefined;
+      this._tags = undefined;
+
+      // initial value for all flags right now is false
+      // see FLAGS const for detailed list of flags used
+      this._flags = 0;
+
+      // used only internally
+      this.source = obj;
+
+      // when meta(obj).proto === obj, the object is intended to be only a
+      // prototype and doesn't need to actually be observable itself
+      this.proto = undefined;
+
+      // The next meta in our inheritance chain. We (will) track this
+      // explicitly instead of using prototypical inheritance because we
+      // have detailed knowledge of how each property should really be
+      // inherited, and we can optimize it much better than JS runtimes.
+      this.parent = parentMeta;
+
+      if (true || false) {
+        this._lastRendered = undefined;
+        _emberMetalDebug.runInDebug(function () {
+          _this._lastRenderedReferenceMap = undefined;
+          _this._lastRenderedTemplateMap = undefined;
+        });
+      }
+
+      this._initializeListeners();
     }
 
-    this._initializeListeners();
-  }
+    Meta.prototype.isInitialized = function isInitialized(obj) {
+      return this.proto !== obj;
+    };
+
+    Meta.prototype.destroy = function destroy() {
+      if (this.isMetaDestroyed()) {
+        return;
+      }
+
+      // remove chainWatchers to remove circular references that would prevent GC
+      var nodes = undefined,
+          key = undefined,
+          nodeObject = undefined;
+      var node = this.readableChains();
+      if (node) {
+        NODE_STACK.push(node);
+        // process tree
+        while (NODE_STACK.length > 0) {
+          node = NODE_STACK.pop();
+          // push children
+          nodes = node._chains;
+          if (nodes) {
+            for (key in nodes) {
+              if (nodes[key] !== undefined) {
+                NODE_STACK.push(nodes[key]);
+              }
+            }
+          }
+
+          // remove chainWatcher in node object
+          if (node._watching) {
+            nodeObject = node._object;
+            if (nodeObject) {
+              var foreignMeta = peekMeta(nodeObject);
+              // avoid cleaning up chain watchers when both current and
+              // foreign objects are being destroyed
+              // if both are being destroyed manual cleanup is not needed
+              // as they will be GC'ed and no non-destroyed references will
+              // be remaining
+              if (foreignMeta && !foreignMeta.isSourceDestroying()) {
+                _emberMetalChains.removeChainWatcher(nodeObject, node._key, node, foreignMeta);
+              }
+            }
+          }
+        }
+      }
+
+      this.setMetaDestroyed();
+    };
+
+    Meta.prototype.isSourceDestroying = function isSourceDestroying() {
+      return (this._flags & SOURCE_DESTROYING) !== 0;
+    };
+
+    Meta.prototype.setSourceDestroying = function setSourceDestroying() {
+      this._flags |= SOURCE_DESTROYING;
+    };
+
+    Meta.prototype.isSourceDestroyed = function isSourceDestroyed() {
+      return (this._flags & SOURCE_DESTROYED) !== 0;
+    };
+
+    Meta.prototype.setSourceDestroyed = function setSourceDestroyed() {
+      this._flags |= SOURCE_DESTROYED;
+    };
+
+    Meta.prototype.isMetaDestroyed = function isMetaDestroyed() {
+      return (this._flags & META_DESTROYED) !== 0;
+    };
+
+    Meta.prototype.setMetaDestroyed = function setMetaDestroyed() {
+      this._flags |= META_DESTROYED;
+    };
+
+    Meta.prototype.isProxy = function isProxy() {
+      return (this._flags & IS_PROXY) !== 0;
+    };
+
+    Meta.prototype.setProxy = function setProxy() {
+      this._flags |= IS_PROXY;
+    };
+
+    Meta.prototype._getOrCreateOwnMap = function _getOrCreateOwnMap(key) {
+      return this[key] || (this[key] = new _emberUtils.EmptyObject());
+    };
+
+    Meta.prototype._getInherited = function _getInherited(key) {
+      var pointer = this;
+      while (pointer !== undefined) {
+        if (pointer[key]) {
+          return pointer[key];
+        }
+        pointer = pointer.parent;
+      }
+    };
+
+    Meta.prototype._findInherited = function _findInherited(key, subkey) {
+      var pointer = this;
+      while (pointer !== undefined) {
+        var map = pointer[key];
+        if (map) {
+          var value = map[subkey];
+          if (value !== undefined) {
+            return value;
+          }
+        }
+        pointer = pointer.parent;
+      }
+    };
 
-  Meta.prototype.isInitialized = function (obj) {
-    return this.proto !== obj;
-  };
+    // Implements a member that provides a lazily created map of maps,
+    // with inheritance at both levels.
 
-  var NODE_STACK = [];
+    Meta.prototype.writeDeps = function writeDeps(subkey, itemkey, value) {
+      _emberMetalDebug.assert('Cannot call writeDeps after the object is destroyed.', !this.isMetaDestroyed());
 
-  Meta.prototype.destroy = function () {
-    if (this.isMetaDestroyed()) {
-      return;
-    }
+      var outerMap = this._getOrCreateOwnMap('_deps');
+      var innerMap = outerMap[subkey];
+      if (!innerMap) {
+        innerMap = outerMap[subkey] = new _emberUtils.EmptyObject();
+      }
+      innerMap[itemkey] = value;
+    };
 
-    // remove chainWatchers to remove circular references that would prevent GC
-    var node = undefined,
-        nodes = undefined,
-        key = undefined,
-        nodeObject = undefined;
-    node = this.readableChains();
-    if (node) {
-      NODE_STACK.push(node);
-      // process tree
-      while (NODE_STACK.length > 0) {
-        node = NODE_STACK.pop();
-        // push children
-        nodes = node._chains;
-        if (nodes) {
-          for (key in nodes) {
-            if (nodes[key] !== undefined) {
-              NODE_STACK.push(nodes[key]);
+    Meta.prototype.peekDeps = function peekDeps(subkey, itemkey) {
+      var pointer = this;
+      while (pointer !== undefined) {
+        var map = pointer._deps;
+        if (map) {
+          var value = map[subkey];
+          if (value) {
+            if (value[itemkey] !== undefined) {
+              return value[itemkey];
             }
           }
         }
+        pointer = pointer.parent;
+      }
+    };
+
+    Meta.prototype.hasDeps = function hasDeps(subkey) {
+      var pointer = this;
+      while (pointer !== undefined) {
+        if (pointer._deps && pointer._deps[subkey]) {
+          return true;
+        }
+        pointer = pointer.parent;
+      }
+      return false;
+    };
+
+    Meta.prototype.forEachInDeps = function forEachInDeps(subkey, fn) {
+      return this._forEachIn('_deps', subkey, fn);
+    };
 
-        // remove chainWatcher in node object
-        if (node._watching) {
-          nodeObject = node._object;
-          if (nodeObject) {
-            var foreignMeta = peekMeta(nodeObject);
-            // avoid cleaning up chain watchers when both current and
-            // foreign objects are being destroyed
-            // if both are being destroyed manual cleanup is not needed
-            // as they will be GC'ed and no non-destroyed references will
-            // be remaining
-            if (foreignMeta && !foreignMeta.isSourceDestroying()) {
-              _emberMetalChains.removeChainWatcher(nodeObject, node._key, node, foreignMeta);
+    Meta.prototype._forEachIn = function _forEachIn(key, subkey, fn) {
+      var pointer = this;
+      var seen = new _emberUtils.EmptyObject();
+      var calls = [];
+      while (pointer !== undefined) {
+        var map = pointer[key];
+        if (map) {
+          var innerMap = map[subkey];
+          if (innerMap) {
+            for (var innerKey in innerMap) {
+              if (!seen[innerKey]) {
+                seen[innerKey] = true;
+                calls.push([innerKey, innerMap[innerKey]]);
+              }
             }
           }
         }
+        pointer = pointer.parent;
       }
-    }
+      for (var i = 0; i < calls.length; i++) {
+        var _calls$i = calls[i];
+        var innerKey = _calls$i[0];
+        var value = _calls$i[1];
 
-    this.setMetaDestroyed();
-  };
+        fn(innerKey, value);
+      }
+    };
 
-  for (var _name in _emberMetalMeta_listeners.protoMethods) {
-    Meta.prototype[_name] = _emberMetalMeta_listeners.protoMethods[_name];
-  }
-  memberNames.forEach(function (name) {
-    return members[name](name, Meta);
-  });
+    Meta.prototype.readInheritedValue = function readInheritedValue(key, subkey) {
+      var internalKey = '_' + key;
 
-  Meta.prototype.isSourceDestroying = function isSourceDestroying() {
-    return (this._flags & SOURCE_DESTROYING) !== 0;
-  };
+      var pointer = this;
 
-  Meta.prototype.setSourceDestroying = function setSourceDestroying() {
-    this._flags |= SOURCE_DESTROYING;
-  };
+      while (pointer !== undefined) {
+        var map = pointer[internalKey];
+        if (map) {
+          var value = map[subkey];
+          if (value !== undefined || subkey in map) {
+            return map[subkey];
+          }
+        }
+        pointer = pointer.parent;
+      }
 
-  Meta.prototype.isSourceDestroyed = function isSourceDestroyed() {
-    return (this._flags & SOURCE_DESTROYED) !== 0;
-  };
+      return UNDEFINED;
+    };
 
-  Meta.prototype.setSourceDestroyed = function setSourceDestroyed() {
-    this._flags |= SOURCE_DESTROYED;
-  };
+    Meta.prototype.writeValue = function writeValue(obj, key, value) {
+      var descriptor = _emberUtils.lookupDescriptor(obj, key);
+      var isMandatorySetter = descriptor && descriptor.set && descriptor.set.isMandatorySetter;
 
-  Meta.prototype.isMetaDestroyed = function isMetaDestroyed() {
-    return (this._flags & META_DESTROYED) !== 0;
-  };
+      if (isMandatorySetter) {
+        this.writeValues(key, value);
+      } else {
+        obj[key] = value;
+      }
+    };
 
-  Meta.prototype.setMetaDestroyed = function setMetaDestroyed() {
-    this._flags |= META_DESTROYED;
-  };
+    return Meta;
+  })();
 
-  Meta.prototype.isProxy = function isProxy() {
-    return (this._flags & IS_PROXY) !== 0;
-  };
+  exports.Meta = Meta;
 
-  Meta.prototype.setProxy = function setProxy() {
-    this._flags |= IS_PROXY;
-  };
+  var NODE_STACK = [];
+
+  for (var _name in _emberMetalMeta_listeners.protoMethods) {
+    Meta.prototype[_name] = _emberMetalMeta_listeners.protoMethods[_name];
+  }
+  memberNames.forEach(function (name) {
+    return members[name](name, Meta);
+  });
 
   // Implements a member that is a lazily created, non-inheritable
   // POJO.
@@ -6010,14 +6201,6 @@ enifed('ember-metal/meta', ['exports', 'ember-utils', 'ember-metal/features', 'e
     };
   }
 
-  Meta.prototype._getOrCreateOwnMap = function (key) {
-    var ret = this[key];
-    if (!ret) {
-      ret = this[key] = new _emberUtils.EmptyObject();
-    }
-    return ret;
-  };
-
   // Implements a member that is a lazily created POJO with inheritable
   // values.
   function inheritedMap(name, Meta) {
@@ -6067,105 +6250,9 @@ enifed('ember-metal/meta', ['exports', 'ember-utils', 'ember-metal/features', 'e
     };
   }
 
-  Meta.prototype._getInherited = function (key) {
-    var pointer = this;
-    while (pointer !== undefined) {
-      if (pointer[key]) {
-        return pointer[key];
-      }
-      pointer = pointer.parent;
-    }
-  };
-
-  Meta.prototype._findInherited = function (key, subkey) {
-    var pointer = this;
-    while (pointer !== undefined) {
-      var map = pointer[key];
-      if (map) {
-        var value = map[subkey];
-        if (value !== undefined) {
-          return value;
-        }
-      }
-      pointer = pointer.parent;
-    }
-  };
-
   var UNDEFINED = _emberUtils.symbol('undefined');
 
   exports.UNDEFINED = UNDEFINED;
-  // Implements a member that provides a lazily created map of maps,
-  // with inheritance at both levels.
-  Meta.prototype.writeDeps = function writeDeps(subkey, itemkey, value) {
-    _emberMetalDebug.assert('Cannot call writeDeps after the object is destroyed.', !this.isMetaDestroyed());
-
-    var outerMap = this._getOrCreateOwnMap('_deps');
-    var innerMap = outerMap[subkey];
-    if (!innerMap) {
-      innerMap = outerMap[subkey] = new _emberUtils.EmptyObject();
-    }
-    innerMap[itemkey] = value;
-  };
-
-  Meta.prototype.peekDeps = function peekDeps(subkey, itemkey) {
-    var pointer = this;
-    while (pointer !== undefined) {
-      var map = pointer._deps;
-      if (map) {
-        var value = map[subkey];
-        if (value) {
-          if (value[itemkey] !== undefined) {
-            return value[itemkey];
-          }
-        }
-      }
-      pointer = pointer.parent;
-    }
-  };
-
-  Meta.prototype.hasDeps = function hasDeps(subkey) {
-    var pointer = this;
-    while (pointer !== undefined) {
-      if (pointer._deps && pointer._deps[subkey]) {
-        return true;
-      }
-      pointer = pointer.parent;
-    }
-    return false;
-  };
-
-  Meta.prototype.forEachInDeps = function forEachInDeps(subkey, fn) {
-    return this._forEachIn('_deps', subkey, fn);
-  };
-
-  Meta.prototype._forEachIn = function (key, subkey, fn) {
-    var pointer = this;
-    var seen = new _emberUtils.EmptyObject();
-    var calls = [];
-    while (pointer !== undefined) {
-      var map = pointer[key];
-      if (map) {
-        var innerMap = map[subkey];
-        if (innerMap) {
-          for (var innerKey in innerMap) {
-            if (!seen[innerKey]) {
-              seen[innerKey] = true;
-              calls.push([innerKey, innerMap[innerKey]]);
-            }
-          }
-        }
-      }
-      pointer = pointer.parent;
-    }
-    for (var i = 0; i < calls.length; i++) {
-      var _calls$i = calls[i];
-      var innerKey = _calls$i[0];
-      var value = _calls$i[1];
-
-      fn(innerKey, value);
-    }
-  };
-
   // Implements a member that provides a non-heritable, lazily-created
   // object using the method you provide.
   function ownCustomObject(name, Meta) {
@@ -6572,7 +6659,6 @@ enifed('ember-metal/mixin', ['exports', 'ember-utils', 'ember-metal/error', 'emb
   */
   exports.detectBinding = detectBinding;
   exports.mixin = mixin;
-  exports.default = Mixin;
   exports.hasUnprocessedMixins = hasUnprocessedMixins;
   exports.clearUnprocessedMixins = clearUnprocessedMixins;
   exports.required = required;
@@ -6584,7 +6670,9 @@ enifed('ember-metal/mixin', ['exports', 'ember-utils', 'ember-metal/error', 'emb
   function ROOT() {}
   ROOT.__hasSuper = false;
 
-  var a_slice = [].slice;
+  var a_slice = Array.prototype.slice;
+  var a_concat = Array.prototype.concat;
+  var isArray = Array.isArray;
 
   function isMethod(obj) {
     return 'function' === typeof obj && obj.isMethod !== false && obj !== Boolean && obj !== Object && obj !== Number && obj !== Array && obj !== Date && obj !== String;
@@ -6608,14 +6696,11 @@ enifed('ember-metal/mixin', ['exports', 'ember-utils', 'ember-metal/error', 'emb
   }
 
   function concatenatedMixinProperties(concatProp, props, values, base) {
-    var concats = undefined;
-
     // reset before adding each new mixin to pickup concats from previous
-    concats = values[concatProp] || base[concatProp];
+    var concats = values[concatProp] || base[concatProp];
     if (props[concatProp]) {
-      concats = concats ? concats.concat(props[concatProp]) : props[concatProp];
+      concats = concats ? a_concat.call(concats, props[concatProp]) : props[concatProp];
     }
-
     return concats;
   }
 
@@ -6682,18 +6767,18 @@ enifed('ember-metal/mixin', ['exports', 'ember-utils', 'ember-metal/error', 'emb
     var baseValue = values[key] || obj[key];
     var ret = undefined;
 
-    if (baseValue) {
-      if ('function' === typeof baseValue.concat) {
+    if (baseValue === null || baseValue === undefined) {
+      ret = _emberUtils.makeArray(value);
+    } else {
+      if (isArray(baseValue)) {
         if (value === null || value === undefined) {
           ret = baseValue;
         } else {
-          ret = baseValue.concat(value);
+          ret = a_concat.call(baseValue, value);
         }
       } else {
-        ret = _emberUtils.makeArray(baseValue).concat(value);
+        ret = a_concat.call(_emberUtils.makeArray(baseValue), value);
       }
-    } else {
-      ret = _emberUtils.makeArray(value);
     }
 
     _emberMetalDebug.runInDebug(function () {
@@ -6712,7 +6797,7 @@ enifed('ember-metal/mixin', ['exports', 'ember-utils', 'ember-metal/error', 'emb
     var baseValue = values[key] || obj[key];
 
     _emberMetalDebug.runInDebug(function () {
-      if (Array.isArray(value)) {
+      if (isArray(value)) {
         // use conditional to avoid stringifying every time
         _emberMetalDebug.assert('You passed in `' + JSON.stringify(value) + '` as the value for `' + key + '` but `' + key + '` cannot be an Array', false);
       }
@@ -7039,40 +7124,87 @@ enifed('ember-metal/mixin', ['exports', 'ember-utils', 'ember-metal/error', 'emb
     @public
   */
 
-  function Mixin(args, properties) {
-    this.properties = properties;
+  var Mixin = (function () {
+    function Mixin(args, properties) {
+      babelHelpers.classCallCheck(this, Mixin);
 
-    var length = args && args.length;
+      this.properties = properties;
 
-    if (length > 0) {
-      var m = new Array(length);
+      var length = args && args.length;
 
-      for (var i = 0; i < length; i++) {
-        var x = args[i];
-        if (x instanceof Mixin) {
-          m[i] = x;
-        } else {
-          m[i] = new Mixin(undefined, x);
+      if (length > 0) {
+        var m = new Array(length);
+
+        for (var i = 0; i < length; i++) {
+          var x = args[i];
+          if (x instanceof Mixin) {
+            m[i] = x;
+          } else {
+            m[i] = new Mixin(undefined, x);
+          }
         }
-      }
 
-      this.mixins = m;
-    } else {
-      this.mixins = undefined;
+        this.mixins = m;
+      } else {
+        this.mixins = undefined;
+      }
+      this.ownerConstructor = undefined;
+      this._without = undefined;
+      this[_emberUtils.GUID_KEY] = null;
+      this[_emberUtils.NAME_KEY] = null;
+      _emberMetalDebug.debugSeal(this);
     }
-    this.ownerConstructor = undefined;
-    this._without = undefined;
-    this[_emberUtils.GUID_KEY] = null;
-    this[_emberUtils.NAME_KEY] = null;
-    _emberMetalDebug.debugSeal(this);
-  }
 
-  Mixin._apply = applyMixin;
+    Mixin.applyPartial = function applyPartial(obj) {
+      var args = a_slice.call(arguments, 1);
+      return applyMixin(obj, args, true);
+    };
 
-  Mixin.applyPartial = function (obj) {
-    var args = a_slice.call(arguments, 1);
-    return applyMixin(obj, args, true);
-  };
+    /**
+      @method create
+      @static
+      @param arguments*
+      @public
+    */
+
+    Mixin.create = function create() {
+      // ES6TODO: this relies on a global state?
+      unprocessedFlag = true;
+      var M = this;
+
+      for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+
+      return new M(args, undefined);
+    };
+
+    // returns the mixins currently applied to the specified object
+    // TODO: Make Ember.mixin
+
+    Mixin.mixins = function mixins(obj) {
+      var m = _emberMetalMeta.peekMeta(obj);
+      var ret = [];
+      if (!m) {
+        return ret;
+      }
+
+      m.forEachMixins(function (key, currentMixin) {
+        // skip primitive mixins since these are always anonymous
+        if (!currentMixin.properties) {
+          ret.push(currentMixin);
+        }
+      });
+
+      return ret;
+    };
+
+    return Mixin;
+  })();
+
+  exports.default = Mixin;
+
+  Mixin._apply = applyMixin;
 
   Mixin.finishPartial = finishPartial;
 
@@ -7086,24 +7218,6 @@ enifed('ember-metal/mixin', ['exports', 'ember-utils', 'ember-metal/error', 'emb
     unprocessedFlag = false;
   }
 
-  /**
-    @method create
-    @static
-    @param arguments*
-    @public
-  */
-  Mixin.create = function () {
-    // ES6TODO: this relies on a global state?
-    unprocessedFlag = true;
-    var M = this;
-
-    for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-      args[_key2] = arguments[_key2];
-    }
-
-    return new M(args, undefined);
-  };
-
   var MixinPrototype = Mixin.prototype;
 
   /**
@@ -7237,25 +7351,6 @@ enifed('ember-metal/mixin', ['exports', 'ember-utils', 'ember-metal/error', 'emb
 
   _emberMetalDebug.debugSeal(MixinPrototype);
 
-  // returns the mixins currently applied to the specified object
-  // TODO: Make Ember.mixin
-  Mixin.mixins = function (obj) {
-    var m = _emberMetalMeta.peekMeta(obj);
-    var ret = [];
-    if (!m) {
-      return ret;
-    }
-
-    m.forEachMixins(function (key, currentMixin) {
-      // skip primitive mixins since these are always anonymous
-      if (!currentMixin.properties) {
-        ret.push(currentMixin);
-      }
-    });
-
-    return ret;
-  };
-
   var REQUIRED = new _emberMetalProperties.Descriptor();
   REQUIRED.toString = function () {
     return '(Required Property)';
@@ -7459,7 +7554,6 @@ enifed('ember-metal/mixin', ['exports', 'ember-utils', 'ember-metal/error', 'emb
   }
 
   exports.Mixin = Mixin;
-  exports.required = required;
   exports.REQUIRED = REQUIRED;
 });
 enifed('ember-metal/observer', ['exports', 'ember-metal/watching', 'ember-metal/events'], function (exports, _emberMetalWatching, _emberMetalEvents) {
@@ -7579,8 +7673,6 @@ enifed('ember-metal/observer', ['exports', 'ember-metal/watching', 'ember-metal/
 enifed('ember-metal/observer_set', ['exports', 'ember-utils', 'ember-metal/events'], function (exports, _emberUtils, _emberMetalEvents) {
   'use strict';
 
-  exports.default = ObserverSet;
-
   /*
     this.observerSet = {
       [senderGuid]: { // variable name: `keySet`
@@ -7600,53 +7692,61 @@ enifed('ember-metal/observer_set', ['exports', 'ember-utils', 'ember-metal/event
     ]
   */
 
-  function ObserverSet() {
-    this.clear();
-  }
-
-  ObserverSet.prototype.add = function (sender, keyName, eventName) {
-    var observerSet = this.observerSet;
-    var observers = this.observers;
-    var senderGuid = _emberUtils.guidFor(sender);
-    var keySet = observerSet[senderGuid];
-    var index = undefined;
+  var ObserverSet = (function () {
+    function ObserverSet() {
+      babelHelpers.classCallCheck(this, ObserverSet);
 
-    if (!keySet) {
-      observerSet[senderGuid] = keySet = {};
-    }
-    index = keySet[keyName];
-    if (index === undefined) {
-      index = observers.push({
-        sender: sender,
-        keyName: keyName,
-        eventName: eventName,
-        listeners: []
-      }) - 1;
-      keySet[keyName] = index;
+      this.clear();
     }
-    return observers[index].listeners;
-  };
 
-  ObserverSet.prototype.flush = function () {
-    var observers = this.observers;
-    var i = undefined,
-        observer = undefined,
-        sender = undefined;
-    this.clear();
-    for (i = 0; i < observers.length; ++i) {
-      observer = observers[i];
-      sender = observer.sender;
-      if (sender.isDestroying || sender.isDestroyed) {
-        continue;
+    ObserverSet.prototype.add = function add(sender, keyName, eventName) {
+      var observerSet = this.observerSet;
+      var observers = this.observers;
+      var senderGuid = _emberUtils.guidFor(sender);
+      var keySet = observerSet[senderGuid];
+      var index = undefined;
+
+      if (!keySet) {
+        observerSet[senderGuid] = keySet = {};
       }
-      _emberMetalEvents.sendEvent(sender, observer.eventName, [sender, observer.keyName], observer.listeners);
-    }
-  };
+      index = keySet[keyName];
+      if (index === undefined) {
+        index = observers.push({
+          sender: sender,
+          keyName: keyName,
+          eventName: eventName,
+          listeners: []
+        }) - 1;
+        keySet[keyName] = index;
+      }
+      return observers[index].listeners;
+    };
 
-  ObserverSet.prototype.clear = function () {
-    this.observerSet = {};
-    this.observers = [];
-  };
+    ObserverSet.prototype.flush = function flush() {
+      var observers = this.observers;
+      var i = undefined,
+          observer = undefined,
+          sender = undefined;
+      this.clear();
+      for (i = 0; i < observers.length; ++i) {
+        observer = observers[i];
+        sender = observer.sender;
+        if (sender.isDestroying || sender.isDestroyed) {
+          continue;
+        }
+        _emberMetalEvents.sendEvent(sender, observer.eventName, [sender, observer.keyName], observer.listeners);
+      }
+    };
+
+    ObserverSet.prototype.clear = function clear() {
+      this.observerSet = {};
+      this.observers = [];
+    };
+
+    return ObserverSet;
+  })();
+
+  exports.default = ObserverSet;
 });
 enifed('ember-metal/path_cache', ['exports', 'ember-metal/cache'], function (exports, _emberMetalCache) {
   'use strict';
@@ -8569,7 +8669,7 @@ enifed('ember-metal/run_loop', ['exports', 'ember-utils', 'ember-metal/debug', '
 
   var onErrorTarget = {
     get onerror() {
-      return _emberMetalError_handler.dispatchError;
+      return _emberMetalError_handler.getOnerror();
     },
     set onerror(handler) {
       return _emberMetalError_handler.setOnerror(handler);
@@ -10628,7 +10728,7 @@ enifed('ember-template-compiler/plugins/transform-input-type-syntax', ['exports'
       }
     }
     if (pair && pair.value.type !== 'StringLiteral') {
-      node.params.unshift(builders.sexpr('-input-type', [pair.value], null, pair.loc));
+      node.params.unshift(builders.sexpr('-input-type', [builders.path(pair.value.original, pair.loc)], null, pair.loc));
     }
   }
 });
@@ -11076,8 +11176,8 @@ enifed('ember-template-compiler/system/calculate-location-display', ['exports'],
 
   exports.default = calculateLocationDisplay;
 
-  function calculateLocationDisplay(moduleName, _loc) {
-    var loc = _loc || {};
+  function calculateLocationDisplay(moduleName) {
+    var loc = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
 
     var _ref = loc.start || {};
 
@@ -11548,7 +11648,7 @@ enifed('ember-utils/guid', ['exports', 'ember-utils/intern'], function (exports,
     }
   }
 });
-enifed('ember-utils/index', ['exports', 'ember-utils/symbol', 'ember-utils/owner', 'ember-utils/assign', 'ember-utils/empty-object', 'ember-utils/dictionary', 'ember-utils/guid', 'ember-utils/intern', 'ember-utils/super', 'ember-utils/inspect', 'ember-utils/lookup-descriptor', 'ember-utils/invoke', 'ember-utils/make-array', 'ember-utils/apply-str', 'ember-utils/name', 'ember-utils/to-string', 'ember-utils/weak-map-utils'], function (exports, _emberUtilsSymbol, _emberUtilsOwner, _emberUtilsAssign, _emberUtilsEmptyObject, _emberUtilsDictionary, _emberUtilsGuid, _emberUtilsIntern, _emberUtilsSuper, _emberUtilsInspect, _emberUtilsLookupDescriptor, _emberUtilsInvoke, _emberUtilsMakeArray, _emberUtilsApplyStr, _emberUtilsName, _emberUtilsToString, _emberUtilsWeakMapUtils) {
+enifed('ember-utils/index', ['exports', 'ember-utils/symbol', 'ember-utils/owner', 'ember-utils/assign', 'ember-utils/empty-object', 'ember-utils/dictionary', 'ember-utils/guid', 'ember-utils/intern', 'ember-utils/super', 'ember-utils/inspect', 'ember-utils/lookup-descriptor', 'ember-utils/invoke', 'ember-utils/make-array', 'ember-utils/apply-str', 'ember-utils/name', 'ember-utils/to-string', 'ember-utils/weak-map-utils', 'ember-utils/proxy-utils'], function (exports, _emberUtilsSymbol, _emberUtilsOwner, _emberUtilsAssign, _emberUtilsEmptyObject, _emberUtilsDictionary, _emberUtilsGuid, _emberUtilsIntern, _emberUtilsSuper, _emberUtilsInspect, _emberUtilsLookupDescriptor, _emberUtilsInvoke, _emberUtilsMakeArray, _emberUtilsApplyStr, _emberUtilsName, _emberUtilsToString, _emberUtilsWeakMapUtils, _emberUtilsProxyUtils) {
   /*
    This package will be eagerly parsed and should have no dependencies on external
    packages.
@@ -11587,6 +11687,7 @@ enifed('ember-utils/index', ['exports', 'ember-utils/symbol', 'ember-utils/owner
   exports.NAME_KEY = _emberUtilsName.default;
   exports.toString = _emberUtilsToString.default;
   exports.HAS_NATIVE_WEAKMAP = _emberUtilsWeakMapUtils.HAS_NATIVE_WEAKMAP;
+  exports.HAS_NATIVE_PROXY = _emberUtilsProxyUtils.HAS_NATIVE_PROXY;
 });
 enifed('ember-utils/inspect', ['exports'], function (exports) {
   'use strict';
@@ -11784,6 +11885,11 @@ enifed("ember-utils/lookup-descriptor", ["exports"], function (exports) {
   }
 });
 enifed("ember-utils/make-array", ["exports"], function (exports) {
+  "use strict";
+
+  exports.default = makeArray;
+  var isArray = Array.isArray;
+
   /**
    Forces the passed object to be part of an array. If the object is already
    an array, it will return the object. Otherwise, it will add the object to
@@ -11807,15 +11913,12 @@ enifed("ember-utils/make-array", ["exports"], function (exports) {
    @return {Array}
    @private
    */
-  "use strict";
-
-  exports.default = makeArray;
 
   function makeArray(obj) {
     if (obj === null || obj === undefined) {
       return [];
     }
-    return Array.isArray(obj) ? obj : [obj];
+    return isArray(obj) ? obj : [obj];
   }
 });
 enifed('ember-utils/name', ['exports', 'ember-utils/symbol'], function (exports, _emberUtilsSymbol) {
@@ -11849,7 +11952,8 @@ enifed('ember-utils/owner', ['exports', 'ember-utils/symbol'], function (exports
     For example, this component dynamically looks up a service based on the
     `audioType` passed as an attribute:
   
-    ```app/components/play-audio.js
+    ```
+    // app/components/play-audio.js
     import Ember from 'ember';
   
     // Usage:
@@ -11896,6 +12000,12 @@ enifed('ember-utils/owner', ['exports', 'ember-utils/symbol'], function (exports
     object[OWNER] = owner;
   }
 });
+enifed('ember-utils/proxy-utils', ['exports'], function (exports) {
+  'use strict';
+
+  var HAS_NATIVE_PROXY = typeof Proxy === 'function';
+  exports.HAS_NATIVE_PROXY = HAS_NATIVE_PROXY;
+});
 enifed('ember-utils/super', ['exports'], function (exports) {
   'use strict';
 
@@ -12023,12 +12133,12 @@ enifed('ember-utils/weak-map-utils', ['exports'], function (exports) {
 enifed("ember/features", ["exports"], function (exports) {
   "use strict";
 
-  exports.default = { "features-stripped-test": false, "ember-libraries-isregistered": false, "ember-runtime-computed-uniq-by": true, "ember-improved-instrumentation": false, "ember-runtime-enumerable-includes": true, "ember-string-ishtmlsafe": true, "ember-testing-check-waiters": true, "ember-metal-weakmap": false, "ember-glimmer-allow-backtracking-rerender": false, "ember-testing-resume-test": false, "mandatory-setter": true, "ember-glimmer-detect-backtracking-rerender": true };
+  exports.default = { "features-stripped-test": false, "ember-libraries-isregistered": false, "ember-improved-instrumentation": false, "ember-metal-weakmap": false, "ember-glimmer-allow-backtracking-rerender": false, "ember-testing-resume-test": false, "ember-factory-for": true, "ember-no-double-extend": false, "mandatory-setter": true, "ember-glimmer-detect-backtracking-rerender": true };
 });
 enifed("ember/version", ["exports"], function (exports) {
   "use strict";
 
-  exports.default = "2.11.3";
+  exports.default = "2.12.0-beta.1";
 });
 enifed("glimmer-compiler/index", ["exports", "glimmer-compiler/lib/compiler", "glimmer-compiler/lib/template-visitor"], function (exports, _glimmerCompilerLibCompiler, _glimmerCompilerLibTemplateVisitor) {
   "use strict";