ember-source 2.17.2 → 2.18.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88f279808b47b8cb3bf5c3b05c68aa44e52761df5681969d9618e54f30042e6c
-  data.tar.gz: 91af64861625b8962ec410954aeb575af88d7445659bd9421f01d88238d2a80c
+  metadata.gz: 0a1f07f335db8b7372bb82060ed1f93972af30747e3936b4c31fbaf1a968e4e3
+  data.tar.gz: 182d672ee9a3b25cc581d83dea780304026b8d962cfb2b84763372312ef18627
 SHA512:
-  metadata.gz: 3267332ad1bb675df2be5dd2851d0e9eb4e043ef3b276a7da216d948d23a3b0135dc42fc9b6e32213ae75948e9dca8aa3d772d3e6cf41feb5700c8f28a6bba94
-  data.tar.gz: 437911cd8ea5bca3754dbb36ac0683824c3de0ffbdfb3cd29715b876f9f40dd1d1bacac5e2d043d66bd464eaef27345a5b317fbf41c8a8a83dead8028d558c26
+  metadata.gz: 536178cc4558abdeeea5ddbf3b01e1b635307d023f6eb0bfe3fb010e4e7714c71b948fb7d8c4757b13df184e9595a3acf65ef0b3b63130f0ca58e4a010f76cbf
+  data.tar.gz: 0c94bd7e28233c9ba2a900a2f2febcd8dab734ec53dd03b33d48ac67cd1656a411c454cb580bf7706cf14954d22fd7354b17752fa9c79cdba8ce0966cf3b2100

data/dist/ember-runtime.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 = {
@@ -134,52 +135,112 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
    @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] : {};
+      (0, _emberBabel.classCallCheck)(this, Container);
+
+      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;
 
-    if (true) {
-      this.validationCache = (0, _emberUtils.dictionary)(options.validationCache || null);
+      if (true) {
+        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)));
+    /**
+     @private
+     @property registry
+     @type Registry
+     @since 1.11.0
+     */
 
-      return lookup(this, this.registry.normalize(fullName), options);
-    },
-    destroy: function () {
+    /**
+     @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 lookup(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 destroy() {
       destroyDestroyables(this);
       this.isDestroyed = true;
-    },
-    reset: function (fullName) {
+    };
+
+    Container.prototype.reset = function reset(fullName) {
       if (fullName === undefined) {
         resetCache(this);
       } else {
         resetMember(this, this.registry.normalize(fullName));
       }
-    },
-    ownerInjection: function () {
+    };
+
+    Container.prototype.ownerInjection = function ownerInjection() {
       var _ref;
 
       return _ref = {}, _ref[_emberUtils.OWNER] = this.owner, _ref;
-    },
-    _resolverCacheKey: function (name, options) {
+    };
+
+    Container.prototype._resolverCacheKey = function _resolverCacheKey(name, options) {
       return this.registry.resolverCacheKey(name, options);
-    },
-    factoryFor: function (fullName) {
+    };
+
+    Container.prototype.factoryFor = function factoryFor(fullName) {
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
       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) {
@@ -224,8 +285,10 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
 
       this.factoryManagerCache[cacheKey] = manager;
       return manager;
-    }
-  };
+    };
+
+    return Container;
+  }();
 
   /*
    * Wrap a factory manager in a proxy which will not permit properties to be
@@ -264,7 +327,7 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
     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] : {};
 
     if (options.source) {
@@ -351,28 +414,19 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
     throw new Error('Could not create factory');
   }
 
-  function buildInjections() /* container, ...injections */{
+  function buildInjections(container, injections) {
     var hash = {};
     var isDynamic = false;
 
-    if (arguments.length > 1) {
-      var container = arguments[0];
-      var injections = [];
-      var injection = void 0;
-
-      for (var i = 1; i < arguments.length; i++) {
-        if (arguments[i]) {
-          injections = injections.concat(arguments[i]);
-        }
-      }
-
+    if (injections.length > 0) {
       if (true) {
         container.registry.validateInjections(injections);
       }
 
-      for (var _i = 0; _i < injections.length; _i++) {
-        injection = injections[_i];
-        hash[injection.property] = lookup(container, injection.fullName);
+      var injection = void 0;
+      for (var i = 0; i < injections.length; i++) {
+        injection = injections[i];
+        hash[injection.property] = _lookup(container, injection.fullName);
         if (!isDynamic) {
           isDynamic = !isSingleton(container, injection.fullName);
         }
@@ -384,10 +438,12 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
 
   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) {
@@ -516,40 +572,39 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
    @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] : {};
+      (0, _emberBabel.classCallCheck)(this, Registry);
+
+      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.
@@ -557,81 +612,79 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
      @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 container(options) {
       return new Container(this, options);
-    },
-    register: function (fullName, factory) {
+    };
+
+    Registry.prototype.register = function register(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)));
+      (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));
 
 
-      if (factory === undefined) {
-        throw new TypeError('Attempting to register an unknown factory: \'' + fullName + '\'');
-      }
-
       var normalizedName = this.normalize(fullName);
+      (true && !(!this._resolveCache[normalizedName]) && (0, _emberDebug.assert)('Cannot re-register: \'' + fullName + '\', as it has already been resolved.', !this._resolveCache[normalizedName]));
 
-      if (this._resolveCache[normalizedName]) {
-        throw new Error('Cannot re-register: \'' + fullName + '\', as it has already been resolved.');
-      }
 
       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 unregister(fullName) {
+      (true && !(this.isValidFullName(fullName)) && (0, _emberDebug.assert)('fullName must be a proper full name', this.isValidFullName(fullName)));
 
 
       var normalizedName = this.normalize(fullName);
@@ -642,83 +695,94 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
       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 resolve(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);
-      if (factory === undefined && this.fallback) {
+      var factory = _resolve(this, this.normalize(fullName), options);
+      if (factory === undefined && this.fallback !== null) {
         var _fallback;
 
         factory = (_fallback = this.fallback).resolve.apply(_fallback, arguments);
       }
       return factory;
-    },
-    describe: function (fullName) {
-      if (this.resolver && this.resolver.lookupDescription) {
+    };
+
+    Registry.prototype.describe = function describe(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 normalizeFullName(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 normalize(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 makeToString(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 has(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 optionsForType(type, options) {
       this._typeOptions[type] = options;
-    },
-    getOptionsForType: function (type) {
+    };
+
+    Registry.prototype.getOptionsForType = function getOptionsForType(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 options(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 getOptions(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 getOption(fullName, optionName) {
       var options = this._options[fullName];
 
       if (options && options[optionName] !== undefined) {
@@ -730,40 +794,44 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
 
       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 typeInjection(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 injection(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 knownForType(type) {
       var fallbackKnown = void 0,
           resolverKnown = void 0;
 
@@ -778,72 +846,70 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
         }
       }
 
-      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 isValidFullName(fullName) {
       return VALID_FULL_NAME_REGEXP.test(fullName);
-    },
-    getInjections: function (fullName) {
+    };
+
+    Registry.prototype.getInjections = function getInjections(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 getTypeInjections(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 resolverCacheKey(name, options) {
       if (!_features.EMBER_MODULE_UNIFICATION) {
         return name;
       }
 
       return options && options.source ? options.source + ':' + name : name;
-    },
-    expandLocalLookup: function (fullName, options) {
-      if (this.resolver && this.resolver.expandLocalLookup) {
-        (true && !(this.validateFullName(fullName)) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName)));
+    };
+
+    Registry.prototype.expandLocalLookup = function expandLocalLookup(fullName, options) {
+      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)));
 
 
         var normalizedFullName = this.normalize(fullName);
         var 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 };
   }
 
   if (true) {
@@ -852,7 +918,7 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
 
       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({
@@ -880,7 +946,7 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
     };
   }
 
-  function expandLocalLookup(registry, normalizedName, normalizedSource) {
+  function _expandLocalLookup(registry, normalizedName, normalizedSource) {
     var cache = registry._localLookupCache;
     var normalizedNameCache = cache[normalizedName];
 
@@ -899,7 +965,7 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
     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
@@ -948,7 +1014,7 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
     return resolved;
   }
 
-  function has(registry, fullName, source) {
+  function _has(registry, fullName, source) {
     return registry.resolve(fullName, { source: source }) !== undefined;
   }
 
@@ -963,9 +1029,9 @@ enifed('container', ['exports', 'ember-babel', 'ember-utils', 'ember-debug', 'em
       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);
   }
@@ -1074,13 +1140,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);
   }
 
   function assertPolyfill(test, message) {
@@ -4850,6 +4910,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();
@@ -4905,14 +4966,13 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   ComputedPropertyPrototype._set = function computedPropertySet(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);
@@ -4924,17 +4984,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);
 
@@ -6461,17 +6515,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       this._coreLibIndex = 0;
     }
 
-    Libraries.prototype.isRegistered = function isRegistered(name) {
-      return !!this._getLibraryByName(name);
-    };
-
-    return Libraries;
-  }();
-
-  Libraries.prototype = {
-    constructor: Libraries,
-
-    _getLibraryByName: function (name) {
+    Libraries.prototype._getLibraryByName = function _getLibraryByName(name) {
       var libs = this._registry;
       var count = libs.length;
 
@@ -6480,8 +6524,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
           return libs[i];
         }
       }
-    },
-    register: function (name, version, isCoreLibrary) {
+    };
+
+    Libraries.prototype.register = function register(name, version, isCoreLibrary) {
       var index = this._registry.length;
 
       if (!this._getLibraryByName(name)) {
@@ -6492,11 +6537,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 registerCoreLibrary(name, version) {
       this.register(name, version, true);
-    },
-    deRegister: function (name) {
+    };
+
+    Libraries.prototype.deRegister = function deRegister(name) {
       var lib = this._getLibraryByName(name);
       var index = void 0;
 
@@ -6504,8 +6551,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) {