ember-source 2.17.2 → 2.18.0.beta.1

data/dist/ember-template-compiler.js

@@ -6,51 +6,14 @@
  *            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.17.2
+ * @version   2.18.0-beta.1
  */
 
+/*global process */
 var enifed, requireModule, Ember;
 var mainContext = this; // Used in ember-environment/lib/global.js
 
 (function() {
-  var isNode = typeof window === 'undefined' &&
-    typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
-
-  if (!isNode) {
-    Ember = this.Ember = this.Ember || {};
-  }
-
-  if (typeof Ember === 'undefined') { Ember = {}; }
-
-  if (typeof Ember.__loader === 'undefined') {
-    var registry = {};
-    var seen = {};
-
-    enifed = function(name, deps, callback) {
-      var value = { };
-
-      if (!callback) {
-        value.deps = [];
-        value.callback = deps;
-      } else {
-        value.deps = deps;
-        value.callback = callback;
-      }
-
-      registry[name] = value;
-    };
-
-    requireModule = function(name) {
-      return internalRequire(name, null);
-    };
-
-    // setup `require` module
-    requireModule['default'] = requireModule;
-
-    requireModule.has = function registryHas(moduleName) {
-      return !!registry[moduleName] || !!registry[moduleName + '/index'];
-    };
-
     function missingModule(name, referrerName) {
       if (referrerName) {
         throw new Error('Could not find module ' + name + ' required by: ' + referrerName);
@@ -99,6 +62,44 @@ var mainContext = this; // Used in ember-environment/lib/global.js
       return exports;
     }
 
+  var isNode = typeof window === 'undefined' &&
+    typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
+
+  if (!isNode) {
+    Ember = this.Ember = this.Ember || {};
+  }
+
+  if (typeof Ember === 'undefined') { Ember = {}; }
+
+  if (typeof Ember.__loader === 'undefined') {
+    var registry = {};
+    var seen = {};
+
+    enifed = function(name, deps, callback) {
+      var value = { };
+
+      if (!callback) {
+        value.deps = [];
+        value.callback = deps;
+      } else {
+        value.deps = deps;
+        value.callback = callback;
+      }
+
+      registry[name] = value;
+    };
+
+    requireModule = function(name) {
+      return internalRequire(name, null);
+    };
+
+    // setup `require` module
+    requireModule['default'] = requireModule;
+
+    requireModule.has = function registryHas(moduleName) {
+      return !!registry[moduleName] || !!registry[moduleName + '/index'];
+    };
+
     requireModule._eak_seen = registry;
 
     Ember.__loader = {
@@ -4586,7 +4587,7 @@ enifed('backburner', ['exports'], function (exports) {
         var index = -1,
             i,
             l;
-        for (i = 0, l = collection.length; i < l; i += 3) {
+        for (i = 0, l = collection.length; i < l; i += 4) {
             if (collection[i] === target && collection[i + 1] === method) {
                 index = i;
                 break;
@@ -4597,9 +4598,9 @@ enifed('backburner', ['exports'], function (exports) {
     function findTimer(timer, collection) {
         var index = -1,
             i;
-        for (i = 2; i < collection.length; i += 3) {
+        for (i = 3; i < collection.length; i += 4) {
             if (collection[i] === timer) {
-                index = i - 2;
+                index = i - 3;
                 break;
             }
         }
@@ -4633,10 +4634,10 @@ enifed('backburner', ['exports'], function (exports) {
             var globalOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
 
 
-            this._queue = []; // TODO: should be private
             this._queueBeingFlushed = [];
             this.targetQueues = Object.create(null);
             this.index = 0;
+            this._queue = [];
             this.name = name;
             this.options = options;
             this.globalOptions = globalOptions;
@@ -4677,27 +4678,22 @@ enifed('backburner', ['exports'], function (exports) {
             var args = void 0;
             var errorRecordedForStack = void 0;
             this.targetQueues = Object.create(null);
-            var queueItems = void 0;
-            if (this._queueBeingFlushed.length > 0) {
-                queueItems = this._queueBeingFlushed;
-            } else {
-                queueItems = this._queueBeingFlushed = this._queue;
+            if (this._queueBeingFlushed.length === 0) {
+                this._queueBeingFlushed = this._queue;
                 this._queue = [];
             }
-            if (before) {
+            if (before !== undefined) {
                 before();
             }
             var invoke = void 0;
+            var queueItems = this._queueBeingFlushed;
             if (queueItems.length > 0) {
                 onError = getOnError(this.globalOptions);
 
                 invoke = onError ? this.invokeWithOnError : this.invoke;
                 for (i = this.index; i < queueItems.length; i += 4) {
                     this.index += 4;
-                    target = queueItems[i];
                     method = queueItems[i + 1];
-                    args = queueItems[i + 2];
-                    errorRecordedForStack = queueItems[i + 3]; // Debugging assistance
                     // method could have been nullified / canceled during flush
                     if (method !== null) {
                         //
@@ -4715,6 +4711,9 @@ enifed('backburner', ['exports'], function (exports) {
                         //    One possible long-term solution is the following Chrome issue:
                         //       https://bugs.chromium.org/p/chromium/issues/detail?id=332624
                         //
+                        target = queueItems[i];
+                        args = queueItems[i + 2];
+                        errorRecordedForStack = queueItems[i + 3]; // Debugging assistance
                         invoke(target, method, args, onError, errorRecordedForStack);
                     }
                     if (this.index !== this._queueBeingFlushed.length && this.globalOptions.mustYield && this.globalOptions.mustYield()) {
@@ -4722,7 +4721,7 @@ enifed('backburner', ['exports'], function (exports) {
                     }
                 }
             }
-            if (after) {
+            if (after !== undefined) {
                 after();
             }
             this._queueBeingFlushed.length = 0;
@@ -4739,17 +4738,17 @@ enifed('backburner', ['exports'], function (exports) {
 
         Queue.prototype.cancel = function (_ref) {
             var target = _ref.target,
-                method = _ref.method;
+                method = _ref.method,
+                t,
+                i,
+                l;
 
             var queue = this._queue;
-            var currentTarget = void 0;
-            var currentMethod = void 0;
-            var i = void 0;
-            var l = void 0;
-            var t = void 0;
             var guid = this.guidForTarget(target);
             var targetQueue = guid ? this.targetQueues[guid] : undefined;
             if (targetQueue !== undefined) {
+                t = void 0;
+
                 for (i = 0, l = targetQueue.length; i < l; i += 2) {
                     t = targetQueue[i];
                     if (t === method) {
@@ -4757,26 +4756,18 @@ enifed('backburner', ['exports'], function (exports) {
                     }
                 }
             }
-            for (i = 0, l = queue.length; i < l; i += 4) {
-                currentTarget = queue[i];
-                currentMethod = queue[i + 1];
-                if (currentTarget === target && currentMethod === method) {
-                    queue.splice(i, 4);
-                    return true;
-                }
+            var index = findItem(target, method, queue);
+            if (index > -1) {
+                queue.splice(index, 4);
+                return true;
             }
             // if not found in current queue
             // could be in the queue that is being flushed
             queue = this._queueBeingFlushed;
-            for (i = 0, l = queue.length; i < l; i += 4) {
-                currentTarget = queue[i];
-                currentMethod = queue[i + 1];
-                if (currentTarget === target && currentMethod === method) {
-                    // don't mess with array during flush
-                    // just nullify the method
-                    queue[i + 1] = null;
-                    return true;
-                }
+            index = findItem(target, method, queue);
+            if (index > -1) {
+                queue[index + 1] = null;
+                return true;
             }
             return false;
         };
@@ -4796,22 +4787,14 @@ enifed('backburner', ['exports'], function (exports) {
         };
 
         Queue.prototype.pushUniqueWithoutGuid = function (target, method, args, stack) {
-            var queue = this._queue,
-                i,
-                l,
-                currentTarget,
-                currentMethod;
-            for (i = 0, l = queue.length; i < l; i += 4) {
-                currentTarget = queue[i];
-                currentMethod = queue[i + 1];
-
-                if (currentTarget === target && currentMethod === method) {
-                    queue[i + 2] = args; // replace args
-                    queue[i + 3] = stack; // replace stack
-                    return;
-                }
+            var queue = this._queue;
+            var index = findItem(target, method, queue);
+            if (index > -1) {
+                queue[index + 2] = args; // replace args
+                queue[index + 3] = stack; // replace stack
+            } else {
+                queue.push(target, method, args, stack);
             }
-            queue.push(target, method, args, stack);
         };
 
         Queue.prototype.targetQueue = function (_targetQueue, target, method, args, stack) {
@@ -4941,6 +4924,30 @@ enifed('backburner', ['exports'], function (exports) {
 
     var noop = function () {};
     var SET_TIMEOUT = setTimeout;
+    function parseArgs() {
+        var length = arguments.length,
+            i;
+        var method = void 0;
+        var target = void 0;
+        var args = void 0;
+        if (length === 1) {
+            method = arguments[0];
+            target = null;
+        } else {
+            target = arguments[0];
+            method = arguments[1];
+            if (isString(method)) {
+                method = target[method];
+            }
+            if (length > 2) {
+                args = new Array(length - 2);
+                for (i = 0; i < length - 2; i++) {
+                    args[i] = arguments[i + 2];
+                }
+            }
+        }
+        return [target, method, args];
+    }
 
     var Backburner = function () {
         function Backburner(queueNames) {
@@ -5081,32 +5088,17 @@ enifed('backburner', ['exports'], function (exports) {
             }
         };
 
-        Backburner.prototype.run = function (target, method) {
-            for (_len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-                args[_key - 2] = arguments[_key];
-            }
+        Backburner.prototype.run = function () {
+            var _parseArgs = parseArgs.apply(undefined, arguments),
+                target = _parseArgs[0],
+                method = _parseArgs[1],
+                args = _parseArgs[2];
 
-            var length = arguments.length,
-                _len,
-                args,
-                _key;
-            var _method = void 0;
-            var _target = void 0;
-            if (length === 1) {
-                _method = target;
-                _target = null;
-            } else {
-                _method = method;
-                _target = target;
-                if (isString(_method)) {
-                    _method = _target[_method];
-                }
-            }
             var onError = getOnError(this.options);
             this.begin();
             if (onError) {
                 try {
-                    return _method.apply(_target, args);
+                    return method.apply(target, args);
                 } catch (error) {
                     onError(error);
                 } finally {
@@ -5114,7 +5106,7 @@ enifed('backburner', ['exports'], function (exports) {
                 }
             } else {
                 try {
-                    return _method.apply(_target, args);
+                    return method.apply(target, args);
                 } finally {
                     this.end();
                 }
@@ -5125,27 +5117,13 @@ enifed('backburner', ['exports'], function (exports) {
             if (this.currentInstance === null) {
                 return this.run.apply(this, arguments);
             }
-            var length = arguments.length,
-                i;
-            var method = void 0;
-            var target = void 0;
-            var args = void 0;
-            if (length === 1) {
-                method = arguments[0];
-                target = null;
-            } else {
-                target = arguments[0];
-                method = arguments[1];
-                if (isString(method)) {
-                    method = target[method];
-                }
-                if (length > 2) {
-                    args = new Array(length - 2);
-                    for (i = 0; i < length - 2; i++) {
-                        args[i] = arguments[i + 2];
-                    }
-                }
-            }
+
+            var _parseArgs2 = parseArgs.apply(undefined, arguments),
+                target = _parseArgs2[0],
+                method = _parseArgs2[1],
+                args = _parseArgs2[2];
+
+            var length = arguments.length;
             if (length === 1) {
                 return method();
             } else if (length === 2) {
@@ -5160,27 +5138,18 @@ enifed('backburner', ['exports'], function (exports) {
         };
 
         Backburner.prototype.schedule = function (queueName) {
-            var length = arguments.length,
-                i;
-            var method = void 0;
-            var target = void 0;
-            var args = void 0;
-            if (length === 2) {
-                method = arguments[1];
-                target = null;
-            } else {
-                target = arguments[1];
-                method = arguments[2];
-                if (isString(method)) {
-                    method = target[method];
-                }
-                if (length > 3) {
-                    args = new Array(length - 3);
-                    for (i = 3; i < length; i++) {
-                        args[i - 3] = arguments[i];
-                    }
-                }
+            for (_len = arguments.length, _args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+                _args[_key - 1] = arguments[_key];
             }
+
+            var _parseArgs3 = parseArgs.apply(undefined, _args),
+                target = _parseArgs3[0],
+                method = _parseArgs3[1],
+                args = _parseArgs3[2],
+                _len,
+                _args,
+                _key;
+
             var stack = this.DEBUG ? new Error() : undefined;
             return this._ensureInstance().schedule(queueName, target, method, args, false, stack);
         };
@@ -5194,28 +5163,19 @@ enifed('backburner', ['exports'], function (exports) {
             return this.scheduleOnce.apply(this, arguments);
         };
 
-        Backburner.prototype.scheduleOnce = function (queueName /* , target, method, args */) {
-            var length = arguments.length,
-                i;
-            var method = void 0;
-            var target = void 0;
-            var args = void 0;
-            if (length === 2) {
-                method = arguments[1];
-                target = null;
-            } else {
-                target = arguments[1];
-                method = arguments[2];
-                if (isString(method)) {
-                    method = target[method];
-                }
-                if (length > 3) {
-                    args = new Array(length - 3);
-                    for (i = 3; i < length; i++) {
-                        args[i - 3] = arguments[i];
-                    }
-                }
+        Backburner.prototype.scheduleOnce = function (queueName) {
+            for (_len2 = arguments.length, _args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+                _args[_key2 - 1] = arguments[_key2];
             }
+
+            var _parseArgs4 = parseArgs.apply(undefined, _args),
+                target = _parseArgs4[0],
+                method = _parseArgs4[1],
+                args = _parseArgs4[2],
+                _len2,
+                _args,
+                _key2;
+
             var stack = this.DEBUG ? new Error() : undefined;
             return this._ensureInstance().schedule(queueName, target, method, args, true, stack);
         };
@@ -5225,14 +5185,14 @@ enifed('backburner', ['exports'], function (exports) {
         };
 
         Backburner.prototype.later = function () {
-            for (_len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-                args[_key2] = arguments[_key2];
+            for (_len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+                args[_key3] = arguments[_key3];
             }
 
             var length = args.length,
-                _len2,
+                _len3,
                 args,
-                _key2,
+                _key3,
                 last;
             var wait = 0;
             var method = void 0;
@@ -5296,19 +5256,19 @@ enifed('backburner', ['exports'], function (exports) {
             return this._setTimeout(fn, executeAt);
         };
 
-        Backburner.prototype.throttle = function (target, method /*, ...args, wait, [immediate] */) {
+        Backburner.prototype.throttle = function (target, method) /*, ...args, wait, [immediate] */{
             var _this2 = this,
-                i;
+                _len4,
+                args,
+                _key4;
 
-            var args = new Array(arguments.length);
-            for (i = 0; i < arguments.length; i++) {
-                args[i] = arguments[i];
+            for (_len4 = arguments.length, args = Array(_len4 > 2 ? _len4 - 2 : 0), _key4 = 2; _key4 < _len4; _key4++) {
+                args[_key4 - 2] = arguments[_key4];
             }
+
             var immediate = args.pop();
             var isImmediate = void 0;
             var wait = void 0;
-            var index = void 0;
-            var timer = void 0;
             if (isCoercableNumber(immediate)) {
                 wait = immediate;
                 isImmediate = true;
@@ -5317,40 +5277,44 @@ enifed('backburner', ['exports'], function (exports) {
                 isImmediate = immediate === true;
             }
             wait = parseInt(wait, 10);
-            index = findItem(target, method, this._throttlers);
+            var index = findItem(target, method, this._throttlers);
             if (index > -1) {
-                return this._throttlers[index + 2];
+                this._throttlers[index + 2] = args;
+                return this._throttlers[index + 3];
             } // throttled
-            timer = this._platform.setTimeout(function () {
+            var timer = this._platform.setTimeout(function () {
+                var i = findTimer(timer, _this2._throttlers);
+
+                var _throttlers$splice = _this2._throttlers.splice(i, 4),
+                    context = _throttlers$splice[0],
+                    func = _throttlers$splice[1],
+                    params = _throttlers$splice[2];
+
                 if (isImmediate === false) {
-                    _this2.run.apply(_this2, args);
-                }
-                index = findTimer(timer, _this2._throttlers);
-                if (index > -1) {
-                    _this2._throttlers.splice(index, 3);
+                    _this2.run.apply(_this2, [context, func].concat(params));
                 }
             }, wait);
             if (isImmediate) {
-                this.join.apply(this, args);
+                this.join.apply(this, [target, method].concat(args));
             }
-            this._throttlers.push(target, method, timer);
+            this._throttlers.push(target, method, args, timer);
             return timer;
         };
 
-        Backburner.prototype.debounce = function (target, method /* , args, wait, [immediate] */) {
+        Backburner.prototype.debounce = function (target, method) /* , wait, [immediate] */{
             var _this3 = this,
-                i,
+                _len5,
+                args,
+                _key5,
                 timerId;
 
-            var args = new Array(arguments.length);
-            for (i = 0; i < arguments.length; i++) {
-                args[i] = arguments[i];
+            for (_len5 = arguments.length, args = Array(_len5 > 2 ? _len5 - 2 : 0), _key5 = 2; _key5 < _len5; _key5++) {
+                args[_key5 - 2] = arguments[_key5];
             }
+
             var immediate = args.pop();
             var isImmediate = void 0;
             var wait = void 0;
-            var index = void 0;
-            var timer = void 0;
             if (isCoercableNumber(immediate)) {
                 wait = immediate;
                 isImmediate = false;
@@ -5360,37 +5324,40 @@ enifed('backburner', ['exports'], function (exports) {
             }
             wait = parseInt(wait, 10);
             // Remove debouncee
-            index = findItem(target, method, this._debouncees);
+            var index = findItem(target, method, this._debouncees);
             if (index > -1) {
-                timerId = this._debouncees[index + 2];
+                timerId = this._debouncees[index + 3];
 
-                this._debouncees.splice(index, 3);
                 this._platform.clearTimeout(timerId);
+                this._debouncees.splice(index, 4);
             }
-            timer = this._platform.setTimeout(function () {
+            var timer = this._platform.setTimeout(function () {
+                var i = findTimer(timer, _this3._debouncees);
+
+                var _debouncees$splice = _this3._debouncees.splice(i, 4),
+                    context = _debouncees$splice[0],
+                    func = _debouncees$splice[1],
+                    params = _debouncees$splice[2];
+
                 if (isImmediate === false) {
-                    _this3.run.apply(_this3, args);
-                }
-                index = findTimer(timer, _this3._debouncees);
-                if (index > -1) {
-                    _this3._debouncees.splice(index, 3);
+                    _this3.run.apply(_this3, [context, func].concat(params));
                 }
             }, wait);
             if (isImmediate && index === -1) {
-                this.join.apply(this, args);
+                this.join.apply(this, [target, method].concat(args));
             }
-            this._debouncees.push(target, method, timer);
+            this._debouncees.push(target, method, args, timer);
             return timer;
         };
 
         Backburner.prototype.cancelTimers = function () {
             var i, t;
 
-            for (i = 2; i < this._throttlers.length; i += 3) {
+            for (i = 3; i < this._throttlers.length; i += 4) {
                 this._platform.clearTimeout(this._throttlers[i]);
             }
             this._throttlers = [];
-            for (t = 2; t < this._debouncees.length; t += 3) {
+            for (t = 3; t < this._debouncees.length; t += 4) {
                 this._platform.clearTimeout(this._debouncees[t]);
             }
             this._debouncees = [];
@@ -5464,8 +5431,8 @@ enifed('backburner', ['exports'], function (exports) {
         Backburner.prototype._cancelItem = function (timer, array) {
             var index = findTimer(timer, array);
             if (index > -1) {
-                array.splice(index, 3);
                 this._platform.clearTimeout(timer);
+                array.splice(index, 4);
                 return true;
             }
             return false;
@@ -5577,51 +5544,110 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
    @private
    @class Container
    */
-  function Container(registry) {
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
-    this.registry = registry;
-    this.owner = options.owner || null;
-    this.cache = (0, _emberUtils.dictionary)(options.cache || null);
-    this.factoryManagerCache = (0, _emberUtils.dictionary)(options.factoryManagerCache || null);
-    this[CONTAINER_OVERRIDE] = undefined;
-    this.isDestroyed = false;
+  var Container = function () {
+    function Container(registry) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
-    this.validationCache = (0, _emberUtils.dictionary)(options.validationCache || null);
-  }
 
-  Container.prototype = {
-    lookup: function (fullName, options) {
-      true && !this.registry.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.registry.validateFullName(fullName));
+      this.registry = registry;
+      this.owner = options.owner || null;
+      this.cache = (0, _emberUtils.dictionary)(options.cache || null);
+      this.factoryManagerCache = (0, _emberUtils.dictionary)(options.factoryManagerCache || null);
+      this[CONTAINER_OVERRIDE] = undefined;
+      this.isDestroyed = false;
 
-      return lookup(this, this.registry.normalize(fullName), options);
-    },
-    destroy: function () {
+      this.validationCache = (0, _emberUtils.dictionary)(options.validationCache || null);
+    }
+
+    /**
+     @private
+     @property registry
+     @type Registry
+     @since 1.11.0
+     */
+
+    /**
+     @private
+     @property cache
+     @type InheritingDict
+     */
+
+    /**
+     @private
+     @property validationCache
+     @type InheritingDict
+     */
+
+    /**
+     Given a fullName return a corresponding instance.
+      The default behavior is for lookup to return a singleton instance.
+     The singleton is scoped to the container, allowing multiple containers
+     to all have their own locally scoped singletons.
+      ```javascript
+     let registry = new Registry();
+     let container = registry.container();
+      registry.register('api:twitter', Twitter);
+      let twitter = container.lookup('api:twitter');
+      twitter instanceof Twitter; // => true
+      // by default the container will return singletons
+     let twitter2 = container.lookup('api:twitter');
+     twitter2 instanceof Twitter; // => true
+      twitter === twitter2; //=> true
+     ```
+      If singletons are not wanted, an optional flag can be provided at lookup.
+      ```javascript
+     let registry = new Registry();
+     let container = registry.container();
+      registry.register('api:twitter', Twitter);
+      let twitter = container.lookup('api:twitter', { singleton: false });
+     let twitter2 = container.lookup('api:twitter', { singleton: false });
+      twitter === twitter2; //=> false
+     ```
+      @private
+     @method lookup
+     @param {String} fullName
+     @param {Object} [options]
+     @param {String} [options.source] The fullname of the request source (used for local lookup)
+     @return {any}
+     */
+
+    Container.prototype.lookup = function (fullName, options) {
+      true && !this.registry.isValidFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.registry.isValidFullName(fullName));
+
+      return _lookup(this, this.registry.normalize(fullName), options);
+    };
+
+    Container.prototype.destroy = function () {
       destroyDestroyables(this);
       this.isDestroyed = true;
-    },
-    reset: function (fullName) {
+    };
+
+    Container.prototype.reset = function (fullName) {
       if (fullName === undefined) {
         resetCache(this);
       } else {
         resetMember(this, this.registry.normalize(fullName));
       }
-    },
-    ownerInjection: function () {
+    };
+
+    Container.prototype.ownerInjection = function () {
       var _ref;
 
       return _ref = {}, _ref[_emberUtils.OWNER] = this.owner, _ref;
-    },
-    _resolverCacheKey: function (name, options) {
+    };
+
+    Container.prototype._resolverCacheKey = function (name, options) {
       return this.registry.resolverCacheKey(name, options);
-    },
-    factoryFor: function (fullName) {
+    };
+
+    Container.prototype.factoryFor = function (fullName) {
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
           expandedFullName;
 
       var normalizedName = this.registry.normalize(fullName);
 
-      true && !this.registry.validateFullName(normalizedName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.registry.validateFullName(normalizedName));
+      true && !this.registry.isValidFullName(normalizedName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.registry.isValidFullName(normalizedName));
 
       if (options.source) {
         expandedFullName = this.registry.expandLocalLookup(fullName, options);
@@ -5665,8 +5691,10 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
 
       this.factoryManagerCache[cacheKey] = manager;
       return manager;
-    }
-  };
+    };
+
+    return Container;
+  }();
 
   /*
    * Wrap a factory manager in a proxy which will not permit properties to be
@@ -5709,7 +5737,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
     return container.registry.getOption(fullName, 'instantiate') !== false;
   }
 
-  function lookup(container, fullName) {
+  function _lookup(container, fullName) {
     var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
         expandedFullName,
         cacheKey,
@@ -5803,33 +5831,19 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
     throw new Error('Could not create factory');
   }
 
-  function buildInjections() /* container, ...injections */{
+  function buildInjections(container, injections) {
     var hash = {},
-        container,
-        injections,
         injection,
-        i,
-        _i;
+        i;
     var isDynamic = false;
 
-    if (arguments.length > 1) {
-      container = arguments[0];
-      injections = [];
-      injection = void 0;
-
-
-      for (i = 1; i < arguments.length; i++) {
-        if (arguments[i]) {
-          injections = injections.concat(arguments[i]);
-        }
-      }
-
+    if (injections.length > 0) {
       container.registry.validateInjections(injections);
+      injection = void 0;
 
-
-      for (_i = 0; _i < injections.length; _i++) {
-        injection = injections[_i];
-        hash[injection.property] = lookup(container, injection.fullName);
+      for (i = 0; i < injections.length; i++) {
+        injection = injections[i];
+        hash[injection.property] = _lookup(container, injection.fullName);
         if (!isDynamic) {
           isDynamic = !isSingleton(container, injection.fullName);
         }
@@ -5841,10 +5855,12 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
 
   function injectionsFor(container, fullName) {
     var registry = container.registry;
-    var splitName = fullName.split(':');
-    var type = splitName[0];
 
-    return buildInjections(container, registry.getTypeInjections(type), registry.getInjections(fullName));
+    var _fullName$split = fullName.split(':'),
+        type = _fullName$split[0];
+
+    var injections = registry.getTypeInjections(type).concat(registry.getInjections(fullName));
+    return buildInjections(container, injections);
   }
 
   function destroyDestroyables(container) {
@@ -5977,40 +5993,39 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
    @class Registry
    @since 1.11.0
   */
-  function Registry() {
-    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
-    this.fallback = options.fallback || null;
+  var Registry = function () {
+    function Registry() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+
+      this.fallback = options.fallback || null;
+      this.resolver = options.resolver || null;
 
-    if (options.resolver) {
-      this.resolver = options.resolver;
       if (typeof this.resolver === 'function') {
         deprecateResolverFunction(this);
       }
-    }
 
-    this.registrations = (0, _emberUtils.dictionary)(options.registrations || null);
+      this.registrations = (0, _emberUtils.dictionary)(options.registrations || null);
 
-    this._typeInjections = (0, _emberUtils.dictionary)(null);
-    this._injections = (0, _emberUtils.dictionary)(null);
+      this._typeInjections = (0, _emberUtils.dictionary)(null);
+      this._injections = (0, _emberUtils.dictionary)(null);
 
-    this._localLookupCache = Object.create(null);
-    this._normalizeCache = (0, _emberUtils.dictionary)(null);
-    this._resolveCache = (0, _emberUtils.dictionary)(null);
-    this._failCache = (0, _emberUtils.dictionary)(null);
+      this._localLookupCache = Object.create(null);
+      this._normalizeCache = (0, _emberUtils.dictionary)(null);
+      this._resolveCache = (0, _emberUtils.dictionary)(null);
+      this._failCache = (0, _emberUtils.dictionary)(null);
 
-    this._options = (0, _emberUtils.dictionary)(null);
-    this._typeOptions = (0, _emberUtils.dictionary)(null);
-  }
+      this._options = (0, _emberUtils.dictionary)(null);
+      this._typeOptions = (0, _emberUtils.dictionary)(null);
+    }
 
-  Registry.prototype = {
     /**
      A backup registry for resolving registrations when no matches can be found.
       @private
      @property fallback
      @type Registry
      */
-    fallback: null,
 
     /**
      An object that has a `resolve` method that resolves a name.
@@ -6018,80 +6033,76 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
      @property resolver
      @type Resolver
      */
-    resolver: null,
 
     /**
      @private
      @property registrations
      @type InheritingDict
      */
-    registrations: null,
 
     /**
      @private
       @property _typeInjections
      @type InheritingDict
      */
-    _typeInjections: null,
 
     /**
      @private
       @property _injections
      @type InheritingDict
      */
-    _injections: null,
 
     /**
      @private
       @property _normalizeCache
      @type InheritingDict
      */
-    _normalizeCache: null,
 
     /**
      @private
       @property _resolveCache
      @type InheritingDict
      */
-    _resolveCache: null,
 
     /**
      @private
       @property _options
      @type InheritingDict
      */
-    _options: null,
 
     /**
      @private
       @property _typeOptions
      @type InheritingDict
      */
-    _typeOptions: null,
 
-    container: function (options) {
+    /**
+     Creates a container based on this registry.
+      @private
+     @method container
+     @param {Object} options
+     @return {Container} created container
+     */
+
+    Registry.prototype.container = function (options) {
       return new Container(this, options);
-    },
-    register: function (fullName, factory) {
-      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-      true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
+    };
 
-      if (factory === undefined) {
-        throw new TypeError('Attempting to register an unknown factory: \'' + fullName + '\'');
-      }
+    Registry.prototype.register = function (fullName, factory) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      true && !this.isValidFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.isValidFullName(fullName));
+      true && !(factory !== undefined) && (0, _emberDebug.assert)('Attempting to register an unknown factory: \'' + fullName + '\'', factory !== undefined);
 
       var normalizedName = this.normalize(fullName);
-
-      if (this._resolveCache[normalizedName]) {
-        throw new Error('Cannot re-register: \'' + fullName + '\', as it has already been resolved.');
-      }
+      true && !!this._resolveCache[normalizedName] && (0, _emberDebug.assert)('Cannot re-register: \'' + fullName + '\', as it has already been resolved.', !this._resolveCache[normalizedName]);
 
       delete this._failCache[normalizedName];
       this.registrations[normalizedName] = factory;
       this._options[normalizedName] = options;
-    },
-    unregister: function (fullName) {
-      true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
+    };
+
+    Registry.prototype.unregister = function (fullName) {
+      true && !this.isValidFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.isValidFullName(fullName));
 
       var normalizedName = this.normalize(fullName);
 
@@ -6101,83 +6112,94 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
       delete this._resolveCache[normalizedName];
       delete this._failCache[normalizedName];
       delete this._options[normalizedName];
-    },
-    resolve: function (fullName, options) {
-      true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
+    };
+
+    Registry.prototype.resolve = function (fullName, options) {
+      true && !this.isValidFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.isValidFullName(fullName));
 
-      var factory = resolve(this, this.normalize(fullName), options),
+      var factory = _resolve(this, this.normalize(fullName), options),
           _fallback;
-      if (factory === undefined && this.fallback) {
+      if (factory === undefined && this.fallback !== null) {
 
         factory = (_fallback = this.fallback).resolve.apply(_fallback, arguments);
       }
       return factory;
-    },
-    describe: function (fullName) {
-      if (this.resolver && this.resolver.lookupDescription) {
+    };
+
+    Registry.prototype.describe = function (fullName) {
+      if (this.resolver !== null && this.resolver.lookupDescription) {
         return this.resolver.lookupDescription(fullName);
-      } else if (this.fallback) {
+      } else if (this.fallback !== null) {
         return this.fallback.describe(fullName);
       } else {
         return fullName;
       }
-    },
-    normalizeFullName: function (fullName) {
-      if (this.resolver && this.resolver.normalize) {
+    };
+
+    Registry.prototype.normalizeFullName = function (fullName) {
+      if (this.resolver !== null && this.resolver.normalize) {
         return this.resolver.normalize(fullName);
-      } else if (this.fallback) {
+      } else if (this.fallback !== null) {
         return this.fallback.normalizeFullName(fullName);
       } else {
         return fullName;
       }
-    },
-    normalize: function (fullName) {
+    };
+
+    Registry.prototype.normalize = function (fullName) {
       return this._normalizeCache[fullName] || (this._normalizeCache[fullName] = this.normalizeFullName(fullName));
-    },
-    makeToString: function (factory, fullName) {
-      if (this.resolver && this.resolver.makeToString) {
+    };
+
+    Registry.prototype.makeToString = function (factory, fullName) {
+      if (this.resolver !== null && this.resolver.makeToString) {
         return this.resolver.makeToString(factory, fullName);
-      } else if (this.fallback) {
+      } else if (this.fallback !== null) {
         return this.fallback.makeToString(factory, fullName);
       } else {
         return factory.toString();
       }
-    },
-    has: function (fullName, options) {
+    };
+
+    Registry.prototype.has = function (fullName, options) {
       if (!this.isValidFullName(fullName)) {
         return false;
       }
 
       var source = options && options.source && this.normalize(options.source);
 
-      return has(this, this.normalize(fullName), source);
-    },
-    optionsForType: function (type, options) {
+      return _has(this, this.normalize(fullName), source);
+    };
+
+    Registry.prototype.optionsForType = function (type, options) {
       this._typeOptions[type] = options;
-    },
-    getOptionsForType: function (type) {
+    };
+
+    Registry.prototype.getOptionsForType = function (type) {
       var optionsForType = this._typeOptions[type];
-      if (optionsForType === undefined && this.fallback) {
+      if (optionsForType === undefined && this.fallback !== null) {
         optionsForType = this.fallback.getOptionsForType(type);
       }
       return optionsForType;
-    },
-    options: function (fullName) {
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    };
+
+    Registry.prototype.options = function (fullName) {
+      var _options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
       var normalizedName = this.normalize(fullName);
-      this._options[normalizedName] = options;
-    },
-    getOptions: function (fullName) {
+      this._options[normalizedName] = _options;
+    };
+
+    Registry.prototype.getOptions = function (fullName) {
       var normalizedName = this.normalize(fullName);
       var options = this._options[normalizedName];
 
-      if (options === undefined && this.fallback) {
+      if (options === undefined && this.fallback !== null) {
         options = this.fallback.getOptions(fullName);
       }
       return options;
-    },
-    getOption: function (fullName, optionName) {
+    };
+
+    Registry.prototype.getOption = function (fullName, optionName) {
       var options = this._options[fullName];
 
       if (options && options[optionName] !== undefined) {
@@ -6189,39 +6211,41 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
 
       if (options && options[optionName] !== undefined) {
         return options[optionName];
-      } else if (this.fallback) {
+      } else if (this.fallback !== null) {
         return this.fallback.getOption(fullName, optionName);
       }
-    },
-    typeInjection: function (type, property, fullName) {
-      true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
+    };
+
+    Registry.prototype.typeInjection = function (type, property, fullName) {
+      true && !this.isValidFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.isValidFullName(fullName));
 
       var fullNameType = fullName.split(':')[0];
-      if (fullNameType === type) {
-        throw new Error('Cannot inject a \'' + fullName + '\' on other ' + type + '(s).');
-      }
+      true && !(fullNameType !== type) && (0, _emberDebug.assert)('Cannot inject a \'' + fullName + '\' on other ' + type + '(s).', fullNameType !== type);
 
       var injections = this._typeInjections[type] || (this._typeInjections[type] = []);
 
       injections.push({ property: property, fullName: fullName });
-    },
-    injection: function (fullName, property, injectionName) {
-      this.validateFullName(injectionName);
+    };
+
+    Registry.prototype.injection = function (fullName, property, injectionName) {
+      true && !this.isValidFullName(injectionName) && (0, _emberDebug.assert)('Invalid injectionName, expected: \'type:name\' got: ' + injectionName, this.isValidFullName(injectionName));
+
       var normalizedInjectionName = this.normalize(injectionName);
 
       if (fullName.indexOf(':') === -1) {
         return this.typeInjection(fullName, property, normalizedInjectionName);
       }
 
-      true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
+      true && !this.isValidFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.isValidFullName(fullName));
 
       var normalizedName = this.normalize(fullName);
 
       var injections = this._injections[normalizedName] || (this._injections[normalizedName] = []);
 
       injections.push({ property: property, fullName: normalizedInjectionName });
-    },
-    knownForType: function (type) {
+    };
+
+    Registry.prototype.knownForType = function (type) {
       var fallbackKnown = void 0,
           resolverKnown = void 0,
           index,
@@ -6240,74 +6264,72 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
         }
       }
 
-      if (this.fallback) {
+      if (this.fallback !== null) {
         fallbackKnown = this.fallback.knownForType(type);
       }
 
-      if (this.resolver && this.resolver.knownForType) {
+      if (this.resolver !== null && this.resolver.knownForType) {
         resolverKnown = this.resolver.knownForType(type);
       }
 
       return (0, _emberUtils.assign)({}, fallbackKnown, localKnown, resolverKnown);
-    },
-    validateFullName: function (fullName) {
-      if (!this.isValidFullName(fullName)) {
-        throw new TypeError('Invalid Fullname, expected: \'type:name\' got: ' + fullName);
-      }
+    };
 
-      return true;
-    },
-    isValidFullName: function (fullName) {
+    Registry.prototype.isValidFullName = function (fullName) {
       return VALID_FULL_NAME_REGEXP.test(fullName);
-    },
-    getInjections: function (fullName) {
+    };
+
+    Registry.prototype.getInjections = function (fullName) {
       var injections = this._injections[fullName] || [];
-      if (this.fallback) {
+      if (this.fallback !== null) {
         injections = injections.concat(this.fallback.getInjections(fullName));
       }
       return injections;
-    },
-    getTypeInjections: function (type) {
+    };
+
+    Registry.prototype.getTypeInjections = function (type) {
       var injections = this._typeInjections[type] || [];
-      if (this.fallback) {
+      if (this.fallback !== null) {
         injections = injections.concat(this.fallback.getTypeInjections(type));
       }
       return injections;
-    },
-    resolverCacheKey: function (name, options) {
+    };
+
+    Registry.prototype.resolverCacheKey = function (name, options) {
       if (!_features.EMBER_MODULE_UNIFICATION) {
         return name;
       }
 
       return options && options.source ? options.source + ':' + name : name;
-    },
-    expandLocalLookup: function (fullName, options) {
+    };
+
+    Registry.prototype.expandLocalLookup = function (fullName, options) {
       var normalizedFullName, normalizedSource;
 
-      if (this.resolver && this.resolver.expandLocalLookup) {
-        true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
+      if (this.resolver !== null && this.resolver.expandLocalLookup) {
+        true && !this.isValidFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.isValidFullName(fullName));
         true && !(options && options.source) && (0, _emberDebug.assert)('options.source must be provided to expandLocalLookup', options && options.source);
-        true && !this.validateFullName(options.source) && (0, _emberDebug.assert)('options.source must be a proper full name', this.validateFullName(options.source));
+        true && !this.isValidFullName(options.source) && (0, _emberDebug.assert)('options.source must be a proper full name', this.isValidFullName(options.source));
 
         normalizedFullName = this.normalize(fullName);
         normalizedSource = this.normalize(options.source);
 
 
-        return expandLocalLookup(this, normalizedFullName, normalizedSource);
-      } else if (this.fallback) {
+        return _expandLocalLookup(this, normalizedFullName, normalizedSource);
+      } else if (this.fallback !== null) {
         return this.fallback.expandLocalLookup(fullName, options);
       } else {
         return null;
       }
-    }
-  };
+    };
+
+    return Registry;
+  }();
 
   function deprecateResolverFunction(registry) {
     true && !false && (0, _emberDebug.deprecate)('Passing a `resolver` function into a Registry is deprecated. Please pass in a Resolver object with a `resolve` method.', false, { id: 'ember-application.registry-resolver-as-function', until: '3.0.0', url: 'https://emberjs.com/deprecations/v2.x#toc_registry-resolver-as-function' });
 
-    registry.resolver = {
-      resolve: registry.resolver
-    };
+    registry.resolver = { resolve: registry.resolver };
   }
 
   Registry.prototype.normalizeInjectionsHash = function (hash) {
@@ -6315,7 +6337,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
 
     for (var key in hash) {
       if (hash.hasOwnProperty(key)) {
-        true && !this.validateFullName(hash[key]) && (0, _emberDebug.assert)('Expected a proper full name, given \'' + hash[key] + '\'', this.validateFullName(hash[key]));
+        true && !this.isValidFullName(hash[key]) && (0, _emberDebug.assert)('Expected a proper full name, given \'' + hash[key] + '\'', this.isValidFullName(hash[key]));
 
         injections.push({
           property: key,
@@ -6343,7 +6365,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
   };
 
 
-  function expandLocalLookup(registry, normalizedName, normalizedSource) {
+  function _expandLocalLookup(registry, normalizedName, normalizedSource) {
     var cache = registry._localLookupCache;
     var normalizedNameCache = cache[normalizedName];
 
@@ -6362,7 +6384,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
     return normalizedNameCache[normalizedSource] = expanded;
   }
 
-  function resolve(registry, normalizedName, options) {
+  function _resolve(registry, normalizedName, options) {
     if (options && options.source) {
       // when `source` is provided expand normalizedName
       // and source into the full normalizedName
@@ -6413,7 +6435,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
     return resolved;
   }
 
-  function has(registry, fullName, source) {
+  function _has(registry, fullName, source) {
     return registry.resolve(fullName, { source: source }) !== undefined;
   }
 
@@ -6436,9 +6458,9 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
       return name;
     }
 
-    var _fullName$split = fullName.split(':'),
-        type = _fullName$split[0],
-        rawName = _fullName$split[1];
+    var _fullName$split2 = fullName.split(':'),
+        type = _fullName$split2[0],
+        rawName = _fullName$split2[1];
 
     return privateNames[fullName] = (0, _emberUtils.intern)(type + ':' + rawName + '-' + privateSuffix);
   };
@@ -6526,13 +6548,7 @@ enifed('ember-console', ['exports', 'ember-environment'], function (exports, _em
       return;
     }
 
-    if (typeof method.bind === 'function') {
-      return method.bind(consoleObj);
-    }
-
-    return function () {
-      method.apply(consoleObj, arguments);
-    };
+    return method.bind(consoleObj);
   }
 
   /**
@@ -11126,6 +11142,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     }
 
     var ret = this._getter.call(obj, keyName);
+
     cache[keyName] = ret === undefined ? UNDEFINED : ret;
 
     var chainWatchers = meta$$1.readableChainWatchers();
@@ -11181,14 +11198,13 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   ComputedPropertyPrototype._set = function (obj, keyName, value) {
     var meta$$1 = meta(obj);
     var cache = meta$$1.writableCache();
-    var hadCachedValue = false;
-    var cachedValue = void 0;
+
     var val = cache[keyName];
-    if (val !== undefined) {
-      if (val !== UNDEFINED) {
-        cachedValue = val;
-      }
-      hadCachedValue = true;
+    var hadCachedValue = val !== undefined;
+
+    var cachedValue = void 0;
+    if (hadCachedValue && val !== UNDEFINED) {
+      cachedValue = val;
     }
 
     var ret = this._setter.call(obj, keyName, value, cachedValue);
@@ -11200,17 +11216,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
     propertyWillChange(obj, keyName, meta$$1);
 
-    if (hadCachedValue) {
-      cache[keyName] = undefined;
-    } else {
+    if (!hadCachedValue) {
       addDependentKeys(this, obj, keyName, meta$$1);
     }
 
-    if (ret === undefined) {
-      cache[keyName] = UNDEFINED;
-    } else {
-      cache[keyName] = ret;
-    }
+    cache[keyName] = ret === undefined ? UNDEFINED : ret;
 
     propertyDidChange(obj, keyName, meta$$1);
 
@@ -12641,17 +12651,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       this._coreLibIndex = 0;
     }
 
-    Libraries.prototype.isRegistered = function (name) {
-      return !!this._getLibraryByName(name);
-    };
-
-    return Libraries;
-  }();
-
-  Libraries.prototype = {
-    constructor: Libraries,
-
-    _getLibraryByName: function (name) {
+    Libraries.prototype._getLibraryByName = function (name) {
       var libs = this._registry,
           i;
       var count = libs.length;
@@ -12661,8 +12661,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
           return libs[i];
         }
       }
-    },
-    register: function (name, version, isCoreLibrary) {
+    };
+
+    Libraries.prototype.register = function (name, version, isCoreLibrary) {
       var index = this._registry.length;
 
       if (!this._getLibraryByName(name)) {
@@ -12673,11 +12674,13 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       } else {
         true && emberDebug.warn('Library "' + name + '" is already registered with Ember.', false, { id: 'ember-metal.libraries-register' });
       }
-    },
-    registerCoreLibrary: function (name, version) {
+    };
+
+    Libraries.prototype.registerCoreLibrary = function (name, version) {
       this.register(name, version, true);
-    },
-    deRegister: function (name) {
+    };
+
+    Libraries.prototype.deRegister = function (name) {
       var lib = this._getLibraryByName(name);
       var index = void 0;
 
@@ -12685,8 +12688,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
         index = this._registry.indexOf(lib);
         this._registry.splice(index, 1);
       }
-    }
-  };
+    };
+
+    return Libraries;
+  }();
 
   if (ember_features.EMBER_LIBRARIES_ISREGISTERED) {
     Libraries.prototype.isRegistered = function (name) {
@@ -15681,7 +15686,7 @@ enifed('ember-template-compiler/plugins/transform-dot-component-invocation', ['e
   };
 
   function isMultipartPath(path) {
-    return path.parts.length > 1;
+    return path.parts && path.parts.length > 1;
   }
 
   function isInlineInvocation(path, params, hash) {
@@ -16434,7 +16439,6 @@ enifed('ember-template-compiler/system/compile-options', ['exports', 'ember-util
     var options = (0, _emberUtils.assign)({ meta: {} }, _options),
         meta,
         potententialPugins,
-        providedPlugins,
         pluginsToAdd;
 
     // move `moduleName` into `meta` property
@@ -16448,14 +16452,11 @@ enifed('ember-template-compiler/system/compile-options', ['exports', 'ember-util
       options.plugins = { ast: [].concat(USER_PLUGINS, _plugins.default) };
     } else {
       potententialPugins = [].concat(USER_PLUGINS, _plugins.default);
-      providedPlugins = options.plugins.ast.map(function (plugin) {
-        return wrapLegacyPluginIfNeeded(plugin);
-      });
       pluginsToAdd = potententialPugins.filter(function (plugin) {
         return options.plugins.ast.indexOf(plugin) === -1;
       });
 
-      options.plugins.ast = providedPlugins.concat(pluginsToAdd);
+      options.plugins.ast = options.plugins.ast.slice().concat(pluginsToAdd);
     }
 
     return options;
@@ -16465,65 +16466,40 @@ enifed('ember-template-compiler/system/compile-options', ['exports', 'ember-util
       throw new Error('Attempting to register ' + _plugin + ' as "' + type + '" which is not a valid Glimmer plugin type.');
     }
 
-    for (i = 0; i < USER_PLUGINS.length; i++) {
-      PLUGIN = USER_PLUGINS[i];
-
-      if (PLUGIN === _plugin || PLUGIN.__raw === _plugin) {
-        return;
-      }
-    }
-
-    var plugin = wrapLegacyPluginIfNeeded(_plugin),
-        i,
-        PLUGIN;
-
-    USER_PLUGINS = [plugin].concat(USER_PLUGINS);
-  };
-  exports.unregisterPlugin = function (type, PluginClass) {
-    if (type !== 'ast') {
-      throw new Error('Attempting to unregister ' + PluginClass + ' as "' + type + '" which is not a valid Glimmer plugin type.');
-    }
-
-    USER_PLUGINS = USER_PLUGINS.filter(function (plugin) {
-      return plugin !== PluginClass && plugin.__raw !== PluginClass;
-    });
-  };
-
-  var USER_PLUGINS = [];
-
-  function wrapLegacyPluginIfNeeded(_plugin) {
-    var plugin = _plugin;
+    var plugin = void 0;
     if (_plugin.prototype && _plugin.prototype.transform) {
       plugin = function (env) {
-        var pluginInstantiated = false;
-
         return {
           name: _plugin.constructor && _plugin.constructor.name,
 
           visitors: {
             Program: function (node) {
-              var _plugin2;
-
-              if (!pluginInstantiated) {
-
-                pluginInstantiated = true;
-                _plugin2 = new _plugin(env);
+              var plugin = new _plugin(env);
 
+              plugin.syntax = env.syntax;
 
-                _plugin2.syntax = env.syntax;
-
-                return _plugin2.transform(node);
-              }
+              return plugin.transform(node);
             }
           }
         };
       };
+    } else {
+      plugin = _plugin;
+    }
 
-      plugin.__raw = _plugin;
+    USER_PLUGINS = [plugin].concat(USER_PLUGINS);
+  };
+  exports.removePlugin = function (type, PluginClass) {
+    if (type !== 'ast') {
+      throw new Error('Attempting to unregister ' + PluginClass + ' as "' + type + '" which is not a valid Glimmer plugin type.');
     }
 
-    return plugin;
-  }
+    USER_PLUGINS = USER_PLUGINS.filter(function (plugin) {
+      return plugin !== PluginClass;
+    });
+  };
+
+  var USER_PLUGINS = [];
 });
 enifed('ember-template-compiler/system/compile', ['exports', 'require', 'ember-template-compiler/system/precompile'], function (exports, _require2, _precompile) {
   'use strict';
@@ -16677,7 +16653,7 @@ enifed('ember-utils', ['exports'], function (exports) {
    @type String
    @final
    */
-  var GUID_PREFIX = 'ember';
+
 
   // Used for guid generation...
   var numberCache = [];
@@ -16734,7 +16710,24 @@ enifed('ember-utils', ['exports'], function (exports) {
       separate the guid into separate namespaces.
     @return {String} the guid
   */
+  function generateGuid(obj) {
+    var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'ember';
 
+    var ret = prefix + uuid();
+    if (obj !== undefined && obj !== null) {
+      if (obj[GUID_KEY] === null) {
+        obj[GUID_KEY] = ret;
+      } else {
+        GUID_DESC.value = ret;
+        if (obj.__defineNonEnumerable) {
+          obj.__defineNonEnumerable(GUID_KEY_PROPERTY);
+        } else {
+          Object.defineProperty(obj, GUID_KEY, GUID_DESC);
+        }
+      }
+    }
+    return ret;
+  }
 
   /**
     Returns a unique id for the object. If the object does not yet have a guid,
@@ -16758,7 +16751,7 @@ enifed('ember-utils', ['exports'], function (exports) {
     // want to require non-enumerability for this API, which
     // would introduce a large cost.
     var id = GUID_KEY + Math.floor(Math.random() * new Date());
-    return intern('__' + debugName + '__ [id=' + id + ']');
+    return intern('__' + debugName + id + '__');
   }
 
   /**
@@ -17151,34 +17144,8 @@ enifed('ember-utils', ['exports'], function (exports) {
   exports.GUID_KEY = GUID_KEY;
   exports.GUID_DESC = GUID_DESC;
   exports.GUID_KEY_PROPERTY = GUID_KEY_PROPERTY;
-  exports.generateGuid = function (obj, prefix) {
-    if (!prefix) {
-      prefix = GUID_PREFIX;
-    }
-
-    var ret = prefix + uuid();
-    if (obj) {
-      if (obj[GUID_KEY] === null) {
-        obj[GUID_KEY] = ret;
-      } else {
-        GUID_DESC.value = ret;
-        if (obj.__defineNonEnumerable) {
-          obj.__defineNonEnumerable(GUID_KEY_PROPERTY);
-        } else {
-          Object.defineProperty(obj, GUID_KEY, GUID_DESC);
-        }
-      }
-    }
-    return ret;
-  };
+  exports.generateGuid = generateGuid;
   exports.guidFor = function (obj) {
-    var type = typeof obj;
-
-
-    if ((type === 'object' && obj !== null || type === 'function') && obj[GUID_KEY]) {
-      return obj[GUID_KEY];
-    }
-
     // special cases where we don't want to add a key to object
     if (obj === undefined) {
       return '(undefined)';
@@ -17188,8 +17155,12 @@ enifed('ember-utils', ['exports'], function (exports) {
       return '(null)';
     }
 
-    var ret = void 0;
+    var type = typeof obj;
+    if ((type === 'object' || type === 'function') && obj[GUID_KEY]) {
+      return obj[GUID_KEY];
+    }
 
+    var ret = void 0;
     // Don't allow prototype changes to String etc. to change the guidFor
     switch (type) {
       case 'number':
@@ -17222,20 +17193,7 @@ enifed('ember-utils', ['exports'], function (exports) {
           return '(Array)';
         }
 
-        ret = GUID_PREFIX + uuid();
-
-        if (obj[GUID_KEY] === null) {
-          obj[GUID_KEY] = ret;
-        } else {
-          GUID_DESC.value = ret;
-
-          if (obj.__defineNonEnumerable) {
-            obj.__defineNonEnumerable(GUID_KEY_PROPERTY);
-          } else {
-            Object.defineProperty(obj, GUID_KEY, GUID_DESC);
-          }
-        }
-        return ret;
+        return generateGuid(obj);
     }
   };
   exports.intern = intern;
@@ -17349,7 +17307,7 @@ enifed('ember/features', ['exports', 'ember-environment', 'ember-utils'], functi
 enifed("ember/version", ["exports"], function (exports) {
   "use strict";
 
-  exports.default = "2.17.2";
+  exports.default = "2.18.0-beta.1";
 });
 enifed("handlebars", ["exports"], function (exports) {
   "use strict";
@@ -18740,16 +18698,17 @@ enifed("handlebars", ["exports"], function (exports) {
     return strip.accept(handlebars.parse(input));
   };
 });
+/*global enifed */
 enifed('node-module', ['exports'], function(_exports) {
   var IS_NODE = typeof module === 'object' && typeof module.require === 'function';
   if (IS_NODE) {
     _exports.require = module.require;
     _exports.module = module;
-    _exports.IS_NODE = IS_NODE
+    _exports.IS_NODE = IS_NODE;
   } else {
     _exports.require = null;
     _exports.module = null;
-    _exports.IS_NODE = IS_NODE
+    _exports.IS_NODE = IS_NODE;
   }
 });
 enifed("simple-html-tokenizer", ["exports"], function (exports) {