ember-source 2.14.0.beta.2 → 2.14.0.beta.3

data/dist/ember-template-compiler.js

@@ -6,7 +6,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   2.14.0-beta.2
+ * @version   2.14.0-beta.3
  */
 
 var enifed, requireModule, Ember;
@@ -4770,12 +4770,12 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember-environment
 
   Container.prototype = {
     lookup: function (fullName, options) {
-      true && (0, _emberDebug.assert)('fullName must be a proper full name', this.registry.validateFullName(fullName));
+      true && !this.registry.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.registry.validateFullName(fullName));
 
       return lookup(this, this.registry.normalize(fullName), options);
     },
     lookupFactory: function (fullName, options) {
-      true && (0, _emberDebug.assert)('fullName must be a proper full name', this.registry.validateFullName(fullName));
+      true && !this.registry.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.registry.validateFullName(fullName));
       true && !false && (0, _emberDebug.deprecate)('Using "_lookupFactory" is deprecated. Please use container.factoryFor instead.', false, { id: 'container-lookupFactory', until: '2.13.0', url: 'http://emberjs.com/deprecations/v2.x/#toc_migrating-from-_lookupfactory-to-factoryfor' });
 
       return deprecatedFactoryFor(this, this.registry.normalize(fullName), options);
@@ -4801,7 +4801,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember-environment
 
       var normalizedName = this.registry.normalize(fullName);
 
-      true && (0, _emberDebug.assert)('fullName must be a proper full name', this.registry.validateFullName(normalizedName));
+      true && !this.registry.validateFullName(normalizedName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.registry.validateFullName(normalizedName));
 
       if (options.source) {
         normalizedName = this.registry.expandLocalLookup(fullName, options);
@@ -5382,7 +5382,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember-environment
     },
     register: function (fullName, factory) {
       var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-      true && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
+      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 + '\'');
@@ -5399,7 +5399,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember-environment
       this._options[normalizedName] = options;
     },
     unregister: function (fullName) {
-      true && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
+      true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
 
       var normalizedName = this.normalize(fullName);
 
@@ -5411,7 +5411,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember-environment
       delete this._options[normalizedName];
     },
     resolve: function (fullName, options) {
-      true && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
+      true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
 
       var factory = resolve(this, this.normalize(fullName), options),
           _fallback;
@@ -5502,7 +5502,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember-environment
       }
     },
     typeInjection: function (type, property, fullName) {
-      true && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
+      true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
 
       var fullNameType = fullName.split(':')[0];
       if (fullNameType === type) {
@@ -5524,7 +5524,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember-environment
         return this.typeInjection(fullName, property, normalizedInjectionName);
       }
 
-      true && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
+      true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
 
       var normalizedName = this.normalize(fullName);
 
@@ -5610,7 +5610,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember-environment
       for (i = 0; i < injections.length; i++) {
         fullName = injections[i].fullName;
 
-        true && (0, _emberDebug.assert)('Attempting to inject an unknown injection: \'' + fullName + '\'', this.has(fullName));
+        true && !this.has(fullName) && (0, _emberDebug.assert)('Attempting to inject an unknown injection: \'' + fullName + '\'', this.has(fullName));
       }
     },
     normalizeInjectionsHash: function (hash) {
@@ -5618,7 +5618,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember-environment
 
       for (var key in hash) {
         if (hash.hasOwnProperty(key)) {
-          true && (0, _emberDebug.assert)('Expected a proper full name, given \'' + hash[key] + '\'', this.validateFullName(hash[key]));
+          true && !this.validateFullName(hash[key]) && (0, _emberDebug.assert)('Expected a proper full name, given \'' + hash[key] + '\'', this.validateFullName(hash[key]));
 
           injections.push({
             property: key,
@@ -5689,9 +5689,9 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember-environment
     var normalizedFullName, normalizedSource;
 
     if (this.resolver && this.resolver.expandLocalLookup) {
-      true && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
-      true && (0, _emberDebug.assert)('options.source must be provided to expandLocalLookup', options && options.source);
-      true && (0, _emberDebug.assert)('options.source must be a proper full name', this.validateFullName(options.source));
+      true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(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));
 
       normalizedFullName = this.normalize(fullName);
       normalizedSource = this.normalize(options.source);
@@ -6000,9 +6000,12 @@ enifed('ember-console', ['exports', 'ember-environment'], function (exports, _em
 enifed('ember-debug/deprecate', ['exports', 'ember-debug/error', 'ember-console', 'ember-environment', 'ember-debug/handlers'], function (exports, _error, _emberConsole, _emberEnvironment, _handlers) {
   'use strict';
 
-  exports.missingOptionsUntilDeprecation = exports.missingOptionsIdDeprecation = exports.missingOptionsDeprecation = undefined;
-  exports.registerHandler = registerHandler;
-  exports.default = deprecate;
+  exports.missingOptionsUntilDeprecation = exports.missingOptionsIdDeprecation = exports.missingOptionsDeprecation = exports.registerHandler = undefined;
+
+  /**
+  @module ember
+  @submodule ember-debug
+  */
 
   /**
     Allows for runtime registration of handler functions that override the default deprecation behavior.
@@ -6039,13 +6042,18 @@ enifed('ember-debug/deprecate', ['exports', 'ember-debug/error', 'ember-console'
     @param handler {Function} A function to handle deprecation calls.
     @since 2.1.0
   */
-  /*global __fail__*/
+  var registerHandler = function () {}; /*global __fail__*/
 
-  function registerHandler(handler) {
+  var missingOptionsDeprecation = void 0,
+      missingOptionsIdDeprecation = void 0,
+      missingOptionsUntilDeprecation = void 0,
+      deprecate = void 0;
+
+  exports.registerHandler = registerHandler = function (handler) {
     (0, _handlers.registerHandler)('deprecate', handler);
-  }
+  };
 
-  function formatMessage(_message, options) {
+  var formatMessage = function (_message, options) {
     var message = _message;
 
     if (options && options.id) {
@@ -6057,7 +6065,7 @@ enifed('ember-debug/deprecate', ['exports', 'ember-debug/error', 'ember-console'
     }
 
     return message;
-  }
+  };
 
   registerHandler(function (message, options) {
     var updatedMessage = formatMessage(message, options);
@@ -6125,23 +6133,16 @@ enifed('ember-debug/deprecate', ['exports', 'ember-debug/error', 'ember-console'
     }
   });
 
-  var missingOptionsDeprecation = exports.missingOptionsDeprecation = 'When calling `Ember.deprecate` you ' + 'must provide an `options` hash as the third parameter.  ' + '`options` should include `id` and `until` properties.';
-  var missingOptionsIdDeprecation = exports.missingOptionsIdDeprecation = 'When calling `Ember.deprecate` you must provide `id` in options.';
-  var missingOptionsUntilDeprecation = exports.missingOptionsUntilDeprecation = 'When calling `Ember.deprecate` you must provide `until` in options.';
-
-  /**
-  @module ember
-  @submodule ember-debug
-  */
+  exports.missingOptionsDeprecation = missingOptionsDeprecation = 'When calling `Ember.deprecate` you ' + 'must provide an `options` hash as the third parameter.  ' + '`options` should include `id` and `until` properties.';
+  exports.missingOptionsIdDeprecation = missingOptionsIdDeprecation = 'When calling `Ember.deprecate` you must provide `id` in options.';
+  exports.missingOptionsUntilDeprecation = missingOptionsUntilDeprecation = 'When calling `Ember.deprecate` you must provide `until` in options.';
 
   /**
     Display a deprecation warning with the provided message and a stack trace
     (Chrome and Firefox only).
-  
-    * In a production build, this method is defined as an empty function (NOP).
+     * In a production build, this method is defined as an empty function (NOP).
     Uses of this method in Ember itself are stripped from the ember.prod.js build.
-  
-    @method deprecate
+     @method deprecate
     @param {String} message A description of the deprecation.
     @param {Boolean} test A boolean. If falsy, the deprecation will be displayed.
     @param {Object} options
@@ -6157,7 +6158,7 @@ enifed('ember-debug/deprecate', ['exports', 'ember-debug/error', 'ember-console'
     @public
     @since 1.0.0
   */
-  function deprecate(message, test, options) {
+  deprecate = function deprecate(message, test, options) {
     if (!options || !options.id && !options.until) {
       deprecate(missingOptionsDeprecation, false, {
         id: 'ember-debug.deprecate-options-missing',
@@ -6183,7 +6184,14 @@ enifed('ember-debug/deprecate', ['exports', 'ember-debug/error', 'ember-console'
     }
 
     _handlers.invoke.apply(undefined, ['deprecate'].concat(Array.prototype.slice.call(arguments)));
-  }
+  };
+
+
+  exports.default = deprecate;
+  exports.registerHandler = registerHandler;
+  exports.missingOptionsDeprecation = missingOptionsDeprecation;
+  exports.missingOptionsIdDeprecation = missingOptionsIdDeprecation;
+  exports.missingOptionsUntilDeprecation = missingOptionsUntilDeprecation;
 });
 enifed("ember-debug/error", ["exports", "ember-babel"], function (exports, _emberBabel) {
   "use strict";
@@ -6292,17 +6300,23 @@ enifed('ember-debug/features', ['exports', 'ember-environment', 'ember/features'
   };
   var FEATURES = _features.FEATURES;
 });
-enifed("ember-debug/handlers", ["exports"], function (exports) {
-  "use strict";
+enifed('ember-debug/handlers', ['exports'], function (exports) {
+  'use strict';
 
-  exports.registerHandler = function (type, callback) {
+  var HANDLERS = exports.HANDLERS = {};
+
+  var registerHandler = function () {};
+  var invoke = function () {};
+
+  exports.registerHandler = registerHandler = function (type, callback) {
     var nextHandler = HANDLERS[type] || function () {};
 
     HANDLERS[type] = function (message, options) {
       callback(message, options, nextHandler);
     };
   };
-  exports.invoke = function (type, message, test, options) {
+
+  exports.invoke = invoke = function (type, message, test, options) {
     if (test) {
       return;
     }
@@ -6313,12 +6327,15 @@ enifed("ember-debug/handlers", ["exports"], function (exports) {
       handlerForType(message, options);
     }
   };
-  var HANDLERS = exports.HANDLERS = {};
+
+
+  exports.registerHandler = registerHandler;
+  exports.invoke = invoke;
 });
 enifed('ember-debug/index', ['exports', 'ember-debug/warn', 'ember-debug/deprecate', 'ember-debug/features', 'ember-debug/error', 'ember-debug/testing', 'ember-environment', 'ember-console', 'ember/features'], function (exports, _warn2, _deprecate2, _features, _error, _testing, _emberEnvironment, _emberConsole, _features2) {
   'use strict';
 
-  exports.runningNonEmberDebugJS = exports.debugFunctions = exports.setTesting = exports.isTesting = exports.Error = exports.isFeatureEnabled = exports.registerDeprecationHandler = exports.registerWarnHandler = undefined;
+  exports._warnIfUsingStrippedFeatureFlags = exports.getDebugFunction = exports.setDebugFunction = exports.deprecateFunc = exports.runInDebug = exports.debugFreeze = exports.debugSeal = exports.deprecate = exports.debug = exports.warn = exports.info = exports.assert = exports.setTesting = exports.isTesting = exports.Error = exports.isFeatureEnabled = exports.registerDeprecationHandler = exports.registerWarnHandler = undefined;
   Object.defineProperty(exports, 'registerWarnHandler', {
     enumerable: true,
     get: function () {
@@ -6355,50 +6372,73 @@ enifed('ember-debug/index', ['exports', 'ember-debug/warn', 'ember-debug/depreca
       return _testing.setTesting;
     }
   });
-  exports._warnIfUsingStrippedFeatureFlags = _warnIfUsingStrippedFeatureFlags;
-  exports.getDebugFunction = function (name) {
-    return debugFunctions[name];
-  };
-  exports.setDebugFunction = setDebugFunction;
-  exports.assert = function () {
-    return debugFunctions.assert.apply(undefined, arguments);
-  };
-  exports.info = function () {
-    return debugFunctions.info.apply(undefined, arguments);
-  };
-  exports.warn = warn;
-  exports.debug = debug;
-  exports.deprecate = deprecate;
-  exports.deprecateFunc = function () {
-    return debugFunctions.deprecateFunc.apply(undefined, arguments);
-  };
-  exports.runInDebug = function () {
-    return debugFunctions.runInDebug.apply(undefined, arguments);
-  };
-  exports.debugSeal = function () {
-    return debugFunctions.debugSeal.apply(undefined, arguments);
-  };
-  exports.debugFreeze = function () {
-    return debugFunctions.debugFreeze.apply(undefined, arguments);
-  };
   var DEFAULT_FEATURES = _features2.DEFAULT_FEATURES,
       FEATURES = _features2.FEATURES,
       featuresWereStripped,
       isFirefox,
       isChrome;
-  var debugFunctions = exports.debugFunctions = {
-    assert: function () {},
-    info: function () {},
-    warn: function () {},
-    debug: function () {},
-    deprecate: function () {},
-    deprecateFunc: function () {
-      var _ref;
 
-      return _ref = arguments.length - 1, arguments.length <= _ref ? undefined : arguments[_ref];
-    },
-    debugSeal: function () {},
-    debugFreeze: function () {}
+  // These are the default production build versions:
+  var assert = function () {};
+  var info = function () {};
+  var warn = function () {};
+  var debug = function () {};
+  var deprecate = function () {};
+  var debugSeal = function () {};
+  var debugFreeze = function () {};
+  var runInDebug = function () {};
+
+  var deprecateFunc = function () {
+    return arguments[arguments.length - 1];
+  };
+
+  var setDebugFunction = function () {};
+  var getDebugFunction = function () {};
+
+  exports.setDebugFunction = setDebugFunction = function (type, callback) {
+    switch (type) {
+      case 'assert':
+        return exports.assert = assert = callback;
+      case 'info':
+        return exports.info = info = callback;
+      case 'warn':
+        return exports.warn = warn = callback;
+      case 'debug':
+        return exports.debug = debug = callback;
+      case 'deprecate':
+        return exports.deprecate = deprecate = callback;
+      case 'debugSeal':
+        return exports.debugSeal = debugSeal = callback;
+      case 'debugFreeze':
+        return exports.debugFreeze = debugFreeze = callback;
+      case 'runInDebug':
+        return exports.runInDebug = runInDebug = callback;
+      case 'deprecateFunc':
+        return exports.deprecateFunc = deprecateFunc = callback;
+    }
+  };
+
+  exports.getDebugFunction = getDebugFunction = function (type) {
+    switch (type) {
+      case 'assert':
+        return assert;
+      case 'info':
+        return info;
+      case 'warn':
+        return warn;
+      case 'debug':
+        return debug;
+      case 'deprecate':
+        return deprecate;
+      case 'debugSeal':
+        return debugSeal;
+      case 'debugFreeze':
+        return debugFreeze;
+      case 'runInDebug':
+        return runInDebug;
+      case 'deprecateFunc':
+        return deprecateFunc;
+    }
   };
 
   /**
@@ -6413,19 +6453,15 @@ enifed('ember-debug/index', ['exports', 'ember-debug/warn', 'ember-debug/depreca
 
   /**
     Define an assertion that will throw an exception if the condition is not met.
-  
-    * In a production build, this method is defined as an empty function (NOP).
+     * In a production build, this method is defined as an empty function (NOP).
     Uses of this method in Ember itself are stripped from the ember.prod.js build.
-  
-    ```javascript
+     ```javascript
     // Test for truthiness
     Ember.assert('Must pass a valid object', obj);
-  
-    // Fail unconditionally
+     // Fail unconditionally
     Ember.assert('This code path should never be run');
     ```
-  
-    @method assert
+     @method assert
     @param {String} desc A description of the assertion. This will become
       the text of the Error thrown if the assertion fails.
     @param {Boolean} test Must be truthy for the assertion to pass. If
@@ -6441,15 +6477,12 @@ enifed('ember-debug/index', ['exports', 'ember-debug/warn', 'ember-debug/depreca
 
   /**
     Display a debug notice.
-  
-    * In a production build, this method is defined as an empty function (NOP).
+     * In a production build, this method is defined as an empty function (NOP).
     Uses of this method in Ember itself are stripped from the ember.prod.js build.
-  
-    ```javascript
+     ```javascript
     Ember.debug('I\'m a debug notice!');
     ```
-  
-    @method debug
+     @method debug
     @param {String} message A debug message to display.
     @public
   */
@@ -6459,11 +6492,9 @@ enifed('ember-debug/index', ['exports', 'ember-debug/warn', 'ember-debug/depreca
 
   /**
     Display an info notice.
-  
-    * In a production build, this method is defined as an empty function (NOP).
+     * In a production build, this method is defined as an empty function (NOP).
     Uses of this method in Ember itself are stripped from the ember.prod.js build.
-  
-    @method info
+     @method info
     @private
   */
   setDebugFunction('info', function () {
@@ -6472,17 +6503,13 @@ enifed('ember-debug/index', ['exports', 'ember-debug/warn', 'ember-debug/depreca
 
   /**
     Alias an old, deprecated method with its new counterpart.
-  
-    Display a deprecation warning with the provided message and a stack trace
+     Display a deprecation warning with the provided message and a stack trace
     (Chrome and Firefox only) when the assigned method is called.
-  
-    * In a production build, this method is defined as an empty function (NOP).
-  
-    ```javascript
+     * In a production build, this method is defined as an empty function (NOP).
+     ```javascript
     Ember.oldMethod = Ember.deprecateFunc('Please use the new, updated method', Ember.newMethod);
     ```
-  
-    @method deprecateFunc
+     @method deprecateFunc
     @param {String} message A description of the deprecation.
     @param {Object} [options] The options object for Ember.deprecate.
     @param {Function} func The new function called to replace its deprecated counterpart.
@@ -6517,11 +6544,9 @@ enifed('ember-debug/index', ['exports', 'ember-debug/warn', 'ember-debug/depreca
 
   /**
     Run a function meant for debugging.
-  
-    * In a production build, this method is defined as an empty function (NOP).
+     * In a production build, this method is defined as an empty function (NOP).
     Uses of this method in Ember itself are stripped from the ember.prod.js build.
-  
-    ```javascript
+     ```javascript
     Ember.runInDebug(() => {
       Ember.Component.reopen({
         didInsertElement() {
@@ -6530,8 +6555,7 @@ enifed('ember-debug/index', ['exports', 'ember-debug/warn', 'ember-debug/depreca
       });
     });
     ```
-  
-    @method runInDebug
+     @method runInDebug
     @param {Function} func The function to be executed.
     @since 1.5.0
     @public
@@ -6552,37 +6576,38 @@ enifed('ember-debug/index', ['exports', 'ember-debug/warn', 'ember-debug/depreca
 
   setDebugFunction('warn', _warn2.default);
 
-  /**
-    Will call `Ember.warn()` if ENABLE_OPTIONAL_FEATURES or
-    any specific FEATURES flag is truthy.
-  
-    This method is called automatically in debug canary builds.
-  
-    @private
-    @method _warnIfUsingStrippedFeatureFlags
-    @return {void}
-  */
-  function _warnIfUsingStrippedFeatureFlags(FEATURES, knownFeatures, featuresWereStripped) {
-    var keys, i, key;
 
-    if (featuresWereStripped) {
-      warn('Ember.ENV.ENABLE_OPTIONAL_FEATURES is only available in canary builds.', !_emberEnvironment.ENV.ENABLE_OPTIONAL_FEATURES, { id: 'ember-debug.feature-flag-with-features-stripped' });
+  var _warnIfUsingStrippedFeatureFlags = void 0;
 
-      keys = Object.keys(FEATURES || {});
+  if (true && !(0, _testing.isTesting)()) {
+    /**
+       Will call `Ember.warn()` if ENABLE_OPTIONAL_FEATURES or
+       any specific FEATURES flag is truthy.
+        This method is called automatically in debug canary builds.
+        @private
+       @method _warnIfUsingStrippedFeatureFlags
+       @return {void}
+    */
+    exports._warnIfUsingStrippedFeatureFlags = _warnIfUsingStrippedFeatureFlags = function (FEATURES, knownFeatures, featuresWereStripped) {
+      var keys, i, key;
 
-      for (i = 0; i < keys.length; i++) {
-        key = keys[i];
+      if (featuresWereStripped) {
+        warn('Ember.ENV.ENABLE_OPTIONAL_FEATURES is only available in canary builds.', !_emberEnvironment.ENV.ENABLE_OPTIONAL_FEATURES, { id: 'ember-debug.feature-flag-with-features-stripped' });
 
-        if (key === 'isEnabled' || !(key in knownFeatures)) {
-          continue;
-        }
+        keys = Object.keys(FEATURES || {});
+
+        for (i = 0; i < keys.length; i++) {
+          key = keys[i];
 
-        warn('FEATURE["' + key + '"] is set as enabled, but FEATURE flags are only available in canary builds.', !FEATURES[key], { id: 'ember-debug.feature-flag-with-features-stripped' });
+          if (key === 'isEnabled' || !(key in knownFeatures)) {
+            continue;
+          }
+
+          warn('FEATURE["' + key + '"] is set as enabled, but FEATURE flags are only available in canary builds.', !FEATURES[key], { id: 'ember-debug.feature-flag-with-features-stripped' });
+        }
       }
-    }
-  }
+    };
 
-  if (!(0, _testing.isTesting)()) {
     // Complain if they're using FEATURE flags in builds other than canary
     FEATURES['features-stripped-test'] = true;
     featuresWereStripped = true;
@@ -6620,37 +6645,18 @@ enifed('ember-debug/index', ['exports', 'ember-debug/warn', 'ember-debug/depreca
     }
   }
 
-  /*
-    We are transitioning away from `ember.js` to `ember.debug.js` to make
-    it much clearer that it is only for local development purposes.
-  
-    This flag value is changed by the tooling (by a simple string replacement)
-    so that if `ember.js` (which must be output for backwards compat reasons) is
-    used a nice helpful warning message will be printed out.
-  */
-  var runningNonEmberDebugJS = exports.runningNonEmberDebugJS = false;
-  if (runningNonEmberDebugJS) {
-    warn('Please use `ember.debug.js` instead of `ember.js` for development and debugging.');
-  }
-
-  function setDebugFunction(name, fn) {
-    debugFunctions[name] = fn;
-  }
-
-  function warn() {
-    return debugFunctions.warn.apply(undefined, arguments);
-  }
-
-  function debug() {
-    return debugFunctions.debug.apply(undefined, arguments);
-  }
-
-  function deprecate() {
-    return debugFunctions.deprecate.apply(undefined, arguments);
-  }
-});
-enifed("ember-debug/run-in-debug", [], function () {
-  "use strict";
+  exports.assert = assert;
+  exports.info = info;
+  exports.warn = warn;
+  exports.debug = debug;
+  exports.deprecate = deprecate;
+  exports.debugSeal = debugSeal;
+  exports.debugFreeze = debugFreeze;
+  exports.runInDebug = runInDebug;
+  exports.deprecateFunc = deprecateFunc;
+  exports.setDebugFunction = setDebugFunction;
+  exports.getDebugFunction = getDebugFunction;
+  exports._warnIfUsingStrippedFeatureFlags = _warnIfUsingStrippedFeatureFlags;
 });
 enifed("ember-debug/testing", ["exports"], function (exports) {
   "use strict";
@@ -6666,22 +6672,61 @@ enifed("ember-debug/testing", ["exports"], function (exports) {
 enifed('ember-debug/warn', ['exports', 'ember-console', 'ember-debug/deprecate', 'ember-debug/handlers'], function (exports, _emberConsole, _deprecate, _handlers) {
   'use strict';
 
-  exports.missingOptionsIdDeprecation = exports.missingOptionsDeprecation = undefined;
-  exports.registerHandler = registerHandler;
-  exports.default =
+  exports.missingOptionsDeprecation = exports.missingOptionsIdDeprecation = exports.registerHandler = undefined;
+
+  var registerHandler = function () {};
+  var warn = function () {};
+  var missingOptionsDeprecation = void 0,
+      missingOptionsIdDeprecation = void 0;
 
   /**
   @module ember
   @submodule ember-debug
   */
 
+  /**
+    Allows for runtime registration of handler functions that override the default warning behavior.
+    Warnings are invoked by calls made to [Ember.warn](http://emberjs.com/api/classes/Ember.html#method_warn).
+    The following example demonstrates its usage by registering a handler that does nothing overriding Ember's
+    default warning behavior.
+     ```javascript
+    // next is not called, so no warnings get the default behavior
+    Ember.Debug.registerWarnHandler(() => {});
+    ```
+     The handler function takes the following arguments:
+     <ul>
+      <li> <code>message</code> - The message received from the warn call. </li>
+      <li> <code>options</code> - An object passed in with the warn call containing additional information including:</li>
+        <ul>
+          <li> <code>id</code> - An id of the warning in the form of <code>package-name.specific-warning</code>.</li>
+        </ul>
+      <li> <code>next</code> - A function that calls into the previously registered handler.</li>
+    </ul>
+     @public
+    @static
+    @method registerWarnHandler
+    @param handler {Function} A function to handle warnings.
+    @since 2.1.0
+  */
+  exports.registerHandler = registerHandler = function (handler) {
+    (0, _handlers.registerHandler)('warn', handler);
+  };
+
+  registerHandler(function (message) {
+    _emberConsole.default.warn('WARNING: ' + message);
+    if ('trace' in _emberConsole.default) {
+      _emberConsole.default.trace();
+    }
+  });
+
+  exports.missingOptionsDeprecation = missingOptionsDeprecation = 'When calling `Ember.warn` you ' + 'must provide an `options` hash as the third parameter.  ' + '`options` should include an `id` property.';
+  exports.missingOptionsIdDeprecation = missingOptionsIdDeprecation = 'When calling `Ember.warn` you must provide `id` in options.';
+
   /**
     Display a warning with the provided message.
-  
-    * In a production build, this method is defined as an empty function (NOP).
+     * In a production build, this method is defined as an empty function (NOP).
     Uses of this method in Ember itself are stripped from the ember.prod.js build.
-  
-    @method warn
+     @method warn
     @param {String} message A warning to display.
     @param {Boolean} test An optional boolean. If falsy, the warning
       will be displayed.
@@ -6693,7 +6738,7 @@ enifed('ember-debug/warn', ['exports', 'ember-console', 'ember-debug/deprecate',
     @public
     @since 1.0.0
   */
-  function (message, test, options) {
+  warn = function (message, test, options) {
     if (arguments.length === 2 && typeof test === 'object') {
       options = test;
       test = false;
@@ -6717,47 +6762,11 @@ enifed('ember-debug/warn', ['exports', 'ember-console', 'ember-debug/deprecate',
     (0, _handlers.invoke)('warn', message, test, options);
   };
 
-  /**
-    Allows for runtime registration of handler functions that override the default warning behavior.
-    Warnings are invoked by calls made to [Ember.warn](http://emberjs.com/api/classes/Ember.html#method_warn).
-    The following example demonstrates its usage by registering a handler that does nothing overriding Ember's
-    default warning behavior.
-  
-    ```javascript
-    // next is not called, so no warnings get the default behavior
-    Ember.Debug.registerWarnHandler(() => {});
-    ```
-  
-    The handler function takes the following arguments:
-  
-    <ul>
-      <li> <code>message</code> - The message received from the warn call. </li>
-      <li> <code>options</code> - An object passed in with the warn call containing additional information including:</li>
-        <ul>
-          <li> <code>id</code> - An id of the warning in the form of <code>package-name.specific-warning</code>.</li>
-        </ul>
-      <li> <code>next</code> - A function that calls into the previously registered handler.</li>
-    </ul>
-  
-    @public
-    @static
-    @method registerWarnHandler
-    @param handler {Function} A function to handle warnings.
-    @since 2.1.0
-  */
-  function registerHandler(handler) {
-    (0, _handlers.registerHandler)('warn', handler);
-  }
 
-  registerHandler(function (message) {
-    _emberConsole.default.warn('WARNING: ' + message);
-    if ('trace' in _emberConsole.default) {
-      _emberConsole.default.trace();
-    }
-  });
-
-  var missingOptionsDeprecation = exports.missingOptionsDeprecation = 'When calling `Ember.warn` you ' + 'must provide an `options` hash as the third parameter.  ' + '`options` should include an `id` property.';
-  var missingOptionsIdDeprecation = exports.missingOptionsIdDeprecation = 'When calling `Ember.warn` you must provide `id` in options.';
+  exports.default = warn;
+  exports.registerHandler = registerHandler;
+  exports.missingOptionsIdDeprecation = missingOptionsIdDeprecation;
+  exports.missingOptionsDeprecation = missingOptionsDeprecation;
 });
 enifed('ember-environment', ['exports'], function (exports) {
   'use strict';
@@ -6863,9 +6872,6 @@ enifed('ember-environment', ['exports'], function (exports) {
   */
   ENV.LOG_VERSION = defaultTrue(ENV.LOG_VERSION);
 
-  // default false
-  ENV.MODEL_FACTORY_INJECTIONS = defaultFalse(ENV.MODEL_FACTORY_INJECTIONS);
-
   /**
     Debug parameter you can turn on. This will log all bindings that fire to
     the console. This should be disabled in production code. Note that you
@@ -7225,7 +7231,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     @public
   */
   function addListener(obj, eventName, target, method, once) {
-    true && emberDebug.assert('You must pass at least an object and event name to Ember.addListener', !!obj && !!eventName);
+    true && !(!!obj && !!eventName) && emberDebug.assert('You must pass at least an object and event name to Ember.addListener', !!obj && !!eventName);
     true && !(eventName !== 'didInitAttrs') && emberDebug.deprecate('didInitAttrs called in ' + (obj && obj.toString && obj.toString()) + '.', eventName !== 'didInitAttrs', {
       id: 'ember-views.did-init-attrs',
       until: '3.0.0',
@@ -7263,7 +7269,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     @public
   */
   function removeListener(obj, eventName, target, method) {
-    true && emberDebug.assert('You must pass at least an object and event name to Ember.removeListener', !!obj && !!eventName);
+    true && !(!!obj && !!eventName) && emberDebug.assert('You must pass at least an object and event name to Ember.removeListener', !!obj && !!eventName);
 
     if (!method && 'function' === typeof target) {
       method = target;
@@ -7676,7 +7682,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
           if (ember_features.EMBER_GLIMMER_ALLOW_BACKTRACKING_RERENDER) {
             true && !false && emberDebug.deprecate(message + ' will be removed in Ember 3.0.', false, { id: 'ember-views.render-double-modify', until: '3.0.0' });
           } else {
-            true && emberDebug.assert(message + ' is no longer supported. See https://github.com/emberjs/ember.js/issues/13948 for more details.', false);
+            true && !false && emberDebug.assert(message + ' is no longer supported. See https://github.com/emberjs/ember.js/issues/13948 for more details.', false);
           }
         }
 
@@ -8015,7 +8021,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       if (!m.isInitialized(this)) {
         m.writeValues(name, value);
       } else {
-        true && emberDebug.assert('You must use Ember.set() to set the `' + name + '` property (of ' + this + ') to `' + value + '`.', false);
+        true && !false && emberDebug.assert('You must use Ember.set() to set the `' + name + '` property (of ' + this + ') to `' + value + '`.', false);
       }
     }
 
@@ -8826,7 +8832,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       var key = memberProperty(name);
       var capitalized = capitalize(name);
       Meta.prototype['writable' + capitalized] = function (create) {
-        true && emberDebug.assert('Cannot call writable' + capitalized + ' after the object is destroyed.', !this.isMetaDestroyed());
+        true && !!this.isMetaDestroyed() && emberDebug.assert('Cannot call writable' + capitalized + ' after the object is destroyed.', !this.isMetaDestroyed());
 
         var ret = this[key];
         if (ret === undefined) {
@@ -9044,7 +9050,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
 
     Meta.prototype.writeDeps = function (subkey, itemkey, value) {
-      true && emberDebug.assert('Cannot call writeDeps after the object is destroyed.', !this.isMetaDestroyed());
+      true && !!this.isMetaDestroyed() && emberDebug.assert('Cannot call writeDeps after the object is destroyed.', !this.isMetaDestroyed());
 
       var outerMap = this._getOrCreateOwnMap('_deps');
       var innerMap = outerMap[subkey];
@@ -9209,7 +9215,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     var capitalized = capitalize(name);
 
     Meta.prototype['write' + capitalized] = function (subkey, value) {
-      true && emberDebug.assert('Cannot call write' + capitalized + ' after the object is destroyed.', !this.isMetaDestroyed());
+      true && !!this.isMetaDestroyed() && emberDebug.assert('Cannot call write' + capitalized + ' after the object is destroyed.', !this.isMetaDestroyed());
 
       var map = this._getOrCreateOwnMap(key);
       map[subkey] = value;
@@ -9240,7 +9246,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     };
 
     Meta.prototype['clear' + capitalized] = function () {
-      true && emberDebug.assert('Cannot call clear' + capitalized + ' after the object is destroyed.', !this.isMetaDestroyed());
+      true && !!this.isMetaDestroyed() && emberDebug.assert('Cannot call clear' + capitalized + ' after the object is destroyed.', !this.isMetaDestroyed());
 
       this[key] = undefined;
     };
@@ -9262,7 +9268,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     var key = memberProperty(name);
     var capitalized = capitalize(name);
     Meta.prototype['writable' + capitalized] = function (create) {
-      true && emberDebug.assert('Cannot call writable' + capitalized + ' after the object is destroyed.', !this.isMetaDestroyed());
+      true && !!this.isMetaDestroyed() && emberDebug.assert('Cannot call writable' + capitalized + ' after the object is destroyed.', !this.isMetaDestroyed());
 
       var ret = this[key];
       if (ret === undefined) {
@@ -9627,11 +9633,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     @public
   */
   function get(obj, keyName) {
-    true && emberDebug.assert('Get must be called with two arguments; an object and a property key', arguments.length === 2);
-    true && emberDebug.assert('Cannot call get with \'' + keyName + '\' on an undefined object.', obj !== undefined && obj !== null);
-    true && emberDebug.assert('The key provided to get must be a string, you passed ' + keyName, typeof keyName === 'string');
-    true && emberDebug.assert('\'this\' in paths is not supported', !hasThis(keyName));
-    true && emberDebug.assert('Cannot call `Ember.get` with an empty string', keyName !== '');
+    true && !(arguments.length === 2) && emberDebug.assert('Get must be called with two arguments; an object and a property key', arguments.length === 2);
+    true && !(obj !== undefined && obj !== null) && emberDebug.assert('Cannot call get with \'' + keyName + '\' on an undefined object.', obj !== undefined && obj !== null);
+    true && !(typeof keyName === 'string') && emberDebug.assert('The key provided to get must be a string, you passed ' + keyName, typeof keyName === 'string');
+    true && !!hasThis(keyName) && emberDebug.assert('\'this\' in paths is not supported', !hasThis(keyName));
+    true && !(keyName !== '') && emberDebug.assert('Cannot call `Ember.get` with an empty string', keyName !== '');
 
     var value = obj[keyName];
     var desc = value !== null && typeof value === 'object' && value.isDescriptor ? value : undefined;
@@ -9719,11 +9725,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     @public
   */
   function set(obj, keyName, value, tolerant) {
-    true && emberDebug.assert('Set must be called with three or four arguments; an object, a property key, a value and tolerant true/false', arguments.length === 3 || arguments.length === 4);
-    true && emberDebug.assert('Cannot call set with \'' + keyName + '\' on an undefined object.', obj && typeof obj === 'object' || typeof obj === 'function');
-    true && emberDebug.assert('The key provided to set must be a string, you passed ' + keyName, typeof keyName === 'string');
-    true && emberDebug.assert('\'this\' in paths is not supported', !hasThis(keyName));
-    true && emberDebug.assert('calling set on destroyed object: ' + emberUtils.toString(obj) + '.' + keyName + ' = ' + emberUtils.toString(value), !obj.isDestroyed);
+    true && !(arguments.length === 3 || arguments.length === 4) && emberDebug.assert('Set must be called with three or four arguments; an object, a property key, a value and tolerant true/false', arguments.length === 3 || arguments.length === 4);
+    true && !(obj && typeof obj === 'object' || typeof obj === 'function') && emberDebug.assert('Cannot call set with \'' + keyName + '\' on an undefined object.', obj && typeof obj === 'object' || typeof obj === 'function');
+    true && !(typeof keyName === 'string') && emberDebug.assert('The key provided to set must be a string, you passed ' + keyName, typeof keyName === 'string');
+    true && !!hasThis(keyName) && emberDebug.assert('\'this\' in paths is not supported', !hasThis(keyName));
+    true && !!obj.isDestroyed && emberDebug.assert('calling set on destroyed object: ' + emberUtils.toString(obj) + '.' + keyName + ' = ' + emberUtils.toString(value), !obj.isDestroyed);
 
     if (isPath(keyName)) {
       return setPath(obj, keyName, value, tolerant);
@@ -9745,7 +9751,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       desc.set(obj, keyName, value);
     } else if (obj.setUnknownProperty && currentValue === undefined && !(keyName in obj)) {
       /* unknown property */
-      true && emberDebug.assert('setUnknownProperty must be a function', typeof obj.setUnknownProperty === 'function');
+      true && !(typeof obj.setUnknownProperty === 'function') && emberDebug.assert('setUnknownProperty must be a function', typeof obj.setUnknownProperty === 'function');
 
       obj.setUnknownProperty(keyName, value);
     } else if (currentValue === value) {
@@ -9866,66 +9872,37 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     expansion, and is passed the expansion.
   */
   function expandProperties(pattern, callback) {
-    true && emberDebug.assert('A computed property key must be a string, you passed ' + typeof pattern + ' ' + pattern, typeof pattern === 'string');
-    true && emberDebug.assert('Brace expanded properties cannot contain spaces, e.g. "user.{firstName, lastName}" should be "user.{firstName,lastName}"', pattern.indexOf(' ') === -1);
+    true && !(typeof pattern === 'string') && emberDebug.assert('A computed property key must be a string, you passed ' + typeof pattern + ' ' + pattern, typeof pattern === 'string');
+    true && !(pattern.indexOf(' ') === -1) && emberDebug.assert('Brace expanded properties cannot contain spaces, e.g. "user.{firstName, lastName}" should be "user.{firstName,lastName}"', pattern.indexOf(' ') === -1);
+    // regex to look for double open, double close, or unclosed braces
 
-    var unbalancedNestedError = 'Brace expanded properties have to be balanced and cannot be nested, pattern: ' + pattern,
-        i,
-        current,
-        expansion,
-        j,
-        property,
-        k,
-        _i;
-    var properties = [pattern];
-
-    // Iterating backward over the pattern makes dealing with indices easier.
-    var bookmark = void 0;
-    var inside = false;
-    for (i = pattern.length; i > 0; --i) {
-      current = pattern[i - 1];
-
-
-      switch (current) {
-        // Closing curly brace will be the first character of the brace expansion we encounter.
-        // Bookmark its index so long as we're not already inside a brace expansion.
-        case '}':
-          if (!inside) {
-            bookmark = i - 1;
-            inside = true;
-          } else {
-            true && emberDebug.assert(unbalancedNestedError, false);
-          }
-          break;
-        // Opening curly brace will be the last character of the brace expansion we encounter.
-        // Apply the brace expansion so long as we've already seen a closing curly brace.
-        case '{':
-          if (inside) {
-            expansion = pattern.slice(i, bookmark).split(',');
-            // Iterating backward allows us to push new properties w/out affecting our "cursor".
-
-            for (j = properties.length; j > 0; --j) {
-              // Extract the unexpanded property from the array.
-              property = properties.splice(j - 1, 1)[0];
-              // Iterate over the expansion, pushing the newly formed properties onto the array.
-
-              for (k = 0; k < expansion.length; ++k) {
-                properties.push(property.slice(0, i - 1) + expansion[k] + property.slice(bookmark + 1));
-              }
-            }
-            inside = false;
-          } else {
-            true && emberDebug.assert(unbalancedNestedError, false);
-          }
-          break;
-      }
-    }
-    if (inside) {
-      true && emberDebug.assert(unbalancedNestedError, false);
+    true && !(pattern.match(/\{[^}{]*\{|\}[^}{]*\}|\{[^}]*$/g) === null) && emberDebug.assert('Brace expanded properties have to be balanced and cannot be nested, pattern: ' + pattern, pattern.match(/\{[^}{]*\{|\}[^}{]*\}|\{[^}]*$/g) === null);
+
+    var start = pattern.indexOf('{');
+    if (start < 0) {
+      callback(pattern.replace(END_WITH_EACH_REGEX, '.[]'));
+    } else {
+      dive('', pattern, start, callback);
     }
+  }
 
-    for (_i = 0; _i < properties.length; _i++) {
-      callback(properties[_i].replace(END_WITH_EACH_REGEX, '.[]'));
+  function dive(prefix, pattern, start, callback) {
+    var end = pattern.indexOf('}'),
+        i = 0,
+        newStart = void 0,
+        arrayLength = void 0;
+    var tempArr = pattern.substring(start + 1, end).split(',');
+    var after = pattern.substring(end + 1);
+    prefix = prefix + pattern.substring(0, start);
+
+    arrayLength = tempArr.length;
+    while (i < arrayLength) {
+      newStart = after.indexOf('{');
+      if (newStart < 0) {
+        callback((prefix + tempArr[i++] + after).replace(END_WITH_EACH_REGEX, '.[]'));
+      } else {
+        dive(prefix + tempArr[i++], after, newStart, callback);
+      }
     }
   }
 
@@ -10138,8 +10115,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     if (typeof config === 'function') {
       this._getter = config;
     } else {
-      true && emberDebug.assert('Ember.computed expects a function or an object as last argument.', typeof config === 'object' && !Array.isArray(config));
-      true && emberDebug.assert('Config object passed to an Ember.computed can only contain `get` or `set` keys.', function () {
+      true && !(typeof config === 'object' && !Array.isArray(config)) && emberDebug.assert('Ember.computed expects a function or an object as last argument.', typeof config === 'object' && !Array.isArray(config));
+      true && !function () {
         var keys = Object.keys(config),
             i;
         for (i = 0; i < keys.length; i++) {
@@ -10148,12 +10125,19 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
           }
         }
         return true;
+      }() && emberDebug.assert('Config object passed to an Ember.computed can only contain `get` or `set` keys.', function () {
+        var keys = Object.keys(config),
+            i;for (i = 0; i < keys.length; i++) {
+          if (keys[i] !== 'get' && keys[i] !== 'set') {
+            return false;
+          }
+        }return true;
       }());
 
       this._getter = config.get;
       this._setter = config.set;
     }
-    true && emberDebug.assert('Computed properties must receive a getter or a setter, you passed none.', !!this._getter || !!this._setter);
+    true && !(!!this._getter || !!this._setter) && emberDebug.assert('Computed properties must receive a getter or a setter, you passed none.', !!this._getter || !!this._setter);
 
     this._dependentKeys = undefined;
     this._suspended = undefined;
@@ -10219,7 +10203,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   */
   ComputedPropertyPrototype.readOnly = function () {
     this._readOnly = true;
-    true && emberDebug.assert('Computed properties that define a setter using the new syntax cannot be read-only', !(this._readOnly && this._setter && this._setter !== this._getter));
+    true && !!(this._readOnly && this._setter && this._setter !== this._getter) && emberDebug.assert('Computed properties that define a setter using the new syntax cannot be read-only', !(this._readOnly && this._setter && this._setter !== this._getter));
 
     return this;
   };
@@ -10600,7 +10584,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     }
 
     AliasedProperty.prototype.setup = function (obj, keyName) {
-      true && emberDebug.assert('Setting alias \'' + keyName + '\' on self', this.altKey !== keyName);
+      true && !(this.altKey !== keyName) && emberDebug.assert('Setting alias \'' + keyName + '\' on self', this.altKey !== keyName);
 
       var meta$$1 = meta(obj);
       if (meta$$1.peekWatching(keyName)) {
@@ -11506,7 +11490,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     @public
   */
   run$1.schedule = function () /* queue, target, method */{
-    true && emberDebug.assert('You have turned on testing mode, which disabled the run-loop\'s autorun. ' + 'You will need to wrap any code with asynchronous side-effects in a run', run$1.currentRunLoop || !emberDebug.isTesting());
+    true && !(run$1.currentRunLoop || !emberDebug.isTesting()) && emberDebug.assert('You have turned on testing mode, which disabled the run-loop\'s autorun. ' + 'You will need to wrap any code with asynchronous side-effects in a run', run$1.currentRunLoop || !emberDebug.isTesting());
 
     return backburner.schedule.apply(backburner, arguments);
   };
@@ -11590,7 +11574,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   run$1.once = function () {
     var _len3, args, _key3;
 
-    true && emberDebug.assert('You have turned on testing mode, which disabled the run-loop\'s autorun. ' + 'You will need to wrap any code with asynchronous side-effects in a run', run$1.currentRunLoop || !emberDebug.isTesting());
+    true && !(run$1.currentRunLoop || !emberDebug.isTesting()) && emberDebug.assert('You have turned on testing mode, which disabled the run-loop\'s autorun. ' + 'You will need to wrap any code with asynchronous side-effects in a run', run$1.currentRunLoop || !emberDebug.isTesting());
 
     for (_len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
       args[_key3] = arguments[_key3];
@@ -11653,7 +11637,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     @public
   */
   run$1.scheduleOnce = function () /*queue, target, method*/{
-    true && emberDebug.assert('You have turned on testing mode, which disabled the run-loop\'s autorun. ' + 'You will need to wrap any code with asynchronous side-effects in a run', run$1.currentRunLoop || !emberDebug.isTesting());
+    true && !(run$1.currentRunLoop || !emberDebug.isTesting()) && emberDebug.assert('You have turned on testing mode, which disabled the run-loop\'s autorun. ' + 'You will need to wrap any code with asynchronous side-effects in a run', run$1.currentRunLoop || !emberDebug.isTesting());
 
     return backburner.scheduleOnce.apply(backburner, arguments);
   };
@@ -12743,7 +12727,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     */
 
     Binding.prototype.connect = function (obj) {
-      true && emberDebug.assert('Must pass a valid object to Ember.Binding.connect()', !!obj);
+      true && !!!obj && emberDebug.assert('Must pass a valid object to Ember.Binding.connect()', !!obj);
 
       var fromObj = void 0,
           fromPath = void 0,
@@ -12799,7 +12783,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     */
 
     Binding.prototype.disconnect = function () {
-      true && emberDebug.assert('Must pass a valid object to Ember.Binding.disconnect()', !!this._toObj);
+      true && !!!this._toObj && emberDebug.assert('Must pass a valid object to Ember.Binding.disconnect()', !!this._toObj);
 
       // Remove an observer on the object so we're no longer notified of
       // changes that should update bindings.
@@ -13231,7 +13215,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     {
       if (isArray(value)) {
         // use conditional to avoid stringifying every time
-        true && emberDebug.assert('You passed in `' + JSON.stringify(value) + '` as the value for `' + key + '` but `' + key + '` cannot be an Array', false);
+        true && !false && emberDebug.assert('You passed in `' + JSON.stringify(value) + '` as the value for `' + key + '` but `' + key + '` cannot be an Array', false);
       }
     }
 
@@ -13308,7 +13292,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
     for (i = 0; i < mixins.length; i++) {
       currentMixin = mixins[i];
-      true && emberDebug.assert('Expected hash or Mixin instance, got ' + Object.prototype.toString.call(currentMixin), typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]');
+      true && !(typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]') && emberDebug.assert('Expected hash or Mixin instance, got ' + Object.prototype.toString.call(currentMixin), typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]');
 
       props = mixinProperties(meta$$1, currentMixin);
       if (props === CONTINUE) {
@@ -13679,7 +13663,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
     for (idx = 0; idx < arguments.length; idx++) {
       currentMixin = arguments[idx];
-      true && emberDebug.assert('Expected hash or Mixin instance, got ' + Object.prototype.toString.call(currentMixin), typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]');
+      true && !(typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]') && emberDebug.assert('Expected hash or Mixin instance, got ' + Object.prototype.toString.call(currentMixin), typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]');
 
       if (currentMixin instanceof Mixin) {
         mixins.push(currentMixin);
@@ -13973,8 +13957,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     var desc = this[keyName];
     var owner = emberUtils.getOwner(this) || this.container; // fallback to `container` for backwards compat
 
-    true && emberDebug.assert('InjectedProperties should be defined with the Ember.inject computed property macros.', desc && desc.isDescriptor && desc.type);
-    true && emberDebug.assert('Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container.', owner);
+    true && !(desc && desc.isDescriptor && desc.type) && emberDebug.assert('InjectedProperties should be defined with the Ember.inject computed property macros.', desc && desc.isDescriptor && desc.type);
+    true && !owner && emberDebug.assert('Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container.', owner);
 
     return owner.lookup(desc.type + ':' + (desc.name || keyName));
   }
@@ -14304,7 +14288,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     for (i = 0; i < arguments.length; i++) {
       arg = arguments[i];
 
-      true && emberDebug.assert('Immediate observers must observe internal properties only, not properties on other objects.', typeof arg !== 'string' || arg.indexOf('.') === -1);
+      true && !(typeof arg !== 'string' || arg.indexOf('.') === -1) && emberDebug.assert('Immediate observers must observe internal properties only, not properties on other objects.', typeof arg !== 'string' || arg.indexOf('.') === -1);
     }
 
     return observer.apply(this, arguments);
@@ -14517,7 +14501,7 @@ enifed('ember-template-compiler/plugins/assert-reserved-named-arguments', ['expo
     this.syntax.traverse(ast, {
       PathExpression: function (node) {
         if (node.original[0] === '@') {
-          true && (0, _emberDebug.assert)(assertMessage(moduleName, node));
+          true && !false && (0, _emberDebug.assert)(assertMessage(moduleName, node));
         }
       }
     });
@@ -15410,7 +15394,7 @@ enifed('ember-template-compiler/plugins/transform-old-binding-syntax', ['exports
           return;
         }
 
-        true && (0, _emberDebug.assert)('Setting \'attributeBindings\' via template helpers is not allowed ' + sourceInformation, key !== 'attributeBindings');
+        true && !(key !== 'attributeBindings') && (0, _emberDebug.assert)('Setting \'attributeBindings\' via template helpers is not allowed ' + sourceInformation, key !== 'attributeBindings');
 
         if (key.substr(-7) === 'Binding') {
           newKey = key.slice(0, -7);
@@ -16662,7 +16646,7 @@ enifed('ember/features', ['exports', 'ember-environment', 'ember-utils'], functi
 enifed("ember/version", ["exports"], function (exports) {
   "use strict";
 
-  exports.default = "2.14.0-beta.2";
+  exports.default = "2.14.0-beta.3";
 });
 enifed("handlebars", ["exports"], function (exports) {
   "use strict";