From 14fa2cc70b6b36711f07cc2e8fbfc34df873cfdb Mon Sep 17 00:00:00 2001
From: Damien White <damien.white@visoftinc.com>
Date: Mon, 6 Apr 2015 07:54:55 -0400
Subject: [PATCH 1/2] Changed helper to work with both Ember 1.10 and 1.11

---
 lib/helper.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/helper.js b/lib/helper.js
index 07f2fb9..6966aae 100644
--- a/lib/helper.js
+++ b/lib/helper.js
@@ -1,5 +1,5 @@
 Ember.Handlebars.registerHelper('flashMessage', function(options) {
-  var container = this._keywords.view.container,
+  var container = options.data.view.container,
       controller = container.lookup('controller:flashMessage'),
 
       parent = Ember.ContainerView.extend({

From 2a9ef5d52dc402d005780765e535d70b68ac77dd Mon Sep 17 00:00:00 2001
From: Damien White <damien.white@visoftinc.com>
Date: Mon, 6 Apr 2015 07:56:35 -0400
Subject: [PATCH 2/2] Upgraded to Ember 1.11 with fix from
 https://github.com/emberjs/ember.js/issues/10310

---
 vendor/js/ember-template-compiler.js |  1549 +-
 vendor/js/ember.js                   | 72233 ++++++++++++-------------
 2 files changed, 35201 insertions(+), 38581 deletions(-)

diff --git a/vendor/js/ember-template-compiler.js b/vendor/js/ember-template-compiler.js
index d593bd0..f74036b 100644
--- a/vendor/js/ember-template-compiler.js
+++ b/vendor/js/ember-template-compiler.js
@@ -1,29 +1,42 @@
 /*!
  * @overview  Ember - JavaScript Application Framework
- * @copyright Copyright 2011-2014 Tilde Inc. and contributors
+ * @copyright Copyright 2011-2015 Tilde Inc. and contributors
  *            Portions Copyright 2006-2011 Strobe Inc.
  *            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   1.10.0
+ * @version   1.11.0
  */
 
 (function() {
-var define, requireModule, require, requirejs, Ember;
+var enifed, requireModule, eriuqer, requirejs, Ember;
+var mainContext = this;
 
 (function() {
+
   Ember = this.Ember = this.Ember || {};
   if (typeof Ember === 'undefined') { Ember = {}; };
   function UNDEFINED() { }
 
   if (typeof Ember.__loader === 'undefined') {
-    var registry = {}, seen = {};
+    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;
+      }
 
-    define = function(name, deps, callback) {
-      registry[name] = { deps: deps, callback: callback };
+        registry[name] = value;
     };
 
-    requirejs = require = requireModule = function(name) {
+    requirejs = eriuqer = requireModule = function(name) {
       var s = seen[name];
 
       if (s !== undefined) { return seen[name]; }
@@ -65,9 +78,13 @@ var define, requireModule, require, requirejs, Ember;
       for (var i=0, l=parts.length; i<l; i++) {
         var part = parts[i];
 
-        if (part === '..') { parentBase.pop(); }
-        else if (part === '.') { continue; }
-        else { parentBase.push(part); }
+        if (part === '..') {
+          parentBase.pop();
+        } else if (part === '.') {
+          continue;
+        } else {
+          parentBase.push(part);
+        }
       }
 
       return parentBase.join('/');
@@ -76,609 +93,590 @@ var define, requireModule, require, requirejs, Ember;
     requirejs._eak_seen = registry;
 
     Ember.__loader = {
-      define: define,
-      require: require,
+      define: enifed,
+      require: eriuqer,
       registry: registry
     };
   } else {
-    define = Ember.__loader.define;
-    requirejs = require = requireModule = Ember.__loader.require;
+    enifed = Ember.__loader.define;
+    requirejs = eriuqer = requireModule = Ember.__loader.require;
   }
 })();
 
-define("ember-metal/core",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /*globals Ember:true,ENV,EmberENV,MetamorphENV:true */
+enifed('ember-metal/core', ['exports'], function (exports) {
 
-    /**
-    @module ember
-    @submodule ember-metal
-    */
+  'use strict';
 
-    /**
-      All Ember methods and functions are defined inside of this namespace. You
-      generally should not add new properties to this namespace as it may be
-      overwritten by future versions of Ember.
+  exports.K = K;
 
-      You can also use the shorthand `Em` instead of `Ember`.
+  /*globals Ember:true,ENV,EmberENV */
 
-      Ember-Runtime is a framework that provides core functions for Ember including
-      cross-platform functions, support for property observing and objects. Its
-      focus is on small size and performance. You can use this in place of or
-      along-side other cross-platform libraries such as jQuery.
+  /**
+  @module ember
+  @submodule ember-metal
+  */
 
-      The core Runtime framework is based on the jQuery API with a number of
-      performance optimizations.
+  /**
+    All Ember methods and functions are defined inside of this namespace. You
+    generally should not add new properties to this namespace as it may be
+    overwritten by future versions of Ember.
 
-      @class Ember
-      @static
-      @version 1.10.0
-    */
+    You can also use the shorthand `Em` instead of `Ember`.
 
-    if ('undefined' === typeof Ember) {
-      // Create core object. Make it act like an instance of Ember.Namespace so that
-      // objects assigned to it are given a sane string representation.
-      Ember = {};
-    }
+    Ember-Runtime is a framework that provides core functions for Ember including
+    cross-platform functions, support for property observing and objects. Its
+    focus is on small size and performance. You can use this in place of or
+    along-side other cross-platform libraries such as jQuery.
 
-    // Default imports, exports and lookup to the global object;
-    Ember.imports = Ember.imports || this;
-    Ember.lookup  = Ember.lookup  || this;
-    var exports   = Ember.exports = Ember.exports || this;
+    The core Runtime framework is based on the jQuery API with a number of
+    performance optimizations.
 
-    // aliases needed to keep minifiers from removing the global context
-    exports.Em = exports.Ember = Ember;
+    @class Ember
+    @static
+    @version 1.11.0
+  */
 
-    // Make sure these are set whether Ember was already defined or not
+  if ('undefined' === typeof Ember) {
+    // Create core object. Make it act like an instance of Ember.Namespace so that
+    // objects assigned to it are given a sane string representation.
+    Ember = {};
+  }
 
-    Ember.isNamespace = true;
+  // Default imports, exports and lookup to the global object;
+  var global = mainContext || {}; // jshint ignore:line
+  Ember.imports = Ember.imports || global;
+  Ember.lookup  = Ember.lookup  || global;
+  var emExports   = Ember.exports = Ember.exports || global;
 
-    Ember.toString = function() { return "Ember"; };
+  // aliases needed to keep minifiers from removing the global context
+  emExports.Em = emExports.Ember = Ember;
 
+  // Make sure these are set whether Ember was already defined or not
 
-    /**
-      @property VERSION
-      @type String
-      @default '1.10.0'
-      @static
-    */
-    Ember.VERSION = '1.10.0';
+  Ember.isNamespace = true;
 
-    /**
-      Standard environmental variables. You can define these in a global `EmberENV`
-      variable before loading Ember to control various configuration settings.
-
-      For backwards compatibility with earlier versions of Ember the global `ENV`
-      variable will be used if `EmberENV` is not defined.
-
-      @property ENV
-      @type Hash
-    */
-
-    if (Ember.ENV) {
-      // do nothing if Ember.ENV is already setup
-    } else if ('undefined' !== typeof EmberENV) {
-      Ember.ENV = EmberENV;
-    } else if('undefined' !== typeof ENV) {
-      Ember.ENV = ENV;
+  Ember.toString = function() { return "Ember"; };
+
+
+  /**
+    @property VERSION
+    @type String
+    @default '1.11.0'
+    @static
+  */
+  Ember.VERSION = '1.11.0';
+
+  /**
+    Standard environmental variables. You can define these in a global `EmberENV`
+    variable before loading Ember to control various configuration settings.
+
+    For backwards compatibility with earlier versions of Ember the global `ENV`
+    variable will be used if `EmberENV` is not defined.
+
+    @property ENV
+    @type Hash
+  */
+
+  if (Ember.ENV) {
+    // do nothing if Ember.ENV is already setup
+    Ember.assert('Ember.ENV should be an object.', 'object' !== typeof Ember.ENV);
+  } else if ('undefined' !== typeof EmberENV) {
+    Ember.ENV = EmberENV;
+  } else if ('undefined' !== typeof ENV) {
+    Ember.ENV = ENV;
+  } else {
+    Ember.ENV = {};
+  }
+
+  Ember.config = Ember.config || {};
+
+  // We disable the RANGE API by default for performance reasons
+  if ('undefined' === typeof Ember.ENV.DISABLE_RANGE_API) {
+    Ember.ENV.DISABLE_RANGE_API = true;
+  }
+
+  /**
+    Hash of enabled Canary features. Add to this before creating your application.
+
+    You can also define `EmberENV.FEATURES` if you need to enable features flagged at runtime.
+
+    @class FEATURES
+    @namespace Ember
+    @static
+    @since 1.1.0
+  */
+
+  Ember.FEATURES = Ember.ENV.FEATURES;
+
+  if (!Ember.FEATURES) {
+    Ember.FEATURES = {"features-stripped-test":false,"ember-routing-named-substates":true,"mandatory-setter":true,"ember-htmlbars-component-generation":false,"ember-htmlbars-component-helper":true,"ember-htmlbars-inline-if-helper":true,"ember-htmlbars-attribute-syntax":true,"ember-routing-transitioning-classes":true,"new-computed-syntax":false,"ember-testing-checkbox-helpers":false,"ember-metal-stream":false,"ember-htmlbars-each-with-index":true,"ember-application-instance-initializers":false,"ember-application-initializer-context":false,"ember-router-willtransition":true,"ember-application-visit":false}; //jshint ignore:line
+  }
+
+  /**
+    Test that a feature is enabled. Parsed by Ember's build tools to leave
+    experimental features out of beta/stable builds.
+
+    You can define the following configuration options:
+
+    * `EmberENV.ENABLE_ALL_FEATURES` - force all features to be enabled.
+    * `EmberENV.ENABLE_OPTIONAL_FEATURES` - enable any features that have not been explicitly
+      enabled/disabled.
+
+    @method isEnabled
+    @param {String} feature
+    @return {Boolean}
+    @for Ember.FEATURES
+    @since 1.1.0
+  */
+
+  Ember.FEATURES.isEnabled = function(feature) {
+    var featureValue = Ember.FEATURES[feature];
+
+    if (Ember.ENV.ENABLE_ALL_FEATURES) {
+      return true;
+    } else if (featureValue === true || featureValue === false || featureValue === undefined) {
+      return featureValue;
+    } else if (Ember.ENV.ENABLE_OPTIONAL_FEATURES) {
+      return true;
     } else {
-      Ember.ENV = {};
+      return false;
     }
+  };
 
-    Ember.config = Ember.config || {};
+  // ..........................................................
+  // BOOTSTRAP
+  //
 
-    // We disable the RANGE API by default for performance reasons
-    if ('undefined' === typeof Ember.ENV.DISABLE_RANGE_API) {
-      Ember.ENV.DISABLE_RANGE_API = true;
-    }
+  /**
+    Determines whether Ember should enhance some built-in object prototypes to
+    provide a more friendly API. If enabled, a few methods will be added to
+    `Function`, `String`, and `Array`. `Object.prototype` will not be enhanced,
+    which is the one that causes most trouble for people.
 
-    if ("undefined" === typeof MetamorphENV) {
-      exports.MetamorphENV = {};
-    }
+    In general we recommend leaving this option set to true since it rarely
+    conflicts with other code. If you need to turn it off however, you can
+    define an `EmberENV.EXTEND_PROTOTYPES` config to disable it.
 
-    MetamorphENV.DISABLE_RANGE_API = Ember.ENV.DISABLE_RANGE_API;
+    @property EXTEND_PROTOTYPES
+    @type Boolean
+    @default true
+    @for Ember
+  */
+  Ember.EXTEND_PROTOTYPES = Ember.ENV.EXTEND_PROTOTYPES;
 
-    /**
-      Hash of enabled Canary features. Add to this before creating your application.
+  if (typeof Ember.EXTEND_PROTOTYPES === 'undefined') {
+    Ember.EXTEND_PROTOTYPES = true;
+  }
 
-      You can also define `EmberENV.FEATURES` if you need to enable features flagged at runtime.
+  /**
+    Determines whether Ember logs a full stack trace during deprecation warnings
+
+    @property LOG_STACKTRACE_ON_DEPRECATION
+    @type Boolean
+    @default true
+  */
+  Ember.LOG_STACKTRACE_ON_DEPRECATION = (Ember.ENV.LOG_STACKTRACE_ON_DEPRECATION !== false);
+
+  /**
+    Determines whether Ember should add ECMAScript 5 Array shims to older browsers.
+
+    @property SHIM_ES5
+    @type Boolean
+    @default Ember.EXTEND_PROTOTYPES
+  */
+  Ember.SHIM_ES5 = (Ember.ENV.SHIM_ES5 === false) ? false : Ember.EXTEND_PROTOTYPES;
+
+  /**
+    Determines whether Ember logs info about version of used libraries
+
+    @property LOG_VERSION
+    @type Boolean
+    @default true
+  */
+  Ember.LOG_VERSION = (Ember.ENV.LOG_VERSION === false) ? false : true;
+
+  /**
+    Empty function. Useful for some operations. Always returns `this`.
+
+    @method K
+    @private
+    @return {Object}
+  */
+  function K() { return this; }
+  Ember.K = K;
+  //TODO: ES6 GLOBAL TODO
+
+  // Stub out the methods defined by the ember-debug package in case it's not loaded
+
+  if ('undefined' === typeof Ember.assert) { Ember.assert = K; }
+  if ('undefined' === typeof Ember.warn) { Ember.warn = K; }
+  if ('undefined' === typeof Ember.debug) { Ember.debug = K; }
+  if ('undefined' === typeof Ember.runInDebug) { Ember.runInDebug = K; }
+  if ('undefined' === typeof Ember.deprecate) { Ember.deprecate = K; }
+  if ('undefined' === typeof Ember.deprecateFunc) {
+    Ember.deprecateFunc = function(_, func) { return func; };
+  }
 
-      @class FEATURES
-      @namespace Ember
-      @static
-      @since 1.1.0
-    */
+  exports['default'] = Ember;
 
-    Ember.FEATURES = Ember.ENV.FEATURES || {};
+});
+enifed('ember-template-compiler', ['exports', 'ember-metal/core', 'ember-template-compiler/system/precompile', 'ember-template-compiler/system/compile', 'ember-template-compiler/system/template', 'ember-template-compiler/plugins', 'ember-template-compiler/plugins/transform-each-in-to-hash', 'ember-template-compiler/plugins/transform-with-as-to-hash', 'ember-template-compiler/compat'], function (exports, _Ember, precompile, compile, template, plugins, TransformEachInToHash, TransformWithAsToHash) {
 
-    /**
-      Test that a feature is enabled. Parsed by Ember's build tools to leave
-      experimental features out of beta/stable builds.
+  'use strict';
 
-      You can define the following configuration options:
+  plugins.registerPlugin('ast', TransformWithAsToHash['default']);
+  plugins.registerPlugin('ast', TransformEachInToHash['default']);
 
-      * `EmberENV.ENABLE_ALL_FEATURES` - force all features to be enabled.
-      * `EmberENV.ENABLE_OPTIONAL_FEATURES` - enable any features that have not been explicitly
-        enabled/disabled.
+  exports._Ember = _Ember['default'];
+  exports.precompile = precompile['default'];
+  exports.compile = compile['default'];
+  exports.template = template['default'];
+  exports.registerPlugin = plugins.registerPlugin;
 
-      @method isEnabled
-      @param {String} feature
-      @return {Boolean}
-      @for Ember.FEATURES
-      @since 1.1.0
-    */
+});
+enifed('ember-template-compiler/compat', ['ember-metal/core', 'ember-template-compiler/compat/precompile', 'ember-template-compiler/system/compile', 'ember-template-compiler/system/template'], function (Ember, precompile, compile, template) {
 
-    Ember.FEATURES.isEnabled = function(feature) {
-      var featureValue = Ember.FEATURES[feature];
+	'use strict';
 
-      if (Ember.ENV.ENABLE_ALL_FEATURES) {
-        return true;
-      } else if (featureValue === true || featureValue === false || featureValue === undefined) {
-        return featureValue;
-      } else if (Ember.ENV.ENABLE_OPTIONAL_FEATURES) {
-        return true;
-      } else {
-        return false;
-      }
-    };
+	var EmberHandlebars = Ember['default'].Handlebars = Ember['default'].Handlebars || {};
 
-    // ..........................................................
-    // BOOTSTRAP
-    //
+	EmberHandlebars.precompile = precompile['default'];
+	EmberHandlebars.compile = compile['default'];
+	EmberHandlebars.template = template['default'];
 
-    /**
-      Determines whether Ember should enhance some built-in object prototypes to
-      provide a more friendly API. If enabled, a few methods will be added to
-      `Function`, `String`, and `Array`. `Object.prototype` will not be enhanced,
-      which is the one that causes most trouble for people.
+});
+enifed('ember-template-compiler/compat/precompile', ['exports', 'ember-template-compiler/system/compile_options'], function (exports, compileOptions) {
 
-      In general we recommend leaving this option set to true since it rarely
-      conflicts with other code. If you need to turn it off however, you can
-      define an `EmberENV.EXTEND_PROTOTYPES` config to disable it.
+  'use strict';
 
-      @property EXTEND_PROTOTYPES
-      @type Boolean
-      @default true
-      @for Ember
-    */
-    Ember.EXTEND_PROTOTYPES = Ember.ENV.EXTEND_PROTOTYPES;
+  /**
+  @module ember
+  @submodule ember-template-compiler
+  */
+  var compile, compileSpec;
 
-    if (typeof Ember.EXTEND_PROTOTYPES === 'undefined') {
-      Ember.EXTEND_PROTOTYPES = true;
+  exports['default'] = function(string) {
+    if ((!compile || !compileSpec) && Ember.__loader.registry['htmlbars-compiler/compiler']) {
+      var Compiler = requireModule('htmlbars-compiler/compiler');
+
+      compile = Compiler.compile;
+      compileSpec = Compiler.compileSpec;
     }
 
-    /**
-      Determines whether Ember logs a full stack trace during deprecation warnings
+    if (!compile || !compileSpec) {
+      throw new Error('Cannot call `precompile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `precompile`.');
+    }
 
-      @property LOG_STACKTRACE_ON_DEPRECATION
-      @type Boolean
-      @default true
-    */
-    Ember.LOG_STACKTRACE_ON_DEPRECATION = (Ember.ENV.LOG_STACKTRACE_ON_DEPRECATION !== false);
+    var asObject = arguments[1] === undefined ? true : arguments[1];
+    var compileFunc = asObject ? compile : compileSpec;
 
-    /**
-      Determines whether Ember should add ECMAScript 5 Array shims to older browsers.
+    return compileFunc(string, compileOptions['default']());
+  }
 
-      @property SHIM_ES5
-      @type Boolean
-      @default Ember.EXTEND_PROTOTYPES
-    */
-    Ember.SHIM_ES5 = (Ember.ENV.SHIM_ES5 === false) ? false : Ember.EXTEND_PROTOTYPES;
+});
+enifed('ember-template-compiler/plugins', ['exports'], function (exports) {
 
-    /**
-      Determines whether Ember logs info about version of used libraries
+  'use strict';
 
-      @property LOG_VERSION
-      @type Boolean
-      @default true
-    */
-    Ember.LOG_VERSION = (Ember.ENV.LOG_VERSION === false) ? false : true;
+  exports.registerPlugin = registerPlugin;
 
-    /**
-      Empty function. Useful for some operations. Always returns `this`.
+  /**
+  @module ember
+  @submodule ember-template-compiler
+  */
 
-      @method K
-      @private
-      @return {Object}
-    */
-    function K() { return this; }
-    __exports__.K = K;
-    Ember.K = K;
-    //TODO: ES6 GLOBAL TODO
+  /**
+   @private
+   @property helpers
+  */
+  var plugins = {
+    ast: []
+  };
 
-    // Stub out the methods defined by the ember-debug package in case it's not loaded
+  /**
+    Adds an AST plugin to be used by Ember.HTMLBars.compile.
 
-    if ('undefined' === typeof Ember.assert) { Ember.assert = K; }
-    if ('undefined' === typeof Ember.warn) { Ember.warn = K; }
-    if ('undefined' === typeof Ember.debug) { Ember.debug = K; }
-    if ('undefined' === typeof Ember.runInDebug) { Ember.runInDebug = K; }
-    if ('undefined' === typeof Ember.deprecate) { Ember.deprecate = K; }
-    if ('undefined' === typeof Ember.deprecateFunc) {
-      Ember.deprecateFunc = function(_, func) { return func; };
+    @private
+    @method registerASTPlugin
+  */
+  function registerPlugin(type, Plugin) {
+    if (!plugins[type]) {
+      throw new Error('Attempting to register "' + Plugin + '" as "' + type + '" which is not a valid HTMLBars plugin type.');
     }
 
-    __exports__["default"] = Ember;
-  });
-define("ember-template-compiler",
-  ["ember-metal/core","ember-template-compiler/system/precompile","ember-template-compiler/system/compile","ember-template-compiler/system/template","ember-template-compiler/plugins","ember-template-compiler/plugins/transform-each-in-to-hash","ember-template-compiler/plugins/transform-with-as-to-hash","ember-template-compiler/compat","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
-    "use strict";
-    var _Ember = __dependency1__["default"];
-    var precompile = __dependency2__["default"];
-    var compile = __dependency3__["default"];
-    var template = __dependency4__["default"];
-    var registerPlugin = __dependency5__.registerPlugin;
-
-    var TransformEachInToHash = __dependency6__["default"];
-    var TransformWithAsToHash = __dependency7__["default"];
+    plugins[type].push(Plugin);
+  }
 
-    // used for adding Ember.Handlebars.compile for backwards compat
+  exports['default'] = plugins;
 
-    registerPlugin('ast', TransformWithAsToHash);
-    registerPlugin('ast', TransformEachInToHash);
+});
+enifed('ember-template-compiler/plugins/transform-each-in-to-hash', ['exports'], function (exports) {
 
-    __exports__._Ember = _Ember;
-    __exports__.precompile = precompile;
-    __exports__.compile = compile;
-    __exports__.template = template;
-    __exports__.registerPlugin = registerPlugin;
-  });
-define("ember-template-compiler/compat",
-  ["ember-metal/core","ember-template-compiler/compat/precompile","ember-template-compiler/system/compile","ember-template-compiler/system/template"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var precompile = __dependency2__["default"];
-    var compile = __dependency3__["default"];
-    var template = __dependency4__["default"];
+  'use strict';
 
-    var EmberHandlebars = Ember.Handlebars = Ember.Handlebars || {};
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-    EmberHandlebars.precompile = precompile;
-    EmberHandlebars.compile = compile;
-    EmberHandlebars.template = template;
-  });
-define("ember-template-compiler/compat/precompile",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-template-compiler
-    */
 
-    var compile, compileSpec;
+  /**
+    An HTMLBars AST transformation that replaces all instances of
 
-    __exports__["default"] = function(string) {
-      if ((!compile || !compileSpec) && Ember.__loader.registry['htmlbars-compiler/compiler']) {
-        var Compiler = requireModule('htmlbars-compiler/compiler');
+    ```handlebars
+    {{#each item in items}}
+    {{/each}}
+    ```
 
-        compile = Compiler.compile;
-        compileSpec = Compiler.compileSpec;
-      }
+    with
 
-      if (!compile || !compileSpec) {
-        throw new Error('Cannot call `precompile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `precompile`.');
-      }
+    ```handlebars
+    {{#each items keyword="item"}}
+    {{/each}}
+    ```
 
-      var asObject = arguments[1] === undefined ? true : arguments[1];
-      var compileFunc = asObject ? compile : compileSpec;
+    @class TransformEachInToHash
+    @private
+  */
+  function TransformEachInToHash() {
+    // set later within HTMLBars to the syntax package
+    this.syntax = null;
+  }
 
-      return compileFunc(string);
-    }
-  });
-define("ember-template-compiler/plugins",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-template-compiler
-    */
+  /**
+    @private
+    @method transform
+    @param {AST} The AST to be transformed.
+  */
+  TransformEachInToHash.prototype.transform = function TransformEachInToHash_transform(ast) {
+    var pluginContext = this;
+    var walker = new pluginContext.syntax.Walker();
+    var b = pluginContext.syntax.builders;
+
+    walker.visit(ast, function(node) {
+      if (pluginContext.validate(node)) {
+
+        if (node.program && node.program.blockParams.length) {
+          throw new Error('You cannot use keyword (`{{each foo in bar}}`) and block params (`{{each bar as |foo|}}`) at the same time.');
+        }
 
-    /**
-     @private
-     @property helpers
-    */
-    var plugins = {
-      ast: [ ]
-    };
+        var removedParams = node.sexpr.params.splice(0, 2);
+        var keyword = removedParams[0].original;
 
-    /**
-      Adds an AST plugin to be used by Ember.HTMLBars.compile.
+        // TODO: This may not be necessary.
+        if (!node.sexpr.hash) {
+          node.sexpr.hash = b.hash();
+        }
 
-      @private
-      @method registerASTPlugin
-    */
-    function registerPlugin(type, Plugin) {
-      if (!plugins[type]) {
-        throw new Error('Attempting to register "' + Plugin + '" as "' + type + '" which is not a valid HTMLBars plugin type.');
+        node.sexpr.hash.pairs.push(b.pair(
+          'keyword',
+          b.string(keyword)
+        ));
       }
+    });
 
-      plugins[type].push(Plugin);
-    }
+    return ast;
+  };
 
-    __exports__.registerPlugin = registerPlugin;__exports__["default"] = plugins;
-  });
-define("ember-template-compiler/plugins/transform-each-in-to-hash",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+  TransformEachInToHash.prototype.validate = function TransformEachInToHash_validate(node) {
+    return (node.type === 'BlockStatement' || node.type === 'MustacheStatement') &&
+      node.sexpr.path.original === 'each' &&
+      node.sexpr.params.length === 3 &&
+      node.sexpr.params[1].type === 'PathExpression' &&
+      node.sexpr.params[1].original === 'in';
+  };
 
+  exports['default'] = TransformEachInToHash;
 
-    /**
-      An HTMLBars AST transformation that replaces all instances of
+});
+enifed('ember-template-compiler/plugins/transform-with-as-to-hash', ['exports'], function (exports) {
 
-      ```handlebars
-      {{#each item in items}}
-      {{/each}}
-      ```
+  'use strict';
 
-      with
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-      ```handlebars
-      {{#each items keyword="item"}}
-      {{/each}}
-      ```
+  /**
+    An HTMLBars AST transformation that replaces all instances of
 
-      @class TransformEachInToHash
-      @private
-    */
-    function TransformEachInToHash() {
-      // set later within HTMLBars to the syntax package
-      this.syntax = null;
-    }
+    ```handlebars
+    {{#with foo.bar as bar}}
+    {{/with}}
+    ```
 
-    /**
-      @private
-      @method transform
-      @param {AST} The AST to be transformed.
-    */
-    TransformEachInToHash.prototype.transform = function TransformEachInToHash_transform(ast) {
-      var pluginContext = this;
-      var walker = new pluginContext.syntax.Walker();
-      var b = pluginContext.syntax.builders;
-
-      walker.visit(ast, function(node) {
-        if (pluginContext.validate(node)) {
-
-          if (node.program && node.program.blockParams.length) {
-            throw new Error('You cannot use keyword (`{{each foo in bar}}`) and block params (`{{each bar as |foo|}}`) at the same time.');
-          }
+    with
 
-          var removedParams = node.sexpr.params.splice(0, 2);
-          var keyword = removedParams[0].original;
+    ```handlebars
+    {{#with foo.bar as |bar|}}
+    {{/with}}
+    ```
 
-          // TODO: This may not be necessary.
-          if (!node.sexpr.hash) {
-            node.sexpr.hash = b.hash();
-          }
+    @private
+    @class TransformWithAsToHash
+  */
+  function TransformWithAsToHash() {
+    // set later within HTMLBars to the syntax package
+    this.syntax = null;
+  }
 
-          node.sexpr.hash.pairs.push(b.pair(
-            'keyword',
-            b.string(keyword)
-          ));
+  /**
+    @private
+    @method transform
+    @param {AST} The AST to be transformed.
+  */
+  TransformWithAsToHash.prototype.transform = function TransformWithAsToHash_transform(ast) {
+    var pluginContext = this;
+    var walker = new pluginContext.syntax.Walker();
+
+    walker.visit(ast, function(node) {
+      if (pluginContext.validate(node)) {
+
+        if (node.program && node.program.blockParams.length) {
+          throw new Error('You cannot use keyword (`{{with foo as bar}}`) and block params (`{{with foo as |bar|}}`) at the same time.');
         }
-      });
 
-      return ast;
-    };
+        var removedParams = node.sexpr.params.splice(1, 2);
+        var keyword = removedParams[1].original;
+        node.program.blockParams = [keyword];
+      }
+    });
 
-    TransformEachInToHash.prototype.validate = function TransformEachInToHash_validate(node) {
-      return (node.type === 'BlockStatement' || node.type === 'MustacheStatement') &&
-        node.sexpr.path.original === 'each' &&
-        node.sexpr.params.length === 3 &&
-        node.sexpr.params[1].type === 'PathExpression' &&
-        node.sexpr.params[1].original === 'in';
-    };
+    return ast;
+  };
 
-    __exports__["default"] = TransformEachInToHash;
-  });
-define("ember-template-compiler/plugins/transform-with-as-to-hash",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+  TransformWithAsToHash.prototype.validate = function TransformWithAsToHash_validate(node) {
+    return node.type === 'BlockStatement' &&
+      node.sexpr.path.original === 'with' &&
+      node.sexpr.params.length === 3 &&
+      node.sexpr.params[1].type === 'PathExpression' &&
+      node.sexpr.params[1].original === 'as';
+  };
 
-    /**
-      An HTMLBars AST transformation that replaces all instances of
+  exports['default'] = TransformWithAsToHash;
 
-      ```handlebars
-      {{#with foo.bar as bar}}
-      {{/with}}
-      ```
+});
+enifed('ember-template-compiler/system/compile', ['exports', 'ember-template-compiler/system/compile_options', 'ember-template-compiler/system/template'], function (exports, compileOptions, template) {
 
-      with
+  'use strict';
 
-      ```handlebars
-      {{#with foo.bar as |bar|}}
-      {{/with}}
-      ```
+  /**
+  @module ember
+  @submodule ember-template-compiler
+  */
 
-      @private
-      @class TransformWithAsToHash
-    */
-    function TransformWithAsToHash() {
-      // set later within HTMLBars to the syntax package
-      this.syntax = null;
+  var compile;
+  exports['default'] = function(templateString) {
+    if (!compile && Ember.__loader.registry['htmlbars-compiler/compiler']) {
+      compile = requireModule('htmlbars-compiler/compiler').compile;
     }
 
-    /**
-      @private
-      @method transform
-      @param {AST} The AST to be transformed.
-    */
-    TransformWithAsToHash.prototype.transform = function TransformWithAsToHash_transform(ast) {
-      var pluginContext = this;
-      var walker = new pluginContext.syntax.Walker();
-
-      walker.visit(ast, function(node) {
-        if (pluginContext.validate(node)) {
-
-          if (node.program && node.program.blockParams.length) {
-            throw new Error('You cannot use keyword (`{{with foo as bar}}`) and block params (`{{with foo as |bar|}}`) at the same time.');
-          }
+    if (!compile) {
+      throw new Error('Cannot call `compile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compile`.');
+    }
 
-          var removedParams = node.sexpr.params.splice(1, 2);
-          var keyword = removedParams[1].original;
-          node.program.blockParams = [ keyword ];
-        }
-      });
+    var templateSpec = compile(templateString, compileOptions['default']());
 
-      return ast;
-    };
+    return template['default'](templateSpec);
+  }
 
-    TransformWithAsToHash.prototype.validate = function TransformWithAsToHash_validate(node) {
-      return node.type === 'BlockStatement' &&
-        node.sexpr.path.original === 'with' &&
-        node.sexpr.params.length === 3 &&
-        node.sexpr.params[1].type === 'PathExpression' &&
-        node.sexpr.params[1].original === 'as';
-    };
+});
+enifed('ember-template-compiler/system/compile_options', ['exports', 'ember-metal/core', 'ember-template-compiler/plugins'], function (exports, Ember, plugins) {
 
-    __exports__["default"] = TransformWithAsToHash;
-  });
-define("ember-template-compiler/system/compile",
-  ["ember-template-compiler/system/compile_options","ember-template-compiler/system/template","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-template-compiler
-    */
+  'use strict';
 
-    var compile;
-    var compileOptions = __dependency1__["default"];
-    var template = __dependency2__["default"];
+  /**
+  @module ember
+  @submodule ember-template-compiler
+  */
 
-    /**
-      Uses HTMLBars `compile` function to process a string into a compiled template.
+  exports['default'] = function() {
+    var disableComponentGeneration = true;
+    
+    return {
+      revision: 'Ember@1.11.0',
 
-      This is not present in production builds.
+      disableComponentGeneration: disableComponentGeneration,
 
-      @private
-      @method compile
-      @param {String} templateString This is the string to be compiled by HTMLBars.
-    */
-    __exports__["default"] = function(templateString) {
-      if (!compile && Ember.__loader.registry['htmlbars-compiler/compiler']) {
-        compile = requireModule('htmlbars-compiler/compiler').compile;
-      }
+      plugins: plugins['default']
+    };
+  }
 
-      if (!compile) {
-        throw new Error('Cannot call `compile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compile`.');
-      }
+});
+enifed('ember-template-compiler/system/precompile', ['exports', 'ember-template-compiler/system/compile_options'], function (exports, compileOptions) {
 
-      var templateSpec = compile(templateString, compileOptions());
+  'use strict';
 
-      return template(templateSpec);
-    }
-  });
-define("ember-template-compiler/system/compile_options",
-  ["ember-metal/core","ember-template-compiler/plugins","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-template-compiler
-    */
+  /**
+  @module ember
+  @submodule ember-template-compiler
+  */
 
-    var Ember = __dependency1__["default"];
-    var plugins = __dependency2__["default"];
+  var compileSpec;
 
-    /**
-      @private
-      @property compileOptions
-    */
-    __exports__["default"] = function() {
-      var disableComponentGeneration = true;
-      
-      return {
-        disableComponentGeneration: disableComponentGeneration,
+  /**
+    Uses HTMLBars `compile` function to process a string into a compiled template string.
+    The returned string must be passed through `Ember.HTMLBars.template`.
 
-        plugins: plugins
-      };
+    This is not present in production builds.
+
+    @private
+    @method precompile
+    @param {String} templateString This is the string to be compiled by HTMLBars.
+  */
+  exports['default'] = function(templateString) {
+    if (!compileSpec && Ember.__loader.registry['htmlbars-compiler/compiler']) {
+      compileSpec = requireModule('htmlbars-compiler/compiler').compileSpec;
     }
-  });
-define("ember-template-compiler/system/precompile",
-  ["ember-template-compiler/system/compile_options","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-template-compiler
-    */
 
-    var compileOptions = __dependency1__["default"];
-    var compileSpec;
+    if (!compileSpec) {
+      throw new Error('Cannot call `compileSpec` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compileSpec`.');
+    }
 
-    /**
-      Uses HTMLBars `compile` function to process a string into a compiled template string.
-      The returned string must be passed through `Ember.HTMLBars.template`.
+    return compileSpec(templateString, compileOptions['default']());
+  }
 
-      This is not present in production builds.
+});
+enifed('ember-template-compiler/system/template', ['exports'], function (exports) {
 
-      @private
-      @method precompile
-      @param {String} templateString This is the string to be compiled by HTMLBars.
-    */
-    __exports__["default"] = function(templateString) {
-      if (!compileSpec && Ember.__loader.registry['htmlbars-compiler/compiler']) {
-        compileSpec = requireModule('htmlbars-compiler/compiler').compileSpec;
-      }
+  'use strict';
 
-      if (!compileSpec) {
-        throw new Error('Cannot call `compileSpec` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compileSpec`.');
-      }
+  /**
+  @module ember
+  @submodule ember-template-compiler
+  */
 
-      return compileSpec(templateString, compileOptions());
-    }
-  });
-define("ember-template-compiler/system/template",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-template-compiler
-    */
+  /**
+    Augments the default precompiled output of an HTMLBars template with
+    additional information needed by Ember.
 
-    /**
-      Augments the detault precompiled output of an HTMLBars template with
-      additional information needed by Ember.
+    @private
+    @method template
+    @param {Function} templateSpec This is the compiled HTMLBars template spec.
+  */
 
-      @private
-      @method template
-      @param {Function} templateSpec This is the compiled HTMLBars template spec.
-    */
+  exports['default'] = function(templateSpec) {
+    templateSpec.isTop = true;
+    templateSpec.isMethod = false;
 
-    __exports__["default"] = function(templateSpec) {
-      templateSpec.isTop = true;
-      templateSpec.isMethod = false;
+    return templateSpec;
+  }
 
-      return templateSpec;
-    }
-  });
-define("htmlbars-compiler",
+});
+enifed("htmlbars-compiler",
   ["./htmlbars-compiler/compiler","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
     var compile = __dependency1__.compile;
-    var compilerSpec = __dependency1__.compilerSpec;
+    var compileSpec = __dependency1__.compileSpec;
+    var template = __dependency1__.template;
 
     __exports__.compile = compile;
-    __exports__.compilerSpec = compilerSpec;
+    __exports__.compileSpec = compileSpec;
+    __exports__.template = template;
   });
-define("htmlbars-compiler/compiler",
+enifed("htmlbars-compiler/compiler",
   ["../htmlbars-syntax/parser","./template-compiler","exports"],
   function(__dependency1__, __dependency2__, __exports__) {
     "use strict";
@@ -687,6 +685,37 @@ define("htmlbars-compiler/compiler",
     var TemplateCompiler = __dependency2__["default"];
 
     /*
+     * Compile a string into a template spec string. The template spec is a string
+     * representation of a template. Usually, you would use compileSpec for
+     * pre-compilation of a template on the server.
+     *
+     * Example usage:
+     *
+     *     var templateSpec = compileSpec("Howdy {{name}}");
+     *     // This next step is basically what plain compile does
+     *     var template = new Function("return " + templateSpec)();
+     *
+     * @method compileSpec
+     * @param {String} string An HTMLBars template string
+     * @return {TemplateSpec} A template spec string
+     */
+    function compileSpec(string, options) {
+      var ast = preprocess(string, options);
+      var compiler = new TemplateCompiler(options);
+      var program = compiler.compile(ast);
+      return program;
+    }
+
+    __exports__.compileSpec = compileSpec;/*
+     * @method template
+     * @param {TemplateSpec} templateSpec A precompiled template
+     * @return {Template} A template spec string
+     */
+    function template(templateSpec) {
+      return new Function("return " + templateSpec)();
+    }
+
+    __exports__.template = template;/*
      * Compile a string into a template rendering function
      *
      * Example usage:
@@ -713,40 +742,17 @@ define("htmlbars-compiler/compiler",
      *     var domFragment = template(context, env, contextualElement);
      *
      * @method compile
-     * @param {String} string An htmlbars template string
+     * @param {String} string An HTMLBars template string
      * @param {Object} options A set of options to provide to the compiler
-     * @return {Function} A function for rendering the template
+     * @return {Template} A function for rendering the template
      */
     function compile(string, options) {
-      var program = compileSpec(string, options);
-      return new Function("return " + program)();
-    }
-
-    __exports__.compile = compile;/*
-     * Compile a string into a template spec string. The template spec is a string
-     * representation of a template. Usually, you would use compileSpec for
-     * pre-compilation of a template on the server.
-     *
-     * Example usage:
-     *
-     *     var templateSpec = compileSpec("Howdy {{name}}");
-     *     // This next step is basically what plain compile does
-     *     var template = new Function("return " + templateSpec)();
-     *
-     * @method compileSpec
-     * @param {String} string An htmlbars template string
-     * @return {Function} A template spec string
-     */
-    function compileSpec(string, options) {
-      var ast = preprocess(string, options);
-      var compiler = new TemplateCompiler(options);
-      var program = compiler.compile(ast);
-      return program;
+      return template(compileSpec(string, options));
     }
 
-    __exports__.compileSpec = compileSpec;
+    __exports__.compile = compile;
   });
-define("htmlbars-compiler/fragment-javascript-compiler",
+enifed("htmlbars-compiler/fragment-javascript-compiler",
   ["./utils","../htmlbars-util/quoting","exports"],
   function(__dependency1__, __dependency2__, __exports__) {
     "use strict";
@@ -849,7 +855,7 @@ define("htmlbars-compiler/fragment-javascript-compiler",
       }
     };
   });
-define("htmlbars-compiler/fragment-opcode-compiler",
+enifed("htmlbars-compiler/fragment-opcode-compiler",
   ["./template-visitor","./utils","../htmlbars-util","../htmlbars-util/array-utils","exports"],
   function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
     "use strict";
@@ -877,14 +883,14 @@ define("htmlbars-compiler/fragment-opcode-compiler",
       this.opcodes.push([type, params]);
     };
 
-    FragmentOpcodeCompiler.prototype.text = function(text, childIndex, childCount, isSingleRoot) {
+    FragmentOpcodeCompiler.prototype.text = function(text) {
       this.opcode('createText', [text.chars]);
-      if (!isSingleRoot) { this.opcode('appendChild'); }
+      this.opcode('appendChild');
     };
 
-    FragmentOpcodeCompiler.prototype.comment = function(comment, childIndex, childCount, isSingleRoot) {
+    FragmentOpcodeCompiler.prototype.comment = function(comment) {
       this.opcode('createComment', [comment.value]);
-      if (!isSingleRoot) { this.opcode('appendChild'); }
+      this.opcode('appendChild');
     };
 
     FragmentOpcodeCompiler.prototype.openElement = function(element) {
@@ -892,32 +898,39 @@ define("htmlbars-compiler/fragment-opcode-compiler",
       forEach(element.attributes, this.attribute, this);
     };
 
-    FragmentOpcodeCompiler.prototype.closeElement = function(element, childIndex, childCount, isSingleRoot) {
-      if (!isSingleRoot) { this.opcode('appendChild'); }
+    FragmentOpcodeCompiler.prototype.closeElement = function() {
+      this.opcode('appendChild');
     };
 
-    FragmentOpcodeCompiler.prototype.startProgram = function(program) {
+    FragmentOpcodeCompiler.prototype.startProgram = function() {
       this.opcodes.length = 0;
-      if (program.body.length !== 1) {
-        this.opcode('createFragment');
-      }
+      this.opcode('createFragment');
     };
 
-    FragmentOpcodeCompiler.prototype.endProgram = function(/* program */) {
+    FragmentOpcodeCompiler.prototype.endProgram = function() {
       this.opcode('returnNode');
     };
 
-    FragmentOpcodeCompiler.prototype.mustache = function () {};
+    FragmentOpcodeCompiler.prototype.mustache = function() {
+      this.pushMorphPlaceholderNode();
+    };
 
-    FragmentOpcodeCompiler.prototype.component = function () {};
+    FragmentOpcodeCompiler.prototype.component = function() {
+      this.pushMorphPlaceholderNode();
+    };
+
+    FragmentOpcodeCompiler.prototype.block = function() {
+      this.pushMorphPlaceholderNode();
+    };
 
-    FragmentOpcodeCompiler.prototype.block = function () {};
+    FragmentOpcodeCompiler.prototype.pushMorphPlaceholderNode = function() {
+      this.opcode('createComment', [""]);
+      this.opcode('appendChild');
+    };
 
     FragmentOpcodeCompiler.prototype.attribute = function(attr) {
       if (attr.value.type === 'TextNode') {
-
         var namespace = getAttrNamespace(attr.name);
-
         this.opcode('setAttribute', [attr.name, attr.value.chars, namespace]);
       }
     };
@@ -926,7 +939,7 @@ define("htmlbars-compiler/fragment-opcode-compiler",
       this.opcode('setNamespace', [namespace]);
     };
   });
-define("htmlbars-compiler/hydration-javascript-compiler",
+enifed("htmlbars-compiler/hydration-javascript-compiler",
   ["./utils","../htmlbars-util/quoting","exports"],
   function(__dependency1__, __dependency2__, __exports__) {
     "use strict";
@@ -960,9 +973,19 @@ define("htmlbars-compiler/hydration-javascript-compiler",
       this.parentCount = 0;
       this.indent = (options && options.indent) || "";
       this.hooks = {};
+      this.hasOpenBoundary = false;
+      this.hasCloseBoundary = false;
 
       processOpcodes(this, opcodes);
 
+      if (this.hasOpenBoundary) {
+        this.source.unshift(this.indent+"  dom.insertBoundary(fragment, 0);\n");
+      }
+
+      if (this.hasCloseBoundary) {
+        this.source.unshift(this.indent+"  dom.insertBoundary(fragment, null);\n");
+      }
+
       var i, l;
       if (this.morphs.length) {
         var morphs = "";
@@ -1008,6 +1031,14 @@ define("htmlbars-compiler/hydration-javascript-compiler",
       this.stack.push(value);
     };
 
+    prototype.openBoundary = function() {
+      this.hasOpenBoundary = true;
+    };
+
+    prototype.closeBoundary = function() {
+      this.hasCloseBoundary = true;
+    };
+
     prototype.pushLiteral = function(value) {
       if (typeof value === 'string') {
         this.stack.push(string(value));
@@ -1187,7 +1218,7 @@ define("htmlbars-compiler/hydration-javascript-compiler",
       return this.parents[this.parents.length-1];
     };
   });
-define("htmlbars-compiler/hydration-opcode-compiler",
+enifed("htmlbars-compiler/hydration-opcode-compiler",
   ["./template-visitor","./utils","../htmlbars-util","../htmlbars-util/array-utils","../htmlbars-syntax/utils","exports"],
   function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
     "use strict";
@@ -1266,33 +1297,32 @@ define("htmlbars-compiler/hydration-opcode-compiler",
       }
     };
 
-    HydrationOpcodeCompiler.prototype.endProgram = function(/* program */) {
+    HydrationOpcodeCompiler.prototype.endProgram = function() {
       distributeMorphs(this.morphs, this.opcodes);
     };
 
-    HydrationOpcodeCompiler.prototype.text = function(/* string, pos, len */) {
+    HydrationOpcodeCompiler.prototype.text = function() {
       ++this.currentDOMChildIndex;
     };
 
-    HydrationOpcodeCompiler.prototype.comment = function(/* string, pos, len */) {
+    HydrationOpcodeCompiler.prototype.comment = function() {
       ++this.currentDOMChildIndex;
     };
 
-    HydrationOpcodeCompiler.prototype.openElement = function(element, pos, len, isSingleRoot, mustacheCount, blankChildTextNodes) {
+    HydrationOpcodeCompiler.prototype.openElement = function(element, pos, len, mustacheCount, blankChildTextNodes) {
       distributeMorphs(this.morphs, this.opcodes);
       ++this.currentDOMChildIndex;
 
       this.element = this.currentDOMChildIndex;
 
-      if (!isSingleRoot) {
-        this.opcode('consumeParent', this.currentDOMChildIndex);
+      this.opcode('consumeParent', this.currentDOMChildIndex);
 
-        // If our parent reference will be used more than once, cache its reference.
-        if (mustacheCount > 1) {
-          this.opcode('shareElement', ++this.elementNum);
-          this.element = null; // Set element to null so we don't cache it twice
-        }
+      // If our parent reference will be used more than once, cache its reference.
+      if (mustacheCount > 1) {
+        this.opcode('shareElement', ++this.elementNum);
+        this.element = null; // Set element to null so we don't cache it twice
       }
+
       var isElementChecked = detectIsElementChecked(element);
       if (blankChildTextNodes.length > 0 || isElementChecked) {
         this.opcode( 'repairClonedNode',
@@ -1304,23 +1334,42 @@ define("htmlbars-compiler/hydration-opcode-compiler",
       this.currentDOMChildIndex = -1;
 
       forEach(element.attributes, this.attribute, this);
-      forEach(element.helpers, this.elementHelper, this);
+      forEach(element.modifiers, this.elementModifier, this);
     };
 
-    HydrationOpcodeCompiler.prototype.closeElement = function(element, pos, len, isSingleRoot) {
+    HydrationOpcodeCompiler.prototype.closeElement = function() {
       distributeMorphs(this.morphs, this.opcodes);
-      if (!isSingleRoot) { this.opcode('popParent'); }
+      this.opcode('popParent');
       this.currentDOMChildIndex = this.paths.pop();
     };
 
-    HydrationOpcodeCompiler.prototype.block = function(block, childIndex, childrenLength) {
-      var sexpr = block.sexpr;
+    HydrationOpcodeCompiler.prototype.mustache = function(mustache, childIndex, childCount) {
+      this.pushMorphPlaceholderNode(childIndex, childCount);
+      
+      var sexpr = mustache.sexpr;
+
+      var morphNum = this.morphNum++;
+      var start = this.currentDOMChildIndex;
+      var end = this.currentDOMChildIndex;
+      this.morphs.push([morphNum, this.paths.slice(), start, end, mustache.escaped]);
+
+      if (isHelper(sexpr)) {
+        prepareSexpr(this, sexpr);
+        this.opcode('printInlineHook', morphNum);
+      } else {
+        preparePath(this, sexpr.path);
+        this.opcode('printContentHook', morphNum);
+      }
+    };
+
+    HydrationOpcodeCompiler.prototype.block = function(block, childIndex, childCount) {
+      this.pushMorphPlaceholderNode(childIndex, childCount);
 
-      var currentDOMChildIndex = this.currentDOMChildIndex;
-      var start = (currentDOMChildIndex < 0) ? null : currentDOMChildIndex;
-      var end = (childIndex === childrenLength - 1) ? null : currentDOMChildIndex + 1;
+      var sexpr = block.sexpr;
 
       var morphNum = this.morphNum++;
+      var start = this.currentDOMChildIndex;
+      var end = this.currentDOMChildIndex;
       this.morphs.push([morphNum, this.paths.slice(), start, end, true]);
 
       var templateId = this.templateId++;
@@ -1330,15 +1379,15 @@ define("htmlbars-compiler/hydration-opcode-compiler",
       this.opcode('printBlockHook', morphNum, templateId, inverseId);
     };
 
-    HydrationOpcodeCompiler.prototype.component = function(component, childIndex, childrenLength) {
-      var currentDOMChildIndex = this.currentDOMChildIndex;
+    HydrationOpcodeCompiler.prototype.component = function(component, childIndex, childCount) {
+      this.pushMorphPlaceholderNode(childIndex, childCount);
+
       var program = component.program || {};
       var blockParams = program.blockParams || [];
 
-      var start = (currentDOMChildIndex < 0 ? null : currentDOMChildIndex),
-          end = (childIndex === childrenLength - 1 ? null : currentDOMChildIndex + 1);
-
       var morphNum = this.morphNum++;
+      var start = this.currentDOMChildIndex;
+      var end = this.currentDOMChildIndex;
       this.morphs.push([morphNum, this.paths.slice(), start, end, true]);
 
       var attrs = component.attributes;
@@ -1392,8 +1441,8 @@ define("htmlbars-compiler/hydration-opcode-compiler",
       this.opcode('printAttributeHook', attrMorphNum, this.elementNum);
     };
 
-    HydrationOpcodeCompiler.prototype.elementHelper = function(sexpr) {
-      prepareSexpr(this, sexpr);
+    HydrationOpcodeCompiler.prototype.elementModifier = function(modifier) {
+      prepareSexpr(this, modifier.sexpr);
 
       // If we have a helper in a node, and this element has not been cached, cache it
       if (this.element !== null) {
@@ -1404,23 +1453,16 @@ define("htmlbars-compiler/hydration-opcode-compiler",
       this.opcode('printElementHook', this.elementNum);
     };
 
-    HydrationOpcodeCompiler.prototype.mustache = function(mustache, childIndex, childrenLength) {
-      var sexpr = mustache.sexpr;
-      var currentDOMChildIndex = this.currentDOMChildIndex;
-
-      var start = currentDOMChildIndex,
-          end = (childIndex === childrenLength - 1 ? -1 : currentDOMChildIndex + 1);
-
-      var morphNum = this.morphNum++;
-      this.morphs.push([morphNum, this.paths.slice(), start, end, mustache.escaped]);
-
-      if (isHelper(sexpr)) {
-        prepareSexpr(this, sexpr);
-        this.opcode('printInlineHook', morphNum);
-      } else {
-        preparePath(this, sexpr.path);
-        this.opcode('printContentHook', morphNum);
+    HydrationOpcodeCompiler.prototype.pushMorphPlaceholderNode = function(childIndex, childCount) {
+      if (this.paths.length === 0) {
+        if (childIndex === 0) {
+          this.opcode('openBoundary');
+        }
+        if (childIndex === childCount - 1) {
+          this.opcode('closeBoundary');
+        }
       }
+      this.comment();
     };
 
     HydrationOpcodeCompiler.prototype.SubExpression = function(sexpr) {
@@ -1499,7 +1541,7 @@ define("htmlbars-compiler/hydration-opcode-compiler",
       morphs.length = 0;
     }
   });
-define("htmlbars-compiler/template-compiler",
+enifed("htmlbars-compiler/template-compiler",
   ["./fragment-opcode-compiler","./fragment-javascript-compiler","./hydration-opcode-compiler","./hydration-javascript-compiler","./template-visitor","./utils","../htmlbars-util/quoting","exports"],
   function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
     "use strict";
@@ -1513,6 +1555,7 @@ define("htmlbars-compiler/template-compiler",
 
     function TemplateCompiler(options) {
       this.options = options || {};
+      this.revision = this.options.revision || "HTMLBars@v0.11.2";
       this.fragmentOpcodeCompiler = new FragmentOpcodeCompiler();
       this.fragmentCompiler = new FragmentJavaScriptCompiler();
       this.hydrationOpcodeCompiler = new HydrationOpcodeCompiler();
@@ -1598,6 +1641,7 @@ define("htmlbars-compiler/template-compiler",
         this.getChildTemplateVars(indent + '  ') +
         indent+'  return {\n' +
         indent+'    isHTMLBars: true,\n' +
+        indent+'    revision: "' + this.revision + '",\n' +
         indent+'    blockParams: ' + blockParams.length + ',\n' +
         indent+'    cachedFragment: null,\n' +
         indent+'    hasRendered: false,\n' +
@@ -1641,14 +1685,14 @@ define("htmlbars-compiler/template-compiler",
       this.hydrationOpcodeCompiler.closeElement(element, i, l, r);
     };
 
-    TemplateCompiler.prototype.component = function(component, i, l) {
-      this.fragmentOpcodeCompiler.component(component, i, l);
-      this.hydrationOpcodeCompiler.component(component, i, l);
+    TemplateCompiler.prototype.component = function(component, i, l, s) {
+      this.fragmentOpcodeCompiler.component(component, i, l, s);
+      this.hydrationOpcodeCompiler.component(component, i, l, s);
     };
 
-    TemplateCompiler.prototype.block = function(block, i, l) {
-      this.fragmentOpcodeCompiler.block(block, i, l);
-      this.hydrationOpcodeCompiler.block(block, i, l);
+    TemplateCompiler.prototype.block = function(block, i, l, s) {
+      this.fragmentOpcodeCompiler.block(block, i, l, s);
+      this.hydrationOpcodeCompiler.block(block, i, l, s);
     };
 
     TemplateCompiler.prototype.text = function(string, i, l, r) {
@@ -1661,16 +1705,16 @@ define("htmlbars-compiler/template-compiler",
       this.hydrationOpcodeCompiler.comment(string, i, l, r);
     };
 
-    TemplateCompiler.prototype.mustache = function (mustache, i, l) {
-      this.fragmentOpcodeCompiler.mustache(mustache, i, l);
-      this.hydrationOpcodeCompiler.mustache(mustache, i, l);
+    TemplateCompiler.prototype.mustache = function (mustache, i, l, s) {
+      this.fragmentOpcodeCompiler.mustache(mustache, i, l, s);
+      this.hydrationOpcodeCompiler.mustache(mustache, i, l, s);
     };
 
     TemplateCompiler.prototype.setNamespace = function(namespace) {
       this.fragmentOpcodeCompiler.setNamespace(namespace);
     };
   });
-define("htmlbars-compiler/template-visitor",
+enifed("htmlbars-compiler/template-visitor",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -1781,19 +1825,17 @@ define("htmlbars-compiler/template-visitor",
     TemplateVisitor.prototype.ElementNode = function(element) {
       var parentFrame = this.getCurrentFrame();
       var elementFrame = this.pushFrame();
-      var parentNode = parentFrame.parentNode;
 
       elementFrame.parentNode = element;
       elementFrame.children = element.children;
       elementFrame.childCount = element.children.length;
-      elementFrame.mustacheCount += element.helpers.length;
+      elementFrame.mustacheCount += element.modifiers.length;
       elementFrame.blankChildTextNodes = [];
 
       var actionArgs = [
         element,
         parentFrame.childIndex,
-        parentFrame.childCount,
-        parentNode.type === 'Program' && parentFrame.childCount === 1
+        parentFrame.childCount
       ];
 
       elementFrame.actions.push(['closeElement', actionArgs]);
@@ -1825,11 +1867,10 @@ define("htmlbars-compiler/template-visitor",
 
     TemplateVisitor.prototype.TextNode = function(text) {
       var frame = this.getCurrentFrame();
-      var isSingleRoot = frame.parentNode.type === 'Program' && frame.childCount === 1;
       if (text.chars === '') {
         frame.blankChildTextNodes.push(domIndexOf(frame.children, text));
       }
-      frame.actions.push(['text', [text, frame.childIndex, frame.childCount, isSingleRoot]]);
+      frame.actions.push(['text', [text, frame.childIndex, frame.childCount]]);
     };
 
     TemplateVisitor.prototype.BlockStatement = function(node) {
@@ -1860,9 +1901,7 @@ define("htmlbars-compiler/template-visitor",
 
     TemplateVisitor.prototype.CommentStatement = function(text) {
       var frame = this.getCurrentFrame();
-      var isSingleRoot = frame.parentNode.type === 'Program' && frame.childCount === 1;
-
-      frame.actions.push(['comment', [text, frame.childIndex, frame.childCount, isSingleRoot]]);
+      frame.actions.push(['comment', [text, frame.childIndex, frame.childCount]]);
     };
 
     TemplateVisitor.prototype.MustacheStatement = function(mustache) {
@@ -1912,7 +1951,7 @@ define("htmlbars-compiler/template-visitor",
       return -1;
     }
   });
-define("htmlbars-compiler/utils",
+enifed("htmlbars-compiler/utils",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -1930,7 +1969,160 @@ define("htmlbars-compiler/utils",
 
     __exports__.processOpcodes = processOpcodes;
   });
-define("htmlbars-syntax",
+enifed("htmlbars-runtime",
+  ["htmlbars-runtime/hooks","htmlbars-runtime/helpers","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    var hooks = __dependency1__["default"];
+    var helpers = __dependency2__["default"];
+
+    __exports__.hooks = hooks;
+    __exports__.helpers = helpers;
+  });
+enifed("htmlbars-runtime/helpers",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    function partial(params, hash, options, env) {
+      var template = env.partials[params[0]];
+      return template.render(this, env, options.morph.contextualElement);
+    }
+
+    __exports__.partial = partial;__exports__["default"] = {
+      partial: partial
+    };
+  });
+enifed("htmlbars-runtime/hooks",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    function block(env, morph, context, path, params, hash, template, inverse) {
+      var options = {
+        morph: morph,
+        template: template,
+        inverse: inverse
+      };
+
+      var helper = lookupHelper(env, context, path);
+      var value = helper.call(context, params, hash, options, env);
+
+      morph.setContent(value);
+    }
+
+    __exports__.block = block;function inline(env, morph, context, path, params, hash) {
+      var helper = lookupHelper(env, context, path);
+      var value = helper.call(context, params, hash, { morph: morph }, env);
+
+      morph.setContent(value);
+    }
+
+    __exports__.inline = inline;function content(env, morph, context, path) {
+      var helper = lookupHelper(env, context, path);
+
+      var value;
+      if (helper) {
+        value = helper.call(context, [], {}, { morph: morph }, env);
+      } else {
+        value = get(env, context, path);
+      }
+
+      morph.setContent(value);
+    }
+
+    __exports__.content = content;function element(env, domElement, context, path, params, hash) {
+      var helper = lookupHelper(env, context, path);
+      if (helper) {
+        helper.call(context, params, hash, { element: domElement }, env);
+      }
+    }
+
+    __exports__.element = element;function attribute(env, attrMorph, domElement, name, value) {
+      attrMorph.setContent(value);
+    }
+
+    __exports__.attribute = attribute;function subexpr(env, context, helperName, params, hash) {
+      var helper = lookupHelper(env, context, helperName);
+      if (helper) {
+        return helper.call(context, params, hash, {}, env);
+      } else {
+        return get(env, context, helperName);
+      }
+    }
+
+    __exports__.subexpr = subexpr;function get(env, context, path) {
+      if (path === '') {
+        return context;
+      }
+
+      var keys = path.split('.');
+      var value = context;
+      for (var i = 0; i < keys.length; i++) {
+        if (value) {
+          value = value[keys[i]];
+        } else {
+          break;
+        }
+      }
+      return value;
+    }
+
+    __exports__.get = get;function set(env, context, name, value) {
+      context[name] = value;
+    }
+
+    __exports__.set = set;function component(env, morph, context, tagName, attrs, template) {
+      var helper = lookupHelper(env, context, tagName);
+
+      var value;
+      if (helper) {
+        var options = {
+          morph: morph,
+          template: template
+        };
+
+        value = helper.call(context, [], attrs, options, env);
+      } else {
+        value = componentFallback(env, morph, context, tagName, attrs, template);
+      }
+
+      morph.setContent(value);
+    }
+
+    __exports__.component = component;function concat(env, params) {
+      var value = "";
+      for (var i = 0, l = params.length; i < l; i++) {
+        value += params[i];
+      }
+      return value;
+    }
+
+    __exports__.concat = concat;function componentFallback(env, morph, context, tagName, attrs, template) {
+      var element = env.dom.createElement(tagName);
+      for (var name in attrs) {
+        element.setAttribute(name, attrs[name]);
+      }
+      element.appendChild(template.render(context, env, morph.contextualElement));
+      return element;
+    }
+
+    function lookupHelper(env, context, helperName) {
+      return env.helpers[helperName];
+    }
+
+    __exports__["default"] = {
+      content: content,
+      block: block,
+      inline: inline,
+      component: component,
+      element: element,
+      attribute: attribute,
+      subexpr: subexpr,
+      concat: concat,
+      get: get,
+      set: set
+    };
+  });
+enifed("htmlbars-syntax",
   ["./htmlbars-syntax/walker","./htmlbars-syntax/builders","./htmlbars-syntax/parser","exports"],
   function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
     "use strict";
@@ -1942,7 +2134,7 @@ define("htmlbars-syntax",
     __exports__.builders = builders;
     __exports__.parse = parse;
   });
-define("htmlbars-syntax/builders",
+enifed("htmlbars-syntax/builders",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -1980,22 +2172,28 @@ define("htmlbars-syntax/builders",
       };
     }
 
-    __exports__.buildComment = buildComment;
-    function buildConcat(parts) {
+    __exports__.buildComment = buildComment;function buildConcat(parts) {
       return {
         type: "ConcatStatement",
         parts: parts || []
       };
     }
 
-    __exports__.buildConcat = buildConcat;// Nodes
+    __exports__.buildConcat = buildConcat;function buildElementModifier(sexpr) {
+      return {
+        type: "ElementModifierStatement",
+        sexpr: sexpr
+      };
+    }
+
+    __exports__.buildElementModifier = buildElementModifier;// Nodes
 
-    function buildElement(tag, attributes, helpers, children) {
+    function buildElement(tag, attributes, modifiers, children) {
       return {
         type: "ElementNode",
         tag: tag,
         attributes: attributes || [],
-        helpers: helpers || [],
+        modifiers: modifiers || [],
         children: children || []
       };
     }
@@ -2098,6 +2296,7 @@ define("htmlbars-syntax/builders",
       partial: buildPartial,
       comment: buildComment,
       element: buildElement,
+      elementModifier: buildElementModifier,
       component: buildComponent,
       attr: buildAttr,
       text: buildText,
@@ -2112,7 +2311,7 @@ define("htmlbars-syntax/builders",
       program: buildProgram
     };
   });
-define("htmlbars-syntax/handlebars/compiler/ast",
+enifed("htmlbars-syntax/handlebars/compiler/ast",
   ["../exception","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
@@ -2232,7 +2431,7 @@ define("htmlbars-syntax/handlebars/compiler/ast",
     // most modify the object to operate properly.
     __exports__["default"] = AST;
   });
-define("htmlbars-syntax/handlebars/compiler/base",
+enifed("htmlbars-syntax/handlebars/compiler/base",
   ["./parser","./ast","./whitespace-control","./helpers","../utils","exports"],
   function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
     "use strict";
@@ -2264,7 +2463,7 @@ define("htmlbars-syntax/handlebars/compiler/base",
 
     __exports__.parse = parse;
   });
-define("htmlbars-syntax/handlebars/compiler/helpers",
+enifed("htmlbars-syntax/handlebars/compiler/helpers",
   ["../exception","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
@@ -2385,7 +2584,7 @@ define("htmlbars-syntax/handlebars/compiler/helpers",
 
     __exports__.prepareBlock = prepareBlock;
   });
-define("htmlbars-syntax/handlebars/compiler/parser",
+enifed("htmlbars-syntax/handlebars/compiler/parser",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -2921,7 +3120,7 @@ define("htmlbars-syntax/handlebars/compiler/parser",
     })();__exports__["default"] = handlebars;
     /* jshint ignore:end */
   });
-define("htmlbars-syntax/handlebars/compiler/visitor",
+enifed("htmlbars-syntax/handlebars/compiler/visitor",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -2992,7 +3191,7 @@ define("htmlbars-syntax/handlebars/compiler/visitor",
 
     __exports__["default"] = Visitor;
   });
-define("htmlbars-syntax/handlebars/compiler/whitespace-control",
+enifed("htmlbars-syntax/handlebars/compiler/whitespace-control",
   ["./visitor","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
@@ -3207,7 +3406,7 @@ define("htmlbars-syntax/handlebars/compiler/whitespace-control",
 
     __exports__["default"] = WhitespaceControl;
   });
-define("htmlbars-syntax/handlebars/exception",
+enifed("htmlbars-syntax/handlebars/exception",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -3242,7 +3441,7 @@ define("htmlbars-syntax/handlebars/exception",
 
     __exports__["default"] = Exception;
   });
-define("htmlbars-syntax/handlebars/safe-string",
+enifed("htmlbars-syntax/handlebars/safe-string",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -3257,7 +3456,7 @@ define("htmlbars-syntax/handlebars/safe-string",
 
     __exports__["default"] = SafeString;
   });
-define("htmlbars-syntax/handlebars/utils",
+enifed("htmlbars-syntax/handlebars/utils",
   ["./safe-string","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
@@ -3349,7 +3548,7 @@ define("htmlbars-syntax/handlebars/utils",
 
     __exports__.appendContextPath = appendContextPath;
   });
-define("htmlbars-syntax/node-handlers",
+enifed("htmlbars-syntax/node-handlers",
   ["./builders","../htmlbars-util/array-utils","./utils","exports"],
   function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
     "use strict";
@@ -3358,7 +3557,6 @@ define("htmlbars-syntax/node-handlers",
     var buildHash = __dependency1__.buildHash;
     var forEach = __dependency2__.forEach;
     var appendChild = __dependency3__.appendChild;
-    var postprocessProgram = __dependency3__.postprocessProgram;
 
     var nodeHandlers = {
 
@@ -3377,8 +3575,6 @@ define("htmlbars-syntax/node-handlers",
 
         this.acceptToken(this.tokenizer.tokenizeEOF());
 
-        postprocessProgram(node);
-
         // Ensure that that the element stack is balanced properly.
         var poppedNode = this.elementStack.pop();
         if (poppedNode !== node) {
@@ -3515,7 +3711,7 @@ define("htmlbars-syntax/node-handlers",
 
     __exports__["default"] = nodeHandlers;
   });
-define("htmlbars-syntax/parser",
+enifed("htmlbars-syntax/parser",
   ["./handlebars/compiler/base","./tokenizer","../simple-html-tokenizer/entity-parser","../simple-html-tokenizer/char-refs/full","./node-handlers","./token-handlers","../htmlbars-syntax","exports"],
   function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
     "use strict";
@@ -3622,7 +3818,7 @@ define("htmlbars-syntax/parser",
       return string.join('\n');
     };
   });
-define("htmlbars-syntax/token-handlers",
+enifed("htmlbars-syntax/token-handlers",
   ["../htmlbars-util/array-utils","./builders","./utils","exports"],
   function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
     "use strict";
@@ -3634,7 +3830,6 @@ define("htmlbars-syntax/token-handlers",
     var buildText = __dependency2__.buildText;
     var appendChild = __dependency3__.appendChild;
     var parseComponentBlockParams = __dependency3__.parseComponentBlockParams;
-    var postprocessProgram = __dependency3__.postprocessProgram;
 
     // The HTML elements in this list are speced by
     // http://www.w3.org/TR/html-markup/syntax.html#syntax-elements,
@@ -3663,7 +3858,7 @@ define("htmlbars-syntax/token-handlers",
       },
 
       StartTag: function(tag) {
-        var element = buildElement(tag.tagName, tag.attributes, tag.helpers || [], []);
+        var element = buildElement(tag.tagName, tag.attributes, tag.modifiers || [], []);
         element.loc = {
           start: { line: tag.firstLine, column: tag.firstColumn},
           end: { line: null, column: null}
@@ -3689,20 +3884,20 @@ define("htmlbars-syntax/token-handlers",
         switch(tokenizer.state) {
           // Tag helpers
           case "tagName":
-            tokenizer.addTagHelper(mustache.sexpr);
+            tokenizer.addElementModifier(mustache);
             tokenizer.state = "beforeAttributeName";
             return;
           case "beforeAttributeName":
-            tokenizer.addTagHelper(mustache.sexpr);
+            tokenizer.addElementModifier(mustache);
             return;
           case "attributeName":
           case "afterAttributeName":
             tokenizer.finalizeAttributeValue();
-            tokenizer.addTagHelper(mustache.sexpr);
+            tokenizer.addElementModifier(mustache);
             tokenizer.state = "beforeAttributeName";
             return;
           case "afterAttributeValueQuoted":
-            tokenizer.addTagHelper(mustache.sexpr);
+            tokenizer.addElementModifier(mustache);
             tokenizer.state = "beforeAttributeName";
             return;
 
@@ -3737,7 +3932,6 @@ define("htmlbars-syntax/token-handlers",
         } else {
           var program = buildProgram(element.children);
           parseComponentBlockParams(element, program);
-          postprocessProgram(program);
           var component = buildComponent(element.tag, element.attributes, program);
           appendChild(parent, component);
         }
@@ -3769,7 +3963,7 @@ define("htmlbars-syntax/token-handlers",
 
     __exports__["default"] = tokenHandlers;
   });
-define("htmlbars-syntax/tokenizer",
+enifed("htmlbars-syntax/tokenizer",
   ["../simple-html-tokenizer","./utils","../htmlbars-util/array-utils","./builders","exports"],
   function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
     "use strict";
@@ -3830,9 +4024,13 @@ define("htmlbars-syntax/tokenizer",
       }
     };
 
-    Tokenizer.prototype.addTagHelper = function(helper) {
-      var helpers = this.token.helpers = this.token.helpers || [];
-      helpers.push(helper);
+    Tokenizer.prototype.addElementModifier = function(mustache) {
+      if (!this.token.modifiers) {
+        this.token.modifiers = [];
+      }
+
+      var modifier = builders.elementModifier(mustache.sexpr);
+      this.token.modifiers.push(modifier);
     };
 
     function prepareAttributeValue(attr) {
@@ -3873,12 +4071,11 @@ define("htmlbars-syntax/tokenizer",
 
     __exports__.unwrapMustache = unwrapMustache;__exports__.Tokenizer = Tokenizer;
   });
-define("htmlbars-syntax/utils",
-  ["./builders","../htmlbars-util/array-utils","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
+enifed("htmlbars-syntax/utils",
+  ["../htmlbars-util/array-utils","exports"],
+  function(__dependency1__, __exports__) {
     "use strict";
-    var buildText = __dependency1__.buildText;
-    var indexOfArray = __dependency2__.indexOfArray;
+    var indexOfArray = __dependency1__.indexOfArray;
     // Regex to validate the identifier for block parameters. 
     // Based on the ID validation regex in Handlebars.
 
@@ -3925,26 +4122,7 @@ define("htmlbars-syntax/utils",
       }
     }
 
-    __exports__.parseComponentBlockParams = parseComponentBlockParams;// Adds an empty text node at the beginning and end of a program.
-    // The empty text nodes *between* nodes are handled elsewhere.
-
-    function postprocessProgram(program) {
-      var body = program.body;
-
-      if (body.length === 0) {
-        return;
-      }
-
-      if (usesMorph(body[0])) {
-        body.unshift(buildText(''));
-      }
-
-      if (usesMorph(body[body.length-1])) {
-        body.push(buildText(''));
-      }
-    }
-
-    __exports__.postprocessProgram = postprocessProgram;function childrenFor(node) {
+    __exports__.parseComponentBlockParams = parseComponentBlockParams;function childrenFor(node) {
       if (node.type === 'Program') {
         return node.body;
       }
@@ -3953,23 +4131,8 @@ define("htmlbars-syntax/utils",
       }
     }
 
-    __exports__.childrenFor = childrenFor;function usesMorph(node) {
-      return node.type === 'MustacheStatement' ||
-             node.type === 'BlockStatement' ||
-             node.type === 'ComponentNode';
-    }
-
-    __exports__.usesMorph = usesMorph;function appendChild(parent, node) {
-      var children = childrenFor(parent);
-
-      var len = children.length, last;
-      if (len > 0) {
-        last = children[len-1];
-        if (usesMorph(last) && usesMorph(node)) {
-          children.push(buildText(''));
-        }
-      }
-      children.push(node);
+    __exports__.childrenFor = childrenFor;function appendChild(parent, node) {
+      childrenFor(parent).push(node);
     }
 
     __exports__.appendChild = appendChild;function isHelper(sexpr) {
@@ -3979,7 +4142,7 @@ define("htmlbars-syntax/utils",
 
     __exports__.isHelper = isHelper;
   });
-define("htmlbars-syntax/walker",
+enifed("htmlbars-syntax/walker",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -4038,7 +4201,7 @@ define("htmlbars-syntax/walker",
       }
     };
   });
-define("htmlbars-test-helpers",
+enifed("htmlbars-test-helpers",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -4150,7 +4313,7 @@ define("htmlbars-test-helpers",
     }
     __exports__.createObject = createObject;
   });
-define("htmlbars-util",
+enifed("htmlbars-util",
   ["./htmlbars-util/safe-string","./htmlbars-util/handlebars/utils","./htmlbars-util/namespaces","exports"],
   function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
     "use strict";
@@ -4162,7 +4325,7 @@ define("htmlbars-util",
     __exports__.escapeExpression = escapeExpression;
     __exports__.getAttrNamespace = getAttrNamespace;
   });
-define("htmlbars-util/array-utils",
+enifed("htmlbars-util/array-utils",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -4214,7 +4377,7 @@ define("htmlbars-util/array-utils",
     var indexOfArray = getIdx;
     __exports__.indexOfArray = indexOfArray;
   });
-define("htmlbars-util/handlebars/safe-string",
+enifed("htmlbars-util/handlebars/safe-string",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -4229,7 +4392,7 @@ define("htmlbars-util/handlebars/safe-string",
 
     __exports__["default"] = SafeString;
   });
-define("htmlbars-util/handlebars/utils",
+enifed("htmlbars-util/handlebars/utils",
   ["./safe-string","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
@@ -4321,7 +4484,7 @@ define("htmlbars-util/handlebars/utils",
 
     __exports__.appendContextPath = appendContextPath;
   });
-define("htmlbars-util/namespaces",
+enifed("htmlbars-util/namespaces",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -4348,7 +4511,7 @@ define("htmlbars-util/namespaces",
 
     __exports__.getAttrNamespace = getAttrNamespace;
   });
-define("htmlbars-util/object-utils",
+enifed("htmlbars-util/object-utils",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -4362,7 +4525,7 @@ define("htmlbars-util/object-utils",
 
     __exports__.merge = merge;
   });
-define("htmlbars-util/quoting",
+enifed("htmlbars-util/quoting",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -4401,7 +4564,7 @@ define("htmlbars-util/quoting",
 
     __exports__.repeat = repeat;
   });
-define("htmlbars-util/safe-string",
+enifed("htmlbars-util/safe-string",
   ["./handlebars/safe-string","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
@@ -4409,7 +4572,7 @@ define("htmlbars-util/safe-string",
 
     __exports__["default"] = SafeString;
   });
-define("simple-html-tokenizer",
+enifed("simple-html-tokenizer",
   ["./simple-html-tokenizer/tokenizer","./simple-html-tokenizer/tokenize","./simple-html-tokenizer/generator","./simple-html-tokenizer/generate","./simple-html-tokenizer/tokens","exports"],
   function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
     "use strict";
@@ -4432,7 +4595,7 @@ define("simple-html-tokenizer",
     __exports__.Chars = Chars;
     __exports__.Comment = Comment;
   });
-define("simple-html-tokenizer/char-refs/full",
+enifed("simple-html-tokenizer/char-refs/full",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -6564,7 +6727,7 @@ define("simple-html-tokenizer/char-refs/full",
       zwnj: [8204]
     };
   });
-define("simple-html-tokenizer/char-refs/min",
+enifed("simple-html-tokenizer/char-refs/min",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -6576,7 +6739,7 @@ define("simple-html-tokenizer/char-refs/min",
       gt: [62]
     };
   });
-define("simple-html-tokenizer/entity-parser",
+enifed("simple-html-tokenizer/entity-parser",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -6611,7 +6774,7 @@ define("simple-html-tokenizer/entity-parser",
 
     __exports__["default"] = EntityParser;
   });
-define("simple-html-tokenizer/generate",
+enifed("simple-html-tokenizer/generate",
   ["./generator","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
@@ -6622,7 +6785,7 @@ define("simple-html-tokenizer/generate",
       return generator.generate(tokens);
     }
   });
-define("simple-html-tokenizer/generator",
+enifed("simple-html-tokenizer/generator",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -6721,7 +6884,7 @@ define("simple-html-tokenizer/generator",
 
     __exports__["default"] = Generator;
   });
-define("simple-html-tokenizer/tokenize",
+enifed("simple-html-tokenizer/tokenize",
   ["./tokenizer","./entity-parser","./char-refs/full","exports"],
   function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
     "use strict";
@@ -6734,7 +6897,7 @@ define("simple-html-tokenizer/tokenize",
       return tokenizer.tokenize();
     }
   });
-define("simple-html-tokenizer/tokenizer",
+enifed("simple-html-tokenizer/tokenizer",
   ["./utils","./tokens","exports"],
   function(__dependency1__, __dependency2__, __exports__) {
     "use strict";
@@ -7138,7 +7301,7 @@ define("simple-html-tokenizer/tokenizer",
 
     __exports__["default"] = Tokenizer;
   });
-define("simple-html-tokenizer/tokens",
+enifed("simple-html-tokenizer/tokens",
   ["exports"],
   function(__exports__) {
     "use strict";
@@ -7166,7 +7329,7 @@ define("simple-html-tokenizer/tokens",
 
     __exports__.Comment = Comment;
   });
-define("simple-html-tokenizer/utils",
+enifed("simple-html-tokenizer/utils",
   ["exports"],
   function(__exports__) {
     "use strict";
diff --git a/vendor/js/ember.js b/vendor/js/ember.js
index 5c0e3e0..b26f893 100644
--- a/vendor/js/ember.js
+++ b/vendor/js/ember.js
@@ -1,26 +1,39 @@
 /*!
  * @overview  Ember - JavaScript Application Framework
- * @copyright Copyright 2011-2014 Tilde Inc. and contributors
+ * @copyright Copyright 2011-2015 Tilde Inc. and contributors
  *            Portions Copyright 2006-2011 Strobe Inc.
  *            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   1.10.0
+ * @version   1.11.0
  */
 
 (function() {
 var enifed, requireModule, eriuqer, requirejs, Ember;
+var mainContext = this;
 
 (function() {
+
   Ember = this.Ember = this.Ember || {};
   if (typeof Ember === 'undefined') { Ember = {}; };
   function UNDEFINED() { }
 
   if (typeof Ember.__loader === 'undefined') {
-    var registry = {}, seen = {};
+    var registry = {};
+    var seen = {};
 
     enifed = function(name, deps, callback) {
-      registry[name] = { deps: deps, callback: callback };
+      var value = { };
+
+      if (!callback) {
+        value.deps = [];
+        value.callback = deps;
+      } else {
+        value.deps = deps;
+        value.callback = callback;
+      }
+
+        registry[name] = value;
     };
 
     requirejs = eriuqer = requireModule = function(name) {
@@ -65,9 +78,13 @@ var enifed, requireModule, eriuqer, requirejs, Ember;
       for (var i=0, l=parts.length; i<l; i++) {
         var part = parts[i];
 
-        if (part === '..') { parentBase.pop(); }
-        else if (part === '.') { continue; }
-        else { parentBase.push(part); }
+        if (part === '..') {
+          parentBase.pop();
+        } else if (part === '.') {
+          continue;
+        } else {
+          parentBase.push(part);
+        }
       }
 
       return parentBase.join('/');
@@ -1072,940 +1089,1170 @@ enifed("calculateVersion",
       }
     };
   });
-enifed("container",
-  ["container/container","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    /*
-    Public api for the container is still in flux.
-    The public api, specified on the application namespace should be considered the stable api.
-    // @module container
-      @private
-    */
+enifed('container', ['exports', 'container/registry', 'container/container'], function (exports, Registry, Container) {
 
-    /*
-     Flag to enable/disable model factory injections (disabled by default)
-     If model factory injections are enabled, models should not be
-     accessed globally (only through `container.lookupFactory('model:modelName'))`);
-    */
-    Ember.MODEL_FACTORY_INJECTIONS = false;
+  'use strict';
 
-    if (Ember.ENV && typeof Ember.ENV.MODEL_FACTORY_INJECTIONS !== 'undefined') {
-      Ember.MODEL_FACTORY_INJECTIONS = !!Ember.ENV.MODEL_FACTORY_INJECTIONS;
-    }
+  /*
+  Public api for the container is still in flux.
+  The public api, specified on the application namespace should be considered the stable api.
+  // @module container
+    @private
+  */
 
+  /*
+   Flag to enable/disable model factory injections (disabled by default)
+   If model factory injections are enabled, models should not be
+   accessed globally (only through `container.lookupFactory('model:modelName'))`);
+  */
+  Ember.MODEL_FACTORY_INJECTIONS = false;
 
-    var Container = __dependency1__["default"];
+  if (Ember.ENV && typeof Ember.ENV.MODEL_FACTORY_INJECTIONS !== 'undefined') {
+    Ember.MODEL_FACTORY_INJECTIONS = !!Ember.ENV.MODEL_FACTORY_INJECTIONS;
+  }
 
-    __exports__["default"] = Container;
-  });
-enifed("container/container",
-  ["ember-metal/core","ember-metal/keys","ember-metal/dictionary","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var emberKeys = __dependency2__["default"];
-    var dictionary = __dependency3__["default"];
+  exports.Registry = Registry['default'];
+  exports.Container = Container['default'];
 
-    // A lightweight container that helps to assemble and decouple components.
-    // Public api for the container is still in flux.
-    // The public api, specified on the application namespace should be considered the stable api.
-    function Container(parent) {
-      this.parent = parent;
-      this.children = [];
+});
+enifed('container/container', ['exports', 'ember-metal/core', 'ember-metal/keys', 'ember-metal/dictionary'], function (exports, Ember, emberKeys, dictionary) {
 
-      this.resolver = parent && parent.resolver || function() {};
+  'use strict';
 
-      this.registry       = dictionary(parent ? parent.registry : null);
-      this.cache          = dictionary(parent ? parent.cache : null);
-      this.factoryCache   = dictionary(parent ? parent.factoryCache : null);
-      this.resolveCache   = dictionary(parent ? parent.resolveCache : null);
-      this.typeInjections = dictionary(parent ? parent.typeInjections : null);
-      this.injections     = dictionary(null);
-      this.normalizeCache = dictionary(null);
-      
-        this.validationCache = dictionary(parent ? parent.validationCache : null);
-      
+  var Registry;
 
-      this.factoryTypeInjections = dictionary(parent ? parent.factoryTypeInjections : null);
-      this.factoryInjections     = dictionary(null);
+  /**
+   A lightweight container used to instantiate and cache objects.
 
-      this._options     = dictionary(parent ? parent._options : null);
-      this._typeOptions = dictionary(parent ? parent._typeOptions : null);
-    }
+   Every `Container` must be associated with a `Registry`, which is referenced
+   to determine the factory and options that should be used to instantiate
+   objects.
 
-    Container.prototype = {
+   The public API for `Container` is still in flux and should not be considered
+   stable.
 
-      /**
-        @property parent
-        @type Container
-        @default null
-      */
-      parent: null,
+   @private
+   @class Container
+   */
+  function Container(registry, options) {
+    this._registry = registry || (function() {
+      Ember['default'].deprecate(
+        "A container should only be created for an already instantiated " +
+        "registry. For backward compatibility, an isolated registry will " +
+        "be instantiated just for this container."
+      );
 
-      /**
-        @property children
-        @type Array
-        @default []
-      */
-      children: null,
+      // TODO - See note above about transpiler import workaround.
+      if (!Registry) { Registry = requireModule('container/registry')['default']; }
 
-      /**
-        @property resolver
-        @type function
-      */
-      resolver: null,
+      return new Registry();
+    }());
 
-      /**
-        @property registry
-        @type InheritingDict
-      */
-      registry: null,
+    this.cache        = dictionary['default'](options && options.cache ? options.cache : null);
+    this.factoryCache = dictionary['default'](options && options.factoryCache ? options.factoryCache : null);
+    this.validationCache = dictionary['default'](options && options.validationCache ? options.validationCache : null);
+  }
 
-      /**
-        @property cache
-        @type InheritingDict
-      */
-      cache: null,
+  Container.prototype = {
+    /**
+     @private
 
-      /**
-        @property typeInjections
-        @type InheritingDict
-      */
-      typeInjections: null,
+     @property _registry
+     @type Registry
+     @since 1.11.0
+     */
+    _registry: null,
 
-      /**
-        @property injections
-        @type Object
-        @default {}
-      */
-      injections: null,
+    /**
+     @property cache
+     @type InheritingDict
+     */
+    cache: null,
 
-      /**
-        @private
+    /**
+     @property factoryCache
+     @type InheritingDict
+     */
+    factoryCache: null,
 
-        @property _options
-        @type InheritingDict
-        @default null
-      */
-      _options: null,
+    /**
+     @property validationCache
+     @type InheritingDict
+     */
+    validationCache: null,
 
-      /**
-        @private
+    /**
+     Given a fullName return a corresponding instance.
 
-        @property _typeOptions
-        @type InheritingDict
-      */
-      _typeOptions: null,
+     The default behaviour 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.
 
-      /**
-        Returns a new child of the current container. These children are configured
-        to correctly inherit from the current container.
+     ```javascript
+     var registry = new Registry();
+     var container = registry.container();
 
-        @method child
-        @return {Container}
-      */
-      child: function() {
-        var container = new Container(this);
-        this.children.push(container);
-        return container;
-      },
+     registry.register('api:twitter', Twitter);
 
-      /**
-        Registers a factory for later injection.
+     var twitter = container.lookup('api:twitter');
 
-        Example:
+     twitter instanceof Twitter; // => true
 
-        ```javascript
-        var container = new Container();
+     // by default the container will return singletons
+     var twitter2 = container.lookup('api:twitter');
+     twitter2 instanceof Twitter; // => true
 
-        container.register('model:user', Person, {singleton: false });
-        container.register('fruit:favorite', Orange);
-        container.register('communication:main', Email, {singleton: false});
-        ```
+     twitter === twitter2; //=> true
+     ```
 
-        @method register
-        @param {String} fullName
-        @param {Function} factory
-        @param {Object} options
-      */
-      register: function(fullName, factory, options) {
-        Ember.assert('fullName must be a proper full name', validateFullName(fullName));
+     If singletons are not wanted an optional flag can be provided at lookup.
 
-        if (factory === undefined) {
-          throw new TypeError('Attempting to register an unknown factory: `' + fullName + '`');
-        }
+     ```javascript
+     var registry = new Registry();
+     var container = registry.container();
 
-        var normalizedName = this.normalize(fullName);
+     registry.register('api:twitter', Twitter);
 
-        if (normalizedName in this.cache) {
-          throw new Error('Cannot re-register: `' + fullName +'`, as it has already been looked up.');
-        }
+     var twitter = container.lookup('api:twitter', { singleton: false });
+     var twitter2 = container.lookup('api:twitter', { singleton: false });
 
-        this.registry[normalizedName] = factory;
-        this._options[normalizedName] = (options || {});
-      },
+     twitter === twitter2; //=> false
+     ```
 
-      /**
-        Unregister a fullName
+     @method lookup
+     @param {String} fullName
+     @param {Object} options
+     @return {any}
+     */
+    lookup: function(fullName, options) {
+      Ember['default'].assert('fullName must be a proper full name', this._registry.validateFullName(fullName));
+      return lookup(this, this._registry.normalize(fullName), options);
+    },
 
-        ```javascript
-        var container = new Container();
-        container.register('model:user', User);
+    /**
+     Given a fullName return the corresponding factory.
 
-        container.lookup('model:user') instanceof User //=> true
+     @method lookupFactory
+     @param {String} fullName
+     @return {any}
+     */
+    lookupFactory: function(fullName) {
+      Ember['default'].assert('fullName must be a proper full name', this._registry.validateFullName(fullName));
+      return factoryFor(this, this._registry.normalize(fullName));
+    },
 
-        container.unregister('model:user')
-        container.lookup('model:user') === undefined //=> true
-        ```
+    /**
+     A depth first traversal, destroying the container, its descendant containers and all
+     their managed objects.
 
-        @method unregister
-        @param {String} fullName
-       */
-      unregister: function(fullName) {
-        Ember.assert('fullName must be a proper full name', validateFullName(fullName));
-
-        var normalizedName = this.normalize(fullName);
-
-        delete this.registry[normalizedName];
-        delete this.cache[normalizedName];
-        delete this.factoryCache[normalizedName];
-        delete this.resolveCache[normalizedName];
-        delete this._options[normalizedName];
-        
-          delete this.validationCache[normalizedName];
-        
-      },
+     @method destroy
+     */
+    destroy: function() {
+      eachDestroyable(this, function(item) {
+        if (item.destroy) {
+          item.destroy();
+        }
+      });
 
-      /**
-        Given a fullName return the corresponding factory.
+      this.isDestroyed = true;
+    },
 
-        By default `resolve` will retrieve the factory from
-        its container's registry.
+    /**
+     Clear either the entire cache or just the cache for a particular key.
 
-        ```javascript
-        var container = new Container();
-        container.register('api:twitter', Twitter);
+     @method reset
+     @param {String} fullName optional key to reset; if missing, resets everything
+     */
+    reset: function(fullName) {
+      if (arguments.length > 0) {
+        resetMember(this, this._registry.normalize(fullName));
+      } else {
+        resetCache(this);
+      }
+    }
+  };
+
+  (function exposeRegistryMethods() {
+    var methods = [
+      'register',
+      'unregister',
+      'resolve',
+      'normalize',
+      'typeInjection',
+      'injection',
+      'factoryInjection',
+      'factoryTypeInjection',
+      'has',
+      'options',
+      'optionsForType'
+    ];
 
-        container.resolve('api:twitter') // => Twitter
-        ```
+    function exposeRegistryMethod(method) {
+      Container.prototype[method] = function() {
+        Ember['default'].deprecate(method + ' should be called on the registry instead of the container');
+        return this._registry[method].apply(this._registry, arguments);
+      };
+    }
 
-        Optionally the container can be provided with a custom resolver.
-        If provided, `resolve` will first provide the custom resolver
-        the opportunity to resolve the fullName, otherwise it will fallback
-        to the registry.
+    for (var i = 0, l = methods.length; i < l; i++) {
+      exposeRegistryMethod(methods[i]);
+    }
+  })();
 
-        ```javascript
-        var container = new Container();
-        container.resolver = function(fullName) {
-          // lookup via the module system of choice
-        };
+  function lookup(container, fullName, options) {
+    options = options || {};
 
-        // the twitter factory is added to the module system
-        container.resolve('api:twitter') // => Twitter
-        ```
+    if (container.cache[fullName] && options.singleton !== false) {
+      return container.cache[fullName];
+    }
 
-        @method resolve
-        @param {String} fullName
-        @return {Function} fullName's factory
-      */
-      resolve: function(fullName) {
-        Ember.assert('fullName must be a proper full name', validateFullName(fullName));
-        return resolve(this, this.normalize(fullName));
-      },
+    var value = instantiate(container, fullName);
 
-      /**
-        A hook that can be used to describe how the resolver will
-        attempt to find the factory.
+    if (value === undefined) { return; }
 
-        For example, the default Ember `.describe` returns the full
-        class name (including namespace) where Ember's resolver expects
-        to find the `fullName`.
+    if (container._registry.getOption(fullName, 'singleton') !== false && options.singleton !== false) {
+      container.cache[fullName] = value;
+    }
 
-        @method describe
-        @param {String} fullName
-        @return {string} described fullName
-      */
-      describe: function(fullName) {
-        return fullName;
-      },
+    return value;
+  }
 
-      /**
-        A hook to enable custom fullName normalization behaviour
+  function buildInjections(container) {
+    var hash = {};
 
-        @method normalizeFullName
-        @param {String} fullName
-        @return {string} normalized fullName
-      */
-      normalizeFullName: function(fullName) {
-        return fullName;
-      },
+    if (arguments.length > 1) {
+      var injectionArgs = Array.prototype.slice.call(arguments, 1);
+      var injections = [];
+      var injection;
 
-      /**
-        normalize a fullName based on the applications conventions
+      for (var i = 0, l = injectionArgs.length; i < l; i++) {
+        if (injectionArgs[i]) {
+          injections = injections.concat(injectionArgs[i]);
+        }
+      }
 
-        @method normalize
-        @param {String} fullName
-        @return {string} normalized fullName
-      */
-      normalize: function(fullName) {
-        return this.normalizeCache[fullName] || (
-          this.normalizeCache[fullName] = this.normalizeFullName(fullName)
-        );
-      },
+      container._registry.validateInjections(injections);
 
-      /**
-        @method makeToString
+      for (i = 0, l = injections.length; i < l; i++) {
+        injection = injections[i];
+        hash[injection.property] = lookup(container, injection.fullName);
+      }
+    }
 
-        @param {any} factory
-        @param {string} fullName
-        @return {function} toString function
-      */
-      makeToString: function(factory, fullName) {
-        return factory.toString();
-      },
+    return hash;
+  }
 
-      /**
-        Given a fullName return a corresponding instance.
+  function factoryFor(container, fullName) {
+    var cache = container.factoryCache;
+    if (cache[fullName]) {
+      return cache[fullName];
+    }
+    var registry = container._registry;
+    var factory = registry.resolve(fullName);
+    if (factory === undefined) { return; }
 
-        The default behaviour 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.
+    var type = fullName.split(':')[0];
+    if (!factory || typeof factory.extend !== 'function' || (!Ember['default'].MODEL_FACTORY_INJECTIONS && type === 'model')) {
+      if (factory && typeof factory._onLookup === 'function') {
+        factory._onLookup(fullName);
+      }
 
-        ```javascript
-        var container = new Container();
-        container.register('api:twitter', Twitter);
+      // TODO: think about a 'safe' merge style extension
+      // for now just fallback to create time injection
+      cache[fullName] = factory;
+      return factory;
 
-        var twitter = container.lookup('api:twitter');
+    } else {
+      var injections = injectionsFor(container, fullName);
+      var factoryInjections = factoryInjectionsFor(container, fullName);
 
-        twitter instanceof Twitter; // => true
+      factoryInjections._toString = registry.makeToString(factory, fullName);
 
-        // by default the container will return singletons
-        var twitter2 = container.lookup('api:twitter');
-        twitter2 instanceof Twitter; // => true
+      var injectedFactory = factory.extend(injections);
+      injectedFactory.reopenClass(factoryInjections);
 
-        twitter === twitter2; //=> true
-        ```
+      if (factory && typeof factory._onLookup === 'function') {
+        factory._onLookup(fullName);
+      }
 
-        If singletons are not wanted an optional flag can be provided at lookup.
+      cache[fullName] = injectedFactory;
 
-        ```javascript
-        var container = new Container();
-        container.register('api:twitter', Twitter);
+      return injectedFactory;
+    }
+  }
 
-        var twitter = container.lookup('api:twitter', { singleton: false });
-        var twitter2 = container.lookup('api:twitter', { singleton: false });
+  function injectionsFor(container, fullName) {
+    var registry = container._registry;
+    var splitName = fullName.split(':');
+    var type = splitName[0];
 
-        twitter === twitter2; //=> false
-        ```
+    var injections = buildInjections(container,
+                                     registry.getTypeInjections(type),
+                                     registry.getInjections(fullName));
+    injections._debugContainerKey = fullName;
+    injections.container = container;
 
-        @method lookup
-        @param {String} fullName
-        @param {Object} options
-        @return {any}
-      */
-      lookup: function(fullName, options) {
-        Ember.assert('fullName must be a proper full name', validateFullName(fullName));
-        return lookup(this, this.normalize(fullName), options);
-      },
+    return injections;
+  }
 
-      /**
-        Given a fullName return the corresponding factory.
+  function factoryInjectionsFor(container, fullName) {
+    var registry = container._registry;
+    var splitName = fullName.split(':');
+    var type = splitName[0];
 
-        @method lookupFactory
-        @param {String} fullName
-        @return {any}
-      */
-      lookupFactory: function(fullName) {
-        Ember.assert('fullName must be a proper full name', validateFullName(fullName));
-        return factoryFor(this, this.normalize(fullName));
-      },
+    var factoryInjections = buildInjections(container,
+                                            registry.getFactoryTypeInjections(type),
+                                            registry.getFactoryInjections(fullName));
+    factoryInjections._debugContainerKey = fullName;
 
-      /**
-        Given a fullName check if the container is aware of its factory
-        or singleton instance.
+    return factoryInjections;
+  }
 
-        @method has
-        @param {String} fullName
-        @return {Boolean}
-      */
-      has: function(fullName) {
-        Ember.assert('fullName must be a proper full name', validateFullName(fullName));
-        return has(this, this.normalize(fullName));
-      },
+  function instantiate(container, fullName) {
+    var factory = factoryFor(container, fullName);
+    var lazyInjections, validationCache;
 
-      /**
-        Allow registering options for all factories of a type.
+    if (container._registry.getOption(fullName, 'instantiate') === false) {
+      return factory;
+    }
 
-        ```javascript
-        var container = new Container();
+    if (factory) {
+      if (typeof factory.create !== 'function') {
+        throw new Error('Failed to create an instance of \'' + fullName + '\'. ' +
+        'Most likely an improperly defined class or an invalid module export.');
+      }
 
-        // if all of type `connection` must not be singletons
-        container.optionsForType('connection', { singleton: false });
+      validationCache = container.validationCache;
 
-        container.register('connection:twitter', TwitterConnection);
-        container.register('connection:facebook', FacebookConnection);
+      // Ensure that all lazy injections are valid at instantiation time
+      if (!validationCache[fullName] && typeof factory._lazyInjections === 'function') {
+        lazyInjections = factory._lazyInjections();
+        lazyInjections = container._registry.normalizeInjectionsHash(lazyInjections);
 
-        var twitter = container.lookup('connection:twitter');
-        var twitter2 = container.lookup('connection:twitter');
+        container._registry.validateInjections(lazyInjections);
+      }
 
-        twitter === twitter2; // => false
+      validationCache[fullName] = true;
 
-        var facebook = container.lookup('connection:facebook');
-        var facebook2 = container.lookup('connection:facebook');
+      if (typeof factory.extend === 'function') {
+        // assume the factory was extendable and is already injected
+        return factory.create();
+      } else {
+        // assume the factory was extendable
+        // to create time injections
+        // TODO: support new'ing for instantiation and merge injections for pure JS Functions
+        return factory.create(injectionsFor(container, fullName));
+      }
+    }
+  }
 
-        facebook === facebook2; // => false
-        ```
+  function eachDestroyable(container, callback) {
+    var cache = container.cache;
+    var keys = emberKeys['default'](cache);
+    var key, value;
 
-        @method optionsForType
-        @param {String} type
-        @param {Object} options
-      */
-      optionsForType: function(type, options) {
-        if (this.parent) { illegalChildOperation('optionsForType'); }
+    for (var i = 0, l = keys.length; i < l; i++) {
+      key = keys[i];
+      value = cache[key];
 
-        this._typeOptions[type] = options;
-      },
+      if (container._registry.getOption(key, 'instantiate') !== false) {
+        callback(value);
+      }
+    }
+  }
 
-      /**
-        @method options
-        @param {String} fullName
-        @param {Object} options
-      */
-      options: function(fullName, options) {
-        options = options || {};
-        var normalizedName = this.normalize(fullName);
-        this._options[normalizedName] = options;
-      },
+  function resetCache(container) {
+    eachDestroyable(container, function(value) {
+      if (value.destroy) {
+        value.destroy();
+      }
+    });
 
-      /**
-        Used only via `injection`.
+    container.cache.dict = dictionary['default'](null);
+  }
 
-        Provides a specialized form of injection, specifically enabling
-        all objects of one type to be injected with a reference to another
-        object.
+  function resetMember(container, fullName) {
+    var member = container.cache[fullName];
 
-        For example, provided each object of type `controller` needed a `router`.
-        one would do the following:
+    delete container.factoryCache[fullName];
 
-        ```javascript
-        var container = new Container();
+    if (member) {
+      delete container.cache[fullName];
 
-        container.register('router:main', Router);
-        container.register('controller:user', UserController);
-        container.register('controller:post', PostController);
+      if (member.destroy) {
+        member.destroy();
+      }
+    }
+  }
 
-        container.typeInjection('controller', 'router', 'router:main');
+  exports['default'] = Container;
 
-        var user = container.lookup('controller:user');
-        var post = container.lookup('controller:post');
+});
+enifed('container/registry', ['exports', 'ember-metal/core', 'ember-metal/dictionary', './container'], function (exports, Ember, dictionary, Container) {
 
-        user.router instanceof Router; //=> true
-        post.router instanceof Router; //=> true
+  'use strict';
 
-        // both controllers share the same router
-        user.router === post.router; //=> true
-        ```
+  var VALID_FULL_NAME_REGEXP = /^[^:]+.+:[^:]+$/;
 
-        @private
-        @method typeInjection
-        @param {String} type
-        @param {String} property
-        @param {String} fullName
-      */
-      typeInjection: function(type, property, fullName) {
-        Ember.assert('fullName must be a proper full name', validateFullName(fullName));
+  var instanceInitializersFeatureEnabled;
 
-        if (this.parent) { illegalChildOperation('typeInjection'); }
+  /**
+   A lightweight registry used to store factory and option information keyed
+   by type.
 
-        var fullNameType = fullName.split(':')[0];
-        if (fullNameType === type) {
-          throw new Error('Cannot inject a `' + fullName +
-                          '` on other ' + type +
-                          '(s). Register the `' + fullName +
-                          '` as a different type and perform the typeInjection.');
-        }
+   A `Registry` stores the factory and option information needed by a
+   `Container` to instantiate and cache objects.
 
-        addTypeInjection(this.typeInjections, type, property, fullName);
-      },
+   The public API for `Registry` is still in flux and should not be considered
+   stable.
 
-      /**
-        Defines injection rules.
+   @private
+   @class Registry
+   @since 1.11.0
+  */
+  function Registry(options) {
+    this.fallback = options && options.fallback ? options.fallback : null;
 
-        These rules are used to inject dependencies onto objects when they
-        are instantiated.
+    this.resolver = options && options.resolver ? options.resolver : function() {};
 
-        Two forms of injections are possible:
+    this.registrations  = dictionary['default'](options && options.registrations ? options.registrations : null);
 
-        * Injecting one fullName on another fullName
-        * Injecting one fullName on a type
+    this._typeInjections        = dictionary['default'](null);
+    this._injections            = dictionary['default'](null);
+    this._factoryTypeInjections = dictionary['default'](null);
+    this._factoryInjections     = dictionary['default'](null);
 
-        Example:
+    this._normalizeCache        = dictionary['default'](null);
+    this._resolveCache          = dictionary['default'](null);
 
-        ```javascript
-        var container = new Container();
+    this._options               = dictionary['default'](null);
+    this._typeOptions           = dictionary['default'](null);
+  }
 
-        container.register('source:main', Source);
-        container.register('model:user', User);
-        container.register('model:post', Post);
+  Registry.prototype = {
+    /**
+     A backup registry for resolving registrations when no matches can be found.
 
-        // injecting one fullName on another fullName
-        // eg. each user model gets a post model
-        container.injection('model:user', 'post', 'model:post');
+     @property fallback
+     @type Registry
+     */
+    fallback: null,
 
-        // injecting one fullName on another type
-        container.injection('model', 'source', 'source:main');
+    /**
+     @property resolver
+     @type function
+     */
+    resolver: null,
 
-        var user = container.lookup('model:user');
-        var post = container.lookup('model:post');
+    /**
+     @property registrations
+     @type InheritingDict
+     */
+    registrations: null,
 
-        user.source instanceof Source; //=> true
-        post.source instanceof Source; //=> true
+    /**
+     @private
 
-        user.post instanceof Post; //=> true
+     @property _typeInjections
+     @type InheritingDict
+     */
+    _typeInjections: null,
 
-        // and both models share the same source
-        user.source === post.source; //=> true
-        ```
+    /**
+     @private
 
-        @method injection
-        @param {String} factoryName
-        @param {String} property
-        @param {String} injectionName
-      */
-      injection: function(fullName, property, injectionName) {
-        if (this.parent) { illegalChildOperation('injection'); }
+     @property _injections
+     @type InheritingDict
+     */
+    _injections: null,
 
-        validateFullName(injectionName);
-        var normalizedInjectionName = this.normalize(injectionName);
+    /**
+     @private
 
-        if (fullName.indexOf(':') === -1) {
-          return this.typeInjection(fullName, property, normalizedInjectionName);
-        }
+     @property _factoryTypeInjections
+     @type InheritingDict
+     */
+    _factoryTypeInjections: null,
 
-        Ember.assert('fullName must be a proper full name', validateFullName(fullName));
-        var normalizedName = this.normalize(fullName);
+    /**
+     @private
 
-        if (this.cache[normalizedName]) {
-          throw new Error("Attempted to register an injection for a type that has already been looked up. ('" +
-                          normalizedName + "', '" +
-                          property + "', '" +
-                          injectionName + "')");
-        }
+     @property _factoryInjections
+     @type InheritingDict
+     */
+    _factoryInjections: null,
 
-        addInjection(initRules(this.injections, normalizedName), property, normalizedInjectionName);
-      },
+    /**
+     @private
 
+     @property _normalizeCache
+     @type InheritingDict
+     */
+    _normalizeCache: null,
 
-      /**
-        Used only via `factoryInjection`.
+    /**
+     @private
 
-        Provides a specialized form of injection, specifically enabling
-        all factory of one type to be injected with a reference to another
-        object.
+     @property _resolveCache
+     @type InheritingDict
+     */
+    _resolveCache: null,
 
-        For example, provided each factory of type `model` needed a `store`.
-        one would do the following:
+    /**
+     @private
 
-        ```javascript
-        var container = new Container();
+     @property _options
+     @type InheritingDict
+     */
+    _options: null,
 
-        container.register('store:main', SomeStore);
+    /**
+     @private
 
-        container.factoryTypeInjection('model', 'store', 'store:main');
+     @property _typeOptions
+     @type InheritingDict
+     */
+    _typeOptions: null,
 
-        var store = container.lookup('store:main');
-        var UserFactory = container.lookupFactory('model:user');
+    /**
+     The first container created for this registry.
 
-        UserFactory.store instanceof SomeStore; //=> true
-        ```
+     This allows deprecated access to `lookup` and `lookupFactory` to avoid
+     breaking compatibility for Ember 1.x initializers.
 
-        @private
-        @method factoryTypeInjection
-        @param {String} type
-        @param {String} property
-        @param {String} fullName
-      */
-      factoryTypeInjection: function(type, property, fullName) {
-        if (this.parent) { illegalChildOperation('factoryTypeInjection'); }
+     @private
+     @property _defaultContainer
+     @type Container
+     */
+    _defaultContainer: null,
 
-        addTypeInjection(this.factoryTypeInjections, type, property, this.normalize(fullName));
-      },
+    /**
+     Creates a container based on this registry.
 
-      /**
-        Defines factory injection rules.
+     @method container
+     @param {Object} options
+     @return {Container} created container
+     */
+    container: function(options) {
+      var container = new Container['default'](this, options);
 
-        Similar to regular injection rules, but are run against factories, via
-        `Container#lookupFactory`.
+      // 2.0TODO - remove `registerContainer`
+      this.registerContainer(container);
 
-        These rules are used to inject objects onto factories when they
-        are looked up.
+      return container;
+    },
 
-        Two forms of injections are possible:
+    /**
+     Register the first container created for a registery to allow deprecated
+     access to its `lookup` and `lookupFactory` methods to avoid breaking
+     compatibility for Ember 1.x initializers.
 
-      * Injecting one fullName on another fullName
-      * Injecting one fullName on a type
+     2.0TODO: Remove this method. The bookkeeping is only needed to support
+              deprecated behavior.
 
-        Example:
+     @param {Container} newly created container
+     */
+    registerContainer: function(container) {
+      if (!this._defaultContainer) {
+        this._defaultContainer = container;
+      }
+      if (this.fallback) {
+        this.fallback.registerContainer(container);
+      }
+    },
 
-        ```javascript
-        var container = new Container();
+    lookup: function(fullName, options) {
+      Ember['default'].assert('Create a container on the registry (with `registry.container()`) before calling `lookup`.', this._defaultContainer);
 
-        container.register('store:main', Store);
-        container.register('store:secondary', OtherStore);
-        container.register('model:user', User);
-        container.register('model:post', Post);
+      if (instanceInitializersFeatureEnabled) {
+        Ember['default'].deprecate(
+          '`lookup` was called on a Registry. The `initializer` API no longer receives a container, and you should use an `instanceInitializer` to look up objects from the container.',
+          false,
+          { url: "http://emberjs.com/guides/deprecations#toc_access-to-instances-in-initializers" }
+        );
+      }
 
-        // injecting one fullName on another type
-        container.factoryInjection('model', 'store', 'store:main');
+      return this._defaultContainer.lookup(fullName, options);
+    },
 
-        // injecting one fullName on another fullName
-        container.factoryInjection('model:post', 'secondaryStore', 'store:secondary');
+    lookupFactory: function(fullName) {
+      Ember['default'].assert('Create a container on the registry (with `registry.container()`) before calling `lookupFactory`.', this._defaultContainer);
 
-        var UserFactory = container.lookupFactory('model:user');
-        var PostFactory = container.lookupFactory('model:post');
-        var store = container.lookup('store:main');
+      if (instanceInitializersFeatureEnabled) {
+        Ember['default'].deprecate(
+          '`lookupFactory` was called on a Registry. The `initializer` API no longer receives a container, and you should use an `instanceInitializer` to look up objects from the container.',
+          false,
+          { url: "http://emberjs.com/guides/deprecations#toc_access-to-instances-in-initializers" }
+        );
+      }
 
-        UserFactory.store instanceof Store; //=> true
-        UserFactory.secondaryStore instanceof OtherStore; //=> false
+      return this._defaultContainer.lookupFactory(fullName);
+    },
 
-        PostFactory.store instanceof Store; //=> true
-        PostFactory.secondaryStore instanceof OtherStore; //=> true
+    /**
+     Registers a factory for later injection.
 
-        // and both models share the same source instance
-        UserFactory.store === PostFactory.store; //=> true
-        ```
+     Example:
 
-        @method factoryInjection
-        @param {String} factoryName
-        @param {String} property
-        @param {String} injectionName
-      */
-      factoryInjection: function(fullName, property, injectionName) {
-        if (this.parent) { illegalChildOperation('injection'); }
+     ```javascript
+     var registry = new Registry();
 
-        var normalizedName = this.normalize(fullName);
-        var normalizedInjectionName = this.normalize(injectionName);
+     registry.register('model:user', Person, {singleton: false });
+     registry.register('fruit:favorite', Orange);
+     registry.register('communication:main', Email, {singleton: false});
+     ```
 
-        validateFullName(injectionName);
+     @method register
+     @param {String} fullName
+     @param {Function} factory
+     @param {Object} options
+     */
+    register: function(fullName, factory, options) {
+      Ember['default'].assert('fullName must be a proper full name', this.validateFullName(fullName));
 
-        if (fullName.indexOf(':') === -1) {
-          return this.factoryTypeInjection(normalizedName, property, normalizedInjectionName);
-        }
+      if (factory === undefined) {
+        throw new TypeError('Attempting to register an unknown factory: `' + fullName + '`');
+      }
 
-        Ember.assert('fullName must be a proper full name', validateFullName(fullName));
+      var normalizedName = this.normalize(fullName);
 
-        if (this.factoryCache[normalizedName]) {
-          throw new Error('Attempted to register a factoryInjection for a type that has already ' +
-            'been looked up. (\'' + normalizedName + '\', \'' + property + '\', \'' + injectionName + '\')');
-        }
+      if (this._resolveCache[normalizedName]) {
+        throw new Error('Cannot re-register: `' + fullName +'`, as it has already been resolved.');
+      }
 
-        addInjection(initRules(this.factoryInjections, normalizedName), property, normalizedInjectionName);
-      },
+      this.registrations[normalizedName] = factory;
+      this._options[normalizedName] = (options || {});
+    },
 
-      /**
-        A depth first traversal, destroying the container, its descendant containers and all
-        their managed objects.
+    /**
+     Unregister a fullName
 
-        @method destroy
-      */
-      destroy: function() {
-        for (var i = 0, length = this.children.length; i < length; i++) {
-          this.children[i].destroy();
-        }
+     ```javascript
+     var registry = new Registry();
+     registry.register('model:user', User);
 
-        this.children = [];
+     registry.resolve('model:user').create() instanceof User //=> true
 
-        eachDestroyable(this, function(item) {
-          item.destroy();
-        });
+     registry.unregister('model:user')
+     registry.resolve('model:user') === undefined //=> true
+     ```
 
-        this.parent = undefined;
-        this.isDestroyed = true;
-      },
+     @method unregister
+     @param {String} fullName
+     */
+    unregister: function(fullName) {
+      Ember['default'].assert('fullName must be a proper full name', this.validateFullName(fullName));
 
-      /**
-        @method reset
-      */
-      reset: function() {
-        for (var i = 0, length = this.children.length; i < length; i++) {
-          resetCache(this.children[i]);
-        }
+      var normalizedName = this.normalize(fullName);
 
-        resetCache(this);
-      }
-    };
+      delete this.registrations[normalizedName];
+      delete this._resolveCache[normalizedName];
+      delete this._options[normalizedName];
+    },
+
+    /**
+     Given a fullName return the corresponding factory.
 
-    function resolve(container, normalizedName) {
-      var cached = container.resolveCache[normalizedName];
-      if (cached) { return cached; }
+     By default `resolve` will retrieve the factory from
+     the registry.
 
-      var resolved = container.resolver(normalizedName) || container.registry[normalizedName];
-      container.resolveCache[normalizedName] = resolved;
+     ```javascript
+     var registry = new Registry();
+     registry.register('api:twitter', Twitter);
 
-      return resolved;
-    }
+     registry.resolve('api:twitter') // => Twitter
+     ```
 
-    function has(container, fullName){
-      if (container.cache[fullName]) {
-        return true;
-      }
+     Optionally the registry can be provided with a custom resolver.
+     If provided, `resolve` will first provide the custom resolver
+     the opportunity to resolve the fullName, otherwise it will fallback
+     to the registry.
 
-      return container.resolve(fullName) !== undefined;
-    }
+     ```javascript
+     var registry = new Registry();
+     registry.resolver = function(fullName) {
+        // lookup via the module system of choice
+      };
 
-    function lookup(container, fullName, options) {
-      options = options || {};
+     // the twitter factory is added to the module system
+     registry.resolve('api:twitter') // => Twitter
+     ```
 
-      if (container.cache[fullName] && options.singleton !== false) {
-        return container.cache[fullName];
+     @method resolve
+     @param {String} fullName
+     @return {Function} fullName's factory
+     */
+    resolve: function(fullName) {
+      Ember['default'].assert('fullName must be a proper full name', this.validateFullName(fullName));
+      var factory = resolve(this, this.normalize(fullName));
+      if (factory === undefined && this.fallback) {
+        factory = this.fallback.resolve(fullName);
       }
+      return factory;
+    },
 
-      var value = instantiate(container, fullName);
+    /**
+     A hook that can be used to describe how the resolver will
+     attempt to find the factory.
 
-      if (value === undefined) { return; }
+     For example, the default Ember `.describe` returns the full
+     class name (including namespace) where Ember's resolver expects
+     to find the `fullName`.
 
-      if (isSingleton(container, fullName) && options.singleton !== false) {
-        container.cache[fullName] = value;
-      }
+     @method describe
+     @param {String} fullName
+     @return {string} described fullName
+     */
+    describe: function(fullName) {
+      return fullName;
+    },
 
-      return value;
-    }
+    /**
+     A hook to enable custom fullName normalization behaviour
 
-    function illegalChildOperation(operation) {
-      throw new Error(operation + ' is not currently supported on child containers');
-    }
+     @method normalizeFullName
+     @param {String} fullName
+     @return {string} normalized fullName
+     */
+    normalizeFullName: function(fullName) {
+      return fullName;
+    },
 
-    function isSingleton(container, fullName) {
-      var singleton = option(container, fullName, 'singleton');
+    /**
+     normalize a fullName based on the applications conventions
 
-      return singleton !== false;
-    }
+     @method normalize
+     @param {String} fullName
+     @return {string} normalized fullName
+     */
+    normalize: function(fullName) {
+      return this._normalizeCache[fullName] || (
+          this._normalizeCache[fullName] = this.normalizeFullName(fullName)
+        );
+    },
 
-    function buildInjections(container, injections) {
-      var hash = {};
+    /**
+     @method makeToString
 
-      if (!injections) { return hash; }
+     @param {any} factory
+     @param {string} fullName
+     @return {function} toString function
+     */
+    makeToString: function(factory, fullName) {
+      return factory.toString();
+    },
 
-      validateInjections(container, injections);
+    /**
+     Given a fullName check if the container is aware of its factory
+     or singleton instance.
 
-      var injection;
+     @method has
+     @param {String} fullName
+     @return {Boolean}
+     */
+    has: function(fullName) {
+      Ember['default'].assert('fullName must be a proper full name', this.validateFullName(fullName));
+      return has(this, this.normalize(fullName));
+    },
 
-      for (var i = 0, length = injections.length; i < length; i++) {
-        injection = injections[i];
-        hash[injection.property] = lookup(container, injection.fullName);
-      }
+    /**
+     Allow registering options for all factories of a type.
 
-      return hash;
-    }
+     ```javascript
+     var registry = new Registry();
+     var container = registry.container();
 
-    function validateInjections(container, injections) {
-      if (!injections) { return; }
+     // if all of type `connection` must not be singletons
+     registry.optionsForType('connection', { singleton: false });
 
-      var fullName;
+     registry.register('connection:twitter', TwitterConnection);
+     registry.register('connection:facebook', FacebookConnection);
 
-      for (var i = 0, length = injections.length; i < length; i++) {
-        fullName = injections[i].fullName;
+     var twitter = container.lookup('connection:twitter');
+     var twitter2 = container.lookup('connection:twitter');
 
-        if (!container.has(fullName)) {
-          throw new Error('Attempting to inject an unknown injection: `' + fullName + '`');
-        }
+     twitter === twitter2; // => false
+
+     var facebook = container.lookup('connection:facebook');
+     var facebook2 = container.lookup('connection:facebook');
+
+     facebook === facebook2; // => false
+     ```
+
+     @method optionsForType
+     @param {String} type
+     @param {Object} options
+     */
+    optionsForType: function(type, options) {
+      this._typeOptions[type] = options;
+    },
+
+    getOptionsForType: function(type) {
+      var optionsForType = this._typeOptions[type];
+      if (optionsForType === undefined && this.fallback) {
+        optionsForType = this.fallback.getOptionsForType(type);
       }
-    }
+      return optionsForType;
+    },
+
+    /**
+     @method options
+     @param {String} fullName
+     @param {Object} options
+     */
+    options: function(fullName, options) {
+      options = options || {};
+      var normalizedName = this.normalize(fullName);
+      this._options[normalizedName] = options;
+    },
+
+    getOptions: function(fullName) {
+      var normalizedName = this.normalize(fullName);
+      var options = this._options[normalizedName];
+      if (options === undefined && this.fallback) {
+        options = this.fallback.getOptions(fullName);
+      }
+      return options;
+    },
 
-    function option(container, fullName, optionName) {
-      var options = container._options[fullName];
+    getOption: function(fullName, optionName) {
+      var options = this._options[fullName];
 
       if (options && options[optionName] !== undefined) {
         return options[optionName];
       }
 
       var type = fullName.split(':')[0];
-      options = container._typeOptions[type];
+      options = this._typeOptions[type];
 
-      if (options) {
+      if (options && options[optionName] !== undefined) {
         return options[optionName];
-      }
-    }
 
-    function factoryFor(container, fullName) {
-      var cache = container.factoryCache;
-      if (cache[fullName]) {
-        return cache[fullName];
+      } else if (this.fallback) {
+        return this.fallback.getOption(fullName, optionName);
       }
-      var factory = container.resolve(fullName);
-      if (factory === undefined) { return; }
+    },
 
-      var type = fullName.split(':')[0];
-      if (!factory || typeof factory.extend !== 'function' || (!Ember.MODEL_FACTORY_INJECTIONS && type === 'model')) {
-        if (factory && typeof factory._onLookup === 'function') {
-          factory._onLookup(fullName);
-        }
+    option: function(fullName, optionName) {
+      Ember['default'].deprecate('`Registry.option()` has been deprecated. Call `Registry.getOption()` instead.');
+      return this.getOption(fullName, optionName);
+    },
 
-        // TODO: think about a 'safe' merge style extension
-        // for now just fallback to create time injection
-        cache[fullName] = factory;
-        return factory;
-      } else {
-        var injections = injectionsFor(container, fullName);
-        var factoryInjections = factoryInjectionsFor(container, fullName);
+    /**
+     Used only via `injection`.
 
-        factoryInjections._toString = container.makeToString(factory, fullName);
+     Provides a specialized form of injection, specifically enabling
+     all objects of one type to be injected with a reference to another
+     object.
 
-        var injectedFactory = factory.extend(injections);
-        injectedFactory.reopenClass(factoryInjections);
+     For example, provided each object of type `controller` needed a `router`.
+     one would do the following:
 
-        if (factory && typeof factory._onLookup === 'function') {
-          factory._onLookup(fullName);
-        }
+     ```javascript
+     var registry = new Registry();
+     var container = registry.container();
+
+     registry.register('router:main', Router);
+     registry.register('controller:user', UserController);
+     registry.register('controller:post', PostController);
+
+     registry.typeInjection('controller', 'router', 'router:main');
+
+     var user = container.lookup('controller:user');
+     var post = container.lookup('controller:post');
+
+     user.router instanceof Router; //=> true
+     post.router instanceof Router; //=> true
+
+     // both controllers share the same router
+     user.router === post.router; //=> true
+     ```
 
-        cache[fullName] = injectedFactory;
+     @private
+     @method typeInjection
+     @param {String} type
+     @param {String} property
+     @param {String} fullName
+     */
+    typeInjection: function(type, property, fullName) {
+      Ember['default'].assert('fullName must be a proper full name', this.validateFullName(fullName));
 
-        return injectedFactory;
+      var fullNameType = fullName.split(':')[0];
+      if (fullNameType === type) {
+        throw new Error('Cannot inject a `' + fullName +
+        '` on other ' + type + '(s).');
       }
-    }
 
-    function injectionsFor(container, fullName) {
-      var splitName = fullName.split(':');
-      var type = splitName[0];
-      var injections = [];
+      var injections = this._typeInjections[type] ||
+                       (this._typeInjections[type] = []);
+
+      injections.push({
+        property: property,
+        fullName: fullName
+      });
+    },
 
-      injections = injections.concat(container.typeInjections[type] || []);
-      injections = injections.concat(container.injections[fullName] || []);
+    /**
+     Defines injection rules.
 
-      injections = buildInjections(container, injections);
-      injections._debugContainerKey = fullName;
-      injections.container = container;
+     These rules are used to inject dependencies onto objects when they
+     are instantiated.
 
-      return injections;
-    }
+     Two forms of injections are possible:
 
-    function factoryInjectionsFor(container, fullName) {
-      var splitName = fullName.split(':');
-      var type = splitName[0];
-      var factoryInjections = [];
+     * Injecting one fullName on another fullName
+     * Injecting one fullName on a type
 
-      factoryInjections = factoryInjections.concat(container.factoryTypeInjections[type] || []);
-      factoryInjections = factoryInjections.concat(container.factoryInjections[fullName] || []);
+     Example:
 
-      factoryInjections = buildInjections(container, factoryInjections);
-      factoryInjections._debugContainerKey = fullName;
+     ```javascript
+     var registry = new Registry();
+     var container = registry.container();
 
-      return factoryInjections;
-    }
+     registry.register('source:main', Source);
+     registry.register('model:user', User);
+     registry.register('model:post', Post);
 
-    function normalizeInjectionsHash(hash) {
-      var injections = [];
+     // injecting one fullName on another fullName
+     // eg. each user model gets a post model
+     registry.injection('model:user', 'post', 'model:post');
 
-      for (var key in hash) {
-        if (hash.hasOwnProperty(key)) {
-          Ember.assert("Expected a proper full name, given '" + hash[key] + "'", validateFullName(hash[key]));
+     // injecting one fullName on another type
+     registry.injection('model', 'source', 'source:main');
 
-          addInjection(injections, key, hash[key]);
-        }
-      }
+     var user = container.lookup('model:user');
+     var post = container.lookup('model:post');
 
-      return injections;
-    }
+     user.source instanceof Source; //=> true
+     post.source instanceof Source; //=> true
+
+     user.post instanceof Post; //=> true
+
+     // and both models share the same source
+     user.source === post.source; //=> true
+     ```
 
-    function instantiate(container, fullName) {
-      var factory = factoryFor(container, fullName);
-      var lazyInjections, validationCache;
+     @method injection
+     @param {String} factoryName
+     @param {String} property
+     @param {String} injectionName
+     */
+    injection: function(fullName, property, injectionName) {
+      this.validateFullName(injectionName);
+      var normalizedInjectionName = this.normalize(injectionName);
 
-      if (option(container, fullName, 'instantiate') === false) {
-        return factory;
+      if (fullName.indexOf(':') === -1) {
+        return this.typeInjection(fullName, property, normalizedInjectionName);
       }
 
-      if (factory) {
-        if (typeof factory.create !== 'function') {
-          throw new Error('Failed to create an instance of \'' + fullName + '\'. ' +
-            'Most likely an improperly defined class or an invalid module export.');
-        }
+      Ember['default'].assert('fullName must be a proper full name', this.validateFullName(fullName));
+      var normalizedName = this.normalize(fullName);
 
-        
-          validationCache = container.validationCache;
+      var injections = this._injections[normalizedName] ||
+                       (this._injections[normalizedName] = []);
 
-          // Ensure that all lazy injections are valid at instantiation time
-          if (!validationCache[fullName] && typeof factory._lazyInjections === 'function') {
-            lazyInjections = factory._lazyInjections();
+      injections.push({
+        property: property,
+        fullName: normalizedInjectionName
+      });
+    },
 
-            validateInjections(container, normalizeInjectionsHash(lazyInjections));
-          }
 
-          validationCache[fullName] = true;
-        
+    /**
+     Used only via `factoryInjection`.
 
-        if (typeof factory.extend === 'function') {
-          // assume the factory was extendable and is already injected
-          return factory.create();
-        } else {
-          // assume the factory was extendable
-          // to create time injections
-          // TODO: support new'ing for instantiation and merge injections for pure JS Functions
-          return factory.create(injectionsFor(container, fullName));
-        }
-      }
-    }
+     Provides a specialized form of injection, specifically enabling
+     all factory of one type to be injected with a reference to another
+     object.
 
-    function eachDestroyable(container, callback) {
-      var cache = container.cache;
-      var keys = emberKeys(cache);
-      var key, value;
+     For example, provided each factory of type `model` needed a `store`.
+     one would do the following:
 
-      for (var i = 0, l = keys.length; i < l; i++) {
-        key = keys[i];
-        value = cache[key];
+     ```javascript
+     var registry = new Registry();
 
-        if (option(container, key, 'instantiate') !== false) {
-          callback(value);
-        }
-      }
-    }
+     registry.register('store:main', SomeStore);
 
-    function resetCache(container) {
-      eachDestroyable(container, function(value) {
-        value.destroy();
+     registry.factoryTypeInjection('model', 'store', 'store:main');
+
+     var store = registry.lookup('store:main');
+     var UserFactory = registry.lookupFactory('model:user');
+
+     UserFactory.store instanceof SomeStore; //=> true
+     ```
+
+     @private
+     @method factoryTypeInjection
+     @param {String} type
+     @param {String} property
+     @param {String} fullName
+     */
+    factoryTypeInjection: function(type, property, fullName) {
+      var injections = this._factoryTypeInjections[type] ||
+                       (this._factoryTypeInjections[type] = []);
+
+      injections.push({
+        property: property,
+        fullName: this.normalize(fullName)
       });
+    },
 
-      container.cache.dict = dictionary(null);
-    }
+    /**
+     Defines factory injection rules.
+
+     Similar to regular injection rules, but are run against factories, via
+     `Registry#lookupFactory`.
+
+     These rules are used to inject objects onto factories when they
+     are looked up.
+
+     Two forms of injections are possible:
 
-    function addTypeInjection(rules, type, property, fullName) {
-      var injections = rules[type];
+     * Injecting one fullName on another fullName
+     * Injecting one fullName on a type
 
-      if (!injections) {
-        injections = [];
-        rules[type] = injections;
+     Example:
+
+     ```javascript
+     var registry = new Registry();
+     var container = registry.container();
+
+     registry.register('store:main', Store);
+     registry.register('store:secondary', OtherStore);
+     registry.register('model:user', User);
+     registry.register('model:post', Post);
+
+     // injecting one fullName on another type
+     registry.factoryInjection('model', 'store', 'store:main');
+
+     // injecting one fullName on another fullName
+     registry.factoryInjection('model:post', 'secondaryStore', 'store:secondary');
+
+     var UserFactory = container.lookupFactory('model:user');
+     var PostFactory = container.lookupFactory('model:post');
+     var store = container.lookup('store:main');
+
+     UserFactory.store instanceof Store; //=> true
+     UserFactory.secondaryStore instanceof OtherStore; //=> false
+
+     PostFactory.store instanceof Store; //=> true
+     PostFactory.secondaryStore instanceof OtherStore; //=> true
+
+     // and both models share the same source instance
+     UserFactory.store === PostFactory.store; //=> true
+     ```
+
+     @method factoryInjection
+     @param {String} factoryName
+     @param {String} property
+     @param {String} injectionName
+     */
+    factoryInjection: function(fullName, property, injectionName) {
+      var normalizedName = this.normalize(fullName);
+      var normalizedInjectionName = this.normalize(injectionName);
+
+      this.validateFullName(injectionName);
+
+      if (fullName.indexOf(':') === -1) {
+        return this.factoryTypeInjection(normalizedName, property, normalizedInjectionName);
       }
 
+      var injections = this._factoryInjections[normalizedName] || (this._factoryInjections[normalizedName] = []);
+
       injections.push({
         property: property,
-        fullName: fullName
+        fullName: normalizedInjectionName
       });
-    }
+    },
 
-    var VALID_FULL_NAME_REGEXP = /^[^:]+.+:[^:]+$/;
-    function validateFullName(fullName) {
+    validateFullName: function(fullName) {
       if (!VALID_FULL_NAME_REGEXP.test(fullName)) {
         throw new TypeError('Invalid Fullname, expected: `type:name` got: ' + fullName);
       }
       return true;
-    }
+    },
 
-    function initRules(rules, factoryName) {
-      return rules[factoryName] || (rules[factoryName] = []);
-    }
+    validateInjections: function(injections) {
+      if (!injections) { return; }
 
-    function addInjection(injections, property, injectionName) {
-      injections.push({
-        property: property,
-        fullName: injectionName
-      });
+      var fullName;
+
+      for (var i = 0, length = injections.length; i < length; i++) {
+        fullName = injections[i].fullName;
+
+        if (!this.has(fullName)) {
+          throw new Error('Attempting to inject an unknown injection: `' + fullName + '`');
+        }
+      }
+    },
+
+    normalizeInjectionsHash: function(hash) {
+      var injections = [];
+
+      for (var key in hash) {
+        if (hash.hasOwnProperty(key)) {
+          Ember['default'].assert("Expected a proper full name, given '" + hash[key] + "'", this.validateFullName(hash[key]));
+
+          injections.push({
+            property: key,
+            fullName: hash[key]
+          });
+        }
+      }
+
+      return injections;
+    },
+
+    getInjections: function(fullName) {
+      var injections = this._injections[fullName] || [];
+      if (this.fallback) {
+        injections = injections.concat(this.fallback.getInjections(fullName));
+      }
+      return injections;
+    },
+
+    getTypeInjections: function(type) {
+      var injections = this._typeInjections[type] || [];
+      if (this.fallback) {
+        injections = injections.concat(this.fallback.getTypeInjections(type));
+      }
+      return injections;
+    },
+
+    getFactoryInjections: function(fullName) {
+      var injections = this._factoryInjections[fullName] || [];
+      if (this.fallback) {
+        injections = injections.concat(this.fallback.getFactoryInjections(fullName));
+      }
+      return injections;
+    },
+
+    getFactoryTypeInjections: function(type) {
+      var injections = this._factoryTypeInjections[type] || [];
+      if (this.fallback) {
+        injections = injections.concat(this.fallback.getFactoryTypeInjections(type));
+      }
+      return injections;
     }
+  };
 
-    __exports__["default"] = Container;
-  });
+  function resolve(registry, normalizedName) {
+    var cached = registry._resolveCache[normalizedName];
+    if (cached) { return cached; }
+
+    var resolved = registry.resolver(normalizedName) || registry.registrations[normalizedName];
+    registry._resolveCache[normalizedName] = resolved;
+
+    return resolved;
+  }
+
+  function has(registry, fullName) {
+    return registry.resolve(fullName) !== undefined;
+  }
+
+  exports['default'] = Registry;
+
+});
 enifed("dag-map",
   ["exports"],
   function(__exports__) {
@@ -2205,45174 +2452,41376 @@ enifed("dag-map.umd",
       this['DAG'] = DAG;
     }
   });
-enifed("ember-application",
-  ["ember-metal/core","ember-runtime/system/lazy_load","ember-application/system/resolver","ember-application/system/application","ember-application/ext/controller"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var runLoadHooks = __dependency2__.runLoadHooks;
-
-    /**
-    Ember Application
-
-    @module ember
-    @submodule ember-application
-    @requires ember-views, ember-routing
-    */
-
-    var Resolver = __dependency3__.Resolver;
-    var DefaultResolver = __dependency3__["default"];
-    var Application = __dependency4__["default"];
-    // side effect of extending ControllerMixin
-
-    Ember.Application = Application;
-    Ember.Resolver = Resolver;
-    Ember.DefaultResolver = DefaultResolver;
-
-    runLoadHooks('Ember.Application', Application);
-  });
-enifed("ember-application/ext/controller",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/error","ember-metal/utils","ember-metal/computed","ember-runtime/mixins/controller","ember-routing/system/controller_for","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
+enifed("dom-helper",
+  ["./morph-range","./morph-attr","./dom-helper/build-html-dom","./dom-helper/classes","./dom-helper/prop","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
     "use strict";
-    /**
-    @module ember
-    @submodule ember-application
-    */
+    var Morph = __dependency1__["default"];
+    var AttrMorph = __dependency2__["default"];
+    var buildHTMLDOM = __dependency3__.buildHTMLDOM;
+    var svgNamespace = __dependency3__.svgNamespace;
+    var svgHTMLIntegrationPoints = __dependency3__.svgHTMLIntegrationPoints;
+    var addClasses = __dependency4__.addClasses;
+    var removeClasses = __dependency4__.removeClasses;
+    var normalizeProperty = __dependency5__.normalizeProperty;
+    var isAttrRemovalValue = __dependency5__.isAttrRemovalValue;
 
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var get = __dependency2__.get;
-    var EmberError = __dependency3__["default"];
-    var inspect = __dependency4__.inspect;
-    var computed = __dependency5__.computed;
-    var ControllerMixin = __dependency6__["default"];
-    var meta = __dependency4__.meta;
-    var controllerFor = __dependency7__["default"];
+    var doc = typeof document === 'undefined' ? false : document;
 
-    function verifyNeedsDependencies(controller, container, needs) {
-      var dependency, i, l;
-      var missing = [];
+    var deletesBlankTextNodes = doc && (function(document){
+      var element = document.createElement('div');
+      element.appendChild( document.createTextNode('') );
+      var clonedElement = element.cloneNode(true);
+      return clonedElement.childNodes.length === 0;
+    })(doc);
 
-      for (i=0, l=needs.length; i<l; i++) {
-        dependency = needs[i];
+    var ignoresCheckedAttribute = doc && (function(document){
+      var element = document.createElement('input');
+      element.setAttribute('checked', 'checked');
+      var clonedElement = element.cloneNode(false);
+      return !clonedElement.checked;
+    })(doc);
 
-        Ember.assert(inspect(controller) + "#needs must not specify dependencies with periods in their names (" +
-                     dependency + ")", dependency.indexOf('.') === -1);
+    var canRemoveSvgViewBoxAttribute = doc && (doc.createElementNS ? (function(document){
+      var element = document.createElementNS(svgNamespace, 'svg');
+      element.setAttribute('viewBox', '0 0 100 100');
+      element.removeAttribute('viewBox');
+      return !element.getAttribute('viewBox');
+    })(doc) : true);
 
-        if (dependency.indexOf(':') === -1) {
-          dependency = "controller:" + dependency;
-        }
+    var canClone = doc && (function(document){
+      var element = document.createElement('div');
+      element.appendChild( document.createTextNode(' '));
+      element.appendChild( document.createTextNode(' '));
+      var clonedElement = element.cloneNode(true);
+      return clonedElement.childNodes[0].nodeValue === ' ';
+    })(doc);
 
-        // Structure assert to still do verification but not string concat in production
-        if (!container.has(dependency)) {
-          missing.push(dependency);
-        }
-      }
-      if (missing.length) {
-        throw new EmberError(inspect(controller) + " needs [ " + missing.join(', ') +
-                             " ] but " + (missing.length > 1 ? 'they' : 'it') + " could not be found");
+    // This is not the namespace of the element, but of
+    // the elements inside that elements.
+    function interiorNamespace(element){
+      if (
+        element &&
+        element.namespaceURI === svgNamespace &&
+        !svgHTMLIntegrationPoints[element.tagName]
+      ) {
+        return svgNamespace;
+      } else {
+        return null;
       }
     }
 
-    var defaultControllersComputedProperty = computed(function() {
-      var controller = this;
-
-      return {
-        needs: get(controller, 'needs'),
-        container: get(controller, 'container'),
-        unknownProperty: function(controllerName) {
-          var needs = this.needs;
-          var dependency, i, l;
-
-          for (i=0, l=needs.length; i<l; i++) {
-            dependency = needs[i];
-            if (dependency === controllerName) {
-              return this.container.lookup('controller:' + controllerName);
-            }
-          }
-
-          var errorMessage = inspect(controller) + '#needs does not include `' +
-                             controllerName + '`. To access the ' +
-                             controllerName + ' controller from ' +
-                             inspect(controller) + ', ' +
-                             inspect(controller) +
-                             ' should have a `needs` property that is an array of the controllers it has access to.';
-          throw new ReferenceError(errorMessage);
-        },
-        setUnknownProperty: function (key, value) {
-          throw new Error("You cannot overwrite the value of `controllers." + key + "` of " + inspect(controller));
-        }
-      };
-    });
-
-    /**
-      @class ControllerMixin
-      @namespace Ember
-    */
-    ControllerMixin.reopen({
-      concatenatedProperties: ['needs'],
-
-      /**
-        An array of other controller objects available inside
-        instances of this controller via the `controllers`
-        property:
-
-        For example, when you define a controller:
-
-        ```javascript
-        App.CommentsController = Ember.ArrayController.extend({
-          needs: ['post']
-        });
-        ```
-
-        The application's single instance of these other
-        controllers are accessible by name through the
-        `controllers` property:
-
-        ```javascript
-        this.get('controllers.post'); // instance of App.PostController
-        ```
-
-        Given that you have a nested controller (nested resource):
-
-        ```javascript
-        App.CommentsNewController = Ember.ObjectController.extend({
-        });
-        ```
-
-        When you define a controller that requires access to a nested one:
-
-        ```javascript
-        App.IndexController = Ember.ObjectController.extend({
-          needs: ['commentsNew']
-        });
-        ```
-
-        You will be able to get access to it:
-
-        ```javascript
-        this.get('controllers.commentsNew'); // instance of App.CommentsNewController
-        ```
-
-        This is only available for singleton controllers.
-
-        @property {Array} needs
-        @default []
-      */
-      needs: [],
-
-      init: function() {
-        var needs = get(this, 'needs');
-        var length = get(needs, 'length');
-
-        if (length > 0) {
-          Ember.assert(' `' + inspect(this) + ' specifies `needs`, but does ' +
-                       "not have a container. Please ensure this controller was " +
-                       "instantiated with a container.",
-                       this.container || meta(this, false).descs.controllers !== defaultControllersComputedProperty);
-
-          if (this.container) {
-            verifyNeedsDependencies(this, this.container, needs);
-          }
+    // The HTML spec allows for "omitted start tags". These tags are optional
+    // when their intended child is the first thing in the parent tag. For
+    // example, this is a tbody start tag:
+    //
+    // <table>
+    //   <tbody>
+    //     <tr>
+    //
+    // The tbody may be omitted, and the browser will accept and render:
+    //
+    // <table>
+    //   <tr>
+    //
+    // However, the omitted start tag will still be added to the DOM. Here
+    // we test the string and context to see if the browser is about to
+    // perform this cleanup.
+    //
+    // http://www.whatwg.org/specs/web-apps/current-work/multipage/syntax.html#optional-tags
+    // describes which tags are omittable. The spec for tbody and colgroup
+    // explains this behavior:
+    //
+    // http://www.whatwg.org/specs/web-apps/current-work/multipage/tables.html#the-tbody-element
+    // http://www.whatwg.org/specs/web-apps/current-work/multipage/tables.html#the-colgroup-element
+    //
 
-          // if needs then initialize controllers proxy
-          get(this, 'controllers');
+    var omittedStartTagChildTest = /<([\w:]+)/;
+    function detectOmittedStartTag(string, contextualElement){
+      // Omitted start tags are only inside table tags.
+      if (contextualElement.tagName === 'TABLE') {
+        var omittedStartTagChildMatch = omittedStartTagChildTest.exec(string);
+        if (omittedStartTagChildMatch) {
+          var omittedStartTagChild = omittedStartTagChildMatch[1];
+          // It is already asserted that the contextual element is a table
+          // and not the proper start tag. Just see if a tag was omitted.
+          return omittedStartTagChild === 'tr' ||
+                 omittedStartTagChild === 'col';
         }
-
-        this._super.apply(this, arguments);
-      },
-
-      /**
-        @method controllerFor
-        @see {Ember.Route#controllerFor}
-        @deprecated Use `needs` instead
-      */
-      controllerFor: function(controllerName) {
-        Ember.deprecate("Controller#controllerFor is deprecated, please use Controller#needs instead");
-        return controllerFor(get(this, 'container'), controllerName);
-      },
-
-      /**
-        Stores the instances of other controllers available from within
-        this controller. Any controller listed by name in the `needs`
-        property will be accessible by name through this property.
-
-        ```javascript
-        App.CommentsController = Ember.ArrayController.extend({
-          needs: ['post'],
-          postTitle: function(){
-            var currentPost = this.get('controllers.post'); // instance of App.PostController
-            return currentPost.get('title');
-          }.property('controllers.post.title')
-        });
-        ```
-
-        @see {Ember.ControllerMixin#needs}
-        @property {Object} controllers
-        @default null
-      */
-      controllers: defaultControllersComputedProperty
-    });
-
-    __exports__["default"] = ControllerMixin;
-  });
-enifed("ember-application/system/application",
-  ["dag-map","container/container","ember-metal","ember-metal/property_get","ember-metal/property_set","ember-runtime/system/lazy_load","ember-runtime/system/namespace","ember-runtime/mixins/deferred","ember-application/system/resolver","ember-metal/platform","ember-metal/run_loop","ember-metal/utils","ember-runtime/controllers/controller","ember-metal/enumerable_utils","ember-runtime/controllers/object_controller","ember-runtime/controllers/array_controller","ember-views/views/select","ember-views/system/event_dispatcher","ember-views/system/jquery","ember-routing/system/route","ember-routing/system/router","ember-routing/location/hash_location","ember-routing/location/history_location","ember-routing/location/auto_location","ember-routing/location/none_location","ember-routing/system/cache","ember-extension-support/container_debug_adapter","ember-metal/core","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __dependency21__, __dependency22__, __dependency23__, __dependency24__, __dependency25__, __dependency26__, __dependency27__, __dependency28__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-application
-    */
-    var DAG = __dependency1__["default"];
-    var Container = __dependency2__["default"];
-
-
-    var Ember = __dependency3__["default"];
-    // Ember.FEATURES, Ember.deprecate, Ember.assert, Ember.libraries, LOG_VERSION, Namespace, BOOTED
-    var get = __dependency4__.get;
-    var set = __dependency5__.set;
-    var runLoadHooks = __dependency6__.runLoadHooks;
-    var Namespace = __dependency7__["default"];
-    var DeferredMixin = __dependency8__["default"];
-    var DefaultResolver = __dependency9__["default"];
-    var create = __dependency10__.create;
-    var run = __dependency11__["default"];
-    var canInvoke = __dependency12__.canInvoke;
-    var Controller = __dependency13__["default"];
-    var EnumerableUtils = __dependency14__["default"];
-    var ObjectController = __dependency15__["default"];
-    var ArrayController = __dependency16__["default"];
-    var SelectView = __dependency17__["default"];
-    var EventDispatcher = __dependency18__["default"];
-    var jQuery = __dependency19__["default"];
-    var Route = __dependency20__["default"];
-    var Router = __dependency21__["default"];
-    var HashLocation = __dependency22__["default"];
-    var HistoryLocation = __dependency23__["default"];
-    var AutoLocation = __dependency24__["default"];
-    var NoneLocation = __dependency25__["default"];
-    var BucketCache = __dependency26__["default"];
-
-    // this is technically incorrect (per @wycats)
-    // it should work properly with:
-    // `import ContainerDebugAdapter from 'ember-extension-support/container_debug_adapter';` but
-    // es6-module-transpiler 0.4.0 eagerly grabs the module (which is undefined)
-
-    var ContainerDebugAdapter = __dependency27__["default"];
-
-    var K = __dependency28__.K;
-
-    function props(obj) {
-      var properties = [];
-
-      for (var key in obj) {
-        properties.push(key);
       }
-
-      return properties;
     }
 
-    var librariesRegistered = false;
-
-    /**
-      An instance of `Ember.Application` is the starting point for every Ember
-      application. It helps to instantiate, initialize and coordinate the many
-      objects that make up your app.
+    function buildSVGDOM(html, dom){
+      var div = dom.document.createElement('div');
+      div.innerHTML = '<svg>'+html+'</svg>';
+      return div.firstChild.childNodes;
+    }
 
-      Each Ember app has one and only one `Ember.Application` object. In fact, the
-      very first thing you should do in your application is create the instance:
+    /*
+     * A class wrapping DOM functions to address environment compatibility,
+     * namespaces, contextual elements for morph un-escaped content
+     * insertion.
+     *
+     * When entering a template, a DOMHelper should be passed:
+     *
+     *   template(context, { hooks: hooks, dom: new DOMHelper() });
+     *
+     * TODO: support foreignObject as a passed contextual element. It has
+     * a namespace (svg) that does not match its internal namespace
+     * (xhtml).
+     *
+     * @class DOMHelper
+     * @constructor
+     * @param {HTMLDocument} _document The document DOM methods are proxied to
+     */
+    function DOMHelper(_document){
+      this.document = _document || document;
+      if (!this.document) {
+        throw new Error("A document object must be passed to the DOMHelper, or available on the global scope");
+      }
+      this.canClone = canClone;
+      this.namespace = null;
+    }
 
-      ```javascript
-      window.App = Ember.Application.create();
-      ```
+    var prototype = DOMHelper.prototype;
+    prototype.constructor = DOMHelper;
 
-      Typically, the application object is the only global variable. All other
-      classes in your app should be properties on the `Ember.Application` instance,
-      which highlights its first role: a global namespace.
+    prototype.getElementById = function(id, rootNode) {
+      rootNode = rootNode || this.document;
+      return rootNode.getElementById(id);
+    };
 
-      For example, if you define a view class, it might look like this:
+    prototype.insertBefore = function(element, childElement, referenceChild) {
+      return element.insertBefore(childElement, referenceChild);
+    };
 
-      ```javascript
-      App.MyView = Ember.View.extend();
-      ```
+    prototype.appendChild = function(element, childElement) {
+      return element.appendChild(childElement);
+    };
 
-      By default, calling `Ember.Application.create()` will automatically initialize
-      your application by calling the `Ember.Application.initialize()` method. If
-      you need to delay initialization, you can call your app's `deferReadiness()`
-      method. When you are ready for your app to be initialized, call its
-      `advanceReadiness()` method.
+    prototype.childAt = function(element, indices) {
+      var child = element;
 
-      You can define a `ready` method on the `Ember.Application` instance, which
-      will be run by Ember when the application is initialized.
+      for (var i = 0; i < indices.length; i++) {
+        child = child.childNodes.item(indices[i]);
+      }
 
-      Because `Ember.Application` inherits from `Ember.Namespace`, any classes
-      you create will have useful string representations when calling `toString()`.
-      See the `Ember.Namespace` documentation for more information.
+      return child;
+    };
 
-      While you can think of your `Ember.Application` as a container that holds the
-      other classes in your application, there are several other responsibilities
-      going on under-the-hood that you may want to understand.
+    // Note to a Fellow Implementor:
+    // Ahh, accessing a child node at an index. Seems like it should be so simple,
+    // doesn't it? Unfortunately, this particular method has caused us a surprising
+    // amount of pain. As you'll note below, this method has been modified to walk
+    // the linked list of child nodes rather than access the child by index
+    // directly, even though there are two (2) APIs in the DOM that do this for us.
+    // If you're thinking to yourself, "What an oversight! What an opportunity to
+    // optimize this code!" then to you I say: stop! For I have a tale to tell.
+    //
+    // First, this code must be compatible with simple-dom for rendering on the
+    // server where there is no real DOM. Previously, we accessed a child node
+    // directly via `element.childNodes[index]`. While we *could* in theory do a
+    // full-fidelity simulation of a live `childNodes` array, this is slow,
+    // complicated and error-prone.
+    //
+    // "No problem," we thought, "we'll just use the similar
+    // `childNodes.item(index)` API." Then, we could just implement our own `item`
+    // method in simple-dom and walk the child node linked list there, allowing
+    // us to retain the performance advantages of the (surely optimized) `item()`
+    // API in the browser.
+    //
+    // Unfortunately, an enterprising soul named Samy Alzahrani discovered that in
+    // IE8, accessing an item out-of-bounds via `item()` causes an exception where
+    // other browsers return null. This necessitated a... check of
+    // `childNodes.length`, bringing us back around to having to support a
+    // full-fidelity `childNodes` array!
+    //
+    // Worst of all, Kris Selden investigated how browsers are actualy implemented
+    // and discovered that they're all linked lists under the hood anyway. Accessing
+    // `childNodes` requires them to allocate a new live collection backed by that
+    // linked list, which is itself a rather expensive operation. Our assumed
+    // optimization had backfired! That is the danger of magical thinking about
+    // the performance of native implementations.
+    //
+    // And this, my friends, is why the following implementation just walks the
+    // linked list, as surprised as that may make you. Please ensure you understand
+    // the above before changing this and submitting a PR.
+    //
+    // Tom Dale, January 18th, 2015, Portland OR
+    prototype.childAtIndex = function(element, index) {
+      var node = element.firstChild;
 
-      ### Event Delegation
+      for (var idx = 0; node && idx < index; idx++) {
+        node = node.nextSibling;
+      }
 
-      Ember uses a technique called _event delegation_. This allows the framework
-      to set up a global, shared event listener instead of requiring each view to
-      do it manually. For example, instead of each view registering its own
-      `mousedown` listener on its associated element, Ember sets up a `mousedown`
-      listener on the `body`.
+      return node;
+    };
 
-      If a `mousedown` event occurs, Ember will look at the target of the event and
-      start walking up the DOM node tree, finding corresponding views and invoking
-      their `mouseDown` method as it goes.
+    prototype.appendText = function(element, text) {
+      return element.appendChild(this.document.createTextNode(text));
+    };
 
-      `Ember.Application` has a number of default events that it listens for, as
-      well as a mapping from lowercase events to camel-cased view method names. For
-      example, the `keypress` event causes the `keyPress` method on the view to be
-      called, the `dblclick` event causes `doubleClick` to be called, and so on.
+    prototype.setAttribute = function(element, name, value) {
+      element.setAttribute(name, String(value));
+    };
 
-      If there is a bubbling browser event that Ember does not listen for by
-      default, you can specify custom events and their corresponding view method
-      names by setting the application's `customEvents` property:
+    prototype.setAttributeNS = function(element, namespace, name, value) {
+      element.setAttributeNS(namespace, name, String(value));
+    };
 
-      ```javascript
-      var App = Ember.Application.create({
-        customEvents: {
-          // add support for the paste event
-          paste: 'paste'
+    if (canRemoveSvgViewBoxAttribute){
+      prototype.removeAttribute = function(element, name) {
+        element.removeAttribute(name);
+      };
+    } else {
+      prototype.removeAttribute = function(element, name) {
+        if (element.tagName === 'svg' && name === 'viewBox') {
+          element.setAttribute(name, null);
+        } else {
+          element.removeAttribute(name);
         }
-      });
-      ```
-
-      By default, the application sets up these event listeners on the document
-      body. However, in cases where you are embedding an Ember application inside
-      an existing page, you may want it to set up the listeners on an element
-      inside the body.
+      };
+    }
 
-      For example, if only events inside a DOM element with the ID of `ember-app`
-      should be delegated, set your application's `rootElement` property:
+    prototype.setPropertyStrict = function(element, name, value) {
+      element[name] = value;
+    };
 
-      ```javascript
-      var App = Ember.Application.create({
-        rootElement: '#ember-app'
-      });
-      ```
-
-      The `rootElement` can be either a DOM element or a jQuery-compatible selector
-      string. Note that *views appended to the DOM outside the root element will
-      not receive events.* If you specify a custom root element, make sure you only
-      append views inside it!
-
-      To learn more about the advantages of event delegation and the Ember view
-      layer, and a list of the event listeners that are setup by default, visit the
-      [Ember View Layer guide](http://emberjs.com/guides/understanding-ember/the-view-layer/#toc_event-delegation).
-
-      ### Initializers
-
-      Libraries on top of Ember can add initializers, like so:
-
-      ```javascript
-      Ember.Application.initializer({
-        name: 'api-adapter',
-
-        initialize: function(container, application) {
-          application.register('api-adapter:main', ApiAdapter);
-        }
-      });
-      ```
-
-      Initializers provide an opportunity to access the container, which
-      organizes the different components of an Ember application. Additionally
-      they provide a chance to access the instantiated application. Beyond
-      being used for libraries, initializers are also a great way to organize
-      dependency injection or setup in your own application.
-
-      ### Routing
-
-      In addition to creating your application's router, `Ember.Application` is
-      also responsible for telling the router when to start routing. Transitions
-      between routes can be logged with the `LOG_TRANSITIONS` flag, and more
-      detailed intra-transition logging can be logged with
-      the `LOG_TRANSITIONS_INTERNAL` flag:
-
-      ```javascript
-      var App = Ember.Application.create({
-        LOG_TRANSITIONS: true, // basic logging of successful transitions
-        LOG_TRANSITIONS_INTERNAL: true // detailed logging of all routing steps
-      });
-      ```
-
-      By default, the router will begin trying to translate the current URL into
-      application state once the browser emits the `DOMContentReady` event. If you
-      need to defer routing, you can call the application's `deferReadiness()`
-      method. Once routing can begin, call the `advanceReadiness()` method.
-
-      If there is any setup required before routing begins, you can implement a
-      `ready()` method on your app that will be invoked immediately before routing
-      begins.
-
-      @class Application
-      @namespace Ember
-      @extends Ember.Namespace
-    */
-
-    var Application = Namespace.extend(DeferredMixin, {
-      _suppressDeferredDeprecation: true,
-
-      /**
-        The root DOM element of the Application. This can be specified as an
-        element or a
-        [jQuery-compatible selector string](http://api.jquery.com/category/selectors/).
-
-        This is the element that will be passed to the Application's,
-        `eventDispatcher`, which sets up the listeners for event delegation. Every
-        view in your application should be a child of the element you specify here.
-
-        @property rootElement
-        @type DOMElement
-        @default 'body'
-      */
-      rootElement: 'body',
-
-      /**
-        The `Ember.EventDispatcher` responsible for delegating events to this
-        application's views.
-
-        The event dispatcher is created by the application at initialization time
-        and sets up event listeners on the DOM element described by the
-        application's `rootElement` property.
-
-        See the documentation for `Ember.EventDispatcher` for more information.
-
-        @property eventDispatcher
-        @type Ember.EventDispatcher
-        @default null
-      */
-      eventDispatcher: null,
-
-      /**
-        The DOM events for which the event dispatcher should listen.
-
-        By default, the application's `Ember.EventDispatcher` listens
-        for a set of standard DOM events, such as `mousedown` and
-        `keyup`, and delegates them to your application's `Ember.View`
-        instances.
-
-        If you would like additional bubbling events to be delegated to your
-        views, set your `Ember.Application`'s `customEvents` property
-        to a hash containing the DOM event name as the key and the
-        corresponding view method name as the value. For example:
-
-        ```javascript
-        var App = Ember.Application.create({
-          customEvents: {
-            // add support for the paste event
-            paste: 'paste'
-          }
-        });
-        ```
-
-        @property customEvents
-        @type Object
-        @default null
-      */
-      customEvents: null,
-
-      init: function() {
-        // Start off the number of deferrals at 1. This will be
-        // decremented by the Application's own `initialize` method.
-        this._readinessDeferrals = 1;
-
-        if (!this.$) {
-          this.$ = jQuery;
-        }
-        this.__container__ = this.buildContainer();
-
-        this.Router = this.defaultRouter();
-
-        this._super();
-
-        this.scheduleInitialize();
-
-        if (!librariesRegistered) {
-          librariesRegistered = true;
-          Ember.libraries.registerCoreLibrary('jQuery', jQuery().jquery);
-        }
-
-        if (Ember.LOG_VERSION) {
-          // we only need to see this once per Application#init
-          Ember.LOG_VERSION = false;
-          var libs = Ember.libraries._registry;
-
-          var nameLengths = EnumerableUtils.map(libs, function(item) {
-            return get(item, 'name.length');
-          });
-
-          var maxNameLength = Math.max.apply(this, nameLengths);
-
-          Ember.debug('-------------------------------');
-          for (var i = 0, l = libs.length; i < l; i++) {
-            var lib = libs[i];
-            var spaces = new Array(maxNameLength - lib.name.length + 1).join(' ');
-            Ember.debug([lib.name, spaces, ' : ', lib.version].join(''));
-          }
-          Ember.debug('-------------------------------');
-        }
-      },
-
-      /**
-        Build the container for the current application.
-
-        Also register a default application view in case the application
-        itself does not.
-
-        @private
-        @method buildContainer
-        @return {Ember.Container} the configured container
-      */
-      buildContainer: function() {
-        var container = this.__container__ = Application.buildContainer(this);
-
-        return container;
-      },
-
-      /**
-        If the application has not opted out of routing and has not explicitly
-        defined a router, supply a default router for the application author
-        to configure.
-
-        This allows application developers to do:
-
-        ```javascript
-        var App = Ember.Application.create();
-
-        App.Router.map(function() {
-          this.resource('posts');
-        });
-        ```
-
-        @private
-        @method defaultRouter
-        @return {Ember.Router} the default router
-      */
-
-      defaultRouter: function() {
-        if (this.Router === false) { return; }
-        var container = this.__container__;
-
-        if (this.Router) {
-          container.unregister('router:main');
-          container.register('router:main', this.Router);
-        }
-
-        return container.lookupFactory('router:main');
-      },
-
-      /**
-        Automatically initialize the application once the DOM has
-        become ready.
-
-        The initialization itself is scheduled on the actions queue
-        which ensures that application loading finishes before
-        booting.
-
-        If you are asynchronously loading code, you should call
-        `deferReadiness()` to defer booting, and then call
-        `advanceReadiness()` once all of your code has finished
-        loading.
-
-        @private
-        @method scheduleInitialize
-      */
-      scheduleInitialize: function() {
-        if (!this.$ || this.$.isReady) {
-          run.schedule('actions', this, '_initialize');
-        } else {
-          this.$().ready(Ember.run.bind(this, '_initialize'));
-        }
-      },
-
-      /**
-        Use this to defer readiness until some condition is true.
-
-        Example:
-
-        ```javascript
-        var App = Ember.Application.create();
-        
-        App.deferReadiness();
-        // Ember.$ is a reference to the jQuery object/function
-        Ember.$.getJSON('/auth-token', function(token) {
-          App.token = token;
-          App.advanceReadiness();
-        });
-        ```
-
-        This allows you to perform asynchronous setup logic and defer
-        booting your application until the setup has finished.
-
-        However, if the setup requires a loading UI, it might be better
-        to use the router for this purpose.
-
-        @method deferReadiness
-      */
-      deferReadiness: function() {
-        Ember.assert("You must call deferReadiness on an instance of Ember.Application", this instanceof Application);
-        Ember.assert("You cannot defer readiness since the `ready()` hook has already been called.", this._readinessDeferrals > 0);
-        this._readinessDeferrals++;
-      },
-
-      /**
-        Call `advanceReadiness` after any asynchronous setup logic has completed.
-        Each call to `deferReadiness` must be matched by a call to `advanceReadiness`
-        or the application will never become ready and routing will not begin.
-
-        @method advanceReadiness
-        @see {Ember.Application#deferReadiness}
-      */
-      advanceReadiness: function() {
-        Ember.assert("You must call advanceReadiness on an instance of Ember.Application", this instanceof Application);
-        this._readinessDeferrals--;
-
-        if (this._readinessDeferrals === 0) {
-          run.once(this, this.didBecomeReady);
-        }
-      },
-
-      /**
-        Registers a factory that can be used for dependency injection (with
-        `App.inject`) or for service lookup. Each factory is registered with
-        a full name including two parts: `type:name`.
-
-        A simple example:
-
-        ```javascript
-        var App = Ember.Application.create();
-        
-        App.Orange = Ember.Object.extend();
-        App.register('fruit:favorite', App.Orange);
-        ```
-
-        Ember will resolve factories from the `App` namespace automatically.
-        For example `App.CarsController` will be discovered and returned if
-        an application requests `controller:cars`.
-
-        An example of registering a controller with a non-standard name:
-
-        ```javascript
-        var App = Ember.Application.create();
-        var Session = Ember.Controller.extend();
-
-        App.register('controller:session', Session);
-
-        // The Session controller can now be treated like a normal controller,
-        // despite its non-standard name.
-        App.ApplicationController = Ember.Controller.extend({
-          needs: ['session']
-        });
-        ```
-
-        Registered factories are **instantiated** by having `create`
-        called on them. Additionally they are **singletons**, each time
-        they are looked up they return the same instance.
-
-        Some examples modifying that default behavior:
-
-        ```javascript
-        var App = Ember.Application.create();
-
-        App.Person  = Ember.Object.extend();
-        App.Orange  = Ember.Object.extend();
-        App.Email   = Ember.Object.extend();
-        App.session = Ember.Object.create();
-
-        App.register('model:user', App.Person, { singleton: false });
-        App.register('fruit:favorite', App.Orange);
-        App.register('communication:main', App.Email, { singleton: false });
-        App.register('session', App.session, { instantiate: false });
-        ```
-
-        @method register
-        @param  fullName {String} type:name (e.g., 'model:user')
-        @param  factory {Function} (e.g., App.Person)
-        @param  options {Object} (optional) disable instantiation or singleton usage
-      **/
-      register: function() {
-        var container = this.__container__;
-        container.register.apply(container, arguments);
-      },
-
-      /**
-        Define a dependency injection onto a specific factory or all factories
-        of a type.
-
-        When Ember instantiates a controller, view, or other framework component
-        it can attach a dependency to that component. This is often used to
-        provide services to a set of framework components.
-
-        An example of providing a session object to all controllers:
-
-        ```javascript
-        var App = Ember.Application.create();
-        var Session = Ember.Object.extend({ isAuthenticated: false });
-
-        // A factory must be registered before it can be injected
-        App.register('session:main', Session);
-
-        // Inject 'session:main' onto all factories of the type 'controller'
-        // with the name 'session'
-        App.inject('controller', 'session', 'session:main');
-
-        App.IndexController = Ember.Controller.extend({
-          isLoggedIn: Ember.computed.alias('session.isAuthenticated')
-        });
-        ```
-
-        Injections can also be performed on specific factories.
-
-        ```javascript
-        App.inject(<full_name or type>, <property name>, <full_name>)
-        App.inject('route', 'source', 'source:main')
-        App.inject('route:application', 'email', 'model:email')
-        ```
-
-        It is important to note that injections can only be performed on
-        classes that are instantiated by Ember itself. Instantiating a class
-        directly (via `create` or `new`) bypasses the dependency injection
-        system.
-
-        **Note:** Ember-Data instantiates its models in a unique manner, and consequently
-        injections onto models (or all models) will not work as expected. Injections
-        on models can be enabled by setting `Ember.MODEL_FACTORY_INJECTIONS`
-        to `true`.
-
-        @method inject
-        @param  factoryNameOrType {String}
-        @param  property {String}
-        @param  injectionName {String}
-      **/
-      inject: function() {
-        var container = this.__container__;
-        container.injection.apply(container, arguments);
-      },
-
-      /**
-        Calling initialize manually is not supported.
-
-        Please see Ember.Application#advanceReadiness and
-        Ember.Application#deferReadiness.
-
-        @private
-        @deprecated
-        @method initialize
-       **/
-      initialize: function() {
-        Ember.deprecate('Calling initialize manually is not supported. Please see Ember.Application#advanceReadiness and Ember.Application#deferReadiness');
-      },
-
-      /**
-        Initialize the application. This happens automatically.
-
-        Run any initializers and run the application load hook. These hooks may
-        choose to defer readiness. For example, an authentication hook might want
-        to defer readiness until the auth token has been retrieved.
-
-        @private
-        @method _initialize
-      */
-      _initialize: function() {
-        if (this.isDestroyed) { return; }
-
-        // At this point, the App.Router must already be assigned
-        if (this.Router) {
-          var container = this.__container__;
-          container.unregister('router:main');
-          container.register('router:main', this.Router);
-        }
-
-        this.runInitializers();
-        runLoadHooks('application', this);
-
-        // At this point, any initializers or load hooks that would have wanted
-        // to defer readiness have fired. In general, advancing readiness here
-        // will proceed to didBecomeReady.
-        this.advanceReadiness();
-
-        return this;
-      },
-
-      /**
-        Reset the application. This is typically used only in tests. It cleans up
-        the application in the following order:
-
-        1. Deactivate existing routes
-        2. Destroy all objects in the container
-        3. Create a new application container
-        4. Re-route to the existing url
-
-        Typical Example:
-
-        ```javascript
-        var App;
-
-        run(function() {
-          App = Ember.Application.create();
-        });
-
-        module('acceptance test', {
-          setup: function() {
-            App.reset();
-          }
-        });
-
-        test('first test', function() {
-          // App is freshly reset
-        });
-
-        test('second test', function() {
-          // App is again freshly reset
-        });
-        ```
-
-        Advanced Example:
-
-        Occasionally you may want to prevent the app from initializing during
-        setup. This could enable extra configuration, or enable asserting prior
-        to the app becoming ready.
-
-        ```javascript
-        var App;
-
-        run(function() {
-          App = Ember.Application.create();
-        });
-
-        module('acceptance test', {
-          setup: function() {
-            run(function() {
-              App.reset();
-              App.deferReadiness();
-            });
-          }
-        });
-
-        test('first test', function() {
-          ok(true, 'something before app is initialized');
-
-          run(function() {
-            App.advanceReadiness();
-          });
-          
-          ok(true, 'something after app is initialized');
-        });
-        ```
-
-        @method reset
-      **/
-      reset: function() {
-        this._readinessDeferrals = 1;
-
-        function handleReset() {
-          var router = this.__container__.lookup('router:main');
-          router.reset();
-
-          run(this.__container__, 'destroy');
-
-          this.buildContainer();
-
-          run.schedule('actions', this, '_initialize');
-        }
-
-        run.join(this, handleReset);
-      },
-
-      /**
-        @private
-        @method runInitializers
-      */
-      runInitializers: function() {
-        var initializersByName = get(this.constructor, 'initializers');
-        var initializers = props(initializersByName);
-        var container = this.__container__;
-        var graph = new DAG();
-        var namespace = this;
-        var initializer;
-
-        for (var i = 0; i < initializers.length; i++) {
-          initializer = initializersByName[initializers[i]];
-          graph.addEdges(initializer.name, initializer.initialize, initializer.before, initializer.after);
-        }
-
-        graph.topsort(function (vertex) {
-          var initializer = vertex.value;
-          Ember.assert("No application initializer named '" + vertex.name + "'", !!initializer);
-          initializer(container, namespace);
-        });
-      },
-
-      /**
-        @private
-        @method didBecomeReady
-      */
-      didBecomeReady: function() {
-        this.setupEventDispatcher();
-        this.ready(); // user hook
-        this.startRouting();
-
-        if (!Ember.testing) {
-          // Eagerly name all classes that are already loaded
-          Ember.Namespace.processAll();
-          Ember.BOOTED = true;
-        }
-
-        this.resolve(this);
-      },
-
-      /**
-        Setup up the event dispatcher to receive events on the
-        application's `rootElement` with any registered
-        `customEvents`.
-
-        @private
-        @method setupEventDispatcher
-      */
-      setupEventDispatcher: function() {
-        var customEvents = get(this, 'customEvents');
-        var rootElement = get(this, 'rootElement');
-        var dispatcher = this.__container__.lookup('event_dispatcher:main');
-
-        set(this, 'eventDispatcher', dispatcher);
-        dispatcher.setup(customEvents, rootElement);
-      },
-
-      /**
-        If the application has a router, use it to route to the current URL, and
-        trigger a new call to `route` whenever the URL changes.
-
-        @private
-        @method startRouting
-        @property router {Ember.Router}
-      */
-      startRouting: function() {
-        var router = this.__container__.lookup('router:main');
-        if (!router) { return; }
-
-        router.startRouting();
-      },
-
-      handleURL: function(url) {
-        var router = this.__container__.lookup('router:main');
-
-        router.handleURL(url);
-      },
-
-      /**
-        Called when the Application has become ready.
-        The call will be delayed until the DOM has become ready.
-
-        @event ready
-      */
-      ready: K,
-
-      /**
-        @deprecated Use 'Resolver' instead
-        Set this to provide an alternate class to `Ember.DefaultResolver`
-
-
-        @property resolver
-      */
-      resolver: null,
-
-      /**
-        Set this to provide an alternate class to `Ember.DefaultResolver`
-
-        @property resolver
-      */
-      Resolver: null,
-
-      willDestroy: function() {
-        Ember.BOOTED = false;
-        // Ensure deactivation of routes before objects are destroyed
-        this.__container__.lookup('router:main').reset();
-
-        this.__container__.destroy();
-      },
-
-      initializer: function(options) {
-        this.constructor.initializer(options);
-      },
-
-      /**
-        @method then
-        @private
-        @deprecated
-      */
-      then: function() {
-        Ember.deprecate('Do not use `.then` on an instance of Ember.Application.  Please use the `.ready` hook instead.', false, { url: 'http://emberjs.com/guides/deprecations/#toc_deprecate-code-then-code-on-ember-application' });
-
-        this._super.apply(this, arguments);
-      }
-    });
-
-    Application.reopenClass({
-      initializers: create(null),
-
-      /**
-        Initializer receives an object which has the following attributes:
-        `name`, `before`, `after`, `initialize`. The only required attribute is
-        `initialize, all others are optional.
-
-        * `name` allows you to specify under which name the initializer is registered.
-        This must be a unique name, as trying to register two initializers with the
-        same name will result in an error.
-
-        ```javascript
-        Ember.Application.initializer({
-          name: 'namedInitializer',
-          
-          initialize: function(container, application) {
-            Ember.debug('Running namedInitializer!');
-          }
-        });
-        ```
-
-        * `before` and `after` are used to ensure that this initializer is ran prior
-        or after the one identified by the value. This value can be a single string
-        or an array of strings, referencing the `name` of other initializers.
-
-        An example of ordering initializers, we create an initializer named `first`:
-
-        ```javascript
-        Ember.Application.initializer({
-          name: 'first',
-          
-          initialize: function(container, application) {
-            Ember.debug('First initializer!');
-          }
-        });
-
-        // DEBUG: First initializer!
-        ```
-
-        We add another initializer named `second`, specifying that it should run
-        after the initializer named `first`:
-
-        ```javascript
-        Ember.Application.initializer({
-          name: 'second',
-          after: 'first',
-
-          initialize: function(container, application) {
-            Ember.debug('Second initializer!');
-          }
-        });
-
-        // DEBUG: First initializer!
-        // DEBUG: Second initializer!
-        ```
-
-        Afterwards we add a further initializer named `pre`, this time specifying
-        that it should run before the initializer named `first`:
-
-        ```javascript
-        Ember.Application.initializer({
-          name: 'pre',
-          before: 'first',
-
-          initialize: function(container, application) {
-            Ember.debug('Pre initializer!');
-          }
-        });
-
-        // DEBUG: Pre initializer!
-        // DEBUG: First initializer!
-        // DEBUG: Second initializer!
-        ```
-
-        Finally we add an initializer named `post`, specifying it should run after
-        both the `first` and the `second` initializers:
-
-        ```javascript
-        Ember.Application.initializer({
-          name: 'post',
-          after: ['first', 'second'],
-
-          initialize: function(container, application) {
-            Ember.debug('Post initializer!');
-          }
-        });
-
-        // DEBUG: Pre initializer!
-        // DEBUG: First initializer!
-        // DEBUG: Second initializer!
-        // DEBUG: Post initializer!
-        ```
-
-        * `initialize` is a callback function that receives two arguments, `container`
-        and `application` on which you can operate.
-
-        Example of using `container` to preload data into the store:
-
-        ```javascript
-        Ember.Application.initializer({
-          name: 'preload-data',
-
-          initialize: function(container, application) {
-            var store = container.lookup('store:main');
-            
-            store.pushPayload(preloadedData);
-          }
-        });
-        ```
-
-        Example of using `application` to register an adapter:
-
-        ```javascript
-        Ember.Application.initializer({
-          name: 'api-adapter',
-
-          initialize: function(container, application) {
-            application.register('api-adapter:main', ApiAdapter);
-          }
-        });
-        ```
-
-        @method initializer
-        @param initializer {Object}
-       */
-      initializer: function(initializer) {
-        // If this is the first initializer being added to a subclass, we are going to reopen the class
-        // to make sure we have a new `initializers` object, which extends from the parent class' using
-        // prototypal inheritance. Without this, attempting to add initializers to the subclass would
-        // pollute the parent class as well as other subclasses.
-        if (this.superclass.initializers !== undefined && this.superclass.initializers === this.initializers) {
-          this.reopenClass({
-            initializers: create(this.initializers)
-          });
-        }
-
-        Ember.assert("The initializer '" + initializer.name + "' has already been registered", !this.initializers[initializer.name]);
-        Ember.assert("An initializer cannot be registered without an initialize function", canInvoke(initializer, 'initialize'));
-        Ember.assert("An initializer cannot be registered without a name property", initializer.name !== undefined);
-
-        this.initializers[initializer.name] = initializer;
-      },
-
-      /**
-        This creates a container with the default Ember naming conventions.
-
-        It also configures the container:
-
-        * registered views are created every time they are looked up (they are
-          not singletons)
-        * registered templates are not factories; the registered value is
-          returned directly.
-        * the router receives the application as its `namespace` property
-        * all controllers receive the router as their `target` and `controllers`
-          properties
-        * all controllers receive the application as their `namespace` property
-        * the application view receives the application controller as its
-          `controller` property
-        * the application view receives the application template as its
-          `defaultTemplate` property
-
-        @private
-        @method buildContainer
-        @static
-        @param {Ember.Application} namespace the application to build the
-          container for.
-        @return {Ember.Container} the built container
-      */
-      buildContainer: function(namespace) {
-        var container = new Container();
-
-        container.set = set;
-        container.resolver = resolverFor(namespace);
-        container.normalizeFullName = container.resolver.normalize;
-        container.describe = container.resolver.describe;
-        container.makeToString = container.resolver.makeToString;
-
-        container.optionsForType('component', { singleton: false });
-        container.optionsForType('view', { singleton: false });
-        container.optionsForType('template', { instantiate: false });
-        container.optionsForType('helper', { instantiate: false });
-
-        container.register('application:main', namespace, { instantiate: false });
-
-        container.register('controller:basic', Controller, { instantiate: false });
-        container.register('controller:object', ObjectController, { instantiate: false });
-        container.register('controller:array', ArrayController, { instantiate: false });
-
-        container.register('view:select', SelectView);
-
-        container.register('route:basic', Route, { instantiate: false });
-        container.register('event_dispatcher:main', EventDispatcher);
-
-        container.register('router:main',  Router);
-        container.injection('router:main', 'namespace', 'application:main');
-
-        container.register('location:auto', AutoLocation);
-        container.register('location:hash', HashLocation);
-        container.register('location:history', HistoryLocation);
-        container.register('location:none', NoneLocation);
-
-        container.injection('controller', 'target', 'router:main');
-        container.injection('controller', 'namespace', 'application:main');
-
-        container.register('-bucket-cache:main', BucketCache);
-        container.injection('router', '_bucketCache', '-bucket-cache:main');
-        container.injection('route',  '_bucketCache', '-bucket-cache:main');
-        container.injection('controller',  '_bucketCache', '-bucket-cache:main');
-
-        container.injection('route', 'router', 'router:main');
-        container.injection('location', 'rootURL', '-location-setting:root-url');
-
-        // DEBUGGING
-        container.register('resolver-for-debugging:main', container.resolver.__resolver__, { instantiate: false });
-        container.injection('container-debug-adapter:main', 'resolver', 'resolver-for-debugging:main');
-        container.injection('data-adapter:main', 'containerDebugAdapter', 'container-debug-adapter:main');
-        // Custom resolver authors may want to register their own ContainerDebugAdapter with this key
-
-        container.register('container-debug-adapter:main', ContainerDebugAdapter);
-
-        return container;
-      }
-    });
-
-    /**
-      This function defines the default lookup rules for container lookups:
-
-      * templates are looked up on `Ember.TEMPLATES`
-      * other names are looked up on the application after classifying the name.
-        For example, `controller:post` looks up `App.PostController` by default.
-      * if the default lookup fails, look for registered classes on the container
-
-      This allows the application to register default injections in the container
-      that could be overridden by the normal naming convention.
-
-      @private
-      @method resolverFor
-      @param {Ember.Namespace} namespace the namespace to look for classes
-      @return {*} the resolved value for a given lookup
-    */
-    function resolverFor(namespace) {
-      Ember.deprecate('Application.resolver is deprecated in favor of Application.Resolver', !namespace.get('resolver'));
-
-      var ResolverClass = namespace.get('resolver') || namespace.get('Resolver') || DefaultResolver;
-      var resolver = ResolverClass.create({
-        namespace: namespace
-      });
-
-      function resolve(fullName) {
-        return resolver.resolve(fullName);
-      }
-
-      resolve.describe = function(fullName) {
-        return resolver.lookupDescription(fullName);
-      };
-
-      resolve.makeToString = function(factory, fullName) {
-        return resolver.makeToString(factory, fullName);
-      };
-
-      resolve.normalize = function(fullName) {
-        if (resolver.normalize) {
-          return resolver.normalize(fullName);
-        } else {
-          Ember.deprecate('The Resolver should now provide a \'normalize\' function', false);
-          return fullName;
-        }
-      };
-
-      resolve.__resolver__ = resolver;
-
-      return resolve;
-    }
-
-    __exports__["default"] = Application;
-  });
-enifed("ember-application/system/resolver",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/logger","ember-runtime/system/string","ember-runtime/system/object","ember-runtime/system/namespace","ember-htmlbars/helpers","ember-metal/dictionary","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-application
-    */
-
-    var Ember = __dependency1__["default"];
-    // Ember.TEMPLATES, Ember.assert
-    var get = __dependency2__.get;
-    var Logger = __dependency3__["default"];
-    var classify = __dependency4__.classify;
-    var capitalize = __dependency4__.capitalize;
-    var decamelize = __dependency4__.decamelize;
-    var EmberObject = __dependency5__["default"];
-    var Namespace = __dependency6__["default"];
-    var helpers = __dependency7__["default"];
-
-    var Resolver = EmberObject.extend({
-      /**
-        This will be set to the Application instance when it is
-        created.
-
-        @property namespace
-      */
-      namespace: null,
-      normalize:         Ember.required(Function),
-      resolve:           Ember.required(Function),
-      parseName:         Ember.required(Function),
-      lookupDescription: Ember.required(Function),
-      makeToString:      Ember.required(Function),
-      resolveOther:      Ember.required(Function),
-      _logLookup:        Ember.required(Function)
-    });
-    __exports__.Resolver = Resolver;
-    /**
-      The DefaultResolver defines the default lookup rules to resolve
-      container lookups before consulting the container for registered
-      items:
-
-      * templates are looked up on `Ember.TEMPLATES`
-      * other names are looked up on the application after converting
-        the name. For example, `controller:post` looks up
-        `App.PostController` by default.
-      * there are some nuances (see examples below)
-
-      ### How Resolving Works
-
-      The container calls this object's `resolve` method with the
-      `fullName` argument.
-
-      It first parses the fullName into an object using `parseName`.
-
-      Then it checks for the presence of a type-specific instance
-      method of the form `resolve[Type]` and calls it if it exists.
-      For example if it was resolving 'template:post', it would call
-      the `resolveTemplate` method.
-
-      Its last resort is to call the `resolveOther` method.
-
-      The methods of this object are designed to be easy to override
-      in a subclass. For example, you could enhance how a template
-      is resolved like so:
-
-      ```javascript
-      App = Ember.Application.create({
-        Resolver: Ember.DefaultResolver.extend({
-          resolveTemplate: function(parsedName) {
-            var resolvedTemplate = this._super(parsedName);
-            if (resolvedTemplate) { return resolvedTemplate; }
-            return Ember.TEMPLATES['not_found'];
-          }
-        })
-      });
-      ```
-
-      Some examples of how names are resolved:
-
-      ```
-      'template:post'           //=> Ember.TEMPLATES['post']
-      'template:posts/byline'   //=> Ember.TEMPLATES['posts/byline']
-      'template:posts.byline'   //=> Ember.TEMPLATES['posts/byline']
-      'template:blogPost'       //=> Ember.TEMPLATES['blogPost']
-                                //   OR
-                                //   Ember.TEMPLATES['blog_post']
-      'controller:post'         //=> App.PostController
-      'controller:posts.index'  //=> App.PostsIndexController
-      'controller:blog/post'    //=> Blog.PostController
-      'controller:basic'        //=> Ember.Controller
-      'route:post'              //=> App.PostRoute
-      'route:posts.index'       //=> App.PostsIndexRoute
-      'route:blog/post'         //=> Blog.PostRoute
-      'route:basic'             //=> Ember.Route
-      'view:post'               //=> App.PostView
-      'view:posts.index'        //=> App.PostsIndexView
-      'view:blog/post'          //=> Blog.PostView
-      'view:basic'              //=> Ember.View
-      'foo:post'                //=> App.PostFoo
-      'model:post'              //=> App.Post
-      ```
-
-      @class DefaultResolver
-      @namespace Ember
-      @extends Ember.Object
-    */
-    var dictionary = __dependency8__["default"];
-
-    __exports__["default"] = EmberObject.extend({
-      /**
-        This will be set to the Application instance when it is
-        created.
-
-        @property namespace
-      */
-      namespace: null,
-
-      init: function() {
-        this._parseNameCache = dictionary(null);
-      },
-      normalize: function(fullName) {
-        var split = fullName.split(':', 2);
-        var type = split[0];
-        var name = split[1];
-
-        Ember.assert("Tried to normalize a container name without a colon (:) in it." +
-                     " You probably tried to lookup a name that did not contain a type," +
-                     " a colon, and a name. A proper lookup name would be `view:post`.", split.length === 2);
-
-        if (type !== 'template') {
-          var result = name;
-
-          if (result.indexOf('.') > -1) {
-            result = result.replace(/\.(.)/g, function(m) {
-              return m.charAt(1).toUpperCase();
-            });
-          }
-
-          if (name.indexOf('_') > -1) {
-            result = result.replace(/_(.)/g, function(m) {
-              return m.charAt(1).toUpperCase();
-            });
-          }
-
-          return type + ':' + result;
-        } else {
-          return fullName;
-        }
-      },
-
-
-      /**
-        This method is called via the container's resolver method.
-        It parses the provided `fullName` and then looks up and
-        returns the appropriate template or class.
-
-        @method resolve
-        @param {String} fullName the lookup string
-        @return {Object} the resolved factory
-      */
-      resolve: function(fullName) {
-        var parsedName = this.parseName(fullName);
-        var resolveMethodName = parsedName.resolveMethodName;
-        var resolved;
-
-        if (!(parsedName.name && parsedName.type)) {
-          throw new TypeError('Invalid fullName: `' + fullName + '`, must be of the form `type:name` ');
-        }
-
-        if (this[resolveMethodName]) {
-          resolved = this[resolveMethodName](parsedName);
-        }
-
-        if (!resolved) {
-          resolved = this.resolveOther(parsedName);
-        }
-
-        if (parsedName.root && parsedName.root.LOG_RESOLVER) {
-          this._logLookup(resolved, parsedName);
-        }
-
-        return resolved;
-      },
-      /**
-        Convert the string name of the form 'type:name' to
-        a Javascript object with the parsed aspects of the name
-        broken out.
-
-        @protected
-        @param {String} fullName the lookup string
-        @method parseName
-      */
-
-      parseName: function(fullName) {
-        return this._parseNameCache[fullName] || (
-          this._parseNameCache[fullName] = this._parseName(fullName)
-        );
-      },
-
-      _parseName: function(fullName) {
-        var nameParts = fullName.split(':');
-        var type = nameParts[0], fullNameWithoutType = nameParts[1];
-        var name = fullNameWithoutType;
-        var namespace = get(this, 'namespace');
-        var root = namespace;
-
-        if (type !== 'template' && name.indexOf('/') !== -1) {
-          var parts = name.split('/');
-          name = parts[parts.length - 1];
-          var namespaceName = capitalize(parts.slice(0, -1).join('.'));
-          root = Namespace.byName(namespaceName);
-
-          Ember.assert('You are looking for a ' + name + ' ' + type +
-                       ' in the ' + namespaceName +
-                       ' namespace, but the namespace could not be found', root);
-        }
-
-        return {
-          fullName: fullName,
-          type: type,
-          fullNameWithoutType: fullNameWithoutType,
-          name: name,
-          root: root,
-          resolveMethodName: 'resolve' + classify(type)
-        };
-      },
-
-      /**
-        Returns a human-readable description for a fullName. Used by the
-        Application namespace in assertions to describe the
-        precise name of the class that Ember is looking for, rather than
-        container keys.
-
-        @protected
-        @param {String} fullName the lookup string
-        @method lookupDescription
-      */
-      lookupDescription: function(fullName) {
-        var parsedName = this.parseName(fullName);
-        var description;
-
-        if (parsedName.type === 'template') {
-          return 'template at ' + parsedName.fullNameWithoutType.replace(/\./g, '/');
-        }
-
-        description = parsedName.root + '.' + classify(parsedName.name).replace(/\./g, '');
-
-        if (parsedName.type !== 'model') {
-          description += classify(parsedName.type);
-        }
-
-        return description;
-      },
-
-      makeToString: function(factory, fullName) {
-        return factory.toString();
-      },
-      /**
-        Given a parseName object (output from `parseName`), apply
-        the conventions expected by `Ember.Router`
-
-        @protected
-        @param {Object} parsedName a parseName object with the parsed
-          fullName lookup string
-        @method useRouterNaming
-      */
-      useRouterNaming: function(parsedName) {
-        parsedName.name = parsedName.name.replace(/\./g, '_');
-        if (parsedName.name === 'basic') {
-          parsedName.name = '';
-        }
-      },
-      /**
-        Look up the template in Ember.TEMPLATES
-
-        @protected
-        @param {Object} parsedName a parseName object with the parsed
-          fullName lookup string
-        @method resolveTemplate
-      */
-      resolveTemplate: function(parsedName) {
-        var templateName = parsedName.fullNameWithoutType.replace(/\./g, '/');
-
-        if (Ember.TEMPLATES[templateName]) {
-          return Ember.TEMPLATES[templateName];
-        }
-
-        templateName = decamelize(templateName);
-        if (Ember.TEMPLATES[templateName]) {
-          return Ember.TEMPLATES[templateName];
-        }
-      },
-
-      /**
-        Lookup the view using `resolveOther`
-
-        @protected
-        @param {Object} parsedName a parseName object with the parsed
-          fullName lookup string
-        @method resolveView
-      */
-      resolveView: function(parsedName) {
-        this.useRouterNaming(parsedName);
-        return this.resolveOther(parsedName);
-      },
-
-      /**
-        Lookup the controller using `resolveOther`
-
-        @protected
-        @param {Object} parsedName a parseName object with the parsed
-          fullName lookup string
-        @method resolveController
-      */
-      resolveController: function(parsedName) {
-        this.useRouterNaming(parsedName);
-        return this.resolveOther(parsedName);
-      },
-      /**
-        Lookup the route using `resolveOther`
-
-        @protected
-        @param {Object} parsedName a parseName object with the parsed
-          fullName lookup string
-        @method resolveRoute
-      */
-      resolveRoute: function(parsedName) {
-        this.useRouterNaming(parsedName);
-        return this.resolveOther(parsedName);
-      },
-
-      /**
-        Lookup the model on the Application namespace
-
-        @protected
-        @param {Object} parsedName a parseName object with the parsed
-          fullName lookup string
-        @method resolveModel
-      */
-      resolveModel: function(parsedName) {
-        var className = classify(parsedName.name);
-        var factory = get(parsedName.root, className);
-
-         if (factory) { return factory; }
-      },
-      /**
-        Look up the specified object (from parsedName) on the appropriate
-        namespace (usually on the Application)
-
-        @protected
-        @param {Object} parsedName a parseName object with the parsed
-          fullName lookup string
-        @method resolveHelper
-      */
-      resolveHelper: function(parsedName) {
-        return this.resolveOther(parsedName) || helpers[parsedName.fullNameWithoutType];
-      },
-      /**
-        Look up the specified object (from parsedName) on the appropriate
-        namespace (usually on the Application)
-
-        @protected
-        @param {Object} parsedName a parseName object with the parsed
-          fullName lookup string
-        @method resolveOther
-      */
-      resolveOther: function(parsedName) {
-        var className = classify(parsedName.name) + classify(parsedName.type);
-        var factory = get(parsedName.root, className);
-        if (factory) { return factory; }
-      },
-
-      /**
-       @method _logLookup
-       @param {Boolean} found
-       @param {Object} parsedName
-       @private
-      */
-      _logLookup: function(found, parsedName) {
-        var symbol, padding;
-
-        if (found) { symbol = '[✓]'; }
-        else       { symbol = '[ ]'; }
-
-        if (parsedName.fullName.length > 60) {
-          padding = '.';
-        } else {
-          padding = new Array(60 - parsedName.fullName.length).join('.');
-        }
-
-        Logger.info(symbol, parsedName.fullName, padding, this.lookupDescription(parsedName.fullName));
-      }
-    });
-  });
-enifed("ember-debug",
-  ["ember-metal/core","ember-metal/error","ember-metal/logger","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    /*global __fail__*/
-
-    var Ember = __dependency1__["default"];
-    var EmberError = __dependency2__["default"];
-    var Logger = __dependency3__["default"];
-
-    /**
-    Ember Debug
-
-    @module ember
-    @submodule ember-debug
-    */
-
-    /**
-    @class Ember
-    */
-
-    /**
-      Define an assertion that will throw an exception if the condition is not
-      met. Ember build tools will remove any calls to `Ember.assert()` when
-      doing a production build. Example:
-
-      ```javascript
-      // Test for truthiness
-      Ember.assert('Must pass a valid object', obj);
-
-      // Fail unconditionally
-      Ember.assert('This code path should never be run');
-      ```
-
-      @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
-        falsy, an exception will be thrown.
-    */
-    Ember.assert = function(desc, test) {
-      var throwAssertion;
-
-      if (Ember.typeOf(test) === 'function') {
-        throwAssertion = !test();
-      } else {
-        throwAssertion = !test;
-      }
-
-      if (throwAssertion) {
-        throw new EmberError("Assertion Failed: " + desc);
-      }
-    };
-
-
-    /**
-      Display a warning with the provided message. Ember build tools will
-      remove any calls to `Ember.warn()` when doing a production build.
-
-      @method warn
-      @param {String} message A warning to display.
-      @param {Boolean} test An optional boolean. If falsy, the warning
-        will be displayed.
-    */
-    Ember.warn = function(message, test) {
-      if (!test) {
-        Logger.warn("WARNING: "+message);
-        if ('trace' in Logger) {
-          Logger.trace();
+    prototype.setProperty = function(element, name, value, namespace) {
+      var lowercaseName = name.toLowerCase();
+      if (element.namespaceURI === svgNamespace || lowercaseName === 'style') {
+        if (isAttrRemovalValue(value)) {
+          element.removeAttribute(name);
+        } else {
+          if (namespace) {
+            element.setAttributeNS(namespace, name, value);
+          } else {
+            element.setAttribute(name, value);
+          }
         }
-      }
-    };
-
-    /**
-      Display a debug notice. Ember build tools will remove any calls to
-      `Ember.debug()` when doing a production build.
-
-      ```javascript
-      Ember.debug('I\'m a debug notice!');
-      ```
-
-      @method debug
-      @param {String} message A debug message to display.
-    */
-    Ember.debug = function(message) {
-      Logger.debug("DEBUG: "+message);
-    };
-
-    /**
-      Display a deprecation warning with the provided message and a stack trace
-      (Chrome and Firefox only). Ember build tools will remove any calls to
-      `Ember.deprecate()` when doing a production build.
-
-      @method deprecate
-      @param {String} message A description of the deprecation.
-      @param {Boolean} test An optional boolean. If falsy, the deprecation
-        will be displayed.
-      @param {Object} options An optional object that can be used to pass
-        in a `url` to the transition guide on the emberjs.com website.
-    */
-    Ember.deprecate = function(message, test, options) {
-      var noDeprecation;
-
-      if (typeof test === 'function') {
-        noDeprecation = test();
       } else {
-        noDeprecation = test;
-      }
-
-      if (noDeprecation) { return; }
-
-      if (Ember.ENV.RAISE_ON_DEPRECATION) { throw new EmberError(message); }
-
-      var error;
-
-      // When using new Error, we can't do the arguments check for Chrome. Alternatives are welcome
-      try { __fail__.fail(); } catch (e) { error = e; }
-
-      if (arguments.length === 3) {
-        Ember.assert('options argument to Ember.deprecate should be an object', options && typeof options === 'object');
-        if (options.url) {
-          message += ' See ' + options.url + ' for more details.';
-        }
-      }
-
-      if (Ember.LOG_STACKTRACE_ON_DEPRECATION && error.stack) {
-        var stack;
-        var stackStr = '';
-
-        if (error['arguments']) {
-          // Chrome
-          stack = error.stack.replace(/^\s+at\s+/gm, '').
-                              replace(/^([^\(]+?)([\n$])/gm, '{anonymous}($1)$2').
-                              replace(/^Object.<anonymous>\s*\(([^\)]+)\)/gm, '{anonymous}($1)').split('\n');
-          stack.shift();
+        var normalized = normalizeProperty(element, name);
+        if (normalized) {
+          element[normalized] = value;
         } else {
-          // Firefox
-          stack = error.stack.replace(/(?:\n@:0)?\s+$/m, '').
-                              replace(/^\(/gm, '{anonymous}(').split('\n');
-        }
-
-        stackStr = "\n    " + stack.slice(2).join("\n    ");
-        message = message + stackStr;
-      }
-
-      Logger.warn("DEPRECATION: "+message);
-    };
-
-
-
-    /**
-      Alias an old, deprecated method with its new counterpart.
-
-      Display a deprecation warning with the provided message and a stack trace
-      (Chrome and Firefox only) when the assigned method is called.
-
-      Ember build tools will not remove calls to `Ember.deprecateFunc()`, though
-      no warnings will be shown in production.
-
-      ```javascript
-      Ember.oldMethod = Ember.deprecateFunc('Please use the new, updated method', Ember.newMethod);
-      ```
-
-      @method deprecateFunc
-      @param {String} message A description of the deprecation.
-      @param {Function} func The new function called to replace its deprecated counterpart.
-      @return {Function} a new function that wrapped the original function with a deprecation warning
-    */
-    Ember.deprecateFunc = function(message, func) {
-      return function() {
-        Ember.deprecate(message);
-        return func.apply(this, arguments);
-      };
-    };
-
-
-    /**
-      Run a function meant for debugging. Ember build tools will remove any calls to
-      `Ember.runInDebug()` when doing a production build.
-
-      ```javascript
-      Ember.runInDebug(function() {
-        Ember.Handlebars.EachView.reopen({
-          didInsertElement: function() {
-            console.log('I\'m happy');
-          }
-        });
-      });
-      ```
-
-      @method runInDebug
-      @param {Function} func The function to be executed.
-      @since 1.5.0
-    */
-    Ember.runInDebug = function(func) {
-      func();
-    };
-
-    /**
-      Will call `Ember.warn()` if ENABLE_ALL_FEATURES, 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, featuresWereStripped) {
-      if (featuresWereStripped) {
-        Ember.warn('Ember.ENV.ENABLE_ALL_FEATURES is only available in canary builds.', !Ember.ENV.ENABLE_ALL_FEATURES);
-        Ember.warn('Ember.ENV.ENABLE_OPTIONAL_FEATURES is only available in canary builds.', !Ember.ENV.ENABLE_OPTIONAL_FEATURES);
-
-        for (var key in FEATURES) {
-          if (FEATURES.hasOwnProperty(key) && key !== 'isEnabled') {
-            Ember.warn('FEATURE["' + key + '"] is set as enabled, but FEATURE flags are only available in canary builds.', !FEATURES[key]);
+          if (isAttrRemovalValue(value)) {
+            element.removeAttribute(name);
+          } else {
+            if (namespace && element.setAttributeNS) {
+              element.setAttributeNS(namespace, name, value);
+            } else {
+              element.setAttribute(name, value);
+            }
           }
         }
       }
-    }
-
-    __exports__._warnIfUsingStrippedFeatureFlags = _warnIfUsingStrippedFeatureFlags;if (!Ember.testing) {
-      // Complain if they're using FEATURE flags in builds other than canary
-      Ember.FEATURES['features-stripped-test'] = true;
-      var featuresWereStripped = true;
-      
-      
-      delete Ember.FEATURES['features-stripped-test'];
-      _warnIfUsingStrippedFeatureFlags(Ember.ENV.FEATURES, featuresWereStripped);
-
-      // Inform the developer about the Ember Inspector if not installed.
-      var isFirefox = typeof InstallTrigger !== 'undefined';
-      var isChrome = !!window.chrome && !window.opera;
-
-      if (typeof window !== 'undefined' && (isFirefox || isChrome) && window.addEventListener) {
-        window.addEventListener("load", function() {
-          if (document.documentElement && document.documentElement.dataset && !document.documentElement.dataset.emberExtension) {
-            var downloadURL;
-
-            if(isChrome) {
-              downloadURL = 'https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi';
-            } else if(isFirefox) {
-              downloadURL = 'https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/';
-            }
+    };
 
-            Ember.debug('For more advanced debugging, install the Ember Inspector from ' + downloadURL);
+    if (doc && doc.createElementNS) {
+      // Only opt into namespace detection if a contextualElement
+      // is passed.
+      prototype.createElement = function(tagName, contextualElement) {
+        var namespace = this.namespace;
+        if (contextualElement) {
+          if (tagName === 'svg') {
+            namespace = svgNamespace;
+          } else {
+            namespace = interiorNamespace(contextualElement);
           }
-        }, false);
-      }
-    }
-
-    /*
-      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 = true;
-    __exports__.runningNonEmberDebugJS = runningNonEmberDebugJS;if (runningNonEmberDebugJS) {
-      Ember.warn('Please use `ember.debug.js` instead of `ember.js` for development and debugging.');
-    }
-  });
-enifed("ember-extension-support",
-  ["ember-metal/core","ember-extension-support/data_adapter","ember-extension-support/container_debug_adapter"],
-  function(__dependency1__, __dependency2__, __dependency3__) {
-    "use strict";
-    /**
-    Ember Extension Support
-
-    @module ember
-    @submodule ember-extension-support
-    @requires ember-application
-    */
-
-    var Ember = __dependency1__["default"];
-    var DataAdapter = __dependency2__["default"];
-    var ContainerDebugAdapter = __dependency3__["default"];
-
-    Ember.DataAdapter = DataAdapter;
-    Ember.ContainerDebugAdapter = ContainerDebugAdapter;
-  });
-enifed("ember-extension-support/container_debug_adapter",
-  ["ember-metal/core","ember-runtime/system/native_array","ember-metal/utils","ember-runtime/system/string","ember-runtime/system/namespace","ember-runtime/system/object","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var emberA = __dependency2__.A;
-    var typeOf = __dependency3__.typeOf;
-    var dasherize = __dependency4__.dasherize;
-    var classify = __dependency4__.classify;
-    var Namespace = __dependency5__["default"];
-    var EmberObject = __dependency6__["default"];
-
-    /**
-    @module ember
-    @submodule ember-extension-support
-    */
-
-    /**
-      The `ContainerDebugAdapter` helps the container and resolver interface
-      with tools that debug Ember such as the
-      [Ember Extension](https://github.com/tildeio/ember-extension)
-      for Chrome and Firefox.
-
-      This class can be extended by a custom resolver implementer
-      to override some of the methods with library-specific code.
-
-      The methods likely to be overridden are:
-
-      * `canCatalogEntriesByType`
-      * `catalogEntriesByType`
-
-      The adapter will need to be registered
-      in the application's container as `container-debug-adapter:main`
-
-      Example:
-
-      ```javascript
-      Application.initializer({
-        name: "containerDebugAdapter",
-
-        initialize: function(container, application) {
-          application.register('container-debug-adapter:main', require('app/container-debug-adapter'));
         }
-      });
-      ```
-
-      @class ContainerDebugAdapter
-      @namespace Ember
-      @extends Ember.Object
-      @since 1.5.0
-    */
-    __exports__["default"] = EmberObject.extend({
-      /**
-        The container of the application being debugged.
-        This property will be injected
-        on creation.
-
-        @property container
-        @default null
-      */
-      container: null,
-
-      /**
-        The resolver instance of the application
-        being debugged. This property will be injected
-        on creation.
-
-        @property resolver
-        @default null
-      */
-      resolver: null,
-
-      /**
-        Returns true if it is possible to catalog a list of available
-        classes in the resolver for a given type.
-
-        @method canCatalogEntriesByType
-        @param {String} type The type. e.g. "model", "controller", "route"
-        @return {boolean} whether a list is available for this type.
-      */
-      canCatalogEntriesByType: function(type) {
-        if (type === 'model' || type === 'template') return false;
-        return true;
-      },
-
-      /**
-        Returns the available classes a given type.
-
-        @method catalogEntriesByType
-        @param {String} type The type. e.g. "model", "controller", "route"
-        @return {Array} An array of strings.
-      */
-      catalogEntriesByType: function(type) {
-        var namespaces = emberA(Namespace.NAMESPACES), types = emberA();
-        var typeSuffixRegex = new RegExp(classify(type) + "$");
-
-        namespaces.forEach(function(namespace) {
-          if (namespace !== Ember) {
-            for (var key in namespace) {
-              if (!namespace.hasOwnProperty(key)) { continue; }
-              if (typeSuffixRegex.test(key)) {
-                var klass = namespace[key];
-                if (typeOf(klass) === 'class') {
-                  types.push(dasherize(key.replace(typeSuffixRegex, '')));
-                }
-              }
-            }
-          }
-        });
-        return types;
-      }
-    });
-  });
-enifed("ember-extension-support/data_adapter",
-  ["ember-metal/property_get","ember-metal/run_loop","ember-runtime/system/string","ember-runtime/system/namespace","ember-runtime/system/object","ember-runtime/system/native_array","ember-application/system/application","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
-    "use strict";
-    var get = __dependency1__.get;
-    var run = __dependency2__["default"];
-    var dasherize = __dependency3__.dasherize;
-    var Namespace = __dependency4__["default"];
-    var EmberObject = __dependency5__["default"];
-    var emberA = __dependency6__.A;
-    var Application = __dependency7__["default"];
-
-    /**
-    @module ember
-    @submodule ember-extension-support
-    */
-
-    /**
-      The `DataAdapter` helps a data persistence library
-      interface with tools that debug Ember such
-      as the [Ember Extension](https://github.com/tildeio/ember-extension)
-      for Chrome and Firefox.
-
-      This class will be extended by a persistence library
-      which will override some of the methods with
-      library-specific code.
-
-      The methods likely to be overridden are:
-
-      * `getFilters`
-      * `detect`
-      * `columnsForType`
-      * `getRecords`
-      * `getRecordColumnValues`
-      * `getRecordKeywords`
-      * `getRecordFilterValues`
-      * `getRecordColor`
-      * `observeRecord`
-
-      The adapter will need to be registered
-      in the application's container as `dataAdapter:main`
-
-      Example:
-
-      ```javascript
-      Application.initializer({
-        name: "data-adapter",
-
-        initialize: function(container, application) {
-          application.register('data-adapter:main', DS.DataAdapter);
+        if (namespace) {
+          return this.document.createElementNS(namespace, tagName);
+        } else {
+          return this.document.createElement(tagName);
         }
-      });
-      ```
-
-      @class DataAdapter
-      @namespace Ember
-      @extends EmberObject
-    */
-    __exports__["default"] = EmberObject.extend({
-      init: function() {
-        this._super();
-        this.releaseMethods = emberA();
-      },
-
-      /**
-        The container of the application being debugged.
-        This property will be injected
-        on creation.
-
-        @property container
-        @default null
-        @since 1.3.0
-      */
-      container: null,
-
-
-      /**
-        The container-debug-adapter which is used
-        to list all models.
-
-        @property containerDebugAdapter
-        @default undefined
-        @since 1.5.0
-      **/
-      containerDebugAdapter: undefined,
-
-      /**
-        Number of attributes to send
-        as columns. (Enough to make the record
-        identifiable).
-
-        @private
-        @property attributeLimit
-        @default 3
-        @since 1.3.0
-      */
-      attributeLimit: 3,
-
-      /**
-        Stores all methods that clear observers.
-        These methods will be called on destruction.
-
-        @private
-        @property releaseMethods
-        @since 1.3.0
-      */
-      releaseMethods: emberA(),
-
-      /**
-        Specifies how records can be filtered.
-        Records returned will need to have a `filterValues`
-        property with a key for every name in the returned array.
-
-        @public
-        @method getFilters
-        @return {Array} List of objects defining filters.
-         The object should have a `name` and `desc` property.
-      */
-      getFilters: function() {
-        return emberA();
-      },
-
-      /**
-        Fetch the model types and observe them for changes.
+      };
+      prototype.setAttributeNS = function(element, namespace, name, value) {
+        element.setAttributeNS(namespace, name, String(value));
+      };
+    } else {
+      prototype.createElement = function(tagName) {
+        return this.document.createElement(tagName);
+      };
+      prototype.setAttributeNS = function(element, namespace, name, value) {
+        element.setAttribute(name, String(value));
+      };
+    }
 
-        @public
-        @method watchModelTypes
+    prototype.addClasses = addClasses;
+    prototype.removeClasses = removeClasses;
 
-        @param {Function} typesAdded Callback to call to add types.
-        Takes an array of objects containing wrapped types (returned from `wrapModelType`).
+    prototype.setNamespace = function(ns) {
+      this.namespace = ns;
+    };
 
-        @param {Function} typesUpdated Callback to call when a type has changed.
-        Takes an array of objects containing wrapped types.
+    prototype.detectNamespace = function(element) {
+      this.namespace = interiorNamespace(element);
+    };
 
-        @return {Function} Method to call to remove all observers
-      */
-      watchModelTypes: function(typesAdded, typesUpdated) {
-        var modelTypes = this.getModelTypes();
-        var self = this;
-        var releaseMethods = emberA();
-        var typesToSend;
-
-        typesToSend = modelTypes.map(function(type) {
-          var klass = type.klass;
-          var wrapped = self.wrapModelType(klass, type.name);
-          releaseMethods.push(self.observeModelType(klass, typesUpdated));
-          return wrapped;
-        });
+    prototype.createDocumentFragment = function(){
+      return this.document.createDocumentFragment();
+    };
 
-        typesAdded(typesToSend);
+    prototype.createTextNode = function(text){
+      return this.document.createTextNode(text);
+    };
 
-        var release = function() {
-          releaseMethods.forEach(function(fn) { fn(); });
-          self.releaseMethods.removeObject(release);
-        };
-        this.releaseMethods.pushObject(release);
-        return release;
-      },
+    prototype.createComment = function(text){
+      return this.document.createComment(text);
+    };
 
-      _nameToClass: function(type) {
-        if (typeof type === 'string') {
-          type = this.container.lookupFactory('model:' + type);
+    prototype.repairClonedNode = function(element, blankChildTextNodes, isChecked){
+      if (deletesBlankTextNodes && blankChildTextNodes.length > 0) {
+        for (var i=0, len=blankChildTextNodes.length;i<len;i++){
+          var textNode = this.document.createTextNode(''),
+              offset = blankChildTextNodes[i],
+              before = this.childAtIndex(element, offset);
+          if (before) {
+            element.insertBefore(textNode, before);
+          } else {
+            element.appendChild(textNode);
+          }
         }
-        return type;
-      },
-
-      /**
-        Fetch the records of a given type and observe them for changes.
-
-        @public
-        @method watchRecords
-
-        @param {Function} recordsAdded Callback to call to add records.
-        Takes an array of objects containing wrapped records.
-        The object should have the following properties:
-          columnValues: {Object} key and value of a table cell
-          object: {Object} the actual record object
-
-        @param {Function} recordsUpdated Callback to call when a record has changed.
-        Takes an array of objects containing wrapped records.
+      }
+      if (ignoresCheckedAttribute && isChecked) {
+        element.setAttribute('checked', 'checked');
+      }
+    };
 
-        @param {Function} recordsRemoved Callback to call when a record has removed.
-        Takes the following parameters:
-          index: the array index where the records were removed
-          count: the number of records removed
+    prototype.cloneNode = function(element, deep){
+      var clone = element.cloneNode(!!deep);
+      return clone;
+    };
 
-        @return {Function} Method to call to remove all observers
-      */
-      watchRecords: function(type, recordsAdded, recordsUpdated, recordsRemoved) {
-        var self = this, releaseMethods = emberA(), records = this.getRecords(type), release;
+    prototype.createAttrMorph = function(element, attrName, namespace){
+      return new AttrMorph(element, attrName, this, namespace);
+    };
 
-        var recordUpdated = function(updatedRecord) {
-          recordsUpdated([updatedRecord]);
-        };
+    prototype.createUnsafeAttrMorph = function(element, attrName, namespace){
+      var morph = this.createAttrMorph(element, attrName, namespace);
+      morph.escaped = false;
+      return morph;
+    };
 
-        var recordsToSend = records.map(function(record) {
-          releaseMethods.push(self.observeRecord(record, recordUpdated));
-          return self.wrapRecord(record);
-        });
+    prototype.createMorph = function(parent, start, end, contextualElement){
+      if (contextualElement && contextualElement.nodeType === 11) {
+        throw new Error("Cannot pass a fragment as the contextual element to createMorph");
+      }
 
+      if (!contextualElement && parent.nodeType === 1) {
+        contextualElement = parent;
+      }
+      var morph = new Morph(this, contextualElement);
+      morph.firstNode = start;
+      morph.lastNode = end;
+      morph.state = {};
+      morph.isDirty = true;
+      return morph;
+    };
 
-        var contentDidChange = function(array, idx, removedCount, addedCount) {
-          for (var i = idx; i < idx + addedCount; i++) {
-            var record = array.objectAt(i);
-            var wrapped = self.wrapRecord(record);
-            releaseMethods.push(self.observeRecord(record, recordUpdated));
-            recordsAdded([wrapped]);
-          }
+    prototype.createUnsafeMorph = function(parent, start, end, contextualElement){
+      var morph = this.createMorph(parent, start, end, contextualElement);
+      morph.parseTextAsHTML = true;
+      return morph;
+    };
 
-          if (removedCount) {
-            recordsRemoved(idx, removedCount);
-          }
-        };
+    // This helper is just to keep the templates good looking,
+    // passing integers instead of element references.
+    prototype.createMorphAt = function(parent, startIndex, endIndex, contextualElement){
+      var single = startIndex === endIndex;
+      var start = this.childAtIndex(parent, startIndex);
+      var end = single ? start : this.childAtIndex(parent, endIndex);
+      return this.createMorph(parent, start, end, contextualElement);
+    };
 
-        var observer = { didChange: contentDidChange, willChange: function() { return this; } };
-        records.addArrayObserver(self, observer);
+    prototype.createUnsafeMorphAt = function(parent, startIndex, endIndex, contextualElement) {
+      var morph = this.createMorphAt(parent, startIndex, endIndex, contextualElement);
+      morph.parseTextAsHTML = true;
+      return morph;
+    };
 
-        release = function() {
-          releaseMethods.forEach(function(fn) { fn(); });
-          records.removeArrayObserver(self, observer);
-          self.releaseMethods.removeObject(release);
-        };
+    prototype.insertMorphBefore = function(element, referenceChild, contextualElement) {
+      var insertion = this.document.createComment('');
+      element.insertBefore(insertion, referenceChild);
+      return this.createMorph(element, insertion, insertion, contextualElement);
+    };
 
-        recordsAdded(recordsToSend);
+    prototype.appendMorph = function(element, contextualElement) {
+      var insertion = this.document.createComment('');
+      element.appendChild(insertion);
+      return this.createMorph(element, insertion, insertion, contextualElement);
+    };
 
-        this.releaseMethods.pushObject(release);
-        return release;
-      },
+    prototype.insertBoundary = function(fragment, index) {
+      // this will always be null or firstChild
+      var child = index === null ? null : this.childAtIndex(fragment, index);
+      this.insertBefore(fragment, this.createTextNode(''), child);
+    };
 
-      /**
-        Clear all observers before destruction
-        @private
-        @method willDestroy
-      */
-      willDestroy: function() {
-        this._super();
-        this.releaseMethods.forEach(function(fn) {
-          fn();
-        });
-      },
+    prototype.parseHTML = function(html, contextualElement) {
+      var childNodes;
 
-      /**
-        Detect whether a class is a model.
+      if (interiorNamespace(contextualElement) === svgNamespace) {
+        childNodes = buildSVGDOM(html, this);
+      } else {
+        var nodes = buildHTMLDOM(html, contextualElement, this);
+        if (detectOmittedStartTag(html, contextualElement)) {
+          var node = nodes[0];
+          while (node && node.nodeType !== 1) {
+            node = node.nextSibling;
+          }
+          childNodes = node.childNodes;
+        } else {
+          childNodes = nodes;
+        }
+      }
 
-        Test that against the model class
-        of your persistence library
+      // Copy node list to a fragment.
+      var fragment = this.document.createDocumentFragment();
 
-        @private
-        @method detect
-        @param {Class} klass The class to test
-        @return boolean Whether the class is a model class or not
-      */
-      detect: function(klass) {
-        return false;
-      },
+      if (childNodes && childNodes.length > 0) {
+        var currentNode = childNodes[0];
 
-      /**
-        Get the columns for a given model type.
+        // We prepend an <option> to <select> boxes to absorb any browser bugs
+        // related to auto-select behavior. Skip past it.
+        if (contextualElement.tagName === 'SELECT') {
+          currentNode = currentNode.nextSibling;
+        }
 
-        @private
-        @method columnsForType
-        @param {Class} type The model type
-        @return {Array} An array of columns of the following format:
-         name: {String} name of the column
-         desc: {String} Humanized description (what would show in a table column name)
-      */
-      columnsForType: function(type) {
-        return emberA();
-      },
+        while (currentNode) {
+          var tempNode = currentNode;
+          currentNode = currentNode.nextSibling;
 
-      /**
-        Adds observers to a model type class.
+          fragment.appendChild(tempNode);
+        }
+      }
 
-        @private
-        @method observeModelType
-        @param {Class} type The model type class
-        @param {Function} typesUpdated Called when a type is modified.
-        @return {Function} The function to call to remove observers
-      */
+      return fragment;
+    };
 
-      observeModelType: function(type, typesUpdated) {
-        var self = this;
-        var records = this.getRecords(type);
+    var parsingNode;
 
-        var onChange = function() {
-          typesUpdated([self.wrapModelType(type)]);
-        };
-        var observer = {
-          didChange: function() {
-            run.scheduleOnce('actions', this, onChange);
-          },
-          willChange: function() { return this; }
-        };
+    // Used to determine whether a URL needs to be sanitized.
+    prototype.protocolForURL = function(url) {
+      if (!parsingNode) {
+        parsingNode = this.document.createElement('a');
+      }
 
-        records.addArrayObserver(this, observer);
+      parsingNode.href = url;
+      return parsingNode.protocol;
+    };
 
-        var release = function() {
-          records.removeArrayObserver(self, observer);
-        };
+    __exports__["default"] = DOMHelper;
+  });
+enifed("dom-helper/build-html-dom",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /* global XMLSerializer:false */
+    var svgHTMLIntegrationPoints = {foreignObject: 1, desc: 1, title: 1};
+    __exports__.svgHTMLIntegrationPoints = svgHTMLIntegrationPoints;var svgNamespace = 'http://www.w3.org/2000/svg';
+    __exports__.svgNamespace = svgNamespace;
+    var doc = typeof document === 'undefined' ? false : document;
 
-        return release;
-      },
+    // Safari does not like using innerHTML on SVG HTML integration
+    // points (desc/title/foreignObject).
+    var needsIntegrationPointFix = doc && (function(document) {
+      if (document.createElementNS === undefined) {
+        return;
+      }
+      // In FF title will not accept innerHTML.
+      var testEl = document.createElementNS(svgNamespace, 'title');
+      testEl.innerHTML = "<div></div>";
+      return testEl.childNodes.length === 0 || testEl.childNodes[0].nodeType !== 1;
+    })(doc);
 
+    // Internet Explorer prior to 9 does not allow setting innerHTML if the first element
+    // is a "zero-scope" element. This problem can be worked around by making
+    // the first node an invisible text node. We, like Modernizr, use &shy;
+    var needsShy = doc && (function(document) {
+      var testEl = document.createElement('div');
+      testEl.innerHTML = "<div></div>";
+      testEl.firstChild.innerHTML = "<script><\/script>";
+      return testEl.firstChild.innerHTML === '';
+    })(doc);
 
-      /**
-        Wraps a given model type and observes changes to it.
+    // IE 8 (and likely earlier) likes to move whitespace preceeding
+    // a script tag to appear after it. This means that we can
+    // accidentally remove whitespace when updating a morph.
+    var movesWhitespace = doc && (function(document) {
+      var testEl = document.createElement('div');
+      testEl.innerHTML = "Test: <script type='text/x-placeholder'><\/script>Value";
+      return testEl.childNodes[0].nodeValue === 'Test:' &&
+              testEl.childNodes[2].nodeValue === ' Value';
+    })(doc);
 
-        @private
-        @method wrapModelType
-        @param {Class} type A model class
-        @param {String}  Optional name of the class
-        @return {Object} contains the wrapped type and the function to remove observers
-        Format:
-          type: {Object} the wrapped type
-            The wrapped type has the following format:
-              name: {String} name of the type
-              count: {Integer} number of records available
-              columns: {Columns} array of columns to describe the record
-              object: {Class} the actual Model type class
-          release: {Function} The function to remove observers
-      */
-      wrapModelType: function(type, name) {
-        var records = this.getRecords(type);
-        var typeToSend;
-
-        typeToSend = {
-          name: name || type.toString(),
-          count: get(records, 'length'),
-          columns: this.columnsForType(type),
-          object: type
+    var tagNamesRequiringInnerHTMLFix = doc && (function(document) {
+      var tagNamesRequiringInnerHTMLFix;
+      // IE 9 and earlier don't allow us to set innerHTML on col, colgroup, frameset,
+      // html, style, table, tbody, tfoot, thead, title, tr. Detect this and add
+      // them to an initial list of corrected tags.
+      //
+      // Here we are only dealing with the ones which can have child nodes.
+      //
+      var tableNeedsInnerHTMLFix;
+      var tableInnerHTMLTestElement = document.createElement('table');
+      try {
+        tableInnerHTMLTestElement.innerHTML = '<tbody></tbody>';
+      } catch (e) {
+      } finally {
+        tableNeedsInnerHTMLFix = (tableInnerHTMLTestElement.childNodes.length === 0);
+      }
+      if (tableNeedsInnerHTMLFix) {
+        tagNamesRequiringInnerHTMLFix = {
+          colgroup: ['table'],
+          table: [],
+          tbody: ['table'],
+          tfoot: ['table'],
+          thead: ['table'],
+          tr: ['table', 'tbody']
         };
+      }
 
+      // IE 8 doesn't allow setting innerHTML on a select tag. Detect this and
+      // add it to the list of corrected tags.
+      //
+      var selectInnerHTMLTestElement = document.createElement('select');
+      selectInnerHTMLTestElement.innerHTML = '<option></option>';
+      if (!selectInnerHTMLTestElement.childNodes[0]) {
+        tagNamesRequiringInnerHTMLFix = tagNamesRequiringInnerHTMLFix || {};
+        tagNamesRequiringInnerHTMLFix.select = [];
+      }
+      return tagNamesRequiringInnerHTMLFix;
+    })(doc);
 
-        return typeToSend;
-      },
-
+    function scriptSafeInnerHTML(element, html) {
+      // without a leading text node, IE will drop a leading script tag.
+      html = '&shy;'+html;
 
-      /**
-        Fetches all models defined in the application.
+      element.innerHTML = html;
 
-        @private
-        @method getModelTypes
-        @return {Array} Array of model types
-      */
-      getModelTypes: function() {
-        var self = this;
-        var containerDebugAdapter = this.get('containerDebugAdapter');
-        var types;
+      var nodes = element.childNodes;
 
-        if (containerDebugAdapter.canCatalogEntriesByType('model')) {
-          types = containerDebugAdapter.catalogEntriesByType('model');
+      // Look for &shy; to remove it.
+      var shyElement = nodes[0];
+      while (shyElement.nodeType === 1 && !shyElement.nodeName) {
+        shyElement = shyElement.firstChild;
+      }
+      // At this point it's the actual unicode character.
+      if (shyElement.nodeType === 3 && shyElement.nodeValue.charAt(0) === "\u00AD") {
+        var newValue = shyElement.nodeValue.slice(1);
+        if (newValue.length) {
+          shyElement.nodeValue = shyElement.nodeValue.slice(1);
         } else {
-          types = this._getObjectsOnNamespaces();
+          shyElement.parentNode.removeChild(shyElement);
         }
+      }
 
-        // New adapters return strings instead of classes
-        types = emberA(types).map(function(name) {
-          return {
-            klass: self._nameToClass(name),
-            name: name
-          };
-        });
-        types = emberA(types).filter(function(type) {
-          return self.detect(type.klass);
-        });
+      return nodes;
+    }
 
-        return emberA(types);
-      },
+    function buildDOMWithFix(html, contextualElement){
+      var tagName = contextualElement.tagName;
 
-      /**
-        Loops over all namespaces and all objects
-        attached to them
+      // Firefox versions < 11 do not have support for element.outerHTML.
+      var outerHTML = contextualElement.outerHTML || new XMLSerializer().serializeToString(contextualElement);
+      if (!outerHTML) {
+        throw "Can't set innerHTML on "+tagName+" in this browser";
+      }
 
-        @private
-        @method _getObjectsOnNamespaces
-        @return {Array} Array of model type strings
-      */
-      _getObjectsOnNamespaces: function() {
-        var namespaces = emberA(Namespace.NAMESPACES);
-        var types = emberA();
-        var self = this;
+      html = fixSelect(html, contextualElement);
 
-        namespaces.forEach(function(namespace) {
-          for (var key in namespace) {
-            if (!namespace.hasOwnProperty(key)) { continue; }
-            // Even though we will filter again in `getModelTypes`,
-            // we should not call `lookupContainer` on non-models
-            // (especially when `Ember.MODEL_FACTORY_INJECTIONS` is `true`)
-            if (!self.detect(namespace[key])) { continue; }
-            var name = dasherize(key);
-            if (!(namespace instanceof Application) && namespace.toString()) {
-              name = namespace + '/' + name;
-            }
-            types.push(name);
-          }
-        });
-        return types;
-      },
+      var wrappingTags = tagNamesRequiringInnerHTMLFix[tagName.toLowerCase()];
 
-      /**
-        Fetches all loaded records for a given type.
+      var startTag = outerHTML.match(new RegExp("<"+tagName+"([^>]*)>", 'i'))[0];
+      var endTag = '</'+tagName+'>';
 
-        @private
-        @method getRecords
-        @return {Array} An array of records.
-         This array will be observed for changes,
-         so it should update when new records are added/removed.
-      */
-      getRecords: function(type) {
-        return emberA();
-      },
+      var wrappedHTML = [startTag, html, endTag];
 
-      /**
-        Wraps a record and observers changes to it.
+      var i = wrappingTags.length;
+      var wrappedDepth = 1 + i;
+      while(i--) {
+        wrappedHTML.unshift('<'+wrappingTags[i]+'>');
+        wrappedHTML.push('</'+wrappingTags[i]+'>');
+      }
 
-        @private
-        @method wrapRecord
-        @param {Object} record The record instance.
-        @return {Object} The wrapped record. Format:
-        columnValues: {Array}
-        searchKeywords: {Array}
-      */
-      wrapRecord: function(record) {
-        var recordToSend = { object: record };
+      var wrapper = document.createElement('div');
+      scriptSafeInnerHTML(wrapper, wrappedHTML.join(''));
+      var element = wrapper;
+      while (wrappedDepth--) {
+        element = element.firstChild;
+        while (element && element.nodeType !== 1) {
+          element = element.nextSibling;
+        }
+      }
+      while (element && element.tagName !== tagName) {
+        element = element.nextSibling;
+      }
+      return element ? element.childNodes : [];
+    }
 
-        recordToSend.columnValues = this.getRecordColumnValues(record);
-        recordToSend.searchKeywords = this.getRecordKeywords(record);
-        recordToSend.filterValues = this.getRecordFilterValues(record);
-        recordToSend.color = this.getRecordColor(record);
+    var buildDOM;
+    if (needsShy) {
+      buildDOM = function buildDOM(html, contextualElement, dom){
+        html = fixSelect(html, contextualElement);
 
-        return recordToSend;
-      },
+        contextualElement = dom.cloneNode(contextualElement, false);
+        scriptSafeInnerHTML(contextualElement, html);
+        return contextualElement.childNodes;
+      };
+    } else {
+      buildDOM = function buildDOM(html, contextualElement, dom){
+        html = fixSelect(html, contextualElement);
 
-      /**
-        Gets the values for each column.
+        contextualElement = dom.cloneNode(contextualElement, false);
+        contextualElement.innerHTML = html;
+        return contextualElement.childNodes;
+      };
+    }
 
-        @private
-        @method getRecordColumnValues
-        @return {Object} Keys should match column names defined
-        by the model type.
-      */
-      getRecordColumnValues: function(record) {
-        return {};
-      },
+    function fixSelect(html, contextualElement) {
+      if (contextualElement.tagName === 'SELECT') {
+        html = "<option></option>" + html;
+      }
 
-      /**
-        Returns keywords to match when searching records.
+      return html;
+    }
 
-        @private
-        @method getRecordKeywords
-        @return {Array} Relevant keywords for search.
-      */
-      getRecordKeywords: function(record) {
-        return emberA();
-      },
+    var buildIESafeDOM;
+    if (tagNamesRequiringInnerHTMLFix || movesWhitespace) {
+      buildIESafeDOM = function buildIESafeDOM(html, contextualElement, dom) {
+        // Make a list of the leading text on script nodes. Include
+        // script tags without any whitespace for easier processing later.
+        var spacesBefore = [];
+        var spacesAfter = [];
+        if (typeof html === 'string') {
+          html = html.replace(/(\s*)(<script)/g, function(match, spaces, tag) {
+            spacesBefore.push(spaces);
+            return tag;
+          });
 
-      /**
-        Returns the values of filters defined by `getFilters`.
+          html = html.replace(/(<\/script>)(\s*)/g, function(match, tag, spaces) {
+            spacesAfter.push(spaces);
+            return tag;
+          });
+        }
 
-        @private
-        @method getRecordFilterValues
-        @param {Object} record The record instance
-        @return {Object} The filter values
-      */
-      getRecordFilterValues: function(record) {
-        return {};
-      },
+        // Fetch nodes
+        var nodes;
+        if (tagNamesRequiringInnerHTMLFix[contextualElement.tagName.toLowerCase()]) {
+          // buildDOMWithFix uses string wrappers for problematic innerHTML.
+          nodes = buildDOMWithFix(html, contextualElement);
+        } else {
+          nodes = buildDOM(html, contextualElement, dom);
+        }
 
-      /**
-        Each record can have a color that represents its state.
+        // Build a list of script tags, the nodes themselves will be
+        // mutated as we add test nodes.
+        var i, j, node, nodeScriptNodes;
+        var scriptNodes = [];
+        for (i=0;i<nodes.length;i++) {
+          node=nodes[i];
+          if (node.nodeType !== 1) {
+            continue;
+          }
+          if (node.tagName === 'SCRIPT') {
+            scriptNodes.push(node);
+          } else {
+            nodeScriptNodes = node.getElementsByTagName('script');
+            for (j=0;j<nodeScriptNodes.length;j++) {
+              scriptNodes.push(nodeScriptNodes[j]);
+            }
+          }
+        }
 
-        @private
-        @method getRecordColor
-        @param {Object} record The record instance
-        @return {String} The record's color
-          Possible options: black, red, blue, green
-      */
-      getRecordColor: function(record) {
-        return null;
-      },
+        // Walk the script tags and put back their leading text nodes.
+        var scriptNode, textNode, spaceBefore, spaceAfter;
+        for (i=0;i<scriptNodes.length;i++) {
+          scriptNode = scriptNodes[i];
+          spaceBefore = spacesBefore[i];
+          if (spaceBefore && spaceBefore.length > 0) {
+            textNode = dom.document.createTextNode(spaceBefore);
+            scriptNode.parentNode.insertBefore(textNode, scriptNode);
+          }
 
-      /**
-        Observes all relevant properties and re-sends the wrapped record
-        when a change occurs.
+          spaceAfter = spacesAfter[i];
+          if (spaceAfter && spaceAfter.length > 0) {
+            textNode = dom.document.createTextNode(spaceAfter);
+            scriptNode.parentNode.insertBefore(textNode, scriptNode.nextSibling);
+          }
+        }
 
-        @private
-        @method observerRecord
-        @param {Object} record The record instance
-        @param {Function} recordUpdated The callback to call when a record is updated.
-        @return {Function} The function to call to remove all observers.
-      */
-      observeRecord: function(record, recordUpdated) {
-        return function(){};
-      }
-    });
-  });
-enifed("ember-htmlbars",
-  ["ember-metal/core","ember-template-compiler","ember-htmlbars/hooks/inline","ember-htmlbars/hooks/content","ember-htmlbars/hooks/component","ember-htmlbars/hooks/block","ember-htmlbars/hooks/element","ember-htmlbars/hooks/subexpr","ember-htmlbars/hooks/attribute","ember-htmlbars/hooks/concat","ember-htmlbars/hooks/get","ember-htmlbars/hooks/set","morph","ember-htmlbars/system/make-view-helper","ember-htmlbars/system/make_bound_helper","ember-htmlbars/helpers","ember-htmlbars/helpers/binding","ember-htmlbars/helpers/view","ember-htmlbars/helpers/yield","ember-htmlbars/helpers/with","ember-htmlbars/helpers/log","ember-htmlbars/helpers/debugger","ember-htmlbars/helpers/bind-attr","ember-htmlbars/helpers/if_unless","ember-htmlbars/helpers/loc","ember-htmlbars/helpers/partial","ember-htmlbars/helpers/template","ember-htmlbars/helpers/input","ember-htmlbars/helpers/text_area","ember-htmlbars/helpers/collection","ember-htmlbars/helpers/each","ember-htmlbars/helpers/unbound","ember-htmlbars/system/bootstrap","ember-htmlbars/compat","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __dependency21__, __dependency22__, __dependency23__, __dependency24__, __dependency25__, __dependency26__, __dependency27__, __dependency28__, __dependency29__, __dependency30__, __dependency31__, __dependency32__, __dependency33__, __dependency34__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-
-    var precompile = __dependency2__.precompile;
-    var compile = __dependency2__.compile;
-    var template = __dependency2__.template;
-    var registerPlugin = __dependency2__.registerPlugin;
-
-    var inline = __dependency3__["default"];
-    var content = __dependency4__["default"];
-    var component = __dependency5__["default"];
-    var block = __dependency6__["default"];
-    var element = __dependency7__["default"];
-    var subexpr = __dependency8__["default"];
-    var attribute = __dependency9__["default"];
-    var concat = __dependency10__["default"];
-    var get = __dependency11__["default"];
-    var set = __dependency12__["default"];
-    var DOMHelper = __dependency13__.DOMHelper;
-    var makeViewHelper = __dependency14__["default"];
-    var makeBoundHelper = __dependency15__["default"];
-
-    var registerHelper = __dependency16__.registerHelper;
-    var helpers = __dependency16__["default"];
-    var bindHelper = __dependency17__.bindHelper;
-    var viewHelper = __dependency18__.viewHelper;
-    var yieldHelper = __dependency19__.yieldHelper;
-    var withHelper = __dependency20__.withHelper;
-    var logHelper = __dependency21__.logHelper;
-    var debuggerHelper = __dependency22__.debuggerHelper;
-    var bindAttrHelper = __dependency23__.bindAttrHelper;
-    var bindAttrHelperDeprecated = __dependency23__.bindAttrHelperDeprecated;
-    var ifHelper = __dependency24__.ifHelper;
-    var unlessHelper = __dependency24__.unlessHelper;
-    var unboundIfHelper = __dependency24__.unboundIfHelper;
-    var boundIfHelper = __dependency24__.boundIfHelper;
-    var locHelper = __dependency25__.locHelper;
-    var partialHelper = __dependency26__.partialHelper;
-    var templateHelper = __dependency27__.templateHelper;
-    var inputHelper = __dependency28__.inputHelper;
-    var textareaHelper = __dependency29__.textareaHelper;
-    var collectionHelper = __dependency30__.collectionHelper;
-    var eachHelper = __dependency31__.eachHelper;
-    var unboundHelper = __dependency32__.unboundHelper;
-
-    // importing adds template bootstrapping
-    // initializer to enable embedded templates
-
-    // importing ember-htmlbars/compat updates the
-    // Ember.Handlebars global if htmlbars is enabled
-
-    registerHelper('bindHelper', bindHelper);
-    registerHelper('bind', bindHelper);
-    registerHelper('view', viewHelper);
-    registerHelper('yield', yieldHelper);
-    registerHelper('with', withHelper);
-    registerHelper('if', ifHelper);
-    registerHelper('unless', unlessHelper);
-    registerHelper('unboundIf', unboundIfHelper);
-    registerHelper('boundIf', boundIfHelper);
-    registerHelper('log', logHelper);
-    registerHelper('debugger', debuggerHelper);
-    registerHelper('loc', locHelper);
-    registerHelper('partial', partialHelper);
-    registerHelper('template', templateHelper);
-    registerHelper('bind-attr', bindAttrHelper);
-    registerHelper('bindAttr', bindAttrHelperDeprecated);
-    registerHelper('input', inputHelper);
-    registerHelper('textarea', textareaHelper);
-    registerHelper('collection', collectionHelper);
-    registerHelper('each', eachHelper);
-    registerHelper('unbound', unboundHelper);
-    registerHelper('concat', concat);
-
-    
-      Ember.HTMLBars = {
-        _registerHelper: registerHelper,
-        template: template,
-        compile: compile,
-        precompile: precompile,
-        makeViewHelper: makeViewHelper,
-        makeBoundHelper: makeBoundHelper,
-        registerPlugin: registerPlugin
+        return nodes;
       };
+    } else {
+      buildIESafeDOM = buildDOM;
+    }
 
-    
-
-    var defaultEnv = {
-      dom: new DOMHelper(),
-
-      hooks: {
-        get: get,
-        set: set,
-        inline: inline,
-        content: content,
-        block: block,
-        element: element,
-        subexpr: subexpr,
-        component: component,
-        attribute: attribute,
-        concat: concat
-      },
-
-      helpers: helpers,
-      useFragmentCache: true
-    };
-    __exports__.defaultEnv = defaultEnv;
-  });
-enifed("ember-htmlbars/compat",
-  ["ember-metal/core","ember-htmlbars/helpers","ember-htmlbars/compat/helper","ember-htmlbars/compat/handlebars-get","ember-htmlbars/compat/make-bound-helper","ember-htmlbars/compat/register-bound-helper","ember-htmlbars/system/make-view-helper","ember-htmlbars/utils/string","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var helpers = __dependency2__["default"];
-    var compatRegisterHelper = __dependency3__.registerHandlebarsCompatibleHelper;
-    var compatHandlebarsHelper = __dependency3__.handlebarsHelper;
-    var compatHandlebarsGet = __dependency4__["default"];
-    var compatMakeBoundHelper = __dependency5__["default"];
-    var compatRegisterBoundHelper = __dependency6__["default"];
-    var makeViewHelper = __dependency7__["default"];
-    var SafeString = __dependency8__.SafeString;
-    var escapeExpression = __dependency8__.escapeExpression;
-
-    var EmberHandlebars;
-    
-      EmberHandlebars = Ember.Handlebars = Ember.Handlebars || {};
-      EmberHandlebars.helpers = helpers;
-      EmberHandlebars.helper = compatHandlebarsHelper;
-      EmberHandlebars.registerHelper = compatRegisterHelper;
-      EmberHandlebars.registerBoundHelper = compatRegisterBoundHelper;
-      EmberHandlebars.makeBoundHelper = compatMakeBoundHelper;
-      EmberHandlebars.get = compatHandlebarsGet;
-      EmberHandlebars.makeViewHelper = makeViewHelper;
-
-      EmberHandlebars.SafeString = SafeString;
-      EmberHandlebars.Utils =  {
-        escapeExpression: escapeExpression
+    var buildHTMLDOM;
+    if (needsIntegrationPointFix) {
+      buildHTMLDOM = function buildHTMLDOM(html, contextualElement, dom){
+        if (svgHTMLIntegrationPoints[contextualElement.tagName]) {
+          return buildIESafeDOM(html, document.createElement('div'), dom);
+        } else {
+          return buildIESafeDOM(html, contextualElement, dom);
+        }
       };
-    
+    } else {
+      buildHTMLDOM = buildIESafeDOM;
+    }
 
-    __exports__["default"] = EmberHandlebars;
+    __exports__.buildHTMLDOM = buildHTMLDOM;
   });
-enifed("ember-htmlbars/compat/handlebars-get",
+enifed("dom-helper/classes",
   ["exports"],
   function(__exports__) {
     "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
-
-    /**
-      Lookup both on root and on window. If the path starts with
-      a keyword, the corresponding object will be looked up in the
-      template's data hash and used to resolve the path.
+    var doc = typeof document === 'undefined' ? false : document;
 
-      @method get
-      @for Ember.Handlebars
-      @param {Object} root The object to look up the property on
-      @param {String} path The path to be lookedup
-      @param {Object} options The template's option hash
-      @deprecated
-    */
-    __exports__["default"] = function handlebarsGet(root, path, options) {
-      Ember.deprecate('Usage of Ember.Handlebars.get is deprecated, use a Component or Ember.Handlebars.makeBoundHelper instead.');
+    // PhantomJS has a broken classList. See https://github.com/ariya/phantomjs/issues/12782
+    var canClassList = doc && (function(){
+      var d = document.createElement('div');
+      if (!d.classList) {
+        return false;
+      }
+      d.classList.add('boo');
+      d.classList.add('boo', 'baz');
+      return (d.className === 'boo baz');
+    })();
 
-      return options.data.view.getStream(path).value();
+    function buildClassList(element) {
+      var classString = (element.getAttribute('class') || '');
+      return classString !== '' && classString !== ' ' ? classString.split(' ') : [];
     }
-  });
-enifed("ember-htmlbars/compat/helper",
-  ["ember-metal/merge","ember-htmlbars/helpers","ember-views/views/view","ember-views/views/component","ember-htmlbars/system/make-view-helper","ember-htmlbars/compat/make-bound-helper","ember-metal/streams/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
 
-    var merge = __dependency1__["default"];
-    var helpers = __dependency2__["default"];
-    var View = __dependency3__["default"];
-    var Component = __dependency4__["default"];
-    var makeViewHelper = __dependency5__["default"];
-    var makeBoundHelper = __dependency6__["default"];
-    var isStream = __dependency7__.isStream;
-
-    var slice = [].slice;
+    function intersect(containingArray, valuesArray) {
+      var containingIndex = 0;
+      var containingLength = containingArray.length;
+      var valuesIndex = 0;
+      var valuesLength = valuesArray.length;
 
-    function calculateCompatType(item) {
-      if (isStream(item)) {
-        return 'ID';
-      } else {
-        var itemType = typeof item;
+      var intersection = new Array(valuesLength);
 
-        return itemType.toUpperCase();
+      // TODO: rewrite this loop in an optimal manner
+      for (;containingIndex<containingLength;containingIndex++) {
+        valuesIndex = 0;
+        for (;valuesIndex<valuesLength;valuesIndex++) {
+          if (valuesArray[valuesIndex] === containingArray[containingIndex]) {
+            intersection[valuesIndex] = containingIndex;
+            break;
+          }
+        }
       }
+
+      return intersection;
     }
 
-    /**
-      Wraps an Handlebars helper with an HTMLBars helper for backwards compatibility.
+    function addClassesViaAttribute(element, classNames) {
+      var existingClasses = buildClassList(element);
 
-      @class HandlebarsCompatibleHelper
-      @constructor
-      @private
-    */
-    function HandlebarsCompatibleHelper(fn) {
-      this.helperFunction = function helperFunc(params, hash, options, env) {
-        var param, blockResult, fnResult;
-        var context = this;
-        var handlebarsOptions = {
-          hash: { },
-          types: new Array(params.length),
-          hashTypes: { }
-        };
+      var indexes = intersect(existingClasses, classNames);
+      var didChange = false;
+
+      for (var i=0, l=classNames.length; i<l; i++) {
+        if (indexes[i] === undefined) {
+          didChange = true;
+          existingClasses.push(classNames[i]);
+        }
+      }
 
-        merge(handlebarsOptions, options);
-        merge(handlebarsOptions, env);
+      if (didChange) {
+        element.setAttribute('class', existingClasses.length > 0 ? existingClasses.join(' ') : '');
+      }
+    }
 
-        handlebarsOptions.hash = {};
+    function removeClassesViaAttribute(element, classNames) {
+      var existingClasses = buildClassList(element);
 
-        if (options.isBlock) {
-          handlebarsOptions.fn = function() {
-            blockResult = options.template.render(context, env, options.morph.contextualElement);
-          };
-        }
+      var indexes = intersect(classNames, existingClasses);
+      var didChange = false;
+      var newClasses = [];
 
-        for (var prop in hash) {
-          param = hash[prop];
+      for (var i=0, l=existingClasses.length; i<l; i++) {
+        if (indexes[i] === undefined) {
+          newClasses.push(existingClasses[i]);
+        } else {
+          didChange = true;
+        }
+      }
 
-          handlebarsOptions.hashTypes[prop] = calculateCompatType(param);
+      if (didChange) {
+        element.setAttribute('class', newClasses.length > 0 ? newClasses.join(' ') : '');
+      }
+    }
 
-          if (isStream(param)) {
-            handlebarsOptions.hash[prop] = param._label;
+    var addClasses, removeClasses;
+    if (canClassList) {
+      addClasses = function addClasses(element, classNames) {
+        if (element.classList) {
+          if (classNames.length === 1) {
+            element.classList.add(classNames[0]);
+          } else if (classNames.length === 2) {
+            element.classList.add(classNames[0], classNames[1]);
           } else {
-            handlebarsOptions.hash[prop] = param;
+            element.classList.add.apply(element.classList, classNames);
           }
+        } else {
+          addClassesViaAttribute(element, classNames);
         }
-
-        var args = new Array(params.length);
-        for (var i = 0, l = params.length; i < l; i++) {
-          param = params[i];
-
-          handlebarsOptions.types[i] = calculateCompatType(param);
-
-          if (isStream(param)) {
-            args[i] = param._label;
+      };
+      removeClasses = function removeClasses(element, classNames) {
+        if (element.classList) {
+          if (classNames.length === 1) {
+            element.classList.remove(classNames[0]);
+          } else if (classNames.length === 2) {
+            element.classList.remove(classNames[0], classNames[1]);
           } else {
-            args[i] = param;
+            element.classList.remove.apply(element.classList, classNames);
           }
+        } else {
+          removeClassesViaAttribute(element, classNames);
         }
-        args.push(handlebarsOptions);
-
-        fnResult = fn.apply(this, args);
-
-        return options.isBlock ? blockResult : fnResult;
       };
-
-      this.isHTMLBars = true;
+    } else {
+      addClasses = addClassesViaAttribute;
+      removeClasses = removeClassesViaAttribute;
     }
 
-    HandlebarsCompatibleHelper.prototype = {
-      preprocessArguments: function() { }
-    };
-
-    function registerHandlebarsCompatibleHelper(name, value) {
-      var helper;
+    __exports__.addClasses = addClasses;
+    __exports__.removeClasses = removeClasses;
+  });
+enifed("dom-helper/prop",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    function isAttrRemovalValue(value) {
+      return value === null || value === undefined;
+    }
 
-      if (value && value.isHTMLBars) {
-        helper = value;
-      } else {
-        helper = new HandlebarsCompatibleHelper(value);
+    __exports__.isAttrRemovalValue = isAttrRemovalValue;// TODO should this be an o_create kind of thing?
+    var propertyCaches = {};
+    __exports__.propertyCaches = propertyCaches;
+    function normalizeProperty(element, attrName) {
+      var tagName = element.tagName;
+      var key;
+      var cache = propertyCaches[tagName];
+      if (!cache) {
+        // TODO should this be an o_create kind of thing?
+        cache = {};
+        for (key in element) {
+          cache[key.toLowerCase()] = key;
+        }
+        propertyCaches[tagName] = cache;
       }
 
-      helpers[name] = helper;
+      // presumes that the attrName has been lowercased.
+      return cache[attrName];
     }
 
-    __exports__.registerHandlebarsCompatibleHelper = registerHandlebarsCompatibleHelper;function handlebarsHelper(name, value) {
-      Ember.assert("You tried to register a component named '" + name +
-                   "', but component names must include a '-'", !Component.detect(value) || name.match(/-/));
-
-      if (View.detect(value)) {
-        helpers[name] = makeViewHelper(value);
-      } else {
-        var boundHelperArgs = slice.call(arguments, 1);
-        var boundFn = makeBoundHelper.apply(this, boundHelperArgs);
+    __exports__.normalizeProperty = normalizeProperty;
+  });
+enifed('ember-application', ['ember-metal/core', 'ember-runtime/system/lazy_load', 'ember-application/system/resolver', 'ember-application/system/application', 'ember-application/ext/controller'], function (Ember, lazy_load, resolver, Application) {
 
-        helpers[name] = boundFn;
-      }
-    }
+  'use strict';
 
-    __exports__.handlebarsHelper = handlebarsHelper;__exports__["default"] = HandlebarsCompatibleHelper;
-  });
-enifed("ember-htmlbars/compat/make-bound-helper",
-  ["ember-metal/core","ember-metal/mixin","ember-htmlbars/system/helper","ember-metal/streams/stream","ember-metal/streams/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+  Ember['default'].Application = Application['default'];
+  Ember['default'].Resolver = resolver.Resolver;
+  Ember['default'].DefaultResolver = resolver["default"];
 
-    var Ember = __dependency1__["default"];
-    // Ember.FEATURES, Ember.assert, Ember.Handlebars, Ember.lookup
-    var IS_BINDING = __dependency2__.IS_BINDING;
-    var Helper = __dependency3__["default"];
+  lazy_load.runLoadHooks('Ember.Application', Application['default']);
 
-    var Stream = __dependency4__["default"];
-    var readArray = __dependency5__.readArray;
-    var scanArray = __dependency5__.scanArray;
-    var scanHash = __dependency5__.scanHash;
-    var readHash = __dependency5__.readHash;
-    var isStream = __dependency5__.isStream;
+});
+enifed('ember-application/ext/controller', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/error', 'ember-metal/utils', 'ember-metal/computed', 'ember-runtime/mixins/controller', 'ember-routing/system/controller_for'], function (exports, Ember, property_get, EmberError, utils, computed, ControllerMixin, controllerFor) {
 
-    /**
-      A helper function used by `registerBoundHelper`. Takes the
-      provided Handlebars helper function fn and returns it in wrapped
-      bound helper form.
+  'use strict';
 
-      The main use case for using this outside of `registerBoundHelper`
-      is for registering helpers on the container:
+  /**
+  @module ember
+  @submodule ember-application
+  */
 
-      ```js
-      var boundHelperFn = Ember.Handlebars.makeBoundHelper(function(word) {
-        return word.toUpperCase();
-      });
+  function verifyNeedsDependencies(controller, container, needs) {
+    var dependency, i, l;
+    var missing = [];
 
-      container.register('helper:my-bound-helper', boundHelperFn);
-      ```
+    for (i=0, l=needs.length; i<l; i++) {
+      dependency = needs[i];
 
-      In the above example, if the helper function hadn't been wrapped in
-      `makeBoundHelper`, the registered helper would be unbound.
+      Ember['default'].assert(utils.inspect(controller) + "#needs must not specify dependencies with periods in their names (" +
+                   dependency + ")", dependency.indexOf('.') === -1);
 
-      @method makeBoundHelper
-      @for Ember.Handlebars
-      @param {Function} function
-      @param {String} dependentKeys*
-      @since 1.2.0
-      @deprecated
-    */
-    __exports__["default"] = function makeBoundHelper(fn, compatMode) {
-      var dependentKeys = [];
-      for (var i = 1; i < arguments.length; i++) {
-        dependentKeys.push(arguments[i]);
+      if (dependency.indexOf(':') === -1) {
+        dependency = "controller:" + dependency;
       }
 
-      function helperFunc(params, hash, options, env) {
-        var view = this;
-        var numParams = params.length;
-        var param;
-
-        Ember.assert("registerBoundHelper-generated helpers do not support use with Handlebars blocks.", !options.template);
+      // Structure assert to still do verification but not string concat in production
+      if (!container._registry.has(dependency)) {
+        missing.push(dependency);
+      }
+    }
+    if (missing.length) {
+      throw new EmberError['default'](utils.inspect(controller) + " needs [ " + missing.join(', ') +
+                           " ] but " + (missing.length > 1 ? 'they' : 'it') + " could not be found");
+    }
+  }
 
-        for (var prop in hash) {
-          if (IS_BINDING.test(prop)) {
-            hash[prop.slice(0, -7)] = view.getStream(hash[prop]);
-            delete hash[prop];
-          }
-        }
+  var defaultControllersComputedProperty = computed.computed(function() {
+    var controller = this;
 
-        function valueFn() {
-          var args = readArray(params);
-          var properties = new Array(params.length);
-          for (var i = 0, l = params.length; i < l; i++) {
-            param = params[i];
+    return {
+      needs: property_get.get(controller, 'needs'),
+      container: property_get.get(controller, 'container'),
+      unknownProperty: function(controllerName) {
+        var needs = this.needs;
+        var dependency, i, l;
 
-            if (isStream(param)) {
-              properties[i] = param._label;
-            } else {
-              properties[i] = param;
-            }
+        for (i=0, l=needs.length; i<l; i++) {
+          dependency = needs[i];
+          if (dependency === controllerName) {
+            return this.container.lookup('controller:' + controllerName);
           }
-
-          args.push({
-            hash: readHash(hash),
-            data: { properties: properties }
-          });
-          return fn.apply(view, args);
         }
 
-        // If none of the hash parameters are bound, act as an unbound helper.
-        // This prevents views from being unnecessarily created
-        var hasStream = scanArray(params) || scanHash(hash);
-
-        if (env.data.isUnbound || !hasStream){
-          return valueFn();
-        } else {
-          var lazyValue = new Stream(valueFn);
-
-          for (i = 0; i < numParams; i++) {
-            param = params[i];
-            if (isStream(param)) {
-              param.subscribe(lazyValue.notify, lazyValue);
-            }
-          }
-
-          for (prop in hash) {
-            param = hash[prop];
-            if (isStream(param)) {
-              param.subscribe(lazyValue.notify, lazyValue);
-            }
-          }
-
-          if (numParams > 0) {
-            var firstParam = params[0];
-            // Only bother with subscriptions if the first argument
-            // is a stream itself, and not a primitive.
-            if (isStream(firstParam)) {
-              var onDependentKeyNotify = function onDependentKeyNotify(stream) {
-                stream.value();
-                lazyValue.notify();
-              };
-              for (i = 0; i < dependentKeys.length; i++) {
-                var childParam = firstParam.get(dependentKeys[i]);
-                childParam.value();
-                childParam.subscribe(onDependentKeyNotify);
-              }
-            }
-          }
-
-          return lazyValue;
-        }
+        var errorMessage = utils.inspect(controller) + '#needs does not include `' +
+                           controllerName + '`. To access the ' +
+                           controllerName + ' controller from ' +
+                           utils.inspect(controller) + ', ' +
+                           utils.inspect(controller) +
+                           ' should have a `needs` property that is an array of the controllers it has access to.';
+        throw new ReferenceError(errorMessage);
+      },
+      setUnknownProperty: function (key, value) {
+        throw new Error("You cannot overwrite the value of `controllers." + key + "` of " + utils.inspect(controller));
       }
-
-      return new Helper(helperFunc);
-    }
+    };
   });
-enifed("ember-htmlbars/compat/register-bound-helper",
-  ["ember-htmlbars/helpers","ember-htmlbars/compat/make-bound-helper","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
 
-    var helpers = __dependency1__["default"];
-    var makeBoundHelper = __dependency2__["default"];
-
-    var slice = [].slice;
+  /**
+    @class ControllerMixin
+    @namespace Ember
+  */
+  ControllerMixin['default'].reopen({
+    concatenatedProperties: ['needs'],
 
     /**
-      Register a bound handlebars helper. Bound helpers behave similarly to regular
-      handlebars helpers, with the added ability to re-render when the underlying data
-      changes.
+      An array of other controller objects available inside
+      instances of this controller via the `controllers`
+      property:
 
-      ## Simple example
+      For example, when you define a controller:
 
       ```javascript
-      Ember.Handlebars.registerBoundHelper('capitalize', function(value) {
-        return Ember.String.capitalize(value);
+      App.CommentsController = Ember.ArrayController.extend({
+        needs: ['post']
       });
       ```
 
-      The above bound helper can be used inside of templates as follows:
-
-      ```handlebars
-      {{capitalize name}}
-      ```
-
-      In this case, when the `name` property of the template's context changes,
-      the rendered value of the helper will update to reflect this change.
-
-      ## Example with options
-
-      Like normal handlebars helpers, bound helpers have access to the options
-      passed into the helper call.
+      The application's single instance of these other
+      controllers are accessible by name through the
+      `controllers` property:
 
       ```javascript
-      Ember.Handlebars.registerBoundHelper('repeat', function(value, options) {
-        var count = options.hash.count;
-        var a = [];
-        while(a.length < count) {
-            a.push(value);
-        }
-        return a.join('');
-      });
-      ```
-
-      This helper could be used in a template as follows:
-
-      ```handlebars
-      {{repeat text count=3}}
-      ```
-
-      ## Example with bound options
-
-      Bound hash options are also supported. Example:
-
-      ```handlebars
-      {{repeat text count=numRepeats}}
+      this.get('controllers.post'); // instance of App.PostController
       ```
 
-      In this example, count will be bound to the value of
-      the `numRepeats` property on the context. If that property
-      changes, the helper will be re-rendered.
-
-      ## Example with extra dependencies
-
-      The `Ember.Handlebars.registerBoundHelper` method takes a variable length
-      third parameter which indicates extra dependencies on the passed in value.
-      This allows the handlebars helper to update when these dependencies change.
+      Given that you have a nested controller (nested resource):
 
       ```javascript
-      Ember.Handlebars.registerBoundHelper('capitalizeName', function(value) {
-        return value.get('name').toUpperCase();
-      }, 'name');
+      App.CommentsNewController = Ember.ObjectController.extend({
+      });
       ```
 
-      ## Example with multiple bound properties
-
-      `Ember.Handlebars.registerBoundHelper` supports binding to
-      multiple properties, e.g.:
+      When you define a controller that requires access to a nested one:
 
       ```javascript
-      Ember.Handlebars.registerBoundHelper('concatenate', function() {
-        var values = Array.prototype.slice.call(arguments, 0, -1);
-        return values.join('||');
+      App.IndexController = Ember.ObjectController.extend({
+        needs: ['commentsNew']
       });
       ```
 
-      Which allows for template syntax such as `{{concatenate prop1 prop2}}` or
-      `{{concatenate prop1 prop2 prop3}}`. If any of the properties change,
-      the helper will re-render.  Note that dependency keys cannot be
-      using in conjunction with multi-property helpers, since it is ambiguous
-      which property the dependent keys would belong to.
-
-      ## Use with unbound helper
+      You will be able to get access to it:
 
-      The `{{unbound}}` helper can be used with bound helper invocations
-      to render them in their unbound form, e.g.
-
-      ```handlebars
-      {{unbound capitalize name}}
+      ```javascript
+      this.get('controllers.commentsNew'); // instance of App.CommentsNewController
       ```
 
-      In this example, if the name property changes, the helper
-      will not re-render.
-
-      ## Use with blocks not supported
-
-      Bound helpers do not support use with Handlebars blocks or
-      the addition of child views of any kind.
-
-      @method registerBoundHelper
-      @for Ember.Handlebars
-      @param {String} name
-      @param {Function} function
-      @param {String} dependentKeys*
-    */
-    __exports__["default"] = function registerBoundHelper(name, fn) {
-      var boundHelperArgs = slice.call(arguments, 1);
-      var boundFn = makeBoundHelper.apply(this, boundHelperArgs);
-
-      helpers[name] = boundFn;
-    }
-  });
-enifed("ember-htmlbars/helpers",
-  ["ember-metal/platform","ember-htmlbars/system/helper","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
-
-    var o_create = __dependency1__.create;
+      This is only available for singleton controllers.
 
-    /**
-     @private
-     @property helpers
+      @property {Array} needs
+      @default []
     */
-    var helpers = o_create(null);
+    needs: [],
 
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+    init: function() {
+      var needs = property_get.get(this, 'needs');
+      var length = property_get.get(needs, 'length');
 
-    var Helper = __dependency2__["default"];
+      if (length > 0) {
+        Ember['default'].assert(' `' + utils.inspect(this) + ' specifies `needs`, but does ' +
+                     "not have a container. Please ensure this controller was " +
+                     "instantiated with a container.",
+                     this.container || this.controllers !== defaultControllersComputedProperty);
 
-    /**
-      @private
-      @method _registerHelper
-      @for Ember.HTMLBars
-      @param {String} name
-      @param {Object|Function} helperFunc the helper function to add
-    */
-    function registerHelper(name, helperFunc) {
-      var helper;
+        if (this.container) {
+          verifyNeedsDependencies(this, this.container, needs);
+        }
 
-      if (helperFunc && helperFunc.isHelper) {
-        helper = helperFunc;
-      } else {
-        helper = new Helper(helperFunc);
+        // if needs then initialize controllers proxy
+        property_get.get(this, 'controllers');
       }
 
-      helpers[name] = helper;
-    }
+      this._super.apply(this, arguments);
+    },
 
-    __exports__.registerHelper = registerHelper;__exports__["default"] = helpers;
-  });
-enifed("ember-htmlbars/helpers/bind-attr",
-  ["ember-metal/core","ember-runtime/system/string","ember-views/attr_nodes/attr_node","ember-views/attr_nodes/legacy_bind","ember-metal/keys","ember-htmlbars/helpers","ember-metal/enumerable_utils","ember-metal/streams/utils","ember-views/streams/class_name_binding","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-htmlbars
+      @method controllerFor
+      @see {Ember.Route#controllerFor}
+      @deprecated Use `needs` instead
     */
-
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-
-    var fmt = __dependency2__.fmt;
-    var AttrNode = __dependency3__["default"];
-    var LegacyBindAttrNode = __dependency4__["default"];
-    var keys = __dependency5__["default"];
-    var helpers = __dependency6__["default"];
-    var map = __dependency7__.map;
-    var isStream = __dependency8__.isStream;
-    var concat = __dependency8__.concat;
-    var streamifyClassNameBinding = __dependency9__.streamifyClassNameBinding;
+    controllerFor: function(controllerName) {
+      Ember['default'].deprecate("Controller#controllerFor is deprecated, please use Controller#needs instead");
+      return controllerFor['default'](property_get.get(this, 'container'), controllerName);
+    },
 
     /**
-      `bind-attr` allows you to create a binding between DOM element attributes and
-      Ember objects. For example:
-
-      ```handlebars
-      <img {{bind-attr src=imageUrl alt=imageTitle}}>
-      ```
-
-      The above handlebars template will fill the `<img>`'s `src` attribute with
-      the value of the property referenced with `imageUrl` and its `alt`
-      attribute with the value of the property referenced with `imageTitle`.
-
-      If the rendering context of this template is the following object:
+      Stores the instances of other controllers available from within
+      this controller. Any controller listed by name in the `needs`
+      property will be accessible by name through this property.
 
       ```javascript
-      {
-        imageUrl: 'http://lolcats.info/haz-a-funny',
-        imageTitle: 'A humorous image of a cat'
-      }
-      ```
-
-      The resulting HTML output will be:
-
-      ```html
-      <img src="http://lolcats.info/haz-a-funny" alt="A humorous image of a cat">
-      ```
-
-      `bind-attr` cannot redeclare existing DOM element attributes. The use of `src`
-      in the following `bind-attr` example will be ignored and the hard coded value
-      of `src="/failwhale.gif"` will take precedence:
-
-      ```handlebars
-      <img src="/failwhale.gif" {{bind-attr src=imageUrl alt=imageTitle}}>
+      App.CommentsController = Ember.ArrayController.extend({
+        needs: ['post'],
+        postTitle: function() {
+          var currentPost = this.get('controllers.post'); // instance of App.PostController
+          return currentPost.get('title');
+        }.property('controllers.post.title')
+      });
       ```
 
-      ### `bind-attr` and the `class` attribute
-
-      `bind-attr` supports a special syntax for handling a number of cases unique
-      to the `class` DOM element attribute. The `class` attribute combines
-      multiple discrete values into a single attribute as a space-delimited
-      list of strings. Each string can be:
+      @see {Ember.ControllerMixin#needs}
+      @property {Object} controllers
+      @default null
+    */
+    controllers: defaultControllersComputedProperty
+  });
 
-      * a string return value of an object's property.
-      * a boolean return value of an object's property
-      * a hard-coded value
+  exports['default'] = ControllerMixin['default'];
 
-      A string return value works identically to other uses of `bind-attr`. The
-      return value of the property will become the value of the attribute. For
-      example, the following view and template:
+});
+enifed('ember-application/system/application-instance', ['exports', 'ember-metal/property_set', 'ember-runtime/system/object', 'ember-metal/run_loop', 'container/registry'], function (exports, property_set, EmberObject, run, Registry) {
 
-      ```javascript
-        AView = View.extend({
-          someProperty: function() {
-            return "aValue";
-          }.property()
-        })
-      ```
+  'use strict';
 
-      ```handlebars
-      <img {{bind-attr class=view.someProperty}}>
-      ```
+  /**
+  @module ember
+  @submodule ember-application
+  @private
+  */
 
-      Result in the following rendered output:
+  exports['default'] = EmberObject['default'].extend({
+    /**
+      The application instance's container. The container stores all of the
+      instance-specific state for this application run.
 
-      ```html
-      <img class="aValue">
-      ```
+      @property {Ember.Container} container
+    */
+    container: null,
 
-      A boolean return value will insert a specified class name if the property
-      returns `true` and remove the class name if the property returns `false`.
+    /**
+      The application's registry. The registry contains the classes, templates,
+      and other code that makes up the application.
 
-      A class name is provided via the syntax
-      `somePropertyName:class-name-if-true`.
+      @property {Ember.Registry} registry
+    */
+    applicationRegistry: null,
 
-      ```javascript
-      AView = View.extend({
-        someBool: true
-      })
-      ```
+    /**
+      The registry for this application instance. It should use the
+      `applicationRegistry` as a fallback.
 
-      ```handlebars
-      <img {{bind-attr class="view.someBool:class-name-if-true"}}>
-      ```
+      @property {Ember.Registry} registry
+    */
+    registry: null,
 
-      Result in the following rendered output:
+    /**
+      The DOM events for which the event dispatcher should listen.
 
-      ```html
-      <img class="class-name-if-true">
-      ```
+      By default, the application's `Ember.EventDispatcher` listens
+      for a set of standard DOM events, such as `mousedown` and
+      `keyup`, and delegates them to your application's `Ember.View`
+      instances.
 
-      An additional section of the binding can be provided if you want to
-      replace the existing class instead of removing it when the boolean
-      value changes:
+      @private
+      @property {Object} customEvents
+    */
+    customEvents: null,
 
-      ```handlebars
-      <img {{bind-attr class="view.someBool:class-name-if-true:class-name-if-false"}}>
-      ```
+    /**
+      The root DOM element of the Application as an element or a
+      [jQuery-compatible selector
+      string](http://api.jquery.com/category/selectors/).
 
-      A hard-coded value can be used by prepending `:` to the desired
-      class name: `:class-name-to-always-apply`.
+      @private
+      @property {String|DOMElement} rootElement
+    */
+    rootElement: null,
 
-      ```handlebars
-      <img {{bind-attr class=":class-name-to-always-apply"}}>
-      ```
+    init: function() {
+      this._super.apply(this, arguments);
 
-      Results in the following rendered output:
+      // Create a per-instance registry that will use the application's registry
+      // as a fallback for resolving registrations.
+      this.registry = new Registry['default']({
+        fallback: this.applicationRegistry,
+        resolver: this.applicationRegistry.resolver
+      });
+      this.registry.normalizeFullName = this.applicationRegistry.normalizeFullName;
+      this.registry.makeToString = this.applicationRegistry.makeToString;
 
-      ```html
-      <img class="class-name-to-always-apply">
-      ```
+      // Create a per-instance container from the instance's registry
+      this.container = this.registry.container();
 
-      All three strategies - string return value, boolean return value, and
-      hard-coded value – can be combined in a single declaration:
+      // Register this instance in the per-instance registry.
+      //
+      // Why do we need to register the instance in the first place?
+      // Because we need a good way for the root route (a.k.a ApplicationRoute)
+      // to notify us when it has created the root-most view. That view is then
+      // appended to the rootElement, in the case of apps, to the fixture harness
+      // in tests, or rendered to a string in the case of FastBoot.
+      this.registry.register('-application-instance:main', this, { instantiate: false });
+    },
 
-      ```handlebars
-      <img {{bind-attr class=":class-name-to-always-apply view.someBool:class-name-if-true view.someProperty"}}>
-      ```
+    /**
+      Instantiates and sets up the router, optionally overriding the default
+      location. This is useful for manually starting the app in FastBoot or
+      testing environments, where trying to modify the URL would be
+      inappropriate.
 
-      @method bind-attr
-      @for Ember.Handlebars.helpers
-      @param {Hash} options
-      @return {String} HTML string
+      @param options
+      @private
     */
-    function bindAttrHelper(params, hash, options, env) {
-      var element = options.element;
+    setupRouter: function(options) {
+      var router = this.container.lookup('router:main');
 
-      Ember.assert("You must specify at least one hash argument to bind-attr", !!keys(hash).length);
+      var location = options.location;
+      if (location) { property_set.set(router, 'location', location); }
 
-      var view = this;
+      router._setupLocation();
+      router.setupRouter(true);
+    },
 
-      // Handle classes differently, as we can bind multiple classes
-      var classNameBindings = hash['class'];
-      if (classNameBindings !== null && classNameBindings !== undefined) {
-        if (!isStream(classNameBindings)) {
-          classNameBindings = applyClassNameBindings(classNameBindings, view);
-        }
+    /**
+      This hook is called by the root-most Route (a.k.a. the ApplicationRoute)
+      when it has finished creating the root View. By default, we simply take the
+      view and append it to the `rootElement` specified on the Application.
 
-        var classView = new AttrNode('class', classNameBindings);
-        classView._morph = env.dom.createAttrMorph(element, 'class');
+      In cases like FastBoot and testing, we can override this hook and implement
+      custom behavior, such as serializing to a string and sending over an HTTP
+      socket rather than appending to DOM.
 
-        Ember.assert(
-          'You cannot set `class` manually and via `{{bind-attr}}` helper on the same element. ' +
-          'Please use `{{bind-attr}}`\'s `:static-class` syntax instead.',
-          !element.getAttribute('class')
-        );
+      @param view {Ember.View} the root-most view
+      @private
+    */
+    didCreateRootView: function(view) {
+      view.appendTo(this.rootElement);
+    },
 
-        view.appendChild(classView);
-      }
+    /**
+      Tells the router to start routing. The router will ask the location for the
+      current URL of the page to determine the initial URL to start routing to.
+      To start the app at a specific URL, call `handleURL` instead.
 
-      var attrKeys = keys(hash);
+      Ensure that you have called `setupRouter()` on the instance before using
+      this method.
 
-      var attr, path, lazyValue, attrView;
-      for (var i=0, l=attrKeys.length;i<l;i++) {
-        attr = attrKeys[i];
-        if (attr === 'class') {
-          continue;
-        }
-        path = hash[attr];
-        if (isStream(path)) {
-          lazyValue = path;
-        } else {
-          Ember.assert(
-            fmt("You must provide an expression as the value of bound attribute." +
-                " You specified: %@=%@", [attr, path]),
-            typeof path === 'string'
-          );
-          lazyValue = view.getStream(path);
-        }
+      @private
+    */
+    startRouting: function() {
+      var router = this.container.lookup('router:main');
+      if (!router) { return; }
 
-        attrView = new LegacyBindAttrNode(attr, lazyValue);
-        attrView._morph = env.dom.createAttrMorph(element, attr);
+      var isModuleBasedResolver = !!this.registry.resolver.moduleBasedResolver;
+      router.startRouting(isModuleBasedResolver);
+    },
 
-        Ember.assert(
-          'You cannot set `' + attr + '` manually and via `{{bind-attr}}` helper on the same element.',
-          !element.getAttribute(attr)
-        );
+    /**
+      Directs the router to route to a particular URL. This is useful in tests,
+      for example, to tell the app to start at a particular URL. Ensure that you
+      have called `setupRouter()` before calling this method.
 
-        view.appendChild(attrView);
-      }
-    }
+      @param url {String} the URL the router should route to
+      @private
+    */
+    handleURL: function(url) {
+      var router = this.container.lookup('router:main');
 
-    function applyClassNameBindings(classNameBindings, view) {
-      var arrayOfClassNameBindings = classNameBindings.split(' ');
-      var boundClassNameBindings = map(arrayOfClassNameBindings, function(classNameBinding) {
-        return streamifyClassNameBinding(view, classNameBinding);
-      });
-      var concatenatedClassNames = concat(boundClassNameBindings, ' ');
-      return concatenatedClassNames;
-    }
+      return router.handleURL(url);
+    },
 
     /**
-      See `bind-attr`
-
-      @method bindAttr
-      @for Ember.Handlebars.helpers
-      @deprecated
-      @param {Function} context
-      @param {Hash} options
-      @return {String} HTML string
+      @private
     */
-    function bindAttrHelperDeprecated() {
-      Ember.deprecate("The 'bindAttr' view helper is deprecated in favor of 'bind-attr'");
+    setupEventDispatcher: function() {
+      var dispatcher = this.container.lookup('event_dispatcher:main');
 
-      
-        return helpers['bind-attr'].helperFunction.apply(this, arguments);
-          }
+      dispatcher.setup(this.customEvents, this.rootElement);
 
-    __exports__["default"] = bindAttrHelper;
+      return dispatcher;
+    },
 
-    __exports__.bindAttrHelper = bindAttrHelper;
-    __exports__.bindAttrHelperDeprecated = bindAttrHelperDeprecated;
-  });
-enifed("ember-htmlbars/helpers/binding",
-  ["ember-metal/is_none","ember-metal/run_loop","ember-metal/property_get","ember-metal/streams/simple","ember-views/views/bound_view","ember-metal/streams/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-htmlbars
+      @private
     */
+    willDestroy: function() {
+      this._super.apply(this, arguments);
+      run['default'](this.container, 'destroy');
+    }
+  });
+
+});
+enifed('ember-application/system/application', ['exports', 'dag-map', 'container/registry', 'ember-metal', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-runtime/system/lazy_load', 'ember-runtime/system/namespace', 'ember-runtime/mixins/deferred', 'ember-application/system/resolver', 'ember-metal/platform/create', 'ember-metal/run_loop', 'ember-metal/utils', 'ember-runtime/controllers/controller', 'ember-metal/enumerable_utils', 'ember-runtime/controllers/object_controller', 'ember-runtime/controllers/array_controller', 'ember-views/system/renderer', 'dom-helper', 'ember-views/views/select', 'ember-routing-views/views/outlet', 'ember-views/views/view', 'ember-views/views/metamorph_view', 'ember-views/system/event_dispatcher', 'ember-views/system/jquery', 'ember-routing/system/route', 'ember-routing/system/router', 'ember-routing/location/hash_location', 'ember-routing/location/history_location', 'ember-routing/location/auto_location', 'ember-routing/location/none_location', 'ember-routing/system/cache', 'ember-application/system/application-instance', 'ember-extension-support/container_debug_adapter', 'ember-metal/environment'], function (exports, DAG, Registry, Ember, property_get, property_set, lazy_load, Namespace, DeferredMixin, DefaultResolver, create, run, utils, Controller, EnumerableUtils, ObjectController, ArrayController, Renderer, DOMHelper, SelectView, outlet, EmberView, _MetamorphView, EventDispatcher, jQuery, Route, Router, HashLocation, HistoryLocation, AutoLocation, NoneLocation, BucketCache, ApplicationInstance, ContainerDebugAdapter, environment) {
 
-    var isNone = __dependency1__["default"];
-    var run = __dependency2__["default"];
-    var get = __dependency3__.get;
-    var SimpleStream = __dependency4__["default"];
-    var BoundView = __dependency5__["default"];
-    var isStream = __dependency6__.isStream;
+  'use strict';
 
-    function exists(value) {
-      return !isNone(value);
+  /**
+  @module ember
+  @submodule ember-application
+  */
+  function props(obj) {
+    var properties = [];
+
+    for (var key in obj) {
+      properties.push(key);
     }
 
-    // Binds a property into the DOM. This will create a hook in DOM that the
-    // KVO system will look for and update if the property changes.
-    function bind(property, hash, options, env, preserveContext, shouldDisplay, valueNormalizer, childProperties, _viewClass) {
-      var valueStream = isStream(property) ? property : this.getStream(property);
-      var lazyValue;
+    return properties;
+  }
 
-      if (childProperties) {
-        lazyValue = new SimpleStream(valueStream);
+  var librariesRegistered = false;
 
-        var subscriber = function(childStream) {
-          childStream.value();
-          lazyValue.notify();
-        };
+  /**
+    An instance of `Ember.Application` is the starting point for every Ember
+    application. It helps to instantiate, initialize and coordinate the many
+    objects that make up your app.
 
-        for (var i = 0; i < childProperties.length; i++) {
-          var childStream = valueStream.get(childProperties[i]);
-          childStream.value();
-          childStream.subscribe(subscriber);
-        }
-      } else {
-        lazyValue = valueStream;
-      }
+    Each Ember app has one and only one `Ember.Application` object. In fact, the
+    very first thing you should do in your application is create the instance:
 
-      // Set up observers for observable objects
-      var viewClass = _viewClass || BoundView;
-      var viewOptions = {
-        _morph: options.morph,
-        preserveContext: preserveContext,
-        shouldDisplayFunc: shouldDisplay,
-        valueNormalizerFunc: valueNormalizer,
-        displayTemplate: options.template,
-        inverseTemplate: options.inverse,
-        lazyValue: lazyValue,
-        previousContext: get(this, 'context'),
-        isEscaped: !hash.unescaped,
-        templateHash: hash,
-        helperName: options.helperName
-      };
+    ```javascript
+    window.App = Ember.Application.create();
+    ```
 
-      if (options.keywords) {
-        viewOptions._keywords = options.keywords;
-      }
+    Typically, the application object is the only global variable. All other
+    classes in your app should be properties on the `Ember.Application` instance,
+    which highlights its first role: a global namespace.
 
-      // Create the view that will wrap the output of this template/property
-      // and add it to the nearest view's childViews array.
-      // See the documentation of Ember._BoundView for more.
-      var bindView = this.createChildView(viewClass, viewOptions);
+    For example, if you define a view class, it might look like this:
 
-      this.appendChild(bindView);
+    ```javascript
+    App.MyView = Ember.View.extend();
+    ```
 
-      lazyValue.subscribe(this._wrapAsScheduled(function() {
-        run.scheduleOnce('render', bindView, 'rerenderIfNeeded');
-      }));
-    }
+    By default, calling `Ember.Application.create()` will automatically initialize
+    your application by calling the `Ember.Application.initialize()` method. If
+    you need to delay initialization, you can call your app's `deferReadiness()`
+    method. When you are ready for your app to be initialized, call its
+    `advanceReadiness()` method.
 
-    /**
-      `bind` can be used to display a value, then update that value if it
-      changes. For example, if you wanted to print the `title` property of
-      `content`:
+    You can define a `ready` method on the `Ember.Application` instance, which
+    will be run by Ember when the application is initialized.
 
-      ```handlebars
-      {{bind "content.title"}}
-      ```
+    Because `Ember.Application` inherits from `Ember.Namespace`, any classes
+    you create will have useful string representations when calling `toString()`.
+    See the `Ember.Namespace` documentation for more information.
 
-      This will return the `title` property as a string, then create a new observer
-      at the specified path. If it changes, it will update the value in DOM. Note
-      that if you need to support IE7 and IE8 you must modify the model objects
-      properties using `Ember.get()` and `Ember.set()` for this to work as it
-      relies on Ember's KVO system. For all other browsers this will be handled for
-      you automatically.
+    While you can think of your `Ember.Application` as a container that holds the
+    other classes in your application, there are several other responsibilities
+    going on under-the-hood that you may want to understand.
 
-      @private
-      @method bind
-      @for Ember.Handlebars.helpers
-      @param {String} property Property to bind
-      @param {Function} render Context to provide for rendering
-      @return {String} HTML string
-    */
-    function bindHelper(params, hash, options, env) {
-      Ember.assert("You must pass exactly one argument to the bind helper", params.length === 1);
+    ### Event Delegation
 
-      var property = params[0];
+    Ember uses a technique called _event delegation_. This allows the framework
+    to set up a global, shared event listener instead of requiring each view to
+    do it manually. For example, instead of each view registering its own
+    `mousedown` listener on its associated element, Ember sets up a `mousedown`
+    listener on the `body`.
 
-      if (typeof property === 'string') {
-        property = this.getStream(property);
-      }
+    If a `mousedown` event occurs, Ember will look at the target of the event and
+    start walking up the DOM node tree, finding corresponding views and invoking
+    their `mouseDown` method as it goes.
 
-      if (options.template) {
-        options.helperName = 'bind';
-        Ember.deprecate("The block form of bind, {{#bind foo}}{{/bind}}, has been deprecated and will be removed.");
-        bind.call(this, property, hash, options, env, false, exists);
-      } else {
-        Ember.deprecate("The `{{bind}}` helper has been deprecated and will be removed.");
+    `Ember.Application` has a number of default events that it listens for, as
+    well as a mapping from lowercase events to camel-cased view method names. For
+    example, the `keypress` event causes the `keyPress` method on the view to be
+    called, the `dblclick` event causes `doubleClick` to be called, and so on.
 
-        return property;
-      }
-    }
+    If there is a bubbling browser event that Ember does not listen for by
+    default, you can specify custom events and their corresponding view method
+    names by setting the application's `customEvents` property:
 
-    __exports__.bind = bind;
-    __exports__.bindHelper = bindHelper;
-  });
-enifed("ember-htmlbars/helpers/collection",
-  ["ember-metal/core","ember-metal/mixin","ember-runtime/system/string","ember-metal/property_get","ember-htmlbars/helpers/view","ember-views/views/collection_view","ember-views/streams/utils","ember-metal/enumerable_utils","ember-views/streams/class_name_binding","ember-metal/binding","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+    ```javascript
+    var App = Ember.Application.create({
+      customEvents: {
+        // add support for the paste event
+        paste: 'paste'
+      }
+    });
+    ```
 
-    var Ember = __dependency1__["default"];
-    // Ember.assert, Ember.deprecate
-    var IS_BINDING = __dependency2__.IS_BINDING;
-    var fmt = __dependency3__.fmt;
-    var get = __dependency4__.get;
-    var ViewHelper = __dependency5__.ViewHelper;
-    var CollectionView = __dependency6__["default"];
-    var readViewFactory = __dependency7__.readViewFactory;
-    var map = __dependency8__.map;
-    var streamifyClassNameBinding = __dependency9__.streamifyClassNameBinding;
-    var Binding = __dependency10__.Binding;
+    By default, the application sets up these event listeners on the document
+    body. However, in cases where you are embedding an Ember application inside
+    an existing page, you may want it to set up the listeners on an element
+    inside the body.
 
-    /**
-      `{{collection}}` is a `Ember.Handlebars` helper for adding instances of
-      `Ember.CollectionView` to a template. See [Ember.CollectionView](/api/classes/Ember.CollectionView.html)
-       for additional information on how a `CollectionView` functions.
+    For example, if only events inside a DOM element with the ID of `ember-app`
+    should be delegated, set your application's `rootElement` property:
 
-      `{{collection}}`'s primary use is as a block helper with a `contentBinding`
-      option pointing towards an `Ember.Array`-compatible object. An `Ember.View`
-      instance will be created for each item in its `content` property. Each view
-      will have its own `content` property set to the appropriate item in the
-      collection.
+    ```javascript
+    var App = Ember.Application.create({
+      rootElement: '#ember-app'
+    });
+    ```
 
-      The provided block will be applied as the template for each item's view.
+    The `rootElement` can be either a DOM element or a jQuery-compatible selector
+    string. Note that *views appended to the DOM outside the root element will
+    not receive events.* If you specify a custom root element, make sure you only
+    append views inside it!
 
-      Given an empty `<body>` the following template:
+    To learn more about the advantages of event delegation and the Ember view
+    layer, and a list of the event listeners that are setup by default, visit the
+    [Ember View Layer guide](http://emberjs.com/guides/understanding-ember/the-view-layer/#toc_event-delegation).
 
-      ```handlebars
-      {{! application.hbs }}
-      {{#collection content=model}}
-        Hi {{view.content.name}}
-      {{/collection}}
-      ```
+    ### Initializers
 
-      And the following application code
+    Libraries on top of Ember can add initializers, like so:
 
-      ```javascript
-      App = Ember.Application.create();
-      App.ApplicationRoute = Ember.Route.extend({
-        model: function(){
-          return [{name: 'Yehuda'},{name: 'Tom'},{name: 'Peter'}];
-        }
-      });
-      ```
+    ```javascript
+    Ember.Application.initializer({
+      name: 'api-adapter',
 
-      The following HTML will result:
+      initialize: function(container, application) {
+        application.register('api-adapter:main', ApiAdapter);
+      }
+    });
+    ```
 
-      ```html
-      <div class="ember-view">
-        <div class="ember-view">Hi Yehuda</div>
-        <div class="ember-view">Hi Tom</div>
-        <div class="ember-view">Hi Peter</div>
-      </div>
-      ```
+    Initializers provide an opportunity to access the container, which
+    organizes the different components of an Ember application. Additionally
+    they provide a chance to access the instantiated application. Beyond
+    being used for libraries, initializers are also a great way to organize
+    dependency injection or setup in your own application.
 
-      ### Non-block version of collection
+    ### Routing
 
-      If you provide an `itemViewClass` option that has its own `template` you may
-      omit the block.
+    In addition to creating your application's router, `Ember.Application` is
+    also responsible for telling the router when to start routing. Transitions
+    between routes can be logged with the `LOG_TRANSITIONS` flag, and more
+    detailed intra-transition logging can be logged with
+    the `LOG_TRANSITIONS_INTERNAL` flag:
 
-      The following template:
+    ```javascript
+    var App = Ember.Application.create({
+      LOG_TRANSITIONS: true, // basic logging of successful transitions
+      LOG_TRANSITIONS_INTERNAL: true // detailed logging of all routing steps
+    });
+    ```
 
-      ```handlebars
-      {{! application.hbs }}
-      {{collection content=model itemViewClass="an-item"}}
-      ```
+    By default, the router will begin trying to translate the current URL into
+    application state once the browser emits the `DOMContentReady` event. If you
+    need to defer routing, you can call the application's `deferReadiness()`
+    method. Once routing can begin, call the `advanceReadiness()` method.
 
-      And application code
+    If there is any setup required before routing begins, you can implement a
+    `ready()` method on your app that will be invoked immediately before routing
+    begins.
 
-      ```javascript
-      App = Ember.Application.create();
-      App.ApplicationRoute = Ember.Route.extend({
-        model: function(){
-          return [{name: 'Yehuda'},{name: 'Tom'},{name: 'Peter'}];
-        }
-      });
+    @class Application
+    @namespace Ember
+    @extends Ember.Namespace
+  */
 
-      App.AnItemView = Ember.View.extend({
-        template: Ember.Handlebars.compile("Greetings {{view.content.name}}")
-      });
-      ```
+  var Application = Namespace['default'].extend(DeferredMixin['default'], {
+    _suppressDeferredDeprecation: true,
 
-      Will result in the HTML structure below
+    /**
+      The root DOM element of the Application. This can be specified as an
+      element or a
+      [jQuery-compatible selector string](http://api.jquery.com/category/selectors/).
 
-      ```html
-      <div class="ember-view">
-        <div class="ember-view">Greetings Yehuda</div>
-        <div class="ember-view">Greetings Tom</div>
-        <div class="ember-view">Greetings Peter</div>
-      </div>
-      ```
+      This is the element that will be passed to the Application's,
+      `eventDispatcher`, which sets up the listeners for event delegation. Every
+      view in your application should be a child of the element you specify here.
 
-      ### Specifying a CollectionView subclass
+      @property rootElement
+      @type DOMElement
+      @default 'body'
+    */
+    rootElement: 'body',
 
-      By default the `{{collection}}` helper will create an instance of
-      `Ember.CollectionView`. You can supply a `Ember.CollectionView` subclass to
-      the helper by passing it as the first argument:
+    /**
+      The `Ember.EventDispatcher` responsible for delegating events to this
+      application's views.
 
-      ```handlebars
-      {{#collection "my-custom-collection" content=model}}
-        Hi {{view.content.name}}
-      {{/collection}}
-      ```
+      The event dispatcher is created by the application at initialization time
+      and sets up event listeners on the DOM element described by the
+      application's `rootElement` property.
 
-      This example would look for the class `App.MyCustomCollection`.
+      See the documentation for `Ember.EventDispatcher` for more information.
 
-      ### Forwarded `item.*`-named Options
+      @property eventDispatcher
+      @type Ember.EventDispatcher
+      @default null
+    */
+    eventDispatcher: null,
 
-      As with the `{{view}}`, helper options passed to the `{{collection}}` will be
-      set on the resulting `Ember.CollectionView` as properties. Additionally,
-      options prefixed with `item` will be applied to the views rendered for each
-      item (note the camelcasing):
+    /**
+      The DOM events for which the event dispatcher should listen.
 
-      ```handlebars
-      {{#collection content=model
-                    itemTagName="p"
-                    itemClassNames="greeting"}}
-        Howdy {{view.content.name}}
-      {{/collection}}
-      ```
+      By default, the application's `Ember.EventDispatcher` listens
+      for a set of standard DOM events, such as `mousedown` and
+      `keyup`, and delegates them to your application's `Ember.View`
+      instances.
 
-      Will result in the following HTML structure:
+      If you would like additional bubbling events to be delegated to your
+      views, set your `Ember.Application`'s `customEvents` property
+      to a hash containing the DOM event name as the key and the
+      corresponding view method name as the value. For example:
 
-      ```html
-      <div class="ember-view">
-        <p class="ember-view greeting">Howdy Yehuda</p>
-        <p class="ember-view greeting">Howdy Tom</p>
-        <p class="ember-view greeting">Howdy Peter</p>
-      </div>
+      ```javascript
+      var App = Ember.Application.create({
+        customEvents: {
+          // add support for the paste event
+          paste: 'paste'
+        }
+      });
       ```
 
-      @method collection
-      @for Ember.Handlebars.helpers
-      @param {String} path
-      @param {Hash} options
-      @return {String} HTML string
-      @deprecated Use `{{each}}` helper instead.
+      @property customEvents
+      @type Object
+      @default null
     */
-    function collectionHelper(params, hash, options, env) {
-      var path = params[0];
+    customEvents: null,
 
-      Ember.deprecate("Using the {{collection}} helper without specifying a class has been" +
-                      " deprecated as the {{each}} helper now supports the same functionality.", path !== 'collection');
-
-      Ember.assert("You cannot pass more than one argument to the collection helper", params.length <= 1);
+    /**
+      Whether the application should automatically start routing and render
+      templates to the `rootElement` on DOM ready. While default by true,
+      other environments such as FastBoot or a testing harness can set this
+      property to `false` and control the precise timing and behavior of the boot
+      process.
 
-      var data     = env.data;
-      var template = options.template;
-      var inverse  = options.inverse;
-      var view     = data.view;
+      @property autoboot
+      @type Boolean
+      @default true
+      @private
+    */
+    autoboot: true,
 
-      // This should be deterministic, and should probably come from a
-      // parent view and not the controller.
-      var  controller = get(view, 'controller');
-      var  container = (controller && controller.container ? controller.container : view.container);
+    init: function() {
+      this._super.apply(this, arguments);
 
-      // If passed a path string, convert that into an object.
-      // Otherwise, just default to the standard class.
-      var collectionClass;
-      if (path) {
-        collectionClass = readViewFactory(path, container);
-        Ember.assert(fmt("%@ #collection: Could not find collection class %@", [data.view, path]), !!collectionClass);
-      }
-      else {
-        collectionClass = CollectionView;
+      if (!this.$) {
+        this.$ = jQuery['default'];
       }
 
-      var itemHash = {};
-      var match;
+      this.buildRegistry();
 
-      // Extract item view class if provided else default to the standard class
-      var collectionPrototype = collectionClass.proto();
-      var itemViewClass;
+      registerLibraries();
+      logLibraryVersions();
 
-      if (hash.itemView) {
-        itemViewClass = readViewFactory(hash.itemView, container);
-      } else if (hash.itemViewClass) {
-        itemViewClass = readViewFactory(hash.itemViewClass, container);
-      } else {
-        itemViewClass = collectionPrototype.itemViewClass;
-      }
+      // Start off the number of deferrals at 1. This will be
+      // decremented by the Application's own `initialize` method.
+      this._readinessDeferrals = 1;
 
-      if (typeof itemViewClass === 'string') {
-        itemViewClass = container.lookupFactory('view:'+itemViewClass);
-      }
 
-      Ember.assert(fmt("%@ #collection: Could not find itemViewClass %@", [data.view, itemViewClass]), !!itemViewClass);
+        this.Router = (this.Router || Router['default']).extend();
+        this.waitForDOMReady(this.buildDefaultInstance());
 
-      delete hash.itemViewClass;
-      delete hash.itemView;
+    },
 
-      // Go through options passed to the {{collection}} helper and extract options
-      // that configure item views instead of the collection itself.
-      for (var prop in hash) {
-        if (prop === 'itemController' || prop === 'itemClassBinding') {
-          continue;
-        }
-        if (hash.hasOwnProperty(prop)) {
-          match = prop.match(/^item(.)(.*)$/);
-          if (match) {
-            var childProp = match[1].toLowerCase() + match[2];
+    /**
+      Build and configure the registry for the current application.
 
-            if (IS_BINDING.test(prop)) {
-              itemHash[childProp] = view._getBindingForStream(hash[prop]);
-            } else {
-              itemHash[childProp] = hash[prop];
-            }
-            delete hash[prop];
-          }
-        }
-      }
+      @private
+      @method buildRegistry
+      @return {Ember.Registry} the configured registry
+    */
+    buildRegistry: function() {
+      var registry = this.registry = Application.buildRegistry(this);
 
-      if (template) {
-        itemHash.template = template;
-        delete options.template;
-      }
+      return registry;
+    },
 
-      var emptyViewClass;
-      if (inverse) {
-        emptyViewClass = get(collectionPrototype, 'emptyViewClass');
-        emptyViewClass = emptyViewClass.extend({
-              template: inverse,
-              tagName: itemHash.tagName
-        });
-      } else if (hash.emptyViewClass) {
-        emptyViewClass = readViewFactory(hash.emptyViewClass, container);
-      }
-      if (emptyViewClass) { hash.emptyView = emptyViewClass; }
+    /**
+      Create a container for the current application's registry.
 
-      if (hash.keyword) {
-        itemHash._contextBinding = Binding.oneWay('_parentView.context');
-      } else {
-        itemHash._contextBinding = Binding.oneWay('content');
-      }
+      @private
+      @method buildInstance
+      @return {Ember.Container} the configured container
+    */
+    buildInstance: function() {
+      return ApplicationInstance['default'].create({
+        customEvents: property_get.get(this, 'customEvents'),
+        rootElement: property_get.get(this, 'rootElement'),
+        applicationRegistry: this.buildRegistry()
+      });
+    },
 
-      var viewOptions = ViewHelper.propertiesFromHTMLOptions(itemHash, {}, { data: data });
+    buildDefaultInstance: function() {
+      var instance = this.buildInstance();
 
-      if (hash.itemClassBinding) {
-        var itemClassBindings = hash.itemClassBinding.split(' ');
-        viewOptions.classNameBindings = map(itemClassBindings, function(classBinding){
-          return streamifyClassNameBinding(view, classBinding);
-        });
-      }
+      // TODO2.0: Legacy support for App.__container__
+      // and global methods on App that rely on a single,
+      // default instance.
+      this.__deprecatedInstance__ = instance;
+      this.__container__ = instance.container;
 
-      hash.itemViewClass = itemViewClass;
-      hash._itemViewProps = viewOptions;
+      return instance;
+    },
 
-      options.helperName = options.helperName || 'collection';
+    /**
+      Automatically initialize the application once the DOM has
+      become ready.
 
-      return env.helpers.view.helperFunction.call(this, [collectionClass], hash, options, env);
-    }
+      The initialization itself is scheduled on the actions queue
+      which ensures that application loading finishes before
+      booting.
 
-    __exports__.collectionHelper = collectionHelper;
-  });
-enifed("ember-htmlbars/helpers/debugger",
-  ["ember-metal/logger","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    /*jshint debug:true*/
+      If you are asynchronously loading code, you should call
+      `deferReadiness()` to defer booting, and then call
+      `advanceReadiness()` once all of your code has finished
+      loading.
 
-    /**
-    @module ember
-    @submodule ember-htmlbars
+      @private
+      @method scheduleInitialize
     */
-    var Logger = __dependency1__["default"];
+    waitForDOMReady: function(_instance) {
+      if (!this.$ || this.$.isReady) {
+        run['default'].schedule('actions', this, 'domReady', _instance);
+      } else {
+        this.$().ready(run['default'].bind(this, 'domReady', _instance));
+      }
+    },
 
     /**
-      Execute the `debugger` statement in the current context.
-
-      ```handlebars
-      {{debugger}}
-      ```
-
-      Before invoking the `debugger` statement, there
-      are a few helpful variables defined in the
-      body of this helper that you can inspect while
-      debugging that describe how and where this
-      helper was invoked:
+      Use this to defer readiness until some condition is true.
 
-      - templateContext: this is most likely a controller
-        from which this template looks up / displays properties
-      - typeOfTemplateContext: a string description of
-        what the templateContext is
+      Example:
 
-      For example, if you're wondering why a value `{{foo}}`
-      isn't rendering as expected within a template, you
-      could place a `{{debugger}}` statement, and when
-      the `debugger;` breakpoint is hit, you can inspect
-      `templateContext`, determine if it's the object you
-      expect, and/or evaluate expressions in the console
-      to perform property lookups on the `templateContext`:
+      ```javascript
+      var App = Ember.Application.create();
 
+      App.deferReadiness();
+      // Ember.$ is a reference to the jQuery object/function
+      Ember.$.getJSON('/auth-token', function(token) {
+        App.token = token;
+        App.advanceReadiness();
+      });
       ```
-        > templateContext.get('foo') // -> "<value of {{foo}}>"
-      ```
-
-      @method debugger
-      @for Ember.Handlebars.helpers
-      @param {String} property
-    */
-    function debuggerHelper() {
 
-      // These are helpful values you can inspect while debugging.
-      /* jshint unused: false */
-      var view = this;
-      Logger.info('Use `this` to access the view context.');
+      This allows you to perform asynchronous setup logic and defer
+      booting your application until the setup has finished.
 
-      debugger;
-    }
+      However, if the setup requires a loading UI, it might be better
+      to use the router for this purpose.
 
-    __exports__.debuggerHelper = debuggerHelper;
-  });
-enifed("ember-htmlbars/helpers/each",
-  ["ember-metal/core","ember-views/views/each","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
+      @method deferReadiness
+    */
+    deferReadiness: function() {
+      Ember['default'].assert("You must call deferReadiness on an instance of Ember.Application", this instanceof Application);
+      Ember['default'].assert("You cannot defer readiness since the `ready()` hook has already been called.", this._readinessDeferrals > 0);
+      this._readinessDeferrals++;
+    },
 
     /**
-    @module ember
-    @submodule ember-htmlbars
+      Call `advanceReadiness` after any asynchronous setup logic has completed.
+      Each call to `deferReadiness` must be matched by a call to `advanceReadiness`
+      or the application will never become ready and routing will not begin.
+
+      @method advanceReadiness
+      @see {Ember.Application#deferReadiness}
     */
-    var Ember = __dependency1__["default"];
-    // Ember.assert;
-    var EachView = __dependency2__["default"];
+    advanceReadiness: function() {
+      Ember['default'].assert("You must call advanceReadiness on an instance of Ember.Application", this instanceof Application);
+      this._readinessDeferrals--;
+
+      if (this._readinessDeferrals === 0) {
+        run['default'].once(this, this.didBecomeReady);
+      }
+    },
 
     /**
-      The `{{#each}}` helper loops over elements in a collection. It is an extension
-      of the base Handlebars `{{#each}}` helper.
+      Registers a factory that can be used for dependency injection (with
+      `App.inject`) or for service lookup. Each factory is registered with
+      a full name including two parts: `type:name`.
 
-      The default behavior of `{{#each}}` is to yield its inner block once for every
-      item in an array.
+      A simple example:
 
       ```javascript
-      var developers = [{name: 'Yehuda'},{name: 'Tom'}, {name: 'Paul'}];
-      ```
+      var App = Ember.Application.create();
 
-      ```handlebars
-      {{#each person in developers}}
-        {{person.name}}
-        {{! `this` is whatever it was outside the #each }}
-      {{/each}}
+      App.Orange = Ember.Object.extend();
+      App.register('fruit:favorite', App.Orange);
       ```
 
-      The same rules apply to arrays of primitives, but the items may need to be
-      references with `{{this}}`.
+      Ember will resolve factories from the `App` namespace automatically.
+      For example `App.CarsController` will be discovered and returned if
+      an application requests `controller:cars`.
+
+      An example of registering a controller with a non-standard name:
 
       ```javascript
-      var developerNames = ['Yehuda', 'Tom', 'Paul']
-      ```
+      var App = Ember.Application.create();
+      var Session = Ember.Controller.extend();
 
-      ```handlebars
-      {{#each name in developerNames}}
-        {{name}}
-      {{/each}}
+      App.register('controller:session', Session);
+
+      // The Session controller can now be treated like a normal controller,
+      // despite its non-standard name.
+      App.ApplicationController = Ember.Controller.extend({
+        needs: ['session']
+      });
       ```
 
-      ### {{else}} condition
+      Registered factories are **instantiated** by having `create`
+      called on them. Additionally they are **singletons**, each time
+      they are looked up they return the same instance.
 
-      `{{#each}}` can have a matching `{{else}}`. The contents of this block will render
-      if the collection is empty.
+      Some examples modifying that default behavior:
 
-      ```
-      {{#each person in developers}}
-        {{person.name}}
-      {{else}}
-        <p>Sorry, nobody is available for this task.</p>
-      {{/each}}
-      ```
+      ```javascript
+      var App = Ember.Application.create();
 
-      ### Specifying an alternative view for each item
+      App.Person  = Ember.Object.extend();
+      App.Orange  = Ember.Object.extend();
+      App.Email   = Ember.Object.extend();
+      App.session = Ember.Object.create();
 
-      `itemViewClass` can control which view will be used during the render of each
-      item's template.
+      App.register('model:user', App.Person, { singleton: false });
+      App.register('fruit:favorite', App.Orange);
+      App.register('communication:main', App.Email, { singleton: false });
+      App.register('session', App.session, { instantiate: false });
+      ```
 
-      The following template:
+      @method register
+      @param  fullName {String} type:name (e.g., 'model:user')
+      @param  factory {Function} (e.g., App.Person)
+      @param  options {Object} (optional) disable instantiation or singleton usage
+    **/
+    register: function() {
+      this.registry.register.apply(this.registry, arguments);
+    },
 
-      ```handlebars
-      <ul>
-      {{#each developer in developers itemViewClass="person"}}
-        {{developer.name}}
-      {{/each}}
-      </ul>
-      ```
+    /**
+      Define a dependency injection onto a specific factory or all factories
+      of a type.
 
-      Will use the following view for each item
+      When Ember instantiates a controller, view, or other framework component
+      it can attach a dependency to that component. This is often used to
+      provide services to a set of framework components.
+
+      An example of providing a session object to all controllers:
 
       ```javascript
-      App.PersonView = Ember.View.extend({
-        tagName: 'li'
-      });
-      ```
+      var App = Ember.Application.create();
+      var Session = Ember.Object.extend({ isAuthenticated: false });
+
+      // A factory must be registered before it can be injected
+      App.register('session:main', Session);
 
-      Resulting in HTML output that looks like the following:
+      // Inject 'session:main' onto all factories of the type 'controller'
+      // with the name 'session'
+      App.inject('controller', 'session', 'session:main');
 
-      ```html
-      <ul>
-        <li class="ember-view">Yehuda</li>
-        <li class="ember-view">Tom</li>
-        <li class="ember-view">Paul</li>
-      </ul>
+      App.IndexController = Ember.Controller.extend({
+        isLoggedIn: Ember.computed.alias('session.isAuthenticated')
+      });
       ```
 
-      `itemViewClass` also enables a non-block form of `{{each}}`. The view
-      must {{#crossLink "Ember.View/toc_templates"}}provide its own template{{/crossLink}},
-      and then the block should be dropped. An example that outputs the same HTML
-      as the previous one:
+      Injections can also be performed on specific factories.
 
       ```javascript
-      App.PersonView = Ember.View.extend({
-        tagName: 'li',
-        template: '{{developer.name}}'
-      });
+      App.inject(<full_name or type>, <property name>, <full_name>)
+      App.inject('route', 'source', 'source:main')
+      App.inject('route:application', 'email', 'model:email')
       ```
 
-      ```handlebars
-      <ul>
-        {{each developer in developers itemViewClass="person"}}
-      </ul>
-      ```
+      It is important to note that injections can only be performed on
+      classes that are instantiated by Ember itself. Instantiating a class
+      directly (via `create` or `new`) bypasses the dependency injection
+      system.
 
-      ### Specifying an alternative view for no items (else)
+      **Note:** Ember-Data instantiates its models in a unique manner, and consequently
+      injections onto models (or all models) will not work as expected. Injections
+      on models can be enabled by setting `Ember.MODEL_FACTORY_INJECTIONS`
+      to `true`.
 
-      The `emptyViewClass` option provides the same flexibility to the `{{else}}`
-      case of the each helper.
+      @method inject
+      @param  factoryNameOrType {String}
+      @param  property {String}
+      @param  injectionName {String}
+    **/
+    inject: function() {
+      this.registry.injection.apply(this.registry, arguments);
+    },
 
-      ```javascript
-      App.NoPeopleView = Ember.View.extend({
-        tagName: 'li',
-        template: 'No person is available, sorry'
-      });
-      ```
+    /**
+      Calling initialize manually is not supported.
 
-      ```handlebars
-      <ul>
-      {{#each developer in developers emptyViewClass="no-people"}}
-        <li>{{developer.name}}</li>
-      {{/each}}
-      </ul>
-      ```
+      Please see Ember.Application#advanceReadiness and
+      Ember.Application#deferReadiness.
 
-      ### Wrapping each item in a controller
+      @private
+      @deprecated
+      @method initialize
+     **/
+    initialize: function() {
+      Ember['default'].deprecate('Calling initialize manually is not supported. Please see Ember.Application#advanceReadiness and Ember.Application#deferReadiness');
+    },
 
-      Controllers in Ember manage state and decorate data. In many cases,
-      providing a controller for each item in a list can be useful.
-      Specifically, an {{#crossLink "Ember.ObjectController"}}Ember.ObjectController{{/crossLink}}
-      should probably be used. Item controllers are passed the item they
-      will present as a `model` property, and an object controller will
-      proxy property lookups to `model` for us.
+    /**
+      Initialize the application. This happens automatically.
 
-      This allows state and decoration to be added to the controller
-      while any other property lookups are delegated to the model. An example:
+      Run any initializers and run the application load hook. These hooks may
+      choose to defer readiness. For example, an authentication hook might want
+      to defer readiness until the auth token has been retrieved.
 
-      ```javascript
-      App.RecruitController = Ember.ObjectController.extend({
-        isAvailableForHire: function() {
-          return !this.get('isEmployed') && this.get('isSeekingWork');
-        }.property('isEmployed', 'isSeekingWork')
-      })
-      ```
+      @private
+      @method _initialize
+    */
+    domReady: function(_instance) {
+      if (this.isDestroyed) { return; }
 
-      ```handlebars
-      {{#each person in developers itemController="recruit"}}
-        {{person.name}} {{#if person.isAvailableForHire}}Hire me!{{/if}}
-      {{/each}}
-      ```
-
-      @method each
-      @for Ember.Handlebars.helpers
-      @param [name] {String} name for item (used with `in`)
-      @param [path] {String} path
-      @param [options] {Object} Handlebars key/value pairs of options
-      @param [options.itemViewClass] {String} a path to a view class used for each item
-      @param [options.emptyViewClass] {String} a path to a view class used for each item
-      @param [options.itemController] {String} name of a controller to be created for each item
-    */
-    function eachHelper(params, hash, options, env) {
-      var helperName = 'each';
-      var path = params[0] || this.getStream('');
-
-      Ember.assert(
-        "If you pass more than one argument to the each helper, " +
-        "it must be in the form #each foo in bar",
-        params.length <= 1
-      );
+      var app = this;
 
-      if (options.template && options.template.blockParams) {
-        hash.keyword = true;
-      }
+      this.boot().then(function() {
+        app.runInstanceInitializers(_instance);
+      });
 
-      Ember.deprecate(
-        "Using the context switching form of {{each}} is deprecated. " +
-        "Please use the keyword form (`{{#each foo in bar}}`) instead.",
-        hash.keyword === true || typeof hash.keyword === 'string',
-        { url: 'http://emberjs.com/guides/deprecations/#toc_more-consistent-handlebars-scope' }
-      );
+      return this;
+    },
 
-      hash.dataSource = path;
-      options.helperName = options.helperName || helperName;
+    boot: function() {
+      if (this._bootPromise) { return this._bootPromise; }
 
-      return env.helpers.collection.helperFunction.call(this, [EachView], hash, options, env);
-    }
+      var defer = new Ember['default'].RSVP.defer();
+      this._bootPromise = defer.promise;
+      this._bootResolver = defer;
 
-    __exports__.EachView = EachView;
-    __exports__.eachHelper = eachHelper;
-  });
-enifed("ember-htmlbars/helpers/if_unless",
-  ["ember-metal/core","ember-htmlbars/helpers/binding","ember-metal/property_get","ember-metal/utils","ember-views/streams/conditional_stream","ember-metal/streams/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+      this.runInitializers(this.registry);
+      lazy_load.runLoadHooks('application', this);
 
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var bind = __dependency2__.bind;
+      this.advanceReadiness();
 
-    var get = __dependency3__.get;
-    var isArray = __dependency4__.isArray;
-    var ConditionalStream = __dependency5__["default"];
-    var isStream = __dependency6__.isStream;
+      return this._bootPromise;
+    },
 
-    function shouldDisplayIfHelperContent(result) {
-      var truthy = result && get(result, 'isTruthy');
-      if (typeof truthy === 'boolean') { return truthy; }
+    /**
+      Reset the application. This is typically used only in tests. It cleans up
+      the application in the following order:
 
-      if (isArray(result)) {
-        return get(result, 'length') !== 0;
-      } else {
-        return !!result;
-      }
-    }
+      1. Deactivate existing routes
+      2. Destroy all objects in the container
+      3. Create a new application container
+      4. Re-route to the existing url
 
-    var EMPTY_TEMPLATE = {
-      isHTMLBars: true,
-      render: function() {
-        return '';
-      }
-    };
-    /**
-      Use the `boundIf` helper to create a conditional that re-evaluates
-      whenever the truthiness of the bound value changes.
+      Typical Example:
 
-      ```handlebars
-      {{#boundIf "content.shouldDisplayTitle"}}
-        {{content.title}}
-      {{/boundIf}}
-      ```
+      ```javascript
+      var App;
 
-      @private
-      @method boundIf
-      @for Ember.Handlebars.helpers
-      @param {String} property Property to bind
-      @param {Function} fn Context to provide for rendering
-      @return {String} HTML string
-    */
-    function boundIfHelper(params, hash, options, env) {
-      options.helperName = options.helperName || 'boundIf';
-      return bind.call(this, params[0], hash, options, env, true, shouldDisplayIfHelperContent, shouldDisplayIfHelperContent, [
-       'isTruthy',
-       'length'
-     ]);
-    }
+      run(function() {
+        App = Ember.Application.create();
+      });
 
-    /**
-      @private
+      module('acceptance test', {
+        setup: function() {
+          App.reset();
+        }
+      });
 
-      Use the `unboundIf` helper to create a conditional that evaluates once.
+      test('first test', function() {
+        // App is freshly reset
+      });
 
-      ```handlebars
-      {{#unboundIf "content.shouldDisplayTitle"}}
-        {{content.title}}
-      {{/unboundIf}}
+      test('second test', function() {
+        // App is again freshly reset
+      });
       ```
 
-      @method unboundIf
-      @for Ember.Handlebars.helpers
-      @param {String} property Property to bind
-      @param {Function} fn Context to provide for rendering
-      @return {String} HTML string
-      @since 1.4.0
-    */
-    function unboundIfHelper(params, hash, options, env) {
-      var template = options.template;
-      var value = params[0];
-
-      if (isStream(params[0])) {
-        value = params[0].value();
-      }
+      Advanced Example:
 
-      if (!shouldDisplayIfHelperContent(value)) {
-        template = options.inverse || EMPTY_TEMPLATE;
-      }
+      Occasionally you may want to prevent the app from initializing during
+      setup. This could enable extra configuration, or enable asserting prior
+      to the app becoming ready.
 
-      return template.render(this, env, options.morph.contextualElement);
-    }
+      ```javascript
+      var App;
 
-    function _inlineIfAssertion(params) {
-      Ember.assert("If helper in inline form expects between two and three arguments", params.length === 2 || params.length === 3);
-    }
+      run(function() {
+        App = Ember.Application.create();
+      });
 
-    /**
-      See [boundIf](/api/classes/Ember.Handlebars.helpers.html#method_boundIf)
-      and [unboundIf](/api/classes/Ember.Handlebars.helpers.html#method_unboundIf)
+      module('acceptance test', {
+        setup: function() {
+          run(function() {
+            App.reset();
+            App.deferReadiness();
+          });
+        }
+      });
 
-      @method if
-      @for Ember.Handlebars.helpers
-      @param {Function} context
-      @param {Hash} options
-      @return {String} HTML string
-    */
-    function ifHelper(params, hash, options, env) {
-      Ember.assert("If helper in block form expect exactly one argument", !options.template || params.length === 1);
-      
-      options.inverse = options.inverse || EMPTY_TEMPLATE;
+      test('first test', function() {
+        ok(true, 'something before app is initialized');
 
-      options.helperName = options.helperName || ('if ');
+        run(function() {
+          App.advanceReadiness();
+        });
 
-      if (env.data.isUnbound) {
-        env.data.isUnbound = false;
-        return env.helpers.unboundIf.helperFunction.call(this, params, hash, options, env);
-      } else {
-        return env.helpers.boundIf.helperFunction.call(this, params, hash, options, env);
-      }
-    }
+        ok(true, 'something after app is initialized');
+      });
+      ```
 
-    /**
-      @method unless
-      @for Ember.Handlebars.helpers
-      @param {Function} context
-      @param {Hash} options
-      @return {String} HTML string
-    */
-    function unlessHelper(params, hash, options, env) {
-      Ember.assert("You must pass exactly one argument to the unless helper", params.length === 1);
-      Ember.assert("You must pass a block to the unless helper", !!options.template);
+      @method reset
+    **/
+    reset: function() {
+      var instance = this.__deprecatedInstance__;
 
-      var template = options.template;
-      var inverse = options.inverse || EMPTY_TEMPLATE;
-      var helperName = 'unless';
+      this._readinessDeferrals = 1;
+      this._bootPromise = null;
+      this._bootResolver = null;
 
-      options.template = inverse;
-      options.inverse = template;
+      function handleReset() {
+        run['default'](instance, 'destroy');
 
-      options.helperName = options.helperName || helperName;
+        this.buildDefaultInstance();
 
-      if (env.data.isUnbound) {
-        env.data.isUnbound = false;
-        return env.helpers.unboundIf.helperFunction.call(this, params, hash, options, env);
-      } else {
-        return env.helpers.boundIf.helperFunction.call(this, params, hash, options, env);
+        run['default'].schedule('actions', this, 'domReady');
       }
-    }
-
-    __exports__.ifHelper = ifHelper;
-    __exports__.boundIfHelper = boundIfHelper;
-    __exports__.unboundIfHelper = unboundIfHelper;
-    __exports__.unlessHelper = unlessHelper;
-  });
-enifed("ember-htmlbars/helpers/input",
-  ["ember-views/views/checkbox","ember-views/views/text_field","ember-metal/streams/utils","ember-metal/core","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    var Checkbox = __dependency1__["default"];
-    var TextField = __dependency2__["default"];
-    var read = __dependency3__.read;
 
-    var Ember = __dependency4__["default"];
-    // Ember.assert
+      run['default'].join(this, handleReset);
+    },
 
     /**
-    @module ember
-    @submodule ember-htmlbars
+      @private
+      @method runInitializers
     */
+    runInitializers: function(registry) {
+      var App = this;
+      this._runInitializer('initializers', function(name, initializer) {
+        Ember['default'].assert("No application initializer named '" + name + "'", !!initializer);
 
-    /**
-
-      The `{{input}}` helper inserts an HTML `<input>` tag into the template,
-      with a `type` value of either `text` or `checkbox`. If no `type` is provided,
-      `text` will be the default value applied. The attributes of `{{input}}`
-      match those of the native HTML tag as closely as possible for these two types.
 
-      ## Use as text field
-      An `{{input}}` with no `type` or a `type` of `text` will render an HTML text input.
-      The following HTML attributes can be set via the helper:
+          var ref = initializer.initialize;
+          ref(registry, App);
 
-     <table>
-      <tr><td>`readonly`</td><td>`required`</td><td>`autofocus`</td></tr>
-      <tr><td>`value`</td><td>`placeholder`</td><td>`disabled`</td></tr>
-      <tr><td>`size`</td><td>`tabindex`</td><td>`maxlength`</td></tr>
-      <tr><td>`name`</td><td>`min`</td><td>`max`</td></tr>
-      <tr><td>`pattern`</td><td>`accept`</td><td>`autocomplete`</td></tr>
-      <tr><td>`autosave`</td><td>`formaction`</td><td>`formenctype`</td></tr>
-      <tr><td>`formmethod`</td><td>`formnovalidate`</td><td>`formtarget`</td></tr>
-      <tr><td>`height`</td><td>`inputmode`</td><td>`multiple`</td></tr>
-      <tr><td>`step`</td><td>`width`</td><td>`form`</td></tr>
-      <tr><td>`selectionDirection`</td><td>`spellcheck`</td><td>&nbsp;</td></tr>
-     </table>
+      });
+    },
 
+    runInstanceInitializers: function(instance) {
+      this._runInitializer('instanceInitializers', function(name, initializer) {
+        Ember['default'].assert("No instance initializer named '" + name + "'", !!initializer);
+        initializer.initialize(instance);
+      });
+    },
 
-      When set to a quoted string, these values will be directly applied to the HTML
-      element. When left unquoted, these values will be bound to a property on the
-      template's current rendering context (most typically a controller instance).
+    _runInitializer: function(bucketName, cb) {
+      var initializersByName = property_get.get(this.constructor, bucketName);
+      var initializers = props(initializersByName);
+      var graph = new DAG['default']();
+      var initializer;
 
-      ## Unbound:
+      for (var i = 0; i < initializers.length; i++) {
+        initializer = initializersByName[initializers[i]];
+        graph.addEdges(initializer.name, initializer, initializer.before, initializer.after);
+      }
 
-      ```handlebars
-      {{input value="http://www.facebook.com"}}
-      ```
+      graph.topsort(function (vertex) {
+        cb(vertex.name, vertex.value);
+      });
+    },
 
+    /**
+      @private
+      @method didBecomeReady
+    */
+    didBecomeReady: function() {
+      if (this.autoboot) {
+        if (environment['default'].hasDOM) {
+          this.__deprecatedInstance__.setupEventDispatcher();
+        }
 
-      ```html
-      <input type="text" value="http://www.facebook.com"/>
-      ```
+        this.ready(); // user hook
+        this.__deprecatedInstance__.startRouting();
 
-      ## Bound:
+        if (!Ember['default'].testing) {
+          // Eagerly name all classes that are already loaded
+          Ember['default'].Namespace.processAll();
+          Ember['default'].BOOTED = true;
+        }
 
-      ```javascript
-      App.ApplicationController = Ember.Controller.extend({
-        firstName: "Stanley",
-        entryNotAllowed: true
-      });
-      ```
+        this.resolve(this);
+      }
 
+      this._bootResolver.resolve();
+    },
 
-      ```handlebars
-      {{input type="text" value=firstName disabled=entryNotAllowed size="50"}}
-      ```
+    /**
+      Called when the Application has become ready.
+      The call will be delayed until the DOM has become ready.
 
+      @event ready
+    */
+    ready: function() { return this; },
 
-      ```html
-      <input type="text" value="Stanley" disabled="disabled" size="50"/>
-      ```
+    /**
+      @deprecated Use 'Resolver' instead
+      Set this to provide an alternate class to `Ember.DefaultResolver`
 
-      ## Actions
 
-      The helper can send multiple actions based on user events.
+      @property resolver
+    */
+    resolver: null,
 
-      The action property defines the action which is sent when
-      the user presses the return key.
+    /**
+      Set this to provide an alternate class to `Ember.DefaultResolver`
 
-      ```handlebars
-      {{input action="submit"}}
-      ```
+      @property resolver
+    */
+    Resolver: null,
 
-      The helper allows some user events to send actions.
+    // This method must be moved to the application instance object
+    willDestroy: function() {
+      Ember['default'].BOOTED = false;
+      this._bootPromise = null;
+      this._bootResolver = null;
+      this.__deprecatedInstance__.destroy();
+    },
 
-    * `enter`
-    * `insert-newline`
-    * `escape-press`
-    * `focus-in`
-    * `focus-out`
-    * `key-press`
+    initializer: function(options) {
+      this.constructor.initializer(options);
+    },
 
+    /**
+      @method then
+      @private
+      @deprecated
+    */
+    then: function() {
+      Ember['default'].deprecate(
+        'Do not use `.then` on an instance of Ember.Application.  Please use the `.ready` hook instead.',
+        false,
+        { url: 'http://emberjs.com/guides/deprecations/#toc_code-then-code-on-ember-application' }
+      );
 
-      For example, if you desire an action to be sent when the input is blurred,
-      you only need to setup the action name to the event name property.
+      this._super.apply(this, arguments);
+    }
+  });
 
-      ```handlebars
-      {{input focus-in="alertMessage"}}
-      ```
 
-      See more about [Text Support Actions](/api/classes/Ember.TextField.html)
 
-      ## Extension
+  Application.reopenClass({
+    initializers: create['default'](null),
+    instanceInitializers: create['default'](null),
 
-      Internally, `{{input type="text"}}` creates an instance of `Ember.TextField`, passing
-      arguments from the helper to `Ember.TextField`'s `create` method. You can extend the
-      capabilities of text inputs in your applications by reopening this class. For example,
-      if you are building a Bootstrap project where `data-*` attributes are used, you
-      can add one to the `TextField`'s `attributeBindings` property:
+    /**
+      Initializer receives an object which has the following attributes:
+      `name`, `before`, `after`, `initialize`. The only required attribute is
+      `initialize, all others are optional.
 
+      * `name` allows you to specify under which name the initializer is registered.
+      This must be a unique name, as trying to register two initializers with the
+      same name will result in an error.
 
       ```javascript
-      Ember.TextField.reopen({
-        attributeBindings: ['data-error']
+      Ember.Application.initializer({
+        name: 'namedInitializer',
+
+        initialize: function(container, application) {
+          Ember.debug('Running namedInitializer!');
+        }
       });
       ```
 
-      Keep in mind when writing `Ember.TextField` subclasses that `Ember.TextField`
-      itself extends `Ember.Component`, meaning that it does NOT inherit
-      the `controller` of the parent view.
-
-      See more about [Ember components](/api/classes/Ember.Component.html)
+      * `before` and `after` are used to ensure that this initializer is ran prior
+      or after the one identified by the value. This value can be a single string
+      or an array of strings, referencing the `name` of other initializers.
 
+      An example of ordering initializers, we create an initializer named `first`:
 
-      ## Use as checkbox
-
-      An `{{input}}` with a `type` of `checkbox` will render an HTML checkbox input.
-      The following HTML attributes can be set via the helper:
+      ```javascript
+      Ember.Application.initializer({
+        name: 'first',
 
-    * `checked`
-    * `disabled`
-    * `tabindex`
-    * `indeterminate`
-    * `name`
-    * `autofocus`
-    * `form`
+        initialize: function(container, application) {
+          Ember.debug('First initializer!');
+        }
+      });
 
+      // DEBUG: First initializer!
+      ```
 
-      When set to a quoted string, these values will be directly applied to the HTML
-      element. When left unquoted, these values will be bound to a property on the
-      template's current rendering context (most typically a controller instance).
+      We add another initializer named `second`, specifying that it should run
+      after the initializer named `first`:
 
-      ## Unbound:
+      ```javascript
+      Ember.Application.initializer({
+        name: 'second',
+        after: 'first',
 
-      ```handlebars
-      {{input type="checkbox" name="isAdmin"}}
-      ```
+        initialize: function(container, application) {
+          Ember.debug('Second initializer!');
+        }
+      });
 
-      ```html
-      <input type="checkbox" name="isAdmin" />
+      // DEBUG: First initializer!
+      // DEBUG: Second initializer!
       ```
 
-      ## Bound:
+      Afterwards we add a further initializer named `pre`, this time specifying
+      that it should run before the initializer named `first`:
 
       ```javascript
-      App.ApplicationController = Ember.Controller.extend({
-        isAdmin: true
+      Ember.Application.initializer({
+        name: 'pre',
+        before: 'first',
+
+        initialize: function(container, application) {
+          Ember.debug('Pre initializer!');
+        }
       });
+
+      // DEBUG: Pre initializer!
+      // DEBUG: First initializer!
+      // DEBUG: Second initializer!
       ```
 
+      Finally we add an initializer named `post`, specifying it should run after
+      both the `first` and the `second` initializers:
 
-      ```handlebars
-      {{input type="checkbox" checked=isAdmin }}
-      ```
+      ```javascript
+      Ember.Application.initializer({
+        name: 'post',
+        after: ['first', 'second'],
 
+        initialize: function(container, application) {
+          Ember.debug('Post initializer!');
+        }
+      });
 
-      ```html
-      <input type="checkbox" checked="checked" />
+      // DEBUG: Pre initializer!
+      // DEBUG: First initializer!
+      // DEBUG: Second initializer!
+      // DEBUG: Post initializer!
       ```
 
-      ## Extension
-
-      Internally, `{{input type="checkbox"}}` creates an instance of `Ember.Checkbox`, passing
-      arguments from the helper to `Ember.Checkbox`'s `create` method. You can extend the
-      capablilties of checkbox inputs in your applications by reopening this class. For example,
-      if you wanted to add a css class to all checkboxes in your application:
+      * `initialize` is a callback function that receives two arguments, `container`
+      and `application` on which you can operate.
 
+      Example of using `container` to preload data into the store:
 
       ```javascript
-      Ember.Checkbox.reopen({
-        classNames: ['my-app-checkbox']
+      Ember.Application.initializer({
+        name: 'preload-data',
+
+        initialize: function(container, application) {
+          var store = container.lookup('store:main');
+
+          store.pushPayload(preloadedData);
+        }
       });
       ```
 
+      Example of using `application` to register an adapter:
 
-      @method input
-      @for Ember.Handlebars.helpers
-      @param {Hash} options
-    */
-    function inputHelper(params, hash, options, env) {
-      Ember.assert('You can only pass attributes to the `input` helper, not arguments', params.length === 0);
+      ```javascript
+      Ember.Application.initializer({
+        name: 'api-adapter',
 
-      var onEvent = hash.on;
-      var inputType;
+        initialize: function(container, application) {
+          application.register('api-adapter:main', ApiAdapter);
+        }
+      });
+      ```
 
-      inputType = read(hash.type);
+      @method initializer
+      @param initializer {Object}
+     */
+    initializer: buildInitializerMethod('initializers', 'initializer'),
 
-      if (inputType === 'checkbox') {
-        delete hash.type;
+    /**
+      This creates a registry with the default Ember naming conventions.
 
-        Ember.assert("{{input type='checkbox'}} does not support setting `value=someBooleanValue`;" +
-                     " you must use `checked=someBooleanValue` instead.", !hash.hasOwnProperty('value'));
+      It also configures the registry:
 
-        env.helpers.view.helperFunction.call(this, [Checkbox], hash, options, env);
-      } else {
-        delete hash.on;
+      * registered views are created every time they are looked up (they are
+        not singletons)
+      * registered templates are not factories; the registered value is
+        returned directly.
+      * the router receives the application as its `namespace` property
+      * all controllers receive the router as their `target` and `controllers`
+        properties
+      * all controllers receive the application as their `namespace` property
+      * the application view receives the application controller as its
+        `controller` property
+      * the application view receives the application template as its
+        `defaultTemplate` property
 
-        hash.onEvent = onEvent || 'enter';
-        env.helpers.view.helperFunction.call(this, [TextField], hash, options, env);
-      }
-    }
+      @private
+      @method buildRegistry
+      @static
+      @param {Ember.Application} namespace the application for which to
+        build the registry
+      @return {Ember.Registry} the built registry
+    */
+    buildRegistry: function(namespace) {
+      var registry = new Registry['default']();
 
-    __exports__.inputHelper = inputHelper;
-  });
-enifed("ember-htmlbars/helpers/loc",
-  ["ember-metal/core","ember-runtime/system/string","ember-metal/streams/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var loc = __dependency2__.loc;
-    var isStream = __dependency3__.isStream;
+      registry.set = property_set.set;
+      registry.resolver = resolverFor(namespace);
+      registry.normalizeFullName = registry.resolver.normalize;
+      registry.describe = registry.resolver.describe;
+      registry.makeToString = registry.resolver.makeToString;
 
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+      registry.optionsForType('component', { singleton: false });
+      registry.optionsForType('view', { singleton: false });
+      registry.optionsForType('template', { instantiate: false });
+      registry.optionsForType('helper', { instantiate: false });
 
-    /**
-      Calls [Ember.String.loc](/api/classes/Ember.String.html#method_loc) with the
-      provided string.
+      registry.register('application:main', namespace, { instantiate: false });
 
-      This is a convenient way to localize text within a template:
+      registry.register('controller:basic', Controller['default'], { instantiate: false });
+      registry.register('controller:object', ObjectController['default'], { instantiate: false });
+      registry.register('controller:array', ArrayController['default'], { instantiate: false });
 
-      ```javascript
-      Ember.STRINGS = {
-        '_welcome_': 'Bonjour'
-      };
-      ```
+      registry.register('renderer:-dom', { create: function() { return new Renderer['default'](new DOMHelper['default']()); } });
 
-      ```handlebars
-      <div class='message'>
-        {{loc '_welcome_'}}
-      </div>
-      ```
+      registry.injection('view', 'renderer', 'renderer:-dom');
+      registry.register('view:select', SelectView['default']);
+      registry.register('view:-outlet', outlet.OutletView);
 
-      ```html
-      <div class='message'>
-        Bonjour
-      </div>
-      ```
+      registry.register('view:default', _MetamorphView['default']);
+      registry.register('view:toplevel', EmberView['default'].extend());
 
-      See [Ember.String.loc](/api/classes/Ember.String.html#method_loc) for how to
-      set up localized string references.
+      registry.register('route:basic', Route['default'], { instantiate: false });
+      registry.register('event_dispatcher:main', EventDispatcher['default']);
 
-      @method loc
-      @for Ember.Handlebars.helpers
-      @param {String} str The string to format
-      @see {Ember.String#loc}
-    */
-    function locHelper(params, hash, options, env) {
-      Ember.assert('You cannot pass bindings to `loc` helper', (function ifParamsContainBindings() {
-        for (var i = 0, l = params.length; i < l; i++) {
-          if (isStream(params[i])) {
-            return false;
-          }
-        }
-        return true;
-      })());
+      registry.injection('router:main', 'namespace', 'application:main');
+      registry.injection('view:-outlet', 'namespace', 'application:main');
 
-      return loc.apply(this, params);
-    }
+      registry.register('location:auto', AutoLocation['default']);
+      registry.register('location:hash', HashLocation['default']);
+      registry.register('location:history', HistoryLocation['default']);
+      registry.register('location:none', NoneLocation['default']);
 
-    __exports__.locHelper = locHelper;
-  });
-enifed("ember-htmlbars/helpers/log",
-  ["ember-metal/logger","ember-metal/streams/utils","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
-    var Logger = __dependency1__["default"];
-    var read = __dependency2__.read;
+      registry.injection('controller', 'target', 'router:main');
+      registry.injection('controller', 'namespace', 'application:main');
 
-    /**
-      `log` allows you to output the value of variables in the current rendering
-      context. `log` also accepts primitive types such as strings or numbers.
+      registry.register('-bucket-cache:main', BucketCache['default']);
+      registry.injection('router', '_bucketCache', '-bucket-cache:main');
+      registry.injection('route', '_bucketCache', '-bucket-cache:main');
+      registry.injection('controller', '_bucketCache', '-bucket-cache:main');
 
-      ```handlebars
-      {{log "myVariable:" myVariable }}
-      ```
+      registry.injection('route', 'router', 'router:main');
+      registry.injection('location', 'rootURL', '-location-setting:root-url');
 
-      @method log
-      @for Ember.Handlebars.helpers
-      @param {String} property
-    */
-    function logHelper(params, hash, options, env) {
-      var logger = Logger.log;
-      var values = [];
+      // DEBUGGING
+      registry.register('resolver-for-debugging:main', registry.resolver.__resolver__, { instantiate: false });
+      registry.injection('container-debug-adapter:main', 'resolver', 'resolver-for-debugging:main');
+      registry.injection('data-adapter:main', 'containerDebugAdapter', 'container-debug-adapter:main');
+      // Custom resolver authors may want to register their own ContainerDebugAdapter with this key
 
-      for (var i = 0; i < params.length; i++) {
-        values.push(read(params[i]));
-      }
+      registry.register('container-debug-adapter:main', ContainerDebugAdapter['default']);
 
-      logger.apply(logger, values);
+      return registry;
     }
-
-    __exports__.logHelper = logHelper;
   });
-enifed("ember-htmlbars/helpers/partial",
-  ["ember-metal/core","ember-metal/is_none","./binding","ember-metal/streams/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-
-    var isNone = __dependency2__["default"];
-    var bind = __dependency3__.bind;
-    var isStream = __dependency4__.isStream;
-
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
 
-    /**
-      The `partial` helper renders another template without
-      changing the template context:
+  /**
+    This function defines the default lookup rules for container lookups:
 
-      ```handlebars
-      {{foo}}
-      {{partial "nav"}}
-      ```
+    * templates are looked up on `Ember.TEMPLATES`
+    * other names are looked up on the application after classifying the name.
+      For example, `controller:post` looks up `App.PostController` by default.
+    * if the default lookup fails, look for registered classes on the container
 
-      The above example template will render a template named
-      "_nav", which has the same context as the parent template
-      it's rendered into, so if the "_nav" template also referenced
-      `{{foo}}`, it would print the same thing as the `{{foo}}`
-      in the above example.
+    This allows the application to register default injections in the container
+    that could be overridden by the normal naming convention.
 
-      If a "_nav" template isn't found, the `partial` helper will
-      fall back to a template named "nav".
+    @private
+    @method resolverFor
+    @param {Ember.Namespace} namespace the namespace to look for classes
+    @return {*} the resolved value for a given lookup
+  */
+  function resolverFor(namespace) {
+    Ember['default'].deprecate(
+      'Application.resolver is deprecated in favor of Application.Resolver',
+      !namespace.get('resolver')
+    );
 
-      ## Bound template names
+    var ResolverClass = namespace.get('resolver') || namespace.get('Resolver') || DefaultResolver['default'];
+    var resolver = ResolverClass.create({
+      namespace: namespace
+    });
 
-      The parameter supplied to `partial` can also be a path
-      to a property containing a template name, e.g.:
+    function resolve(fullName) {
+      return resolver.resolve(fullName);
+    }
 
-      ```handlebars
-      {{partial someTemplateName}}
-      ```
+    resolve.describe = function(fullName) {
+      return resolver.lookupDescription(fullName);
+    };
 
-      The above example will look up the value of `someTemplateName`
-      on the template context (e.g. a controller) and use that
-      value as the name of the template to render. If the resolved
-      value is falsy, nothing will be rendered. If `someTemplateName`
-      changes, the partial will be re-rendered using the new template
-      name.
+    resolve.makeToString = function(factory, fullName) {
+      return resolver.makeToString(factory, fullName);
+    };
 
+    resolve.normalize = function(fullName) {
+      if (resolver.normalize) {
+        return resolver.normalize(fullName);
+      } else {
+        Ember['default'].deprecate('The Resolver should now provide a \'normalize\' function');
+        return fullName;
+      }
+    };
 
-      @method partial
-      @for Ember.Handlebars.helpers
-      @param {String} partialName the name of the template to render minus the leading underscore
-    */
+    resolve.__resolver__ = resolver;
 
-    function partialHelper(params, hash, options, env) {
-      options.helperName = options.helperName || 'partial';
+    return resolve;
+  }
 
-      var name = params[0];
+  function registerLibraries() {
+    if (!librariesRegistered) {
+      librariesRegistered = true;
 
-      if (isStream(name)) {
-        options.template = createPartialTemplate(name);
-        bind.call(this, name, hash, options, env, true, exists);
-      } else {
-        return renderPartial(name, this, env, options.morph.contextualElement);
+      if (environment['default'].hasDOM) {
+        Ember['default'].libraries.registerCoreLibrary('jQuery', jQuery['default']().jquery);
       }
     }
+  }
 
-    __exports__.partialHelper = partialHelper;function exists(value) {
-      return !isNone(value);
-    }
+  function logLibraryVersions() {
+    if (Ember['default'].LOG_VERSION) {
+      // we only need to see this once per Application#init
+      Ember['default'].LOG_VERSION = false;
+      var libs = Ember['default'].libraries._registry;
 
-    function lookupPartial(view, templateName) {
-      var nameParts = templateName.split("/");
-      var lastPart = nameParts[nameParts.length - 1];
+      var nameLengths = EnumerableUtils['default'].map(libs, function(item) {
+        return property_get.get(item, 'name.length');
+      });
 
-      nameParts[nameParts.length - 1] = "_" + lastPart;
+      var maxNameLength = Math.max.apply(this, nameLengths);
 
-      var underscoredName = nameParts.join('/');
-      var template = view.templateForName(underscoredName);
-      if (!template) {
-        template = view.templateForName(templateName);
+      Ember['default'].debug('-------------------------------');
+      for (var i = 0, l = libs.length; i < l; i++) {
+        var lib = libs[i];
+        var spaces = new Array(maxNameLength - lib.name.length + 1).join(' ');
+        Ember['default'].debug([lib.name, spaces, ' : ', lib.version].join(''));
       }
+      Ember['default'].debug('-------------------------------');
+    }
+  }
 
-      Ember.assert('Unable to find partial with name "'+templateName+'"', !!template);
+  function buildInitializerMethod(bucketName, humanName) {
+    return function(initializer) {
+      // If this is the first initializer being added to a subclass, we are going to reopen the class
+      // to make sure we have a new `initializers` object, which extends from the parent class' using
+      // prototypal inheritance. Without this, attempting to add initializers to the subclass would
+      // pollute the parent class as well as other subclasses.
+      if (this.superclass[bucketName] !== undefined && this.superclass[bucketName] === this[bucketName]) {
+        var attrs = {};
+        attrs[bucketName] = create['default'](this[bucketName]);
+        this.reopenClass(attrs);
+      }
 
-      return template;
-    }
+      Ember['default'].assert("The " + humanName + " '" + initializer.name + "' has already been registered", !this[bucketName][initializer.name]);
+      Ember['default'].assert("An " + humanName + " cannot be registered without an initialize function", utils.canInvoke(initializer, 'initialize'));
+      Ember['default'].assert("An " + humanName + " cannot be registered without a name property", initializer.name !== undefined);
 
-    function renderPartial(name, view, env, contextualElement) {
-      var template = lookupPartial(view, name);
-      return template.render(view, env, contextualElement);
-    }
+      this[bucketName][initializer.name] = initializer;
+    };
+  }
 
-    function createPartialTemplate(nameStream) {
-      return {
-        isHTMLBars: true,
-        render: function(view, env, contextualElement) {
-          return renderPartial(nameStream.value(), view, env, contextualElement);
-        }
-      };
-    }
-  });
-enifed("ember-htmlbars/helpers/template",
-  ["ember-metal/core","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.deprecate;
+  exports['default'] = Application;
 
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+});
+enifed('ember-application/system/resolver', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/logger', 'ember-runtime/system/string', 'ember-runtime/system/object', 'ember-runtime/system/namespace', 'ember-htmlbars/helpers', 'ember-metal/dictionary'], function (exports, Ember, property_get, Logger, string, EmberObject, Namespace, helpers, dictionary) {
+
+  'use strict';
+
+  /**
+  @module ember
+  @submodule ember-application
+  */
 
+  var Resolver = EmberObject['default'].extend({
     /**
-      @deprecated
-      @method template
-      @for Ember.Handlebars.helpers
-      @param {String} templateName the template to render
+      This will be set to the Application instance when it is
+      created.
+
+      @property namespace
     */
-    function templateHelper(params, hash, options, env) {
-      Ember.deprecate("The `template` helper has been deprecated in favor of the `partial` helper." +
-                      " Please use `partial` instead, which will work the same way.");
+    namespace: null,
+    normalize:         Ember['default'].required(Function),
+    resolve:           Ember['default'].required(Function),
+    parseName:         Ember['default'].required(Function),
+    lookupDescription: Ember['default'].required(Function),
+    makeToString:      Ember['default'].required(Function),
+    resolveOther:      Ember['default'].required(Function),
+    _logLookup:        Ember['default'].required(Function)
+  });
 
-      options.helperName = options.helperName || 'template';
+  /**
+    The DefaultResolver defines the default lookup rules to resolve
+    container lookups before consulting the container for registered
+    items:
 
-      return env.helpers.partial.helperFunction.call(this, params, hash, options, env);
-    }
+    * templates are looked up on `Ember.TEMPLATES`
+    * other names are looked up on the application after converting
+      the name. For example, `controller:post` looks up
+      `App.PostController` by default.
+    * there are some nuances (see examples below)
 
-    __exports__.templateHelper = templateHelper;
-  });
-enifed("ember-htmlbars/helpers/text_area",
-  ["ember-metal/core","ember-views/views/text_area","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+    ### How Resolving Works
 
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var TextArea = __dependency2__["default"];
+    The container calls this object's `resolve` method with the
+    `fullName` argument.
 
-    /**
-      `{{textarea}}` inserts a new instance of `<textarea>` tag into the template.
-      The attributes of `{{textarea}}` match those of the native HTML tags as
-      closely as possible.
+    It first parses the fullName into an object using `parseName`.
+
+    Then it checks for the presence of a type-specific instance
+    method of the form `resolve[Type]` and calls it if it exists.
+    For example if it was resolving 'template:post', it would call
+    the `resolveTemplate` method.
 
-      The following HTML attributes can be set:
+    Its last resort is to call the `resolveOther` method.
 
-        * `value`
-        * `name`
-        * `rows`
-        * `cols`
-        * `placeholder`
-        * `disabled`
-        * `maxlength`
-        * `tabindex`
-        * `selectionEnd`
-        * `selectionStart`
-        * `selectionDirection`
-        * `wrap`
-        * `readonly`
-        * `autofocus`
-        * `form`
-        * `spellcheck`
-        * `required`
+    The methods of this object are designed to be easy to override
+    in a subclass. For example, you could enhance how a template
+    is resolved like so:
 
-      When set to a quoted string, these value will be directly applied to the HTML
-      element. When left unquoted, these values will be bound to a property on the
-      template's current rendering context (most typically a controller instance).
+    ```javascript
+    App = Ember.Application.create({
+      Resolver: Ember.DefaultResolver.extend({
+        resolveTemplate: function(parsedName) {
+          var resolvedTemplate = this._super(parsedName);
+          if (resolvedTemplate) { return resolvedTemplate; }
+          return Ember.TEMPLATES['not_found'];
+        }
+      })
+    });
+    ```
 
-      Unbound:
+    Some examples of how names are resolved:
 
-      ```handlebars
-      {{textarea value="Lots of static text that ISN'T bound"}}
-      ```
+    ```
+    'template:post'           //=> Ember.TEMPLATES['post']
+    'template:posts/byline'   //=> Ember.TEMPLATES['posts/byline']
+    'template:posts.byline'   //=> Ember.TEMPLATES['posts/byline']
+    'template:blogPost'       //=> Ember.TEMPLATES['blogPost']
+                              //   OR
+                              //   Ember.TEMPLATES['blog_post']
+    'controller:post'         //=> App.PostController
+    'controller:posts.index'  //=> App.PostsIndexController
+    'controller:blog/post'    //=> Blog.PostController
+    'controller:basic'        //=> Ember.Controller
+    'route:post'              //=> App.PostRoute
+    'route:posts.index'       //=> App.PostsIndexRoute
+    'route:blog/post'         //=> Blog.PostRoute
+    'route:basic'             //=> Ember.Route
+    'view:post'               //=> App.PostView
+    'view:posts.index'        //=> App.PostsIndexView
+    'view:blog/post'          //=> Blog.PostView
+    'view:basic'              //=> Ember.View
+    'foo:post'                //=> App.PostFoo
+    'model:post'              //=> App.Post
+    ```
 
-      Would result in the following HTML:
+    @class DefaultResolver
+    @namespace Ember
+    @extends Ember.Object
+  */
+  exports['default'] = EmberObject['default'].extend({
+    /**
+      This will be set to the Application instance when it is
+      created.
 
-      ```html
-      <textarea class="ember-text-area">
-        Lots of static text that ISN'T bound
-      </textarea>
-      ```
+      @property namespace
+    */
+    namespace: null,
 
-      Bound:
+    init: function() {
+      this._parseNameCache = dictionary['default'](null);
+    },
+    normalize: function(fullName) {
+      var split = fullName.split(':', 2);
+      var type = split[0];
+      var name = split[1];
 
-      In the following example, the `writtenWords` property on `App.ApplicationController`
-      will be updated live as the user types 'Lots of text that IS bound' into
-      the text area of their browser's window.
+      Ember['default'].assert("Tried to normalize a container name without a colon (:) in it." +
+                   " You probably tried to lookup a name that did not contain a type," +
+                   " a colon, and a name. A proper lookup name would be `view:post`.", split.length === 2);
 
-      ```javascript
-      App.ApplicationController = Ember.Controller.extend({
-        writtenWords: "Lots of text that IS bound"
-      });
-      ```
+      if (type !== 'template') {
+        var result = name;
 
-      ```handlebars
-      {{textarea value=writtenWords}}
-      ```
+        if (result.indexOf('.') > -1) {
+          result = result.replace(/\.(.)/g, function(m) {
+            return m.charAt(1).toUpperCase();
+          });
+        }
 
-       Would result in the following HTML:
+        if (name.indexOf('_') > -1) {
+          result = result.replace(/_(.)/g, function(m) {
+            return m.charAt(1).toUpperCase();
+          });
+        }
 
-      ```html
-      <textarea class="ember-text-area">
-        Lots of text that IS bound
-      </textarea>
-      ```
+        return type + ':' + result;
+      } else {
+        return fullName;
+      }
+    },
 
-      If you wanted a one way binding between the text area and a div tag
-      somewhere else on your screen, you could use `Ember.computed.oneWay`:
 
-      ```javascript
-      App.ApplicationController = Ember.Controller.extend({
-        writtenWords: "Lots of text that IS bound",
-        outputWrittenWords: Ember.computed.oneWay("writtenWords")
-      });
-      ```
+    /**
+      This method is called via the container's resolver method.
+      It parses the provided `fullName` and then looks up and
+      returns the appropriate template or class.
 
-      ```handlebars
-      {{textarea value=writtenWords}}
+      @method resolve
+      @param {String} fullName the lookup string
+      @return {Object} the resolved factory
+    */
+    resolve: function(fullName) {
+      var parsedName = this.parseName(fullName);
+      var resolveMethodName = parsedName.resolveMethodName;
+      var resolved;
 
-      <div>
-        {{outputWrittenWords}}
-      </div>
-      ```
+      if (this[resolveMethodName]) {
+        resolved = this[resolveMethodName](parsedName);
+      }
 
-      Would result in the following HTML:
+      resolved = resolved || this.resolveOther(parsedName);
+
+      if (parsedName.root && parsedName.root.LOG_RESOLVER) {
+        this._logLookup(resolved, parsedName);
+      }
 
-      ```html
-      <textarea class="ember-text-area">
-        Lots of text that IS bound
-      </textarea>
+      return resolved;
+    },
 
-      <-- the following div will be updated in real time as you type -->
+    /**
+      Convert the string name of the form 'type:name' to
+      a Javascript object with the parsed aspects of the name
+      broken out.
 
-      <div>
-        Lots of text that IS bound
-      </div>
-      ```
+      @protected
+      @param {String} fullName the lookup string
+      @method parseName
+    */
 
-      Finally, this example really shows the power and ease of Ember when two
-      properties are bound to eachother via `Ember.computed.alias`. Type into
-      either text area box and they'll both stay in sync. Note that
-      `Ember.computed.alias` costs more in terms of performance, so only use it when
-      your really binding in both directions:
+    parseName: function(fullName) {
+      return this._parseNameCache[fullName] || (
+        this._parseNameCache[fullName] = this._parseName(fullName)
+      );
+    },
 
-      ```javascript
-      App.ApplicationController = Ember.Controller.extend({
-        writtenWords: "Lots of text that IS bound",
-        twoWayWrittenWords: Ember.computed.alias("writtenWords")
-      });
-      ```
+    _parseName: function(fullName) {
+      var nameParts = fullName.split(':');
+      var type = nameParts[0];
+      var fullNameWithoutType = nameParts[1];
+      var name = fullNameWithoutType;
+      var namespace = property_get.get(this, 'namespace');
+      var root = namespace;
 
-      ```handlebars
-      {{textarea value=writtenWords}}
-      {{textarea value=twoWayWrittenWords}}
-      ```
+      if (type !== 'template' && name.indexOf('/') !== -1) {
+        var parts = name.split('/');
+        name = parts[parts.length - 1];
+        var namespaceName = string.capitalize(parts.slice(0, -1).join('.'));
+        root = Namespace['default'].byName(namespaceName);
 
-      ```html
-      <textarea id="ember1" class="ember-text-area">
-        Lots of text that IS bound
-      </textarea>
+        Ember['default'].assert('You are looking for a ' + name + ' ' + type +
+                     ' in the ' + namespaceName +
+                     ' namespace, but the namespace could not be found', root);
+      }
 
-      <-- both updated in real time -->
+      var resolveMethodName = fullNameWithoutType === 'main' ? 'Main' : string.classify(type);
 
-      <textarea id="ember2" class="ember-text-area">
-        Lots of text that IS bound
-      </textarea>
-      ```
+      if (!(name && type)) {
+        throw new TypeError('Invalid fullName: `' + fullName + '`, must be of the form `type:name` ');
+      }
 
-      ## Actions
+      return {
+        fullName: fullName,
+        type: type,
+        fullNameWithoutType: fullNameWithoutType,
+        name: name,
+        root: root,
+        resolveMethodName: 'resolve' + resolveMethodName
+      };
+    },
 
-      The helper can send multiple actions based on user events.
+    /**
+      Returns a human-readable description for a fullName. Used by the
+      Application namespace in assertions to describe the
+      precise name of the class that Ember is looking for, rather than
+      container keys.
 
-      The action property defines the action which is send when
-      the user presses the return key.
+      @protected
+      @param {String} fullName the lookup string
+      @method lookupDescription
+    */
+    lookupDescription: function(fullName) {
+      var parsedName = this.parseName(fullName);
+      var description;
 
-      ```handlebars
-      {{input action="submit"}}
-      ```
+      if (parsedName.type === 'template') {
+        return 'template at ' + parsedName.fullNameWithoutType.replace(/\./g, '/');
+      }
 
-      The helper allows some user events to send actions.
+      description = parsedName.root + '.' + string.classify(parsedName.name).replace(/\./g, '');
 
-    * `enter`
-    * `insert-newline`
-    * `escape-press`
-    * `focus-in`
-    * `focus-out`
-    * `key-press`
+      if (parsedName.type !== 'model') {
+        description += string.classify(parsedName.type);
+      }
 
-      For example, if you desire an action to be sent when the input is blurred,
-      you only need to setup the action name to the event name property.
+      return description;
+    },
 
-      ```handlebars
-      {{textarea focus-in="alertMessage"}}
-      ```
+    makeToString: function(factory, fullName) {
+      return factory.toString();
+    },
 
-      See more about [Text Support Actions](/api/classes/Ember.TextArea.html)
+    /**
+      Given a parseName object (output from `parseName`), apply
+      the conventions expected by `Ember.Router`
 
-      ## Extension
+      @protected
+      @param {Object} parsedName a parseName object with the parsed
+        fullName lookup string
+      @method useRouterNaming
+    */
+    useRouterNaming: function(parsedName) {
+      parsedName.name = parsedName.name.replace(/\./g, '_');
+      if (parsedName.name === 'basic') {
+        parsedName.name = '';
+      }
+    },
+    /**
+      Look up the template in Ember.TEMPLATES
 
-      Internally, `{{textarea}}` creates an instance of `Ember.TextArea`, passing
-      arguments from the helper to `Ember.TextArea`'s `create` method. You can
-      extend the capabilities of text areas in your application by reopening this
-      class. For example, if you are building a Bootstrap project where `data-*`
-      attributes are used, you can globally add support for a `data-*` attribute
-      on all `{{textarea}}`s' in your app by reopening `Ember.TextArea` or
-      `Ember.TextSupport` and adding it to the `attributeBindings` concatenated
-      property:
+      @protected
+      @param {Object} parsedName a parseName object with the parsed
+        fullName lookup string
+      @method resolveTemplate
+    */
+    resolveTemplate: function(parsedName) {
+      var templateName = parsedName.fullNameWithoutType.replace(/\./g, '/');
 
-      ```javascript
-      Ember.TextArea.reopen({
-        attributeBindings: ['data-error']
-      });
-      ```
+      if (Ember['default'].TEMPLATES[templateName]) {
+        return Ember['default'].TEMPLATES[templateName];
+      }
 
-      Keep in mind when writing `Ember.TextArea` subclasses that `Ember.TextArea`
-      itself extends `Ember.Component`, meaning that it does NOT inherit
-      the `controller` of the parent view.
+      templateName = string.decamelize(templateName);
+      if (Ember['default'].TEMPLATES[templateName]) {
+        return Ember['default'].TEMPLATES[templateName];
+      }
+    },
 
-      See more about [Ember components](/api/classes/Ember.Component.html)
+    /**
+      Lookup the view using `resolveOther`
 
-      @method textarea
-      @for Ember.Handlebars.helpers
-      @param {Hash} options
+      @protected
+      @param {Object} parsedName a parseName object with the parsed
+        fullName lookup string
+      @method resolveView
     */
-    function textareaHelper(params, hash, options, env) {
-      Ember.assert('You can only pass attributes to the `textarea` helper, not arguments', params.length === 0);
+    resolveView: function(parsedName) {
+      this.useRouterNaming(parsedName);
+      return this.resolveOther(parsedName);
+    },
 
-      return env.helpers.view.helperFunction.call(this, [TextArea], hash, options, env);
-    }
+    /**
+      Lookup the controller using `resolveOther`
 
-    __exports__.textareaHelper = textareaHelper;
-  });
-enifed("ember-htmlbars/helpers/unbound",
-  ["ember-htmlbars/system/lookup-helper","ember-metal/streams/utils","ember-metal/error","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var lookupHelper = __dependency1__["default"];
-    var read = __dependency2__.read;
-    var EmberError = __dependency3__["default"];
+      @protected
+      @param {Object} parsedName a parseName object with the parsed
+        fullName lookup string
+      @method resolveController
+    */
+    resolveController: function(parsedName) {
+      this.useRouterNaming(parsedName);
+      return this.resolveOther(parsedName);
+    },
+    /**
+      Lookup the route using `resolveOther`
+
+      @protected
+      @param {Object} parsedName a parseName object with the parsed
+        fullName lookup string
+      @method resolveRoute
+    */
+    resolveRoute: function(parsedName) {
+      this.useRouterNaming(parsedName);
+      return this.resolveOther(parsedName);
+    },
 
     /**
-    @module ember
-    @submodule ember-htmlbars
+      Lookup the model on the Application namespace
+
+      @protected
+      @param {Object} parsedName a parseName object with the parsed
+        fullName lookup string
+      @method resolveModel
     */
+    resolveModel: function(parsedName) {
+      var className = string.classify(parsedName.name);
+      var factory = property_get.get(parsedName.root, className);
 
+      if (factory) { return factory; }
+    },
     /**
-      `unbound` allows you to output a property without binding. *Important:* The
-      output will not be updated if the property changes. Use with caution.
+      Look up the specified object (from parsedName) on the appropriate
+      namespace (usually on the Application)
 
-      ```handlebars
-      <div>{{unbound somePropertyThatDoesntChange}}</div>
-      ```
+      @protected
+      @param {Object} parsedName a parseName object with the parsed
+        fullName lookup string
+      @method resolveHelper
+    */
+    resolveHelper: function(parsedName) {
+      return this.resolveOther(parsedName) || helpers['default'][parsedName.fullNameWithoutType];
+    },
+    /**
+      Look up the specified object (from parsedName) on the appropriate
+      namespace (usually on the Application)
 
-      `unbound` can also be used in conjunction with a bound helper to
-      render it in its unbound form:
+      @protected
+      @param {Object} parsedName a parseName object with the parsed
+        fullName lookup string
+      @method resolveOther
+    */
+    resolveOther: function(parsedName) {
+      var className = string.classify(parsedName.name) + string.classify(parsedName.type);
+      var factory = property_get.get(parsedName.root, className);
+      if (factory) { return factory; }
+    },
 
-      ```handlebars
-      <div>{{unbound helperName somePropertyThatDoesntChange}}</div>
-      ```
+    resolveMain: function(parsedName) {
+      var className = string.classify(parsedName.type);
+      return property_get.get(parsedName.root, className);
+    },
 
-      @method unbound
-      @for Ember.Handlebars.helpers
-      @param {String} property
-      @return {String} HTML string
+    /**
+     @method _logLookup
+     @param {Boolean} found
+     @param {Object} parsedName
+     @private
     */
-    function unboundHelper(params, hash, options, env) {
-      var length = params.length;
-      var result;
+    _logLookup: function(found, parsedName) {
+      var symbol, padding;
 
-      options.helperName = options.helperName || 'unbound';
+      if (found) {
+        symbol = '[✓]';
+      } else {
+        symbol = '[ ]';
+      }
 
-      if (length === 1) {
-        result = read(params[0]);
-      } else if (length >= 2) {
-        env.data.isUnbound = true;
+      if (parsedName.fullName.length > 60) {
+        padding = '.';
+      } else {
+        padding = new Array(60 - parsedName.fullName.length).join('.');
+      }
 
-        var helperName = params[0]._label;
-        var args = [];
+      Logger['default'].info(symbol, parsedName.fullName, padding, this.lookupDescription(parsedName.fullName));
+    }
+  });
 
-        for (var i = 1, l = params.length; i < l; i++) {
-          var value = read(params[i]);
+  exports.Resolver = Resolver;
 
-          args.push(value);
-        }
+});
+enifed('ember-debug', ['exports', 'ember-metal/core', 'ember-metal/error', 'ember-metal/logger', 'ember-metal/environment'], function (exports, Ember, EmberError, Logger, environment) {
 
-        var helper = lookupHelper(helperName, this, env);
+  'use strict';
 
-        if (!helper) {
-          throw new EmberError('HTMLBars error: Could not find component or helper named ' + helperName + '.');
-        }
+  exports._warnIfUsingStrippedFeatureFlags = _warnIfUsingStrippedFeatureFlags;
 
-        result = helper.helperFunction.call(this, args, hash, options, env);
+  /*global __fail__*/
 
-        delete env.data.isUnbound;
-      }
+  Ember['default'].assert = function(desc, test) {
+    var throwAssertion;
 
-      return result;
+    if (Ember['default'].typeOf(test) === 'function') {
+      throwAssertion = !test();
+    } else {
+      throwAssertion = !test;
     }
 
-    __exports__.unboundHelper = unboundHelper;
-  });
-enifed("ember-htmlbars/helpers/view",
-  ["ember-metal/core","ember-runtime/system/object","ember-metal/property_get","ember-metal/streams/simple","ember-metal/keys","ember-metal/mixin","ember-metal/streams/utils","ember-views/streams/utils","ember-views/views/view","ember-metal/enumerable_utils","ember-views/streams/class_name_binding","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+    if (throwAssertion) {
+      throw new EmberError['default']("Assertion Failed: " + desc);
+    }
+  };
 
-    var Ember = __dependency1__["default"];
-    // Ember.warn, Ember.assert
-    var EmberObject = __dependency2__["default"];
-    var get = __dependency3__.get;
-    var SimpleStream = __dependency4__["default"];
-    var keys = __dependency5__["default"];
-    var IS_BINDING = __dependency6__.IS_BINDING;
-    var read = __dependency7__.read;
-    var isStream = __dependency7__.isStream;
-    var readViewFactory = __dependency8__.readViewFactory;
-    var View = __dependency9__["default"];
 
-    var map = __dependency10__.map;
-    var streamifyClassNameBinding = __dependency11__.streamifyClassNameBinding;
+  /**
+    Display a warning with the provided message. Ember build tools will
+    remove any calls to `Ember.warn()` when doing a production build.
 
-    function makeBindings(hash, options, view) {
-      for (var prop in hash) {
-        var value = hash[prop];
+    @method warn
+    @param {String} message A warning to display.
+    @param {Boolean} test An optional boolean. If falsy, the warning
+      will be displayed.
+  */
+  Ember['default'].warn = function(message, test) {
+    if (!test) {
+      Logger['default'].warn("WARNING: "+message);
+      if ('trace' in Logger['default']) {
+        Logger['default'].trace();
+      }
+    }
+  };
 
-        // Classes are processed separately
-        if (prop === 'class' && isStream(value)) {
-          hash.classBinding = value._label;
-          delete hash['class'];
-          continue;
-        }
+  /**
+    Display a debug notice. Ember build tools will remove any calls to
+    `Ember.debug()` when doing a production build.
 
-        if (prop === 'classBinding') {
-          continue;
-        }
+    ```javascript
+    Ember.debug('I\'m a debug notice!');
+    ```
 
-        if (IS_BINDING.test(prop)) {
-          if (isStream(value)) {
-            Ember.warn("You're attempting to render a view by passing " +
-                       prop + " " +
-                       "to a view helper without a quoted value, " +
-                       "but this syntax is ambiguous. You should either surround " +
-                       prop + "'s value in quotes or remove `Binding` " +
-                       "from " + prop + ".");
-          } else if (typeof value === 'string') {
-            hash[prop] = view._getBindingForStream(value);
-          }
-        } else {
-          if (isStream(value) && prop !== 'id') {
-            hash[prop + 'Binding'] = view._getBindingForStream(value);
-            delete hash[prop];
-          }
-        }
-      }
+    @method debug
+    @param {String} message A debug message to display.
+  */
+  Ember['default'].debug = function(message) {
+    Logger['default'].debug("DEBUG: "+message);
+  };
+
+  /**
+    Display a deprecation warning with the provided message and a stack trace
+    (Chrome and Firefox only). Ember build tools will remove any calls to
+    `Ember.deprecate()` when doing a production build.
+
+    @method deprecate
+    @param {String} message A description of the deprecation.
+    @param {Boolean} test An optional boolean. If falsy, the deprecation
+      will be displayed.
+    @param {Object} options An optional object that can be used to pass
+      in a `url` to the transition guide on the emberjs.com website.
+  */
+  Ember['default'].deprecate = function(message, test, options) {
+    var noDeprecation;
+
+    if (typeof test === 'function') {
+      noDeprecation = test();
+    } else {
+      noDeprecation = test;
     }
 
-    var ViewHelper = EmberObject.create({
-      propertiesFromHTMLOptions: function(hash, options, env) {
-        var view    = env.data.view;
-        var classes = read(hash['class']);
+    if (noDeprecation) { return; }
 
-        var extensions = {
-          helperName: options.helperName || ''
-        };
+    if (Ember['default'].ENV.RAISE_ON_DEPRECATION) { throw new EmberError['default'](message); }
 
-        if (hash.id) {
-          extensions.elementId = read(hash.id);
-        }
+    var error;
 
-        if (hash.tag) {
-          extensions.tagName = hash.tag;
-        }
+    // When using new Error, we can't do the arguments check for Chrome. Alternatives are welcome
+    try { __fail__.fail(); } catch (e) { error = e; }
 
-        if (classes) {
-          classes = classes.split(' ');
-          extensions.classNames = classes;
-        }
+    if (arguments.length === 3) {
+      Ember['default'].assert('options argument to Ember.deprecate should be an object', options && typeof options === 'object');
+      if (options.url) {
+        message += ' See ' + options.url + ' for more details.';
+      }
+    }
 
-        if (hash.classBinding) {
-          extensions.classNameBindings = hash.classBinding.split(' ');
-        }
+    if (Ember['default'].LOG_STACKTRACE_ON_DEPRECATION && error.stack) {
+      var stack;
+      var stackStr = '';
 
-        if (hash.classNameBindings) {
-          if (extensions.classNameBindings === undefined) {
-            extensions.classNameBindings = [];
-          }
-          extensions.classNameBindings = extensions.classNameBindings.concat(hash.classNameBindings.split(' '));
-        }
+      if (error['arguments']) {
+        // Chrome
+        stack = error.stack.replace(/^\s+at\s+/gm, '').
+                            replace(/^([^\(]+?)([\n$])/gm, '{anonymous}($1)$2').
+                            replace(/^Object.<anonymous>\s*\(([^\)]+)\)/gm, '{anonymous}($1)').split('\n');
+        stack.shift();
+      } else {
+        // Firefox
+        stack = error.stack.replace(/(?:\n@:0)?\s+$/m, '').
+                            replace(/^\(/gm, '{anonymous}(').split('\n');
+      }
 
-        if (hash.attributeBindings) {
-          Ember.assert("Setting 'attributeBindings' via template helpers is not allowed." +
-                       " Please subclass Ember.View and set it there instead.");
-          extensions.attributeBindings = null;
-        }
+      stackStr = "\n    " + stack.slice(2).join("\n    ");
+      message = message + stackStr;
+    }
 
-        // Set the proper context for all bindings passed to the helper. This applies to regular attribute bindings
-        // as well as class name bindings. If the bindings are local, make them relative to the current context
-        // instead of the view.
+    Logger['default'].warn("DEPRECATION: "+message);
+  };
 
-        var hashKeys = keys(hash);
 
-        for (var i = 0, l = hashKeys.length; i < l; i++) {
-          var prop = hashKeys[i];
 
-          if (prop !== 'classNameBindings') {
-            extensions[prop] = hash[prop];
-          }
-        }
+  /**
+    Alias an old, deprecated method with its new counterpart.
 
-        if (extensions.classNameBindings) {
-          extensions.classNameBindings = map(extensions.classNameBindings, function(classNameBinding){
-            var binding = streamifyClassNameBinding(view, classNameBinding);
-            if (isStream(binding)) {
-              return binding;
-            } else {
-              // returning a stream informs the classNameBindings logic
-              // in views/view that this value is already processed.
-              return new SimpleStream(binding);
-            }
-          });
-        }
+    Display a deprecation warning with the provided message and a stack trace
+    (Chrome and Firefox only) when the assigned method is called.
 
-        return extensions;
-      },
+    Ember build tools will not remove calls to `Ember.deprecateFunc()`, though
+    no warnings will be shown in production.
 
-      helper: function(newView, hash, options, env) {
-        var data = env.data;
-        var template = options.template;
-        var newViewProto;
+    ```javascript
+    Ember.oldMethod = Ember.deprecateFunc('Please use the new, updated method', Ember.newMethod);
+    ```
 
-        makeBindings(hash, options, env.data.view);
+    @method deprecateFunc
+    @param {String} message A description of the deprecation.
+    @param {Function} func The new function called to replace its deprecated counterpart.
+    @return {Function} a new function that wrapped the original function with a deprecation warning
+  */
+  Ember['default'].deprecateFunc = function(message, func) {
+    return function() {
+      Ember['default'].deprecate(message);
+      return func.apply(this, arguments);
+    };
+  };
 
-        var viewOptions = this.propertiesFromHTMLOptions(hash, options, env);
-        var currentView = data.view;
 
-        if (View.detectInstance(newView)) {
-          newViewProto = newView;
-        } else {
-          newViewProto = newView.proto();
-        }
+  /**
+    Run a function meant for debugging. Ember build tools will remove any calls to
+    `Ember.runInDebug()` when doing a production build.
 
-        if (template) {
-          Ember.assert(
-            "You cannot provide a template block if you also specified a templateName",
-            !get(viewOptions, 'templateName') && !get(newViewProto, 'templateName')
-          );
-          viewOptions.template = template;
+    ```javascript
+    Ember.runInDebug(function() {
+      Ember.Handlebars.EachView.reopen({
+        didInsertElement: function() {
+          console.log('I\'m happy');
         }
+      });
+    });
+    ```
 
-        // We only want to override the `_context` computed property if there is
-        // no specified controller. See View#_context for more information.
-        if (!newViewProto.controller && !newViewProto.controllerBinding && !viewOptions.controller && !viewOptions.controllerBinding) {
-          viewOptions._context = get(currentView, 'context'); // TODO: is this right?!
-        }
+    @method runInDebug
+    @param {Function} func The function to be executed.
+    @since 1.5.0
+  */
+  Ember['default'].runInDebug = function(func) {
+    func();
+  };
 
-        viewOptions._morph = options.morph;
+  /**
+    Will call `Ember.warn()` if ENABLE_ALL_FEATURES, ENABLE_OPTIONAL_FEATURES, or
+    any specific FEATURES flag is truthy.
 
-        currentView.appendChild(newView, viewOptions);
-      },
+    This method is called automatically in debug canary builds.
 
-      instanceHelper: function(newView, hash, options, env) {
-        var data = env.data;
-        var template = options.template;
+    @private
+    @method _warnIfUsingStrippedFeatureFlags
+    @return {void}
+  */
+  function _warnIfUsingStrippedFeatureFlags(FEATURES, featuresWereStripped) {
+    if (featuresWereStripped) {
+      Ember['default'].warn('Ember.ENV.ENABLE_ALL_FEATURES is only available in canary builds.', !Ember['default'].ENV.ENABLE_ALL_FEATURES);
+      Ember['default'].warn('Ember.ENV.ENABLE_OPTIONAL_FEATURES is only available in canary builds.', !Ember['default'].ENV.ENABLE_OPTIONAL_FEATURES);
 
-        makeBindings(hash, options, env.data.view);
+      for (var key in FEATURES) {
+        if (FEATURES.hasOwnProperty(key) && key !== 'isEnabled') {
+          Ember['default'].warn('FEATURE["' + key + '"] is set as enabled, but FEATURE flags are only available in canary builds.', !FEATURES[key]);
+        }
+      }
+    }
+  }
 
-        Ember.assert(
-          'Only a instance of a view may be passed to the ViewHelper.instanceHelper',
-          View.detectInstance(newView)
-        );
+  if (!Ember['default'].testing) {
+    // Complain if they're using FEATURE flags in builds other than canary
+    Ember['default'].FEATURES['features-stripped-test'] = true;
+    var featuresWereStripped = true;
 
-        var viewOptions = this.propertiesFromHTMLOptions(hash, options, env);
-        var currentView = data.view;
 
-        if (template) {
-          Ember.assert(
-            "You cannot provide a template block if you also specified a templateName",
-            !get(viewOptions, 'templateName') && !get(newView, 'templateName')
-          );
-          viewOptions.template = template;
-        }
+    delete Ember['default'].FEATURES['features-stripped-test'];
+    _warnIfUsingStrippedFeatureFlags(Ember['default'].ENV.FEATURES, featuresWereStripped);
 
-        // We only want to override the `_context` computed property if there is
-        // no specified controller. See View#_context for more information.
-        if (!newView.controller && !newView.controllerBinding &&
-            !viewOptions.controller && !viewOptions.controllerBinding) {
-          viewOptions._context = get(currentView, 'context'); // TODO: is this right?!
-        }
+    // Inform the developer about the Ember Inspector if not installed.
+    var isFirefox = typeof InstallTrigger !== 'undefined';
+    var isChrome = environment['default'].isChrome;
 
-        viewOptions._morph = options.morph;
+    if (typeof window !== 'undefined' && (isFirefox || isChrome) && window.addEventListener) {
+      window.addEventListener("load", function() {
+        if (document.documentElement && document.documentElement.dataset && !document.documentElement.dataset.emberExtension) {
+          var downloadURL;
 
-        currentView.appendChild(newView, viewOptions);
-      }
-    });
-    __exports__.ViewHelper = ViewHelper;
-    /**
-      `{{view}}` inserts a new instance of an `Ember.View` into a template passing its
-      options to the `Ember.View`'s `create` method and using the supplied block as
-      the view's own template.
+          if (isChrome) {
+            downloadURL = 'https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi';
+          } else if (isFirefox) {
+            downloadURL = 'https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/';
+          }
 
-      An empty `<body>` and the following template:
+          Ember['default'].debug('For more advanced debugging, install the Ember Inspector from ' + downloadURL);
+        }
+      }, false);
+    }
+  }
 
-      ```handlebars
-      A span:
-      {{#view tagName="span"}}
-        hello.
-      {{/view}}
-      ```
+  /*
+    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 = false;
+  if (runningNonEmberDebugJS) {
+    Ember['default'].warn('Please use `ember.debug.js` instead of `ember.js` for development and debugging.');
+  }
 
-      Will result in HTML structure:
+  exports.runningNonEmberDebugJS = runningNonEmberDebugJS;
 
-      ```html
-      <body>
-        <!-- Note: the handlebars template script
-             also results in a rendered Ember.View
-             which is the outer <div> here -->
+});
+enifed('ember-extension-support', ['ember-metal/core', 'ember-extension-support/data_adapter', 'ember-extension-support/container_debug_adapter'], function (Ember, DataAdapter, ContainerDebugAdapter) {
 
-        <div class="ember-view">
-          A span:
-          <span id="ember1" class="ember-view">
-            Hello.
-          </span>
-        </div>
-      </body>
-      ```
+	'use strict';
 
-      ### `parentView` setting
+	/**
+	Ember Extension Support
 
-      The `parentView` property of the new `Ember.View` instance created through
-      `{{view}}` will be set to the `Ember.View` instance of the template where
-      `{{view}}` was called.
+	@module ember
+	@submodule ember-extension-support
+	@requires ember-application
+	*/
 
-      ```javascript
-      aView = Ember.View.create({
-        template: Ember.Handlebars.compile("{{#view}} my parent: {{parentView.elementId}} {{/view}}")
-      });
+	Ember['default'].DataAdapter = DataAdapter['default'];
+	Ember['default'].ContainerDebugAdapter = ContainerDebugAdapter['default'];
 
-      aView.appendTo('body');
-      ```
+});
+enifed('ember-extension-support/container_debug_adapter', ['exports', 'ember-metal/core', 'ember-runtime/system/native_array', 'ember-metal/utils', 'ember-runtime/system/string', 'ember-runtime/system/namespace', 'ember-runtime/system/object'], function (exports, Ember, native_array, utils, string, Namespace, EmberObject) {
 
-      Will result in HTML structure:
+  'use strict';
 
-      ```html
-      <div id="ember1" class="ember-view">
-        <div id="ember2" class="ember-view">
-          my parent: ember1
-        </div>
-      </div>
-      ```
+  exports['default'] = EmberObject['default'].extend({
+    /**
+      The container of the application being debugged.
+      This property will be injected
+      on creation.
 
-      ### Setting CSS id and class attributes
+      @property container
+      @default null
+    */
+    container: null,
 
-      The HTML `id` attribute can be set on the `{{view}}`'s resulting element with
-      the `id` option. This option will _not_ be passed to `Ember.View.create`.
+    /**
+      The resolver instance of the application
+      being debugged. This property will be injected
+      on creation.
 
-      ```handlebars
-      {{#view tagName="span" id="a-custom-id"}}
-        hello.
-      {{/view}}
-      ```
+      @property resolver
+      @default null
+    */
+    resolver: null,
 
-      Results in the following HTML structure:
+    /**
+      Returns true if it is possible to catalog a list of available
+      classes in the resolver for a given type.
 
-      ```html
-      <div class="ember-view">
-        <span id="a-custom-id" class="ember-view">
-          hello.
-        </span>
-      </div>
-      ```
+      @method canCatalogEntriesByType
+      @param {String} type The type. e.g. "model", "controller", "route"
+      @return {boolean} whether a list is available for this type.
+    */
+    canCatalogEntriesByType: function(type) {
+      if (type === 'model' || type === 'template') {
+        return false;
+      }
 
-      The HTML `class` attribute can be set on the `{{view}}`'s resulting element
-      with the `class` or `classNameBindings` options. The `class` option will
-      directly set the CSS `class` attribute and will not be passed to
-      `Ember.View.create`. `classNameBindings` will be passed to `create` and use
-      `Ember.View`'s class name binding functionality:
+      return true;
+    },
 
-      ```handlebars
-      {{#view tagName="span" class="a-custom-class"}}
-        hello.
-      {{/view}}
-      ```
+    /**
+      Returns the available classes a given type.
 
-      Results in the following HTML structure:
+      @method catalogEntriesByType
+      @param {String} type The type. e.g. "model", "controller", "route"
+      @return {Array} An array of strings.
+    */
+    catalogEntriesByType: function(type) {
+      var namespaces = native_array.A(Namespace['default'].NAMESPACES);
+      var types = native_array.A();
+      var typeSuffixRegex = new RegExp(string.classify(type) + "$");
 
-      ```html
-      <div class="ember-view">
-        <span id="ember2" class="ember-view a-custom-class">
-          hello.
-        </span>
-      </div>
-      ```
+      namespaces.forEach(function(namespace) {
+        if (namespace !== Ember['default']) {
+          for (var key in namespace) {
+            if (!namespace.hasOwnProperty(key)) { continue; }
+            if (typeSuffixRegex.test(key)) {
+              var klass = namespace[key];
+              if (utils.typeOf(klass) === 'class') {
+                types.push(string.dasherize(key.replace(typeSuffixRegex, '')));
+              }
+            }
+          }
+        }
+      });
+      return types;
+    }
+  });
 
-      ### Supplying a different view class
+});
+enifed('ember-extension-support/data_adapter', ['exports', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-runtime/system/string', 'ember-runtime/system/namespace', 'ember-runtime/system/object', 'ember-runtime/system/native_array', 'ember-application/system/application'], function (exports, property_get, run, string, Namespace, EmberObject, native_array, Application) {
 
-      `{{view}}` can take an optional first argument before its supplied options to
-      specify a path to a custom view class.
+  'use strict';
 
-      ```handlebars
-      {{#view "custom"}}{{! will look up App.CustomView }}
-        hello.
-      {{/view}}
-      ```
+  exports['default'] = EmberObject['default'].extend({
+    init: function() {
+      this._super.apply(this, arguments);
+      this.releaseMethods = native_array.A();
+    },
 
-      The first argument can also be a relative path accessible from the current
-      context.
+    /**
+      The container of the application being debugged.
+      This property will be injected
+      on creation.
 
-      ```javascript
-      MyApp = Ember.Application.create({});
-      MyApp.OuterView = Ember.View.extend({
-        innerViewClass: Ember.View.extend({
-          classNames: ['a-custom-view-class-as-property']
-        }),
-        template: Ember.Handlebars.compile('{{#view view.innerViewClass}} hi {{/view}}')
-      });
+      @property container
+      @default null
+      @since 1.3.0
+    */
+    container: null,
 
-      MyApp.OuterView.create().appendTo('body');
-      ```
 
-      Will result in the following HTML:
+    /**
+      The container-debug-adapter which is used
+      to list all models.
 
-      ```html
-      <div id="ember1" class="ember-view">
-        <div id="ember2" class="ember-view a-custom-view-class-as-property">
-          hi
-        </div>
-      </div>
-      ```
+      @property containerDebugAdapter
+      @default undefined
+      @since 1.5.0
+    **/
+    containerDebugAdapter: undefined,
 
-      ### Blockless use
+    /**
+      Number of attributes to send
+      as columns. (Enough to make the record
+      identifiable).
 
-      If you supply a custom `Ember.View` subclass that specifies its own template
-      or provide a `templateName` option to `{{view}}` it can be used without
-      supplying a block. Attempts to use both a `templateName` option and supply a
-      block will throw an error.
+      @private
+      @property attributeLimit
+      @default 3
+      @since 1.3.0
+    */
+    attributeLimit: 3,
 
-      ```javascript
-      var App = Ember.Application.create();
-      App.WithTemplateDefinedView = Ember.View.extend({
-        templateName: 'defined-template'
-      });
-      ```
+    /**
+      Stores all methods that clear observers.
+      These methods will be called on destruction.
 
-      ```handlebars
-      {{! application.hbs }}
-      {{view 'with-template-defined'}}
-      ```
+      @private
+      @property releaseMethods
+      @since 1.3.0
+    */
+    releaseMethods: native_array.A(),
 
-      ```handlebars
-      {{! defined-template.hbs }}
-      Some content for the defined template view.
-      ```
+    /**
+      Specifies how records can be filtered.
+      Records returned will need to have a `filterValues`
+      property with a key for every name in the returned array.
 
-      ### `viewName` property
+      @public
+      @method getFilters
+      @return {Array} List of objects defining filters.
+       The object should have a `name` and `desc` property.
+    */
+    getFilters: function() {
+      return native_array.A();
+    },
 
-      You can supply a `viewName` option to `{{view}}`. The `Ember.View` instance
-      will be referenced as a property of its parent view by this name.
+    /**
+      Fetch the model types and observe them for changes.
 
-      ```javascript
-      aView = Ember.View.create({
-        template: Ember.Handlebars.compile('{{#view viewName="aChildByName"}} hi {{/view}}')
-      });
+      @public
+      @method watchModelTypes
 
-      aView.appendTo('body');
-      aView.get('aChildByName') // the instance of Ember.View created by {{view}} helper
-      ```
+      @param {Function} typesAdded Callback to call to add types.
+      Takes an array of objects containing wrapped types (returned from `wrapModelType`).
 
-      @method view
-      @for Ember.Handlebars.helpers
-      @param {String} path
-      @param {Hash} options
-      @return {String} HTML string
+      @param {Function} typesUpdated Callback to call when a type has changed.
+      Takes an array of objects containing wrapped types.
+
+      @return {Function} Method to call to remove all observers
     */
-    function viewHelper(params, hash, options, env) {
-      Ember.assert("The view helper only takes a single argument", params.length <= 2);
+    watchModelTypes: function(typesAdded, typesUpdated) {
+      var modelTypes = this.getModelTypes();
+      var self = this;
+      var releaseMethods = native_array.A();
+      var typesToSend;
 
-      var container = this.container || read(this._keywords.view).container;
-      var viewClass;
+      typesToSend = modelTypes.map(function(type) {
+        var klass = type.klass;
+        var wrapped = self.wrapModelType(klass, type.name);
+        releaseMethods.push(self.observeModelType(klass, typesUpdated));
+        return wrapped;
+      });
 
-      if (params.length === 0) {
-        if (container) {
-          viewClass = container.lookupFactory('view:toplevel');
-        } else {
-          viewClass = View;
-        }
-      } else {
-        var pathStream = params[0];
-        viewClass = readViewFactory(pathStream, container);
-      }
+      typesAdded(typesToSend);
 
-      options.helperName = options.helperName || 'view';
+      var release = function() {
+        releaseMethods.forEach(function(fn) { fn(); });
+        self.releaseMethods.removeObject(release);
+      };
+      this.releaseMethods.pushObject(release);
+      return release;
+    },
 
-      return ViewHelper.helper(viewClass, hash, options, env);
-    }
+    _nameToClass: function(type) {
+      if (typeof type === 'string') {
+        type = this.container.lookupFactory('model:' + type);
+      }
+      return type;
+    },
 
-    __exports__.viewHelper = viewHelper;
-  });
-enifed("ember-htmlbars/helpers/with",
-  ["ember-metal/core","ember-metal/is_none","ember-htmlbars/helpers/binding","ember-views/views/with_view","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+      Fetch the records of a given type and observe them for changes.
 
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var isNone = __dependency2__["default"];
-    var bind = __dependency3__.bind;
-    var WithView = __dependency4__["default"];
+      @public
+      @method watchRecords
 
-    /**
-      Use the `{{with}}` helper when you want to aliases the to a new name. It's helpful
-      for semantic clarity and to retain default scope or to reference from another
-      `{{with}}` block.
+      @param {Function} recordsAdded Callback to call to add records.
+      Takes an array of objects containing wrapped records.
+      The object should have the following properties:
+        columnValues: {Object} key and value of a table cell
+        object: {Object} the actual record object
 
-      ```handlebars
-      // posts might not be
-      {{#with user.posts as blogPosts}}
-        <div class="notice">
-          There are {{blogPosts.length}} blog posts written by {{user.name}}.
-        </div>
+      @param {Function} recordsUpdated Callback to call when a record has changed.
+      Takes an array of objects containing wrapped records.
 
-        {{#each post in blogPosts}}
-          <li>{{post.title}}</li>
-        {{/each}}
-      {{/with}}
-      ```
+      @param {Function} recordsRemoved Callback to call when a record has removed.
+      Takes the following parameters:
+        index: the array index where the records were removed
+        count: the number of records removed
 
-      Without the `as` operator, it would be impossible to reference `user.name` in the example above.
+      @return {Function} Method to call to remove all observers
+    */
+    watchRecords: function(type, recordsAdded, recordsUpdated, recordsRemoved) {
+      var self = this;
+      var releaseMethods = native_array.A();
+      var records = this.getRecords(type);
+      var release;
 
-      NOTE: The alias should not reuse a name from the bound property path.
-      For example: `{{#with foo.bar as foo}}` is not supported because it attempts to alias using
-      the first part of the property path, `foo`. Instead, use `{{#with foo.bar as baz}}`.
+      var recordUpdated = function(updatedRecord) {
+        recordsUpdated([updatedRecord]);
+      };
 
-      ### `controller` option
+      var recordsToSend = records.map(function(record) {
+        releaseMethods.push(self.observeRecord(record, recordUpdated));
+        return self.wrapRecord(record);
+      });
 
-      Adding `controller='something'` instructs the `{{with}}` helper to create and use an instance of
-      the specified controller wrapping the aliased keyword.
 
-      This is very similar to using an `itemController` option with the `{{each}}` helper.
+      var contentDidChange = function(array, idx, removedCount, addedCount) {
+        for (var i = idx; i < idx + addedCount; i++) {
+          var record = array.objectAt(i);
+          var wrapped = self.wrapRecord(record);
+          releaseMethods.push(self.observeRecord(record, recordUpdated));
+          recordsAdded([wrapped]);
+        }
 
-      ```handlebars
-      {{#with users.posts as posts controller='userBlogPosts'}}
-        {{!- `posts` is wrapped in our controller instance }}
-      {{/with}}
-      ```
-
-      In the above example, the `posts` keyword is now wrapped in the `userBlogPost` controller,
-      which provides an elegant way to decorate the context with custom
-      functions/properties.
-
-      @method with
-      @for Ember.Handlebars.helpers
-      @param {Function} context
-      @param {Hash} options
-      @return {String} HTML string
-    */
-    function withHelper(params, hash, options, env) {
-      Ember.assert(
-        "{{#with foo}} must be called with a single argument or the use the " +
-        "{{#with foo as bar}} syntax",
-        params.length === 1
-      );
+        if (removedCount) {
+          recordsRemoved(idx, removedCount);
+        }
+      };
 
-      Ember.assert(
-        "The {{#with}} helper must be called with a block",
-        !!options.template
-      );
+      var observer = { didChange: contentDidChange, willChange: function() { return this; } };
+      records.addArrayObserver(self, observer);
 
-      var preserveContext;
+      release = function() {
+        releaseMethods.forEach(function(fn) { fn(); });
+        records.removeArrayObserver(self, observer);
+        self.releaseMethods.removeObject(release);
+      };
 
-      if (options.template.blockParams) {
-        preserveContext = true;
-      } else {
-        Ember.deprecate(
-          "Using the context switching form of `{{with}}` is deprecated. " +
-          "Please use the keyword form (`{{with foo as bar}}`) instead.",
-          false,
-          { url: 'http://emberjs.com/guides/deprecations/#toc_more-consistent-handlebars-scope' }
-        );
-        preserveContext = false;
-      }
+      recordsAdded(recordsToSend);
 
-      bind.call(this, params[0], hash, options, env, preserveContext, exists, undefined, undefined, WithView);
-    }
+      this.releaseMethods.pushObject(release);
+      return release;
+    },
 
-    __exports__.withHelper = withHelper;function exists(value) {
-      return !isNone(value);
-    }
-  });
-enifed("ember-htmlbars/helpers/yield",
-  ["ember-metal/core","ember-metal/property_get","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-htmlbars
+      Clear all observers before destruction
+      @private
+      @method willDestroy
     */
+    willDestroy: function() {
+      this._super.apply(this, arguments);
+      this.releaseMethods.forEach(function(fn) {
+        fn();
+      });
+    },
 
-    var Ember = __dependency1__["default"];
+    /**
+      Detect whether a class is a model.
+
+      Test that against the model class
+      of your persistence library
 
-    var get = __dependency2__.get;
+      @private
+      @method detect
+      @param {Class} klass The class to test
+      @return boolean Whether the class is a model class or not
+    */
+    detect: function(klass) {
+      return false;
+    },
 
     /**
-      `{{yield}}` denotes an area of a template that will be rendered inside
-      of another template. It has two main uses:
+      Get the columns for a given model type.
 
-      ### Use with `layout`
-      When used in a Handlebars template that is assigned to an `Ember.View`
-      instance's `layout` property Ember will render the layout template first,
-      inserting the view's own rendered output at the `{{yield}}` location.
+      @private
+      @method columnsForType
+      @param {Class} type The model type
+      @return {Array} An array of columns of the following format:
+       name: {String} name of the column
+       desc: {String} Humanized description (what would show in a table column name)
+    */
+    columnsForType: function(type) {
+      return native_array.A();
+    },
 
-      An empty `<body>` and the following application code:
+    /**
+      Adds observers to a model type class.
 
-      ```javascript
-      AView = Ember.View.extend({
-        classNames: ['a-view-with-layout'],
-        layout: Ember.Handlebars.compile('<div class="wrapper">{{yield}}</div>'),
-        template: Ember.Handlebars.compile('<span>I am wrapped</span>')
-      });
+      @private
+      @method observeModelType
+      @param {Class} type The model type class
+      @param {Function} typesUpdated Called when a type is modified.
+      @return {Function} The function to call to remove observers
+    */
 
-      aView = AView.create();
-      aView.appendTo('body');
-      ```
+    observeModelType: function(type, typesUpdated) {
+      var self = this;
+      var records = this.getRecords(type);
 
-      Will result in the following HTML output:
+      var onChange = function() {
+        typesUpdated([self.wrapModelType(type)]);
+      };
+      var observer = {
+        didChange: function() {
+          run['default'].scheduleOnce('actions', this, onChange);
+        },
+        willChange: function() { return this; }
+      };
 
-      ```html
-      <body>
-        <div class='ember-view a-view-with-layout'>
-          <div class="wrapper">
-            <span>I am wrapped</span>
-          </div>
-        </div>
-      </body>
-      ```
+      records.addArrayObserver(this, observer);
 
-      The `yield` helper cannot be used outside of a template assigned to an
-      `Ember.View`'s `layout` property and will throw an error if attempted.
+      var release = function() {
+        records.removeArrayObserver(self, observer);
+      };
 
-      ```javascript
-      BView = Ember.View.extend({
-        classNames: ['a-view-with-layout'],
-        template: Ember.Handlebars.compile('{{yield}}')
-      });
+      return release;
+    },
 
-      bView = BView.create();
-      bView.appendTo('body');
 
-      // throws
-      // Uncaught Error: assertion failed:
-      // You called yield in a template that was not a layout
-      ```
+    /**
+      Wraps a given model type and observes changes to it.
 
-      ### Use with Ember.Component
-      When designing components `{{yield}}` is used to denote where, inside the component's
-      template, an optional block passed to the component should render:
+      @private
+      @method wrapModelType
+      @param {Class} type A model class
+      @param {String}  Optional name of the class
+      @return {Object} contains the wrapped type and the function to remove observers
+      Format:
+        type: {Object} the wrapped type
+          The wrapped type has the following format:
+            name: {String} name of the type
+            count: {Integer} number of records available
+            columns: {Columns} array of columns to describe the record
+            object: {Class} the actual Model type class
+        release: {Function} The function to remove observers
+    */
+    wrapModelType: function(type, name) {
+      var records = this.getRecords(type);
+      var typeToSend;
+
+      typeToSend = {
+        name: name || type.toString(),
+        count: property_get.get(records, 'length'),
+        columns: this.columnsForType(type),
+        object: type
+      };
 
-      ```handlebars
-      <!-- application.hbs -->
-      {{#labeled-textfield value=someProperty}}
-        First name:
-      {{/labeled-textfield}}
-      ```
 
-      ```handlebars
-      <!-- components/labeled-textfield.hbs -->
-      <label>
-        {{yield}} {{input value=value}}
-      </label>
-      ```
+      return typeToSend;
+    },
 
-      Result:
 
-      ```html
-      <label>
-        First name: <input type="text" />
-      </label>
-      ```
+    /**
+      Fetches all models defined in the application.
 
-      @method yield
-      @for Ember.Handlebars.helpers
-      @param {Hash} options
-      @return {String} HTML string
+      @private
+      @method getModelTypes
+      @return {Array} Array of model types
     */
-    function yieldHelper(params, hash, options, env) {
-      var view = this;
+    getModelTypes: function() {
+      var self = this;
+      var containerDebugAdapter = this.get('containerDebugAdapter');
+      var types;
 
-      // Yea gods
-      while (view && !get(view, 'layout')) {
-        if (view._contextView) {
-          view = view._contextView;
-        } else {
-          view = get(view, '_parentView');
-        }
+      if (containerDebugAdapter.canCatalogEntriesByType('model')) {
+        types = containerDebugAdapter.catalogEntriesByType('model');
+      } else {
+        types = this._getObjectsOnNamespaces();
       }
 
-      Ember.assert("You called yield in a template that was not a layout", !!view);
+      // New adapters return strings instead of classes
+      types = native_array.A(types).map(function(name) {
+        return {
+          klass: self._nameToClass(name),
+          name: name
+        };
+      });
+      types = native_array.A(types).filter(function(type) {
+        return self.detect(type.klass);
+      });
 
-      return view._yield(null, env, options.morph, params);
-    }
+      return native_array.A(types);
+    },
 
-    __exports__.yieldHelper = yieldHelper;
-  });
-enifed("ember-htmlbars/hooks/attribute",
-  ["ember-views/attr_nodes/attr_node","ember-metal/error","ember-metal/streams/utils","ember-views/system/sanitize_attribute_value","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-htmlbars
-    */
-
-    var AttrNode = __dependency1__["default"];
-    var EmberError = __dependency2__["default"];
-    var isStream = __dependency3__.isStream;
-    var sanitizeAttributeValue = __dependency4__["default"];
+      Loops over all namespaces and all objects
+      attached to them
 
-    var boundAttributesEnabled = false;
+      @private
+      @method _getObjectsOnNamespaces
+      @return {Array} Array of model type strings
+    */
+    _getObjectsOnNamespaces: function() {
+      var namespaces = native_array.A(Namespace['default'].NAMESPACES);
+      var types = native_array.A();
+      var self = this;
 
-    
-    __exports__["default"] = function attribute(env, morph, element, attrName, attrValue) {
-      if (boundAttributesEnabled) {
-        var attrNode = new AttrNode(attrName, attrValue);
-        attrNode._morph = morph;
-        env.data.view.appendChild(attrNode);
-      } else {
-        if (isStream(attrValue)) {
-          throw new EmberError('Bound attributes are not yet supported in Ember.js');
-        } else {
-          var sanitizedValue = sanitizeAttributeValue(element, attrName, attrValue);
-          env.dom.setProperty(element, attrName, sanitizedValue);
+      namespaces.forEach(function(namespace) {
+        for (var key in namespace) {
+          if (!namespace.hasOwnProperty(key)) { continue; }
+          // Even though we will filter again in `getModelTypes`,
+          // we should not call `lookupContainer` on non-models
+          // (especially when `Ember.MODEL_FACTORY_INJECTIONS` is `true`)
+          if (!self.detect(namespace[key])) { continue; }
+          var name = string.dasherize(key);
+          if (!(namespace instanceof Application['default']) && namespace.toString()) {
+            name = namespace + '/' + name;
+          }
+          types.push(name);
         }
-      }
-    }
-  });
-enifed("ember-htmlbars/hooks/block",
-  ["ember-views/views/simple_bound_view","ember-metal/streams/utils","ember-htmlbars/system/lookup-helper","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
+      });
+      return types;
+    },
+
     /**
-    @module ember
-    @submodule ember-htmlbars
+      Fetches all loaded records for a given type.
+
+      @private
+      @method getRecords
+      @return {Array} An array of records.
+       This array will be observed for changes,
+       so it should update when new records are added/removed.
     */
+    getRecords: function(type) {
+      return native_array.A();
+    },
 
-    var appendSimpleBoundView = __dependency1__.appendSimpleBoundView;
-    var isStream = __dependency2__.isStream;
-    var lookupHelper = __dependency3__["default"];
+    /**
+      Wraps a record and observers changes to it.
 
-    __exports__["default"] = function block(env, morph, view, path, params, hash, template, inverse) {
-      var helper = lookupHelper(path, view, env);
+      @private
+      @method wrapRecord
+      @param {Object} record The record instance.
+      @return {Object} The wrapped record. Format:
+      columnValues: {Array}
+      searchKeywords: {Array}
+    */
+    wrapRecord: function(record) {
+      var recordToSend = { object: record };
 
-      Ember.assert("A helper named `"+path+"` could not be found", helper);
+      recordToSend.columnValues = this.getRecordColumnValues(record);
+      recordToSend.searchKeywords = this.getRecordKeywords(record);
+      recordToSend.filterValues = this.getRecordFilterValues(record);
+      recordToSend.color = this.getRecordColor(record);
 
-      var options = {
-        morph: morph,
-        template: template,
-        inverse: inverse,
-        isBlock: true
-      };
-      var result = helper.helperFunction.call(view, params, hash, options, env);
+      return recordToSend;
+    },
 
-      if (isStream(result)) {
-        appendSimpleBoundView(view, morph, result);
-      } else {
-        morph.setContent(result);
-      }
-    }
-  });
-enifed("ember-htmlbars/hooks/component",
-  ["ember-metal/core","ember-htmlbars/system/lookup-helper","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+      Gets the values for each column.
 
-    var Ember = __dependency1__["default"];
-    var lookupHelper = __dependency2__["default"];
+      @private
+      @method getRecordColumnValues
+      @return {Object} Keys should match column names defined
+      by the model type.
+    */
+    getRecordColumnValues: function(record) {
+      return {};
+    },
 
-    __exports__["default"] = function component(env, morph, view, tagName, attrs, template) {
-      var helper = lookupHelper(tagName, view, env);
+    /**
+      Returns keywords to match when searching records.
 
-      Ember.assert('You specified `' + tagName + '` in your template, but a component for `' + tagName + '` could not be found.', !!helper);
+      @private
+      @method getRecordKeywords
+      @return {Array} Relevant keywords for search.
+    */
+    getRecordKeywords: function(record) {
+      return native_array.A();
+    },
 
-      return helper.helperFunction.call(view, [], attrs, {morph: morph, template: template}, env);
-    }
-  });
-enifed("ember-htmlbars/hooks/concat",
-  ["ember-metal/streams/utils","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+      Returns the values of filters defined by `getFilters`.
 
-    var streamConcat = __dependency1__.concat;
+      @private
+      @method getRecordFilterValues
+      @param {Object} record The record instance
+      @return {Object} The filter values
+    */
+    getRecordFilterValues: function(record) {
+      return {};
+    },
 
-    __exports__["default"] = function concat(env, parts) {
-      return streamConcat(parts, '');
-    }
-  });
-enifed("ember-htmlbars/hooks/content",
-  ["ember-views/views/simple_bound_view","ember-metal/streams/utils","ember-htmlbars/system/lookup-helper","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-htmlbars
+      Each record can have a color that represents its state.
+
+      @private
+      @method getRecordColor
+      @param {Object} record The record instance
+      @return {String} The record's color
+        Possible options: black, red, blue, green
     */
+    getRecordColor: function(record) {
+      return null;
+    },
 
-    var appendSimpleBoundView = __dependency1__.appendSimpleBoundView;
-    var isStream = __dependency2__.isStream;
-    var lookupHelper = __dependency3__["default"];
+    /**
+      Observes all relevant properties and re-sends the wrapped record
+      when a change occurs.
 
-    __exports__["default"] = function content(env, morph, view, path) {
-      var helper = lookupHelper(path, view, env);
-      var result;
+      @private
+      @method observerRecord
+      @param {Object} record The record instance
+      @param {Function} recordUpdated The callback to call when a record is updated.
+      @return {Function} The function to call to remove all observers.
+    */
+    observeRecord: function(record, recordUpdated) {
+      return function() {};
+    }
+  });
+
+});
+enifed('ember-htmlbars', ['ember-metal/core', 'ember-template-compiler', 'ember-htmlbars/system/make-view-helper', 'ember-htmlbars/system/make_bound_helper', 'ember-htmlbars/helpers', 'ember-htmlbars/helpers/view', 'ember-htmlbars/helpers/component', 'ember-htmlbars/helpers/yield', 'ember-htmlbars/helpers/with', 'ember-htmlbars/helpers/log', 'ember-htmlbars/helpers/debugger', 'ember-htmlbars/helpers/bind-attr', 'ember-htmlbars/helpers/if_unless', 'ember-htmlbars/helpers/loc', 'ember-htmlbars/helpers/partial', 'ember-htmlbars/helpers/template', 'ember-htmlbars/helpers/input', 'ember-htmlbars/helpers/text_area', 'ember-htmlbars/helpers/collection', 'ember-htmlbars/helpers/each', 'ember-htmlbars/helpers/unbound', 'ember-htmlbars/system/bootstrap', 'ember-htmlbars/compat'], function (Ember, ember_template_compiler, makeViewHelper, makeBoundHelper, helpers, view, component, _yield, _with, log, _debugger, bind_attr, if_unless, loc, partial, template, input, text_area, collection, each, unbound) {
+
+  'use strict';
+
+  helpers.registerHelper('view', view.viewHelper);
+
+    helpers.registerHelper('component', component.componentHelper);
+
+  helpers.registerHelper('yield', _yield.yieldHelper);
+  helpers.registerHelper('with', _with.withHelper);
+  helpers.registerHelper('if', if_unless.ifHelper);
+  helpers.registerHelper('unless', if_unless.unlessHelper);
+  helpers.registerHelper('log', log.logHelper);
+  helpers.registerHelper('debugger', _debugger.debuggerHelper);
+  helpers.registerHelper('loc', loc.locHelper);
+  helpers.registerHelper('partial', partial.partialHelper);
+  helpers.registerHelper('template', template.templateHelper);
+  helpers.registerHelper('bind-attr', bind_attr.bindAttrHelper);
+  helpers.registerHelper('bindAttr', bind_attr.bindAttrHelperDeprecated);
+  helpers.registerHelper('input', input.inputHelper);
+  helpers.registerHelper('textarea', text_area.textareaHelper);
+  helpers.registerHelper('collection', collection.collectionHelper);
+  helpers.registerHelper('each', each.eachHelper);
+  helpers.registerHelper('unbound', unbound.unboundHelper);
+
+  Ember['default'].HTMLBars = {
+    _registerHelper: helpers.registerHelper,
+    template: ember_template_compiler.template,
+    compile: ember_template_compiler.compile,
+    precompile: ember_template_compiler.precompile,
+    makeViewHelper: makeViewHelper['default'],
+    makeBoundHelper: makeBoundHelper['default'],
+    registerPlugin: ember_template_compiler.registerPlugin
+  };
+
+});
+enifed('ember-htmlbars/compat', ['exports', 'ember-metal/core', 'ember-htmlbars/helpers', 'ember-htmlbars/compat/helper', 'ember-htmlbars/compat/handlebars-get', 'ember-htmlbars/compat/make-bound-helper', 'ember-htmlbars/compat/register-bound-helper', 'ember-htmlbars/system/make-view-helper', 'ember-htmlbars/utils/string'], function (exports, Ember, helpers, helper, compatHandlebarsGet, compatMakeBoundHelper, compatRegisterBoundHelper, makeViewHelper, string) {
+
+  'use strict';
+
+  var EmberHandlebars = Ember['default'].Handlebars = Ember['default'].Handlebars || {};
+  EmberHandlebars.helpers = helpers['default'];
+  EmberHandlebars.helper = helper.handlebarsHelper;
+  EmberHandlebars.registerHelper = helper.registerHandlebarsCompatibleHelper;
+  EmberHandlebars.registerBoundHelper = compatRegisterBoundHelper['default'];
+  EmberHandlebars.makeBoundHelper = compatMakeBoundHelper['default'];
+  EmberHandlebars.get = compatHandlebarsGet['default'];
+  EmberHandlebars.makeViewHelper = makeViewHelper['default'];
+
+  EmberHandlebars.SafeString = string.SafeString;
+  EmberHandlebars.Utils =  {
+    escapeExpression: string.escapeExpression
+  };
+
+  exports['default'] = EmberHandlebars;
+
+});
+enifed('ember-htmlbars/compat/handlebars-get', ['exports'], function (exports) {
+
+  'use strict';
+
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+
+  /**
+    Lookup both on root and on window. If the path starts with
+    a keyword, the corresponding object will be looked up in the
+    template's data hash and used to resolve the path.
+
+    @method get
+    @for Ember.Handlebars
+    @param {Object} root The object to look up the property on
+    @param {String} path The path to be lookedup
+    @param {Object} options The template's option hash
+    @deprecated
+  */
+  function handlebarsGet(root, path, options) {
+    Ember.deprecate('Usage of Ember.Handlebars.get is deprecated, use a Component or Ember.Handlebars.makeBoundHelper instead.');
+
+    return options.data.view.getStream(path).value();
+  }
+  exports['default'] = handlebarsGet;
 
-      if (helper) {
-        var options = {
-          morph: morph,
-          isInline: true
-        };
-        result = helper.helperFunction.call(view, [], {}, options, env);
-      } else {
-        result = view.getStream(path);
-      }
+});
+enifed('ember-htmlbars/compat/helper', ['exports', 'ember-metal/merge', 'ember-htmlbars/helpers', 'ember-views/views/view', 'ember-views/views/component', 'ember-htmlbars/system/make-view-helper', 'ember-htmlbars/compat/make-bound-helper', 'ember-metal/streams/utils'], function (exports, merge, helpers, View, Component, makeViewHelper, makeBoundHelper, utils) {
 
-      if (isStream(result)) {
-        appendSimpleBoundView(view, morph, result);
-      } else {
-        morph.setContent(result);
-      }
+  'use strict';
+
+  exports.registerHandlebarsCompatibleHelper = registerHandlebarsCompatibleHelper;
+  exports.handlebarsHelper = handlebarsHelper;
+
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+
+  var slice = [].slice;
+
+  function calculateCompatType(item) {
+    if (utils.isStream(item)) {
+      return 'ID';
+    } else {
+      var itemType = typeof item;
+
+      return itemType.toUpperCase();
     }
-  });
-enifed("ember-htmlbars/hooks/element",
-  ["ember-metal/core","ember-metal/streams/utils","ember-htmlbars/system/lookup-helper","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+  }
 
-    var Ember = __dependency1__["default"];
-    var read = __dependency2__.read;
-    var lookupHelper = __dependency3__["default"];
+  /**
+    Wraps an Handlebars helper with an HTMLBars helper for backwards compatibility.
+
+    @class HandlebarsCompatibleHelper
+    @constructor
+    @private
+  */
+  function HandlebarsCompatibleHelper(fn) {
+    this.helperFunction = function helperFunc(params, hash, options, env) {
+      var param, blockResult, fnResult;
+      var context = this;
+      var handlebarsOptions = {
+        hash: { },
+        types: new Array(params.length),
+        hashTypes: { }
+      };
+
+      merge['default'](handlebarsOptions, options);
+      merge['default'](handlebarsOptions, env);
 
-    __exports__["default"] = function element(env, domElement, view, path, params, hash) { //jshint ignore:line
-      var helper = lookupHelper(path, view, env);
-      var valueOrLazyValue;
+      handlebarsOptions.hash = {};
 
-      if (helper) {
-        var options = {
-          element: domElement
+      if (options.isBlock) {
+        handlebarsOptions.fn = function() {
+          blockResult = options.template.render(context, env, options.morph.contextualElement);
         };
-        valueOrLazyValue = helper.helperFunction.call(view, params, hash, options, env);
-      } else {
-        valueOrLazyValue = view.getStream(path);
       }
 
-      var value = read(valueOrLazyValue);
-      if (value) {
-        Ember.deprecate('Returning a string of attributes from a helper inside an element is deprecated.');
+      for (var prop in hash) {
+        param = hash[prop];
+
+        handlebarsOptions.hashTypes[prop] = calculateCompatType(param);
+
+        if (utils.isStream(param)) {
+          handlebarsOptions.hash[prop] = param._label;
+        } else {
+          handlebarsOptions.hash[prop] = param;
+        }
+      }
 
-        var parts = value.toString().split(/\s+/);
-        for (var i = 0, l = parts.length; i < l; i++) {
-          var attrParts = parts[i].split('=');
-          var attrName = attrParts[0];
-          var attrValue = attrParts[1];
+      var args = new Array(params.length);
+      for (var i = 0, l = params.length; i < l; i++) {
+        param = params[i];
 
-          attrValue = attrValue.replace(/^['"]/, '').replace(/['"]$/, '');
+        handlebarsOptions.types[i] = calculateCompatType(param);
 
-          env.dom.setAttribute(domElement, attrName, attrValue);
+        if (utils.isStream(param)) {
+          args[i] = param._label;
+        } else {
+          args[i] = param;
         }
       }
-    }
-  });
-enifed("ember-htmlbars/hooks/get",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+      args.push(handlebarsOptions);
 
-    __exports__["default"] = function get(env, view, path) {
-      return view.getStream(path);
-    }
-  });
-enifed("ember-htmlbars/hooks/inline",
-  ["ember-views/views/simple_bound_view","ember-metal/streams/utils","ember-htmlbars/system/lookup-helper","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+      fnResult = fn.apply(this, args);
 
-    var appendSimpleBoundView = __dependency1__.appendSimpleBoundView;
-    var isStream = __dependency2__.isStream;
-    var lookupHelper = __dependency3__["default"];
+      return options.isBlock ? blockResult : fnResult;
+    };
 
-    __exports__["default"] = function inline(env, morph, view, path, params, hash) {
-      var helper = lookupHelper(path, view, env);
+    this.isHTMLBars = true;
+  }
 
-      Ember.assert("A helper named '"+path+"' could not be found", helper);
+  HandlebarsCompatibleHelper.prototype = {
+    preprocessArguments: function() { }
+  };
 
-      var result = helper.helperFunction.call(view, params, hash, {morph: morph}, env);
+  function registerHandlebarsCompatibleHelper(name, value) {
+    var helper;
 
-      if (isStream(result)) {
-        appendSimpleBoundView(view, morph, result);
-      } else {
-        morph.setContent(result);
-      }
+    if (value && value.isHTMLBars) {
+      helper = value;
+    } else {
+      helper = new HandlebarsCompatibleHelper(value);
     }
-  });
-enifed("ember-htmlbars/hooks/set",
-  ["ember-metal/core","ember-metal/error","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
 
-    var Ember = __dependency1__["default"];
-    var EmberError = __dependency2__["default"];
+    helpers['default'][name] = helper;
+  }
 
-    __exports__["default"] = function set(env, view, name, value) {
-      
-        view._keywords[name] = value;
-          }
-  });
-enifed("ember-htmlbars/hooks/subexpr",
-  ["ember-htmlbars/system/lookup-helper","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+  function handlebarsHelper(name, value) {
+    Ember.assert("You tried to register a component named '" + name +
+                 "', but component names must include a '-'", !Component['default'].detect(value) || name.match(/-/));
 
-    var lookupHelper = __dependency1__["default"];
+    if (View['default'].detect(value)) {
+      helpers['default'][name] = makeViewHelper['default'](value);
+    } else {
+      var boundHelperArgs = slice.call(arguments, 1);
+      var boundFn = makeBoundHelper['default'].apply(this, boundHelperArgs);
 
-    __exports__["default"] = function subexpr(env, view, path, params, hash) {
-      var helper = lookupHelper(path, view, env);
+      helpers['default'][name] = boundFn;
+    }
+  }
 
-      Ember.assert("A helper named '"+path+"' could not be found", helper);
+  exports['default'] = HandlebarsCompatibleHelper;
 
-      var options = {
-        isInline: true
-      };
-      return helper.helperFunction.call(view, params, hash, options, env);
-    }
-  });
-enifed("ember-htmlbars/system/bootstrap",
-  ["ember-metal/core","ember-views/component_lookup","ember-views/system/jquery","ember-metal/error","ember-runtime/system/lazy_load","ember-template-compiler/system/compile","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
-    /*globals Handlebars */
+});
+enifed('ember-htmlbars/compat/make-bound-helper', ['exports', 'ember-metal/core', 'ember-metal/mixin', 'ember-htmlbars/system/helper', 'ember-metal/streams/stream', 'ember-metal/streams/utils'], function (exports, Ember, mixin, Helper, Stream, utils) {
 
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+  'use strict';
 
-    var Ember = __dependency1__["default"];
-    var ComponentLookup = __dependency2__["default"];
-    var jQuery = __dependency3__["default"];
-    var EmberError = __dependency4__["default"];
-    var onLoad = __dependency5__.onLoad;
-    var htmlbarsCompile = __dependency6__["default"];
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-    /**
-    @module ember
-    @submodule ember-handlebars
-    */
+  function makeBoundHelper(fn, compatMode) {
+    var dependentKeys = [];
+    for (var i = 1; i < arguments.length; i++) {
+      dependentKeys.push(arguments[i]);
+    }
 
-    /**
-      Find templates stored in the head tag as script tags and make them available
-      to `Ember.CoreView` in the global `Ember.TEMPLATES` object. This will be run
-      as as jQuery DOM-ready callback.
+    function helperFunc(params, hash, options, env) {
+      var view = env.data.view;
+      var numParams = params.length;
+      var param;
 
-      Script tags with `text/x-handlebars` will be compiled
-      with Ember's Handlebars and are suitable for use as a view's template.
-      Those with type `text/x-raw-handlebars` will be compiled with regular
-      Handlebars and are suitable for use in views' computed properties.
+      Ember['default'].assert("registerBoundHelper-generated helpers do not support use with Handlebars blocks.", !options.template);
 
-      @private
-      @method bootstrap
-      @for Ember.Handlebars
-      @static
-      @param ctx
-    */
-    function bootstrap(ctx) {
-      var selectors = 'script[type="text/x-handlebars"], script[type="text/x-raw-handlebars"]';
+      for (var prop in hash) {
+        if (mixin.IS_BINDING.test(prop)) {
+          hash[prop.slice(0, -7)] = view.getStream(hash[prop]);
+          delete hash[prop];
+        }
+      }
 
-      jQuery(selectors, ctx)
-        .each(function() {
-        // Get a reference to the script tag
-        var script = jQuery(this);
+      function valueFn() {
+        var args = utils.readArray(params);
+        var properties = new Array(params.length);
+        for (var i = 0, l = params.length; i < l; i++) {
+          param = params[i];
+
+          if (utils.isStream(param)) {
+            properties[i] = param._label;
+          } else {
+            properties[i] = param;
+          }
+        }
+
+        args.push({
+          hash: utils.readHash(hash),
+          data: { properties: properties }
+        });
+        return fn.apply(view, args);
+      }
 
-        var compile = (script.attr('type') === 'text/x-raw-handlebars') ?
-                      jQuery.proxy(Handlebars.compile, Handlebars) :
-                      htmlbarsCompile;
-        // Get the name of the script, used by Ember.View's templateName property.
-        // First look for data-template-name attribute, then fall back to its
-        // id if no name is found.
-        var templateName = script.attr('data-template-name') || script.attr('id') || 'application';
-        var template = compile(script.html());
+      // If none of the hash parameters are bound, act as an unbound helper.
+      // This prevents views from being unnecessarily created
+      var hasStream = utils.scanArray(params) || utils.scanHash(hash);
+      if (hasStream) {
+        var lazyValue = new Stream['default'](valueFn);
 
-        // Check if template of same name already exists
-        if (Ember.TEMPLATES[templateName] !== undefined) {
-          throw new EmberError('Template named "' + templateName  + '" already exists.');
+        for (i = 0; i < numParams; i++) {
+          param = params[i];
+          if (utils.isStream(param)) {
+            param.subscribe(lazyValue.notify, lazyValue);
+          }
         }
 
-        // For templates which have a name, we save them and then remove them from the DOM
-        Ember.TEMPLATES[templateName] = template;
+        for (prop in hash) {
+          param = hash[prop];
+          if (utils.isStream(param)) {
+            param.subscribe(lazyValue.notify, lazyValue);
+          }
+        }
 
-        // Remove script tag from DOM
-        script.remove();
-      });
-    }
+        if (numParams > 0) {
+          var firstParam = params[0];
+          // Only bother with subscriptions if the first argument
+          // is a stream itself, and not a primitive.
+          if (utils.isStream(firstParam)) {
+            var onDependentKeyNotify = function onDependentKeyNotify(stream) {
+              stream.value();
+              lazyValue.notify();
+            };
+            for (i = 0; i < dependentKeys.length; i++) {
+              var childParam = firstParam.get(dependentKeys[i]);
+              childParam.value();
+              childParam.subscribe(onDependentKeyNotify);
+            }
+          }
+        }
 
-    function _bootstrap() {
-      bootstrap( jQuery(document) );
+        return lazyValue;
+      } else {
+        return valueFn();
+      }
     }
 
-    function registerComponentLookup(container) {
-      container.register('component-lookup:main', ComponentLookup);
-    }
+    return new Helper['default'](helperFunc);
+  }
+  exports['default'] = makeBoundHelper;
 
-    /*
-      We tie this to application.load to ensure that we've at least
-      attempted to bootstrap at the point that the application is loaded.
+});
+enifed('ember-htmlbars/compat/register-bound-helper', ['exports', 'ember-htmlbars/helpers', 'ember-htmlbars/compat/make-bound-helper'], function (exports, helpers, makeBoundHelper) {
 
-      We also tie this to document ready since we're guaranteed that all
-      the inline templates are present at this point.
+  'use strict';
 
-      There's no harm to running this twice, since we remove the templates
-      from the DOM after processing.
-    */
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-    onLoad('Ember.Application', function(Application) {
-      
+  var slice = [].slice;
 
-      Application.initializer({
-        name: 'domTemplates',
-        initialize: _bootstrap
-      });
+  /**
+    Register a bound handlebars helper. Bound helpers behave similarly to regular
+    handlebars helpers, with the added ability to re-render when the underlying data
+    changes.
 
-      Application.initializer({
-        name: 'registerComponentLookup',
-        after: 'domTemplates',
-        initialize: registerComponentLookup
-      });
+    ## Simple example
 
-      
+    ```javascript
+    Ember.Handlebars.registerBoundHelper('capitalize', function(value) {
+      return Ember.String.capitalize(value);
     });
+    ```
 
-    __exports__["default"] = bootstrap;
-  });
-enifed("ember-htmlbars/system/helper",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+    The above bound helper can be used inside of templates as follows:
 
-    /**
-      @class Helper
-      @namespace Ember.HTMLBars
-    */
-    function Helper(helper) {
-      this.helperFunction = helper;
+    ```handlebars
+    {{capitalize name}}
+    ```
 
-      this.isHelper = true;
-      this.isHTMLBars = true;
-    }
+    In this case, when the `name` property of the template's context changes,
+    the rendered value of the helper will update to reflect this change.
 
-    __exports__["default"] = Helper;
-  });
-enifed("ember-htmlbars/system/lookup-helper",
-  ["ember-metal/core","ember-metal/cache","ember-htmlbars/system/make-view-helper","ember-htmlbars/compat/helper","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+    ## Example with options
 
-    var Ember = __dependency1__["default"];
-    var Cache = __dependency2__["default"];
-    var makeViewHelper = __dependency3__["default"];
-    var HandlebarsCompatibleHelper = __dependency4__["default"];
+    Like normal handlebars helpers, bound helpers have access to the options
+    passed into the helper call.
 
-    var ISNT_HELPER_CACHE = new Cache(1000, function(key) {
-      return key.indexOf('-') === -1;
+    ```javascript
+    Ember.Handlebars.registerBoundHelper('repeat', function(value, options) {
+      var count = options.hash.count;
+      var a = [];
+      while(a.length < count) {
+          a.push(value);
+      }
+      return a.join('');
     });
-    __exports__.ISNT_HELPER_CACHE = ISNT_HELPER_CACHE;
-    /**
-      Used to lookup/resolve handlebars helpers. The lookup order is:
-
-      * Look for a registered helper
-      * If a dash exists in the name:
-        * Look for a helper registed in the container
-        * Use Ember.ComponentLookup to find an Ember.Component that resolves
-          to the given name
+    ```
 
-      @private
-      @method resolveHelper
-      @param {Container} container
-      @param {String} name the name of the helper to lookup
-      @return {Handlebars Helper}
-    */
-    __exports__["default"] = function lookupHelper(name, view, env) {
-      var helper = env.helpers[name];
-      if (helper) {
-        return helper;
-      }
+    This helper could be used in a template as follows:
 
-      var container = view.container;
+    ```handlebars
+    {{repeat text count=3}}
+    ```
 
-      if (!container || ISNT_HELPER_CACHE.get(name)) {
-        return;
-      }
+    ## Example with bound options
 
-      var helperName = 'helper:' + name;
-      helper = container.lookup(helperName);
-      if (!helper) {
-        var componentLookup = container.lookup('component-lookup:main');
-        Ember.assert("Could not find 'component-lookup:main' on the provided container," +
-                     " which is necessary for performing component lookups", componentLookup);
+    Bound hash options are also supported. Example:
 
-        var Component = componentLookup.lookupFactory(name, container);
-        if (Component) {
-          helper = makeViewHelper(Component);
-          container.register(helperName, helper);
-        }
-      }
+    ```handlebars
+    {{repeat text count=numRepeats}}
+    ```
 
-      if (helper && !helper.isHTMLBars) {
-        helper = new HandlebarsCompatibleHelper(helper);
-        container.unregister(helperName);
-        container.register(helperName, helper);
-      }
+    In this example, count will be bound to the value of
+    the `numRepeats` property on the context. If that property
+    changes, the helper will be re-rendered.
 
-      return helper;
-    }
-  });
-enifed("ember-htmlbars/system/make-view-helper",
-  ["ember-metal/core","ember-htmlbars/system/helper","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+    ## Example with extra dependencies
 
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var Helper = __dependency2__["default"];
+    The `Ember.Handlebars.registerBoundHelper` method takes a variable length
+    third parameter which indicates extra dependencies on the passed in value.
+    This allows the handlebars helper to update when these dependencies change.
 
-    /**
-      Returns a helper function that renders the provided ViewClass.
+    ```javascript
+    Ember.Handlebars.registerBoundHelper('capitalizeName', function(value) {
+      return value.get('name').toUpperCase();
+    }, 'name');
+    ```
 
-      Used internally by Ember.Handlebars.helper and other methods
-      involving helper/component registration.
+    ## Example with multiple bound properties
 
-      @private
-      @method makeViewHelper
-      @param {Function} ViewClass view class constructor
-      @since 1.2.0
-    */
-    __exports__["default"] = function makeViewHelper(ViewClass) {
-      function helperFunc(params, hash, options, env) {
-        Ember.assert("You can only pass attributes (such as name=value) not bare " +
-                     "values to a helper for a View found in '" + ViewClass.toString() + "'", params.length === 0);
+    `Ember.Handlebars.registerBoundHelper` supports binding to
+    multiple properties, e.g.:
 
-        return env.helpers.view.helperFunction.call(this, [ViewClass], hash, options, env);
-      }
+    ```javascript
+    Ember.Handlebars.registerBoundHelper('concatenate', function() {
+      var values = Array.prototype.slice.call(arguments, 0, -1);
+      return values.join('||');
+    });
+    ```
 
-      return new Helper(helperFunc);
-    }
-  });
-enifed("ember-htmlbars/system/make_bound_helper",
-  ["ember-metal/core","ember-htmlbars/system/helper","ember-metal/streams/stream","ember-metal/streams/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+    Which allows for template syntax such as `{{concatenate prop1 prop2}}` or
+    `{{concatenate prop1 prop2 prop3}}`. If any of the properties change,
+    the helper will re-render.  Note that dependency keys cannot be
+    using in conjunction with multi-property helpers, since it is ambiguous
+    which property the dependent keys would belong to.
 
-    var Ember = __dependency1__["default"];
-    // Ember.FEATURES, Ember.assert, Ember.Handlebars, Ember.lookup
-    var Helper = __dependency2__["default"];
+    ## Use with unbound helper
 
-    var Stream = __dependency3__["default"];
-    var readArray = __dependency4__.readArray;
-    var readHash = __dependency4__.readHash;
-    var subscribe = __dependency4__.subscribe;
-    var scanHash = __dependency4__.scanHash;
-    var scanArray = __dependency4__.scanArray;
+    The `{{unbound}}` helper can be used with bound helper invocations
+    to render them in their unbound form, e.g.
 
-    /**
-      Create a bound helper. Accepts a function that receives the ordered and hash parameters
-      from the template. If a bound property was provided in the template it will be resolved to its
-      value and any changes to the bound property cause the helper function to be re-ran with the updated
-      values.
+    ```handlebars
+    {{unbound capitalize name}}
+    ```
 
-      * `params` - An array of resolved ordered parameters.
-      * `hash` - An object containing the hash parameters.
+    In this example, if the name property changes, the helper
+    will not re-render.
 
-      For example:
+    ## Use with blocks not supported
 
-      * With an unqouted ordered parameter:
+    Bound helpers do not support use with Handlebars blocks or
+    the addition of child views of any kind.
 
-        ```javascript
-        {{x-capitalize foo}}
-        ```
+    @method registerBoundHelper
+    @for Ember.Handlebars
+    @param {String} name
+    @param {Function} function
+    @param {String} dependentKeys*
+  */
+  function registerBoundHelper(name, fn) {
+    var boundHelperArgs = slice.call(arguments, 1);
+    var boundFn = makeBoundHelper['default'].apply(this, boundHelperArgs);
 
-        Assuming `foo` was set to `"bar"`, the bound helper would receive `["bar"]` as its first argument, and
-        an empty hash as its second.
+    helpers['default'][name] = boundFn;
+  }
+  exports['default'] = registerBoundHelper;
 
-      * With a quoted ordered parameter:
+});
+enifed('ember-htmlbars/env', ['exports', 'ember-metal/environment', 'dom-helper', 'ember-htmlbars/hooks/inline', 'ember-htmlbars/hooks/content', 'ember-htmlbars/hooks/component', 'ember-htmlbars/hooks/block', 'ember-htmlbars/hooks/element', 'ember-htmlbars/hooks/subexpr', 'ember-htmlbars/hooks/attribute', 'ember-htmlbars/hooks/concat', 'ember-htmlbars/hooks/get', 'ember-htmlbars/hooks/set', 'ember-htmlbars/helpers'], function (exports, environment, DOMHelper, inline, content, component, block, element, subexpr, attribute, concat, get, set, helpers) {
 
-        ```javascript
-        {{x-capitalize "foo"}}
-        ```
+  'use strict';
 
-        The bound helper would receive `["foo"]` as its first argument, and an empty hash as its second.
+  exports['default'] = {
+    hooks: {
+      get: get['default'],
+      set: set['default'],
+      inline: inline['default'],
+      content: content['default'],
+      block: block['default'],
+      element: element['default'],
+      subexpr: subexpr['default'],
+      component: component['default'],
+      attribute: attribute['default'],
+      concat: concat['default']
+    },
 
-      * With an unquoted hash parameter:
+    helpers: helpers['default'],
 
-        ```javascript
-        {{x-repeat "foo" count=repeatCount}}
-        ```
+    useFragmentCache: true
+  };
 
-        Assuming that `repeatCount` resolved to 2, the bound helper would receive `["foo"]` as its first argument,
-        and { count: 2 } as its second.
+  var domHelper = environment['default'].hasDOM ? new DOMHelper['default']() : null;
 
-      @private
-      @method makeBoundHelper
-      @for Ember.HTMLBars
-      @param {Function} function
-      @since 1.10.0
-    */
-    __exports__["default"] = function makeBoundHelper(fn) {
-      function helperFunc(params, hash, options, env) {
-        var view = this;
-        var numParams = params.length;
-        var param, prop;
+  exports.domHelper = domHelper;
 
-        Ember.assert("makeBoundHelper generated helpers do not support use with blocks", !options.template);
+});
+enifed('ember-htmlbars/helpers', ['exports', 'ember-metal/platform/create', 'ember-htmlbars/system/helper'], function (exports, o_create, Helper) {
 
-        function valueFn() {
-          return fn.call(view, readArray(params), readHash(hash), options, env);
-        }
+  'use strict';
 
-        // If none of the hash parameters are bound, act as an unbound helper.
-        // This prevents views from being unnecessarily created
-        var hasStream = scanArray(params) || scanHash(hash);
+  exports.registerHelper = registerHelper;
 
-        if (env.data.isUnbound || !hasStream) {
-          return valueFn();
-        } else {
-          var lazyValue = new Stream(valueFn);
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-          for (var i = 0; i < numParams; i++) {
-            param = params[i];
-            subscribe(param, lazyValue.notify, lazyValue);
-          }
+  var helpers = o_create['default'](null);
 
-          for (prop in hash) {
-            param = hash[prop];
-            subscribe(param, lazyValue.notify, lazyValue);
-          }
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-          return lazyValue;
-        }
-      }
+  function registerHelper(name, helperFunc) {
+    var helper;
 
-      return new Helper(helperFunc);
+    if (helperFunc && helperFunc.isHelper) {
+      helper = helperFunc;
+    } else {
+      helper = new Helper['default'](helperFunc);
     }
-  });
-enifed("ember-htmlbars/templates/component",
-  ["ember-template-compiler/system/template","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var template = __dependency1__["default"];
-    var t = (function() {
-      return {
-        isHTMLBars: true,
-        blockParams: 0,
-        cachedFragment: null,
-        hasRendered: false,
-        build: function build(dom) {
-          var el0 = dom.createDocumentFragment();
-          var el1 = dom.createTextNode("");
-          dom.appendChild(el0, el1);
-          var el1 = dom.createTextNode("");
-          dom.appendChild(el0, el1);
-          return el0;
-        },
-        render: function render(context, env, contextualElement) {
-          var dom = env.dom;
-          var hooks = env.hooks, content = hooks.content;
-          dom.detectNamespace(contextualElement);
-          var fragment;
-          if (env.useFragmentCache && dom.canClone) {
-            if (this.cachedFragment === null) {
-              fragment = this.build(dom);
-              if (this.hasRendered) {
-                this.cachedFragment = fragment;
-              } else {
-                this.hasRendered = true;
-              }
-            }
-            if (this.cachedFragment) {
-              fragment = dom.cloneNode(this.cachedFragment, true);
-            }
-          } else {
-            fragment = this.build(dom);
-          }
-          if (this.cachedFragment) { dom.repairClonedNode(fragment,[0,1]); }
-          var morph0 = dom.createMorphAt(fragment,0,1,contextualElement);
-          content(env, morph0, context, "yield");
-          return fragment;
-        }
-      };
-    }());
-     __exports__["default"] = template(t);
-  });
-enifed("ember-htmlbars/templates/select",
-  ["ember-template-compiler/system/template","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var template = __dependency1__["default"];
-    var t = (function() {
-      var child0 = (function() {
-        return {
-          isHTMLBars: true,
-          blockParams: 0,
-          cachedFragment: null,
-          hasRendered: false,
-          build: function build(dom) {
-            var el0 = dom.createElement("option");
-            dom.setAttribute(el0,"value","");
-            return el0;
-          },
-          render: function render(context, env, contextualElement) {
-            var dom = env.dom;
-            var hooks = env.hooks, content = hooks.content;
-            dom.detectNamespace(contextualElement);
-            var fragment;
-            if (env.useFragmentCache && dom.canClone) {
-              if (this.cachedFragment === null) {
-                fragment = this.build(dom);
-                if (this.hasRendered) {
-                  this.cachedFragment = fragment;
-                } else {
-                  this.hasRendered = true;
-                }
-              }
-              if (this.cachedFragment) {
-                fragment = dom.cloneNode(this.cachedFragment, true);
-              }
-            } else {
-              fragment = this.build(dom);
-            }
-            var morph0 = dom.createMorphAt(fragment,-1,-1);
-            content(env, morph0, context, "view.prompt");
-            return fragment;
-          }
-        };
-      }());
-      var child1 = (function() {
-        var child0 = (function() {
-          return {
-            isHTMLBars: true,
-            blockParams: 0,
-            cachedFragment: null,
-            hasRendered: false,
-            build: function build(dom) {
-              var el0 = dom.createDocumentFragment();
-              var el1 = dom.createTextNode("");
-              dom.appendChild(el0, el1);
-              var el1 = dom.createTextNode("");
-              dom.appendChild(el0, el1);
-              return el0;
-            },
-            render: function render(context, env, contextualElement) {
-              var dom = env.dom;
-              var hooks = env.hooks, get = hooks.get, inline = hooks.inline;
-              dom.detectNamespace(contextualElement);
-              var fragment;
-              if (env.useFragmentCache && dom.canClone) {
-                if (this.cachedFragment === null) {
-                  fragment = this.build(dom);
-                  if (this.hasRendered) {
-                    this.cachedFragment = fragment;
-                  } else {
-                    this.hasRendered = true;
-                  }
-                }
-                if (this.cachedFragment) {
-                  fragment = dom.cloneNode(this.cachedFragment, true);
-                }
-              } else {
-                fragment = this.build(dom);
-              }
-              if (this.cachedFragment) { dom.repairClonedNode(fragment,[0,1]); }
-              var morph0 = dom.createMorphAt(fragment,0,1,contextualElement);
-              inline(env, morph0, context, "view", [get(env, context, "view.groupView")], {"content": get(env, context, "group.content"), "label": get(env, context, "group.label")});
-              return fragment;
-            }
-          };
-        }());
-        return {
-          isHTMLBars: true,
-          blockParams: 0,
-          cachedFragment: null,
-          hasRendered: false,
-          build: function build(dom) {
-            var el0 = dom.createDocumentFragment();
-            var el1 = dom.createTextNode("");
-            dom.appendChild(el0, el1);
-            var el1 = dom.createTextNode("");
-            dom.appendChild(el0, el1);
-            return el0;
-          },
-          render: function render(context, env, contextualElement) {
-            var dom = env.dom;
-            var hooks = env.hooks, get = hooks.get, block = hooks.block;
-            dom.detectNamespace(contextualElement);
-            var fragment;
-            if (env.useFragmentCache && dom.canClone) {
-              if (this.cachedFragment === null) {
-                fragment = this.build(dom);
-                if (this.hasRendered) {
-                  this.cachedFragment = fragment;
-                } else {
-                  this.hasRendered = true;
-                }
-              }
-              if (this.cachedFragment) {
-                fragment = dom.cloneNode(this.cachedFragment, true);
-              }
-            } else {
-              fragment = this.build(dom);
-            }
-            if (this.cachedFragment) { dom.repairClonedNode(fragment,[0,1]); }
-            var morph0 = dom.createMorphAt(fragment,0,1,contextualElement);
-            block(env, morph0, context, "each", [get(env, context, "view.groupedContent")], {"keyword": "group"}, child0, null);
-            return fragment;
-          }
-        };
-      }());
-      var child2 = (function() {
-        var child0 = (function() {
-          return {
-            isHTMLBars: true,
-            blockParams: 0,
-            cachedFragment: null,
-            hasRendered: false,
-            build: function build(dom) {
-              var el0 = dom.createDocumentFragment();
-              var el1 = dom.createTextNode("");
-              dom.appendChild(el0, el1);
-              var el1 = dom.createTextNode("");
-              dom.appendChild(el0, el1);
-              return el0;
-            },
-            render: function render(context, env, contextualElement) {
-              var dom = env.dom;
-              var hooks = env.hooks, get = hooks.get, inline = hooks.inline;
-              dom.detectNamespace(contextualElement);
-              var fragment;
-              if (env.useFragmentCache && dom.canClone) {
-                if (this.cachedFragment === null) {
-                  fragment = this.build(dom);
-                  if (this.hasRendered) {
-                    this.cachedFragment = fragment;
-                  } else {
-                    this.hasRendered = true;
-                  }
-                }
-                if (this.cachedFragment) {
-                  fragment = dom.cloneNode(this.cachedFragment, true);
-                }
-              } else {
-                fragment = this.build(dom);
-              }
-              if (this.cachedFragment) { dom.repairClonedNode(fragment,[0,1]); }
-              var morph0 = dom.createMorphAt(fragment,0,1,contextualElement);
-              inline(env, morph0, context, "view", [get(env, context, "view.optionView")], {"content": get(env, context, "item")});
-              return fragment;
-            }
-          };
-        }());
-        return {
-          isHTMLBars: true,
-          blockParams: 0,
-          cachedFragment: null,
-          hasRendered: false,
-          build: function build(dom) {
-            var el0 = dom.createDocumentFragment();
-            var el1 = dom.createTextNode("");
-            dom.appendChild(el0, el1);
-            var el1 = dom.createTextNode("");
-            dom.appendChild(el0, el1);
-            return el0;
-          },
-          render: function render(context, env, contextualElement) {
-            var dom = env.dom;
-            var hooks = env.hooks, get = hooks.get, block = hooks.block;
-            dom.detectNamespace(contextualElement);
-            var fragment;
-            if (env.useFragmentCache && dom.canClone) {
-              if (this.cachedFragment === null) {
-                fragment = this.build(dom);
-                if (this.hasRendered) {
-                  this.cachedFragment = fragment;
-                } else {
-                  this.hasRendered = true;
-                }
-              }
-              if (this.cachedFragment) {
-                fragment = dom.cloneNode(this.cachedFragment, true);
-              }
-            } else {
-              fragment = this.build(dom);
-            }
-            if (this.cachedFragment) { dom.repairClonedNode(fragment,[0,1]); }
-            var morph0 = dom.createMorphAt(fragment,0,1,contextualElement);
-            block(env, morph0, context, "each", [get(env, context, "view.content")], {"keyword": "item"}, child0, null);
-            return fragment;
-          }
-        };
-      }());
-      return {
-        isHTMLBars: true,
-        blockParams: 0,
-        cachedFragment: null,
-        hasRendered: false,
-        build: function build(dom) {
-          var el0 = dom.createDocumentFragment();
-          var el1 = dom.createTextNode("");
-          dom.appendChild(el0, el1);
-          var el1 = dom.createTextNode("");
-          dom.appendChild(el0, el1);
-          var el1 = dom.createTextNode("\n");
-          dom.appendChild(el0, el1);
-          return el0;
-        },
-        render: function render(context, env, contextualElement) {
-          var dom = env.dom;
-          var hooks = env.hooks, get = hooks.get, block = hooks.block;
-          dom.detectNamespace(contextualElement);
-          var fragment;
-          if (env.useFragmentCache && dom.canClone) {
-            if (this.cachedFragment === null) {
-              fragment = this.build(dom);
-              if (this.hasRendered) {
-                this.cachedFragment = fragment;
-              } else {
-                this.hasRendered = true;
-              }
-            }
-            if (this.cachedFragment) {
-              fragment = dom.cloneNode(this.cachedFragment, true);
-            }
-          } else {
-            fragment = this.build(dom);
-          }
-          if (this.cachedFragment) { dom.repairClonedNode(fragment,[0,1]); }
-          var morph0 = dom.createMorphAt(fragment,0,1,contextualElement);
-          var morph1 = dom.createMorphAt(fragment,1,2,contextualElement);
-          block(env, morph0, context, "if", [get(env, context, "view.prompt")], {}, child0, null);
-          block(env, morph1, context, "if", [get(env, context, "view.optionGroupPath")], {}, child1, child2);
-          return fragment;
-        }
-      };
-    }());
-     __exports__["default"] = template(t);
-  });
-enifed("ember-htmlbars/utils/string",
-  ["htmlbars-util","ember-runtime/system/string","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
 
-    // required so we can extend this object.
-    var SafeString = __dependency1__.SafeString;
-    var escapeExpression = __dependency1__.escapeExpression;
-    var EmberStringUtils = __dependency2__["default"];
+    helpers[name] = helper;
+  }
 
-    /**
-      Mark a string as safe for unescaped output with Handlebars. If you
-      return HTML from a Handlebars helper, use this function to
-      ensure Handlebars does not escape the HTML.
+  exports['default'] = helpers;
 
-      ```javascript
-      Ember.String.htmlSafe('<div>someString</div>')
-      ```
+});
+enifed('ember-htmlbars/helpers/bind-attr', ['exports', 'ember-metal/core', 'ember-runtime/system/string', 'ember-views/attr_nodes/attr_node', 'ember-views/attr_nodes/legacy_bind', 'ember-metal/keys', 'ember-htmlbars/helpers', 'ember-metal/enumerable_utils', 'ember-metal/streams/utils', 'ember-views/streams/class_name_binding'], function (exports, Ember, string, AttrNode, LegacyBindAttrNode, keys, helpers, enumerable_utils, utils, class_name_binding) {
 
-      @method htmlSafe
-      @for Ember.String
-      @static
-      @return {Handlebars.SafeString} a string that will not be html escaped by Handlebars
-    */
-    function htmlSafe(str) {
-      if (str === null || str === undefined) {
-        return "";
+  'use strict';
+
+  exports.bindAttrHelper = bindAttrHelper;
+  exports.bindAttrHelperDeprecated = bindAttrHelperDeprecated;
+
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+
+  function bindAttrHelper(params, hash, options, env) {
+    var element = options.element;
+
+    Ember['default'].assert("You must specify at least one hash argument to bind-attr", !!keys['default'](hash).length);
+
+    var view = env.data.view;
+
+    // Handle classes differently, as we can bind multiple classes
+    var classNameBindings = hash['class'];
+    if (classNameBindings !== null && classNameBindings !== undefined) {
+      if (!utils.isStream(classNameBindings)) {
+        classNameBindings = applyClassNameBindings(classNameBindings, view);
       }
 
-      if (typeof str !== 'string') {
-        str = ''+str;
+      var classView = new AttrNode['default']('class', classNameBindings);
+      classView._morph = env.dom.createAttrMorph(element, 'class');
+
+      Ember['default'].assert(
+        'You cannot set `class` manually and via `{{bind-attr}}` helper on the same element. ' +
+        'Please use `{{bind-attr}}`\'s `:static-class` syntax instead.',
+        !element.getAttribute('class')
+      );
+
+      view.appendChild(classView);
+    }
+
+    var attrKeys = keys['default'](hash);
+
+    var attr, path, lazyValue, attrView;
+    for (var i=0, l=attrKeys.length;i<l;i++) {
+      attr = attrKeys[i];
+      if (attr === 'class') {
+        continue;
+      }
+      path = hash[attr];
+      if (utils.isStream(path)) {
+        lazyValue = path;
+      } else {
+        Ember['default'].assert(
+          string.fmt("You must provide an expression as the value of bound attribute." +
+              " You specified: %@=%@", [attr, path]),
+          typeof path === 'string'
+        );
+        lazyValue = view.getStream(path);
       }
-      return new SafeString(str);
+
+      attrView = new LegacyBindAttrNode['default'](attr, lazyValue);
+      attrView._morph = env.dom.createAttrMorph(element, attr);
+
+      Ember['default'].assert(
+        'You cannot set `' + attr + '` manually and via `{{bind-attr}}` helper on the same element.',
+        !element.getAttribute(attr)
+      );
+
+      view.appendChild(attrView);
     }
+  }
 
-    EmberStringUtils.htmlSafe = htmlSafe;
-    if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) {
+  function applyClassNameBindings(classNameBindings, view) {
+    var arrayOfClassNameBindings = classNameBindings.split(' ');
+    var boundClassNameBindings = enumerable_utils.map(arrayOfClassNameBindings, function(classNameBinding) {
+      return class_name_binding.streamifyClassNameBinding(view, classNameBinding);
+    });
+    var concatenatedClassNames = utils.concat(boundClassNameBindings, ' ');
+    return concatenatedClassNames;
+  }
 
-      /**
-        Mark a string as being safe for unescaped output with Handlebars.
+  /**
+    See `bind-attr`
 
-        ```javascript
-        '<div>someString</div>'.htmlSafe()
-        ```
+    @method bindAttr
+    @for Ember.Handlebars.helpers
+    @deprecated
+    @param {Function} context
+    @param {Hash} options
+    @return {String} HTML string
+  */
+  function bindAttrHelperDeprecated() {
+    Ember['default'].deprecate("The 'bindAttr' view helper is deprecated in favor of 'bind-attr'");
 
-        See [Ember.String.htmlSafe](/api/classes/Ember.String.html#method_htmlSafe).
+    return helpers['default']['bind-attr'].helperFunction.apply(this, arguments);
+  }
 
-        @method htmlSafe
-        @for String
-        @return {Handlebars.SafeString} a string that will not be html escaped by Handlebars
-      */
-      String.prototype.htmlSafe = function() {
-        return htmlSafe(this);
-      };
+  exports['default'] = bindAttrHelper;
+
+});
+enifed('ember-htmlbars/helpers/collection', ['exports', 'ember-metal/core', 'ember-metal/mixin', 'ember-runtime/system/string', 'ember-metal/property_get', 'ember-views/views/collection_view', 'ember-views/streams/utils', 'ember-metal/enumerable_utils', 'ember-views/streams/class_name_binding', 'ember-htmlbars/system/merge-view-bindings'], function (exports, Ember, mixin, string, property_get, CollectionView, utils, enumerable_utils, class_name_binding, mergeViewBindings) {
+
+  'use strict';
+
+  exports.collectionHelper = collectionHelper;
+
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+
+  function collectionHelper(params, hash, options, env) {
+    var path = params[0];
+
+    Ember['default'].deprecate(
+      "Using the {{collection}} helper without specifying a class has been" +
+      " deprecated as the {{each}} helper now supports the same functionality.",
+      path !== 'collection'
+    );
+
+    Ember['default'].assert("You cannot pass more than one argument to the collection helper", params.length <= 1);
+
+    var data     = env.data;
+    var template = options.template;
+    var inverse  = options.inverse;
+    var view     = data.view;
+
+    // This should be deterministic, and should probably come from a
+    // parent view and not the controller.
+    var  controller = property_get.get(view, 'controller');
+    var  container = (controller && controller.container ? controller.container : view.container);
+
+    // If passed a path string, convert that into an object.
+    // Otherwise, just default to the standard class.
+    var collectionClass;
+    if (path) {
+      collectionClass = utils.readViewFactory(path, container);
+      Ember['default'].assert(string.fmt("%@ #collection: Could not find collection class %@", [data.view, path]), !!collectionClass);
+    } else {
+      collectionClass = CollectionView['default'];
     }
 
-    __exports__.SafeString = SafeString;
-    __exports__.htmlSafe = htmlSafe;
-    __exports__.escapeExpression = escapeExpression;
-  });
-enifed("ember-metal-views",
-  ["ember-metal-views/renderer","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Renderer = __dependency1__["default"];
-    __exports__.Renderer = Renderer;
-  });
-enifed("ember-metal-views/renderer",
-  ["morph","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var DOMHelper = __dependency1__.DOMHelper;
-
-    function Renderer() {
-      this._uuid = 0;
-      this._views = new Array(2000);
-      this._queue = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
-      this._parents = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
-      this._elements = new Array(17);
-      this._inserts = {};
-      this._dom = new DOMHelper();
-    }
-
-    function Renderer_renderTree(_view, _parentView, _insertAt) {
-      var views = this._views;
-      views[0] = _view;
-      var insertAt = _insertAt === undefined ? -1 : _insertAt;
-      var index = 0;
-      var total = 1;
-      var levelBase = _parentView ? _parentView._level+1 : 0;
-
-      var root = _parentView == null ? _view : _parentView._root;
-
-      // if root view has a _morph assigned
-      var willInsert = !!root._morph;
-
-      var queue = this._queue;
-      queue[0] = 0;
-      var length = 1;
-
-      var parentIndex = -1;
-      var parents = this._parents;
-      var parent = _parentView || null;
-      var elements = this._elements;
-      var element = null;
-      var contextualElement = null;
-      var level = 0;
-
-      var view = _view;
-      var children, i, child;
-      while (length) {
-        elements[level] = element;
-        if (!view._morph) {
-          // ensure props we add are in same order
-          view._morph = null;
-        }
-        view._root = root;
-        this.uuid(view);
-        view._level = levelBase + level;
-        if (view._elementCreated) {
-          this.remove(view, false, true);
-        }
-
-        this.willCreateElement(view);
-
-        contextualElement = view._morph && view._morph.contextualElement;
-        if (!contextualElement && parent && parent._childViewsMorph) {
-          contextualElement = parent._childViewsMorph.contextualElement;
-        }
-        if (!contextualElement && view._didCreateElementWithoutMorph) {
-          // This code path is only used by createElement and rerender when createElement
-          // was previously called on a view.
-          contextualElement = document.body;
-        }
-        element = this.createElement(view, contextualElement);
-
-        parents[level++] = parentIndex;
-        parentIndex = index;
-        parent = view;
-
-        // enqueue for end
-        queue[length++] = index;
-        // enqueue children
-        children = this.childViews(view);
-        if (children) {
-          for (i=children.length-1;i>=0;i--) {
-            child = children[i];
-            index = total++;
-            views[index] = child;
-            queue[length++] = index;
-            view = child;
-          }
-        }
+    var itemHash = {};
+    var match;
 
-        index = queue[--length];
-        view = views[index];
+    // Extract item view class if provided else default to the standard class
+    var collectionPrototype = collectionClass.proto();
+    var itemViewClass;
 
-        while (parentIndex === index) {
-          level--;
-          view._elementCreated = true;
-          this.didCreateElement(view);
-          if (willInsert) {
-            this.willInsertElement(view);
-          }
+    if (hash.itemView) {
+      itemViewClass = utils.readViewFactory(hash.itemView, container);
+    } else if (hash.itemViewClass) {
+      itemViewClass = utils.readViewFactory(hash.itemViewClass, container);
+    } else {
+      itemViewClass = collectionPrototype.itemViewClass;
+    }
 
-          if (level === 0) {
-            length--;
-            break;
-          }
+    if (typeof itemViewClass === 'string') {
+      itemViewClass = container.lookupFactory('view:'+itemViewClass);
+    }
 
-          parentIndex = parents[level];
-          parent = parentIndex === -1 ? _parentView : views[parentIndex];
-          this.insertElement(view, parent, element, -1);
-          index = queue[--length];
-          view = views[index];
-          element = elements[level];
-          elements[level] = null;
-        }
-      }
+    Ember['default'].assert(string.fmt("%@ #collection: Could not find itemViewClass %@", [data.view, itemViewClass]), !!itemViewClass);
 
-      this.insertElement(view, _parentView, element, insertAt);
+    delete hash.itemViewClass;
+    delete hash.itemView;
 
-      for (i=total-1; i>=0; i--) {
-        if (willInsert) {
-          views[i]._elementInserted = true;
-          this.didInsertElement(views[i]);
+    // Go through options passed to the {{collection}} helper and extract options
+    // that configure item views instead of the collection itself.
+    for (var prop in hash) {
+      if (prop === 'itemController' || prop === 'itemClassBinding') {
+        continue;
+      }
+      if (hash.hasOwnProperty(prop)) {
+        match = prop.match(/^item(.)(.*)$/);
+        if (match) {
+          var childProp = match[1].toLowerCase() + match[2];
+
+          if (mixin.IS_BINDING.test(prop)) {
+            itemHash[childProp] = view._getBindingForStream(hash[prop]);
+          } else {
+            itemHash[childProp] = hash[prop];
+          }
+          delete hash[prop];
         }
-        views[i] = null;
       }
+    }
 
-      return element;
+    if (template) {
+      itemHash.template = template;
+      delete options.template;
     }
 
-    Renderer.prototype.uuid = function Renderer_uuid(view) {
-      if (view._uuid === undefined) {
-        view._uuid = ++this._uuid;
-        view._renderer = this;
-      } // else assert(view._renderer === this)
-      return view._uuid;
-    };
+    var emptyViewClass;
+    if (inverse) {
+      emptyViewClass = property_get.get(collectionPrototype, 'emptyViewClass');
+      emptyViewClass = emptyViewClass.extend({
+        template: inverse,
+        tagName: itemHash.tagName
+      });
+    } else if (hash.emptyViewClass) {
+      emptyViewClass = utils.readViewFactory(hash.emptyViewClass, container);
+    }
+    if (emptyViewClass) { hash.emptyView = emptyViewClass; }
 
-    Renderer.prototype.scheduleInsert =
-      function Renderer_scheduleInsert(view, morph) {
-        if (view._morph || view._elementCreated) {
-          throw new Error("You cannot insert a View that has already been rendered");
-        }
-        Ember.assert("You cannot insert a View without a morph", morph);
-        view._morph = morph;
-        var viewId = this.uuid(view);
-        this._inserts[viewId] = this.scheduleRender(this, function scheduledRenderTree() {
-          this._inserts[viewId] = null;
-          this.renderTree(view);
-        });
-      };
+    var viewOptions = mergeViewBindings['default'](view, {}, itemHash);
 
-    Renderer.prototype.appendTo =
-      function Renderer_appendTo(view, target) {
-        var morph = this._dom.appendMorph(target);
-        this.scheduleInsert(view, morph);
-      };
+    if (hash.itemClassBinding) {
+      var itemClassBindings = hash.itemClassBinding.split(' ');
+      viewOptions.classNameBindings = enumerable_utils.map(itemClassBindings, function(classBinding) {
+        return class_name_binding.streamifyClassNameBinding(view, classBinding);
+      });
+    }
 
-    Renderer.prototype.replaceIn =
-      function Renderer_replaceIn(view, target) {
-        var morph = this._dom.createMorph(target, null, null);
-        this.scheduleInsert(view, morph);
-      };
+    hash.itemViewClass = itemViewClass;
+    hash._itemViewProps = viewOptions;
 
-    function Renderer_remove(_view, shouldDestroy, reset) {
-      var viewId = this.uuid(_view);
+    options.helperName = options.helperName || 'collection';
 
-      if (this._inserts[viewId]) {
-        this.cancelRender(this._inserts[viewId]);
-        this._inserts[viewId] = undefined;
-      }
+    return env.helpers.view.helperFunction.call(this, [collectionClass], hash, options, env);
+  }
 
-      if (!_view._elementCreated) {
-        return;
+});
+enifed('ember-htmlbars/helpers/component', ['exports', 'ember-metal/core', 'ember-metal/streams/utils', 'ember-views/streams/utils', 'ember-metal/error', 'ember-views/views/bound_component_view', 'ember-htmlbars/system/merge-view-bindings', 'ember-htmlbars/system/append-templated-view'], function (exports, Ember, utils, streams__utils, EmberError, BoundComponentView, mergeViewBindings, appendTemplatedView) {
+
+  'use strict';
+
+  exports.componentHelper = componentHelper;
+
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+  function componentHelper(params, hash, options, env) {
+    Ember['default'].assert(
+      "The `component` helper expects exactly one argument, plus name/property values.",
+      params.length === 1
+    );
+
+    var view = env.data.view;
+    var componentNameParam = params[0];
+    var container = view.container || utils.read(view._keywords.view).container;
+
+    var props = {
+      helperName: options.helperName || 'component'
+    };
+    if (options.template) {
+      props.template = options.template;
+    }
+
+    var viewClass;
+    if (utils.isStream(componentNameParam)) {
+      viewClass = BoundComponentView['default'];
+      props = { _boundComponentOptions: Ember['default'].merge(hash, props) };
+      props._boundComponentOptions.componentNameStream = componentNameParam;
+    } else {
+      viewClass = streams__utils.readComponentFactory(componentNameParam, container);
+      if (!viewClass) {
+        throw new EmberError['default']('HTMLBars error: Could not find component named "' + componentNameParam + '".');
       }
+      mergeViewBindings['default'](view, props, hash);
+    }
 
-      var removeQueue = [];
-      var destroyQueue = [];
-      var morph = _view._morph;
-      var idx, len, view, queue, childViews, i, l;
+    appendTemplatedView['default'](view, options.morph, viewClass, props);
+  }
 
-      removeQueue.push(_view);
+});
+enifed('ember-htmlbars/helpers/debugger', ['exports', 'ember-metal/logger'], function (exports, Logger) {
 
-      for (idx=0; idx<removeQueue.length; idx++) {
-        view = removeQueue[idx];
+  'use strict';
 
-        if (!shouldDestroy && view._childViewsMorph) {
-          queue = removeQueue;
-        } else {
-          queue = destroyQueue;
-        }
+  exports.debuggerHelper = debuggerHelper;
+
+  /*jshint debug:true*/
+
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+  function debuggerHelper(params, hash, options, env) {
+
+    /* jshint unused: false */
+    var view = env.data.view;
+
+    /* jshint unused: false */
+    var context = view.get('context');
+
+    /* jshint unused: false */
+    function get(path) {
+      return view.getStream(path).value();
+    }
+
+    Logger['default'].info('Use `view`, `context`, and `get(<path>)` to debug this template.');
+
+    debugger;
+  }
+
+});
+enifed('ember-htmlbars/helpers/each', ['exports', 'ember-metal/core', 'ember-views/views/each'], function (exports, Ember, EachView) {
+
+  'use strict';
+
+  exports.eachHelper = eachHelper;
+
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+  function eachHelper(params, hash, options, env) {
+    var view = env.data.view;
+    var helperName = 'each';
+    var path = params[0] || view.getStream('');
+
+    Ember['default'].assert(
+      "If you pass more than one argument to the each helper, " +
+      "it must be in the form #each foo in bar",
+      params.length <= 1
+    );
+
+    var blockParams = options.template && options.template.blockParams;
+
+    if (blockParams) {
+      hash.keyword = true;
+      hash.blockParams = blockParams;
+    }
+
+    Ember['default'].deprecate(
+      "Using the context switching form of {{each}} is deprecated. " +
+      "Please use the keyword form (`{{#each foo in bar}}`) instead.",
+      hash.keyword === true || typeof hash.keyword === 'string',
+      { url: 'http://emberjs.com/guides/deprecations/#toc_more-consistent-handlebars-scope' }
+    );
+
+    hash.dataSource = path;
+    options.helperName = options.helperName || helperName;
+
+    return env.helpers.collection.helperFunction.call(this, [EachView['default']], hash, options, env);
+  }
+
+  exports.EachView = EachView['default'];
+
+});
+enifed('ember-htmlbars/helpers/if_unless', ['exports', 'ember-metal/core', 'ember-metal/streams/conditional', 'ember-views/streams/should_display', 'ember-metal/property_get', 'ember-metal/streams/utils', 'ember-views/views/bound_if_view', 'ember-htmlbars/templates/empty'], function (exports, Ember, conditional, shouldDisplay, property_get, utils, BoundIfView, emptyTemplate) {
+
+  'use strict';
+
+  exports.ifHelper = ifHelper;
+  exports.unlessHelper = unlessHelper;
+
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+
+  function ifHelper(params, hash, options, env) {
+    var helperName = options.helperName || 'if';
+    return appendConditional(false, helperName, params, hash, options, env);
+  }
 
-        this.beforeRemove(removeQueue[idx]);
+  /**
+    @method unless
+    @for Ember.Handlebars.helpers
+  */
+  function unlessHelper(params, hash, options, env) {
+    var helperName = options.helperName || 'unless';
+    return appendConditional(true, helperName, params, hash, options, env);
+  }
+
+
+  function assertInlineIfNotEnabled() {
+    Ember['default'].assert(
+      "To use the inline forms of the `if` and `unless` helpers you must " +
+      "enable the `ember-htmlbars-inline-if-helper` feature flag."
+    );
+  }
 
-        childViews = view._childViews;
-        if (childViews) {
-          for (i=0,l=childViews.length; i<l; i++) {
-            queue.push(childViews[i]);
+  function appendConditional(inverted, helperName, params, hash, options, env) {
+    var view = env.data.view;
+
+    if (options.isBlock) {
+      return appendBlockConditional(view, inverted, helperName, params, hash, options, env);
+    } else {
+
+        return appendInlineConditional(view, inverted, helperName, params, hash, options, env);
           }
-        }
+  }
+
+  function appendBlockConditional(view, inverted, helperName, params, hash, options, env) {
+    Ember['default'].assert(
+      "The block form of the `if` and `unless` helpers expect exactly one " +
+      "argument, e.g. `{{#if newMessages}} You have new messages. {{/if}}.`",
+      params.length === 1
+    );
+
+    var condition = shouldDisplay['default'](params[0]);
+    var truthyTemplate = (inverted ? options.inverse : options.template) || emptyTemplate['default'];
+    var falsyTemplate = (inverted ? options.template : options.inverse) || emptyTemplate['default'];
+
+    if (utils.isStream(condition)) {
+      view.appendChild(BoundIfView['default'], {
+        _morph: options.morph,
+        _context: property_get.get(view, 'context'),
+        conditionStream: condition,
+        truthyTemplate: truthyTemplate,
+        falsyTemplate: falsyTemplate,
+        helperName: helperName
+      });
+    } else {
+      var template = condition ? truthyTemplate : falsyTemplate;
+      if (template) {
+        return template.render(view, env, options.morph.contextualElement);
       }
+    }
+  }
 
-      for (idx=0; idx<destroyQueue.length; idx++) {
-        view = destroyQueue[idx];
+  function appendInlineConditional(view, inverted, helperName, params) {
+    Ember['default'].assert(
+      "The inline form of the `if` and `unless` helpers expect two or " +
+      "three arguments, e.g. `{{if trialExpired 'Expired' expiryDate}}` " +
+      "or `{{unless isFirstLogin 'Welcome back!'}}`.",
+      params.length === 2 || params.length === 3
+    );
+
+    return conditional['default'](
+      shouldDisplay['default'](params[0]),
+      inverted ? params[2] : params[1],
+      inverted ? params[1] : params[2]
+    );
+  }
 
-        this.beforeRemove(destroyQueue[idx]);
+});
+enifed('ember-htmlbars/helpers/input', ['exports', 'ember-views/views/checkbox', 'ember-views/views/text_field', 'ember-metal/streams/utils', 'ember-metal/core'], function (exports, Checkbox, TextField, utils, Ember) {
 
-        childViews = view._childViews;
-        if (childViews) {
-          for (i=0,l=childViews.length; i<l; i++) {
-            destroyQueue.push(childViews[i]);
-          }
+  'use strict';
+
+  exports.inputHelper = inputHelper;
+
+  function inputHelper(params, hash, options, env) {
+    Ember['default'].assert('You can only pass attributes to the `input` helper, not arguments', params.length === 0);
+
+    var onEvent = hash.on;
+    var inputType;
+
+    inputType = utils.read(hash.type);
+
+    if (inputType === 'checkbox') {
+      delete hash.type;
+
+      Ember['default'].assert("{{input type='checkbox'}} does not support setting `value=someBooleanValue`;" +
+                   " you must use `checked=someBooleanValue` instead.", !hash.hasOwnProperty('value'));
+
+      env.helpers.view.helperFunction.call(this, [Checkbox['default']], hash, options, env);
+    } else {
+      delete hash.on;
+
+      hash.onEvent = onEvent || 'enter';
+      env.helpers.view.helperFunction.call(this, [TextField['default']], hash, options, env);
+    }
+  }
+
+});
+enifed('ember-htmlbars/helpers/loc', ['exports', 'ember-metal/core', 'ember-runtime/system/string', 'ember-metal/streams/utils'], function (exports, Ember, string, utils) {
+
+  'use strict';
+
+  exports.locHelper = locHelper;
+
+  function locHelper(params, hash, options, env) {
+    Ember['default'].assert('You cannot pass bindings to `loc` helper', (function ifParamsContainBindings() {
+      for (var i = 0, l = params.length; i < l; i++) {
+        if (utils.isStream(params[i])) {
+          return false;
         }
       }
+      return true;
+    })());
 
-      // destroy DOM from root insertion
-      if (morph && !reset) {
-        morph.destroy();
-      }
+    return string.loc.apply(env.data.view, params);
+  }
 
-      for (idx=0, len=removeQueue.length; idx < len; idx++) {
-        this.afterRemove(removeQueue[idx], false);
-      }
+});
+enifed('ember-htmlbars/helpers/log', ['exports', 'ember-metal/logger', 'ember-metal/streams/utils'], function (exports, Logger, utils) {
+
+  'use strict';
+
+  exports.logHelper = logHelper;
+
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+  function logHelper(params, hash, options, env) {
+    var logger = Logger['default'].log;
+    var values = [];
+
+    for (var i = 0; i < params.length; i++) {
+      values.push(utils.read(params[i]));
+    }
+
+    logger.apply(logger, values);
+  }
+
+});
+enifed('ember-htmlbars/helpers/partial', ['exports', 'ember-metal/property_get', 'ember-metal/streams/utils', 'ember-views/views/bound_partial_view', 'ember-views/system/lookup_partial'], function (exports, property_get, utils, BoundPartialView, lookupPartial) {
+
+  'use strict';
+
+  exports.partialHelper = partialHelper;
+
+  function partialHelper(params, hash, options, env) {
+    var view = env.data.view;
+    var templateName = params[0];
+
+    if (utils.isStream(templateName)) {
+      view.appendChild(BoundPartialView['default'], {
+        _morph: options.morph,
+        _context: property_get.get(view, 'context'),
+        templateNameStream: templateName,
+        helperName: options.helperName || 'partial'
+      });
+    } else {
+      var template = lookupPartial['default'](view, templateName);
+      return template.render(view, env, options.morph.contextualElement);
+    }
+  }
+
+});
+enifed('ember-htmlbars/helpers/template', ['exports', 'ember-metal/core'], function (exports, Ember) {
+
+  'use strict';
+
+  exports.templateHelper = templateHelper;
+
+  function templateHelper(params, hash, options, env) {
+    Ember['default'].deprecate(
+      "The `template` helper has been deprecated in favor of the `partial` helper." +
+      " Please use `partial` instead, which will work the same way."
+    );
+
+    options.helperName = options.helperName || 'template';
+
+    return env.helpers.partial.helperFunction.call(this, params, hash, options, env);
+  }
 
-      for (idx=0, len=destroyQueue.length; idx < len; idx++) {
-        this.afterRemove(destroyQueue[idx], true);
+});
+enifed('ember-htmlbars/helpers/text_area', ['exports', 'ember-metal/core', 'ember-views/views/text_area'], function (exports, Ember, TextArea) {
+
+  'use strict';
+
+  exports.textareaHelper = textareaHelper;
+
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+
+  function textareaHelper(params, hash, options, env) {
+    Ember['default'].assert('You can only pass attributes to the `textarea` helper, not arguments', params.length === 0);
+
+    return env.helpers.view.helperFunction.call(this, [TextArea['default']], hash, options, env);
+  }
+
+});
+enifed('ember-htmlbars/helpers/unbound', ['exports', 'ember-metal/error', 'ember-metal/mixin', 'ember-metal/streams/utils', 'ember-htmlbars/system/lookup-helper'], function (exports, EmberError, mixin, utils, lookupHelper) {
+
+  'use strict';
+
+  exports.unboundHelper = unboundHelper;
+
+  function unboundHelper(params, hash, options, env) {
+    Ember.assert(
+      "The `unbound` helper expects at least one argument, " +
+      "e.g. `{{unbound user.name}}`.",
+      params.length > 0
+    );
+
+    if (params.length === 1) {
+      return utils.read(params[0]);
+    } else {
+      options.helperName = options.helperName || 'unbound';
+
+      var view = env.data.view;
+      var helperName = params[0]._label;
+      var helper = lookupHelper['default'](helperName, view, env);
+
+      if (!helper) {
+        throw new EmberError['default']('HTMLBars error: Could not find component or helper named ' + helperName + '.');
       }
 
-      if (reset) {
-        _view._morph = morph;
+      return helper.helperFunction.call(this, readParams(params), readHash(hash, view), options, env);
+    }
+  }
+
+  function readParams(params) {
+    var l = params.length;
+    var unboundParams = new Array(l - 1);
+
+    for (var i = 1; i < l; i++) {
+      unboundParams[i-1] = utils.read(params[i]);
+    }
+
+    return unboundParams;
+  }
+
+  function readHash(hash, view) {
+    var unboundHash = {};
+
+    for (var prop in hash) {
+      if (mixin.IS_BINDING.test(prop)) {
+        var value = hash[prop];
+        if (typeof value === 'string') {
+          value = view.getStream(value);
+        }
+
+        unboundHash[prop.slice(0, -7)] = utils.read(value);
+      } else {
+        unboundHash[prop] = utils.read(hash[prop]);
       }
     }
 
-    function Renderer_insertElement(view, parentView, element, index) {
-      if (element === null || element === undefined) {
-        return;
+    return unboundHash;
+  }
+
+});
+enifed('ember-htmlbars/helpers/view', ['exports', 'ember-metal/core', 'ember-metal/streams/utils', 'ember-views/streams/utils', 'ember-views/views/view', 'ember-htmlbars/system/merge-view-bindings', 'ember-htmlbars/system/append-templated-view'], function (exports, Ember, utils, streams__utils, View, mergeViewBindings, appendTemplatedView) {
+
+  'use strict';
+
+  exports.viewHelper = viewHelper;
+
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+
+  function viewHelper(params, hash, options, env) {
+    Ember['default'].assert(
+      "The `view` helper expects zero or one arguments.",
+      params.length <= 2
+    );
+
+    var view = env.data.view;
+    var container = view.container || utils.read(view._keywords.view).container;
+    var viewClassOrInstance;
+    if (params.length === 0) {
+      if (container) {
+        viewClassOrInstance = container.lookupFactory('view:toplevel');
+      } else {
+        viewClassOrInstance = View['default'];
       }
+    } else {
+      viewClassOrInstance = streams__utils.readViewFactory(params[0], container);
+    }
+
+    var props = {
+      helperName: options.helperName || 'view'
+    };
+
+    if (options.template) {
+      props.template = options.template;
+    }
+
+    mergeViewBindings['default'](view, props, hash);
+    appendTemplatedView['default'](view, options.morph, viewClassOrInstance, props);
+  }
+
+});
+enifed('ember-htmlbars/helpers/with', ['exports', 'ember-metal/core', 'ember-views/views/with_view'], function (exports, Ember, WithView) {
+
+  'use strict';
+
+  exports.withHelper = withHelper;
+
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+
+  function withHelper(params, hash, options, env) {
+    Ember['default'].assert(
+      "{{#with foo}} must be called with a single argument or the use the " +
+      "{{#with foo as bar}} syntax",
+      params.length === 1
+    );
+
+    Ember['default'].assert(
+      "The {{#with}} helper must be called with a block",
+      !!options.template
+    );
+
+    var view = env.data.view;
+    var preserveContext;
+
+    if (options.template.blockParams) {
+      preserveContext = true;
+    } else {
+      Ember['default'].deprecate(
+        "Using the context switching form of `{{with}}` is deprecated. " +
+        "Please use the keyword form (`{{with foo as bar}}`) instead.",
+        false,
+        { url: 'http://emberjs.com/guides/deprecations/#toc_more-consistent-handlebars-scope' }
+      );
+      preserveContext = false;
+    }
+
+    view.appendChild(WithView['default'], {
+      _morph: options.morph,
+      withValue: params[0],
+      preserveContext: preserveContext,
+      previousContext: view.get('context'),
+      controllerName: hash.controller,
+      mainTemplate: options.template,
+      inverseTemplate: options.inverse,
+      helperName: options.helperName || 'with'
+    });
+  }
+
+});
+enifed('ember-htmlbars/helpers/yield', ['exports', 'ember-metal/core', 'ember-metal/property_get'], function (exports, Ember, property_get) {
+
+  'use strict';
+
+  exports.yieldHelper = yieldHelper;
+
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+
+  function yieldHelper(params, hash, options, env) {
+    var view = env.data.view;
+    var layoutView = view;
 
-      if (view._morph) {
-        view._morph.setContent(element);
-      } else if (parentView) {
-        if (index === -1) {
-          view._morph = parentView._childViewsMorph.append(element);
-        } else {
-          view._morph = parentView._childViewsMorph.insert(index, element);
-        }
+    // Yea gods
+    while (layoutView && !property_get.get(layoutView, 'layout')) {
+      if (layoutView._contextView) {
+        layoutView = layoutView._contextView;
+      } else {
+        layoutView = layoutView._parentView;
       }
     }
 
-    function Renderer_beforeRemove(view) {
-      if (view._elementCreated) {
-        this.willDestroyElement(view);
-      }
-      if (view._elementInserted) {
-        this.willRemoveElement(view);
-      }
-    }
+    Ember['default'].assert("You called yield in a template that was not a layout", !!layoutView);
 
-    function Renderer_afterRemove(view, shouldDestroy) {
-      view._elementInserted = false;
-      view._morph = null;
-      view._childViewsMorph = null;
-      if (view._elementCreated) {
-        view._elementCreated = false;
-        this.didDestroyElement(view);
-      }
-      if (shouldDestroy) {
-        this.destroyView(view);
-      }
-    }
+    return layoutView._yield(view, env, options.morph, params);
+  }
 
-    Renderer.prototype.remove = Renderer_remove;
-    Renderer.prototype.destroy = function (view) {
-      this.remove(view, true);
-    };
+});
+enifed('ember-htmlbars/hooks/attribute', ['exports', 'ember-views/attr_nodes/attr_node', 'ember-metal/error', 'ember-metal/streams/utils', 'morph-attr/sanitize-attribute-value'], function (exports, AttrNode, EmberError, utils, sanitizeAttributeValue) {
 
-    Renderer.prototype.renderTree = Renderer_renderTree;
-    Renderer.prototype.insertElement = Renderer_insertElement;
-    Renderer.prototype.beforeRemove = Renderer_beforeRemove;
-    Renderer.prototype.afterRemove = Renderer_afterRemove;
-
-    /// HOOKS
-    var noop = function () {};
-
-    Renderer.prototype.willCreateElement = noop; // inBuffer
-    Renderer.prototype.createElement = noop; // renderToBuffer or createElement
-    Renderer.prototype.didCreateElement = noop; // hasElement
-    Renderer.prototype.willInsertElement = noop; // will place into DOM
-    Renderer.prototype.didInsertElement = noop; // inDOM // placed into DOM
-    Renderer.prototype.willRemoveElement = noop; // removed from DOM  willDestroyElement currently paired with didInsertElement
-    Renderer.prototype.willDestroyElement = noop; // willClearRender (currently balanced with render) this is now paired with createElement
-    Renderer.prototype.didDestroyElement = noop; // element destroyed so view.destroy shouldn't try to remove it removedFromDOM
-    Renderer.prototype.destroyView = noop;
-    Renderer.prototype.childViews = noop;
-
-    __exports__["default"] = Renderer;
-  });
-enifed("ember-metal",
-  ["ember-metal/core","ember-metal/merge","ember-metal/instrumentation","ember-metal/utils","ember-metal/error","ember-metal/enumerable_utils","ember-metal/cache","ember-metal/platform","ember-metal/array","ember-metal/logger","ember-metal/property_get","ember-metal/events","ember-metal/observer_set","ember-metal/property_events","ember-metal/properties","ember-metal/property_set","ember-metal/map","ember-metal/get_properties","ember-metal/set_properties","ember-metal/watch_key","ember-metal/chains","ember-metal/watch_path","ember-metal/watching","ember-metal/expand_properties","ember-metal/computed","ember-metal/computed_macros","ember-metal/observer","ember-metal/mixin","ember-metal/binding","ember-metal/run_loop","ember-metal/libraries","ember-metal/is_none","ember-metal/is_empty","ember-metal/is_blank","ember-metal/is_present","ember-metal/keys","backburner","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __dependency21__, __dependency22__, __dependency23__, __dependency24__, __dependency25__, __dependency26__, __dependency27__, __dependency28__, __dependency29__, __dependency30__, __dependency31__, __dependency32__, __dependency33__, __dependency34__, __dependency35__, __dependency36__, __dependency37__, __exports__) {
-    "use strict";
-    /**
-    Ember Metal
+  'use strict';
 
-    @module ember
-    @submodule ember-metal
-    */
-
-    // BEGIN IMPORTS
-    var Ember = __dependency1__["default"];
-    var merge = __dependency2__["default"];
-    var instrument = __dependency3__.instrument;
-    var reset = __dependency3__.reset;
-    var subscribe = __dependency3__.subscribe;
-    var unsubscribe = __dependency3__.unsubscribe;
-    var EMPTY_META = __dependency4__.EMPTY_META;
-    var GUID_KEY = __dependency4__.GUID_KEY;
-    var META_DESC = __dependency4__.META_DESC;
-    var apply = __dependency4__.apply;
-    var applyStr = __dependency4__.applyStr;
-    var canInvoke = __dependency4__.canInvoke;
-    var generateGuid = __dependency4__.generateGuid;
-    var getMeta = __dependency4__.getMeta;
-    var guidFor = __dependency4__.guidFor;
-    var inspect = __dependency4__.inspect;
-    var isArray = __dependency4__.isArray;
-    var makeArray = __dependency4__.makeArray;
-    var meta = __dependency4__.meta;
-    var metaPath = __dependency4__.metaPath;
-    var setMeta = __dependency4__.setMeta;
-    var tryCatchFinally = __dependency4__.tryCatchFinally;
-    var tryFinally = __dependency4__.tryFinally;
-    var tryInvoke = __dependency4__.tryInvoke;
-    var typeOf = __dependency4__.typeOf;
-    var uuid = __dependency4__.uuid;
-    var wrap = __dependency4__.wrap;
-    var EmberError = __dependency5__["default"];
-    var EnumerableUtils = __dependency6__["default"];
-    var Cache = __dependency7__["default"];
-    var create = __dependency8__.create;
-    var hasPropertyAccessors = __dependency8__.hasPropertyAccessors;
-    var filter = __dependency9__.filter;
-    var forEach = __dependency9__.forEach;
-    var indexOf = __dependency9__.indexOf;
-    var map = __dependency9__.map;
-    var Logger = __dependency10__["default"];
-
-    var _getPath = __dependency11__._getPath;
-    var get = __dependency11__.get;
-    var getWithDefault = __dependency11__.getWithDefault;
-    var normalizeTuple = __dependency11__.normalizeTuple;
-
-    var accumulateListeners = __dependency12__.accumulateListeners;
-    var addListener = __dependency12__.addListener;
-    var hasListeners = __dependency12__.hasListeners;
-    var listenersFor = __dependency12__.listenersFor;
-    var on = __dependency12__.on;
-    var removeListener = __dependency12__.removeListener;
-    var sendEvent = __dependency12__.sendEvent;
-    var suspendListener = __dependency12__.suspendListener;
-    var suspendListeners = __dependency12__.suspendListeners;
-    var watchedEvents = __dependency12__.watchedEvents;
-
-    var ObserverSet = __dependency13__["default"];
-
-    var beginPropertyChanges = __dependency14__.beginPropertyChanges;
-    var changeProperties = __dependency14__.changeProperties;
-    var endPropertyChanges = __dependency14__.endPropertyChanges;
-    var overrideChains = __dependency14__.overrideChains;
-    var propertyDidChange = __dependency14__.propertyDidChange;
-    var propertyWillChange = __dependency14__.propertyWillChange;
-
-    var Descriptor = __dependency15__.Descriptor;
-    var defineProperty = __dependency15__.defineProperty;
-    var set = __dependency16__.set;
-    var trySet = __dependency16__.trySet;
-
-    var Map = __dependency17__.Map;
-    var MapWithDefault = __dependency17__.MapWithDefault;
-    var OrderedSet = __dependency17__.OrderedSet;
-    var getProperties = __dependency18__["default"];
-    var setProperties = __dependency19__["default"];
-    var watchKey = __dependency20__.watchKey;
-    var unwatchKey = __dependency20__.unwatchKey;
-    var ChainNode = __dependency21__.ChainNode;
-    var finishChains = __dependency21__.finishChains;
-    var flushPendingChains = __dependency21__.flushPendingChains;
-    var removeChainWatcher = __dependency21__.removeChainWatcher;
-    var watchPath = __dependency22__.watchPath;
-    var unwatchPath = __dependency22__.unwatchPath;
-    var destroy = __dependency23__.destroy;
-    var isWatching = __dependency23__.isWatching;
-    var rewatch = __dependency23__.rewatch;
-    var unwatch = __dependency23__.unwatch;
-    var watch = __dependency23__.watch;
-    var expandProperties = __dependency24__["default"];
-    var ComputedProperty = __dependency25__.ComputedProperty;
-    var computed = __dependency25__.computed;
-    var cacheFor = __dependency25__.cacheFor;
-
-    // side effect of defining the computed.* macros
-
-    var _suspendBeforeObserver = __dependency27__._suspendBeforeObserver;
-    var _suspendBeforeObservers = __dependency27__._suspendBeforeObservers;
-    var _suspendObserver = __dependency27__._suspendObserver;
-    var _suspendObservers = __dependency27__._suspendObservers;
-    var addBeforeObserver = __dependency27__.addBeforeObserver;
-    var addObserver = __dependency27__.addObserver;
-    var beforeObserversFor = __dependency27__.beforeObserversFor;
-    var observersFor = __dependency27__.observersFor;
-    var removeBeforeObserver = __dependency27__.removeBeforeObserver;
-    var removeObserver = __dependency27__.removeObserver;
-    var IS_BINDING = __dependency28__.IS_BINDING;
-    var Mixin = __dependency28__.Mixin;
-    var aliasMethod = __dependency28__.aliasMethod;
-    var beforeObserver = __dependency28__.beforeObserver;
-    var immediateObserver = __dependency28__.immediateObserver;
-    var mixin = __dependency28__.mixin;
-    var observer = __dependency28__.observer;
-    var required = __dependency28__.required;
-    var Binding = __dependency29__.Binding;
-    var bind = __dependency29__.bind;
-    var isGlobalPath = __dependency29__.isGlobalPath;
-    var oneWay = __dependency29__.oneWay;
-    var run = __dependency30__["default"];
-    var Libraries = __dependency31__["default"];
-    var isNone = __dependency32__["default"];
-    var isEmpty = __dependency33__["default"];
-    var isBlank = __dependency34__["default"];
-    var isPresent = __dependency35__["default"];
-    var keys = __dependency36__["default"];
-    var Backburner = __dependency37__["default"];
-
-    // END IMPORTS
-
-    // BEGIN EXPORTS
-    var EmberInstrumentation = Ember.Instrumentation = {};
-    EmberInstrumentation.instrument = instrument;
-    EmberInstrumentation.subscribe = subscribe;
-    EmberInstrumentation.unsubscribe = unsubscribe;
-    EmberInstrumentation.reset  = reset;
-
-    Ember.instrument = instrument;
-    Ember.subscribe = subscribe;
-
-    Ember._Cache = Cache;
-
-    Ember.generateGuid    = generateGuid;
-    Ember.GUID_KEY        = GUID_KEY;
-    Ember.create          = create;
-    Ember.keys            = keys;
-    Ember.platform        = {
-      defineProperty: defineProperty,
-      hasPropertyAccessors: hasPropertyAccessors
-    };
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-    var EmberArrayPolyfills = Ember.ArrayPolyfills = {};
-
-    EmberArrayPolyfills.map = map;
-    EmberArrayPolyfills.forEach = forEach;
-    EmberArrayPolyfills.filter = filter;
-    EmberArrayPolyfills.indexOf = indexOf;
-
-    Ember.Error           = EmberError;
-    Ember.guidFor         = guidFor;
-    Ember.META_DESC       = META_DESC;
-    Ember.EMPTY_META      = EMPTY_META;
-    Ember.meta            = meta;
-    Ember.getMeta         = getMeta;
-    Ember.setMeta         = setMeta;
-    Ember.metaPath        = metaPath;
-    Ember.inspect         = inspect;
-    Ember.typeOf          = typeOf;
-    Ember.tryCatchFinally = tryCatchFinally;
-    Ember.isArray         = isArray;
-    Ember.makeArray       = makeArray;
-    Ember.canInvoke       = canInvoke;
-    Ember.tryInvoke       = tryInvoke;
-    Ember.tryFinally      = tryFinally;
-    Ember.wrap            = wrap;
-    Ember.apply           = apply;
-    Ember.applyStr        = applyStr;
-    Ember.uuid            = uuid;
-
-    Ember.Logger = Logger;
-
-    Ember.get            = get;
-    Ember.getWithDefault = getWithDefault;
-    Ember.normalizeTuple = normalizeTuple;
-    Ember._getPath       = _getPath;
-
-    Ember.EnumerableUtils = EnumerableUtils;
-
-    Ember.on                  = on;
-    Ember.addListener         = addListener;
-    Ember.removeListener      = removeListener;
-    Ember._suspendListener    = suspendListener;
-    Ember._suspendListeners   = suspendListeners;
-    Ember.sendEvent           = sendEvent;
-    Ember.hasListeners        = hasListeners;
-    Ember.watchedEvents       = watchedEvents;
-    Ember.listenersFor        = listenersFor;
-    Ember.accumulateListeners = accumulateListeners;
-
-    Ember._ObserverSet = ObserverSet;
-
-    Ember.propertyWillChange = propertyWillChange;
-    Ember.propertyDidChange = propertyDidChange;
-    Ember.overrideChains = overrideChains;
-    Ember.beginPropertyChanges = beginPropertyChanges;
-    Ember.endPropertyChanges = endPropertyChanges;
-    Ember.changeProperties = changeProperties;
-
-    Ember.Descriptor     = Descriptor;
-    Ember.defineProperty = defineProperty;
-
-    Ember.set    = set;
-    Ember.trySet = trySet;
-
-    Ember.OrderedSet = OrderedSet;
-    Ember.Map = Map;
-    Ember.MapWithDefault = MapWithDefault;
-
-    Ember.getProperties = getProperties;
-    Ember.setProperties = setProperties;
-
-    Ember.watchKey   = watchKey;
-    Ember.unwatchKey = unwatchKey;
-
-    Ember.flushPendingChains = flushPendingChains;
-    Ember.removeChainWatcher = removeChainWatcher;
-    Ember._ChainNode = ChainNode;
-    Ember.finishChains = finishChains;
-
-    Ember.watchPath = watchPath;
-    Ember.unwatchPath = unwatchPath;
-
-    Ember.watch = watch;
-    Ember.isWatching = isWatching;
-    Ember.unwatch = unwatch;
-    Ember.rewatch = rewatch;
-    Ember.destroy = destroy;
-
-    Ember.expandProperties = expandProperties;
-
-    Ember.ComputedProperty = ComputedProperty;
-    Ember.computed = computed;
-    Ember.cacheFor = cacheFor;
-
-    Ember.addObserver = addObserver;
-    Ember.observersFor = observersFor;
-    Ember.removeObserver = removeObserver;
-    Ember.addBeforeObserver = addBeforeObserver;
-    Ember._suspendBeforeObserver = _suspendBeforeObserver;
-    Ember._suspendBeforeObservers = _suspendBeforeObservers;
-    Ember._suspendObserver = _suspendObserver;
-    Ember._suspendObservers = _suspendObservers;
-    Ember.beforeObserversFor = beforeObserversFor;
-    Ember.removeBeforeObserver = removeBeforeObserver;
-
-    Ember.IS_BINDING = IS_BINDING;
-    Ember.required = required;
-    Ember.aliasMethod = aliasMethod;
-    Ember.observer = observer;
-    Ember.immediateObserver = immediateObserver;
-    Ember.beforeObserver = beforeObserver;
-    Ember.mixin = mixin;
-    Ember.Mixin = Mixin;
-
-    Ember.oneWay = oneWay;
-    Ember.bind = bind;
-    Ember.Binding = Binding;
-    Ember.isGlobalPath = isGlobalPath;
-
-    Ember.run = run;
-
-    /**
-     * @class Backburner
-     * @for Ember
-     * @private
-    */
-    Ember.Backburner = Backburner;
+  var boundAttributesEnabled = false;
 
-    Ember.libraries = new Libraries();
-    Ember.libraries.registerCoreLibrary('Ember', Ember.VERSION);
 
-    Ember.isNone = isNone;
-    Ember.isEmpty = isEmpty;
-    Ember.isBlank = isBlank;
+    boundAttributesEnabled = true;
 
-    
-      Ember.isPresent = isPresent;
-    
 
-    Ember.merge = merge;
+  function attribute(env, morph, element, attrName, attrValue) {
+    if (boundAttributesEnabled) {
+      var attrNode = new AttrNode['default'](attrName, attrValue);
+      attrNode._morph = morph;
+      env.data.view.appendChild(attrNode);
+    } else {
+      if (utils.isStream(attrValue)) {
+        throw new EmberError['default']('Bound attributes are not yet supported in Ember.js');
+      } else {
+        var sanitizedValue = sanitizeAttributeValue['default'](env.dom, element, attrName, attrValue);
+        env.dom.setProperty(element, attrName, sanitizedValue);
+      }
+    }
+  }
+  exports['default'] = attribute;
 
-    /**
-      A function may be assigned to `Ember.onerror` to be called when Ember
-      internals encounter an error. This is useful for specialized error handling
-      and reporting code.
+});
+enifed('ember-htmlbars/hooks/block', ['exports', 'ember-views/views/simple_bound_view', 'ember-metal/streams/utils', 'ember-htmlbars/system/lookup-helper'], function (exports, simple_bound_view, utils, lookupHelper) {
 
-      ```javascript
-      Ember.onerror = function(error) {
-        Em.$.ajax('/report-error', 'POST', {
-          stack: error.stack,
-          otherInformation: 'whatever app state you want to provide'
-        });
-      };
-      ```
+  'use strict';
 
-      Internally, `Ember.onerror` is used as Backburner's error handler.
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-      @event onerror
-      @for Ember
-      @param {Exception} error the error object
-    */
-    Ember.onerror = null;
-    // END EXPORTS
+  function block(env, morph, view, path, params, hash, template, inverse) {
+    var helper = lookupHelper['default'](path, view, env);
 
-    // do this for side-effects of updating Ember.assert, warn, etc when
-    // ember-debug is present
-    if (Ember.__loader.registry['ember-debug']) {
-      requireModule('ember-debug');
-    }
+    Ember.assert("A helper named `"+path+"` could not be found", helper);
 
-    __exports__["default"] = Ember;
-  });
-enifed("ember-metal/alias",
-  ["ember-metal/property_get","ember-metal/property_set","ember-metal/core","ember-metal/error","ember-metal/properties","ember-metal/computed","ember-metal/platform","ember-metal/utils","ember-metal/dependent_keys","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __exports__) {
-    "use strict";
-    var get = __dependency1__.get;
-    var set = __dependency2__.set;
-    var Ember = __dependency3__["default"];
-    // Ember.assert
-    var EmberError = __dependency4__["default"];
-    var Descriptor = __dependency5__.Descriptor;
-    var defineProperty = __dependency5__.defineProperty;
-    var ComputedProperty = __dependency6__.ComputedProperty;
-    var create = __dependency7__.create;
-    var meta = __dependency8__.meta;
-    var inspect = __dependency8__.inspect;
-    var addDependentKeys = __dependency9__.addDependentKeys;
-    var removeDependentKeys = __dependency9__.removeDependentKeys;
+    var options = {
+      morph: morph,
+      template: template,
+      inverse: inverse,
+      isBlock: true
+    };
+    var result = helper.helperFunction.call(undefined, params, hash, options, env);
 
-    __exports__["default"] = function alias(altKey) {
-      return new AliasedProperty(altKey);
+    if (utils.isStream(result)) {
+      simple_bound_view.appendSimpleBoundView(view, morph, result);
+    } else {
+      morph.setContent(result);
     }
+  }
+  exports['default'] = block;
 
-    function AliasedProperty(altKey) {
-      this.altKey = altKey;
-      this._dependentKeys = [ altKey ];
-    }
+});
+enifed('ember-htmlbars/hooks/component', ['exports', 'ember-metal/core', 'ember-htmlbars/system/lookup-helper'], function (exports, Ember, lookupHelper) {
 
-    __exports__.AliasedProperty = AliasedProperty;AliasedProperty.prototype = create(Descriptor.prototype);
+  'use strict';
 
-    AliasedProperty.prototype.get = function AliasedProperty_get(obj, keyName) {
-      return get(obj, this.altKey);
-    };
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-    AliasedProperty.prototype.set = function AliasedProperty_set(obj, keyName, value) {
-      return set(obj, this.altKey, value);
-    };
+  function component(env, morph, view, tagName, attrs, template) {
+    var helper = lookupHelper['default'](tagName, view, env);
 
-    AliasedProperty.prototype.willWatch = function(obj, keyName) {
-      addDependentKeys(this, obj, keyName, meta(obj));
-    };
+    Ember['default'].assert('You specified `' + tagName + '` in your template, but a component for `' + tagName + '` could not be found.', !!helper);
 
-    AliasedProperty.prototype.didUnwatch = function(obj, keyName) {
-      removeDependentKeys(this, obj, keyName, meta(obj));
-    };
+    return helper.helperFunction.call(undefined, [], attrs, { morph: morph, template: template }, env);
+  }
+  exports['default'] = component;
 
-    AliasedProperty.prototype.setup = function(obj, keyName) {
-      Ember.assert("Setting alias '" + keyName + "' on self", this.altKey !== keyName);
-      var m = meta(obj);
-      if (m.watching[keyName]) {
-        addDependentKeys(this, obj, keyName, m);
-      }
-    };
+});
+enifed('ember-htmlbars/hooks/concat', ['exports', 'ember-metal/streams/utils'], function (exports, utils) {
 
-    AliasedProperty.prototype.teardown = function(obj, keyName) {
-      var m = meta(obj);
-      if (m.watching[keyName]) {
-        removeDependentKeys(this, obj, keyName, m);
-      }
-    };
+  'use strict';
 
-    AliasedProperty.prototype.readOnly = function() {
-      this.set = AliasedProperty_readOnlySet;
-      return this;
-    };
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-    function AliasedProperty_readOnlySet(obj, keyName, value) {
-      throw new EmberError('Cannot set read-only property "' + keyName + '" on object: ' + inspect(obj));
-    }
+  function concat(env, parts) {
+    return utils.concat(parts, '');
+  }
+  exports['default'] = concat;
 
-    AliasedProperty.prototype.oneWay = function() {
-      this.set = AliasedProperty_oneWaySet;
-      return this;
-    };
+});
+enifed('ember-htmlbars/hooks/content', ['exports', 'ember-views/views/simple_bound_view', 'ember-metal/streams/utils', 'ember-htmlbars/system/lookup-helper'], function (exports, simple_bound_view, utils, lookupHelper) {
 
-    function AliasedProperty_oneWaySet(obj, keyName, value) {
-      defineProperty(obj, keyName, null);
-      return set(obj, keyName, value);
-    }
+  'use strict';
 
-    // Backwards compatibility with Ember Data
-    AliasedProperty.prototype._meta = undefined;
-    AliasedProperty.prototype.meta = ComputedProperty.prototype.meta;
-  });
-enifed("ember-metal/array",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember-metal
-    */
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-    var ArrayPrototype = Array.prototype;
+  function content(env, morph, view, path) {
+    var helper = lookupHelper['default'](path, view, env);
+    var result;
 
-    // Testing this is not ideal, but we want to use native functions
-    // if available, but not to use versions created by libraries like Prototype
-    var isNativeFunc = function(func) {
-      // This should probably work in all browsers likely to have ES5 array methods
-      return func && Function.prototype.toString.call(func).indexOf('[native code]') > -1;
-    };
+    if (helper) {
+      var options = {
+        morph: morph,
+        isInline: true
+      };
+      result = helper.helperFunction.call(undefined, [], {}, options, env);
+    } else {
+      result = view.getStream(path);
+    }
 
-    var defineNativeShim = function(nativeFunc, shim) {
-      if (isNativeFunc(nativeFunc)) {
-        return nativeFunc;
-      }
-      return shim;
-    };
+    if (utils.isStream(result)) {
+      simple_bound_view.appendSimpleBoundView(view, morph, result);
+    } else {
+      morph.setContent(result);
+    }
+  }
+  exports['default'] = content;
 
-    // From: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/map
-    var map = defineNativeShim(ArrayPrototype.map, function(fun /*, thisp */) {
-      //"use strict";
+});
+enifed('ember-htmlbars/hooks/element', ['exports', 'ember-metal/core', 'ember-metal/streams/utils', 'ember-htmlbars/system/lookup-helper'], function (exports, Ember, utils, lookupHelper) {
 
-      if (this === void 0 || this === null || typeof fun !== "function") {
-        throw new TypeError();
-      }
+  'use strict';
 
-      var t = Object(this);
-      var len = t.length >>> 0;
-      var res = new Array(len);
-      var thisp = arguments[1];
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-      for (var i = 0; i < len; i++) {
-        if (i in t) {
-          res[i] = fun.call(thisp, t[i], i, t);
-        }
-      }
+  function element(env, domElement, view, path, params, hash) { //jshint ignore:line
+    var helper = lookupHelper['default'](path, view, env);
+    var valueOrLazyValue;
 
-      return res;
-    });
+    if (helper) {
+      var options = {
+        element: domElement
+      };
+      valueOrLazyValue = helper.helperFunction.call(undefined, params, hash, options, env);
+    } else {
+      valueOrLazyValue = view.getStream(path);
+    }
 
-    // From: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/foreach
-    var forEach = defineNativeShim(ArrayPrototype.forEach, function(fun /*, thisp */) {
-      //"use strict";
+    var value = utils.read(valueOrLazyValue);
+    if (value) {
+      Ember['default'].deprecate('Returning a string of attributes from a helper inside an element is deprecated.');
 
-      if (this === void 0 || this === null || typeof fun !== "function") {
-        throw new TypeError();
-      }
+      var parts = value.toString().split(/\s+/);
+      for (var i = 0, l = parts.length; i < l; i++) {
+        var attrParts = parts[i].split('=');
+        var attrName = attrParts[0];
+        var attrValue = attrParts[1];
 
-      var t = Object(this);
-      var len = t.length >>> 0;
-      var thisp = arguments[1];
+        attrValue = attrValue.replace(/^['"]/, '').replace(/['"]$/, '');
 
-      for (var i = 0; i < len; i++) {
-        if (i in t) {
-          fun.call(thisp, t[i], i, t);
-        }
+        env.dom.setAttribute(domElement, attrName, attrValue);
       }
-    });
+    }
+  }
+  exports['default'] = element;
 
-    var indexOf = defineNativeShim(ArrayPrototype.indexOf, function (obj, fromIndex) {
-      if (fromIndex === null || fromIndex === undefined) {
-        fromIndex = 0;
-      }
-      else if (fromIndex < 0) {
-        fromIndex = Math.max(0, this.length + fromIndex);
-      }
+});
+enifed('ember-htmlbars/hooks/get', ['exports'], function (exports) {
 
-      for (var i = fromIndex, j = this.length; i < j; i++) {
-        if (this[i] === obj) {
-          return i;
-        }
-      }
-      return -1;
-    });
+  'use strict';
 
-    var lastIndexOf = defineNativeShim(ArrayPrototype.lastIndexOf, function(obj, fromIndex) {
-        var len = this.length;
-        var idx;
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-        if (fromIndex === undefined) fromIndex = len-1;
-        else fromIndex = (fromIndex < 0) ? Math.ceil(fromIndex) : Math.floor(fromIndex);
-        if (fromIndex < 0) fromIndex += len;
+  function get(env, view, path) {
+    return view.getStream(path);
+  }
+  exports['default'] = get;
 
-        for(idx = fromIndex;idx>=0;idx--) {
-          if (this[idx] === obj) return idx ;
-        }
-        return -1;
-    });
+});
+enifed('ember-htmlbars/hooks/inline', ['exports', 'ember-views/views/simple_bound_view', 'ember-metal/streams/utils', 'ember-htmlbars/system/lookup-helper'], function (exports, simple_bound_view, utils, lookupHelper) {
 
-    var filter = defineNativeShim(ArrayPrototype.filter, function (fn, context) {
-      var i, value;
-      var result = [];
-      var length = this.length;
+  'use strict';
 
-      for (i = 0; i < length; i++) {
-        if (this.hasOwnProperty(i)) {
-          value = this[i];
-          if (fn.call(context, value, i, this)) {
-            result.push(value);
-          }
-        }
-      }
-      return result;
-    });
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+
+  function inline(env, morph, view, path, params, hash) {
+    var helper = lookupHelper['default'](path, view, env);
 
-    if (Ember.SHIM_ES5) {
-      ArrayPrototype.map = ArrayPrototype.map || map;
-      ArrayPrototype.forEach = ArrayPrototype.forEach || forEach;
-      ArrayPrototype.filter = ArrayPrototype.filter || filter;
-      ArrayPrototype.indexOf = ArrayPrototype.indexOf || indexOf;
-      ArrayPrototype.lastIndexOf = ArrayPrototype.lastIndexOf || lastIndexOf;
+    Ember.assert("A helper named '"+path+"' could not be found", helper);
+
+    var result = helper.helperFunction.call(undefined, params, hash, { morph: morph }, env);
+
+    if (utils.isStream(result)) {
+      simple_bound_view.appendSimpleBoundView(view, morph, result);
+    } else {
+      morph.setContent(result);
     }
+  }
+  exports['default'] = inline;
 
-    /**
-      Array polyfills to support ES5 features in older browsers.
+});
+enifed('ember-htmlbars/hooks/set', ['exports'], function (exports) {
 
-      @namespace Ember
-      @property ArrayPolyfills
-    */
-    __exports__.map = map;
-    __exports__.forEach = forEach;
-    __exports__.filter = filter;
-    __exports__.indexOf = indexOf;
-    __exports__.lastIndexOf = lastIndexOf;
-  });
-enifed("ember-metal/binding",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/observer","ember-metal/run_loop","ember-metal/path_cache","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.Logger, Ember.LOG_BINDINGS, assert
-    var get = __dependency2__.get;
-    var trySet = __dependency3__.trySet;
-    var guidFor = __dependency4__.guidFor;
-    var addObserver = __dependency5__.addObserver;
-    var removeObserver = __dependency5__.removeObserver;
-    var _suspendObserver = __dependency5__._suspendObserver;
-    var run = __dependency6__["default"];
-    var isGlobalPath = __dependency7__.isGlobal;
+  'use strict';
 
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-    // ES6TODO: where is Ember.lookup defined?
-    /**
-    @module ember-metal
-    */
+  function set(env, view, name, value) {
+    view._keywords[name] = value;
+  }
+  exports['default'] = set;
 
-    // ..........................................................
-    // CONSTANTS
-    //
+});
+enifed('ember-htmlbars/hooks/subexpr', ['exports', 'ember-htmlbars/system/lookup-helper'], function (exports, lookupHelper) {
 
-    /**
-      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
-      can also enable this from the console or temporarily.
+  'use strict';
 
-      @property LOG_BINDINGS
-      @for Ember
-      @type Boolean
-      @default false
-    */
-    Ember.LOG_BINDINGS = false || !!Ember.ENV.LOG_BINDINGS;
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-    /**
-      Returns true if the provided path is global (e.g., `MyApp.fooController.bar`)
-      instead of local (`foo.bar.baz`).
+  function subexpr(env, view, path, params, hash) {
+    var helper = lookupHelper['default'](path, view, env);
 
-      @method isGlobalPath
-      @for Ember
-      @private
-      @param {String} path
-      @return Boolean
-    */
+    Ember.assert("A helper named '"+path+"' could not be found", helper);
 
-    function getWithGlobals(obj, path) {
-      return get(isGlobalPath(path) ? Ember.lookup : obj, path);
-    }
+    var options = {
+      isInline: true
+    };
+    return helper.helperFunction.call(undefined, params, hash, options, env);
+  }
+  exports['default'] = subexpr;
 
-    // ..........................................................
-    // BINDING
-    //
+});
+enifed('ember-htmlbars/system/append-templated-view', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-views/views/view'], function (exports, Ember, property_get, View) {
 
-    function Binding(toPath, fromPath) {
-      this._direction = undefined;
-      this._from = fromPath;
-      this._to   = toPath;
-      this._readyToSync = undefined;
-      this._oneWay = undefined;
-    }
+  'use strict';
 
-    /**
-    @class Binding
-    @namespace Ember
-    */
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-    Binding.prototype = {
-      /**
-        This copies the Binding so it can be connected to another object.
+  function appendTemplatedView(parentView, morph, viewClassOrInstance, props) {
+    var viewProto;
+    if (View['default'].detectInstance(viewClassOrInstance)) {
+      viewProto = viewClassOrInstance;
+    } else {
+      viewProto = viewClassOrInstance.proto();
+    }
 
-        @method copy
-        @return {Ember.Binding} `this`
-      */
-      copy: function () {
-        var copy = new Binding(this._to, this._from);
-        if (this._oneWay) { copy._oneWay = true; }
-        return copy;
-      },
+    Ember['default'].assert(
+      "You cannot provide a template block if you also specified a templateName",
+      !props.template || (!property_get.get(props, 'templateName') && !property_get.get(viewProto, 'templateName'))
+    );
 
-      // ..........................................................
-      // CONFIG
-      //
+    // We only want to override the `_context` computed property if there is
+    // no specified controller. See View#_context for more information.
 
-      /**
-        This will set `from` property path to the specified value. It will not
-        attempt to resolve this property path to an actual object until you
-        connect the binding.
+    var noControllerInProto = !viewProto.controller;
+    if (viewProto.controller && viewProto.controller.isDescriptor) { noControllerInProto = true; }
+    if (noControllerInProto &&
+        !viewProto.controllerBinding &&
+        !props.controller &&
+        !props.controllerBinding) {
+      props._context = property_get.get(parentView, 'context'); // TODO: is this right?!
+    }
 
-        The binding will search for the property path starting at the root object
-        you pass when you `connect()` the binding. It follows the same rules as
-        `get()` - see that method for more information.
+    props._morph = morph;
 
-        @method from
-        @param {String} path the property path to connect to
-        @return {Ember.Binding} `this`
-      */
-      from: function(path) {
-        this._from = path;
-        return this;
-      },
+    return parentView.appendChild(viewClassOrInstance, props);
+  }
+  exports['default'] = appendTemplatedView;
 
-      /**
-        This will set the `to` property path to the specified value. It will not
-        attempt to resolve this property path to an actual object until you
-        connect the binding.
+});
+enifed('ember-htmlbars/system/bootstrap', ['exports', 'ember-metal/core', 'ember-views/component_lookup', 'ember-views/system/jquery', 'ember-metal/error', 'ember-runtime/system/lazy_load', 'ember-template-compiler/system/compile', 'ember-metal/environment'], function (exports, Ember, ComponentLookup, jQuery, EmberError, lazy_load, htmlbarsCompile, environment) {
 
-        The binding will search for the property path starting at the root object
-        you pass when you `connect()` the binding. It follows the same rules as
-        `get()` - see that method for more information.
+  'use strict';
 
-        @method to
-        @param {String|Tuple} path A property path or tuple
-        @return {Ember.Binding} `this`
-      */
-      to: function(path) {
-        this._to = path;
-        return this;
-      },
+  /*globals Handlebars */
 
-      /**
-        Configures the binding as one way. A one-way binding will relay changes
-        on the `from` side to the `to` side, but not the other way around. This
-        means that if you change the `to` side directly, the `from` side may have
-        a different value.
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-        @method oneWay
-        @return {Ember.Binding} `this`
-      */
-      oneWay: function() {
-        this._oneWay = true;
-        return this;
-      },
+  function bootstrap(ctx) {
+    var selectors = 'script[type="text/x-handlebars"], script[type="text/x-raw-handlebars"]';
 
-      /**
-        @method toString
-        @return {String} string representation of binding
-      */
-      toString: function() {
-        var oneWay = this._oneWay ? '[oneWay]' : '';
-        return "Ember.Binding<" + guidFor(this) + ">(" + this._from + " -> " + this._to + ")" + oneWay;
-      },
+    jQuery['default'](selectors, ctx)
+      .each(function() {
+      // Get a reference to the script tag
+      var script = jQuery['default'](this);
 
-      // ..........................................................
-      // CONNECT AND SYNC
-      //
+      var compile = (script.attr('type') === 'text/x-raw-handlebars') ?
+                    jQuery['default'].proxy(Handlebars.compile, Handlebars) :
+                    htmlbarsCompile['default'];
+      // Get the name of the script, used by Ember.View's templateName property.
+      // First look for data-template-name attribute, then fall back to its
+      // id if no name is found.
+      var templateName = script.attr('data-template-name') || script.attr('id') || 'application';
+      var template = compile(script.html());
 
-      /**
-        Attempts to connect this binding instance so that it can receive and relay
-        changes. This method will raise an exception if you have not set the
-        from/to properties yet.
+      // Check if template of same name already exists
+      if (Ember['default'].TEMPLATES[templateName] !== undefined) {
+        throw new EmberError['default']('Template named "' + templateName  + '" already exists.');
+      }
 
-        @method connect
-        @param {Object} obj The root object for this binding.
-        @return {Ember.Binding} `this`
-      */
-      connect: function(obj) {
-        Ember.assert('Must pass a valid object to Ember.Binding.connect()', !!obj);
+      // For templates which have a name, we save them and then remove them from the DOM
+      Ember['default'].TEMPLATES[templateName] = template;
 
-        var fromPath = this._from;
-        var toPath = this._to;
-        trySet(obj, toPath, getWithGlobals(obj, fromPath));
+      // Remove script tag from DOM
+      script.remove();
+    });
+  }
 
-        // add an observer on the object to be notified when the binding should be updated
-        addObserver(obj, fromPath, this, this.fromDidChange);
+  function _bootstrap() {
+    bootstrap(jQuery['default'](document));
+  }
 
-        // if the binding is a two-way binding, also set up an observer on the target
-        if (!this._oneWay) {
-          addObserver(obj, toPath, this, this.toDidChange);
-        }
+  function registerComponentLookup(registry) {
+    registry.register('component-lookup:main', ComponentLookup['default']);
+  }
 
-        this._readyToSync = true;
+  /*
+    We tie this to application.load to ensure that we've at least
+    attempted to bootstrap at the point that the application is loaded.
 
-        return this;
-      },
+    We also tie this to document ready since we're guaranteed that all
+    the inline templates are present at this point.
 
-      /**
-        Disconnects the binding instance. Changes will no longer be relayed. You
-        will not usually need to call this method.
+    There's no harm to running this twice, since we remove the templates
+    from the DOM after processing.
+  */
 
-        @method disconnect
-        @param {Object} obj The root object you passed when connecting the binding.
-        @return {Ember.Binding} `this`
-      */
-      disconnect: function(obj) {
-        Ember.assert('Must pass a valid object to Ember.Binding.disconnect()', !!obj);
+  lazy_load.onLoad('Ember.Application', function(Application) {
+    Application.initializer({
+      name: 'domTemplates',
+      initialize: environment['default'].hasDOM ? _bootstrap : function() { }
+    });
 
-        var twoWay = !this._oneWay;
+    Application.initializer({
+      name: 'registerComponentLookup',
+      after: 'domTemplates',
+      initialize: registerComponentLookup
+    });
+  });
 
-        // remove an observer on the object so we're no longer notified of
-        // changes that should update bindings.
-        removeObserver(obj, this._from, this, this.fromDidChange);
+  exports['default'] = bootstrap;
 
-        // if the binding is two-way, remove the observer from the target as well
-        if (twoWay) {
-          removeObserver(obj, this._to, this, this.toDidChange);
-        }
+});
+enifed('ember-htmlbars/system/helper', ['exports'], function (exports) {
 
-        this._readyToSync = false; // disable scheduled syncs...
-        return this;
-      },
+  'use strict';
 
-      // ..........................................................
-      // PRIVATE
-      //
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-      /* called when the from side changes */
-      fromDidChange: function(target) {
-        this._scheduleSync(target, 'fwd');
-      },
+  /**
+    @class Helper
+    @namespace Ember.HTMLBars
+  */
+  function Helper(helper) {
+    this.helperFunction = helper;
 
-      /* called when the to side changes */
-      toDidChange: function(target) {
-        this._scheduleSync(target, 'back');
-      },
+    this.isHelper = true;
+    this.isHTMLBars = true;
+  }
 
-      _scheduleSync: function(obj, dir) {
-        var existingDir = this._direction;
+  exports['default'] = Helper;
 
-        // if we haven't scheduled the binding yet, schedule it
-        if (existingDir === undefined) {
-          run.schedule('sync', this, this._sync, obj);
-          this._direction  = dir;
-        }
+});
+enifed('ember-htmlbars/system/lookup-helper', ['exports', 'ember-metal/core', 'ember-metal/cache', 'ember-htmlbars/system/make-view-helper', 'ember-htmlbars/compat/helper'], function (exports, Ember, Cache, makeViewHelper, HandlebarsCompatibleHelper) {
 
-        // If both a 'back' and 'fwd' sync have been scheduled on the same object,
-        // default to a 'fwd' sync so that it remains deterministic.
-        if (existingDir === 'back' && dir === 'fwd') {
-          this._direction = 'fwd';
-        }
-      },
+  'use strict';
 
-      _sync: function(obj) {
-        var log = Ember.LOG_BINDINGS;
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-        // don't synchronize destroyed objects or disconnected bindings
-        if (obj.isDestroyed || !this._readyToSync) { return; }
+  var ISNT_HELPER_CACHE = new Cache['default'](1000, function(key) {
+    return key.indexOf('-') === -1;
+  });
 
-        // get the direction of the binding for the object we are
-        // synchronizing from
-        var direction = this._direction;
+  /**
+    Used to lookup/resolve handlebars helpers. The lookup order is:
 
-        var fromPath = this._from;
-        var toPath = this._to;
+    * Look for a registered helper
+    * If a dash exists in the name:
+      * Look for a helper registed in the container
+      * Use Ember.ComponentLookup to find an Ember.Component that resolves
+        to the given name
 
-        this._direction = undefined;
+    @private
+    @method resolveHelper
+    @param {Container} container
+    @param {String} name the name of the helper to lookup
+    @return {Handlebars Helper}
+  */
+  function lookupHelper(name, view, env) {
+    var helper = env.helpers[name];
+    if (helper) {
+      return helper;
+    }
 
-        // if we're synchronizing from the remote object...
-        if (direction === 'fwd') {
-          var fromValue = getWithGlobals(obj, this._from);
-          if (log) {
-            Ember.Logger.log(' ', this.toString(), '->', fromValue, obj);
-          }
-          if (this._oneWay) {
-            trySet(obj, toPath, fromValue);
-          } else {
-            _suspendObserver(obj, toPath, this, this.toDidChange, function () {
-              trySet(obj, toPath, fromValue);
-            });
-          }
-        // if we're synchronizing *to* the remote object
-        } else if (direction === 'back') {
-          var toValue = get(obj, this._to);
-          if (log) {
-            Ember.Logger.log(' ', this.toString(), '<-', toValue, obj);
-          }
-          _suspendObserver(obj, fromPath, this, this.fromDidChange, function () {
-            trySet(isGlobalPath(fromPath) ? Ember.lookup : obj, fromPath, toValue);
-          });
-        }
-      }
+    var container = view.container;
 
-    };
+    if (!container || ISNT_HELPER_CACHE.get(name)) {
+      return;
+    }
 
-    function mixinProperties(to, from) {
-      for (var key in from) {
-        if (from.hasOwnProperty(key)) {
-          to[key] = from[key];
-        }
+    var helperName = 'helper:' + name;
+    helper = container.lookup(helperName);
+    if (!helper) {
+      var componentLookup = container.lookup('component-lookup:main');
+      Ember['default'].assert("Could not find 'component-lookup:main' on the provided container," +
+                   " which is necessary for performing component lookups", componentLookup);
+
+      var Component = componentLookup.lookupFactory(name, container);
+      if (Component) {
+        helper = makeViewHelper['default'](Component);
+        container._registry.register(helperName, helper);
       }
     }
 
-    mixinProperties(Binding, {
+    if (helper && !helper.isHTMLBars) {
+      helper = new HandlebarsCompatibleHelper['default'](helper);
+      container._registry.unregister(helperName);
+      container._registry.register(helperName, helper);
+    }
 
-      /*
-        See `Ember.Binding.from`.
+    return helper;
+  }
+  exports['default'] = lookupHelper;
 
-        @method from
-        @static
-      */
-      from: function(from) {
-        var C = this;
-        return new C(undefined, from);
-      },
+  exports.ISNT_HELPER_CACHE = ISNT_HELPER_CACHE;
 
-      /*
-        See `Ember.Binding.to`.
+});
+enifed('ember-htmlbars/system/make-view-helper', ['exports', 'ember-metal/core', 'ember-htmlbars/system/helper'], function (exports, Ember, Helper) {
 
-        @method to
-        @static
-      */
-      to: function(to) {
-        var C = this;
-        return new C(to, undefined);
-      },
+  'use strict';
 
-      /**
-        Creates a new Binding instance and makes it apply in a single direction.
-        A one-way binding will relay changes on the `from` side object (supplied
-        as the `from` argument) the `to` side, but not the other way around.
-        This means that if you change the "to" side directly, the "from" side may have
-        a different value.
-
-        See `Binding.oneWay`.
-
-        @method oneWay
-        @param {String} from from path.
-        @param {Boolean} [flag] (Optional) passing nothing here will make the
-          binding `oneWay`. You can instead pass `false` to disable `oneWay`, making the
-          binding two way again.
-        @return {Ember.Binding} `this`
-      */
-      oneWay: function(from, flag) {
-        var C = this;
-        return new C(undefined, from).oneWay(flag);
-      }
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-    });
-    /**
-      An `Ember.Binding` connects the properties of two objects so that whenever
-      the value of one property changes, the other property will be changed also.
+  function makeViewHelper(ViewClass) {
+    function helperFunc(params, hash, options, env) {
+      Ember['default'].assert("You can only pass attributes (such as name=value) not bare " +
+                   "values to a helper for a View found in '" + ViewClass.toString() + "'", params.length === 0);
 
-      ## Automatic Creation of Bindings with `/^*Binding/`-named Properties
+      return env.helpers.view.helperFunction.call(this, [ViewClass], hash, options, env);
+    }
 
-      You do not usually create Binding objects directly but instead describe
-      bindings in your class or object definition using automatic binding
-      detection.
+    return new Helper['default'](helperFunc);
+  }
+  exports['default'] = makeViewHelper;
 
-      Properties ending in a `Binding` suffix will be converted to `Ember.Binding`
-      instances. The value of this property should be a string representing a path
-      to another object or a custom binding instance created using Binding helpers
-      (see "One Way Bindings"):
+});
+enifed('ember-htmlbars/system/make_bound_helper', ['exports', 'ember-metal/core', 'ember-htmlbars/system/helper', 'ember-metal/streams/stream', 'ember-metal/streams/utils'], function (exports, Ember, Helper, Stream, utils) {
 
-      ```
-      valueBinding: "MyApp.someController.title"
-      ```
+  'use strict';
 
-      This will create a binding from `MyApp.someController.title` to the `value`
-      property of your object instance automatically. Now the two values will be
-      kept in sync.
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-      ## One Way Bindings
+  function makeBoundHelper(fn) {
+    function helperFunc(params, hash, options, env) {
+      var view = env.data.view;
+      var numParams = params.length;
+      var param, prop;
 
-      One especially useful binding customization you can use is the `oneWay()`
-      helper. This helper tells Ember that you are only interested in
-      receiving changes on the object you are binding from. For example, if you
-      are binding to a preference and you want to be notified if the preference
-      has changed, but your object will not be changing the preference itself, you
-      could do:
+      Ember['default'].assert("makeBoundHelper generated helpers do not support use with blocks", !options.template);
 
-      ```
-      bigTitlesBinding: Ember.Binding.oneWay("MyApp.preferencesController.bigTitles")
-      ```
+      function valueFn() {
+        return fn.call(view, utils.readArray(params), utils.readHash(hash), options, env);
+      }
+
+      // If none of the hash parameters are bound, act as an unbound helper.
+      // This prevents views from being unnecessarily created
+      var hasStream = utils.scanArray(params) || utils.scanHash(hash);
+      if (hasStream) {
+        var lazyValue = new Stream['default'](valueFn);
 
-      This way if the value of `MyApp.preferencesController.bigTitles` changes the
-      `bigTitles` property of your object will change also. However, if you
-      change the value of your `bigTitles` property, it will not update the
-      `preferencesController`.
+        for (var i = 0; i < numParams; i++) {
+          param = params[i];
+          utils.subscribe(param, lazyValue.notify, lazyValue);
+        }
 
-      One way bindings are almost twice as fast to setup and twice as fast to
-      execute because the binding only has to worry about changes to one side.
+        for (prop in hash) {
+          param = hash[prop];
+          utils.subscribe(param, lazyValue.notify, lazyValue);
+        }
 
-      You should consider using one way bindings anytime you have an object that
-      may be created frequently and you do not intend to change a property; only
-      to monitor it for changes (such as in the example above).
+        return lazyValue;
+      } else {
+        return valueFn();
+      }
+    }
 
-      ## Adding Bindings Manually
+    return new Helper['default'](helperFunc);
+  }
+  exports['default'] = makeBoundHelper;
 
-      All of the examples above show you how to configure a custom binding, but the
-      result of these customizations will be a binding template, not a fully active
-      Binding instance. The binding will actually become active only when you
-      instantiate the object the binding belongs to. It is useful however, to
-      understand what actually happens when the binding is activated.
+});
+enifed('ember-htmlbars/system/merge-view-bindings', ['exports', 'ember-metal/core', 'ember-metal/mixin', 'ember-metal/streams/simple', 'ember-metal/streams/utils', 'ember-views/streams/class_name_binding'], function (exports, Ember, mixin, SimpleStream, utils, class_name_binding) {
 
-      For a binding to function it must have at least a `from` property and a `to`
-      property. The `from` property path points to the object/key that you want to
-      bind from while the `to` path points to the object/key you want to bind to.
+  'use strict';
 
-      When you define a custom binding, you are usually describing the property
-      you want to bind from (such as `MyApp.someController.value` in the examples
-      above). When your object is created, it will automatically assign the value
-      you want to bind `to` based on the name of your binding key. In the
-      examples above, during init, Ember objects will effectively call
-      something like this on your binding:
+  var a_push = Array.prototype.push;
 
-      ```javascript
-      binding = Ember.Binding.from("valueBinding").to("value");
-      ```
+  function mergeViewBindings(view, props, hash) {
+    mergeGenericViewBindings(view, props, hash);
+    mergeDOMViewBindings(view, props, hash);
+    return props;
+  }
+  exports['default'] = mergeViewBindings;
+
+  function mergeGenericViewBindings(view, props, hash) {
+    for (var key in hash) {
+      if (key === 'id' ||
+          key === 'tag' ||
+          key === 'class' ||
+          key === 'classBinding' ||
+          key === 'classNameBindings' ||
+          key === 'attributeBindings') {
+        continue;
+      }
+
+      var value = hash[key];
+
+      if (mixin.IS_BINDING.test(key)) {
+        if (typeof value === 'string') {
+          Ember['default'].deprecate(
+            "You're attempting to render a view by passing " + key + " " +
+            "to a view helper, but this syntax is deprecated. You should use `" +
+            key.slice(0, -7) + "=someValue` instead."
+          );
 
-      This creates a new binding instance based on the template you provide, and
-      sets the to path to the `value` property of the new object. Now that the
-      binding is fully configured with a `from` and a `to`, it simply needs to be
-      connected to become active. This is done through the `connect()` method:
+          props[key] = view._getBindingForStream(value);
+        } else if (utils.isStream(value)) {
+          Ember['default'].deprecate(
+            "You're attempting to render a view by passing " + key + " " +
+            "to a view helper without a quoted value, but this syntax is " +
+            "ambiguous. You should either surround " + key + "'s value in " +
+            "quotes or remove `Binding` from " + key + "."
+          );
 
-      ```javascript
-      binding.connect(this);
-      ```
+          props[key] = view._getBindingForStream(value);
+        } else {
+          props[key] = value;
+        }
+      } else {
+        if (utils.isStream(value)) {
+          props[key + 'Binding'] = view._getBindingForStream(value);
+        } else {
+          props[key] = value;
+        }
+      }
+    }
+  }
 
-      Note that when you connect a binding you pass the object you want it to be
-      connected to. This object will be used as the root for both the from and
-      to side of the binding when inspecting relative paths. This allows the
-      binding to be automatically inherited by subclassed objects as well.
+  function mergeDOMViewBindings(view, props, hash) {
+    Ember['default'].assert(
+      "Setting 'attributeBindings' via template helpers is not allowed. " +
+      "Please subclass Ember.View and set it there instead.",
+      !hash.attributeBindings
+    );
 
-      This also allows you to bind between objects using the paths you declare in
-      `from` and `to`:
+    if (hash.id) {
+      props.id = props.elementId = utils.read(hash.id);
+    }
 
-      ```javascript
-      // Example 1
-      binding = Ember.Binding.from("App.someObject.value").to("value");
-      binding.connect(this);
+    if (hash.tag) {
+      props.tagName = utils.read(hash.tag);
+    }
 
-      // Example 2
-      binding = Ember.Binding.from("parentView.value").to("App.someObject.value");
-      binding.connect(this);
-      ```
+    var classBindings = [];
+
+    if (hash['class']) {
+      if (typeof hash['class'] === 'string') {
+        props.classNames = hash['class'].split(' ');
+      } else if (hash['class']._label) {
+        // label exists for via property paths in the template
+        // but not for streams with nested sub-expressions
+        classBindings.push(hash['class']._label);
+      } else {
+        // this stream did not have a label which means that
+        // it is not a simple property path type stream (likely
+        // the result of a sub-expression)
+        classBindings.push(hash['class']);
+      }
+    }
 
-      Now that the binding is connected, it will observe both the from and to side
-      and relay changes.
+    if (hash.classBinding) {
+      a_push.apply(classBindings, hash.classBinding.split(' '));
+    }
 
-      If you ever needed to do so (you almost never will, but it is useful to
-      understand this anyway), you could manually create an active binding by
-      using the `Ember.bind()` helper method. (This is the same method used by
-      to setup your bindings on objects):
+    if (hash.classNameBindings) {
+      a_push.apply(classBindings, hash.classNameBindings.split(' '));
+    }
 
-      ```javascript
-      Ember.bind(MyApp.anotherObject, "value", "MyApp.someController.value");
-      ```
+    if (classBindings.length > 0) {
+      props.classNameBindings = classBindings;
 
-      Both of these code fragments have the same effect as doing the most friendly
-      form of binding creation like so:
+      for (var i = 0; i < classBindings.length; i++) {
+        var initialValue = classBindings[i];
+        var classBinding;
 
-      ```javascript
-      MyApp.anotherObject = Ember.Object.create({
-        valueBinding: "MyApp.someController.value",
+        if (utils.isStream(initialValue)) {
+          classBinding = initialValue;
+        } else {
+          classBinding = class_name_binding.streamifyClassNameBinding(view, initialValue);
+        }
 
-        // OTHER CODE FOR THIS OBJECT...
-      });
-      ```
+        if (utils.isStream(classBinding)) {
+          classBindings[i] = classBinding;
+        } else {
+          classBindings[i] = new SimpleStream['default'](classBinding);
+        }
+      }
+    }
+  }
 
-      Ember's built in binding creation method makes it easy to automatically
-      create bindings for you. You should always use the highest-level APIs
-      available, even if you understand how it works underneath.
+});
+enifed('ember-htmlbars/system/render-view', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-htmlbars/env'], function (exports, Ember, property_get, defaultEnv) {
 
-      @class Binding
-      @namespace Ember
-      @since Ember 0.9
-    */
-    // Ember.Binding = Binding; ES6TODO: where to put this?
+  'use strict';
 
+  function renderView(view, buffer, template) {
+    if (!template) {
+      return;
+    }
 
-    /**
-      Global helper method to create a new binding. Just pass the root object
-      along with a `to` and `from` path to create and connect the binding.
+    var output;
 
-      @method bind
-      @for Ember
-      @param {Object} obj The root object of the transform.
-      @param {String} to The path to the 'to' side of the binding.
-        Must be relative to obj.
-      @param {String} from The path to the 'from' side of the binding.
-        Must be relative to obj or a global path.
-      @return {Ember.Binding} binding instance
-    */
-    function bind(obj, to, from) {
-      return new Binding(to, from).connect(obj);
+    if (template.isHTMLBars) {
+      Ember['default'].assert('template must be an object. Did you mean to call Ember.Handlebars.compile("...") or specify templateName instead?', typeof template === 'object');
+      output = renderHTMLBarsTemplate(view, buffer, template);
+    } else {
+      Ember['default'].assert('template must be a function. Did you mean to call Ember.Handlebars.compile("...") or specify templateName instead?', typeof template === 'function');
+      output = renderLegacyTemplate(view, buffer, template);
     }
 
-    __exports__.bind = bind;/**
-      @method oneWay
-      @for Ember
-      @param {Object} obj The root object of the transform.
-      @param {String} to The path to the 'to' side of the binding.
-        Must be relative to obj.
-      @param {String} from The path to the 'from' side of the binding.
-        Must be relative to obj or a global path.
-      @return {Ember.Binding} binding instance
-    */
-    function oneWay(obj, to, from) {
-      return new Binding(to, from).oneWay().connect(obj);
+    if (output !== undefined) {
+      buffer.push(output);
     }
+  }
+  exports['default'] = renderView;
+
+  function renderHTMLBarsTemplate(view, buffer, template) {
+    Ember['default'].assert(
+      'The template being rendered by `' + view + '` was compiled with `' + template.revision +
+      '` which does not match `Ember@1.11.0` (this revision).',
+      template.revision === 'Ember@1.11.0'
+    );
+
+    var contextualElement = buffer.innerContextualElement();
+    var args = view._blockArguments;
+    var env = {
+      view: this,
+      dom: view.renderer._dom,
+      hooks: defaultEnv['default'].hooks,
+      helpers: defaultEnv['default'].helpers,
+      useFragmentCache: defaultEnv['default'].useFragmentCache,
+      data: {
+        view: view,
+        buffer: buffer
+      }
+    };
+
+    return template.render(view, env, contextualElement, args);
+  }
 
-    __exports__.oneWay = oneWay;__exports__.Binding = Binding;
-    __exports__.isGlobalPath = isGlobalPath;
-  });
-enifed("ember-metal/cache",
-  ["ember-metal/dictionary","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var dictionary = __dependency1__["default"];
-    __exports__["default"] = Cache;
+  function renderLegacyTemplate(view, buffer, template) {
+    var context = property_get.get(view, 'context');
+    var options = {
+      data: {
+        view: view,
+        buffer: buffer
+      }
+    };
 
-    function Cache(limit, func) {
-      this.store  = dictionary(null);
-      this.size   = 0;
-      this.misses = 0;
-      this.hits   = 0;
-      this.limit  = limit;
-      this.func   = func;
-    }
+    return template(context, options);
+  }
 
-    var UNDEFINED = function() { };
+});
+enifed('ember-htmlbars/templates/component', ['exports', 'ember-template-compiler/system/template'], function (exports, template) {
 
-    Cache.prototype = {
-      set: function(key, value) {
-        if (this.limit > this.size) {
-          this.size ++;
-          if (value === undefined) {
-            this.store[key] = UNDEFINED;
-          } else {
-            this.store[key] = value;
+  'use strict';
+
+  exports['default'] = template['default']((function() {
+    return {
+      isHTMLBars: true,
+      revision: "Ember@1.11.0",
+      blockParams: 0,
+      cachedFragment: null,
+      hasRendered: false,
+      build: function build(dom) {
+        var el0 = dom.createDocumentFragment();
+        var el1 = dom.createComment("");
+        dom.appendChild(el0, el1);
+        return el0;
+      },
+      render: function render(context, env, contextualElement) {
+        var dom = env.dom;
+        var hooks = env.hooks, content = hooks.content;
+        dom.detectNamespace(contextualElement);
+        var fragment;
+        if (env.useFragmentCache && dom.canClone) {
+          if (this.cachedFragment === null) {
+            fragment = this.build(dom);
+            if (this.hasRendered) {
+              this.cachedFragment = fragment;
+            } else {
+              this.hasRendered = true;
+            }
           }
+          if (this.cachedFragment) {
+            fragment = dom.cloneNode(this.cachedFragment, true);
+          }
+        } else {
+          fragment = this.build(dom);
         }
+        var morph0 = dom.createMorphAt(fragment,0,0,contextualElement);
+        dom.insertBoundary(fragment, null);
+        dom.insertBoundary(fragment, 0);
+        content(env, morph0, context, "yield");
+        return fragment;
+      }
+    };
+  }()));
 
-        return value;
-      },
+});
+enifed('ember-htmlbars/templates/empty', ['exports', 'ember-template-compiler/system/template'], function (exports, template) {
 
-      get: function(key) {
-        var value = this.store[key];
+  'use strict';
 
-        if (value === undefined) {
-          this.misses ++;
-          value = this.set(key, this.func(key));
-        } else if (value === UNDEFINED) {
-          this.hits ++;
-          value = undefined;
+  exports['default'] = template['default']((function() {
+    return {
+      isHTMLBars: true,
+      revision: "Ember@1.11.0",
+      blockParams: 0,
+      cachedFragment: null,
+      hasRendered: false,
+      build: function build(dom) {
+        var el0 = dom.createDocumentFragment();
+        return el0;
+      },
+      render: function render(context, env, contextualElement) {
+        var dom = env.dom;
+        dom.detectNamespace(contextualElement);
+        var fragment;
+        if (env.useFragmentCache && dom.canClone) {
+          if (this.cachedFragment === null) {
+            fragment = this.build(dom);
+            if (this.hasRendered) {
+              this.cachedFragment = fragment;
+            } else {
+              this.hasRendered = true;
+            }
+          }
+          if (this.cachedFragment) {
+            fragment = dom.cloneNode(this.cachedFragment, true);
+          }
         } else {
-          this.hits ++;
-          // nothing to translate
+          fragment = this.build(dom);
         }
-
-        return value;
-      },
-
-      purge: function() {
-        this.store  = dictionary(null);
-        this.size   = 0;
-        this.hits   = 0;
-        this.misses = 0;
+        return fragment;
       }
     };
-  });
-enifed("ember-metal/chains",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/array","ember-metal/watch_key","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // warn, assert, etc;
-    var get = __dependency2__.get;
-    var normalizeTuple = __dependency2__.normalizeTuple;
-    var metaFor = __dependency3__.meta;
-    var forEach = __dependency4__.forEach;
-    var watchKey = __dependency5__.watchKey;
-    var unwatchKey = __dependency5__.unwatchKey;
-
-    var warn = Ember.warn;
-    var FIRST_KEY = /^([^\.]+)/;
-
-    function firstKey(path) {
-      return path.match(FIRST_KEY)[0];
-    }
-
-    var pendingQueue = [];
+  }()));
 
-    // attempts to add the pendingQueue chains again. If some of them end up
-    // back in the queue and reschedule is true, schedules a timeout to try
-    // again.
-    function flushPendingChains() {
-      if (pendingQueue.length === 0) { return; } // nothing to do
+});
+enifed('ember-htmlbars/templates/link-to-escaped', ['exports', 'ember-template-compiler/system/template'], function (exports, template) {
 
-      var queue = pendingQueue;
-      pendingQueue = [];
+  'use strict';
 
-      forEach.call(queue, function(q) {
-        q[0].add(q[1]);
-      });
-
-      warn('Watching an undefined global, Ember expects watched globals to be' +
-           ' setup by the time the run loop is flushed, check for typos', pendingQueue.length === 0);
-    }
-
-    __exports__.flushPendingChains = flushPendingChains;function addChainWatcher(obj, keyName, node) {
-      if (!obj || ('object' !== typeof obj)) { return; } // nothing to do
+  exports['default'] = template['default']((function() {
+    return {
+      isHTMLBars: true,
+      revision: "Ember@1.11.0",
+      blockParams: 0,
+      cachedFragment: null,
+      hasRendered: false,
+      build: function build(dom) {
+        var el0 = dom.createDocumentFragment();
+        var el1 = dom.createComment("");
+        dom.appendChild(el0, el1);
+        return el0;
+      },
+      render: function render(context, env, contextualElement) {
+        var dom = env.dom;
+        var hooks = env.hooks, content = hooks.content;
+        dom.detectNamespace(contextualElement);
+        var fragment;
+        if (env.useFragmentCache && dom.canClone) {
+          if (this.cachedFragment === null) {
+            fragment = this.build(dom);
+            if (this.hasRendered) {
+              this.cachedFragment = fragment;
+            } else {
+              this.hasRendered = true;
+            }
+          }
+          if (this.cachedFragment) {
+            fragment = dom.cloneNode(this.cachedFragment, true);
+          }
+        } else {
+          fragment = this.build(dom);
+        }
+        var morph0 = dom.createMorphAt(fragment,0,0,contextualElement);
+        dom.insertBoundary(fragment, null);
+        dom.insertBoundary(fragment, 0);
+        content(env, morph0, context, "linkTitle");
+        return fragment;
+      }
+    };
+  }()));
 
-      var m = metaFor(obj);
-      var nodes = m.chainWatchers;
+});
+enifed('ember-htmlbars/templates/link-to-unescaped', ['exports', 'ember-template-compiler/system/template'], function (exports, template) {
 
-      if (!m.hasOwnProperty('chainWatchers')) {
-        nodes = m.chainWatchers = {};
-      }
+  'use strict';
 
-      if (!nodes[keyName]) {
-        nodes[keyName] = [];
+  exports['default'] = template['default']((function() {
+    return {
+      isHTMLBars: true,
+      revision: "Ember@1.11.0",
+      blockParams: 0,
+      cachedFragment: null,
+      hasRendered: false,
+      build: function build(dom) {
+        var el0 = dom.createDocumentFragment();
+        var el1 = dom.createComment("");
+        dom.appendChild(el0, el1);
+        return el0;
+      },
+      render: function render(context, env, contextualElement) {
+        var dom = env.dom;
+        var hooks = env.hooks, content = hooks.content;
+        dom.detectNamespace(contextualElement);
+        var fragment;
+        if (env.useFragmentCache && dom.canClone) {
+          if (this.cachedFragment === null) {
+            fragment = this.build(dom);
+            if (this.hasRendered) {
+              this.cachedFragment = fragment;
+            } else {
+              this.hasRendered = true;
+            }
+          }
+          if (this.cachedFragment) {
+            fragment = dom.cloneNode(this.cachedFragment, true);
+          }
+        } else {
+          fragment = this.build(dom);
+        }
+        var morph0 = dom.createUnsafeMorphAt(fragment,0,0,contextualElement);
+        dom.insertBoundary(fragment, null);
+        dom.insertBoundary(fragment, 0);
+        content(env, morph0, context, "linkTitle");
+        return fragment;
       }
-      nodes[keyName].push(node);
-      watchKey(obj, keyName, m);
-    }
-
-    function removeChainWatcher(obj, keyName, node) {
-      if (!obj || 'object' !== typeof obj) { return; } // nothing to do
+    };
+  }()));
 
-      var m = obj['__ember_meta__'];
-      if (m && !m.hasOwnProperty('chainWatchers')) { return; } // nothing to do
+});
+enifed('ember-htmlbars/templates/select', ['exports', 'ember-template-compiler/system/template'], function (exports, template) {
 
-      var nodes = m && m.chainWatchers;
+  'use strict';
 
-      if (nodes && nodes[keyName]) {
-        nodes = nodes[keyName];
-        for (var i = 0, l = nodes.length; i < l; i++) {
-          if (nodes[i] === node) {
-            nodes.splice(i, 1);
-            break;
+  exports['default'] = template['default']((function() {
+    var child0 = (function() {
+      return {
+        isHTMLBars: true,
+        revision: "Ember@1.11.0",
+        blockParams: 0,
+        cachedFragment: null,
+        hasRendered: false,
+        build: function build(dom) {
+          var el0 = dom.createDocumentFragment();
+          var el1 = dom.createElement("option");
+          dom.setAttribute(el1,"value","");
+          var el2 = dom.createComment("");
+          dom.appendChild(el1, el2);
+          dom.appendChild(el0, el1);
+          return el0;
+        },
+        render: function render(context, env, contextualElement) {
+          var dom = env.dom;
+          var hooks = env.hooks, content = hooks.content;
+          dom.detectNamespace(contextualElement);
+          var fragment;
+          if (env.useFragmentCache && dom.canClone) {
+            if (this.cachedFragment === null) {
+              fragment = this.build(dom);
+              if (this.hasRendered) {
+                this.cachedFragment = fragment;
+              } else {
+                this.hasRendered = true;
+              }
+            }
+            if (this.cachedFragment) {
+              fragment = dom.cloneNode(this.cachedFragment, true);
+            }
+          } else {
+            fragment = this.build(dom);
+          }
+          var morph0 = dom.createMorphAt(dom.childAt(fragment, [0]),0,0);
+          content(env, morph0, context, "view.prompt");
+          return fragment;
+        }
+      };
+    }());
+    var child1 = (function() {
+      var child0 = (function() {
+        return {
+          isHTMLBars: true,
+          revision: "Ember@1.11.0",
+          blockParams: 0,
+          cachedFragment: null,
+          hasRendered: false,
+          build: function build(dom) {
+            var el0 = dom.createDocumentFragment();
+            var el1 = dom.createComment("");
+            dom.appendChild(el0, el1);
+            return el0;
+          },
+          render: function render(context, env, contextualElement) {
+            var dom = env.dom;
+            var hooks = env.hooks, get = hooks.get, inline = hooks.inline;
+            dom.detectNamespace(contextualElement);
+            var fragment;
+            if (env.useFragmentCache && dom.canClone) {
+              if (this.cachedFragment === null) {
+                fragment = this.build(dom);
+                if (this.hasRendered) {
+                  this.cachedFragment = fragment;
+                } else {
+                  this.hasRendered = true;
+                }
+              }
+              if (this.cachedFragment) {
+                fragment = dom.cloneNode(this.cachedFragment, true);
+              }
+            } else {
+              fragment = this.build(dom);
+            }
+            var morph0 = dom.createMorphAt(fragment,0,0,contextualElement);
+            dom.insertBoundary(fragment, null);
+            dom.insertBoundary(fragment, 0);
+            inline(env, morph0, context, "view", [get(env, context, "view.groupView")], {"content": get(env, context, "group.content"), "label": get(env, context, "group.label")});
+            return fragment;
+          }
+        };
+      }());
+      return {
+        isHTMLBars: true,
+        revision: "Ember@1.11.0",
+        blockParams: 0,
+        cachedFragment: null,
+        hasRendered: false,
+        build: function build(dom) {
+          var el0 = dom.createDocumentFragment();
+          var el1 = dom.createComment("");
+          dom.appendChild(el0, el1);
+          return el0;
+        },
+        render: function render(context, env, contextualElement) {
+          var dom = env.dom;
+          var hooks = env.hooks, get = hooks.get, block = hooks.block;
+          dom.detectNamespace(contextualElement);
+          var fragment;
+          if (env.useFragmentCache && dom.canClone) {
+            if (this.cachedFragment === null) {
+              fragment = this.build(dom);
+              if (this.hasRendered) {
+                this.cachedFragment = fragment;
+              } else {
+                this.hasRendered = true;
+              }
+            }
+            if (this.cachedFragment) {
+              fragment = dom.cloneNode(this.cachedFragment, true);
+            }
+          } else {
+            fragment = this.build(dom);
+          }
+          var morph0 = dom.createMorphAt(fragment,0,0,contextualElement);
+          dom.insertBoundary(fragment, null);
+          dom.insertBoundary(fragment, 0);
+          block(env, morph0, context, "each", [get(env, context, "view.groupedContent")], {"keyword": "group"}, child0, null);
+          return fragment;
+        }
+      };
+    }());
+    var child2 = (function() {
+      var child0 = (function() {
+        return {
+          isHTMLBars: true,
+          revision: "Ember@1.11.0",
+          blockParams: 0,
+          cachedFragment: null,
+          hasRendered: false,
+          build: function build(dom) {
+            var el0 = dom.createDocumentFragment();
+            var el1 = dom.createComment("");
+            dom.appendChild(el0, el1);
+            return el0;
+          },
+          render: function render(context, env, contextualElement) {
+            var dom = env.dom;
+            var hooks = env.hooks, get = hooks.get, inline = hooks.inline;
+            dom.detectNamespace(contextualElement);
+            var fragment;
+            if (env.useFragmentCache && dom.canClone) {
+              if (this.cachedFragment === null) {
+                fragment = this.build(dom);
+                if (this.hasRendered) {
+                  this.cachedFragment = fragment;
+                } else {
+                  this.hasRendered = true;
+                }
+              }
+              if (this.cachedFragment) {
+                fragment = dom.cloneNode(this.cachedFragment, true);
+              }
+            } else {
+              fragment = this.build(dom);
+            }
+            var morph0 = dom.createMorphAt(fragment,0,0,contextualElement);
+            dom.insertBoundary(fragment, null);
+            dom.insertBoundary(fragment, 0);
+            inline(env, morph0, context, "view", [get(env, context, "view.optionView")], {"content": get(env, context, "item")});
+            return fragment;
+          }
+        };
+      }());
+      return {
+        isHTMLBars: true,
+        revision: "Ember@1.11.0",
+        blockParams: 0,
+        cachedFragment: null,
+        hasRendered: false,
+        build: function build(dom) {
+          var el0 = dom.createDocumentFragment();
+          var el1 = dom.createComment("");
+          dom.appendChild(el0, el1);
+          return el0;
+        },
+        render: function render(context, env, contextualElement) {
+          var dom = env.dom;
+          var hooks = env.hooks, get = hooks.get, block = hooks.block;
+          dom.detectNamespace(contextualElement);
+          var fragment;
+          if (env.useFragmentCache && dom.canClone) {
+            if (this.cachedFragment === null) {
+              fragment = this.build(dom);
+              if (this.hasRendered) {
+                this.cachedFragment = fragment;
+              } else {
+                this.hasRendered = true;
+              }
+            }
+            if (this.cachedFragment) {
+              fragment = dom.cloneNode(this.cachedFragment, true);
+            }
+          } else {
+            fragment = this.build(dom);
           }
+          var morph0 = dom.createMorphAt(fragment,0,0,contextualElement);
+          dom.insertBoundary(fragment, null);
+          dom.insertBoundary(fragment, 0);
+          block(env, morph0, context, "each", [get(env, context, "view.content")], {"keyword": "item"}, child0, null);
+          return fragment;
+        }
+      };
+    }());
+    return {
+      isHTMLBars: true,
+      revision: "Ember@1.11.0",
+      blockParams: 0,
+      cachedFragment: null,
+      hasRendered: false,
+      build: function build(dom) {
+        var el0 = dom.createDocumentFragment();
+        var el1 = dom.createComment("");
+        dom.appendChild(el0, el1);
+        var el1 = dom.createComment("");
+        dom.appendChild(el0, el1);
+        var el1 = dom.createTextNode("\n");
+        dom.appendChild(el0, el1);
+        return el0;
+      },
+      render: function render(context, env, contextualElement) {
+        var dom = env.dom;
+        var hooks = env.hooks, get = hooks.get, block = hooks.block;
+        dom.detectNamespace(contextualElement);
+        var fragment;
+        if (env.useFragmentCache && dom.canClone) {
+          if (this.cachedFragment === null) {
+            fragment = this.build(dom);
+            if (this.hasRendered) {
+              this.cachedFragment = fragment;
+            } else {
+              this.hasRendered = true;
+            }
+          }
+          if (this.cachedFragment) {
+            fragment = dom.cloneNode(this.cachedFragment, true);
+          }
+        } else {
+          fragment = this.build(dom);
         }
+        var morph0 = dom.createMorphAt(fragment,0,0,contextualElement);
+        var morph1 = dom.createMorphAt(fragment,1,1,contextualElement);
+        dom.insertBoundary(fragment, 0);
+        block(env, morph0, context, "if", [get(env, context, "view.prompt")], {}, child0, null);
+        block(env, morph1, context, "if", [get(env, context, "view.optionGroupPath")], {}, child1, child2);
+        return fragment;
       }
-      unwatchKey(obj, keyName, m);
-    }
-
-    // A ChainNode watches a single key on an object. If you provide a starting
-    // value for the key then the node won't actually watch it. For a root node
-    // pass null for parent and key and object for value.
-    function ChainNode(parent, key, value) {
-      this._parent = parent;
-      this._key    = key;
+    };
+  }()));
 
-      // _watching is true when calling get(this._parent, this._key) will
-      // return the value of this node.
-      //
-      // It is false for the root of a chain (because we have no parent)
-      // and for global paths (because the parent node is the object with
-      // the observer on it)
-      this._watching = value===undefined;
+});
+enifed('ember-htmlbars/utils/string', ['exports', 'htmlbars-util', 'ember-runtime/system/string'], function (exports, htmlbars_util, EmberStringUtils) {
 
-      this._value  = value;
-      this._paths = {};
-      if (this._watching) {
-        this._object = parent.value();
-        if (this._object) {
-          addChainWatcher(this._object, this._key, this);
-        }
-      }
+  'use strict';
 
-      // Special-case: the EachProxy relies on immediate evaluation to
-      // establish its observers.
-      //
-      // TODO: Replace this with an efficient callback that the EachProxy
-      // can implement.
-      if (this._parent && this._parent._key === '@each') {
-        this.value();
-      }
-    }
+  exports.htmlSafe = htmlSafe;
 
-    var ChainNodePrototype = ChainNode.prototype;
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-    function lazyGet(obj, key) {
-      if (!obj) return undefined;
+  // required so we can extend this object.
+  function htmlSafe(str) {
+    if (str === null || str === undefined) {
+      return "";
+    }
 
-      var meta = obj['__ember_meta__'];
-      // check if object meant only to be a prototype
-      if (meta && meta.proto === obj) {
-        return undefined;
-      }
+    if (typeof str !== 'string') {
+      str = ''+str;
+    }
+    return new htmlbars_util.SafeString(str);
+  }
 
-      if (key === "@each") {
-        return get(obj, key);
-      }
+  EmberStringUtils['default'].htmlSafe = htmlSafe;
+  if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) {
 
-      // if a CP only return cached value
-      var desc = meta && meta.descs[key];
-      if (desc && desc._cacheable) {
-        if (key in meta.cache) {
-          return meta.cache[key];
-        } else {
-          return undefined;
-        }
-      }
+    /**
+      Mark a string as being safe for unescaped output with Handlebars.
 
-      return get(obj, key);
-    }
+      ```javascript
+      '<div>someString</div>'.htmlSafe()
+      ```
 
-    ChainNodePrototype.value = function() {
-      if (this._value === undefined && this._watching) {
-        var obj = this._parent.value();
-        this._value = lazyGet(obj, this._key);
-      }
-      return this._value;
-    };
+      See [Ember.String.htmlSafe](/api/classes/Ember.String.html#method_htmlSafe).
 
-    ChainNodePrototype.destroy = function() {
-      if (this._watching) {
-        var obj = this._object;
-        if (obj) {
-          removeChainWatcher(obj, this._key, this);
-        }
-        this._watching = false; // so future calls do nothing
-      }
+      @method htmlSafe
+      @for String
+      @return {Handlebars.SafeString} a string that will not be html escaped by Handlebars
+    */
+    String.prototype.htmlSafe = function() {
+      return htmlSafe(this);
     };
+  }
 
-    // copies a top level object only
-    ChainNodePrototype.copy = function(obj) {
-      var ret = new ChainNode(null, null, obj);
-      var paths = this._paths;
-      var path;
+  exports.SafeString = htmlbars_util.SafeString;
+  exports.escapeExpression = htmlbars_util.escapeExpression;
 
-      for (path in paths) {
-        // this check will also catch non-number vals.
-        if (paths[path] <= 0) {
-          continue;
-        }
-        ret.add(path);
-      }
-      return ret;
-    };
+});
+enifed('ember-metal-views', ['exports', 'ember-metal-views/renderer'], function (exports, Renderer) {
 
-    // called on the root node of a chain to setup watchers on the specified
-    // path.
-    ChainNodePrototype.add = function(path) {
-      var obj, tuple, key, src, paths;
+	'use strict';
 
-      paths = this._paths;
-      paths[path] = (paths[path] || 0) + 1;
 
-      obj = this.value();
-      tuple = normalizeTuple(obj, path);
 
-      // the path was a local path
-      if (tuple[0] && tuple[0] === obj) {
-        path = tuple[1];
-        key  = firstKey(path);
-        path = path.slice(key.length+1);
+	exports.Renderer = Renderer['default'];
 
-      // global path, but object does not exist yet.
-      // put into a queue and try to connect later.
-      } else if (!tuple[0]) {
-        pendingQueue.push([this, path]);
-        tuple.length = 0;
-        return;
+});
+enifed('ember-metal-views/renderer', ['exports', 'dom-helper', 'ember-metal/environment'], function (exports, DOMHelper, environment) {
 
-      // global path, and object already exists
-      } else {
-        src  = tuple[0];
-        key  = path.slice(0, 0-(tuple[1].length+1));
-        path = tuple[1];
-      }
+  'use strict';
 
-      tuple.length = 0;
-      this.chain(key, path, src);
-    };
+  var domHelper = environment['default'].hasDOM ? new DOMHelper['default']() : null;
 
-    // called on the root node of a chain to teardown watcher on the specified
-    // path
-    ChainNodePrototype.remove = function(path) {
-      var obj, tuple, key, src, paths;
+  function Renderer(_helper, _destinedForDOM) {
+    this._uuid = 0;
 
-      paths = this._paths;
-      if (paths[path] > 0) {
-        paths[path]--;
-      }
+    // These sizes and values are somewhat arbitrary (but sensible)
+    // pre-allocation defaults.
+    this._views = new Array(2000);
+    this._queue = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
+    this._parents = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
+    this._elements = new Array(17);
+    this._inserts = {};
+    this._dom = _helper || domHelper;
+    this._destinedForDOM = _destinedForDOM === undefined ? true : _destinedForDOM;
+  }
 
-      obj = this.value();
-      tuple = normalizeTuple(obj, path);
-      if (tuple[0] === obj) {
-        path = tuple[1];
-        key  = firstKey(path);
-        path = path.slice(key.length+1);
-      } else {
-        src  = tuple[0];
-        key  = path.slice(0, 0-(tuple[1].length+1));
-        path = tuple[1];
+  function Renderer_renderTree(_view, _parentView, _refMorph) {
+    var views = this._views;
+    views[0] = _view;
+    var index = 0;
+    var total = 1;
+    var levelBase = _parentView ? _parentView._level+1 : 0;
+
+    var root = _parentView == null ? _view : _parentView._root;
+
+    // if root view has a _morph assigned
+    var willInsert = !!root._morph;
+
+    var queue = this._queue;
+    queue[0] = 0;
+    var length = 1;
+
+    var parentIndex = -1;
+    var parents = this._parents;
+    var parent = _parentView || null;
+    var elements = this._elements;
+    var element = null;
+    var contextualElement = null;
+    var level = 0;
+
+    var view = _view;
+    var children, i, child;
+    while (length) {
+      elements[level] = element;
+      if (!view._morph) {
+        // ensure props we add are in same order
+        view._morph = null;
+      }
+      view._root = root;
+      this.uuid(view);
+      view._level = levelBase + level;
+      if (view._elementCreated) {
+        this.remove(view, false, true);
       }
 
-      tuple.length = 0;
-      this.unchain(key, path);
-    };
+      this.willCreateElement(view);
 
-    ChainNodePrototype.count = 0;
-
-    ChainNodePrototype.chain = function(key, path, src) {
-      var chains = this._chains;
-      var node;
-      if (!chains) {
-        chains = this._chains = {};
+      contextualElement = view._morph && view._morph.contextualElement;
+      if (!contextualElement && parent && parent._childViewsMorph) {
+        contextualElement = parent._childViewsMorph.contextualElement;
       }
+      if (!contextualElement && view._didCreateElementWithoutMorph) {
+        // This code path is used by view.createElement(), which has two purposes:
+        //
+        // 1. Legacy usage of `createElement()`. Nobody really knows what the point
+        //    of that is. This usage may be removed in Ember 2.0.
+        // 2. FastBoot, which creates an element and has no DOM to insert it into.
+        //
+        // For FastBoot purposes, rendering the DOM without a contextual element
+        // should work fine, because it essentially re-emits the original markup
+        // as a String, which will then be parsed again by the browser, which will
+        // apply the appropriate parsing rules.
+        contextualElement = typeof document !== 'undefined' ? document.body : null;
+      }
+      element = this.createElement(view, contextualElement);
+
+      parents[level++] = parentIndex;
+      parentIndex = index;
+      parent = view;
+
+      // enqueue for end
+      queue[length++] = index;
+      // enqueue children
+      children = this.childViews(view);
+      if (children) {
+        for (i=children.length-1;i>=0;i--) {
+          child = children[i];
+          index = total++;
+          views[index] = child;
+          queue[length++] = index;
+          view = child;
+        }
+      }
+
+      index = queue[--length];
+      view = views[index];
+
+      while (parentIndex === index) {
+        level--;
+        view._elementCreated = true;
+        this.didCreateElement(view);
+        if (willInsert) {
+          this.willInsertElement(view);
+        }
 
-      node = chains[key];
-      if (!node) {
-        node = chains[key] = new ChainNode(this, key, src);
-      }
-      node.count++; // count chains...
+        if (level === 0) {
+          length--;
+          break;
+        }
 
-      // chain rest of path if there is one
-      if (path) {
-        key = firstKey(path);
-        path = path.slice(key.length+1);
-        node.chain(key, path); // NOTE: no src means it will observe changes...
+        parentIndex = parents[level];
+        parent = parentIndex === -1 ? _parentView : views[parentIndex];
+        this.insertElement(view, parent, element, null);
+        index = queue[--length];
+        view = views[index];
+        element = elements[level];
+        elements[level] = null;
       }
-    };
+    }
 
-    ChainNodePrototype.unchain = function(key, path) {
-      var chains = this._chains;
-      var node = chains[key];
+    this.insertElement(view, _parentView, element, _refMorph);
 
-      // unchain rest of path first...
-      if (path && path.length > 1) {
-        var nextKey  = firstKey(path);
-        var nextPath = path.slice(nextKey.length + 1);
-        node.unchain(nextKey, nextPath);
+    for (i=total-1; i>=0; i--) {
+      if (willInsert) {
+        views[i]._elementInserted = true;
+        this.didInsertElement(views[i]);
       }
+      views[i] = null;
+    }
 
-      // delete node if needed.
-      node.count--;
-      if (node.count<=0) {
-        delete chains[node._key];
-        node.destroy();
-      }
+    return element;
+  }
 
-    };
+  Renderer.prototype.uuid = function Renderer_uuid(view) {
+    if (view._uuid === undefined) {
+      view._uuid = ++this._uuid;
+      view._renderer = this;
+    } // else assert(view._renderer === this)
+    return view._uuid;
+  };
 
-    ChainNodePrototype.willChange = function(events) {
-      var chains = this._chains;
-      if (chains) {
-        for(var key in chains) {
-          if (!chains.hasOwnProperty(key)) {
-            continue;
-          }
-          chains[key].willChange(events);
-        }
+  Renderer.prototype.scheduleInsert =
+    function Renderer_scheduleInsert(view, morph) {
+      if (view._morph || view._elementCreated) {
+        throw new Error("You cannot insert a View that has already been rendered");
       }
+      Ember.assert("You cannot insert a View without a morph", morph);
+      view._morph = morph;
+      var viewId = this.uuid(view);
+      this._inserts[viewId] = this.scheduleRender(this, function scheduledRenderTree() {
+        this._inserts[viewId] = null;
+        this.renderTree(view);
+      });
+    };
 
-      if (this._parent) {
-        this._parent.chainWillChange(this, this._key, 1, events);
-      }
+  Renderer.prototype.appendTo =
+    function Renderer_appendTo(view, target) {
+      var morph = this._dom.appendMorph(target);
+      this.scheduleInsert(view, morph);
     };
 
-    ChainNodePrototype.chainWillChange = function(chain, path, depth, events) {
-      if (this._key) {
-        path = this._key + '.' + path;
-      }
+  Renderer.prototype.appendAttrTo =
+    function Renderer_appendAttrTo(view, target, attrName) {
+      var morph = this._dom.createAttrMorph(target, attrName);
+      this.scheduleInsert(view, morph);
+    };
 
-      if (this._parent) {
-        this._parent.chainWillChange(this, path, depth+1, events);
+  Renderer.prototype.replaceIn =
+    function Renderer_replaceIn(view, target) {
+      var morph;
+      if (target.firstNode) {
+        morph = this._dom.createMorph(target, target.firstNode, target.lastNode);
       } else {
-        if (depth > 1) {
-          events.push(this.value(), path);
-        }
-        path = 'this.' + path;
-        if (this._paths[path] > 0) {
-          events.push(this.value(), path);
-        }
+        morph = this._dom.appendMorph(target);
       }
+      this.scheduleInsert(view, morph);
     };
 
-    ChainNodePrototype.chainDidChange = function(chain, path, depth, events) {
-      if (this._key) {
-        path = this._key + '.' + path;
-      }
+  function Renderer_remove(_view, shouldDestroy, reset) {
+    var viewId = this.uuid(_view);
 
-      if (this._parent) {
-        this._parent.chainDidChange(this, path, depth+1, events);
-      } else {
-        if (depth > 1) {
-          events.push(this.value(), path);
-        }
-        path = 'this.' + path;
-        if (this._paths[path] > 0) {
-          events.push(this.value(), path);
-        }
-      }
-    };
+    if (this._inserts[viewId]) {
+      this.cancelRender(this._inserts[viewId]);
+      this._inserts[viewId] = undefined;
+    }
 
-    ChainNodePrototype.didChange = function(events) {
-      // invalidate my own value first.
-      if (this._watching) {
-        var obj = this._parent.value();
-        if (obj !== this._object) {
-          removeChainWatcher(this._object, this._key, this);
-          this._object = obj;
-          addChainWatcher(obj, this._key, this);
-        }
-        this._value  = undefined;
+    if (!_view._elementCreated) {
+      return;
+    }
 
-        // Special-case: the EachProxy relies on immediate evaluation to
-        // establish its observers.
-        if (this._parent && this._parent._key === '@each') {
-          this.value();
-        }
-      }
+    var removeQueue = [];
+    var destroyQueue = [];
+    var morph = _view._morph;
+    var idx, len, view, queue, childViews, i, l;
 
-      // then notify chains...
-      var chains = this._chains;
-      if (chains) {
-        for(var key in chains) {
-          if (!chains.hasOwnProperty(key)) { continue; }
-          chains[key].didChange(events);
-        }
-      }
+    removeQueue.push(_view);
 
-      // if no events are passed in then we only care about the above wiring update
-      if (events === null) {
-        return;
-      }
+    for (idx=0; idx<removeQueue.length; idx++) {
+      view = removeQueue[idx];
 
-      // and finally tell parent about my path changing...
-      if (this._parent) {
-        this._parent.chainDidChange(this, this._key, 1, events);
+      if (!shouldDestroy && view._childViewsMorph) {
+        queue = removeQueue;
+      } else {
+        queue = destroyQueue;
       }
-    };
 
-    function finishChains(obj) {
-      // We only create meta if we really have to
-      var m = obj['__ember_meta__'];
-      var chains, chainWatchers, chainNodes;
-
-      if (m) {
-        // finish any current chains node watchers that reference obj
-        chainWatchers = m.chainWatchers;
-        if (chainWatchers) {
-          for(var key in chainWatchers) {
-            if (!chainWatchers.hasOwnProperty(key)) {
-              continue;
-            }
+      this.beforeRemove(removeQueue[idx]);
 
-            chainNodes = chainWatchers[key];
-            if (chainNodes) {
-              for (var i=0,l=chainNodes.length;i<l;i++) {
-                chainNodes[i].didChange(null);
-              }
-            }
-          }
-        }
-        // copy chains from prototype
-        chains = m.chains;
-        if (chains && chains.value() !== obj) {
-          metaFor(obj).chains = chains = chains.copy(obj);
+      childViews = view._childViews;
+      if (childViews) {
+        for (i=0,l=childViews.length; i<l; i++) {
+          queue.push(childViews[i]);
         }
       }
     }
 
-    __exports__.finishChains = finishChains;__exports__.removeChainWatcher = removeChainWatcher;
-    __exports__.ChainNode = ChainNode;
-  });
-enifed("ember-metal/computed",
-  ["ember-metal/property_set","ember-metal/utils","ember-metal/expand_properties","ember-metal/error","ember-metal/properties","ember-metal/property_events","ember-metal/dependent_keys","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
-    "use strict";
-    var set = __dependency1__.set;
-    var meta = __dependency2__.meta;
-    var inspect = __dependency2__.inspect;
-    var expandProperties = __dependency3__["default"];
-    var EmberError = __dependency4__["default"];
-    var Descriptor = __dependency5__.Descriptor;
-    var defineProperty = __dependency5__.defineProperty;
-    var propertyWillChange = __dependency6__.propertyWillChange;
-    var propertyDidChange = __dependency6__.propertyDidChange;
-    var addDependentKeys = __dependency7__.addDependentKeys;
-    var removeDependentKeys = __dependency7__.removeDependentKeys;
-
-    /**
-    @module ember-metal
-    */
-
-    var metaFor = meta;
-    var a_slice = [].slice;
+    for (idx=0; idx<destroyQueue.length; idx++) {
+      view = destroyQueue[idx];
 
-    function UNDEFINED() { }
-
-    // ..........................................................
-    // COMPUTED PROPERTY
-    //
+      this.beforeRemove(destroyQueue[idx]);
 
-    /**
-      A computed property transforms an object's function into a property.
+      childViews = view._childViews;
+      if (childViews) {
+        for (i=0,l=childViews.length; i<l; i++) {
+          destroyQueue.push(childViews[i]);
+        }
+      }
+    }
 
-      By default the function backing the computed property will only be called
-      once and the result will be cached. You can specify various properties
-      that your computed property depends on. This will force the cached
-      result to be recomputed if the dependencies are modified.
+    // destroy DOM from root insertion
+    if (morph && !reset) {
+      morph.destroy();
+    }
 
-      In the following example we declare a computed property (by calling
-      `.property()` on the fullName function) and setup the property
-      dependencies (depending on firstName and lastName). The fullName function
-      will be called once (regardless of how many times it is accessed) as long
-      as its dependencies have not changed. Once firstName or lastName are updated
-      any future calls (or anything bound) to fullName will incorporate the new
-      values.
+    for (idx=0, len=removeQueue.length; idx < len; idx++) {
+      this.afterRemove(removeQueue[idx], false);
+    }
 
-      ```javascript
-      var Person = Ember.Object.extend({
-        // these will be supplied by `create`
-        firstName: null,
-        lastName: null,
+    for (idx=0, len=destroyQueue.length; idx < len; idx++) {
+      this.afterRemove(destroyQueue[idx], true);
+    }
 
-        fullName: function() {
-          var firstName = this.get('firstName');
-          var lastName = this.get('lastName');
+    if (reset) {
+      _view._morph = morph;
+    }
+  }
 
-         return firstName + ' ' + lastName;
-        }.property('firstName', 'lastName')
-      });
+  function Renderer_insertElement(view, parentView, element, refMorph) {
+    if (element === null || element === undefined) {
+      return;
+    }
 
-      var tom = Person.create({
-        firstName: 'Tom',
-        lastName: 'Dale'
-      });
+    if (view._morph) {
+      view._morph.setContent(element);
+    } else if (parentView) {
+      view._morph = parentView._childViewsMorph.insertContentBeforeMorph(element, refMorph);
+    }
+  }
 
-      tom.get('fullName') // 'Tom Dale'
-      ```
+  function Renderer_beforeRemove(view) {
+    if (view._elementCreated) {
+      this.willDestroyElement(view);
+    }
+    if (view._elementInserted) {
+      this.willRemoveElement(view);
+    }
+  }
 
-      You can also define what Ember should do when setting a computed property.
-      If you try to set a computed property, it will be invoked with the key and
-      value you want to set it to. You can also accept the previous value as the
-      third parameter.
+  function Renderer_afterRemove(view, shouldDestroy) {
+    view._elementInserted = false;
+    view._morph = null;
+    view._childViewsMorph = null;
+    if (view._elementCreated) {
+      view._elementCreated = false;
+      this.didDestroyElement(view);
+    }
+    if (shouldDestroy) {
+      this.destroyView(view);
+    }
+  }
 
-      ```javascript
-      var Person = Ember.Object.extend({
-        // these will be supplied by `create`
-        firstName: null,
-        lastName: null,
+  Renderer.prototype.remove = Renderer_remove;
+  Renderer.prototype.removeAndDestroy = function (view) {
+    this.remove(view, true);
+  };
+
+  Renderer.prototype.renderTree = Renderer_renderTree;
+  Renderer.prototype.insertElement = Renderer_insertElement;
+  Renderer.prototype.beforeRemove = Renderer_beforeRemove;
+  Renderer.prototype.afterRemove = Renderer_afterRemove;
+
+  /// HOOKS
+  var noop = function () {};
+
+  Renderer.prototype.willCreateElement = noop; // inBuffer
+  Renderer.prototype.createElement = noop; // renderToBuffer or createElement
+  Renderer.prototype.didCreateElement = noop; // hasElement
+  Renderer.prototype.willInsertElement = noop; // will place into DOM
+  Renderer.prototype.didInsertElement = noop; // inDOM // placed into DOM
+  Renderer.prototype.willRemoveElement = noop; // removed from DOM  willDestroyElement currently paired with didInsertElement
+  Renderer.prototype.willDestroyElement = noop; // willClearRender (currently balanced with render) this is now paired with createElement
+  Renderer.prototype.didDestroyElement = noop; // element destroyed so view.destroy shouldn't try to remove it removedFromDOM
+  Renderer.prototype.destroyView = noop;
+  Renderer.prototype.childViews = noop;
+
+  exports['default'] = Renderer;
+
+});
+enifed('ember-metal', ['exports', 'ember-metal/core', 'ember-metal/merge', 'ember-metal/instrumentation', 'ember-metal/utils', 'ember-metal/error', 'ember-metal/enumerable_utils', 'ember-metal/cache', 'ember-metal/platform/define_property', 'ember-metal/platform/create', 'ember-metal/array', 'ember-metal/logger', 'ember-metal/property_get', 'ember-metal/events', 'ember-metal/observer_set', 'ember-metal/property_events', 'ember-metal/properties', 'ember-metal/property_set', 'ember-metal/map', 'ember-metal/get_properties', 'ember-metal/set_properties', 'ember-metal/watch_key', 'ember-metal/chains', 'ember-metal/watch_path', 'ember-metal/watching', 'ember-metal/expand_properties', 'ember-metal/computed', 'ember-metal/alias', 'ember-metal/computed_macros', 'ember-metal/observer', 'ember-metal/mixin', 'ember-metal/binding', 'ember-metal/run_loop', 'ember-metal/libraries', 'ember-metal/is_none', 'ember-metal/is_empty', 'ember-metal/is_blank', 'ember-metal/is_present', 'ember-metal/keys', 'backburner', 'ember-metal/streams/utils', 'ember-metal/streams/stream'], function (exports, Ember, merge, instrumentation, utils, EmberError, EnumerableUtils, Cache, define_property, create, array, Logger, property_get, events, ObserverSet, property_events, properties, property_set, map, getProperties, setProperties, watch_key, chains, watch_path, watching, expandProperties, computed, alias, computed_macros, observer, mixin, binding, run, Libraries, isNone, isEmpty, isBlank, isPresent, keys, Backburner, streams__utils, Stream) {
+
+  'use strict';
+
+  /**
+  Ember Metal
+
+  @module ember
+  @submodule ember-metal
+  */
+
+  // BEGIN IMPORTS
+  computed.computed.empty = computed_macros.empty;
+  computed.computed.notEmpty = computed_macros.notEmpty;
+  computed.computed.none = computed_macros.none;
+  computed.computed.not = computed_macros.not;
+  computed.computed.bool = computed_macros.bool;
+  computed.computed.match = computed_macros.match;
+  computed.computed.equal = computed_macros.equal;
+  computed.computed.gt = computed_macros.gt;
+  computed.computed.gte = computed_macros.gte;
+  computed.computed.lt = computed_macros.lt;
+  computed.computed.lte = computed_macros.lte;
+  computed.computed.alias = alias['default'];
+  computed.computed.oneWay = computed_macros.oneWay;
+  computed.computed.reads = computed_macros.oneWay;
+  computed.computed.readOnly = computed_macros.readOnly;
+  computed.computed.defaultTo = computed_macros.defaultTo;
+  computed.computed.deprecatingAlias = computed_macros.deprecatingAlias;
+  computed.computed.and = computed_macros.and;
+  computed.computed.or = computed_macros.or;
+  computed.computed.any = computed_macros.any;
+  computed.computed.collect = computed_macros.collect;
+
+  var EmberInstrumentation = Ember['default'].Instrumentation = {};
+  EmberInstrumentation.instrument = instrumentation.instrument;
+  EmberInstrumentation.subscribe = instrumentation.subscribe;
+  EmberInstrumentation.unsubscribe = instrumentation.unsubscribe;
+  EmberInstrumentation.reset  = instrumentation.reset;
+
+  Ember['default'].instrument = instrumentation.instrument;
+  Ember['default'].subscribe = instrumentation.subscribe;
+
+  Ember['default']._Cache = Cache['default'];
+
+  Ember['default'].generateGuid    = utils.generateGuid;
+  Ember['default'].GUID_KEY        = utils.GUID_KEY;
+  Ember['default'].create          = create['default'];
+  Ember['default'].keys            = keys['default'];
+  Ember['default'].platform        = {
+    defineProperty: properties.defineProperty,
+    hasPropertyAccessors: define_property.hasPropertyAccessors
+  };
+
+  var EmberArrayPolyfills = Ember['default'].ArrayPolyfills = {};
+
+  EmberArrayPolyfills.map = array.map;
+  EmberArrayPolyfills.forEach = array.forEach;
+  EmberArrayPolyfills.filter = array.filter;
+  EmberArrayPolyfills.indexOf = array.indexOf;
+
+  Ember['default'].Error           = EmberError['default'];
+  Ember['default'].guidFor         = utils.guidFor;
+  Ember['default'].META_DESC       = utils.META_DESC;
+  Ember['default'].EMPTY_META      = utils.EMPTY_META;
+  Ember['default'].meta            = utils.meta;
+  Ember['default'].getMeta         = utils.getMeta;
+  Ember['default'].setMeta         = utils.setMeta;
+  Ember['default'].metaPath        = utils.metaPath;
+  Ember['default'].inspect         = utils.inspect;
+  Ember['default'].typeOf          = utils.typeOf;
+  Ember['default'].tryCatchFinally = utils.tryCatchFinally;
+  Ember['default'].isArray         = utils.isArray;
+  Ember['default'].makeArray       = utils.makeArray;
+  Ember['default'].canInvoke       = utils.canInvoke;
+  Ember['default'].tryInvoke       = utils.tryInvoke;
+  Ember['default'].tryFinally      = utils.tryFinally;
+  Ember['default'].wrap            = utils.wrap;
+  Ember['default'].apply           = utils.apply;
+  Ember['default'].applyStr        = utils.applyStr;
+  Ember['default'].uuid            = utils.uuid;
+
+  Ember['default'].Logger = Logger['default'];
+
+  Ember['default'].get            = property_get.get;
+  Ember['default'].getWithDefault = property_get.getWithDefault;
+  Ember['default'].normalizeTuple = property_get.normalizeTuple;
+  Ember['default']._getPath       = property_get._getPath;
+
+  Ember['default'].EnumerableUtils = EnumerableUtils['default'];
+
+  Ember['default'].on                  = events.on;
+  Ember['default'].addListener         = events.addListener;
+  Ember['default'].removeListener      = events.removeListener;
+  Ember['default']._suspendListener    = events.suspendListener;
+  Ember['default']._suspendListeners   = events.suspendListeners;
+  Ember['default'].sendEvent           = events.sendEvent;
+  Ember['default'].hasListeners        = events.hasListeners;
+  Ember['default'].watchedEvents       = events.watchedEvents;
+  Ember['default'].listenersFor        = events.listenersFor;
+  Ember['default'].accumulateListeners = events.accumulateListeners;
+
+  Ember['default']._ObserverSet = ObserverSet['default'];
+
+  Ember['default'].propertyWillChange = property_events.propertyWillChange;
+  Ember['default'].propertyDidChange = property_events.propertyDidChange;
+  Ember['default'].overrideChains = property_events.overrideChains;
+  Ember['default'].beginPropertyChanges = property_events.beginPropertyChanges;
+  Ember['default'].endPropertyChanges = property_events.endPropertyChanges;
+  Ember['default'].changeProperties = property_events.changeProperties;
+
+  Ember['default'].Descriptor     = properties.Descriptor;
+  Ember['default'].defineProperty = properties.defineProperty;
+
+  Ember['default'].set    = property_set.set;
+  Ember['default'].trySet = property_set.trySet;
+
+  Ember['default'].OrderedSet = map.OrderedSet;
+  Ember['default'].Map = map.Map;
+  Ember['default'].MapWithDefault = map.MapWithDefault;
+
+  Ember['default'].getProperties = getProperties['default'];
+  Ember['default'].setProperties = setProperties['default'];
+
+  Ember['default'].watchKey   = watch_key.watchKey;
+  Ember['default'].unwatchKey = watch_key.unwatchKey;
+
+  Ember['default'].flushPendingChains = chains.flushPendingChains;
+  Ember['default'].removeChainWatcher = chains.removeChainWatcher;
+  Ember['default']._ChainNode = chains.ChainNode;
+  Ember['default'].finishChains = chains.finishChains;
+
+  Ember['default'].watchPath = watch_path.watchPath;
+  Ember['default'].unwatchPath = watch_path.unwatchPath;
+
+  Ember['default'].watch = watching.watch;
+  Ember['default'].isWatching = watching.isWatching;
+  Ember['default'].unwatch = watching.unwatch;
+  Ember['default'].rewatch = watching.rewatch;
+  Ember['default'].destroy = watching.destroy;
+
+  Ember['default'].expandProperties = expandProperties['default'];
+
+  Ember['default'].ComputedProperty = computed.ComputedProperty;
+  Ember['default'].computed = computed.computed;
+  Ember['default'].cacheFor = computed.cacheFor;
+
+  Ember['default'].addObserver = observer.addObserver;
+  Ember['default'].observersFor = observer.observersFor;
+  Ember['default'].removeObserver = observer.removeObserver;
+  Ember['default'].addBeforeObserver = observer.addBeforeObserver;
+  Ember['default']._suspendBeforeObserver = observer._suspendBeforeObserver;
+  Ember['default']._suspendBeforeObservers = observer._suspendBeforeObservers;
+  Ember['default']._suspendObserver = observer._suspendObserver;
+  Ember['default']._suspendObservers = observer._suspendObservers;
+  Ember['default'].beforeObserversFor = observer.beforeObserversFor;
+  Ember['default'].removeBeforeObserver = observer.removeBeforeObserver;
+
+  Ember['default'].IS_BINDING = mixin.IS_BINDING;
+  Ember['default'].required = mixin.required;
+  Ember['default'].aliasMethod = mixin.aliasMethod;
+  Ember['default'].observer = mixin.observer;
+  Ember['default'].immediateObserver = mixin.immediateObserver;
+  Ember['default'].beforeObserver = mixin.beforeObserver;
+  Ember['default'].mixin = mixin.mixin;
+  Ember['default'].Mixin = mixin.Mixin;
+
+  Ember['default'].oneWay = binding.oneWay;
+  Ember['default'].bind = binding.bind;
+  Ember['default'].Binding = binding.Binding;
+  Ember['default'].isGlobalPath = binding.isGlobalPath;
+
+  Ember['default'].run = run['default'];
+
+  /**
+   * @class Backburner
+   * @for Ember
+   * @private
+  */
+  Ember['default'].Backburner = Backburner['default'];
+
+  Ember['default'].libraries = new Libraries['default']();
+  Ember['default'].libraries.registerCoreLibrary('Ember', Ember['default'].VERSION);
+
+  Ember['default'].isNone = isNone['default'];
+  Ember['default'].isEmpty = isEmpty['default'];
+  Ember['default'].isBlank = isBlank['default'];
+  Ember['default'].isPresent = isPresent['default'];
+
+  Ember['default'].merge = merge['default'];
+
+
+  /**
+    A function may be assigned to `Ember.onerror` to be called when Ember
+    internals encounter an error. This is useful for specialized error handling
+    and reporting code.
 
-        fullName: function(key, value, oldValue) {
-          // getter
-          if (arguments.length === 1) {
-            var firstName = this.get('firstName');
-            var lastName = this.get('lastName');
+    ```javascript
+    Ember.onerror = function(error) {
+      Em.$.ajax('/report-error', 'POST', {
+        stack: error.stack,
+        otherInformation: 'whatever app state you want to provide'
+      });
+    };
+    ```
 
-            return firstName + ' ' + lastName;
+    Internally, `Ember.onerror` is used as Backburner's error handler.
 
-          // setter
-          } else {
-            var name = value.split(' ');
+    @event onerror
+    @for Ember
+    @param {Exception} error the error object
+  */
+  Ember['default'].onerror = null;
+  // END EXPORTS
 
-            this.set('firstName', name[0]);
-            this.set('lastName', name[1]);
+  // do this for side-effects of updating Ember.assert, warn, etc when
+  // ember-debug is present
+  if (Ember['default'].__loader.registry['ember-debug']) {
+    requireModule('ember-debug');
+  }
 
-            return value;
-          }
-        }.property('firstName', 'lastName')
-      });
+  exports['default'] = Ember['default'];
 
-      var person = Person.create();
+});
+enifed('ember-metal/alias', ['exports', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/core', 'ember-metal/error', 'ember-metal/properties', 'ember-metal/computed', 'ember-metal/platform/create', 'ember-metal/utils', 'ember-metal/dependent_keys'], function (exports, property_get, property_set, Ember, EmberError, properties, computed, create, utils, dependent_keys) {
 
-      person.set('fullName', 'Peter Wagenet');
-      person.get('firstName'); // 'Peter'
-      person.get('lastName');  // 'Wagenet'
-      ```
+  'use strict';
 
-      @class ComputedProperty
-      @namespace Ember
-      @extends Ember.Descriptor
-      @constructor
-    */
-    function ComputedProperty(func, opts) {
-      func.__ember_arity__ = func.length;
-      this.func = func;
+  exports.AliasedProperty = AliasedProperty;
 
-      this._dependentKeys = undefined;
-      this._suspended = undefined;
-      this._meta = undefined;
+  function alias(altKey) {
+    return new AliasedProperty(altKey);
+  }
+  exports['default'] = alias;
 
-      Ember.deprecate("Passing opts.cacheable to the CP constructor is deprecated. Invoke `volatile()` on the CP instead.", !opts || !opts.hasOwnProperty('cacheable'));
-      this._cacheable = (opts && opts.cacheable !== undefined) ? opts.cacheable : true;   // TODO: Set always to `true` once this deprecation is gone.
-      this._dependentKeys = opts && opts.dependentKeys;
-      Ember.deprecate("Passing opts.readOnly to the CP constructor is deprecated. All CPs are writable by default. Yo can invoke `readOnly()` on the CP to change this.", !opts || !opts.hasOwnProperty('readOnly'));
-      this._readOnly = opts && (opts.readOnly !== undefined || !!opts.readOnly) || false; // TODO: Set always to `false` once this deprecation is gone.
-    }
+  function AliasedProperty(altKey) {
+    this.isDescriptor = true;
+    this.altKey = altKey;
+    this._dependentKeys = [altKey];
+  }
 
-    ComputedProperty.prototype = new Descriptor();
+  AliasedProperty.prototype = create['default'](properties.Descriptor.prototype);
 
-    var ComputedPropertyPrototype = ComputedProperty.prototype;
+  AliasedProperty.prototype.get = function AliasedProperty_get(obj, keyName) {
+    return property_get.get(obj, this.altKey);
+  };
 
-    /**
-      Properties are cacheable by default. Computed property will automatically
-      cache the return value of your function until one of the dependent keys changes.
+  AliasedProperty.prototype.set = function AliasedProperty_set(obj, keyName, value) {
+    return property_set.set(obj, this.altKey, value);
+  };
 
-      Call `volatile()` to set it into non-cached mode. When in this mode
-      the computed property will not automatically cache the return value.
+  AliasedProperty.prototype.willWatch = function(obj, keyName) {
+    dependent_keys.addDependentKeys(this, obj, keyName, utils.meta(obj));
+  };
 
-      However, if a property is properly observable, there is no reason to disable
-      caching.
+  AliasedProperty.prototype.didUnwatch = function(obj, keyName) {
+    dependent_keys.removeDependentKeys(this, obj, keyName, utils.meta(obj));
+  };
 
-      @method cacheable
-      @param {Boolean} aFlag optional set to `false` to disable caching
-      @return {Ember.ComputedProperty} this
-      @chainable
-      @deprecated All computed properties are cacheble by default. Use `volatile()` instead to opt-out to caching.
-    */
-    ComputedPropertyPrototype.cacheable = function(aFlag) {
-      Ember.deprecate('ComputedProperty.cacheable() is deprecated. All computed properties are cacheable by default.');
-      this._cacheable = aFlag !== false;
-      return this;
-    };
+  AliasedProperty.prototype.setup = function(obj, keyName) {
+    Ember['default'].assert("Setting alias '" + keyName + "' on self", this.altKey !== keyName);
+    var m = utils.meta(obj);
+    if (m.watching[keyName]) {
+      dependent_keys.addDependentKeys(this, obj, keyName, m);
+    }
+  };
 
-    /**
-      Call on a computed property to set it into non-cached mode. When in this
-      mode the computed property will not automatically cache the return value.
+  AliasedProperty.prototype.teardown = function(obj, keyName) {
+    var m = utils.meta(obj);
+    if (m.watching[keyName]) {
+      dependent_keys.removeDependentKeys(this, obj, keyName, m);
+    }
+  };
 
-      ```javascript
-      var outsideService = Ember.Object.extend({
-        value: function() {
-          return OutsideService.getValue();
-        }.property().volatile()
-      }).create();
-      ```
+  AliasedProperty.prototype.readOnly = function() {
+    this.set = AliasedProperty_readOnlySet;
+    return this;
+  };
 
-      @method volatile
-      @return {Ember.ComputedProperty} this
-      @chainable
-    */
-    ComputedPropertyPrototype["volatile"] = function() {
-      this._cacheable = false;
-      return this;
-    };
+  function AliasedProperty_readOnlySet(obj, keyName, value) {
+    throw new EmberError['default']('Cannot set read-only property "' + keyName + '" on object: ' + utils.inspect(obj));
+  }
 
-    /**
-      Call on a computed property to set it into read-only mode. When in this
-      mode the computed property will throw an error when set.
+  AliasedProperty.prototype.oneWay = function() {
+    this.set = AliasedProperty_oneWaySet;
+    return this;
+  };
 
-      ```javascript
-      var Person = Ember.Object.extend({
-        guid: function() {
-          return 'guid-guid-guid';
-        }.property().readOnly()
-      });
+  function AliasedProperty_oneWaySet(obj, keyName, value) {
+    properties.defineProperty(obj, keyName, null);
+    return property_set.set(obj, keyName, value);
+  }
 
-      var person = Person.create();
+  // Backwards compatibility with Ember Data
+  AliasedProperty.prototype._meta = undefined;
+  AliasedProperty.prototype.meta = computed.ComputedProperty.prototype.meta;
 
-      person.set('guid', 'new-guid'); // will throw an exception
-      ```
+});
+enifed('ember-metal/array', ['exports'], function (exports) {
 
-      @method readOnly
-      @return {Ember.ComputedProperty} this
-      @chainable
-    */
-    ComputedPropertyPrototype.readOnly = function(readOnly) {
-      Ember.deprecate('Passing arguments to ComputedProperty.readOnly() is deprecated.', arguments.length === 0);
-      this._readOnly = readOnly === undefined || !!readOnly; // Force to true once this deprecation is gone
-      return this;
-    };
+  'use strict';
 
-    /**
-      Sets the dependent keys on this computed property. Pass any number of
-      arguments containing key paths that this computed property depends on.
+  /**
+  @module ember-metal
+  */
 
-      ```javascript
-      var President = Ember.Object.extend({
-        fullName: computed(function() {
-          return this.get('firstName') + ' ' + this.get('lastName');
+  var ArrayPrototype = Array.prototype;
 
-          // Tell Ember that this computed property depends on firstName
-          // and lastName
-        }).property('firstName', 'lastName')
-      });
+  // Testing this is not ideal, but we want to use native functions
+  // if available, but not to use versions created by libraries like Prototype
+  var isNativeFunc = function(func) {
+    // This should probably work in all browsers likely to have ES5 array methods
+    return func && Function.prototype.toString.call(func).indexOf('[native code]') > -1;
+  };
 
-      var president = President.create({
-        firstName: 'Barack',
-        lastName: 'Obama'
-      });
+  var defineNativeShim = function(nativeFunc, shim) {
+    if (isNativeFunc(nativeFunc)) {
+      return nativeFunc;
+    }
+    return shim;
+  };
 
-      president.get('fullName'); // 'Barack Obama'
-      ```
+  // From: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/map
+  var map = defineNativeShim(ArrayPrototype.map, function(fun /*, thisp */) {
+    //"use strict";
 
-      @method property
-      @param {String} path* zero or more property paths
-      @return {Ember.ComputedProperty} this
-      @chainable
-    */
-    ComputedPropertyPrototype.property = function() {
-      var args;
+    if (this === void 0 || this === null || typeof fun !== "function") {
+      throw new TypeError();
+    }
 
-      var addArg = function (property) {
-        args.push(property);
-      };
+    var t = Object(this);
+    var len = t.length >>> 0;
+    var res = new Array(len);
+    var thisp = arguments[1];
 
-      args = [];
-      for (var i = 0, l = arguments.length; i < l; i++) {
-        expandProperties(arguments[i], addArg);
+    for (var i = 0; i < len; i++) {
+      if (i in t) {
+        res[i] = fun.call(thisp, t[i], i, t);
       }
+    }
 
-      this._dependentKeys = args;
-      return this;
-    };
-
-    /**
-      In some cases, you may want to annotate computed properties with additional
-      metadata about how they function or what values they operate on. For example,
-      computed property functions may close over variables that are then no longer
-      available for introspection.
-
-      You can pass a hash of these values to a computed property like this:
+    return res;
+  });
 
-      ```
-      person: function() {
-        var personId = this.get('personId');
-        return App.Person.create({ id: personId });
-      }.property().meta({ type: App.Person })
-      ```
+  // From: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/foreach
+  var forEach = defineNativeShim(ArrayPrototype.forEach, function(fun /*, thisp */) {
+    //"use strict";
 
-      The hash that you pass to the `meta()` function will be saved on the
-      computed property descriptor under the `_meta` key. Ember runtime
-      exposes a public API for retrieving these values from classes,
-      via the `metaForProperty()` function.
+    if (this === void 0 || this === null || typeof fun !== "function") {
+      throw new TypeError();
+    }
 
-      @method meta
-      @param {Hash} meta
-      @chainable
-    */
+    var t = Object(this);
+    var len = t.length >>> 0;
+    var thisp = arguments[1];
 
-    ComputedPropertyPrototype.meta = function(meta) {
-      if (arguments.length === 0) {
-        return this._meta || {};
-      } else {
-        this._meta = meta;
-        return this;
+    for (var i = 0; i < len; i++) {
+      if (i in t) {
+        fun.call(thisp, t[i], i, t);
       }
-    };
+    }
+  });
 
-    /* impl descriptor API */
-    ComputedPropertyPrototype.didChange = function(obj, keyName) {
-      // _suspended is set via a CP.set to ensure we don't clear
-      // the cached value set by the setter
-      if (this._cacheable && this._suspended !== obj) {
-        var meta = metaFor(obj);
-        if (meta.cache[keyName] !== undefined) {
-          meta.cache[keyName] = undefined;
-          removeDependentKeys(this, obj, keyName, meta);
-        }
-      }
-    };
+  var indexOf = defineNativeShim(ArrayPrototype.indexOf, function (obj, fromIndex) {
+    if (fromIndex === null || fromIndex === undefined) {
+      fromIndex = 0;
+    } else if (fromIndex < 0) {
+      fromIndex = Math.max(0, this.length + fromIndex);
+    }
 
-    function finishChains(chainNodes)
-    {
-      for (var i=0, l=chainNodes.length; i<l; i++) {
-        chainNodes[i].didChange(null);
+    for (var i = fromIndex, j = this.length; i < j; i++) {
+      if (this[i] === obj) {
+        return i;
       }
     }
+    return -1;
+  });
 
-    /**
-      Access the value of the function backing the computed property.
-      If this property has already been cached, return the cached result.
-      Otherwise, call the function passing the property name as an argument.
-
-      ```javascript
-      var Person = Ember.Object.extend({
-        fullName: function(keyName) {
-          // the keyName parameter is 'fullName' in this case.
-          return this.get('firstName') + ' ' + this.get('lastName');
-        }.property('firstName', 'lastName')
-      });
-
-
-      var tom = Person.create({
-        firstName: 'Tom',
-        lastName: 'Dale'
-      });
-
-      tom.get('fullName') // 'Tom Dale'
-      ```
+  var lastIndexOf = defineNativeShim(ArrayPrototype.lastIndexOf, function(obj, fromIndex) {
+    var len = this.length;
+    var idx;
 
-      @method get
-      @param {String} keyName The key being accessed.
-      @return {Object} The return value of the function backing the CP.
-    */
-    ComputedPropertyPrototype.get = function(obj, keyName) {
-      var ret, cache, meta, chainNodes;
-      if (this._cacheable) {
-        meta = metaFor(obj);
-        cache = meta.cache;
+    if (fromIndex === undefined) {
+      fromIndex = len-1;
+    } else {
+      fromIndex = (fromIndex < 0) ? Math.ceil(fromIndex) : Math.floor(fromIndex);
+    }
 
-        var result = cache[keyName];
+    if (fromIndex < 0) {
+      fromIndex += len;
+    }
 
-        if (result === UNDEFINED) {
-          return undefined;
-        }  else if (result !== undefined) {
-          return result;
-        }
+    for (idx = fromIndex; idx >= 0; idx--) {
+      if (this[idx] === obj) {
+        return idx;
+      }
+    }
+    return -1;
+  });
 
-        ret = this.func.call(obj, keyName);
-        if (ret === undefined) {
-          cache[keyName] = UNDEFINED;
-        } else {
-          cache[keyName] = ret;
-        }
+  var filter = defineNativeShim(ArrayPrototype.filter, function (fn, context) {
+    var i, value;
+    var result = [];
+    var length = this.length;
 
-        chainNodes = meta.chainWatchers && meta.chainWatchers[keyName];
-        if (chainNodes) {
-          finishChains(chainNodes);
+    for (i = 0; i < length; i++) {
+      if (this.hasOwnProperty(i)) {
+        value = this[i];
+        if (fn.call(context, value, i, this)) {
+          result.push(value);
         }
-        addDependentKeys(this, obj, keyName, meta);
-      } else {
-        ret = this.func.call(obj, keyName);
       }
-      return ret;
-    };
+    }
+    return result;
+  });
 
-    /**
-      Set the value of a computed property. If the function that backs your
-      computed property does not accept arguments then the default action for
-      setting would be to define the property on the current object, and set
-      the value of the property to the value being set.
+  if (Ember.SHIM_ES5) {
+    ArrayPrototype.map = ArrayPrototype.map || map;
+    ArrayPrototype.forEach = ArrayPrototype.forEach || forEach;
+    ArrayPrototype.filter = ArrayPrototype.filter || filter;
+    ArrayPrototype.indexOf = ArrayPrototype.indexOf || indexOf;
+    ArrayPrototype.lastIndexOf = ArrayPrototype.lastIndexOf || lastIndexOf;
+  }
 
-      Generally speaking if you intend for your computed property to be set
-      your backing function should accept either two or three arguments.
+  /**
+    Array polyfills to support ES5 features in older browsers.
 
-      ```javascript
-      var Person = Ember.Object.extend({
-        // these will be supplied by `create`
-        firstName: null,
-        lastName: null,
+    @namespace Ember
+    @property ArrayPolyfills
+  */
 
-        fullName: function(key, value, oldValue) {
-          // getter
-          if (arguments.length === 1) {
-            var firstName = this.get('firstName');
-            var lastName = this.get('lastName');
+  exports.map = map;
+  exports.forEach = forEach;
+  exports.filter = filter;
+  exports.indexOf = indexOf;
+  exports.lastIndexOf = lastIndexOf;
 
-            return firstName + ' ' + lastName;
+});
+enifed('ember-metal/binding', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/utils', 'ember-metal/observer', 'ember-metal/run_loop', 'ember-metal/path_cache'], function (exports, Ember, property_get, property_set, utils, observer, run, path_cache) {
 
-          // setter
-          } else {
-            var name = value.split(' ');
+  'use strict';
 
-            this.set('firstName', name[0]);
-            this.set('lastName', name[1]);
+  exports.bind = bind;
+  exports.oneWay = oneWay;
+  exports.Binding = Binding;
 
-            return value;
-          }
-        }.property('firstName', 'lastName')
-      });
+  Ember['default'].LOG_BINDINGS = false || !!Ember['default'].ENV.LOG_BINDINGS;
 
-      var person = Person.create();
+  /**
+    Returns true if the provided path is global (e.g., `MyApp.fooController.bar`)
+    instead of local (`foo.bar.baz`).
 
-      person.set('fullName', 'Peter Wagenet');
-      person.get('firstName'); // 'Peter'
-      person.get('lastName');  // 'Wagenet'
-      ```
+    @method isGlobalPath
+    @for Ember
+    @private
+    @param {String} path
+    @return Boolean
+  */
 
-      @method set
-      @param {String} keyName The key being accessed.
-      @param {Object} newValue The new value being assigned.
-      @param {String} oldValue The old value being replaced.
-      @return {Object} The return value of the function backing the CP.
-    */
-    ComputedPropertyPrototype.set = function computedPropertySetWithSuspend(obj, keyName, value) {
-      var oldSuspended = this._suspended;
+  function getWithGlobals(obj, path) {
+    return property_get.get(path_cache.isGlobal(path) ? Ember['default'].lookup : obj, path);
+  }
 
-      this._suspended = obj;
+  // ..........................................................
+  // BINDING
+  //
 
-      try {
-        this._set(obj, keyName, value);
-      } finally {
-        this._suspended = oldSuspended;
-      }
-    };
+  function Binding(toPath, fromPath) {
+    this._direction = undefined;
+    this._from = fromPath;
+    this._to   = toPath;
+    this._readyToSync = undefined;
+    this._oneWay = undefined;
+  }
 
-    ComputedPropertyPrototype._set = function computedPropertySet(obj, keyName, value) {
-      var cacheable      = this._cacheable;
-      var func           = this.func;
-      var meta           = metaFor(obj, cacheable);
-      var cache          = meta.cache;
-      var hadCachedValue = false;
+  /**
+  @class Binding
+  @namespace Ember
+  */
 
-      var funcArgLength, cachedValue, ret;
+  Binding.prototype = {
+    /**
+      This copies the Binding so it can be connected to another object.
 
-      if (this._readOnly) {
-        throw new EmberError('Cannot set read-only property "' + keyName + '" on object: ' + inspect(obj));
-      }
+      @method copy
+      @return {Ember.Binding} `this`
+    */
+    copy: function () {
+      var copy = new Binding(this._to, this._from);
+      if (this._oneWay) { copy._oneWay = true; }
+      return copy;
+    },
 
-      if (cacheable && cache[keyName] !== undefined) {
-        if(cache[keyName] !== UNDEFINED) {
-          cachedValue = cache[keyName];
-        }
+    // ..........................................................
+    // CONFIG
+    //
 
-        hadCachedValue = true;
-      }
+    /**
+      This will set `from` property path to the specified value. It will not
+      attempt to resolve this property path to an actual object until you
+      connect the binding.
 
-      // Check if the CP has been wrapped. If it has, use the
-      // length from the wrapped function.
+      The binding will search for the property path starting at the root object
+      you pass when you `connect()` the binding. It follows the same rules as
+      `get()` - see that method for more information.
 
-      funcArgLength = func.wrappedFunction ? func.wrappedFunction.__ember_arity__ : func.__ember_arity__;
+      @method from
+      @param {String} path the property path to connect to
+      @return {Ember.Binding} `this`
+    */
+    from: function(path) {
+      this._from = path;
+      return this;
+    },
 
-      // For backwards-compatibility with computed properties
-      // that check for arguments.length === 2 to determine if
-      // they are being get or set, only pass the old cached
-      // value if the computed property opts into a third
-      // argument.
-      if (funcArgLength === 3) {
-        ret = func.call(obj, keyName, value, cachedValue);
-      } else if (funcArgLength === 2) {
-        ret = func.call(obj, keyName, value);
-      } else {
-        defineProperty(obj, keyName, null, cachedValue);
-        set(obj, keyName, value);
-        return;
-      }
+    /**
+      This will set the `to` property path to the specified value. It will not
+      attempt to resolve this property path to an actual object until you
+      connect the binding.
 
-      if (hadCachedValue && cachedValue === ret) { return; }
+      The binding will search for the property path starting at the root object
+      you pass when you `connect()` the binding. It follows the same rules as
+      `get()` - see that method for more information.
 
-      var watched = meta.watching[keyName];
-      if (watched) {
-        propertyWillChange(obj, keyName);
-      }
+      @method to
+      @param {String|Tuple} path A property path or tuple
+      @return {Ember.Binding} `this`
+    */
+    to: function(path) {
+      this._to = path;
+      return this;
+    },
 
-      if (hadCachedValue) {
-        cache[keyName] = undefined;
-      }
+    /**
+      Configures the binding as one way. A one-way binding will relay changes
+      on the `from` side to the `to` side, but not the other way around. This
+      means that if you change the `to` side directly, the `from` side may have
+      a different value.
 
-      if (cacheable) {
-        if (!hadCachedValue) {
-          addDependentKeys(this, obj, keyName, meta);
-        }
-        if (ret === undefined) {
-          cache[keyName] = UNDEFINED;
-        } else {
-          cache[keyName] = ret;
-        }
-      }
+      @method oneWay
+      @return {Ember.Binding} `this`
+    */
+    oneWay: function() {
+      this._oneWay = true;
+      return this;
+    },
 
-      if (watched) {
-        propertyDidChange(obj, keyName);
-      }
+    /**
+      @method toString
+      @return {String} string representation of binding
+    */
+    toString: function() {
+      var oneWay = this._oneWay ? '[oneWay]' : '';
+      return "Ember.Binding<" + utils.guidFor(this) + ">(" + this._from + " -> " + this._to + ")" + oneWay;
+    },
 
-      return ret;
-    };
+    // ..........................................................
+    // CONNECT AND SYNC
+    //
 
-    /* called before property is overridden */
-    ComputedPropertyPrototype.teardown = function(obj, keyName) {
-      var meta = metaFor(obj);
+    /**
+      Attempts to connect this binding instance so that it can receive and relay
+      changes. This method will raise an exception if you have not set the
+      from/to properties yet.
 
-      if (keyName in meta.cache) {
-        removeDependentKeys(this, obj, keyName, meta);
-      }
+      @method connect
+      @param {Object} obj The root object for this binding.
+      @return {Ember.Binding} `this`
+    */
+    connect: function(obj) {
+      Ember['default'].assert('Must pass a valid object to Ember.Binding.connect()', !!obj);
 
-      if (this._cacheable) { delete meta.cache[keyName]; }
+      var fromPath = this._from;
+      var toPath = this._to;
+      property_set.trySet(obj, toPath, getWithGlobals(obj, fromPath));
 
-      return null; // no value to restore
-    };
+      // add an observer on the object to be notified when the binding should be updated
+      observer.addObserver(obj, fromPath, this, this.fromDidChange);
 
+      // if the binding is a two-way binding, also set up an observer on the target
+      if (!this._oneWay) {
+        observer.addObserver(obj, toPath, this, this.toDidChange);
+      }
 
-    /**
-      This helper returns a new property descriptor that wraps the passed
-      computed property function. You can use this helper to define properties
-      with mixins or via `Ember.defineProperty()`.
+      this._readyToSync = true;
 
-      The function you pass will be used to both get and set property values.
-      The function should accept two parameters, key and value. If value is not
-      undefined you should set the value first. In either case return the
-      current value of the property.
+      return this;
+    },
 
-      A computed property defined in this way might look like this:
+    /**
+      Disconnects the binding instance. Changes will no longer be relayed. You
+      will not usually need to call this method.
 
-      ```js
-      var Person = Ember.Object.extend({
-        firstName: 'Betty',
-        lastName: 'Jones',
+      @method disconnect
+      @param {Object} obj The root object you passed when connecting the binding.
+      @return {Ember.Binding} `this`
+    */
+    disconnect: function(obj) {
+      Ember['default'].assert('Must pass a valid object to Ember.Binding.disconnect()', !!obj);
 
-        fullName: Ember.computed('firstName', 'lastName', function(key, value) {
-          return this.get('firstName') + ' ' + this.get('lastName');
-        })
-      });
+      var twoWay = !this._oneWay;
 
-      var client = Person.create();
+      // remove an observer on the object so we're no longer notified of
+      // changes that should update bindings.
+      observer.removeObserver(obj, this._from, this, this.fromDidChange);
 
-      client.get('fullName'); // 'Betty Jones'
+      // if the binding is two-way, remove the observer from the target as well
+      if (twoWay) {
+        observer.removeObserver(obj, this._to, this, this.toDidChange);
+      }
 
-      client.set('lastName', 'Fuller');
-      client.get('fullName'); // 'Betty Fuller'
-      ```
+      this._readyToSync = false; // disable scheduled syncs...
+      return this;
+    },
 
-      _Note: This is the preferred way to define computed properties when writing third-party
-      libraries that depend on or use Ember, since there is no guarantee that the user
-      will have prototype extensions enabled._
+    // ..........................................................
+    // PRIVATE
+    //
 
-      You might use this method if you disabled
-      [Prototype Extensions](http://emberjs.com/guides/configuring-ember/disabling-prototype-extensions/).
-      The alternative syntax might look like this
-      (if prototype extensions are enabled, which is the default behavior):
+    /* called when the from side changes */
+    fromDidChange: function(target) {
+      this._scheduleSync(target, 'fwd');
+    },
 
-      ```js
-      fullName: function () {
-        return this.get('firstName') + ' ' + this.get('lastName');
-      }.property('firstName', 'lastName')
-      ```
+    /* called when the to side changes */
+    toDidChange: function(target) {
+      this._scheduleSync(target, 'back');
+    },
 
-      @method computed
-      @for Ember
-      @param {String} [dependentKeys*] Optional dependent keys that trigger this computed property.
-      @param {Function} func The computed property function.
-      @return {Ember.ComputedProperty} property descriptor instance
-    */
-    function computed(func) {
-      var args;
+    _scheduleSync: function(obj, dir) {
+      var existingDir = this._direction;
 
-      if (arguments.length > 1) {
-        args = a_slice.call(arguments);
-        func = args.pop();
+      // if we haven't scheduled the binding yet, schedule it
+      if (existingDir === undefined) {
+        run['default'].schedule('sync', this, this._sync, obj);
+        this._direction  = dir;
       }
 
-      if (typeof func !== "function") {
-        throw new EmberError("Computed Property declared without a property function");
+      // If both a 'back' and 'fwd' sync have been scheduled on the same object,
+      // default to a 'fwd' sync so that it remains deterministic.
+      if (existingDir === 'back' && dir === 'fwd') {
+        this._direction = 'fwd';
       }
+    },
 
-      var cp = new ComputedProperty(func);
+    _sync: function(obj) {
+      var log = Ember['default'].LOG_BINDINGS;
 
-      if (args) {
-        cp.property.apply(cp, args);
-      }
+      // don't synchronize destroyed objects or disconnected bindings
+      if (obj.isDestroyed || !this._readyToSync) { return; }
 
-      return cp;
-    }
+      // get the direction of the binding for the object we are
+      // synchronizing from
+      var direction = this._direction;
 
-    /**
-      Returns the cached value for a property, if one exists.
-      This can be useful for peeking at the value of a computed
-      property that is generated lazily, without accidentally causing
-      it to be created.
+      var fromPath = this._from;
+      var toPath = this._to;
 
-      @method cacheFor
-      @for Ember
-      @param {Object} obj the object whose property you want to check
-      @param {String} key the name of the property whose cached value you want
-        to return
-      @return {Object} the cached value
-    */
-    function cacheFor(obj, key) {
-      var meta = obj['__ember_meta__'];
-      var cache = meta && meta.cache;
-      var ret = cache && cache[key];
+      this._direction = undefined;
 
-      if (ret === UNDEFINED) {
-        return undefined;
+      // if we're synchronizing from the remote object...
+      if (direction === 'fwd') {
+        var fromValue = getWithGlobals(obj, this._from);
+        if (log) {
+          Ember['default'].Logger.log(' ', this.toString(), '->', fromValue, obj);
+        }
+        if (this._oneWay) {
+          property_set.trySet(obj, toPath, fromValue);
+        } else {
+          observer._suspendObserver(obj, toPath, this, this.toDidChange, function () {
+            property_set.trySet(obj, toPath, fromValue);
+          });
+        }
+      // if we're synchronizing *to* the remote object
+      } else if (direction === 'back') {
+        var toValue = property_get.get(obj, this._to);
+        if (log) {
+          Ember['default'].Logger.log(' ', this.toString(), '<-', toValue, obj);
+        }
+        observer._suspendObserver(obj, fromPath, this, this.fromDidChange, function () {
+          property_set.trySet(path_cache.isGlobal(fromPath) ? Ember['default'].lookup : obj, fromPath, toValue);
+        });
       }
-      return ret;
     }
 
-    cacheFor.set = function(cache, key, value) {
-      if (value === undefined) {
-        cache[key] = UNDEFINED;
-      } else {
-        cache[key] = value;
-      }
-    };
+  };
 
-    cacheFor.get = function(cache, key) {
-      var ret = cache[key];
-      if (ret === UNDEFINED) {
-        return undefined;
+  function mixinProperties(to, from) {
+    for (var key in from) {
+      if (from.hasOwnProperty(key)) {
+        to[key] = from[key];
       }
-      return ret;
-    };
+    }
+  }
 
-    cacheFor.remove = function(cache, key) {
-      cache[key] = undefined;
-    };
+  mixinProperties(Binding, {
 
-    __exports__.ComputedProperty = ComputedProperty;
-    __exports__.computed = computed;
-    __exports__.cacheFor = cacheFor;
-  });
-enifed("ember-metal/computed_macros",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/computed","ember-metal/is_empty","ember-metal/is_none","ember-metal/alias"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var get = __dependency2__.get;
-    var set = __dependency3__.set;
-    var computed = __dependency4__.computed;
-    var isEmpty = __dependency5__["default"];
-    var isNone = __dependency6__["default"];
-    var alias = __dependency7__["default"];
+    /*
+      See `Ember.Binding.from`.
 
-    /**
-    @module ember-metal
+      @method from
+      @static
     */
+    from: function(from) {
+      var C = this;
+      return new C(undefined, from);
+    },
 
-    var a_slice = [].slice;
-
-    function getProperties(self, propertyNames) {
-      var ret = {};
-      for(var i = 0; i < propertyNames.length; i++) {
-        ret[propertyNames[i]] = get(self, propertyNames[i]);
-      }
-      return ret;
-    }
+    /*
+      See `Ember.Binding.to`.
 
-    function registerComputed(name, macro) {
-      computed[name] = function(dependentKey) {
-        var args = a_slice.call(arguments);
-        return computed(dependentKey, function() {
-          return macro.apply(this, args);
-        });
-      };
-    }
+      @method to
+      @static
+    */
+    to: function(to) {
+      var C = this;
+      return new C(to, undefined);
+    },
 
-    function registerComputedWithProperties(name, macro) {
-      computed[name] = function() {
-        var properties = a_slice.call(arguments);
+    /**
+      Creates a new Binding instance and makes it apply in a single direction.
+      A one-way binding will relay changes on the `from` side object (supplied
+      as the `from` argument) the `to` side, but not the other way around.
+      This means that if you change the "to" side directly, the "from" side may have
+      a different value.
 
-        var computedFunc = computed(function() {
-          return macro.apply(this, [getProperties(this, properties)]);
-        });
+      See `Binding.oneWay`.
 
-        return computedFunc.property.apply(computedFunc, properties);
-      };
+      @method oneWay
+      @param {String} from from path.
+      @param {Boolean} [flag] (Optional) passing nothing here will make the
+        binding `oneWay`. You can instead pass `false` to disable `oneWay`, making the
+        binding two way again.
+      @return {Ember.Binding} `this`
+    */
+    oneWay: function(from, flag) {
+      var C = this;
+      return new C(undefined, from).oneWay(flag);
     }
 
-    /**
-      A computed property that returns true if the value of the dependent
-      property is null, an empty string, empty array, or empty function.
+  });
+  /**
+    An `Ember.Binding` connects the properties of two objects so that whenever
+    the value of one property changes, the other property will be changed also.
 
-      Example
+    ## Automatic Creation of Bindings with `/^*Binding/`-named Properties
 
-      ```javascript
-      var ToDoList = Ember.Object.extend({
-        isDone: Ember.computed.empty('todos')
-      });
+    You do not usually create Binding objects directly but instead describe
+    bindings in your class or object definition using automatic binding
+    detection.
 
-      var todoList = ToDoList.create({
-        todos: ['Unit Test', 'Documentation', 'Release']
-      });
+    Properties ending in a `Binding` suffix will be converted to `Ember.Binding`
+    instances. The value of this property should be a string representing a path
+    to another object or a custom binding instance created using Binding helpers
+    (see "One Way Bindings"):
 
-      todoList.get('isDone'); // false
-      todoList.get('todos').clear();
-      todoList.get('isDone'); // true
-      ```
+    ```
+    valueBinding: "MyApp.someController.title"
+    ```
 
-      @since 1.6.0
-      @method computed.empty
-      @for Ember
-      @param {String} dependentKey
-      @return {Ember.ComputedProperty} computed property which negate
-      the original value for property
-    */
-    computed.empty = function (dependentKey) {
-      return computed(dependentKey + '.length', function () {
-        return isEmpty(get(this, dependentKey));
-      });
-    };
+    This will create a binding from `MyApp.someController.title` to the `value`
+    property of your object instance automatically. Now the two values will be
+    kept in sync.
 
-    /**
-      A computed property that returns true if the value of the dependent
-      property is NOT null, an empty string, empty array, or empty function.
+    ## One Way Bindings
 
-      Example
+    One especially useful binding customization you can use is the `oneWay()`
+    helper. This helper tells Ember that you are only interested in
+    receiving changes on the object you are binding from. For example, if you
+    are binding to a preference and you want to be notified if the preference
+    has changed, but your object will not be changing the preference itself, you
+    could do:
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        hasStuff: Ember.computed.notEmpty('backpack')
-      });
+    ```
+    bigTitlesBinding: Ember.Binding.oneWay("MyApp.preferencesController.bigTitles")
+    ```
 
-      var hamster = Hamster.create({ backpack: ['Food', 'Sleeping Bag', 'Tent'] });
+    This way if the value of `MyApp.preferencesController.bigTitles` changes the
+    `bigTitles` property of your object will change also. However, if you
+    change the value of your `bigTitles` property, it will not update the
+    `preferencesController`.
 
-      hamster.get('hasStuff');         // true
-      hamster.get('backpack').clear(); // []
-      hamster.get('hasStuff');         // false
-      ```
+    One way bindings are almost twice as fast to setup and twice as fast to
+    execute because the binding only has to worry about changes to one side.
 
-      @method computed.notEmpty
-      @for Ember
-      @param {String} dependentKey
-      @return {Ember.ComputedProperty} computed property which returns true if
-      original value for property is not empty.
-    */
-    computed.notEmpty = function(dependentKey) {
-      return computed(dependentKey + '.length', function () {
-        return !isEmpty(get(this, dependentKey));
-      });
-    };
+    You should consider using one way bindings anytime you have an object that
+    may be created frequently and you do not intend to change a property; only
+    to monitor it for changes (such as in the example above).
 
-    /**
-      A computed property that returns true if the value of the dependent
-      property is null or undefined. This avoids errors from JSLint complaining
-      about use of ==, which can be technically confusing.
+    ## Adding Bindings Manually
 
-      Example
+    All of the examples above show you how to configure a custom binding, but the
+    result of these customizations will be a binding template, not a fully active
+    Binding instance. The binding will actually become active only when you
+    instantiate the object the binding belongs to. It is useful however, to
+    understand what actually happens when the binding is activated.
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        isHungry: Ember.computed.none('food')
-      });
+    For a binding to function it must have at least a `from` property and a `to`
+    property. The `from` property path points to the object/key that you want to
+    bind from while the `to` path points to the object/key you want to bind to.
 
-      var hamster = Hamster.create();
+    When you define a custom binding, you are usually describing the property
+    you want to bind from (such as `MyApp.someController.value` in the examples
+    above). When your object is created, it will automatically assign the value
+    you want to bind `to` based on the name of your binding key. In the
+    examples above, during init, Ember objects will effectively call
+    something like this on your binding:
 
-      hamster.get('isHungry'); // true
-      hamster.set('food', 'Banana');
-      hamster.get('isHungry'); // false
-      hamster.set('food', null);
-      hamster.get('isHungry'); // true
-      ```
+    ```javascript
+    binding = Ember.Binding.from("valueBinding").to("value");
+    ```
 
-      @method computed.none
-      @for Ember
-      @param {String} dependentKey
-      @return {Ember.ComputedProperty} computed property which
-      returns true if original value for property is null or undefined.
-    */
-    registerComputed('none', function(dependentKey) {
-      return isNone(get(this, dependentKey));
-    });
+    This creates a new binding instance based on the template you provide, and
+    sets the to path to the `value` property of the new object. Now that the
+    binding is fully configured with a `from` and a `to`, it simply needs to be
+    connected to become active. This is done through the `connect()` method:
 
-    /**
-      A computed property that returns the inverse boolean value
-      of the original value for the dependent property.
+    ```javascript
+    binding.connect(this);
+    ```
 
-      Example
+    Note that when you connect a binding you pass the object you want it to be
+    connected to. This object will be used as the root for both the from and
+    to side of the binding when inspecting relative paths. This allows the
+    binding to be automatically inherited by subclassed objects as well.
 
-      ```javascript
-      var User = Ember.Object.extend({
-        isAnonymous: Ember.computed.not('loggedIn')
-      });
+    This also allows you to bind between objects using the paths you declare in
+    `from` and `to`:
 
-      var user = User.create({loggedIn: false});
+    ```javascript
+    // Example 1
+    binding = Ember.Binding.from("App.someObject.value").to("value");
+    binding.connect(this);
 
-      user.get('isAnonymous'); // true
-      user.set('loggedIn', true);
-      user.get('isAnonymous'); // false
-      ```
+    // Example 2
+    binding = Ember.Binding.from("parentView.value").to("App.someObject.value");
+    binding.connect(this);
+    ```
 
-      @method computed.not
-      @for Ember
-      @param {String} dependentKey
-      @return {Ember.ComputedProperty} computed property which returns
-      inverse of the original value for property
-    */
-    registerComputed('not', function(dependentKey) {
-      return !get(this, dependentKey);
-    });
+    Now that the binding is connected, it will observe both the from and to side
+    and relay changes.
 
-    /**
-      A computed property that converts the provided dependent property
-      into a boolean value.
+    If you ever needed to do so (you almost never will, but it is useful to
+    understand this anyway), you could manually create an active binding by
+    using the `Ember.bind()` helper method. (This is the same method used by
+    to setup your bindings on objects):
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        hasBananas: Ember.computed.bool('numBananas')
-      });
+    ```javascript
+    Ember.bind(MyApp.anotherObject, "value", "MyApp.someController.value");
+    ```
 
-      var hamster = Hamster.create();
+    Both of these code fragments have the same effect as doing the most friendly
+    form of binding creation like so:
 
-      hamster.get('hasBananas'); // false
-      hamster.set('numBananas', 0);
-      hamster.get('hasBananas'); // false
-      hamster.set('numBananas', 1);
-      hamster.get('hasBananas'); // true
-      hamster.set('numBananas', null);
-      hamster.get('hasBananas'); // false
-      ```
+    ```javascript
+    MyApp.anotherObject = Ember.Object.create({
+      valueBinding: "MyApp.someController.value",
 
-      @method computed.bool
-      @for Ember
-      @param {String} dependentKey
-      @return {Ember.ComputedProperty} computed property which converts
-      to boolean the original value for property
-    */
-    registerComputed('bool', function(dependentKey) {
-      return !!get(this, dependentKey);
+      // OTHER CODE FOR THIS OBJECT...
     });
+    ```
 
-    /**
-      A computed property which matches the original value for the
-      dependent property against a given RegExp, returning `true`
-      if they values matches the RegExp and `false` if it does not.
+    Ember's built in binding creation method makes it easy to automatically
+    create bindings for you. You should always use the highest-level APIs
+    available, even if you understand how it works underneath.
 
-      Example
+    @class Binding
+    @namespace Ember
+    @since Ember 0.9
+  */
+  // Ember.Binding = Binding; ES6TODO: where to put this?
+
+
+  /**
+    Global helper method to create a new binding. Just pass the root object
+    along with a `to` and `from` path to create and connect the binding.
+
+    @method bind
+    @for Ember
+    @param {Object} obj The root object of the transform.
+    @param {String} to The path to the 'to' side of the binding.
+      Must be relative to obj.
+    @param {String} from The path to the 'from' side of the binding.
+      Must be relative to obj or a global path.
+    @return {Ember.Binding} binding instance
+  */
+  function bind(obj, to, from) {
+    return new Binding(to, from).connect(obj);
+  }
 
-      ```javascript
-      var User = Ember.Object.extend({
-        hasValidEmail: Ember.computed.match('email', /^.+@.+\..+$/)
-      });
+  /**
+    @method oneWay
+    @for Ember
+    @param {Object} obj The root object of the transform.
+    @param {String} to The path to the 'to' side of the binding.
+      Must be relative to obj.
+    @param {String} from The path to the 'from' side of the binding.
+      Must be relative to obj or a global path.
+    @return {Ember.Binding} binding instance
+  */
+  function oneWay(obj, to, from) {
+    return new Binding(to, from).oneWay().connect(obj);
+  }
 
-      var user = User.create({loggedIn: false});
+  exports.isGlobalPath = path_cache.isGlobal;
 
-      user.get('hasValidEmail'); // false
-      user.set('email', '');
-      user.get('hasValidEmail'); // false
-      user.set('email', 'ember_hamster@example.com');
-      user.get('hasValidEmail'); // true
-      ```
+});
+enifed('ember-metal/cache', ['exports', 'ember-metal/dictionary'], function (exports, dictionary) {
 
-      @method computed.match
-      @for Ember
-      @param {String} dependentKey
-      @param {RegExp} regexp
-      @return {Ember.ComputedProperty} computed property which match
-      the original value for property against a given RegExp
-    */
-    registerComputed('match', function(dependentKey, regexp) {
-      var value = get(this, dependentKey);
-      return typeof value === 'string' ? regexp.test(value) : false;
-    });
+  'use strict';
 
-    /**
-      A computed property that returns true if the provided dependent property
-      is equal to the given value.
+  exports['default'] = Cache;
 
-      Example
+  function Cache(limit, func) {
+    this.store  = dictionary['default'](null);
+    this.size   = 0;
+    this.misses = 0;
+    this.hits   = 0;
+    this.limit  = limit;
+    this.func   = func;
+  }
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        napTime: Ember.computed.equal('state', 'sleepy')
-      });
+  var UNDEFINED = function() { };
 
-      var hamster = Hamster.create();
+  Cache.prototype = {
+    set: function(key, value) {
+      if (this.limit > this.size) {
+        this.size ++;
+        if (value === undefined) {
+          this.store[key] = UNDEFINED;
+        } else {
+          this.store[key] = value;
+        }
+      }
 
-      hamster.get('napTime'); // false
-      hamster.set('state', 'sleepy');
-      hamster.get('napTime'); // true
-      hamster.set('state', 'hungry');
-      hamster.get('napTime'); // false
-      ```
+      return value;
+    },
 
-      @method computed.equal
-      @for Ember
-      @param {String} dependentKey
-      @param {String|Number|Object} value
-      @return {Ember.ComputedProperty} computed property which returns true if
-      the original value for property is equal to the given value.
-    */
-    registerComputed('equal', function(dependentKey, value) {
-      return get(this, dependentKey) === value;
-    });
+    get: function(key) {
+      var value = this.store[key];
 
-    /**
-      A computed property that returns true if the provided dependent property
-      is greater than the provided value.
+      if (value === undefined) {
+        this.misses ++;
+        value = this.set(key, this.func(key));
+      } else if (value === UNDEFINED) {
+        this.hits ++;
+        value = undefined;
+      } else {
+        this.hits ++;
+        // nothing to translate
+      }
 
-      Example
+      return value;
+    },
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        hasTooManyBananas: Ember.computed.gt('numBananas', 10)
-      });
+    purge: function() {
+      this.store  = dictionary['default'](null);
+      this.size   = 0;
+      this.hits   = 0;
+      this.misses = 0;
+    }
+  };
 
-      var hamster = Hamster.create();
+});
+enifed('ember-metal/chains', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/utils', 'ember-metal/array', 'ember-metal/watch_key'], function (exports, Ember, property_get, utils, array, watch_key) {
 
-      hamster.get('hasTooManyBananas'); // false
-      hamster.set('numBananas', 3);
-      hamster.get('hasTooManyBananas'); // false
-      hamster.set('numBananas', 11);
-      hamster.get('hasTooManyBananas'); // true
-      ```
+  'use strict';
 
-      @method computed.gt
-      @for Ember
-      @param {String} dependentKey
-      @param {Number} value
-      @return {Ember.ComputedProperty} computed property which returns true if
-      the original value for property is greater than given value.
-    */
-    registerComputed('gt', function(dependentKey, value) {
-      return get(this, dependentKey) > value;
-    });
+  exports.flushPendingChains = flushPendingChains;
+  exports.finishChains = finishChains;
+  exports.removeChainWatcher = removeChainWatcher;
+  exports.ChainNode = ChainNode;
 
-    /**
-      A computed property that returns true if the provided dependent property
-      is greater than or equal to the provided value.
+  var warn = Ember['default'].warn;
+  var FIRST_KEY = /^([^\.]+)/;
 
-      Example
+  function firstKey(path) {
+    return path.match(FIRST_KEY)[0];
+  }
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        hasTooManyBananas: Ember.computed.gte('numBananas', 10)
-      });
+  var pendingQueue = [];
 
-      var hamster = Hamster.create();
+  // attempts to add the pendingQueue chains again. If some of them end up
+  // back in the queue and reschedule is true, schedules a timeout to try
+  // again.
+  function flushPendingChains() {
+    if (pendingQueue.length === 0) { return; } // nothing to do
 
-      hamster.get('hasTooManyBananas'); // false
-      hamster.set('numBananas', 3);
-      hamster.get('hasTooManyBananas'); // false
-      hamster.set('numBananas', 10);
-      hamster.get('hasTooManyBananas'); // true
-      ```
+    var queue = pendingQueue;
+    pendingQueue = [];
 
-      @method computed.gte
-      @for Ember
-      @param {String} dependentKey
-      @param {Number} value
-      @return {Ember.ComputedProperty} computed property which returns true if
-      the original value for property is greater or equal then given value.
-    */
-    registerComputed('gte', function(dependentKey, value) {
-      return get(this, dependentKey) >= value;
+    array.forEach.call(queue, function(q) {
+      q[0].add(q[1]);
     });
 
-    /**
-      A computed property that returns true if the provided dependent property
-      is less than the provided value.
+    warn('Watching an undefined global, Ember expects watched globals to be' +
+         ' setup by the time the run loop is flushed, check for typos', pendingQueue.length === 0);
+  }
 
-      Example
+  function addChainWatcher(obj, keyName, node) {
+    if (!obj || ('object' !== typeof obj)) { return; } // nothing to do
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        needsMoreBananas: Ember.computed.lt('numBananas', 3)
-      });
+    var m = utils.meta(obj);
+    var nodes = m.chainWatchers;
 
-      var hamster = Hamster.create();
+    if (!m.hasOwnProperty('chainWatchers')) { // FIXME?!
+      nodes = m.chainWatchers = {};
+    }
 
-      hamster.get('needsMoreBananas'); // true
-      hamster.set('numBananas', 3);
-      hamster.get('needsMoreBananas'); // false
-      hamster.set('numBananas', 2);
-      hamster.get('needsMoreBananas'); // true
-      ```
+    if (!nodes[keyName]) {
+      nodes[keyName] = [];
+    }
+    nodes[keyName].push(node);
+    watch_key.watchKey(obj, keyName, m);
+  }
 
-      @method computed.lt
-      @for Ember
-      @param {String} dependentKey
-      @param {Number} value
-      @return {Ember.ComputedProperty} computed property which returns true if
-      the original value for property is less then given value.
-    */
-    registerComputed('lt', function(dependentKey, value) {
-      return get(this, dependentKey) < value;
-    });
+  function removeChainWatcher(obj, keyName, node) {
+    if (!obj || 'object' !== typeof obj) { return; } // nothing to do
 
-    /**
-      A computed property that returns true if the provided dependent property
-      is less than or equal to the provided value.
+    var m = obj['__ember_meta__'];
+    if (m && !m.hasOwnProperty('chainWatchers')) { return; } // nothing to do
+
+    var nodes = m && m.chainWatchers;
+
+    if (nodes && nodes[keyName]) {
+      nodes = nodes[keyName];
+      for (var i = 0, l = nodes.length; i < l; i++) {
+        if (nodes[i] === node) {
+          nodes.splice(i, 1);
+          break;
+        }
+      }
+    }
+    watch_key.unwatchKey(obj, keyName, m);
+  }
+
+  // A ChainNode watches a single key on an object. If you provide a starting
+  // value for the key then the node won't actually watch it. For a root node
+  // pass null for parent and key and object for value.
+  function ChainNode(parent, key, value) {
+    this._parent = parent;
+    this._key    = key;
+
+    // _watching is true when calling get(this._parent, this._key) will
+    // return the value of this node.
+    //
+    // It is false for the root of a chain (because we have no parent)
+    // and for global paths (because the parent node is the object with
+    // the observer on it)
+    this._watching = value===undefined;
+
+    this._value  = value;
+    this._paths = {};
+    if (this._watching) {
+      this._object = parent.value();
+      if (this._object) {
+        addChainWatcher(this._object, this._key, this);
+      }
+    }
 
-      Example
+    // Special-case: the EachProxy relies on immediate evaluation to
+    // establish its observers.
+    //
+    // TODO: Replace this with an efficient callback that the EachProxy
+    // can implement.
+    if (this._parent && this._parent._key === '@each') {
+      this.value();
+    }
+  }
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        needsMoreBananas: Ember.computed.lte('numBananas', 3)
-      });
+  var ChainNodePrototype = ChainNode.prototype;
 
-      var hamster = Hamster.create();
+  function lazyGet(obj, key) {
+    if (!obj) {
+      return undefined;
+    }
 
-      hamster.get('needsMoreBananas'); // true
-      hamster.set('numBananas', 5);
-      hamster.get('needsMoreBananas'); // false
-      hamster.set('numBananas', 3);
-      hamster.get('needsMoreBananas'); // true
-      ```
+    var meta = obj['__ember_meta__'];
+    // check if object meant only to be a prototype
+    if (meta && meta.proto === obj) {
+      return undefined;
+    }
 
-      @method computed.lte
-      @for Ember
-      @param {String} dependentKey
-      @param {Number} value
-      @return {Ember.ComputedProperty} computed property which returns true if
-      the original value for property is less or equal than given value.
-    */
-    registerComputed('lte', function(dependentKey, value) {
-      return get(this, dependentKey) <= value;
-    });
+    if (key === "@each") {
+      return property_get.get(obj, key);
+    }
 
-    /**
-      A computed property that performs a logical `and` on the
-      original values for the provided dependent properties.
+    // if a CP only return cached value
+    var possibleDesc = obj[key];
+    var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
+    if (desc && desc._cacheable) {
+      if (meta.cache && key in meta.cache) {
+        return meta.cache[key];
+      } else {
+        return undefined;
+      }
+    }
 
-      Example
+    return property_get.get(obj, key);
+  }
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        readyForCamp: Ember.computed.and('hasTent', 'hasBackpack')
-      });
+  ChainNodePrototype.value = function() {
+    if (this._value === undefined && this._watching) {
+      var obj = this._parent.value();
+      this._value = lazyGet(obj, this._key);
+    }
+    return this._value;
+  };
 
-      var hamster = Hamster.create();
+  ChainNodePrototype.destroy = function() {
+    if (this._watching) {
+      var obj = this._object;
+      if (obj) {
+        removeChainWatcher(obj, this._key, this);
+      }
+      this._watching = false; // so future calls do nothing
+    }
+  };
 
-      hamster.get('readyForCamp'); // false
-      hamster.set('hasTent', true);
-      hamster.get('readyForCamp'); // false
-      hamster.set('hasBackpack', true);
-      hamster.get('readyForCamp'); // true
-      ```
+  // copies a top level object only
+  ChainNodePrototype.copy = function(obj) {
+    var ret = new ChainNode(null, null, obj);
+    var paths = this._paths;
+    var path;
 
-      @method computed.and
-      @for Ember
-      @param {String} dependentKey*
-      @return {Ember.ComputedProperty} computed property which performs
-      a logical `and` on the values of all the original values for properties.
-    */
-    registerComputedWithProperties('and', function(properties) {
-      for (var key in properties) {
-        if (properties.hasOwnProperty(key) && !properties[key]) {
-          return false;
-        }
+    for (path in paths) {
+      // this check will also catch non-number vals.
+      if (paths[path] <= 0) {
+        continue;
       }
-      return true;
-    });
+      ret.add(path);
+    }
+    return ret;
+  };
 
-    /**
-      A computed property which performs a logical `or` on the
-      original values for the provided dependent properties.
+  // called on the root node of a chain to setup watchers on the specified
+  // path.
+  ChainNodePrototype.add = function(path) {
+    var obj, tuple, key, src, paths;
 
-      Example
+    paths = this._paths;
+    paths[path] = (paths[path] || 0) + 1;
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        readyForRain: Ember.computed.or('hasJacket', 'hasUmbrella')
-      });
+    obj = this.value();
+    tuple = property_get.normalizeTuple(obj, path);
 
-      var hamster = Hamster.create();
+    // the path was a local path
+    if (tuple[0] && tuple[0] === obj) {
+      path = tuple[1];
+      key  = firstKey(path);
+      path = path.slice(key.length+1);
 
-      hamster.get('readyForRain'); // false
-      hamster.set('hasJacket', true);
-      hamster.get('readyForRain'); // true
-      ```
+    // global path, but object does not exist yet.
+    // put into a queue and try to connect later.
+    } else if (!tuple[0]) {
+      pendingQueue.push([this, path]);
+      tuple.length = 0;
+      return;
 
-      @method computed.or
-      @for Ember
-      @param {String} dependentKey*
-      @return {Ember.ComputedProperty} computed property which performs
-      a logical `or` on the values of all the original values for properties.
-    */
-    registerComputedWithProperties('or', function(properties) {
-      for (var key in properties) {
-        if (properties.hasOwnProperty(key) && properties[key]) {
-          return true;
-        }
-      }
-      return false;
-    });
+    // global path, and object already exists
+    } else {
+      src  = tuple[0];
+      key  = path.slice(0, 0-(tuple[1].length+1));
+      path = tuple[1];
+    }
 
-    /**
-      A computed property that returns the first truthy value
-      from a list of dependent properties.
+    tuple.length = 0;
+    this.chain(key, path, src);
+  };
 
-      Example
+  // called on the root node of a chain to teardown watcher on the specified
+  // path
+  ChainNodePrototype.remove = function(path) {
+    var obj, tuple, key, src, paths;
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        hasClothes: Ember.computed.any('hat', 'shirt')
-      });
+    paths = this._paths;
+    if (paths[path] > 0) {
+      paths[path]--;
+    }
 
-      var hamster = Hamster.create();
+    obj = this.value();
+    tuple = property_get.normalizeTuple(obj, path);
+    if (tuple[0] === obj) {
+      path = tuple[1];
+      key  = firstKey(path);
+      path = path.slice(key.length+1);
+    } else {
+      src  = tuple[0];
+      key  = path.slice(0, 0-(tuple[1].length+1));
+      path = tuple[1];
+    }
 
-      hamster.get('hasClothes'); // null
-      hamster.set('shirt', 'Hawaiian Shirt');
-      hamster.get('hasClothes'); // 'Hawaiian Shirt'
-      ```
+    tuple.length = 0;
+    this.unchain(key, path);
+  };
 
-      @method computed.any
-      @for Ember
-      @param {String} dependentKey*
-      @return {Ember.ComputedProperty} computed property which returns
-      the first truthy value of given list of properties.
-    */
-    registerComputedWithProperties('any', function(properties) {
-      for (var key in properties) {
-        if (properties.hasOwnProperty(key) && properties[key]) {
-          return properties[key];
-        }
-      }
-      return null;
-    });
+  ChainNodePrototype.count = 0;
 
-    /**
-      A computed property that returns the array of values
-      for the provided dependent properties.
+  ChainNodePrototype.chain = function(key, path, src) {
+    var chains = this._chains;
+    var node;
+    if (!chains) {
+      chains = this._chains = {};
+    }
 
-      Example
+    node = chains[key];
+    if (!node) {
+      node = chains[key] = new ChainNode(this, key, src);
+    }
+    node.count++; // count chains...
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        clothes: Ember.computed.collect('hat', 'shirt')
-      });
+    // chain rest of path if there is one
+    if (path) {
+      key = firstKey(path);
+      path = path.slice(key.length+1);
+      node.chain(key, path); // NOTE: no src means it will observe changes...
+    }
+  };
 
-      var hamster = Hamster.create();
+  ChainNodePrototype.unchain = function(key, path) {
+    var chains = this._chains;
+    var node = chains[key];
 
-      hamster.get('clothes'); // [null, null]
-      hamster.set('hat', 'Camp Hat');
-      hamster.set('shirt', 'Camp Shirt');
-      hamster.get('clothes'); // ['Camp Hat', 'Camp Shirt']
-      ```
+    // unchain rest of path first...
+    if (path && path.length > 1) {
+      var nextKey  = firstKey(path);
+      var nextPath = path.slice(nextKey.length + 1);
+      node.unchain(nextKey, nextPath);
+    }
 
-      @method computed.collect
-      @for Ember
-      @param {String} dependentKey*
-      @return {Ember.ComputedProperty} computed property which maps
-      values of all passed in properties to an array.
-    */
-    registerComputedWithProperties('collect', function(properties) {
-      var res = Ember.A();
-      for (var key in properties) {
-        if (properties.hasOwnProperty(key)) {
-          if (isNone(properties[key])) {
-            res.push(null);
-          } else {
-            res.push(properties[key]);
-          }
+    // delete node if needed.
+    node.count--;
+    if (node.count<=0) {
+      delete chains[node._key];
+      node.destroy();
+    }
+
+  };
+
+  ChainNodePrototype.willChange = function(events) {
+    var chains = this._chains;
+    if (chains) {
+      for (var key in chains) {
+        if (!chains.hasOwnProperty(key)) {
+          continue;
         }
+        chains[key].willChange(events);
       }
-      return res;
-    });
+    }
 
-    /**
-      Creates a new property that is an alias for another property
-      on an object. Calls to `get` or `set` this property behave as
-      though they were called on the original property.
+    if (this._parent) {
+      this._parent.chainWillChange(this, this._key, 1, events);
+    }
+  };
 
-      ```javascript
-      var Person = Ember.Object.extend({
-        name: 'Alex Matchneer',
-        nomen: Ember.computed.alias('name')
-      });
+  ChainNodePrototype.chainWillChange = function(chain, path, depth, events) {
+    if (this._key) {
+      path = this._key + '.' + path;
+    }
 
-      var alex = Person.create();
+    if (this._parent) {
+      this._parent.chainWillChange(this, path, depth+1, events);
+    } else {
+      if (depth > 1) {
+        events.push(this.value(), path);
+      }
+      path = 'this.' + path;
+      if (this._paths[path] > 0) {
+        events.push(this.value(), path);
+      }
+    }
+  };
 
-      alex.get('nomen'); // 'Alex Matchneer'
-      alex.get('name');  // 'Alex Matchneer'
+  ChainNodePrototype.chainDidChange = function(chain, path, depth, events) {
+    if (this._key) {
+      path = this._key + '.' + path;
+    }
 
-      alex.set('nomen', '@machty');
-      alex.get('name');  // '@machty'
-      ```
+    if (this._parent) {
+      this._parent.chainDidChange(this, path, depth+1, events);
+    } else {
+      if (depth > 1) {
+        events.push(this.value(), path);
+      }
+      path = 'this.' + path;
+      if (this._paths[path] > 0) {
+        events.push(this.value(), path);
+      }
+    }
+  };
 
-      @method computed.alias
-      @for Ember
-      @param {String} dependentKey
-      @return {Ember.ComputedProperty} computed property which creates an
-      alias to the original value for property.
-    */
-    computed.alias = alias;
+  ChainNodePrototype.didChange = function(events) {
+    // invalidate my own value first.
+    if (this._watching) {
+      var obj = this._parent.value();
+      if (obj !== this._object) {
+        removeChainWatcher(this._object, this._key, this);
+        this._object = obj;
+        addChainWatcher(obj, this._key, this);
+      }
+      this._value  = undefined;
 
-    /**
-      Where `computed.alias` aliases `get` and `set`, and allows for bidirectional
-      data flow, `computed.oneWay` only provides an aliased `get`. The `set` will
-      not mutate the upstream property, rather causes the current property to
-      become the value set. This causes the downstream property to permanently
-      diverge from the upstream property.
+      // Special-case: the EachProxy relies on immediate evaluation to
+      // establish its observers.
+      if (this._parent && this._parent._key === '@each') {
+        this.value();
+      }
+    }
 
-      Example
+    // then notify chains...
+    var chains = this._chains;
+    if (chains) {
+      for (var key in chains) {
+        if (!chains.hasOwnProperty(key)) { continue; }
+        chains[key].didChange(events);
+      }
+    }
 
-      ```javascript
-      var User = Ember.Object.extend({
-        firstName: null,
-        lastName: null,
-        nickName: Ember.computed.oneWay('firstName')
-      });
+    // if no events are passed in then we only care about the above wiring update
+    if (events === null) {
+      return;
+    }
 
-      var teddy = User.create({
-        firstName: 'Teddy',
-        lastName:  'Zeenny'
-      });
+    // and finally tell parent about my path changing...
+    if (this._parent) {
+      this._parent.chainDidChange(this, this._key, 1, events);
+    }
+  };
 
-      teddy.get('nickName');              // 'Teddy'
-      teddy.set('nickName', 'TeddyBear'); // 'TeddyBear'
-      teddy.get('firstName');             // 'Teddy'
-      ```
+  function finishChains(obj) {
+    // We only create meta if we really have to
+    var m = obj['__ember_meta__'];
+    var chains, chainWatchers, chainNodes;
 
-      @method computed.oneWay
-      @for Ember
-      @param {String} dependentKey
-      @return {Ember.ComputedProperty} computed property which creates a
-      one way computed property to the original value for property.
-    */
-    computed.oneWay = function(dependentKey) {
-      return alias(dependentKey).oneWay();
-    };
+    if (m) {
+      // finish any current chains node watchers that reference obj
+      chainWatchers = m.chainWatchers;
+      if (chainWatchers) {
+        for (var key in chainWatchers) {
+          if (!chainWatchers.hasOwnProperty(key)) {
+            continue;
+          }
 
-    /**
-      This is a more semantically meaningful alias of `computed.oneWay`,
-      whose name is somewhat ambiguous as to which direction the data flows.
+          chainNodes = chainWatchers[key];
+          if (chainNodes) {
+            for (var i=0,l=chainNodes.length;i<l;i++) {
+              chainNodes[i].didChange(null);
+            }
+          }
+        }
+      }
+      // copy chains from prototype
+      chains = m.chains;
+      if (chains && chains.value() !== obj) {
+        utils.meta(obj).chains = chains = chains.copy(obj);
+      }
+    }
+  }
 
-      @method computed.reads
-      @for Ember
-      @param {String} dependentKey
-      @return {Ember.ComputedProperty} computed property which creates a
-        one way computed property to the original value for property.
-     */
-    computed.reads = computed.oneWay;
+});
+enifed('ember-metal/computed', ['exports', 'ember-metal/property_set', 'ember-metal/utils', 'ember-metal/expand_properties', 'ember-metal/error', 'ember-metal/properties', 'ember-metal/property_events', 'ember-metal/dependent_keys'], function (exports, property_set, utils, expandProperties, EmberError, properties, property_events, dependent_keys) {
 
-    /**
-      Where `computed.oneWay` provides oneWay bindings, `computed.readOnly` provides
-      a readOnly one way binding. Very often when using `computed.oneWay` one does
-      not also want changes to propagate back up, as they will replace the value.
+  'use strict';
 
-      This prevents the reverse flow, and also throws an exception when it occurs.
+  exports.ComputedProperty = ComputedProperty;
+  exports.computed = computed;
+  exports.cacheFor = cacheFor;
 
-      Example
+  var metaFor = utils.meta;
+  var a_slice = [].slice;
 
-      ```javascript
-      var User = Ember.Object.extend({
-        firstName: null,
-        lastName: null,
-        nickName: Ember.computed.readOnly('firstName')
-      });
+  function UNDEFINED() { }
 
-      var teddy = User.create({
-        firstName: 'Teddy',
-        lastName:  'Zeenny'
-      });
+  // ..........................................................
+  // COMPUTED PROPERTY
+  //
 
-      teddy.get('nickName');              // 'Teddy'
-      teddy.set('nickName', 'TeddyBear'); // throws Exception
-      // throw new Ember.Error('Cannot Set: nickName on: <User:ember27288>' );`
-      teddy.get('firstName');             // 'Teddy'
-      ```
+  /**
+    A computed property transforms an object's function into a property.
 
-      @method computed.readOnly
-      @for Ember
-      @param {String} dependentKey
-      @return {Ember.ComputedProperty} computed property which creates a
-      one way computed property to the original value for property.
-      @since 1.5.0
-    */
-    computed.readOnly = function(dependentKey) {
-      return alias(dependentKey).readOnly();
-    };
-    /**
-      A computed property that acts like a standard getter and setter,
-      but returns the value at the provided `defaultPath` if the
-      property itself has not been set to a value
+    By default the function backing the computed property will only be called
+    once and the result will be cached. You can specify various properties
+    that your computed property depends on. This will force the cached
+    result to be recomputed if the dependencies are modified.
 
-      Example
+    In the following example we declare a computed property (by calling
+    `.property()` on the fullName function) and setup the property
+    dependencies (depending on firstName and lastName). The fullName function
+    will be called once (regardless of how many times it is accessed) as long
+    as its dependencies have not changed. Once firstName or lastName are updated
+    any future calls (or anything bound) to fullName will incorporate the new
+    values.
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        wishList: Ember.computed.defaultTo('favoriteFood')
-      });
+    ```javascript
+    var Person = Ember.Object.extend({
+      // these will be supplied by `create`
+      firstName: null,
+      lastName: null,
 
-      var hamster = Hamster.create({ favoriteFood: 'Banana' });
+      fullName: function() {
+        var firstName = this.get('firstName');
+        var lastName = this.get('lastName');
 
-      hamster.get('wishList');                     // 'Banana'
-      hamster.set('wishList', 'More Unit Tests');
-      hamster.get('wishList');                     // 'More Unit Tests'
-      hamster.get('favoriteFood');                 // 'Banana'
-      ```
+       return firstName + ' ' + lastName;
+      }.property('firstName', 'lastName')
+    });
 
-      @method computed.defaultTo
-      @for Ember
-      @param {String} defaultPath
-      @return {Ember.ComputedProperty} computed property which acts like
-      a standard getter and setter, but defaults to the value from `defaultPath`.
-      @deprecated Use `Ember.computed.oneWay` or custom CP with default instead.
-    */
-    // ES6TODO: computed should have its own export path so you can do import {defaultTo} from computed
-    computed.defaultTo = function(defaultPath) {
-      return computed(function(key, newValue, cachedValue) {
-        Ember.deprecate('Usage of Ember.computed.defaultTo is deprecated, use `Ember.computed.oneWay` instead.');
+    var tom = Person.create({
+      firstName: 'Tom',
+      lastName: 'Dale'
+    });
 
-        if (arguments.length === 1) {
-          return get(this, defaultPath);
-        }
-        return newValue != null ? newValue : get(this, defaultPath);
-      });
-    };
+    tom.get('fullName') // 'Tom Dale'
+    ```
 
-    /**
-      Creates a new property that is an alias for another property
-      on an object. Calls to `get` or `set` this property behave as
-      though they were called on the original property, but also
-      print a deprecation warning.
+    You can also define what Ember should do when setting a computed property.
+    If you try to set a computed property, it will be invoked with the key and
+    value you want to set it to. You can also accept the previous value as the
+    third parameter.
 
-      @method computed.deprecatingAlias
-      @for Ember
-      @param {String} dependentKey
-      @return {Ember.ComputedProperty} computed property which creates an
-      alias with a deprecation to the original value for property.
-      @since 1.7.0
-    */
-    computed.deprecatingAlias = function(dependentKey) {
-      return computed(dependentKey, function(key, value) {
-        Ember.deprecate('Usage of `' + key + '` is deprecated, use `' + dependentKey + '` instead.');
+    ```javascript
+    var Person = Ember.Object.extend({
+      // these will be supplied by `create`
+      firstName: null,
+      lastName: null,
 
-        if (arguments.length > 1) {
-          set(this, dependentKey, value);
-          return value;
-        } else {
-          return get(this, dependentKey);
-        }
-      });
-    };
-  });
-enifed("ember-metal/core",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /*globals Ember:true,ENV,EmberENV,MetamorphENV:true */
+      fullName: function(key, value, oldValue) {
+        // getter
+        if (arguments.length === 1) {
+          var firstName = this.get('firstName');
+          var lastName = this.get('lastName');
 
-    /**
-    @module ember
-    @submodule ember-metal
-    */
+          return firstName + ' ' + lastName;
 
-    /**
-      All Ember methods and functions are defined inside of this namespace. You
-      generally should not add new properties to this namespace as it may be
-      overwritten by future versions of Ember.
+        // setter
+        } else {
+          var name = value.split(' ');
 
-      You can also use the shorthand `Em` instead of `Ember`.
+          this.set('firstName', name[0]);
+          this.set('lastName', name[1]);
 
-      Ember-Runtime is a framework that provides core functions for Ember including
-      cross-platform functions, support for property observing and objects. Its
-      focus is on small size and performance. You can use this in place of or
-      along-side other cross-platform libraries such as jQuery.
+          return value;
+        }
+      }.property('firstName', 'lastName')
+    });
 
-      The core Runtime framework is based on the jQuery API with a number of
-      performance optimizations.
+    var person = Person.create();
 
-      @class Ember
-      @static
-      @version 1.10.0
-    */
+    person.set('fullName', 'Peter Wagenet');
+    person.get('firstName'); // 'Peter'
+    person.get('lastName');  // 'Wagenet'
+    ```
 
-    if ('undefined' === typeof Ember) {
-      // Create core object. Make it act like an instance of Ember.Namespace so that
-      // objects assigned to it are given a sane string representation.
-      Ember = {};
-    }
+    @class ComputedProperty
+    @namespace Ember
+    @extends Ember.Descriptor
+    @constructor
+  */
+  function ComputedProperty(config, opts) {
+    this.isDescriptor = true;
 
-    // Default imports, exports and lookup to the global object;
-    Ember.imports = Ember.imports || this;
-    Ember.lookup  = Ember.lookup  || this;
-    var exports   = Ember.exports = Ember.exports || this;
+      config.__ember_arity = config.length;
+      this._getter = config;
+      if (config.__ember_arity > 1) {
+        this._setter = config;
+      }
 
-    // aliases needed to keep minifiers from removing the global context
-    exports.Em = exports.Ember = Ember;
 
-    // Make sure these are set whether Ember was already defined or not
+    this._dependentKeys = undefined;
+    this._suspended = undefined;
+    this._meta = undefined;
 
-    Ember.isNamespace = true;
+    Ember.deprecate("Passing opts.cacheable to the CP constructor is deprecated. Invoke `volatile()` on the CP instead.", !opts || !opts.hasOwnProperty('cacheable'));
+    this._cacheable = (opts && opts.cacheable !== undefined) ? opts.cacheable : true;   // TODO: Set always to `true` once this deprecation is gone.
+    this._dependentKeys = opts && opts.dependentKeys;
+    Ember.deprecate("Passing opts.readOnly to the CP constructor is deprecated. All CPs are writable by default. Yo can invoke `readOnly()` on the CP to change this.", !opts || !opts.hasOwnProperty('readOnly'));
+    this._readOnly = opts && (opts.readOnly !== undefined || !!opts.readOnly) || false; // TODO: Set always to `false` once this deprecation is gone.
+  }
 
-    Ember.toString = function() { return "Ember"; };
+  ComputedProperty.prototype = new properties.Descriptor();
 
+  var ComputedPropertyPrototype = ComputedProperty.prototype;
 
-    /**
-      @property VERSION
-      @type String
-      @default '1.10.0'
-      @static
-    */
-    Ember.VERSION = '1.10.0';
+  /**
+    Properties are cacheable by default. Computed property will automatically
+    cache the return value of your function until one of the dependent keys changes.
 
-    /**
-      Standard environmental variables. You can define these in a global `EmberENV`
-      variable before loading Ember to control various configuration settings.
+    Call `volatile()` to set it into non-cached mode. When in this mode
+    the computed property will not automatically cache the return value.
 
-      For backwards compatibility with earlier versions of Ember the global `ENV`
-      variable will be used if `EmberENV` is not defined.
+    However, if a property is properly observable, there is no reason to disable
+    caching.
 
-      @property ENV
-      @type Hash
-    */
+    @method cacheable
+    @param {Boolean} aFlag optional set to `false` to disable caching
+    @return {Ember.ComputedProperty} this
+    @chainable
+    @deprecated All computed properties are cacheble by default. Use `volatile()` instead to opt-out to caching.
+  */
+  ComputedPropertyPrototype.cacheable = function(aFlag) {
+    Ember.deprecate('ComputedProperty.cacheable() is deprecated. All computed properties are cacheable by default.');
+    this._cacheable = aFlag !== false;
+    return this;
+  };
 
-    if (Ember.ENV) {
-      // do nothing if Ember.ENV is already setup
-    } else if ('undefined' !== typeof EmberENV) {
-      Ember.ENV = EmberENV;
-    } else if('undefined' !== typeof ENV) {
-      Ember.ENV = ENV;
-    } else {
-      Ember.ENV = {};
-    }
+  /**
+    Call on a computed property to set it into non-cached mode. When in this
+    mode the computed property will not automatically cache the return value.
 
-    Ember.config = Ember.config || {};
+    ```javascript
+    var outsideService = Ember.Object.extend({
+      value: function() {
+        return OutsideService.getValue();
+      }.property().volatile()
+    }).create();
+    ```
 
-    // We disable the RANGE API by default for performance reasons
-    if ('undefined' === typeof Ember.ENV.DISABLE_RANGE_API) {
-      Ember.ENV.DISABLE_RANGE_API = true;
-    }
+    @method volatile
+    @return {Ember.ComputedProperty} this
+    @chainable
+  */
+  ComputedPropertyPrototype["volatile"] = function() {
+    this._cacheable = false;
+    return this;
+  };
 
-    if ("undefined" === typeof MetamorphENV) {
-      exports.MetamorphENV = {};
-    }
+  /**
+    Call on a computed property to set it into read-only mode. When in this
+    mode the computed property will throw an error when set.
 
-    MetamorphENV.DISABLE_RANGE_API = Ember.ENV.DISABLE_RANGE_API;
+    ```javascript
+    var Person = Ember.Object.extend({
+      guid: function() {
+        return 'guid-guid-guid';
+      }.property().readOnly()
+    });
 
-    /**
-      Hash of enabled Canary features. Add to this before creating your application.
+    var person = Person.create();
 
-      You can also define `EmberENV.FEATURES` if you need to enable features flagged at runtime.
+    person.set('guid', 'new-guid'); // will throw an exception
+    ```
 
-      @class FEATURES
-      @namespace Ember
-      @static
-      @since 1.1.0
-    */
+    @method readOnly
+    @return {Ember.ComputedProperty} this
+    @chainable
+  */
+  ComputedPropertyPrototype.readOnly = function(readOnly) {
+    Ember.deprecate('Passing arguments to ComputedProperty.readOnly() is deprecated.', arguments.length === 0);
+    this._readOnly = readOnly === undefined || !!readOnly; // Force to true once this deprecation is gone
+    return this;
+  };
 
-    Ember.FEATURES = Ember.ENV.FEATURES || {};
+  /**
+    Sets the dependent keys on this computed property. Pass any number of
+    arguments containing key paths that this computed property depends on.
 
-    /**
-      Test that a feature is enabled. Parsed by Ember's build tools to leave
-      experimental features out of beta/stable builds.
+    ```javascript
+    var President = Ember.Object.extend({
+      fullName: computed(function() {
+        return this.get('firstName') + ' ' + this.get('lastName');
 
-      You can define the following configuration options:
+        // Tell Ember that this computed property depends on firstName
+        // and lastName
+      }).property('firstName', 'lastName')
+    });
 
-      * `EmberENV.ENABLE_ALL_FEATURES` - force all features to be enabled.
-      * `EmberENV.ENABLE_OPTIONAL_FEATURES` - enable any features that have not been explicitly
-        enabled/disabled.
+    var president = President.create({
+      firstName: 'Barack',
+      lastName: 'Obama'
+    });
 
-      @method isEnabled
-      @param {String} feature
-      @return {Boolean}
-      @for Ember.FEATURES
-      @since 1.1.0
-    */
+    president.get('fullName'); // 'Barack Obama'
+    ```
 
-    Ember.FEATURES.isEnabled = function(feature) {
-      var featureValue = Ember.FEATURES[feature];
+    @method property
+    @param {String} path* zero or more property paths
+    @return {Ember.ComputedProperty} this
+    @chainable
+  */
+  ComputedPropertyPrototype.property = function() {
+    var args;
 
-      if (Ember.ENV.ENABLE_ALL_FEATURES) {
-        return true;
-      } else if (featureValue === true || featureValue === false || featureValue === undefined) {
-        return featureValue;
-      } else if (Ember.ENV.ENABLE_OPTIONAL_FEATURES) {
-        return true;
-      } else {
-        return false;
-      }
+    var addArg = function (property) {
+      args.push(property);
     };
 
-    // ..........................................................
-    // BOOTSTRAP
-    //
-
-    /**
-      Determines whether Ember should enhance some built-in object prototypes to
-      provide a more friendly API. If enabled, a few methods will be added to
-      `Function`, `String`, and `Array`. `Object.prototype` will not be enhanced,
-      which is the one that causes most trouble for people.
-
-      In general we recommend leaving this option set to true since it rarely
-      conflicts with other code. If you need to turn it off however, you can
-      define an `EmberENV.EXTEND_PROTOTYPES` config to disable it.
+    args = [];
+    for (var i = 0, l = arguments.length; i < l; i++) {
+      expandProperties['default'](arguments[i], addArg);
+    }
 
-      @property EXTEND_PROTOTYPES
-      @type Boolean
-      @default true
-      @for Ember
-    */
-    Ember.EXTEND_PROTOTYPES = Ember.ENV.EXTEND_PROTOTYPES;
+    this._dependentKeys = args;
+    return this;
+  };
 
-    if (typeof Ember.EXTEND_PROTOTYPES === 'undefined') {
-      Ember.EXTEND_PROTOTYPES = true;
-    }
+  /**
+    In some cases, you may want to annotate computed properties with additional
+    metadata about how they function or what values they operate on. For example,
+    computed property functions may close over variables that are then no longer
+    available for introspection.
 
-    /**
-      Determines whether Ember logs a full stack trace during deprecation warnings
+    You can pass a hash of these values to a computed property like this:
 
-      @property LOG_STACKTRACE_ON_DEPRECATION
-      @type Boolean
-      @default true
-    */
-    Ember.LOG_STACKTRACE_ON_DEPRECATION = (Ember.ENV.LOG_STACKTRACE_ON_DEPRECATION !== false);
+    ```
+    person: function() {
+      var personId = this.get('personId');
+      return App.Person.create({ id: personId });
+    }.property().meta({ type: App.Person })
+    ```
 
-    /**
-      Determines whether Ember should add ECMAScript 5 Array shims to older browsers.
+    The hash that you pass to the `meta()` function will be saved on the
+    computed property descriptor under the `_meta` key. Ember runtime
+    exposes a public API for retrieving these values from classes,
+    via the `metaForProperty()` function.
 
-      @property SHIM_ES5
-      @type Boolean
-      @default Ember.EXTEND_PROTOTYPES
-    */
-    Ember.SHIM_ES5 = (Ember.ENV.SHIM_ES5 === false) ? false : Ember.EXTEND_PROTOTYPES;
+    @method meta
+    @param {Hash} meta
+    @chainable
+  */
 
-    /**
-      Determines whether Ember logs info about version of used libraries
+  ComputedPropertyPrototype.meta = function(meta) {
+    if (arguments.length === 0) {
+      return this._meta || {};
+    } else {
+      this._meta = meta;
+      return this;
+    }
+  };
 
-      @property LOG_VERSION
-      @type Boolean
-      @default true
-    */
-    Ember.LOG_VERSION = (Ember.ENV.LOG_VERSION === false) ? false : true;
+  /* impl descriptor API */
+  ComputedPropertyPrototype.didChange = function(obj, keyName) {
+    // _suspended is set via a CP.set to ensure we don't clear
+    // the cached value set by the setter
+    if (this._cacheable && this._suspended !== obj) {
+      var meta = metaFor(obj);
+      if (meta.cache && meta.cache[keyName] !== undefined) {
+        meta.cache[keyName] = undefined;
+        dependent_keys.removeDependentKeys(this, obj, keyName, meta);
+      }
+    }
+  };
 
-    /**
-      Empty function. Useful for some operations. Always returns `this`.
+  function finishChains(chainNodes) {
+    for (var i=0, l=chainNodes.length; i<l; i++) {
+      chainNodes[i].didChange(null);
+    }
+  }
 
-      @method K
-      @private
-      @return {Object}
-    */
-    function K() { return this; }
-    __exports__.K = K;
-    Ember.K = K;
-    //TODO: ES6 GLOBAL TODO
+  /**
+    Access the value of the function backing the computed property.
+    If this property has already been cached, return the cached result.
+    Otherwise, call the function passing the property name as an argument.
 
-    // Stub out the methods defined by the ember-debug package in case it's not loaded
+    ```javascript
+    var Person = Ember.Object.extend({
+      fullName: function(keyName) {
+        // the keyName parameter is 'fullName' in this case.
+        return this.get('firstName') + ' ' + this.get('lastName');
+      }.property('firstName', 'lastName')
+    });
 
-    if ('undefined' === typeof Ember.assert) { Ember.assert = K; }
-    if ('undefined' === typeof Ember.warn) { Ember.warn = K; }
-    if ('undefined' === typeof Ember.debug) { Ember.debug = K; }
-    if ('undefined' === typeof Ember.runInDebug) { Ember.runInDebug = K; }
-    if ('undefined' === typeof Ember.deprecate) { Ember.deprecate = K; }
-    if ('undefined' === typeof Ember.deprecateFunc) {
-      Ember.deprecateFunc = function(_, func) { return func; };
-    }
 
-    __exports__["default"] = Ember;
-  });
-enifed("ember-metal/dependent_keys",
-  ["ember-metal/platform","ember-metal/watching","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-        // Remove "use strict"; from transpiled module until
-    // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
-    //
-    // REMOVE_USE_STRICT: true
+    var tom = Person.create({
+      firstName: 'Tom',
+      lastName: 'Dale'
+    });
 
-    var o_create = __dependency1__.create;
-    var watch = __dependency2__.watch;
-    var unwatch = __dependency2__.unwatch;
+    tom.get('fullName') // 'Tom Dale'
+    ```
 
-    /**
-    @module ember-metal
-    */
+    @method get
+    @param {String} keyName The key being accessed.
+    @return {Object} The return value of the function backing the CP.
+  */
+  ComputedPropertyPrototype.get = function(obj, keyName) {
+    var ret, cache, meta, chainNodes;
+    if (this._cacheable) {
+      meta = metaFor(obj);
+      cache = meta.cache;
 
-    // ..........................................................
-    // DEPENDENT KEYS
-    //
+      var result = cache && cache[keyName];
 
-    // data structure:
-    //  meta.deps = {
-    //    'depKey': {
-    //      'keyName': count,
-    //    }
-    //  }
+      if (result === UNDEFINED) {
+        return undefined;
+      } else if (result !== undefined) {
+        return result;
+      }
 
-    /*
-      This function returns a map of unique dependencies for a
-      given object and key.
-    */
-    function keysForDep(depsMeta, depKey) {
-      var keys = depsMeta[depKey];
-      if (!keys) {
-        // if there are no dependencies yet for a the given key
-        // create a new empty list of dependencies for the key
-        keys = depsMeta[depKey] = {};
-      } else if (!depsMeta.hasOwnProperty(depKey)) {
-        // otherwise if the dependency list is inherited from
-        // a superclass, clone the hash
-        keys = depsMeta[depKey] = o_create(keys);
+      ret = this._getter.call(obj, keyName);
+      cache = meta.cache;
+      if (!cache) {
+        cache = meta.cache = {};
+      }
+      if (ret === undefined) {
+        cache[keyName] = UNDEFINED;
+      } else {
+        cache[keyName] = ret;
       }
-      return keys;
-    }
 
-    function metaForDeps(meta) {
-      return keysForDep(meta, 'deps');
+      chainNodes = meta.chainWatchers && meta.chainWatchers[keyName];
+      if (chainNodes) {
+        finishChains(chainNodes);
+      }
+      dependent_keys.addDependentKeys(this, obj, keyName, meta);
+    } else {
+      ret = this._getter.call(obj, keyName);
     }
+    return ret;
+  };
 
-    function addDependentKeys(desc, obj, keyName, meta) {
-      // the descriptor has a list of dependent keys, so
-      // add all of its dependent keys.
-      var depKeys = desc._dependentKeys, depsMeta, idx, len, depKey, keys;
-      if (!depKeys) return;
+  /**
+    Set the value of a computed property. If the function that backs your
+    computed property does not accept arguments then the default action for
+    setting would be to define the property on the current object, and set
+    the value of the property to the value being set.
 
-      depsMeta = metaForDeps(meta);
+    Generally speaking if you intend for your computed property to be set
+    your backing function should accept either two or three arguments.
 
-      for(idx = 0, len = depKeys.length; idx < len; idx++) {
-        depKey = depKeys[idx];
-        // Lookup keys meta for depKey
-        keys = keysForDep(depsMeta, depKey);
-        // Increment the number of times depKey depends on keyName.
-        keys[keyName] = (keys[keyName] || 0) + 1;
-        // Watch the depKey
-        watch(obj, depKey, meta);
-      }
-    }
-
-    __exports__.addDependentKeys = addDependentKeys;function removeDependentKeys(desc, obj, keyName, meta) {
-      // the descriptor has a list of dependent keys, so
-      // remove all of its dependent keys.
-      var depKeys = desc._dependentKeys, depsMeta, idx, len, depKey, keys;
-      if (!depKeys) return;
+    ```javascript
+    var Person = Ember.Object.extend({
+      // these will be supplied by `create`
+      firstName: null,
+      lastName: null,
 
-      depsMeta = metaForDeps(meta);
+      fullName: function(key, value, oldValue) {
+        // getter
+        if (arguments.length === 1) {
+          var firstName = this.get('firstName');
+          var lastName = this.get('lastName');
 
-      for(idx = 0, len = depKeys.length; idx < len; idx++) {
-        depKey = depKeys[idx];
-        // Lookup keys meta for depKey
-        keys = keysForDep(depsMeta, depKey);
-        // Decrement the number of times depKey depends on keyName.
-        keys[keyName] = (keys[keyName] || 0) - 1;
-        // Unwatch the depKey
-        unwatch(obj, depKey, meta);
-      }
-    }
+          return firstName + ' ' + lastName;
 
-    __exports__.removeDependentKeys = removeDependentKeys;
-  });
-enifed("ember-metal/deprecate_property",
-  ["ember-metal/core","ember-metal/platform","ember-metal/properties","ember-metal/property_get","ember-metal/property_set","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
-    /**
-    @module ember-metal
-    */
+        // setter
+        } else {
+          var name = value.split(' ');
 
-    var Ember = __dependency1__["default"];
-    var hasPropertyAccessors = __dependency2__.hasPropertyAccessors;
-    var defineProperty = __dependency3__.defineProperty;
-    var get = __dependency4__.get;
-    var set = __dependency5__.set;
+          this.set('firstName', name[0]);
+          this.set('lastName', name[1]);
 
+          return value;
+        }
+      }.property('firstName', 'lastName')
+    });
 
-    /**
-      Used internally to allow changing properties in a backwards compatible way, and print a helpful
-      deprecation warning.
+    var person = Person.create();
 
-      @method deprecateProperty
-      @param {Object} object The object to add the deprecated property to.
-      @param {String} deprecatedKey The property to add (and print deprecation warnings upon accessing).
-      @param {String} newKey The property that will be aliased.
-      @private
-      @since 1.7.0
-    */
+    person.set('fullName', 'Peter Wagenet');
+    person.get('firstName'); // 'Peter'
+    person.get('lastName');  // 'Wagenet'
+    ```
 
-    function deprecateProperty(object, deprecatedKey, newKey) {
-      function deprecate() {
-        Ember.deprecate('Usage of `' + deprecatedKey + '` is deprecated, use `' + newKey + '` instead.');
-      }
+    @method set
+    @param {String} keyName The key being accessed.
+    @param {Object} newValue The new value being assigned.
+    @param {String} oldValue The old value being replaced.
+    @return {Object} The return value of the function backing the CP.
+  */
+  ComputedPropertyPrototype.set = function computedPropertySetWithSuspend(obj, keyName, value) {
+    var oldSuspended = this._suspended;
 
-      if (hasPropertyAccessors) {
-        defineProperty(object, deprecatedKey, {
-            configurable: true,
-            enumerable: false,
-            set: function(value) { deprecate(); set(this, newKey, value); },
-            get: function() { deprecate(); return get(this, newKey); }
-        });
-      }
-    }
+    this._suspended = obj;
 
-    __exports__.deprecateProperty = deprecateProperty;
-  });
-enifed("ember-metal/dictionary",
-  ["ember-metal/platform","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var create = __dependency1__.create;
-
-    // the delete is meant to hint at runtimes that this object should remain in
-    // dictionary mode. This is clearly a runtime specific hack, but currently it
-    // appears worthwile in some usecases. Please note, these deletes do increase
-    // the cost of creation dramatically over a plain Object.create. And as this
-    // only makes sense for long-lived dictionaries that aren't instantiated often.
-    __exports__["default"] = function makeDictionary(parent) {
-      var dict = create(parent);
-      dict['_dict'] = null;
-      delete dict['_dict'];
-      return dict;
+    try {
+      this._set(obj, keyName, value);
+    } finally {
+      this._suspended = oldSuspended;
     }
-  });
-enifed("ember-metal/enumerable_utils",
-  ["ember-metal/array","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var _filter = __dependency1__.filter;
-    var a_forEach = __dependency1__.forEach;
-    var _indexOf = __dependency1__.indexOf;
-    var _map = __dependency1__.map;
+  };
 
-    var splice = Array.prototype.splice;
+  ComputedPropertyPrototype._set = function computedPropertySet(obj, keyName, value) {
+    var cacheable      = this._cacheable;
+    var setter         = this._setter;
+    var meta           = metaFor(obj, cacheable);
+    var cache          = meta.cache;
+    var hadCachedValue = false;
 
-    /**
-     * Defines some convenience methods for working with Enumerables.
-     * `Ember.EnumerableUtils` uses `Ember.ArrayPolyfills` when necessary.
-     *
-     * @class EnumerableUtils
-     * @namespace Ember
-     * @static
-     * */
+    var cachedValue, ret;
 
-    /**
-     * Calls the map function on the passed object with a specified callback. This
-     * uses `Ember.ArrayPolyfill`'s-map method when necessary.
-     *
-     * @method map
-     * @param {Object} obj The object that should be mapped
-     * @param {Function} callback The callback to execute
-     * @param {Object} thisArg Value to use as this when executing *callback*
-     *
-     * @return {Array} An array of mapped values.
-     */
-    function map(obj, callback, thisArg) {
-      return obj.map ? obj.map(callback, thisArg) : _map.call(obj, callback, thisArg);
+    if (this._readOnly) {
+      throw new EmberError['default']('Cannot set read-only property "' + keyName + '" on object: ' + utils.inspect(obj));
     }
 
-    __exports__.map = map;/**
-     * Calls the forEach function on the passed object with a specified callback. This
-     * uses `Ember.ArrayPolyfill`'s-forEach method when necessary.
-     *
-     * @method forEach
-     * @param {Object} obj The object to call forEach on
-     * @param {Function} callback The callback to execute
-     * @param {Object} thisArg Value to use as this when executing *callback*
-     *
-     */
-    function forEach(obj, callback, thisArg) {
-      return obj.forEach ? obj.forEach(callback, thisArg) : a_forEach.call(obj, callback, thisArg);
-    }
+    if (cacheable && cache && cache[keyName] !== undefined) {
+      if (cache[keyName] !== UNDEFINED) {
+        cachedValue = cache[keyName];
+      }
 
-    __exports__.forEach = forEach;/**
-     * Calls the filter function on the passed object with a specified callback. This
-     * uses `Ember.ArrayPolyfill`'s-filter method when necessary.
-     *
-     * @method filter
-     * @param {Object} obj The object to call filter on
-     * @param {Function} callback The callback to execute
-     * @param {Object} thisArg Value to use as this when executing *callback*
-     *
-     * @return {Array} An array containing the filtered values
-     * @since 1.4.0
-     */
-    function filter(obj, callback, thisArg) {
-      return obj.filter ? obj.filter(callback, thisArg) : _filter.call(obj, callback, thisArg);
+      hadCachedValue = true;
     }
 
-    __exports__.filter = filter;/**
-     * Calls the indexOf function on the passed object with a specified callback. This
-     * uses `Ember.ArrayPolyfill`'s-indexOf method when necessary.
-     *
-     * @method indexOf
-     * @param {Object} obj The object to call indexOn on
-     * @param {Function} callback The callback to execute
-     * @param {Object} index The index to start searching from
-     *
-     */
-    function indexOf(obj, element, index) {
-      return obj.indexOf ? obj.indexOf(element, index) : _indexOf.call(obj, element, index);
+    if (!setter) {
+      properties.defineProperty(obj, keyName, null, cachedValue);
+      property_set.set(obj, keyName, value);
+      return;
+    } else if (setter.__ember_arity === 2) {
+      // Is there any way of deprecate this in a sensitive way?
+      // Maybe now that getters and setters are the prefered options we can....
+      ret = setter.call(obj, keyName, value);
+    } else {
+      ret = setter.call(obj, keyName, value, cachedValue);
     }
 
-    __exports__.indexOf = indexOf;/**
-     * Returns an array of indexes of the first occurrences of the passed elements
-     * on the passed object.
-     *
-     * ```javascript
-     *  var array = [1, 2, 3, 4, 5];
-     *  Ember.EnumerableUtils.indexesOf(array, [2, 5]); // [1, 4]
-     *
-     *  var fubar = "Fubarr";
-     *  Ember.EnumerableUtils.indexesOf(fubar, ['b', 'r']); // [2, 4]
-     * ```
-     *
-     * @method indexesOf
-     * @param {Object} obj The object to check for element indexes
-     * @param {Array} elements The elements to search for on *obj*
-     *
-     * @return {Array} An array of indexes.
-     *
-     */
-    function indexesOf(obj, elements) {
-      return elements === undefined ? [] : map(elements, function(item) {
-        return indexOf(obj, item);
-      });
-    }
+    if (hadCachedValue && cachedValue === ret) { return; }
 
-    __exports__.indexesOf = indexesOf;/**
-     * Adds an object to an array. If the array already includes the object this
-     * method has no effect.
-     *
-     * @method addObject
-     * @param {Array} array The array the passed item should be added to
-     * @param {Object} item The item to add to the passed array
-     *
-     * @return 'undefined'
-     */
-    function addObject(array, item) {
-      var index = indexOf(array, item);
-      if (index === -1) { array.push(item); }
+    var watched = meta.watching[keyName];
+    if (watched) {
+      property_events.propertyWillChange(obj, keyName);
     }
 
-    __exports__.addObject = addObject;/**
-     * Removes an object from an array. If the array does not contain the passed
-     * object this method has no effect.
-     *
-     * @method removeObject
-     * @param {Array} array The array to remove the item from.
-     * @param {Object} item The item to remove from the passed array.
-     *
-     * @return 'undefined'
-     */
-    function removeObject(array, item) {
-      var index = indexOf(array, item);
-      if (index !== -1) { array.splice(index, 1); }
+    if (hadCachedValue) {
+      cache[keyName] = undefined;
     }
 
-    __exports__.removeObject = removeObject;function _replace(array, idx, amt, objects) {
-      var args = [].concat(objects);
-      var ret = [];
-      // https://code.google.com/p/chromium/issues/detail?id=56588
-      var size = 60000;
-      var start = idx;
-      var ends = amt;
-      var count, chunk;
+    if (cacheable) {
+      if (!hadCachedValue) {
+        dependent_keys.addDependentKeys(this, obj, keyName, meta);
+      }
+      if (!cache) {
+        cache = meta.cache = {};
+      }
+      if (ret === undefined) {
+        cache[keyName] = UNDEFINED;
+      } else {
+        cache[keyName] = ret;
+      }
+    }
 
-      while (args.length) {
-        count = ends > size ? size : ends;
-        if (count <= 0) { count = 0; }
+    if (watched) {
+      property_events.propertyDidChange(obj, keyName);
+    }
 
-        chunk = args.splice(0, size);
-        chunk = [start, count].concat(chunk);
+    return ret;
+  };
 
-        start += size;
-        ends -= count;
+  /* called before property is overridden */
+  ComputedPropertyPrototype.teardown = function(obj, keyName) {
+    var meta = metaFor(obj);
 
-        ret = ret.concat(splice.apply(array, chunk));
+    if (meta.cache) {
+      if (keyName in meta.cache) {
+        dependent_keys.removeDependentKeys(this, obj, keyName, meta);
       }
-      return ret;
-    }
 
-    __exports__._replace = _replace;/**
-     * Replaces objects in an array with the passed objects.
-     *
-     * ```javascript
-     *   var array = [1,2,3];
-     *   Ember.EnumerableUtils.replace(array, 1, 2, [4, 5]); // [1, 4, 5]
-     *
-     *   var array = [1,2,3];
-     *   Ember.EnumerableUtils.replace(array, 1, 1, [4, 5]); // [1, 4, 5, 3]
-     *
-     *   var array = [1,2,3];
-     *   Ember.EnumerableUtils.replace(array, 10, 1, [4, 5]); // [1, 2, 3, 4, 5]
-     * ```
-     *
-     * @method replace
-     * @param {Array} array The array the objects should be inserted into.
-     * @param {Number} idx Starting index in the array to replace. If *idx* >=
-     * length, then append to the end of the array.
-     * @param {Number} amt Number of elements that should be removed from the array,
-     * starting at *idx*
-     * @param {Array} objects An array of zero or more objects that should be
-     * inserted into the array at *idx*
-     *
-     * @return {Array} The modified array.
-     */
-    function replace(array, idx, amt, objects) {
-      if (array.replace) {
-        return array.replace(idx, amt, objects);
-      } else {
-        return _replace(array, idx, amt, objects);
-      }
+      if (this._cacheable) { delete meta.cache[keyName]; }
     }
 
-    __exports__.replace = replace;/**
-     * Calculates the intersection of two arrays. This method returns a new array
-     * filled with the records that the two passed arrays share with each other.
-     * If there is no intersection, an empty array will be returned.
-     *
-     * ```javascript
-     * var array1 = [1, 2, 3, 4, 5];
-     * var array2 = [1, 3, 5, 6, 7];
-     *
-     * Ember.EnumerableUtils.intersection(array1, array2); // [1, 3, 5]
-     *
-     * var array1 = [1, 2, 3];
-     * var array2 = [4, 5, 6];
-     *
-     * Ember.EnumerableUtils.intersection(array1, array2); // []
-     * ```
-     *
-     * @method intersection
-     * @param {Array} array1 The first array
-     * @param {Array} array2 The second array
-     *
-     * @return {Array} The intersection of the two passed arrays.
-     */
-    function intersection(array1, array2) {
-      var result = [];
-      forEach(array1, function(element) {
-        if (indexOf(array2, element) >= 0) {
-          result.push(element);
-        }
-      });
+    return null; // no value to restore
+  };
 
-      return result;
-    }
 
-    __exports__.intersection = intersection;// TODO: this only exists to maintain the existing api, as we move forward it
-    // should only be part of the "global build" via some shim
-    __exports__["default"] = {
-      _replace: _replace,
-      addObject: addObject,
-      filter: filter,
-      forEach: forEach,
-      indexOf: indexOf,
-      indexesOf: indexesOf,
-      intersection: intersection,
-      map: map,
-      removeObject: removeObject,
-      replace: replace
-    };
-  });
-enifed("ember-metal/error",
-  ["ember-metal/platform","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var create = __dependency1__.create;
+  /**
+    This helper returns a new property descriptor that wraps the passed
+    computed property function. You can use this helper to define properties
+    with mixins or via `Ember.defineProperty()`.
 
-    var errorProps = [
-      'description',
-      'fileName',
-      'lineNumber',
-      'message',
-      'name',
-      'number',
-      'stack'
-    ];
+    The function you pass will be used to both get and set property values.
+    The function should accept two parameters, key and value. If value is not
+    undefined you should set the value first. In either case return the
+    current value of the property.
 
-    /**
-      A subclass of the JavaScript Error object for use in Ember.
+    A computed property defined in this way might look like this:
 
-      @class Error
-      @namespace Ember
-      @extends Error
-      @constructor
-    */
-    function EmberError() {
-      var tmp = Error.apply(this, arguments);
+    ```js
+    var Person = Ember.Object.extend({
+      firstName: 'Betty',
+      lastName: 'Jones',
 
-      // Adds a `stack` property to the given error object that will yield the
-      // stack trace at the time captureStackTrace was called.
-      // When collecting the stack trace all frames above the topmost call
-      // to this function, including that call, will be left out of the
-      // stack trace.
-      // This is useful because we can hide Ember implementation details
-      // that are not very helpful for the user.
-      if (Error.captureStackTrace) {
-        Error.captureStackTrace(this, Ember.Error);
-      }
-      // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
-      for (var idx = 0; idx < errorProps.length; idx++) {
-        this[errorProps[idx]] = tmp[errorProps[idx]];
-      }
-    }
+      fullName: Ember.computed('firstName', 'lastName', function(key, value) {
+        return this.get('firstName') + ' ' + this.get('lastName');
+      })
+    });
 
-    EmberError.prototype = create(Error.prototype);
+    var client = Person.create();
 
-    __exports__["default"] = EmberError;
-  });
-enifed("ember-metal/events",
-  ["ember-metal/core","ember-metal/utils","ember-metal/platform","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-        // Remove "use strict"; from transpiled module until
-    // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
-    //
-    // REMOVE_USE_STRICT: true
+    client.get('fullName'); // 'Betty Jones'
 
-    /**
-    @module ember-metal
-    */
-    var Ember = __dependency1__["default"];
-    var metaFor = __dependency2__.meta;
-    var tryFinally = __dependency2__.tryFinally;
-    var apply = __dependency2__.apply;
-    var applyStr = __dependency2__.applyStr;
-    var create = __dependency3__.create;
+    client.set('lastName', 'Fuller');
+    client.get('fullName'); // 'Betty Fuller'
+    ```
 
-    var a_slice = [].slice;
+    _Note: This is the preferred way to define computed properties when writing third-party
+    libraries that depend on or use Ember, since there is no guarantee that the user
+    will have prototype extensions enabled._
 
-    /* listener flags */
-    var ONCE = 1;
-    var SUSPENDED = 2;
+    You might use this method if you disabled
+    [Prototype Extensions](http://emberjs.com/guides/configuring-ember/disabling-prototype-extensions/).
+    The alternative syntax might look like this
+    (if prototype extensions are enabled, which is the default behavior):
 
+    ```js
+    fullName: function () {
+      return this.get('firstName') + ' ' + this.get('lastName');
+    }.property('firstName', 'lastName')
+    ```
 
-    /*
-      The event system uses a series of nested hashes to store listeners on an
-      object. When a listener is registered, or when an event arrives, these
-      hashes are consulted to determine which target and action pair to invoke.
-
-      The hashes are stored in the object's meta hash, and look like this:
-
-          // Object's meta hash
-          {
-            listeners: {       // variable name: `listenerSet`
-              "foo:changed": [ // variable name: `actions`
-                target, method, flags
-              ]
-            }
-          }
+    @class computed
+    @namespace Ember
+    @constructor
+    @static
+    @param {String} [dependentKeys*] Optional dependent keys that trigger this computed property.
+    @param {Function} func The computed property function.
+    @return {Ember.ComputedProperty} property descriptor instance
+  */
+  function computed(func) {
+    var args;
 
-    */
+    if (arguments.length > 1) {
+      args = a_slice.call(arguments);
+      func = args.pop();
+    }
 
-    function indexOf(array, target, method) {
-      var index = -1;
-      // hashes are added to the end of the event array
-      // so it makes sense to start searching at the end
-      // of the array and search in reverse
-      for (var i = array.length - 3 ; i >=0; i -= 3) {
-        if (target === array[i] && method === array[i + 1]) {
-             index = i; break;
-        }
+    var cp = new ComputedProperty(func);
+    // jscs:disable
+
+      // jscs:enable
+      if (typeof func !== "function") {
+        throw new EmberError['default']("Computed Property declared without a property function");
       }
-      return index;
+
+
+    if (args) {
+      cp.property.apply(cp, args);
     }
 
-    function actionsFor(obj, eventName) {
-      var meta = metaFor(obj, true);
-      var actions;
-      var listeners = meta.listeners;
+    return cp;
+  }
 
-      if (!listeners) {
-        listeners = meta.listeners = create(null);
-        listeners.__source__ = obj;
-      } else if (listeners.__source__ !== obj) {
-        // setup inherited copy of the listeners object
-        listeners = meta.listeners = create(listeners);
-        listeners.__source__ = obj;
-      }
+  /**
+    Returns the cached value for a property, if one exists.
+    This can be useful for peeking at the value of a computed
+    property that is generated lazily, without accidentally causing
+    it to be created.
+
+    @method cacheFor
+    @for Ember
+    @param {Object} obj the object whose property you want to check
+    @param {String} key the name of the property whose cached value you want
+      to return
+    @return {Object} the cached value
+  */
+  function cacheFor(obj, key) {
+    var meta = obj['__ember_meta__'];
+    var cache = meta && meta.cache;
+    var ret = cache && cache[key];
+
+    if (ret === UNDEFINED) {
+      return undefined;
+    }
+    return ret;
+  }
 
-      actions = listeners[eventName];
+  cacheFor.set = function(cache, key, value) {
+    if (value === undefined) {
+      cache[key] = UNDEFINED;
+    } else {
+      cache[key] = value;
+    }
+  };
+
+  cacheFor.get = function(cache, key) {
+    var ret = cache[key];
+    if (ret === UNDEFINED) {
+      return undefined;
+    }
+    return ret;
+  };
+
+  cacheFor.remove = function(cache, key) {
+    cache[key] = undefined;
+  };
+
+});
+enifed('ember-metal/computed_macros', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/computed', 'ember-metal/is_empty', 'ember-metal/is_none', 'ember-metal/alias'], function (exports, Ember, property_get, property_set, computed, isEmpty, isNone, alias) {
+
+  'use strict';
+
+  exports.empty = empty;
+  exports.notEmpty = notEmpty;
+  exports.none = none;
+  exports.not = not;
+  exports.bool = bool;
+  exports.match = match;
+  exports.equal = equal;
+  exports.gt = gt;
+  exports.gte = gte;
+  exports.lt = lt;
+  exports.lte = lte;
+  exports.oneWay = oneWay;
+  exports.readOnly = readOnly;
+  exports.defaultTo = defaultTo;
+  exports.deprecatingAlias = deprecatingAlias;
+
+  var a_slice = [].slice;
+
+  function getProperties(self, propertyNames) {
+    var ret = {};
+    for (var i = 0; i < propertyNames.length; i++) {
+      ret[propertyNames[i]] = property_get.get(self, propertyNames[i]);
+    }
+    return ret;
+  }
 
-      // if there are actions, but the eventName doesn't exist in our listeners, then copy them from the prototype
-      if (actions && actions.__source__ !== obj) {
-        actions = listeners[eventName] = listeners[eventName].slice();
-        actions.__source__ = obj;
-      } else if (!actions) {
-        actions = listeners[eventName] = [];
-        actions.__source__ = obj;
-      }
+  function generateComputedWithProperties(macro) {
+    return function() {
+      var properties = a_slice.call(arguments);
 
-      return actions;
-    }
+      var computedFunc = computed.computed(function() {
+        return macro.apply(this, [getProperties(this, properties)]);
+      });
 
-    function accumulateListeners(obj, eventName, otherActions) {
-      var meta = obj['__ember_meta__'];
-      var actions = meta && meta.listeners && meta.listeners[eventName];
+      return computedFunc.property.apply(computedFunc, properties);
+    };
+  }
 
-      if (!actions) { return; }
+  /**
+    A computed property that returns true if the value of the dependent
+    property is null, an empty string, empty array, or empty function.
 
-      var newActions = [];
+    Example
 
-      for (var i = actions.length - 3; i >= 0; i -= 3) {
-        var target = actions[i];
-        var method = actions[i+1];
-        var flags = actions[i+2];
-        var actionIndex = indexOf(otherActions, target, method);
+    ```javascript
+    var ToDoList = Ember.Object.extend({
+      isDone: Ember.computed.empty('todos')
+    });
 
-        if (actionIndex === -1) {
-          otherActions.push(target, method, flags);
-          newActions.push(target, method, flags);
-        }
-      }
+    var todoList = ToDoList.create({
+      todos: ['Unit Test', 'Documentation', 'Release']
+    });
 
-      return newActions;
-    }
+    todoList.get('isDone'); // false
+    todoList.get('todos').clear();
+    todoList.get('isDone'); // true
+    ```
 
-    __exports__.accumulateListeners = accumulateListeners;/**
-      Add an event listener
+    @since 1.6.0
+    @method empty
+    @for Ember.computed
+    @param {String} dependentKey
+    @return {Ember.ComputedProperty} computed property which negate
+    the original value for property
+  */
+  function empty(dependentKey) {
+    return computed.computed(dependentKey + '.length', function () {
+      return isEmpty['default'](property_get.get(this, dependentKey));
+    });
+  }
 
-      @method addListener
-      @for Ember
-      @param obj
-      @param {String} eventName
-      @param {Object|Function} target A target object or a function
-      @param {Function|String} method A function or the name of a function to be called on `target`
-      @param {Boolean} once A flag whether a function should only be called once
-    */
-    function addListener(obj, eventName, target, method, once) {
-      Ember.assert("You must pass at least an object and event name to Ember.addListener", !!obj && !!eventName);
+  /**
+    A computed property that returns true if the value of the dependent
+    property is NOT null, an empty string, empty array, or empty function.
 
-      if (!method && 'function' === typeof target) {
-        method = target;
-        target = null;
-      }
+    Example
 
-      var actions = actionsFor(obj, eventName);
-      var actionIndex = indexOf(actions, target, method);
-      var flags = 0;
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      hasStuff: Ember.computed.notEmpty('backpack')
+    });
 
-      if (once) flags |= ONCE;
+    var hamster = Hamster.create({ backpack: ['Food', 'Sleeping Bag', 'Tent'] });
 
-      if (actionIndex !== -1) { return; }
+    hamster.get('hasStuff');         // true
+    hamster.get('backpack').clear(); // []
+    hamster.get('hasStuff');         // false
+    ```
 
-      actions.push(target, method, flags);
+    @method notEmpty
+    @for Ember.computed
+    @param {String} dependentKey
+    @return {Ember.ComputedProperty} computed property which returns true if
+    original value for property is not empty.
+  */
+  function notEmpty(dependentKey) {
+    return computed.computed(dependentKey + '.length', function () {
+      return !isEmpty['default'](property_get.get(this, dependentKey));
+    });
+  }
 
-      if ('function' === typeof obj.didAddListener) {
-        obj.didAddListener(eventName, target, method);
-      }
-    }
+  /**
+    A computed property that returns true if the value of the dependent
+    property is null or undefined. This avoids errors from JSLint complaining
+    about use of ==, which can be technically confusing.
 
-    __exports__.addListener = addListener;/**
-      Remove an event listener
+    Example
 
-      Arguments should match those passed to `Ember.addListener`.
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      isHungry: Ember.computed.none('food')
+    });
 
-      @method removeListener
-      @for Ember
-      @param obj
-      @param {String} eventName
-      @param {Object|Function} target A target object or a function
-      @param {Function|String} method A function or the name of a function to be called on `target`
-    */
-    function removeListener(obj, eventName, target, method) {
-      Ember.assert("You must pass at least an object and event name to Ember.removeListener", !!obj && !!eventName);
+    var hamster = Hamster.create();
 
-      if (!method && 'function' === typeof target) {
-        method = target;
-        target = null;
-      }
+    hamster.get('isHungry'); // true
+    hamster.set('food', 'Banana');
+    hamster.get('isHungry'); // false
+    hamster.set('food', null);
+    hamster.get('isHungry'); // true
+    ```
 
-      function _removeListener(target, method) {
-        var actions = actionsFor(obj, eventName);
-        var actionIndex = indexOf(actions, target, method);
+    @method none
+    @for Ember.computed
+    @param {String} dependentKey
+    @return {Ember.ComputedProperty} computed property which
+    returns true if original value for property is null or undefined.
+  */
+  function none(dependentKey) {
+    return computed.computed(dependentKey, function () {
+      return isNone['default'](property_get.get(this, dependentKey));
+    });
+  }
 
-        // action doesn't exist, give up silently
-        if (actionIndex === -1) { return; }
+  /**
+    A computed property that returns the inverse boolean value
+    of the original value for the dependent property.
 
-        actions.splice(actionIndex, 3);
+    Example
 
-        if ('function' === typeof obj.didRemoveListener) {
-          obj.didRemoveListener(eventName, target, method);
-        }
-      }
+    ```javascript
+    var User = Ember.Object.extend({
+      isAnonymous: Ember.computed.not('loggedIn')
+    });
 
-      if (method) {
-        _removeListener(target, method);
-      } else {
-        var meta = obj['__ember_meta__'];
-        var actions = meta && meta.listeners && meta.listeners[eventName];
+    var user = User.create({loggedIn: false});
 
-        if (!actions) { return; }
-        for (var i = actions.length - 3; i >= 0; i -= 3) {
-          _removeListener(actions[i], actions[i+1]);
-        }
-      }
-    }
+    user.get('isAnonymous'); // true
+    user.set('loggedIn', true);
+    user.get('isAnonymous'); // false
+    ```
 
-    /**
-      Suspend listener during callback.
+    @method not
+    @for Ember.computed
+    @param {String} dependentKey
+    @return {Ember.ComputedProperty} computed property which returns
+    inverse of the original value for property
+  */
+  function not(dependentKey) {
+    return computed.computed(dependentKey, function () {
+      return !property_get.get(this, dependentKey);
+    });
+  }
 
-      This should only be used by the target of the event listener
-      when it is taking an action that would cause the event, e.g.
-      an object might suspend its property change listener while it is
-      setting that property.
+  /**
+    A computed property that converts the provided dependent property
+    into a boolean value.
 
-      @method suspendListener
-      @for Ember
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      hasBananas: Ember.computed.bool('numBananas')
+    });
 
-      @private
-      @param obj
-      @param {String} eventName
-      @param {Object|Function} target A target object or a function
-      @param {Function|String} method A function or the name of a function to be called on `target`
-      @param {Function} callback
-    */
-    function suspendListener(obj, eventName, target, method, callback) {
-      if (!method && 'function' === typeof target) {
-        method = target;
-        target = null;
-      }
+    var hamster = Hamster.create();
 
-      var actions = actionsFor(obj, eventName);
-      var actionIndex = indexOf(actions, target, method);
+    hamster.get('hasBananas'); // false
+    hamster.set('numBananas', 0);
+    hamster.get('hasBananas'); // false
+    hamster.set('numBananas', 1);
+    hamster.get('hasBananas'); // true
+    hamster.set('numBananas', null);
+    hamster.get('hasBananas'); // false
+    ```
 
-      if (actionIndex !== -1) {
-        actions[actionIndex+2] |= SUSPENDED; // mark the action as suspended
-      }
+    @method bool
+    @for Ember.computed
+    @param {String} dependentKey
+    @return {Ember.ComputedProperty} computed property which converts
+    to boolean the original value for property
+  */
+  function bool(dependentKey) {
+    return computed.computed(dependentKey, function () {
+      return !!property_get.get(this, dependentKey);
+    });
+  }
 
-      function tryable()   { return callback.call(target); }
-      function finalizer() { if (actionIndex !== -1) { actions[actionIndex+2] &= ~SUSPENDED; } }
+  /**
+    A computed property which matches the original value for the
+    dependent property against a given RegExp, returning `true`
+    if they values matches the RegExp and `false` if it does not.
 
-      return tryFinally(tryable, finalizer);
-    }
+    Example
 
-    __exports__.suspendListener = suspendListener;/**
-      Suspends multiple listeners during a callback.
+    ```javascript
+    var User = Ember.Object.extend({
+      hasValidEmail: Ember.computed.match('email', /^.+@.+\..+$/)
+    });
 
-      @method suspendListeners
-      @for Ember
+    var user = User.create({loggedIn: false});
 
-      @private
-      @param obj
-      @param {Array} eventNames Array of event names
-      @param {Object|Function} target A target object or a function
-      @param {Function|String} method A function or the name of a function to be called on `target`
-      @param {Function} callback
-    */
-    function suspendListeners(obj, eventNames, target, method, callback) {
-      if (!method && 'function' === typeof target) {
-        method = target;
-        target = null;
-      }
+    user.get('hasValidEmail'); // false
+    user.set('email', '');
+    user.get('hasValidEmail'); // false
+    user.set('email', 'ember_hamster@example.com');
+    user.get('hasValidEmail'); // true
+    ```
+
+    @method match
+    @for Ember.computed
+    @param {String} dependentKey
+    @param {RegExp} regexp
+    @return {Ember.ComputedProperty} computed property which match
+    the original value for property against a given RegExp
+  */
+  function match(dependentKey, regexp) {
+    return computed.computed(dependentKey, function () {
+      var value = property_get.get(this, dependentKey);
 
-      var suspendedActions = [];
-      var actionsList = [];
-      var eventName, actions, i, l;
+      return typeof value === 'string' ? regexp.test(value) : false;
+    });
+  }
 
-      for (i=0, l=eventNames.length; i<l; i++) {
-        eventName = eventNames[i];
-        actions = actionsFor(obj, eventName);
-        var actionIndex = indexOf(actions, target, method);
+  /**
+    A computed property that returns true if the provided dependent property
+    is equal to the given value.
 
-        if (actionIndex !== -1) {
-          actions[actionIndex+2] |= SUSPENDED;
-          suspendedActions.push(actionIndex);
-          actionsList.push(actions);
-        }
-      }
+    Example
+
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      napTime: Ember.computed.equal('state', 'sleepy')
+    });
 
-      function tryable() { return callback.call(target); }
+    var hamster = Hamster.create();
 
-      function finalizer() {
-        for (var i = 0, l = suspendedActions.length; i < l; i++) {
-          var actionIndex = suspendedActions[i];
-          actionsList[i][actionIndex+2] &= ~SUSPENDED;
-        }
-      }
+    hamster.get('napTime'); // false
+    hamster.set('state', 'sleepy');
+    hamster.get('napTime'); // true
+    hamster.set('state', 'hungry');
+    hamster.get('napTime'); // false
+    ```
 
-      return tryFinally(tryable, finalizer);
-    }
+    @method equal
+    @for Ember.computed
+    @param {String} dependentKey
+    @param {String|Number|Object} value
+    @return {Ember.ComputedProperty} computed property which returns true if
+    the original value for property is equal to the given value.
+  */
+  function equal(dependentKey, value) {
+    return computed.computed(dependentKey, function () {
+      return property_get.get(this, dependentKey) === value;
+    });
+  }
 
-    __exports__.suspendListeners = suspendListeners;/**
-      Return a list of currently watched events
+  /**
+    A computed property that returns true if the provided dependent property
+    is greater than the provided value.
 
-      @private
-      @method watchedEvents
-      @for Ember
-      @param obj
-    */
-    function watchedEvents(obj) {
-      var listeners = obj['__ember_meta__'].listeners, ret = [];
+    Example
 
-      if (listeners) {
-        for (var eventName in listeners) {
-          if (eventName !== '__source__' &&
-              listeners[eventName]) {
-            ret.push(eventName);
-          }
-        }
-      }
-      return ret;
-    }
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      hasTooManyBananas: Ember.computed.gt('numBananas', 10)
+    });
 
-    __exports__.watchedEvents = watchedEvents;/**
-      Send an event. The execution of suspended listeners
-      is skipped, and once listeners are removed. A listener without
-      a target is executed on the passed object. If an array of actions
-      is not passed, the actions stored on the passed object are invoked.
+    var hamster = Hamster.create();
 
-      @method sendEvent
-      @for Ember
-      @param obj
-      @param {String} eventName
-      @param {Array} params Optional parameters for each listener.
-      @param {Array} actions Optional array of actions (listeners).
-      @return true
-    */
-    function sendEvent(obj, eventName, params, actions) {
-      // first give object a chance to handle it
-      if (obj !== Ember && 'function' === typeof obj.sendEvent) {
-        obj.sendEvent(eventName, params);
-      }
+    hamster.get('hasTooManyBananas'); // false
+    hamster.set('numBananas', 3);
+    hamster.get('hasTooManyBananas'); // false
+    hamster.set('numBananas', 11);
+    hamster.get('hasTooManyBananas'); // true
+    ```
 
-      if (!actions) {
-        var meta = obj['__ember_meta__'];
-        actions = meta && meta.listeners && meta.listeners[eventName];
-      }
+    @method gt
+    @for Ember.computed
+    @param {String} dependentKey
+    @param {Number} value
+    @return {Ember.ComputedProperty} computed property which returns true if
+    the original value for property is greater than given value.
+  */
+  function gt(dependentKey, value) {
+    return computed.computed(dependentKey, function () {
+      return property_get.get(this, dependentKey) > value;
+    });
+  }
 
-      if (!actions) { return; }
+  /**
+    A computed property that returns true if the provided dependent property
+    is greater than or equal to the provided value.
 
-      for (var i = actions.length - 3; i >= 0; i -= 3) { // looping in reverse for once listeners
-        var target = actions[i], method = actions[i+1], flags = actions[i+2];
-        if (!method) { continue; }
-        if (flags & SUSPENDED) { continue; }
-        if (flags & ONCE) { removeListener(obj, eventName, target, method); }
-        if (!target) { target = obj; }
-        if ('string' === typeof method) {
-          if (params) {
-            applyStr(target, method, params);
-          } else {
-            target[method]();
-          }
-        } else {
-          if (params) {
-            apply(target, method, params);
-          } else {
-            method.call(target);
-          }
-        }
-      }
-      return true;
-    }
+    Example
 
-    __exports__.sendEvent = sendEvent;/**
-      @private
-      @method hasListeners
-      @for Ember
-      @param obj
-      @param {String} eventName
-    */
-    function hasListeners(obj, eventName) {
-      var meta = obj['__ember_meta__'];
-      var actions = meta && meta.listeners && meta.listeners[eventName];
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      hasTooManyBananas: Ember.computed.gte('numBananas', 10)
+    });
 
-      return !!(actions && actions.length);
-    }
+    var hamster = Hamster.create();
 
-    __exports__.hasListeners = hasListeners;/**
-      @private
-      @method listenersFor
-      @for Ember
-      @param obj
-      @param {String} eventName
-    */
-    function listenersFor(obj, eventName) {
-      var ret = [];
-      var meta = obj['__ember_meta__'];
-      var actions = meta && meta.listeners && meta.listeners[eventName];
+    hamster.get('hasTooManyBananas'); // false
+    hamster.set('numBananas', 3);
+    hamster.get('hasTooManyBananas'); // false
+    hamster.set('numBananas', 10);
+    hamster.get('hasTooManyBananas'); // true
+    ```
 
-      if (!actions) { return ret; }
+    @method gte
+    @for Ember.computed
+    @param {String} dependentKey
+    @param {Number} value
+    @return {Ember.ComputedProperty} computed property which returns true if
+    the original value for property is greater or equal then given value.
+  */
+  function gte(dependentKey, value) {
+    return computed.computed(dependentKey, function () {
+      return property_get.get(this, dependentKey) >= value;
+    });
+  }
 
-      for (var i = 0, l = actions.length; i < l; i += 3) {
-        var target = actions[i];
-        var method = actions[i+1];
-        ret.push([target, method]);
-      }
+  /**
+    A computed property that returns true if the provided dependent property
+    is less than the provided value.
 
-      return ret;
-    }
+    Example
 
-    __exports__.listenersFor = listenersFor;/**
-      Define a property as a function that should be executed when
-      a specified event or events are triggered.
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      needsMoreBananas: Ember.computed.lt('numBananas', 3)
+    });
 
+    var hamster = Hamster.create();
 
-      ``` javascript
-      var Job = Ember.Object.extend({
-        logCompleted: Ember.on('completed', function() {
-          console.log('Job completed!');
-        })
-      });
+    hamster.get('needsMoreBananas'); // true
+    hamster.set('numBananas', 3);
+    hamster.get('needsMoreBananas'); // false
+    hamster.set('numBananas', 2);
+    hamster.get('needsMoreBananas'); // true
+    ```
 
-      var job = Job.create();
+    @method lt
+    @for Ember.computed
+    @param {String} dependentKey
+    @param {Number} value
+    @return {Ember.ComputedProperty} computed property which returns true if
+    the original value for property is less then given value.
+  */
+  function lt(dependentKey, value) {
+    return computed.computed(dependentKey, function () {
+      return property_get.get(this, dependentKey) < value;
+    });
+  }
 
-      Ember.sendEvent(job, 'completed'); // Logs 'Job completed!'
-     ```
+  /**
+    A computed property that returns true if the provided dependent property
+    is less than or equal to the provided value.
 
-      @method on
-      @for Ember
-      @param {String} eventNames*
-      @param {Function} func
-      @return func
-    */
-    function on(){
-      var func = a_slice.call(arguments, -1)[0];
-      var events = a_slice.call(arguments, 0, -1);
-      func.__ember_listens__ = events;
-      return func;
-    }
+    Example
 
-    __exports__.on = on;__exports__.removeListener = removeListener;
-  });
-enifed("ember-metal/expand_properties",
-  ["ember-metal/core","ember-metal/error","ember-metal/enumerable_utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var EmberError = __dependency2__["default"];
-    var forEach = __dependency3__.forEach;
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      needsMoreBananas: Ember.computed.lte('numBananas', 3)
+    });
 
-    /**
-      @module ember-metal
-      */
+    var hamster = Hamster.create();
 
-    var BRACE_EXPANSION = /^((?:[^\.]*\.)*)\{(.*)\}$/;
-    var SPLIT_REGEX = /\{|\}/;
+    hamster.get('needsMoreBananas'); // true
+    hamster.set('numBananas', 5);
+    hamster.get('needsMoreBananas'); // false
+    hamster.set('numBananas', 3);
+    hamster.get('needsMoreBananas'); // true
+    ```
 
-    /**
-      Expands `pattern`, invoking `callback` for each expansion.
+    @method lte
+    @for Ember.computed
+    @param {String} dependentKey
+    @param {Number} value
+    @return {Ember.ComputedProperty} computed property which returns true if
+    the original value for property is less or equal than given value.
+  */
+  function lte(dependentKey, value) {
+    return computed.computed(dependentKey, function () {
+      return property_get.get(this, dependentKey) <= value;
+    });
+  }
 
-      The only pattern supported is brace-expansion, anything else will be passed
-      once to `callback` directly.
+  /**
+    A computed property that performs a logical `and` on the
+    original values for the provided dependent properties.
 
-      Example
+    Example
 
-      ```js
-      function echo(arg){ console.log(arg); }
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      readyForCamp: Ember.computed.and('hasTent', 'hasBackpack')
+    });
 
-      Ember.expandProperties('foo.bar', echo);              //=> 'foo.bar'
-      Ember.expandProperties('{foo,bar}', echo);            //=> 'foo', 'bar'
-      Ember.expandProperties('foo.{bar,baz}', echo);        //=> 'foo.bar', 'foo.baz'
-      Ember.expandProperties('{foo,bar}.baz', echo);        //=> '{foo,bar}.baz'
-      Ember.expandProperties('foo.{bar,baz}.@each', echo)   //=> 'foo.bar.@each', 'foo.baz.@each'
-      Ember.expandProperties('{foo,bar}.{spam,eggs}', echo) //=> 'foo.spam', 'foo.eggs', 'bar.spam', 'bar.eggs'
-      Ember.expandProperties('{foo}.bar.{baz}')             //=> 'foo.bar.baz'
-      ```
+    var hamster = Hamster.create();
 
-      @method
-      @private
-      @param {String} pattern The property pattern to expand.
-      @param {Function} callback The callback to invoke.  It is invoked once per
-      expansion, and is passed the expansion.
-      */
-    __exports__["default"] = function expandProperties(pattern, callback) {
-      if (pattern.indexOf(' ') > -1) {
-        throw new EmberError('Brace expanded properties cannot contain spaces, ' +
-          'e.g. `user.{firstName, lastName}` should be `user.{firstName,lastName}`');
+    hamster.get('readyForCamp'); // false
+    hamster.set('hasTent', true);
+    hamster.get('readyForCamp'); // false
+    hamster.set('hasBackpack', true);
+    hamster.get('readyForCamp'); // true
+    hamster.set('hasBackpack', 'Yes');
+    hamster.get('readyForCamp'); // 'Yes'
+    ```
+
+    @method and
+    @for Ember.computed
+    @param {String} dependentKey*
+    @return {Ember.ComputedProperty} computed property which performs
+    a logical `and` on the values of all the original values for properties.
+  */
+  var and = generateComputedWithProperties(function(properties) {
+    var value;
+    for (var key in properties) {
+      value = properties[key];
+      if (properties.hasOwnProperty(key) && !value) {
+        return false;
       }
+    }
+    return value;
+  });
 
-      
-        return newExpandProperties(pattern, callback);
-          }
+  /**
+    A computed property which performs a logical `or` on the
+    original values for the provided dependent properties.
 
-    function oldExpandProperties(pattern, callback) {
-      var match, prefix, list;
+    Example
 
-      if (match = BRACE_EXPANSION.exec(pattern)) {
-        prefix = match[1];
-        list = match[2];
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      readyForRain: Ember.computed.or('hasJacket', 'hasUmbrella')
+    });
 
-        forEach(list.split(','), function (suffix) {
-            callback(prefix + suffix);
-        });
-      } else {
-        callback(pattern);
+    var hamster = Hamster.create();
+
+    hamster.get('readyForRain'); // false
+    hamster.set('hasUmbrella', true);
+    hamster.get('readyForRain'); // true
+    hamster.set('hasJacket', 'Yes');
+    hamster.get('readyForRain'); // 'Yes'
+    ```
+
+    @method or
+    @for Ember.computed
+    @param {String} dependentKey*
+    @return {Ember.ComputedProperty} computed property which performs
+    a logical `or` on the values of all the original values for properties.
+  */
+  var or = generateComputedWithProperties(function(properties) {
+    for (var key in properties) {
+      if (properties.hasOwnProperty(key) && properties[key]) {
+        return properties[key];
       }
     }
+    return false;
+  });
 
-    function newExpandProperties(pattern, callback) {
-      if ('string' === Ember.typeOf(pattern)) {
-        var parts = pattern.split(SPLIT_REGEX);
-        var properties = [parts];
+  /**
+    A computed property that returns the first truthy value
+    from a list of dependent properties.
 
-        forEach(parts, function(part, index) {
-          if (part.indexOf(',') >= 0) {
-            properties = duplicateAndReplace(properties, part.split(','), index);
-          }
-        });
+    Example
 
-        forEach(properties, function(property) {
-          callback(property.join(''));
-        });
-      } else {
-        callback(pattern);
-      }
-    }
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      hasClothes: Ember.computed.any('hat', 'shirt')
+    });
 
-    function duplicateAndReplace(properties, currentParts, index) {
-      var all = [];
+    var hamster = Hamster.create();
 
-      forEach(properties, function(property) {
-        forEach(currentParts, function(part) {
-          var current = property.slice(0);
-          current[index] = part;
-          all.push(current);
-        });
-      });
+    hamster.get('hasClothes'); // null
+    hamster.set('shirt', 'Hawaiian Shirt');
+    hamster.get('hasClothes'); // 'Hawaiian Shirt'
+    ```
 
-      return all;
+    @method any
+    @for Ember.computed
+    @param {String} dependentKey*
+    @return {Ember.ComputedProperty} computed property which returns
+    the first truthy value of given list of properties.
+    @deprecated Use `Ember.computed.or` instead.
+  */
+  var any = generateComputedWithProperties(function(properties) {
+    for (var key in properties) {
+      if (properties.hasOwnProperty(key) && properties[key]) {
+        return properties[key];
+      }
     }
+    return null;
   });
-enifed("ember-metal/get_properties",
-  ["ember-metal/property_get","ember-metal/utils","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var get = __dependency1__.get;
-    var typeOf = __dependency2__.typeOf;
 
-    /**
-      To get multiple properties at once, call `Ember.getProperties`
-      with an object followed by a list of strings or an array:
+  /**
+    A computed property that returns the array of values
+    for the provided dependent properties.
 
-      ```javascript
-      Ember.getProperties(record, 'firstName', 'lastName', 'zipCode');
-      // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
-      ```
+    Example
 
-      is equivalent to:
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      clothes: Ember.computed.collect('hat', 'shirt')
+    });
 
-      ```javascript
-      Ember.getProperties(record, ['firstName', 'lastName', 'zipCode']);
-      // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
-      ```
+    var hamster = Hamster.create();
 
-      @method getProperties
-      @for Ember
-      @param {Object} obj
-      @param {String...|Array} list of keys to get
-      @return {Object}
-    */
-    __exports__["default"] = function getProperties(obj) {
-      var ret = {};
-      var propertyNames = arguments;
-      var i = 1;
+    hamster.get('clothes'); // [null, null]
+    hamster.set('hat', 'Camp Hat');
+    hamster.set('shirt', 'Camp Shirt');
+    hamster.get('clothes'); // ['Camp Hat', 'Camp Shirt']
+    ```
 
-      if (arguments.length === 2 && typeOf(arguments[1]) === 'array') {
-        i = 0;
-        propertyNames = arguments[1];
-      }
-      for(var len = propertyNames.length; i < len; i++) {
-        ret[propertyNames[i]] = get(obj, propertyNames[i]);
+    @method collect
+    @for Ember.computed
+    @param {String} dependentKey*
+    @return {Ember.ComputedProperty} computed property which maps
+    values of all passed in properties to an array.
+  */
+  var collect = generateComputedWithProperties(function(properties) {
+    var res = Ember['default'].A();
+    for (var key in properties) {
+      if (properties.hasOwnProperty(key)) {
+        if (isNone['default'](properties[key])) {
+          res.push(null);
+        } else {
+          res.push(properties[key]);
+        }
       }
-      return ret;
     }
+    return res;
   });
-enifed("ember-metal/injected_property",
-  ["ember-metal/core","ember-metal/computed","ember-metal/alias","ember-metal/properties","ember-metal/platform","ember-metal/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var ComputedProperty = __dependency2__.ComputedProperty;
-    var AliasedProperty = __dependency3__.AliasedProperty;
-    var Descriptor = __dependency4__.Descriptor;
-    var create = __dependency5__.create;
-    var meta = __dependency6__.meta;
 
-    /**
-      Read-only property that returns the result of a container lookup.
+  /**
+    Creates a new property that is an alias for another property
+    on an object. Calls to `get` or `set` this property behave as
+    though they were called on the original property.
 
-      @class InjectedProperty
-      @namespace Ember
-      @extends Ember.Descriptor
-      @constructor
-      @param {String} type The container type the property will lookup
-      @param {String} name (optional) The name the property will lookup, defaults
-             to the property's name
-    */
-    function InjectedProperty(type, name) {
-      this.type = type;
-      this.name = name;
+    ```javascript
+    var Person = Ember.Object.extend({
+      name: 'Alex Matchneer',
+      nomen: Ember.computed.alias('name')
+    });
 
-      this._super$Constructor(injectedPropertyGet);
-      AliasedPropertyPrototype.oneWay.call(this);
-    }
+    var alex = Person.create();
 
-    function injectedPropertyGet(keyName) {
-      var desc = meta(this).descs[keyName];
+    alex.get('nomen'); // 'Alex Matchneer'
+    alex.get('name');  // 'Alex Matchneer'
 
-      Ember.assert("Attempting to lookup an injected property on an object " +
-                   "without a container, ensure that the object was " +
-                   "instantiated via a container.", this.container);
+    alex.set('nomen', '@machty');
+    alex.get('name');  // '@machty'
+    ```
 
-      return this.container.lookup(desc.type + ':' + (desc.name || keyName));
-    }
+    @method alias
+    @for Ember.computed
+    @param {String} dependentKey
+    @return {Ember.ComputedProperty} computed property which creates an
+    alias to the original value for property.
+  */
 
-    InjectedProperty.prototype = create(Descriptor.prototype);
+  /**
+    Where `computed.alias` aliases `get` and `set`, and allows for bidirectional
+    data flow, `computed.oneWay` only provides an aliased `get`. The `set` will
+    not mutate the upstream property, rather causes the current property to
+    become the value set. This causes the downstream property to permanently
+    diverge from the upstream property.
 
-    var InjectedPropertyPrototype = InjectedProperty.prototype;
-    var ComputedPropertyPrototype = ComputedProperty.prototype;
-    var AliasedPropertyPrototype = AliasedProperty.prototype;
+    Example
 
-    InjectedPropertyPrototype._super$Constructor = ComputedProperty;
+    ```javascript
+    var User = Ember.Object.extend({
+      firstName: null,
+      lastName: null,
+      nickName: Ember.computed.oneWay('firstName')
+    });
 
-    InjectedPropertyPrototype.get = ComputedPropertyPrototype.get;
-    InjectedPropertyPrototype.readOnly = ComputedPropertyPrototype.readOnly;
+    var teddy = User.create({
+      firstName: 'Teddy',
+      lastName:  'Zeenny'
+    });
 
-    InjectedPropertyPrototype.teardown = ComputedPropertyPrototype.teardown;
+    teddy.get('nickName');              // 'Teddy'
+    teddy.set('nickName', 'TeddyBear'); // 'TeddyBear'
+    teddy.get('firstName');             // 'Teddy'
+    ```
 
-    __exports__["default"] = InjectedProperty;
-  });
-enifed("ember-metal/instrumentation",
-  ["ember-metal/core","ember-metal/utils","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var tryCatchFinally = __dependency2__.tryCatchFinally;
+    @method oneWay
+    @for Ember.computed
+    @param {String} dependentKey
+    @return {Ember.ComputedProperty} computed property which creates a
+    one way computed property to the original value for property.
+  */
+  function oneWay(dependentKey) {
+    return alias['default'](dependentKey).oneWay();
+  }
 
-    /**
-      The purpose of the Ember Instrumentation module is
-      to provide efficient, general-purpose instrumentation
-      for Ember.
+  /**
+    This is a more semantically meaningful alias of `computed.oneWay`,
+    whose name is somewhat ambiguous as to which direction the data flows.
 
-      Subscribe to a listener by using `Ember.subscribe`:
+    @method reads
+    @for Ember.computed
+    @param {String} dependentKey
+    @return {Ember.ComputedProperty} computed property which creates a
+      one way computed property to the original value for property.
+   */
 
-      ```javascript
-      Ember.subscribe("render", {
-        before: function(name, timestamp, payload) {
+  /**
+    Where `computed.oneWay` provides oneWay bindings, `computed.readOnly` provides
+    a readOnly one way binding. Very often when using `computed.oneWay` one does
+    not also want changes to propagate back up, as they will replace the value.
 
-        },
+    This prevents the reverse flow, and also throws an exception when it occurs.
 
-        after: function(name, timestamp, payload) {
+    Example
 
-        }
-      });
-      ```
+    ```javascript
+    var User = Ember.Object.extend({
+      firstName: null,
+      lastName: null,
+      nickName: Ember.computed.readOnly('firstName')
+    });
 
-      If you return a value from the `before` callback, that same
-      value will be passed as a fourth parameter to the `after`
-      callback.
+    var teddy = User.create({
+      firstName: 'Teddy',
+      lastName:  'Zeenny'
+    });
 
-      Instrument a block of code by using `Ember.instrument`:
+    teddy.get('nickName');              // 'Teddy'
+    teddy.set('nickName', 'TeddyBear'); // throws Exception
+    // throw new Ember.Error('Cannot Set: nickName on: <User:ember27288>' );`
+    teddy.get('firstName');             // 'Teddy'
+    ```
 
-      ```javascript
-      Ember.instrument("render.handlebars", payload, function() {
-        // rendering logic
-      }, binding);
-      ```
+    @method readOnly
+    @for Ember.computed
+    @param {String} dependentKey
+    @return {Ember.ComputedProperty} computed property which creates a
+    one way computed property to the original value for property.
+    @since 1.5.0
+  */
+  function readOnly(dependentKey) {
+    return alias['default'](dependentKey).readOnly();
+  }
 
-      Event names passed to `Ember.instrument` are namespaced
-      by periods, from more general to more specific. Subscribers
-      can listen for events by whatever level of granularity they
-      are interested in.
+  /**
+    A computed property that acts like a standard getter and setter,
+    but returns the value at the provided `defaultPath` if the
+    property itself has not been set to a value
 
-      In the above example, the event is `render.handlebars`,
-      and the subscriber listened for all events beginning with
-      `render`. It would receive callbacks for events named
-      `render`, `render.handlebars`, `render.container`, or
-      even `render.handlebars.layout`.
+    Example
 
-      @class Instrumentation
-      @namespace Ember
-      @static
-    */
-    var subscribers = [];
-    __exports__.subscribers = subscribers;var cache = {};
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      wishList: Ember.computed.defaultTo('favoriteFood')
+    });
 
-    var populateListeners = function(name) {
-      var listeners = [];
-      var subscriber;
+    var hamster = Hamster.create({ favoriteFood: 'Banana' });
 
-      for (var i=0, l=subscribers.length; i<l; i++) {
-        subscriber = subscribers[i];
-        if (subscriber.regex.test(name)) {
-          listeners.push(subscriber.object);
-        }
+    hamster.get('wishList');                     // 'Banana'
+    hamster.set('wishList', 'More Unit Tests');
+    hamster.get('wishList');                     // 'More Unit Tests'
+    hamster.get('favoriteFood');                 // 'Banana'
+    ```
+
+    @method defaultTo
+    @for Ember.computed
+    @param {String} defaultPath
+    @return {Ember.ComputedProperty} computed property which acts like
+    a standard getter and setter, but defaults to the value from `defaultPath`.
+    @deprecated Use `Ember.computed.oneWay` or custom CP with default instead.
+  */
+  function defaultTo(defaultPath) {
+    return computed.computed(function(key, newValue, cachedValue) {
+      Ember['default'].deprecate('Usage of Ember.computed.defaultTo is deprecated, use `Ember.computed.oneWay` instead.');
+
+      if (arguments.length === 1) {
+        return property_get.get(this, defaultPath);
+      }
+      return newValue != null ? newValue : property_get.get(this, defaultPath);
+    });
+  }
+
+  /**
+    Creates a new property that is an alias for another property
+    on an object. Calls to `get` or `set` this property behave as
+    though they were called on the original property, but also
+    print a deprecation warning.
+
+    @method deprecatingAlias
+    @for Ember.computed
+    @param {String} dependentKey
+    @return {Ember.ComputedProperty} computed property which creates an
+    alias with a deprecation to the original value for property.
+    @since 1.7.0
+  */
+  function deprecatingAlias(dependentKey) {
+    return computed.computed(dependentKey, function(key, value) {
+      Ember['default'].deprecate('Usage of `' + key + '` is deprecated, use `' + dependentKey + '` instead.');
+
+      if (arguments.length > 1) {
+        property_set.set(this, dependentKey, value);
+        return value;
+      } else {
+        return property_get.get(this, dependentKey);
       }
+    });
+  }
 
-      cache[name] = listeners;
-      return listeners;
-    };
+  exports.and = and;
+  exports.or = or;
+  exports.any = any;
+  exports.collect = collect;
 
-    var time = (function() {
-      var perf = 'undefined' !== typeof window ? window.performance || {} : {};
-      var fn = perf.now || perf.mozNow || perf.webkitNow || perf.msNow || perf.oNow;
-      // fn.bind will be available in all the browsers that support the advanced window.performance... ;-)
-      return fn ? fn.bind(perf) : function() { return +new Date(); };
-    })();
+});
+enifed('ember-metal/core', ['exports'], function (exports) {
 
-    /**
-      Notifies event's subscribers, calls `before` and `after` hooks.
+  'use strict';
 
-      @method instrument
-      @namespace Ember.Instrumentation
+  exports.K = K;
 
-      @param {String} [name] Namespaced event name.
-      @param {Object} payload
-      @param {Function} callback Function that you're instrumenting.
-      @param {Object} binding Context that instrument function is called with.
-    */
-    function instrument(name, _payload, callback, binding) {
-      if (arguments.length <= 3 && typeof _payload === 'function') {
-        binding = callback;
-        callback = _payload;
-        _payload = undefined;
-      }
-      if (subscribers.length === 0) {
-        return callback.call(binding);
-      }
-      var payload = _payload || {};
-      var finalizer = _instrumentStart(name, function () {
-        return payload;
-      });
-      if (finalizer) {
-        var tryable = function _instrumenTryable() {
-          return callback.call(binding);
-        };
-        var catchable = function _instrumentCatchable(e) {
-          payload.exception = e;
-        };
-        return tryCatchFinally(tryable, catchable, finalizer);
-      } else {
-        return callback.call(binding);
-      }
-    }
+  /*globals Ember:true,ENV,EmberENV */
 
-    __exports__.instrument = instrument;// private for now
-    function _instrumentStart(name, _payload) {
-      var listeners = cache[name];
+  /**
+  @module ember
+  @submodule ember-metal
+  */
 
-      if (!listeners) {
-        listeners = populateListeners(name);
-      }
+  /**
+    All Ember methods and functions are defined inside of this namespace. You
+    generally should not add new properties to this namespace as it may be
+    overwritten by future versions of Ember.
 
-      if (listeners.length === 0) {
-        return;
-      }
+    You can also use the shorthand `Em` instead of `Ember`.
 
-      var payload = _payload();
+    Ember-Runtime is a framework that provides core functions for Ember including
+    cross-platform functions, support for property observing and objects. Its
+    focus is on small size and performance. You can use this in place of or
+    along-side other cross-platform libraries such as jQuery.
 
-      var STRUCTURED_PROFILE = Ember.STRUCTURED_PROFILE;
-      var timeName;
-      if (STRUCTURED_PROFILE) {
-        timeName = name + ": " + payload.object;
-        console.time(timeName);
-      }
+    The core Runtime framework is based on the jQuery API with a number of
+    performance optimizations.
 
-      var l = listeners.length;
-      var beforeValues = new Array(l);
-      var i, listener;
-      var timestamp = time();
-      for (i=0; i<l; i++) {
-        listener = listeners[i];
-        beforeValues[i] = listener.before(name, timestamp, payload);
-      }
+    @class Ember
+    @static
+    @version 1.11.0
+  */
 
-      return function _instrumentEnd() {
-        var i, l, listener;
-        var timestamp = time();
-        for (i=0, l=listeners.length; i<l; i++) {
-          listener = listeners[i];
-          listener.after(name, timestamp, payload, beforeValues[i]);
-        }
+  if ('undefined' === typeof Ember) {
+    // Create core object. Make it act like an instance of Ember.Namespace so that
+    // objects assigned to it are given a sane string representation.
+    Ember = {};
+  }
 
-        if (STRUCTURED_PROFILE) {
-          console.timeEnd(timeName);
-        }
-      };
-    }
+  // Default imports, exports and lookup to the global object;
+  var global = mainContext || {}; // jshint ignore:line
+  Ember.imports = Ember.imports || global;
+  Ember.lookup  = Ember.lookup  || global;
+  var emExports   = Ember.exports = Ember.exports || global;
 
-    __exports__._instrumentStart = _instrumentStart;/**
-      Subscribes to a particular event or instrumented block of code.
+  // aliases needed to keep minifiers from removing the global context
+  emExports.Em = emExports.Ember = Ember;
 
-      @method subscribe
-      @namespace Ember.Instrumentation
+  // Make sure these are set whether Ember was already defined or not
 
-      @param {String} [pattern] Namespaced event name.
-      @param {Object} [object] Before and After hooks.
+  Ember.isNamespace = true;
 
-      @return {Subscriber}
-    */
-    function subscribe(pattern, object) {
-      var paths = pattern.split("."), path, regex = [];
+  Ember.toString = function() { return "Ember"; };
 
-      for (var i=0, l=paths.length; i<l; i++) {
-        path = paths[i];
-        if (path === "*") {
-          regex.push("[^\\.]*");
-        } else {
-          regex.push(path);
-        }
-      }
 
-      regex = regex.join("\\.");
-      regex = regex + "(\\..*)?";
+  /**
+    @property VERSION
+    @type String
+    @default '1.11.0'
+    @static
+  */
+  Ember.VERSION = '1.11.0';
+
+  /**
+    Standard environmental variables. You can define these in a global `EmberENV`
+    variable before loading Ember to control various configuration settings.
+
+    For backwards compatibility with earlier versions of Ember the global `ENV`
+    variable will be used if `EmberENV` is not defined.
+
+    @property ENV
+    @type Hash
+  */
+
+  if (Ember.ENV) {
+    // do nothing if Ember.ENV is already setup
+    Ember.assert('Ember.ENV should be an object.', 'object' !== typeof Ember.ENV);
+  } else if ('undefined' !== typeof EmberENV) {
+    Ember.ENV = EmberENV;
+  } else if ('undefined' !== typeof ENV) {
+    Ember.ENV = ENV;
+  } else {
+    Ember.ENV = {};
+  }
 
-      var subscriber = {
-        pattern: pattern,
-        regex: new RegExp("^" + regex + "$"),
-        object: object
-      };
+  Ember.config = Ember.config || {};
 
-      subscribers.push(subscriber);
-      cache = {};
+  // We disable the RANGE API by default for performance reasons
+  if ('undefined' === typeof Ember.ENV.DISABLE_RANGE_API) {
+    Ember.ENV.DISABLE_RANGE_API = true;
+  }
 
-      return subscriber;
-    }
+  /**
+    Hash of enabled Canary features. Add to this before creating your application.
 
-    __exports__.subscribe = subscribe;/**
-      Unsubscribes from a particular event or instrumented block of code.
+    You can also define `EmberENV.FEATURES` if you need to enable features flagged at runtime.
 
-      @method unsubscribe
-      @namespace Ember.Instrumentation
+    @class FEATURES
+    @namespace Ember
+    @static
+    @since 1.1.0
+  */
 
-      @param {Object} [subscriber]
-    */
-    function unsubscribe(subscriber) {
-      var index;
+  Ember.FEATURES = Ember.ENV.FEATURES;
 
-      for (var i=0, l=subscribers.length; i<l; i++) {
-        if (subscribers[i] === subscriber) {
-          index = i;
-        }
-      }
+  if (!Ember.FEATURES) {
+    Ember.FEATURES = {"features-stripped-test":false,"ember-routing-named-substates":true,"mandatory-setter":true,"ember-htmlbars-component-generation":false,"ember-htmlbars-component-helper":true,"ember-htmlbars-inline-if-helper":true,"ember-htmlbars-attribute-syntax":true,"ember-routing-transitioning-classes":true,"new-computed-syntax":false,"ember-testing-checkbox-helpers":false,"ember-metal-stream":false,"ember-htmlbars-each-with-index":true,"ember-application-instance-initializers":false,"ember-application-initializer-context":false,"ember-router-willtransition":true,"ember-application-visit":false}; //jshint ignore:line
+  }
 
-      subscribers.splice(index, 1);
-      cache = {};
-    }
+  /**
+    Test that a feature is enabled. Parsed by Ember's build tools to leave
+    experimental features out of beta/stable builds.
 
-    __exports__.unsubscribe = unsubscribe;/**
-      Resets `Ember.Instrumentation` by flushing list of subscribers.
+    You can define the following configuration options:
 
-      @method reset
-      @namespace Ember.Instrumentation
-    */
-    function reset() {
-      subscribers.length = 0;
-      cache = {};
-    }
+    * `EmberENV.ENABLE_ALL_FEATURES` - force all features to be enabled.
+    * `EmberENV.ENABLE_OPTIONAL_FEATURES` - enable any features that have not been explicitly
+      enabled/disabled.
 
-    __exports__.reset = reset;
-  });
-enifed("ember-metal/is_blank",
-  ["ember-metal/is_empty","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var isEmpty = __dependency1__["default"];
+    @method isEnabled
+    @param {String} feature
+    @return {Boolean}
+    @for Ember.FEATURES
+    @since 1.1.0
+  */
 
-    /**
-      A value is blank if it is empty or a whitespace string.
+  Ember.FEATURES.isEnabled = function(feature) {
+    var featureValue = Ember.FEATURES[feature];
 
-      ```javascript
-      Ember.isBlank();                // true
-      Ember.isBlank(null);            // true
-      Ember.isBlank(undefined);       // true
-      Ember.isBlank('');              // true
-      Ember.isBlank([]);              // true
-      Ember.isBlank('\n\t');          // true
-      Ember.isBlank('  ');            // true
-      Ember.isBlank({});              // false
-      Ember.isBlank('\n\t Hello');    // false
-      Ember.isBlank('Hello world');   // false
-      Ember.isBlank([1,2,3]);         // false
-      ```
-
-      @method isBlank
-      @for Ember
-      @param {Object} obj Value to test
-      @return {Boolean}
-      @since 1.5.0
-      */
-    __exports__["default"] = function isBlank(obj) {
-      return isEmpty(obj) || (typeof obj === 'string' && obj.match(/\S/) === null);
+    if (Ember.ENV.ENABLE_ALL_FEATURES) {
+      return true;
+    } else if (featureValue === true || featureValue === false || featureValue === undefined) {
+      return featureValue;
+    } else if (Ember.ENV.ENABLE_OPTIONAL_FEATURES) {
+      return true;
+    } else {
+      return false;
     }
-  });
-enifed("ember-metal/is_empty",
-  ["ember-metal/property_get","ember-metal/is_none","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var get = __dependency1__.get;
-    var isNone = __dependency2__["default"];
+  };
 
-    /**
-      Verifies that a value is `null` or an empty string, empty array,
-      or empty function.
+  // ..........................................................
+  // BOOTSTRAP
+  //
 
-      Constrains the rules on `Ember.isNone` by returning true for empty
-      string and empty arrays.
+  /**
+    Determines whether Ember should enhance some built-in object prototypes to
+    provide a more friendly API. If enabled, a few methods will be added to
+    `Function`, `String`, and `Array`. `Object.prototype` will not be enhanced,
+    which is the one that causes most trouble for people.
 
-      ```javascript
-      Ember.isEmpty();                // true
-      Ember.isEmpty(null);            // true
-      Ember.isEmpty(undefined);       // true
-      Ember.isEmpty('');              // true
-      Ember.isEmpty([]);              // true
-      Ember.isEmpty({});              // false
-      Ember.isEmpty('Adam Hawkins');  // false
-      Ember.isEmpty([0,1,2]);         // false
-      ```
+    In general we recommend leaving this option set to true since it rarely
+    conflicts with other code. If you need to turn it off however, you can
+    define an `EmberENV.EXTEND_PROTOTYPES` config to disable it.
 
-      @method isEmpty
-      @for Ember
-      @param {Object} obj Value to test
-      @return {Boolean}
-    */
-    function isEmpty(obj) {
-      var none = isNone(obj);
-      if (none) {
-        return none;
-      }
+    @property EXTEND_PROTOTYPES
+    @type Boolean
+    @default true
+    @for Ember
+  */
+  Ember.EXTEND_PROTOTYPES = Ember.ENV.EXTEND_PROTOTYPES;
+
+  if (typeof Ember.EXTEND_PROTOTYPES === 'undefined') {
+    Ember.EXTEND_PROTOTYPES = true;
+  }
+
+  /**
+    Determines whether Ember logs a full stack trace during deprecation warnings
+
+    @property LOG_STACKTRACE_ON_DEPRECATION
+    @type Boolean
+    @default true
+  */
+  Ember.LOG_STACKTRACE_ON_DEPRECATION = (Ember.ENV.LOG_STACKTRACE_ON_DEPRECATION !== false);
+
+  /**
+    Determines whether Ember should add ECMAScript 5 Array shims to older browsers.
+
+    @property SHIM_ES5
+    @type Boolean
+    @default Ember.EXTEND_PROTOTYPES
+  */
+  Ember.SHIM_ES5 = (Ember.ENV.SHIM_ES5 === false) ? false : Ember.EXTEND_PROTOTYPES;
+
+  /**
+    Determines whether Ember logs info about version of used libraries
+
+    @property LOG_VERSION
+    @type Boolean
+    @default true
+  */
+  Ember.LOG_VERSION = (Ember.ENV.LOG_VERSION === false) ? false : true;
+
+  /**
+    Empty function. Useful for some operations. Always returns `this`.
+
+    @method K
+    @private
+    @return {Object}
+  */
+  function K() { return this; }
+  Ember.K = K;
+  //TODO: ES6 GLOBAL TODO
+
+  // Stub out the methods defined by the ember-debug package in case it's not loaded
+
+  if ('undefined' === typeof Ember.assert) { Ember.assert = K; }
+  if ('undefined' === typeof Ember.warn) { Ember.warn = K; }
+  if ('undefined' === typeof Ember.debug) { Ember.debug = K; }
+  if ('undefined' === typeof Ember.runInDebug) { Ember.runInDebug = K; }
+  if ('undefined' === typeof Ember.deprecate) { Ember.deprecate = K; }
+  if ('undefined' === typeof Ember.deprecateFunc) {
+    Ember.deprecateFunc = function(_, func) { return func; };
+  }
 
-      if (typeof obj.size === 'number') {
-        return !obj.size;
-      }
+  exports['default'] = Ember;
 
-      var objectType = typeof obj;
+});
+enifed('ember-metal/dependent_keys', ['exports', 'ember-metal/platform/create', 'ember-metal/watching'], function (exports, o_create, watching) {
 
-      if (objectType === 'object') {
-        var size = get(obj, 'size');
-        if (typeof size === 'number') {
-          return !size;
-        }
-      }
 
-      if (typeof obj.length === 'number' && objectType !== 'function') {
-        return !obj.length;
-      }
+  exports.addDependentKeys = addDependentKeys;
+  exports.removeDependentKeys = removeDependentKeys;
 
-      if (objectType === 'object') {
-        var length = get(obj, 'length');
-        if (typeof length === 'number') {
-          return !length;
-        }
-      }
+  // Remove "use strict"; from transpiled module until
+  // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
+  //
+  "REMOVE_USE_STRICT: true";
 
-      return false;
+  function keysForDep(depsMeta, depKey) {
+    var keys = depsMeta[depKey];
+    if (!keys) {
+      // if there are no dependencies yet for a the given key
+      // create a new empty list of dependencies for the key
+      keys = depsMeta[depKey] = {};
+    } else if (!depsMeta.hasOwnProperty(depKey)) {
+      // otherwise if the dependency list is inherited from
+      // a superclass, clone the hash
+      keys = depsMeta[depKey] = o_create['default'](keys);
     }
+    return keys;
+  }
 
-    __exports__["default"] = isEmpty;
-  });
-enifed("ember-metal/is_none",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-      Returns true if the passed value is null or undefined. This avoids errors
-      from JSLint complaining about use of ==, which can be technically
-      confusing.
+  function metaForDeps(meta) {
+    return keysForDep(meta, 'deps');
+  }
 
-      ```javascript
-      Ember.isNone();              // true
-      Ember.isNone(null);          // true
-      Ember.isNone(undefined);     // true
-      Ember.isNone('');            // false
-      Ember.isNone([]);            // false
-      Ember.isNone(function() {});  // false
-      ```
+  function addDependentKeys(desc, obj, keyName, meta) {
+    // the descriptor has a list of dependent keys, so
+    // add all of its dependent keys.
+    var depsMeta, idx, len, depKey, keys;
+    var depKeys = desc._dependentKeys;
+    if (!depKeys) {
+      return;
+    }
 
-      @method isNone
-      @for Ember
-      @param {Object} obj Value to test
-      @return {Boolean}
-    */
-    function isNone(obj) {
-      return obj === null || obj === undefined;
+    depsMeta = metaForDeps(meta);
+
+    for (idx = 0, len = depKeys.length; idx < len; idx++) {
+      depKey = depKeys[idx];
+      // Lookup keys meta for depKey
+      keys = keysForDep(depsMeta, depKey);
+      // Increment the number of times depKey depends on keyName.
+      keys[keyName] = (keys[keyName] || 0) + 1;
+      // Watch the depKey
+      watching.watch(obj, depKey, meta);
     }
+  }
 
-    __exports__["default"] = isNone;
-  });
-enifed("ember-metal/is_present",
-  ["ember-metal/is_blank","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var isBlank = __dependency1__["default"];
-    var isPresent;
+  function removeDependentKeys(desc, obj, keyName, meta) {
+    // the descriptor has a list of dependent keys, so
+    // remove all of its dependent keys.
+    var depKeys = desc._dependentKeys;
+    var depsMeta, idx, len, depKey, keys;
+    if (!depKeys) {
+      return;
+    }
 
-    
-      /**
-        A value is present if it not `isBlank`.
+    depsMeta = metaForDeps(meta);
 
-        ```javascript
-        Ember.isPresent();                // false
-        Ember.isPresent(null);            // false
-        Ember.isPresent(undefined);       // false
-        Ember.isPresent('');              // false
-        Ember.isPresent([]);              // false
-        Ember.isPresent('\n\t');          // false
-        Ember.isPresent('  ');            // false
-        Ember.isPresent({});              // true
-        Ember.isPresent('\n\t Hello');    // true
-        Ember.isPresent('Hello world');   // true
-        Ember.isPresent([1,2,3]);         // true
-        ```
+    for (idx = 0, len = depKeys.length; idx < len; idx++) {
+      depKey = depKeys[idx];
+      // Lookup keys meta for depKey
+      keys = keysForDep(depsMeta, depKey);
+      // Decrement the number of times depKey depends on keyName.
+      keys[keyName] = (keys[keyName] || 0) - 1;
+      // Unwatch the depKey
+      watching.unwatch(obj, depKey, meta);
+    }
+  }
 
-        @method isPresent
-        @for Ember
-        @param {Object} obj Value to test
-        @return {Boolean}
-        @since 1.8.0
-        */
-      isPresent = function isPresent(obj) {
-        return !isBlank(obj);
-      };
-    
+});
+enifed('ember-metal/deprecate_property', ['exports', 'ember-metal/core', 'ember-metal/platform/define_property', 'ember-metal/properties', 'ember-metal/property_get', 'ember-metal/property_set'], function (exports, Ember, define_property, properties, property_get, property_set) {
 
-    __exports__["default"] = isPresent;
-  });
-enifed("ember-metal/keys",
-  ["ember-metal/platform","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var canDefineNonEnumerableProperties = __dependency1__.canDefineNonEnumerableProperties;
-
-    /**
-      Returns all of the keys defined on an object or hash. This is useful
-      when inspecting objects for debugging. On browsers that support it, this
-      uses the native `Object.keys` implementation.
-
-      @method keys
-      @for Ember
-      @param {Object} obj
-      @return {Array} Array containing keys of obj
-    */
-    var keys = Object.keys;
-
-    if (!keys || !canDefineNonEnumerableProperties) {
-      // modified from
-      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys
-      keys = (function () {
-        var hasOwnProperty = Object.prototype.hasOwnProperty,
-            hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
-            dontEnums = [
-              'toString',
-              'toLocaleString',
-              'valueOf',
-              'hasOwnProperty',
-              'isPrototypeOf',
-              'propertyIsEnumerable',
-              'constructor'
-            ],
-            dontEnumsLength = dontEnums.length;
-
-        return function keys(obj) {
-          if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {
-            throw new TypeError('Object.keys called on non-object');
-          }
+  'use strict';
 
-          var result = [];
-          var prop, i;
+  exports.deprecateProperty = deprecateProperty;
 
-          for (prop in obj) {
-            if (prop !== '_super' &&
-              prop.lastIndexOf('__',0) !== 0 &&
-              hasOwnProperty.call(obj, prop)) {
-              result.push(prop);
-            }
-          }
+  /**
+  @module ember-metal
+  */
 
-          if (hasDontEnumBug) {
-            for (i = 0; i < dontEnumsLength; i++) {
-              if (hasOwnProperty.call(obj, dontEnums[i])) {
-                result.push(dontEnums[i]);
-              }
-            }
-          }
-          return result;
-        };
-      }());
+  function deprecateProperty(object, deprecatedKey, newKey) {
+    function deprecate() {
+      Ember['default'].deprecate('Usage of `' + deprecatedKey + '` is deprecated, use `' + newKey + '` instead.');
     }
 
-    __exports__["default"] = keys;
-  });
-enifed("ember-metal/libraries",
-  ["ember-metal/core","ember-metal/enumerable_utils","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var forEach = __dependency2__.forEach;
-    var indexOf = __dependency2__.indexOf;
+    if (define_property.hasPropertyAccessors) {
+      properties.defineProperty(object, deprecatedKey, {
+        configurable: true,
+        enumerable: false,
+        set: function(value) {
+          deprecate();
+          property_set.set(this, newKey, value);
+        },
+        get: function() {
+          deprecate();
+          return property_get.get(this, newKey);
+        }
+      });
+    }
+  }
 
-    /**
-      Helper class that allows you to register your library with Ember.
+});
+enifed('ember-metal/dictionary', ['exports', 'ember-metal/platform/create'], function (exports, create) {
 
-      Singleton created at `Ember.libraries`.
+  'use strict';
 
-      @class Libraries
-      @constructor
-      @private
-    */
-    function Libraries() {
-      this._registry = [];
-      this._coreLibIndex = 0;
-    }
+  function makeDictionary(parent) {
+    var dict = create['default'](parent);
+    dict['_dict'] = null;
+    delete dict['_dict'];
+    return dict;
+  }
+  exports['default'] = makeDictionary;
+
+});
+enifed('ember-metal/enumerable_utils', ['exports', 'ember-metal/array'], function (exports, array) {
+
+  'use strict';
+
+  exports.map = map;
+  exports.forEach = forEach;
+  exports.filter = filter;
+  exports.indexOf = indexOf;
+  exports.indexesOf = indexesOf;
+  exports.addObject = addObject;
+  exports.removeObject = removeObject;
+  exports._replace = _replace;
+  exports.replace = replace;
+  exports.intersection = intersection;
+
+  var splice = Array.prototype.splice;
+
+  /**
+   * Defines some convenience methods for working with Enumerables.
+   * `Ember.EnumerableUtils` uses `Ember.ArrayPolyfills` when necessary.
+   *
+   * @class EnumerableUtils
+   * @namespace Ember
+   * @static
+   * */
+
+  /**
+   * Calls the map function on the passed object with a specified callback. This
+   * uses `Ember.ArrayPolyfill`'s-map method when necessary.
+   *
+   * @method map
+   * @param {Object} obj The object that should be mapped
+   * @param {Function} callback The callback to execute
+   * @param {Object} thisArg Value to use as this when executing *callback*
+   *
+   * @return {Array} An array of mapped values.
+   */
+  function map(obj, callback, thisArg) {
+    return obj.map ? obj.map(callback, thisArg) : array.map.call(obj, callback, thisArg);
+  }
 
-    Libraries.prototype = {
-      constructor: Libraries,
+  /**
+   * Calls the forEach function on the passed object with a specified callback. This
+   * uses `Ember.ArrayPolyfill`'s-forEach method when necessary.
+   *
+   * @method forEach
+   * @param {Object} obj The object to call forEach on
+   * @param {Function} callback The callback to execute
+   * @param {Object} thisArg Value to use as this when executing *callback*
+   *
+   */
+  function forEach(obj, callback, thisArg) {
+    return obj.forEach ? obj.forEach(callback, thisArg) : array.forEach.call(obj, callback, thisArg);
+  }
 
-      _getLibraryByName: function(name) {
-        var libs = this._registry;
-        var count = libs.length;
+  /**
+   * Calls the filter function on the passed object with a specified callback. This
+   * uses `Ember.ArrayPolyfill`'s-filter method when necessary.
+   *
+   * @method filter
+   * @param {Object} obj The object to call filter on
+   * @param {Function} callback The callback to execute
+   * @param {Object} thisArg Value to use as this when executing *callback*
+   *
+   * @return {Array} An array containing the filtered values
+   * @since 1.4.0
+   */
+  function filter(obj, callback, thisArg) {
+    return obj.filter ? obj.filter(callback, thisArg) : array.filter.call(obj, callback, thisArg);
+  }
 
-        for (var i = 0; i < count; i++) {
-          if (libs[i].name === name) {
-            return libs[i];
-          }
-        }
-      },
+  /**
+   * Calls the indexOf function on the passed object with a specified callback. This
+   * uses `Ember.ArrayPolyfill`'s-indexOf method when necessary.
+   *
+   * @method indexOf
+   * @param {Object} obj The object to call indexOn on
+   * @param {Function} callback The callback to execute
+   * @param {Object} index The index to start searching from
+   *
+   */
+  function indexOf(obj, element, index) {
+    return obj.indexOf ? obj.indexOf(element, index) : array.indexOf.call(obj, element, index);
+  }
 
-      register: function(name, version, isCoreLibrary) {
-        var index = this._registry.length;
+  /**
+   * Returns an array of indexes of the first occurrences of the passed elements
+   * on the passed object.
+   *
+   * ```javascript
+   *  var array = [1, 2, 3, 4, 5];
+   *  Ember.EnumerableUtils.indexesOf(array, [2, 5]); // [1, 4]
+   *
+   *  var fubar = "Fubarr";
+   *  Ember.EnumerableUtils.indexesOf(fubar, ['b', 'r']); // [2, 4]
+   * ```
+   *
+   * @method indexesOf
+   * @param {Object} obj The object to check for element indexes
+   * @param {Array} elements The elements to search for on *obj*
+   *
+   * @return {Array} An array of indexes.
+   *
+   */
+  function indexesOf(obj, elements) {
+    return elements === undefined ? [] : map(elements, function(item) {
+      return indexOf(obj, item);
+    });
+  }
 
-        if (!this._getLibraryByName(name)) {
-          if (isCoreLibrary) {
-            index = this._coreLibIndex++;
-          }
-          this._registry.splice(index, 0, { name: name, version: version });
-        } else {
-          Ember.warn('Library "' + name + '" is already registered with Ember.');
-        }
-      },
+  /**
+   * Adds an object to an array. If the array already includes the object this
+   * method has no effect.
+   *
+   * @method addObject
+   * @param {Array} array The array the passed item should be added to
+   * @param {Object} item The item to add to the passed array
+   *
+   * @return 'undefined'
+   */
+  function addObject(array, item) {
+    var index = indexOf(array, item);
+    if (index === -1) { array.push(item); }
+  }
 
-      registerCoreLibrary: function(name, version) {
-        this.register(name, version, true);
-      },
+  /**
+   * Removes an object from an array. If the array does not contain the passed
+   * object this method has no effect.
+   *
+   * @method removeObject
+   * @param {Array} array The array to remove the item from.
+   * @param {Object} item The item to remove from the passed array.
+   *
+   * @return 'undefined'
+   */
+  function removeObject(array, item) {
+    var index = indexOf(array, item);
+    if (index !== -1) { array.splice(index, 1); }
+  }
 
-      deRegister: function(name) {
-        var lib = this._getLibraryByName(name);
-        var index;
+  function _replace(array, idx, amt, objects) {
+    var args = [].concat(objects);
+    var ret = [];
+    // https://code.google.com/p/chromium/issues/detail?id=56588
+    var size = 60000;
+    var start = idx;
+    var ends = amt;
+    var count, chunk;
 
-        if (lib) {
-          index = indexOf(this._registry, lib);
-          this._registry.splice(index, 1);
-        }
-      },
+    while (args.length) {
+      count = ends > size ? size : ends;
+      if (count <= 0) { count = 0; }
 
-      each: function(callback) {
-        Ember.deprecate('Using Ember.libraries.each() is deprecated. Access to a list of registered libraries is currently a private API. If you are not knowingly accessing this method, your out-of-date Ember Inspector may be doing so.');
-        forEach(this._registry, function(lib) {
-          callback(lib.name, lib.version);
-        });
+      chunk = args.splice(0, size);
+      chunk = [start, count].concat(chunk);
+
+      start += size;
+      ends -= count;
+
+      ret = ret.concat(splice.apply(array, chunk));
+    }
+    return ret;
+  }
+
+  /**
+   * Replaces objects in an array with the passed objects.
+   *
+   * ```javascript
+   *   var array = [1,2,3];
+   *   Ember.EnumerableUtils.replace(array, 1, 2, [4, 5]); // [1, 4, 5]
+   *
+   *   var array = [1,2,3];
+   *   Ember.EnumerableUtils.replace(array, 1, 1, [4, 5]); // [1, 4, 5, 3]
+   *
+   *   var array = [1,2,3];
+   *   Ember.EnumerableUtils.replace(array, 10, 1, [4, 5]); // [1, 2, 3, 4, 5]
+   * ```
+   *
+   * @method replace
+   * @param {Array} array The array the objects should be inserted into.
+   * @param {Number} idx Starting index in the array to replace. If *idx* >=
+   * length, then append to the end of the array.
+   * @param {Number} amt Number of elements that should be removed from the array,
+   * starting at *idx*
+   * @param {Array} objects An array of zero or more objects that should be
+   * inserted into the array at *idx*
+   *
+   * @return {Array} The modified array.
+   */
+  function replace(array, idx, amt, objects) {
+    if (array.replace) {
+      return array.replace(idx, amt, objects);
+    } else {
+      return _replace(array, idx, amt, objects);
+    }
+  }
+
+  /**
+   * Calculates the intersection of two arrays. This method returns a new array
+   * filled with the records that the two passed arrays share with each other.
+   * If there is no intersection, an empty array will be returned.
+   *
+   * ```javascript
+   * var array1 = [1, 2, 3, 4, 5];
+   * var array2 = [1, 3, 5, 6, 7];
+   *
+   * Ember.EnumerableUtils.intersection(array1, array2); // [1, 3, 5]
+   *
+   * var array1 = [1, 2, 3];
+   * var array2 = [4, 5, 6];
+   *
+   * Ember.EnumerableUtils.intersection(array1, array2); // []
+   * ```
+   *
+   * @method intersection
+   * @param {Array} array1 The first array
+   * @param {Array} array2 The second array
+   *
+   * @return {Array} The intersection of the two passed arrays.
+   */
+  function intersection(array1, array2) {
+    var result = [];
+    forEach(array1, function(element) {
+      if (indexOf(array2, element) >= 0) {
+        result.push(element);
       }
+    });
+
+    return result;
+  }
+
+  // TODO: this only exists to maintain the existing api, as we move forward it
+  // should only be part of the "global build" via some shim
+  exports['default'] = {
+    _replace: _replace,
+    addObject: addObject,
+    filter: filter,
+    forEach: forEach,
+    indexOf: indexOf,
+    indexesOf: indexesOf,
+    intersection: intersection,
+    map: map,
+    removeObject: removeObject,
+    replace: replace
+  };
+
+});
+enifed('ember-metal/environment', ['exports', 'ember-metal/core'], function (exports, Ember) {
+
+  'use strict';
+
+  var environment;
+
+  // This code attempts to automatically detect an environment with DOM
+  // by searching for window and document.createElement. An environment
+  // with DOM may disable the DOM functionality of Ember explicitly by
+  // defining a `disableBrowserEnvironment` ENV.
+  var hasDOM = typeof window !== 'undefined' &&
+               typeof document !== 'undefined' &&
+               typeof document.createElement !== 'undefined' &&
+               !Ember['default'].ENV.disableBrowserEnvironment;
+
+  if (hasDOM) {
+    environment = {
+      hasDOM: true,
+      isChrome: !!window.chrome && !window.opera,
+      location: window.location,
+      history: window.history,
+      userAgent: window.navigator.userAgent
+    };
+  } else {
+    environment = {
+      hasDOM: false,
+      isChrome: false,
+      location: null,
+      history: null,
+      userAgent: "Lynx (textmode)"
     };
+  }
 
-    __exports__["default"] = Libraries;
-  });
-enifed("ember-metal/logger",
-  ["ember-metal/core","ember-metal/error","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.imports
-    var EmberError = __dependency2__["default"];
+  exports['default'] = environment;
 
-    function K() { return this; }
+});
+enifed('ember-metal/error', ['exports', 'ember-metal/platform/create'], function (exports, create) {
 
-    function consoleMethod(name) {
-      var consoleObj, logToConsole;
-      if (Ember.imports.console) {
-        consoleObj = Ember.imports.console;
-      } else if (typeof console !== 'undefined') {
-        consoleObj = console;
-      }
+  'use strict';
 
-      var method = typeof consoleObj === 'object' ? consoleObj[name] : null;
+  var errorProps = [
+    'description',
+    'fileName',
+    'lineNumber',
+    'message',
+    'name',
+    'number',
+    'stack'
+  ];
 
-      if (method) {
-        // Older IE doesn't support bind, but Chrome needs it
-        if (typeof method.bind === 'function') {
-          logToConsole = method.bind(consoleObj);
-          logToConsole.displayName = 'console.' + name;
-          return logToConsole;
-        } else if (typeof method.apply === 'function') {
-          logToConsole = function() {
-            method.apply(consoleObj, arguments);
-          };
-          logToConsole.displayName = 'console.' + name;
-          return logToConsole;
-        } else {
-          return function() {
-            var message = Array.prototype.join.call(arguments, ', ');
-            method(message);
-          };
-        }
-      }
-    }
+  /**
+    A subclass of the JavaScript Error object for use in Ember.
 
-    function assertPolyfill(test, message) {
-      if (!test) {
-        try {
-          // attempt to preserve the stack
-          throw new EmberError("assertion failed: " + message);
-        } catch(error) {
-          setTimeout(function() {
-            throw error;
-          }, 0);
-        }
-      }
+    @class Error
+    @namespace Ember
+    @extends Error
+    @constructor
+  */
+  function EmberError() {
+    var tmp = Error.apply(this, arguments);
+
+    // Adds a `stack` property to the given error object that will yield the
+    // stack trace at the time captureStackTrace was called.
+    // When collecting the stack trace all frames above the topmost call
+    // to this function, including that call, will be left out of the
+    // stack trace.
+    // This is useful because we can hide Ember implementation details
+    // that are not very helpful for the user.
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, Ember.Error);
+    }
+    // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
+    for (var idx = 0; idx < errorProps.length; idx++) {
+      this[errorProps[idx]] = tmp[errorProps[idx]];
     }
+  }
 
-    /**
-      Inside Ember-Metal, simply uses the methods from `imports.console`.
-      Override this to provide more robust logging functionality.
+  EmberError.prototype = create['default'](Error.prototype);
 
-      @class Logger
-      @namespace Ember
-    */
-    __exports__["default"] = {
-      /**
-       Logs the arguments to the console.
-       You can pass as many arguments as you want and they will be joined together with a space.
+  exports['default'] = EmberError;
 
-        ```javascript
-        var foo = 1;
-        Ember.Logger.log('log value of foo:', foo);
-        // "log value of foo: 1" will be printed to the console
-        ```
+});
+enifed('ember-metal/events', ['exports', 'ember-metal/core', 'ember-metal/utils', 'ember-metal/platform/create'], function (exports, Ember, utils, create) {
 
-       @method log
-       @for Ember.Logger
-       @param {*} arguments
-      */
-      log:   consoleMethod('log')   || K,
 
-      /**
-       Prints the arguments to the console with a warning icon.
-       You can pass as many arguments as you want and they will be joined together with a space.
+  exports.accumulateListeners = accumulateListeners;
+  exports.addListener = addListener;
+  exports.suspendListener = suspendListener;
+  exports.suspendListeners = suspendListeners;
+  exports.watchedEvents = watchedEvents;
+  exports.sendEvent = sendEvent;
+  exports.hasListeners = hasListeners;
+  exports.listenersFor = listenersFor;
+  exports.on = on;
+  exports.removeListener = removeListener;
 
-        ```javascript
-        Ember.Logger.warn('Something happened!');
-        // "Something happened!" will be printed to the console with a warning icon.
-        ```
+  // Remove "use strict"; from transpiled module until
+  // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
+  //
+  "REMOVE_USE_STRICT: true";
 
-       @method warn
-       @for Ember.Logger
-       @param {*} arguments
-      */
-      warn:  consoleMethod('warn')  || K,
+  /**
+  @module ember-metal
+  */
+  var a_slice = [].slice;
 
-      /**
-       Prints the arguments to the console with an error icon, red text and a stack trace.
-       You can pass as many arguments as you want and they will be joined together with a space.
+  /* listener flags */
+  var ONCE = 1;
+  var SUSPENDED = 2;
 
-        ```javascript
-        Ember.Logger.error('Danger! Danger!');
-        // "Danger! Danger!" will be printed to the console in red text.
-        ```
 
-       @method error
-       @for Ember.Logger
-       @param {*} arguments
-      */
-      error: consoleMethod('error') || K,
+  /*
+    The event system uses a series of nested hashes to store listeners on an
+    object. When a listener is registered, or when an event arrives, these
+    hashes are consulted to determine which target and action pair to invoke.
 
-      /**
-       Logs the arguments to the console.
-       You can pass as many arguments as you want and they will be joined together with a space.
+    The hashes are stored in the object's meta hash, and look like this:
 
-        ```javascript
-        var foo = 1;
-        Ember.Logger.info('log value of foo:', foo);
-        // "log value of foo: 1" will be printed to the console
-        ```
+        // Object's meta hash
+        {
+          listeners: {       // variable name: `listenerSet`
+            "foo:changed": [ // variable name: `actions`
+              target, method, flags
+            ]
+          }
+        }
 
-       @method info
-       @for Ember.Logger
-       @param {*} arguments
-      */
-      info:  consoleMethod('info')  || K,
+  */
 
-      /**
-       Logs the arguments to the console in blue text.
-       You can pass as many arguments as you want and they will be joined together with a space.
+  function indexOf(array, target, method) {
+    var index = -1;
+    // hashes are added to the end of the event array
+    // so it makes sense to start searching at the end
+    // of the array and search in reverse
+    for (var i = array.length - 3 ; i >=0; i -= 3) {
+      if (target === array[i] && method === array[i + 1]) {
+        index = i;
+        break;
+      }
+    }
+    return index;
+  }
 
-        ```javascript
-        var foo = 1;
-        Ember.Logger.debug('log value of foo:', foo);
-        // "log value of foo: 1" will be printed to the console
-        ```
+  function actionsFor(obj, eventName) {
+    var meta = utils.meta(obj, true);
+    var actions;
+    var listeners = meta.listeners;
 
-       @method debug
-       @for Ember.Logger
-       @param {*} arguments
-      */
-      debug: consoleMethod('debug') || consoleMethod('info') || K,
+    if (!listeners) {
+      listeners = meta.listeners = create['default'](null);
+      listeners.__source__ = obj;
+    } else if (listeners.__source__ !== obj) {
+      // setup inherited copy of the listeners object
+      listeners = meta.listeners = create['default'](listeners);
+      listeners.__source__ = obj;
+    }
 
-      /**
-       If the value passed into `Ember.Logger.assert` is not truthy it will throw an error with a stack trace.
+    actions = listeners[eventName];
 
-        ```javascript
-        Ember.Logger.assert(true); // undefined
-        Ember.Logger.assert(true === false); // Throws an Assertion failed error.
-        ```
+    // if there are actions, but the eventName doesn't exist in our listeners, then copy them from the prototype
+    if (actions && actions.__source__ !== obj) {
+      actions = listeners[eventName] = listeners[eventName].slice();
+      actions.__source__ = obj;
+    } else if (!actions) {
+      actions = listeners[eventName] = [];
+      actions.__source__ = obj;
+    }
 
-       @method assert
-       @for Ember.Logger
-       @param {Boolean} bool Value to test
-      */
-      assert: consoleMethod('assert') || assertPolyfill
-    };
-  });
-enifed("ember-metal/map",
-  ["ember-metal/utils","ember-metal/array","ember-metal/platform","ember-metal/deprecate_property","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    /**
-    @module ember-metal
-    */
+    return actions;
+  }
 
-    /*
-      JavaScript (before ES6) does not have a Map implementation. Objects,
-      which are often used as dictionaries, may only have Strings as keys.
+  function accumulateListeners(obj, eventName, otherActions) {
+    var meta = obj['__ember_meta__'];
+    var actions = meta && meta.listeners && meta.listeners[eventName];
 
-      Because Ember has a way to get a unique identifier for every object
-      via `Ember.guidFor`, we can implement a performant Map with arbitrary
-      keys. Because it is commonly used in low-level bookkeeping, Map is
-      implemented as a pure JavaScript object for performance.
+    if (!actions) { return; }
 
-      This implementation follows the current iteration of the ES6 proposal for
-      maps (http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets),
-      with one exception:  as we do not have the luxury of in-VM iteration, we implement a
-      forEach method for iteration.
+    var newActions = [];
 
-      Map is mocked out to look like an Ember object, so you can do
-      `Ember.Map.create()` for symmetry with other Ember classes.
-    */
+    for (var i = actions.length - 3; i >= 0; i -= 3) {
+      var target = actions[i];
+      var method = actions[i+1];
+      var flags = actions[i+2];
+      var actionIndex = indexOf(otherActions, target, method);
+
+      if (actionIndex === -1) {
+        otherActions.push(target, method, flags);
+        newActions.push(target, method, flags);
+      }
+    }
+
+    return newActions;
+  }
 
-    var guidFor = __dependency1__.guidFor;
-    var indexOf = __dependency2__.indexOf;
-    var create = __dependency3__.create;
-    var deprecateProperty = __dependency4__.deprecateProperty;
+  /**
+    Add an event listener
 
-    function missingFunction(fn) {
-      throw new TypeError('' + Object.prototype.toString.call(fn) + " is not a function");
+    @method addListener
+    @for Ember
+    @param obj
+    @param {String} eventName
+    @param {Object|Function} target A target object or a function
+    @param {Function|String} method A function or the name of a function to be called on `target`
+    @param {Boolean} once A flag whether a function should only be called once
+  */
+  function addListener(obj, eventName, target, method, once) {
+    Ember['default'].assert("You must pass at least an object and event name to Ember.addListener", !!obj && !!eventName);
+
+    if (!method && 'function' === typeof target) {
+      method = target;
+      target = null;
     }
 
-    function missingNew(name) {
-      throw new TypeError("Constructor " + name + "requires 'new'");
+    var actions = actionsFor(obj, eventName);
+    var actionIndex = indexOf(actions, target, method);
+    var flags = 0;
+
+    if (once) {
+      flags |= ONCE;
     }
 
-    function copyNull(obj) {
-      var output = create(null);
+    if (actionIndex !== -1) {
+      return;
+    }
 
-      for (var prop in obj) {
-        // hasOwnPropery is not needed because obj is Object.create(null);
-        output[prop] = obj[prop];
-      }
+    actions.push(target, method, flags);
 
-      return output;
+    if ('function' === typeof obj.didAddListener) {
+      obj.didAddListener(eventName, target, method);
     }
+  }
+
+  /**
+    Remove an event listener
 
-    function copyMap(original, newObject) {
-      var keys = original.keys.copy();
-      var values = copyNull(original.values);
+    Arguments should match those passed to `Ember.addListener`.
 
-      newObject.keys = keys;
-      newObject.values = values;
-      newObject.size = original.size;
+    @method removeListener
+    @for Ember
+    @param obj
+    @param {String} eventName
+    @param {Object|Function} target A target object or a function
+    @param {Function|String} method A function or the name of a function to be called on `target`
+  */
+  function removeListener(obj, eventName, target, method) {
+    Ember['default'].assert("You must pass at least an object and event name to Ember.removeListener", !!obj && !!eventName);
 
-      return newObject;
+    if (!method && 'function' === typeof target) {
+      method = target;
+      target = null;
     }
 
-    /**
-      This class is used internally by Ember and Ember Data.
-      Please do not use it at this time. We plan to clean it up
-      and add many tests soon.
+    function _removeListener(target, method) {
+      var actions = actionsFor(obj, eventName);
+      var actionIndex = indexOf(actions, target, method);
 
-      @class OrderedSet
-      @namespace Ember
-      @constructor
-      @private
-    */
-    function OrderedSet() {
+      // action doesn't exist, give up silently
+      if (actionIndex === -1) { return; }
 
-      if (this instanceof OrderedSet) {
-        this.clear();
-        this._silenceRemoveDeprecation = false;
-      } else {
-        missingNew("OrderedSet");
+      actions.splice(actionIndex, 3);
+
+      if ('function' === typeof obj.didRemoveListener) {
+        obj.didRemoveListener(eventName, target, method);
       }
     }
 
-    /**
-      @method create
-      @static
-      @return {Ember.OrderedSet}
-    */
-    OrderedSet.create = function() {
-      var Constructor = this;
-
-      return new Constructor();
-    };
+    if (method) {
+      _removeListener(target, method);
+    } else {
+      var meta = obj['__ember_meta__'];
+      var actions = meta && meta.listeners && meta.listeners[eventName];
 
-    OrderedSet.prototype = {
-      constructor: OrderedSet,
-      /**
-        @method clear
-      */
-      clear: function() {
-        this.presenceSet = create(null);
-        this.list = [];
-        this.size = 0;
-      },
+      if (!actions) { return; }
+      for (var i = actions.length - 3; i >= 0; i -= 3) {
+        _removeListener(actions[i], actions[i+1]);
+      }
+    }
+  }
 
-      /**
-        @method add
-        @param obj
-        @param guid (optional, and for internal use)
-        @return {Ember.OrderedSet}
-      */
-      add: function(obj, _guid) {
-        var guid = _guid || guidFor(obj);
-        var presenceSet = this.presenceSet;
-        var list = this.list;
+  /**
+    Suspend listener during callback.
 
-        if (presenceSet[guid] === true) {
-          return;
-        }
+    This should only be used by the target of the event listener
+    when it is taking an action that would cause the event, e.g.
+    an object might suspend its property change listener while it is
+    setting that property.
 
-        presenceSet[guid] = true;
-        this.size = list.push(obj);
+    @method suspendListener
+    @for Ember
 
-        return this;
-      },
+    @private
+    @param obj
+    @param {String} eventName
+    @param {Object|Function} target A target object or a function
+    @param {Function|String} method A function or the name of a function to be called on `target`
+    @param {Function} callback
+  */
+  function suspendListener(obj, eventName, target, method, callback) {
+    if (!method && 'function' === typeof target) {
+      method = target;
+      target = null;
+    }
 
-      /**
-        @deprecated
+    var actions = actionsFor(obj, eventName);
+    var actionIndex = indexOf(actions, target, method);
 
-        @method remove
-        @param obj
-        @param _guid (optional and for internal use only)
-        @return {Boolean}
-      */
-      remove: function(obj, _guid) {
-        Ember.deprecate('Calling `OrderedSet.prototype.remove` has been deprecated, please use `OrderedSet.prototype.delete` instead.', this._silenceRemoveDeprecation);
+    if (actionIndex !== -1) {
+      actions[actionIndex+2] |= SUSPENDED; // mark the action as suspended
+    }
 
-        return this["delete"](obj, _guid);
-      },
+    function tryable() { return callback.call(target); }
+    function finalizer() { if (actionIndex !== -1) { actions[actionIndex+2] &= ~SUSPENDED; } }
 
-      /**
-        @since 1.8.0
-        @method delete
-        @param obj
-        @param _guid (optional and for internal use only)
-        @return {Boolean}
-      */
-      "delete": function(obj, _guid) {
-        var guid = _guid || guidFor(obj);
-        var presenceSet = this.presenceSet;
-        var list = this.list;
-
-        if (presenceSet[guid] === true) {
-          delete presenceSet[guid];
-          var index = indexOf.call(list, obj);
-          if (index > -1) {
-            list.splice(index, 1);
-          }
-          this.size = list.length;
-          return true;
-        } else {
-          return false;
-        }
-      },
+    return utils.tryFinally(tryable, finalizer);
+  }
 
-      /**
-        @method isEmpty
-        @return {Boolean}
-      */
-      isEmpty: function() {
-        return this.size === 0;
-      },
+  /**
+    Suspends multiple listeners during a callback.
 
-      /**
-        @method has
-        @param obj
-        @return {Boolean}
-      */
-      has: function(obj) {
-        if (this.size === 0) { return false; }
+    @method suspendListeners
+    @for Ember
 
-        var guid = guidFor(obj);
-        var presenceSet = this.presenceSet;
+    @private
+    @param obj
+    @param {Array} eventNames Array of event names
+    @param {Object|Function} target A target object or a function
+    @param {Function|String} method A function or the name of a function to be called on `target`
+    @param {Function} callback
+  */
+  function suspendListeners(obj, eventNames, target, method, callback) {
+    if (!method && 'function' === typeof target) {
+      method = target;
+      target = null;
+    }
 
-        return presenceSet[guid] === true;
-      },
+    var suspendedActions = [];
+    var actionsList = [];
+    var eventName, actions, i, l;
 
-      /**
-        @method forEach
-        @param {Function} fn
-        @param self
-      */
-      forEach: function(fn /*, thisArg*/) {
-        if (typeof fn !== 'function') {
-          missingFunction(fn);
-        }
+    for (i=0, l=eventNames.length; i<l; i++) {
+      eventName = eventNames[i];
+      actions = actionsFor(obj, eventName);
+      var actionIndex = indexOf(actions, target, method);
 
-        if (this.size === 0) { return; }
+      if (actionIndex !== -1) {
+        actions[actionIndex+2] |= SUSPENDED;
+        suspendedActions.push(actionIndex);
+        actionsList.push(actions);
+      }
+    }
 
-        var list = this.list;
-        var length = arguments.length;
-        var i;
+    function tryable() { return callback.call(target); }
 
-        if (length === 2) {
-          for (i = 0; i < list.length; i++) {
-            fn.call(arguments[1], list[i]);
-          }
-        } else {
-          for (i = 0; i < list.length; i++) {
-            fn(list[i]);
-          }
-        }
-      },
+    function finalizer() {
+      for (var i = 0, l = suspendedActions.length; i < l; i++) {
+        var actionIndex = suspendedActions[i];
+        actionsList[i][actionIndex+2] &= ~SUSPENDED;
+      }
+    }
 
-      /**
-        @method toArray
-        @return {Array}
-      */
-      toArray: function() {
-        return this.list.slice();
-      },
+    return utils.tryFinally(tryable, finalizer);
+  }
 
-      /**
-        @method copy
-        @return {Ember.OrderedSet}
-      */
-      copy: function() {
-        var Constructor = this.constructor;
-        var set = new Constructor();
+  /**
+    Return a list of currently watched events
 
-        set._silenceRemoveDeprecation = this._silenceRemoveDeprecation;
-        set.presenceSet = copyNull(this.presenceSet);
-        set.list = this.toArray();
-        set.size = this.size;
+    @private
+    @method watchedEvents
+    @for Ember
+    @param obj
+  */
+  function watchedEvents(obj) {
+    var listeners = obj['__ember_meta__'].listeners;
+    var ret = [];
 
-        return set;
+    if (listeners) {
+      for (var eventName in listeners) {
+        if (eventName !== '__source__' &&
+            listeners[eventName]) {
+          ret.push(eventName);
+        }
       }
-    };
-
-    deprecateProperty(OrderedSet.prototype, 'length', 'size');
-
-    /**
-      A Map stores values indexed by keys. Unlike JavaScript's
-      default Objects, the keys of a Map can be any JavaScript
-      object.
+    }
+    return ret;
+  }
 
-      Internally, a Map has two data structures:
+  /**
+    Send an event. The execution of suspended listeners
+    is skipped, and once listeners are removed. A listener without
+    a target is executed on the passed object. If an array of actions
+    is not passed, the actions stored on the passed object are invoked.
+
+    @method sendEvent
+    @for Ember
+    @param obj
+    @param {String} eventName
+    @param {Array} params Optional parameters for each listener.
+    @param {Array} actions Optional array of actions (listeners).
+    @return true
+  */
+  function sendEvent(obj, eventName, params, actions) {
+    // first give object a chance to handle it
+    if (obj !== Ember['default'] && 'function' === typeof obj.sendEvent) {
+      obj.sendEvent(eventName, params);
+    }
+
+    if (!actions) {
+      var meta = obj['__ember_meta__'];
+      actions = meta && meta.listeners && meta.listeners[eventName];
+    }
 
-      1. `keys`: an OrderedSet of all of the existing keys
-      2. `values`: a JavaScript Object indexed by the `Ember.guidFor(key)`
+    if (!actions) { return; }
 
-      When a key/value pair is added for the first time, we
-      add the key to the `keys` OrderedSet, and create or
-      replace an entry in `values`. When an entry is deleted,
-      we delete its entry in `keys` and `values`.
+    for (var i = actions.length - 3; i >= 0; i -= 3) { // looping in reverse for once listeners
+      var target = actions[i];
+      var method = actions[i+1];
+      var flags = actions[i+2];
 
-      @class Map
-      @namespace Ember
-      @private
-      @constructor
-    */
-    function Map() {
-      if (this instanceof this.constructor) {
-        this.keys = OrderedSet.create();
-        this.keys._silenceRemoveDeprecation = true;
-        this.values = create(null);
-        this.size = 0;
+      if (!method) { continue; }
+      if (flags & SUSPENDED) { continue; }
+      if (flags & ONCE) { removeListener(obj, eventName, target, method); }
+      if (!target) { target = obj; }
+      if ('string' === typeof method) {
+        if (params) {
+          utils.applyStr(target, method, params);
+        } else {
+          target[method]();
+        }
       } else {
-        missingNew("OrderedSet");
+        if (params) {
+          utils.apply(target, method, params);
+        } else {
+          method.call(target);
+        }
       }
     }
+    return true;
+  }
 
-    Ember.Map = Map;
-
-    /**
-      @method create
-      @static
-    */
-    Map.create = function() {
-      var Constructor = this;
-      return new Constructor();
-    };
+  /**
+    @private
+    @method hasListeners
+    @for Ember
+    @param obj
+    @param {String} eventName
+  */
+  function hasListeners(obj, eventName) {
+    var meta = obj['__ember_meta__'];
+    var actions = meta && meta.listeners && meta.listeners[eventName];
+
+    return !!(actions && actions.length);
+  }
 
-    Map.prototype = {
-      constructor: Map,
+  /**
+    @private
+    @method listenersFor
+    @for Ember
+    @param obj
+    @param {String} eventName
+  */
+  function listenersFor(obj, eventName) {
+    var ret = [];
+    var meta = obj['__ember_meta__'];
+    var actions = meta && meta.listeners && meta.listeners[eventName];
 
-      /**
-        This property will change as the number of objects in the map changes.
+    if (!actions) { return ret; }
 
-        @since 1.8.0
-        @property size
-        @type number
-        @default 0
-      */
-      size: 0,
+    for (var i = 0, l = actions.length; i < l; i += 3) {
+      var target = actions[i];
+      var method = actions[i+1];
+      ret.push([target, method]);
+    }
 
-      /**
-        Retrieve the value associated with a given key.
+    return ret;
+  }
 
-        @method get
-        @param {*} key
-        @return {*} the value associated with the key, or `undefined`
-      */
-      get: function(key) {
-        if (this.size === 0) { return; }
+  /**
+    Define a property as a function that should be executed when
+    a specified event or events are triggered.
 
-        var values = this.values;
-        var guid = guidFor(key);
 
-        return values[guid];
-      },
+    ``` javascript
+    var Job = Ember.Object.extend({
+      logCompleted: Ember.on('completed', function() {
+        console.log('Job completed!');
+      })
+    });
 
-      /**
-        Adds a value to the map. If a value for the given key has already been
-        provided, the new value will replace the old value.
+    var job = Job.create();
+
+    Ember.sendEvent(job, 'completed'); // Logs 'Job completed!'
+   ```
+
+    @method on
+    @for Ember
+    @param {String} eventNames*
+    @param {Function} func
+    @return func
+  */
+  function on() {
+    var func = a_slice.call(arguments, -1)[0];
+    var events = a_slice.call(arguments, 0, -1);
+    func.__ember_listens__ = events;
+    return func;
+  }
 
-        @method set
-        @param {*} key
-        @param {*} value
-        @return {Ember.Map}
-      */
-      set: function(key, value) {
-        var keys = this.keys;
-        var values = this.values;
-        var guid = guidFor(key);
+});
+enifed('ember-metal/expand_properties', ['exports', 'ember-metal/error', 'ember-metal/enumerable_utils', 'ember-metal/utils'], function (exports, EmberError, enumerable_utils, utils) {
 
-        // ensure we don't store -0
-        var k = key === -0 ? 0 : key;
+  'use strict';
 
-        keys.add(k, guid);
+  var SPLIT_REGEX = /\{|\}/;
 
-        values[guid] = value;
+  /**
+    Expands `pattern`, invoking `callback` for each expansion.
 
-        this.size = keys.size;
+    The only pattern supported is brace-expansion, anything else will be passed
+    once to `callback` directly.
 
-        return this;
-      },
+    Example
 
-      /**
-        @deprecated see delete
-        Removes a value from the map for an associated key.
+    ```js
+    function echo(arg){ console.log(arg); }
 
-        @method remove
-        @param {*} key
-        @return {Boolean} true if an item was removed, false otherwise
-      */
-      remove: function(key) {
-        Ember.deprecate('Calling `Map.prototype.remove` has been deprecated, please use `Map.prototype.delete` instead.');
+    Ember.expandProperties('foo.bar', echo);              //=> 'foo.bar'
+    Ember.expandProperties('{foo,bar}', echo);            //=> 'foo', 'bar'
+    Ember.expandProperties('foo.{bar,baz}', echo);        //=> 'foo.bar', 'foo.baz'
+    Ember.expandProperties('{foo,bar}.baz', echo);        //=> '{foo,bar}.baz'
+    Ember.expandProperties('foo.{bar,baz}.@each', echo)   //=> 'foo.bar.@each', 'foo.baz.@each'
+    Ember.expandProperties('{foo,bar}.{spam,eggs}', echo) //=> 'foo.spam', 'foo.eggs', 'bar.spam', 'bar.eggs'
+    Ember.expandProperties('{foo}.bar.{baz}')             //=> 'foo.bar.baz'
+    ```
 
-        return this["delete"](key);
-      },
+    @method
+    @private
+    @param {String} pattern The property pattern to expand.
+    @param {Function} callback The callback to invoke.  It is invoked once per
+    expansion, and is passed the expansion.
+    */
+  function expandProperties(pattern, callback) {
+    if (pattern.indexOf(' ') > -1) {
+      throw new EmberError['default']('Brace expanded properties cannot contain spaces, ' +
+        'e.g. `user.{firstName, lastName}` should be `user.{firstName,lastName}`');
+    }
 
-      /**
-        Removes a value from the map for an associated key.
+    if ('string' === utils.typeOf(pattern)) {
+      var parts = pattern.split(SPLIT_REGEX);
+      var properties = [parts];
 
-        @since 1.8.0
-        @method delete
-        @param {*} key
-        @return {Boolean} true if an item was removed, false otherwise
-      */
-      "delete": function(key) {
-        if (this.size === 0) { return false; }
-        // don't use ES6 "delete" because it will be annoying
-        // to use in browsers that are not ES6 friendly;
-        var keys = this.keys;
-        var values = this.values;
-        var guid = guidFor(key);
-
-        if (keys["delete"](key, guid)) {
-          delete values[guid];
-          this.size = keys.size;
-          return true;
-        } else {
-          return false;
+      enumerable_utils.forEach(parts, function(part, index) {
+        if (part.indexOf(',') >= 0) {
+          properties = duplicateAndReplace(properties, part.split(','), index);
         }
-      },
+      });
 
-      /**
-        Check whether a key is present.
+      enumerable_utils.forEach(properties, function(property) {
+        callback(property.join(''));
+      });
+    } else {
+      callback(pattern);
+    }
+  }
+  exports['default'] = expandProperties;
 
-        @method has
-        @param {*} key
-        @return {Boolean} true if the item was present, false otherwise
-      */
-      has: function(key) {
-        return this.keys.has(key);
-      },
+  function duplicateAndReplace(properties, currentParts, index) {
+    var all = [];
 
-      /**
-        Iterate over all the keys and values. Calls the function once
-        for each key, passing in value, key, and the map being iterated over,
-        in that order.
+    enumerable_utils.forEach(properties, function(property) {
+      enumerable_utils.forEach(currentParts, function(part) {
+        var current = property.slice(0);
+        current[index] = part;
+        all.push(current);
+      });
+    });
 
-        The keys are guaranteed to be iterated over in insertion order.
+    return all;
+  }
 
-        @method forEach
-        @param {Function} callback
-        @param {*} self if passed, the `this` value inside the
-          callback. By default, `this` is the map.
-      */
-      forEach: function(callback /*, thisArg*/) {
-        if (typeof callback !== 'function') {
-          missingFunction(callback);
-        }
+});
+enifed('ember-metal/get_properties', ['exports', 'ember-metal/property_get', 'ember-metal/utils'], function (exports, property_get, utils) {
 
-        if (this.size === 0) { return; }
+  'use strict';
 
-        var length = arguments.length;
-        var map = this;
-        var cb, thisArg;
+  function getProperties(obj) {
+    var ret = {};
+    var propertyNames = arguments;
+    var i = 1;
 
-        if (length === 2) {
-          thisArg = arguments[1];
-          cb = function(key) {
-            callback.call(thisArg, map.get(key), key, map);
-          };
-        } else {
-          cb = function(key) {
-            callback(map.get(key), key, map);
-          };
-        }
+    if (arguments.length === 2 && utils.typeOf(arguments[1]) === 'array') {
+      i = 0;
+      propertyNames = arguments[1];
+    }
+    for (var len = propertyNames.length; i < len; i++) {
+      ret[propertyNames[i]] = property_get.get(obj, propertyNames[i]);
+    }
+    return ret;
+  }
+  exports['default'] = getProperties;
 
-        this.keys.forEach(cb);
-      },
+});
+enifed('ember-metal/injected_property', ['exports', 'ember-metal/core', 'ember-metal/computed', 'ember-metal/alias', 'ember-metal/properties', 'ember-metal/platform/create'], function (exports, Ember, computed, alias, properties, create) {
 
-      /**
-        @method clear
-      */
-      clear: function() {
-        this.keys.clear();
-        this.values = create(null);
-        this.size = 0;
-      },
+  'use strict';
 
-      /**
-        @method copy
-        @return {Ember.Map}
-      */
-      copy: function() {
-        return copyMap(this, new Map());
-      }
-    };
+  function InjectedProperty(type, name) {
+    this.type = type;
+    this.name = name;
 
-    deprecateProperty(Map.prototype, 'length', 'size');
+    this._super$Constructor(injectedPropertyGet);
+    AliasedPropertyPrototype.oneWay.call(this);
+  }
 
-    /**
-      @class MapWithDefault
-      @namespace Ember
-      @extends Ember.Map
-      @private
-      @constructor
-      @param [options]
-        @param {*} [options.defaultValue]
-    */
-    function MapWithDefault(options) {
-      this._super$constructor();
-      this.defaultValue = options.defaultValue;
-    }
+  function injectedPropertyGet(keyName) {
+    var possibleDesc = this[keyName];
+    var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
 
-    /**
-      @method create
-      @static
-      @param [options]
-        @param {*} [options.defaultValue]
-      @return {Ember.MapWithDefault|Ember.Map} If options are passed, returns
-        `Ember.MapWithDefault` otherwise returns `Ember.Map`
-    */
-    MapWithDefault.create = function(options) {
-      if (options) {
-        return new MapWithDefault(options);
-      } else {
-        return new Map();
-      }
-    };
+    Ember['default'].assert("Attempting to lookup an injected property on an object " +
+                 "without a container, ensure that the object was " +
+                 "instantiated via a container.", this.container);
 
-    MapWithDefault.prototype = create(Map.prototype);
-    MapWithDefault.prototype.constructor = MapWithDefault;
-    MapWithDefault.prototype._super$constructor = Map;
-    MapWithDefault.prototype._super$get = Map.prototype.get;
+    return this.container.lookup(desc.type + ':' + (desc.name || keyName));
+  }
 
-    /**
-      Retrieve the value associated with a given key.
+  InjectedProperty.prototype = create['default'](properties.Descriptor.prototype);
 
-      @method get
-      @param {*} key
-      @return {*} the value associated with the key, or the default value
-    */
-    MapWithDefault.prototype.get = function(key) {
-      var hasValue = this.has(key);
+  var InjectedPropertyPrototype = InjectedProperty.prototype;
+  var ComputedPropertyPrototype = computed.ComputedProperty.prototype;
+  var AliasedPropertyPrototype = alias.AliasedProperty.prototype;
 
-      if (hasValue) {
-        return this._super$get(key);
-      } else {
-        var defaultValue = this.defaultValue(key);
-        this.set(key, defaultValue);
-        return defaultValue;
-      }
-    };
+  InjectedPropertyPrototype._super$Constructor = computed.ComputedProperty;
 
-    /**
-      @method copy
-      @return {Ember.MapWithDefault}
-    */
-    MapWithDefault.prototype.copy = function() {
-      var Constructor = this.constructor;
-      return copyMap(this, new Constructor({
-        defaultValue: this.defaultValue
-      }));
-    };
+  InjectedPropertyPrototype.get = ComputedPropertyPrototype.get;
+  InjectedPropertyPrototype.readOnly = ComputedPropertyPrototype.readOnly;
 
-    __exports__["default"] = Map;
+  InjectedPropertyPrototype.teardown = ComputedPropertyPrototype.teardown;
 
-    __exports__.OrderedSet = OrderedSet;
-    __exports__.Map = Map;
-    __exports__.MapWithDefault = MapWithDefault;
-  });
-enifed("ember-metal/merge",
-  ["ember-metal/keys","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var keys = __dependency1__["default"];
+  exports['default'] = InjectedProperty;
 
-    /**
-      Merge the contents of two objects together into the first object.
+});
+enifed('ember-metal/instrumentation', ['exports', 'ember-metal/core', 'ember-metal/utils'], function (exports, Ember, utils) {
 
-      ```javascript
-      Ember.merge({first: 'Tom'}, {last: 'Dale'}); // {first: 'Tom', last: 'Dale'}
-      var a = {first: 'Yehuda'}, b = {last: 'Katz'};
-      Ember.merge(a, b); // a == {first: 'Yehuda', last: 'Katz'}, b == {last: 'Katz'}
-      ```
+  'use strict';
 
-      @method merge
-      @for Ember
-      @param {Object} original The object to merge into
-      @param {Object} updates The object to copy properties from
-      @return {Object}
-    */
-    __exports__["default"] = function merge(original, updates) {
-      if (!updates || typeof updates !== 'object') { 
-        return original;
-      }
+  exports.instrument = instrument;
+  exports._instrumentStart = _instrumentStart;
+  exports.subscribe = subscribe;
+  exports.unsubscribe = unsubscribe;
+  exports.reset = reset;
 
-      var props = keys(updates);
-      var prop;
-      var length = props.length;
+  var subscribers = [];
+  var cache = {};
 
-      for (var i = 0; i < length; i++) {
-        prop = props[i];
-        original[prop] = updates[prop];
+  var populateListeners = function(name) {
+    var listeners = [];
+    var subscriber;
+
+    for (var i=0, l=subscribers.length; i<l; i++) {
+      subscriber = subscribers[i];
+      if (subscriber.regex.test(name)) {
+        listeners.push(subscriber.object);
       }
+    }
 
-      return original;
+    cache[name] = listeners;
+    return listeners;
+  };
+
+  var time = (function() {
+    var perf = 'undefined' !== typeof window ? window.performance || {} : {};
+    var fn = perf.now || perf.mozNow || perf.webkitNow || perf.msNow || perf.oNow;
+    // fn.bind will be available in all the browsers that support the advanced window.performance... ;-)
+    return fn ? fn.bind(perf) : function() { return +new Date(); };
+  })();
+
+  /**
+    Notifies event's subscribers, calls `before` and `after` hooks.
+
+    @method instrument
+    @namespace Ember.Instrumentation
+
+    @param {String} [name] Namespaced event name.
+    @param {Object} payload
+    @param {Function} callback Function that you're instrumenting.
+    @param {Object} binding Context that instrument function is called with.
+  */
+  function instrument(name, _payload, callback, binding) {
+    if (arguments.length <= 3 && typeof _payload === 'function') {
+      binding = callback;
+      callback = _payload;
+      _payload = undefined;
     }
-  });
-enifed("ember-metal/mixin",
-  ["ember-metal/core","ember-metal/merge","ember-metal/array","ember-metal/platform","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/expand_properties","ember-metal/properties","ember-metal/computed","ember-metal/binding","ember-metal/observer","ember-metal/events","ember-metal/streams/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __exports__) {
-        // Remove "use strict"; from transpiled module until
-    // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
-    //
-    // REMOVE_USE_STRICT: true
+    if (subscribers.length === 0) {
+      return callback.call(binding);
+    }
+    var payload = _payload || {};
+    var finalizer = _instrumentStart(name, function () {
+      return payload;
+    });
+    if (finalizer) {
+      var tryable = function _instrumenTryable() {
+        return callback.call(binding);
+      };
+      var catchable = function _instrumentCatchable(e) {
+        payload.exception = e;
+      };
+      return utils.tryCatchFinally(tryable, catchable, finalizer);
+    } else {
+      return callback.call(binding);
+    }
+  }
 
-    /**
-    @module ember
-    @submodule ember-metal
-    */
-
-    var Ember = __dependency1__["default"];
-    // warn, assert, wrap, et;
-    var merge = __dependency2__["default"];
-    var a_indexOf = __dependency3__.indexOf;
-    var a_forEach = __dependency3__.forEach;
-    var o_create = __dependency4__.create;
-    var get = __dependency5__.get;
-    var set = __dependency6__.set;
-    var trySet = __dependency6__.trySet;
-    var guidFor = __dependency7__.guidFor;
-    var metaFor = __dependency7__.meta;
-    var wrap = __dependency7__.wrap;
-    var makeArray = __dependency7__.makeArray;
-    var isArray = __dependency7__.isArray;
-    var expandProperties = __dependency8__["default"];
-    var Descriptor = __dependency9__.Descriptor;
-    var defineProperty = __dependency9__.defineProperty;
-    var ComputedProperty = __dependency10__.ComputedProperty;
-    var Binding = __dependency11__.Binding;
-    var addObserver = __dependency12__.addObserver;
-    var removeObserver = __dependency12__.removeObserver;
-    var addBeforeObserver = __dependency12__.addBeforeObserver;
-    var removeBeforeObserver = __dependency12__.removeBeforeObserver;
-    var _suspendObserver = __dependency12__._suspendObserver;
-    var addListener = __dependency13__.addListener;
-    var removeListener = __dependency13__.removeListener;
-    var isStream = __dependency14__.isStream;
-
-    var REQUIRED;
-    var a_slice = [].slice;
-
-    function superFunction(){
-      var func = this.__nextSuper;
-      var ret;
+  // private for now
+  function _instrumentStart(name, _payload) {
+    var listeners = cache[name];
 
-      if (func) {
-        var length = arguments.length;
-        this.__nextSuper = null;
-        if (length === 0) {
-          ret = func.call(this);
-        } else if (length === 1) {
-          ret = func.call(this, arguments[0]);
-        } else if (length === 2) {
-          ret = func.call(this, arguments[0], arguments[1]);
-        } else {
-          ret = func.apply(this, arguments);
-        }
-        this.__nextSuper = func;
-        return ret;
-      }
+    if (!listeners) {
+      listeners = populateListeners(name);
     }
 
-    // ensure we prime superFunction to mitigate
-    // v8 bug potentially incorrectly deopts this function: https://code.google.com/p/v8/issues/detail?id=3709
-    var primer = {
-      __nextSuper: function(a,b,c,d ) { }
-    };
+    if (listeners.length === 0) {
+      return;
+    }
 
-    superFunction.call(primer);
-    superFunction.call(primer, 1);
-    superFunction.call(primer, 1, 2);
-    superFunction.call(primer, 1, 2, 3);
+    var payload = _payload();
 
-    function mixinsMeta(obj) {
-      var m = metaFor(obj, true);
-      var ret = m.mixins;
-      if (!ret) {
-        ret = m.mixins = {};
-      } else if (!m.hasOwnProperty('mixins')) {
-        ret = m.mixins = o_create(ret);
-      }
-      return ret;
+    var STRUCTURED_PROFILE = Ember['default'].STRUCTURED_PROFILE;
+    var timeName;
+    if (STRUCTURED_PROFILE) {
+      timeName = name + ": " + payload.object;
+      console.time(timeName);
     }
 
-    function isMethod(obj) {
-      return 'function' === typeof obj &&
-             obj.isMethod !== false &&
-             obj !== Boolean &&
-             obj !== Object &&
-             obj !== Number &&
-             obj !== Array &&
-             obj !== Date &&
-             obj !== String;
+    var l = listeners.length;
+    var beforeValues = new Array(l);
+    var i, listener;
+    var timestamp = time();
+    for (i=0; i<l; i++) {
+      listener = listeners[i];
+      beforeValues[i] = listener.before(name, timestamp, payload);
     }
 
-    var CONTINUE = {};
+    return function _instrumentEnd() {
+      var i, l, listener;
+      var timestamp = time();
+      for (i=0, l=listeners.length; i<l; i++) {
+        listener = listeners[i];
+        listener.after(name, timestamp, payload, beforeValues[i]);
+      }
+
+      if (STRUCTURED_PROFILE) {
+        console.timeEnd(timeName);
+      }
+    };
+  }
+
+  /**
+    Subscribes to a particular event or instrumented block of code.
 
-    function mixinProperties(mixinsMeta, mixin) {
-      var guid;
+    @method subscribe
+    @namespace Ember.Instrumentation
 
-      if (mixin instanceof Mixin) {
-        guid = guidFor(mixin);
-        if (mixinsMeta[guid]) { return CONTINUE; }
-        mixinsMeta[guid] = mixin;
-        return mixin.properties;
+    @param {String} [pattern] Namespaced event name.
+    @param {Object} [object] Before and After hooks.
+
+    @return {Subscriber}
+  */
+  function subscribe(pattern, object) {
+    var paths = pattern.split(".");
+    var path;
+    var regex = [];
+
+    for (var i=0, l=paths.length; i<l; i++) {
+      path = paths[i];
+      if (path === "*") {
+        regex.push("[^\\.]*");
       } else {
-        return mixin; // apply anonymous mixin properties
+        regex.push(path);
       }
     }
 
-    function concatenatedMixinProperties(concatProp, props, values, base) {
-      var concats;
+    regex = regex.join("\\.");
+    regex = regex + "(\\..*)?";
 
-      // reset before adding each new mixin to pickup concats from previous
-      concats = values[concatProp] || base[concatProp];
-      if (props[concatProp]) {
-        concats = concats ? concats.concat(props[concatProp]) : props[concatProp];
-      }
+    var subscriber = {
+      pattern: pattern,
+      regex: new RegExp("^" + regex + "$"),
+      object: object
+    };
 
-      return concats;
-    }
+    subscribers.push(subscriber);
+    cache = {};
+
+    return subscriber;
+  }
 
-    function giveDescriptorSuper(meta, key, property, values, descs) {
-      var superProperty;
+  /**
+    Unsubscribes from a particular event or instrumented block of code.
 
-      // Computed properties override methods, and do not call super to them
-      if (values[key] === undefined) {
-        // Find the original descriptor in a parent mixin
-        superProperty = descs[key];
-      }
+    @method unsubscribe
+    @namespace Ember.Instrumentation
 
-      // If we didn't find the original descriptor in a parent mixin, find
-      // it on the original object.
-      superProperty = superProperty || meta.descs[key];
+    @param {Object} [subscriber]
+  */
+  function unsubscribe(subscriber) {
+    var index;
 
-      if (superProperty === undefined || !(superProperty instanceof ComputedProperty)) {
-        return property;
+    for (var i=0, l=subscribers.length; i<l; i++) {
+      if (subscribers[i] === subscriber) {
+        index = i;
       }
+    }
 
-      // Since multiple mixins may inherit from the same parent, we need
-      // to clone the computed property so that other mixins do not receive
-      // the wrapped version.
-      property = o_create(property);
-      property.func = wrap(property.func, superProperty.func);
+    subscribers.splice(index, 1);
+    cache = {};
+  }
 
-      return property;
-    }
+  /**
+    Resets `Ember.Instrumentation` by flushing list of subscribers.
 
-    var sourceAvailable = (function() {
-      return this;
-    }).toString().indexOf('return this;') > -1;
+    @method reset
+    @namespace Ember.Instrumentation
+  */
+  function reset() {
+    subscribers.length = 0;
+    cache = {};
+  }
 
-    function giveMethodSuper(obj, key, method, values, descs) {
-      var superMethod;
+  exports.subscribers = subscribers;
 
-      // Methods overwrite computed properties, and do not call super to them.
-      if (descs[key] === undefined) {
-        // Find the original method in a parent mixin
-        superMethod = values[key];
-      }
+});
+enifed('ember-metal/is_blank', ['exports', 'ember-metal/is_empty'], function (exports, isEmpty) {
 
-      // If we didn't find the original value in a parent mixin, find it in
-      // the original object
-      superMethod = superMethod || obj[key];
+  'use strict';
 
-      // Only wrap the new method if the original method was a function
-      if (superMethod === undefined || 'function' !== typeof superMethod) {
-        return method;
-      }
+  function isBlank(obj) {
+    return isEmpty['default'](obj) || (typeof obj === 'string' && obj.match(/\S/) === null);
+  }
+  exports['default'] = isBlank;
 
-      var hasSuper;
-      if (sourceAvailable) {
-        hasSuper = method.__hasSuper;
+});
+enifed('ember-metal/is_empty', ['exports', 'ember-metal/property_get', 'ember-metal/is_none'], function (exports, property_get, isNone) {
 
-        if (hasSuper === undefined) {
-          hasSuper = method.toString().indexOf('_super') > -1;
-          method.__hasSuper = hasSuper;
-        }
-      }
+  'use strict';
 
-      if (sourceAvailable === false || hasSuper) {
-        return wrap(method, superMethod);
-      } else {
-        return method;
+  function isEmpty(obj) {
+    var none = isNone['default'](obj);
+    if (none) {
+      return none;
+    }
+
+    if (typeof obj.size === 'number') {
+      return !obj.size;
+    }
+
+    var objectType = typeof obj;
+
+    if (objectType === 'object') {
+      var size = property_get.get(obj, 'size');
+      if (typeof size === 'number') {
+        return !size;
       }
     }
 
-    function applyConcatenatedProperties(obj, key, value, values) {
-      var baseValue = values[key] || obj[key];
+    if (typeof obj.length === 'number' && objectType !== 'function') {
+      return !obj.length;
+    }
 
-      if (baseValue) {
-        if ('function' === typeof baseValue.concat) {
-          if (value === null || value === undefined) {
-            return baseValue;
-          } else {
-            return baseValue.concat(value);
-          }
-        } else {
-          return makeArray(baseValue).concat(value);
-        }
-      } else {
-        return makeArray(value);
+    if (objectType === 'object') {
+      var length = property_get.get(obj, 'length');
+      if (typeof length === 'number') {
+        return !length;
       }
     }
 
-    function applyMergedProperties(obj, key, value, values) {
-      var baseValue = values[key] || obj[key];
+    return false;
+  }
+
+  exports['default'] = isEmpty;
 
-      Ember.assert("You passed in `" + JSON.stringify(value) + "` as the value for `" + key +
-                   "` but `" + key + "` cannot be an Array", !isArray(value));
+});
+enifed('ember-metal/is_none', ['exports'], function (exports) {
 
-      if (!baseValue) { return value; }
+  'use strict';
 
-      var newBase = merge({}, baseValue);
-      var hasFunction = false;
+  /**
+    Returns true if the passed value is null or undefined. This avoids errors
+    from JSLint complaining about use of ==, which can be technically
+    confusing.
 
-      for (var prop in value) {
-        if (!value.hasOwnProperty(prop)) { continue; }
+    ```javascript
+    Ember.isNone();              // true
+    Ember.isNone(null);          // true
+    Ember.isNone(undefined);     // true
+    Ember.isNone('');            // false
+    Ember.isNone([]);            // false
+    Ember.isNone(function() {});  // false
+    ```
 
-        var propValue = value[prop];
-        if (isMethod(propValue)) {
-          // TODO: support for Computed Properties, etc?
-          hasFunction = true;
-          newBase[prop] = giveMethodSuper(obj, prop, propValue, baseValue, {});
-        } else {
-          newBase[prop] = propValue;
-        }
-      }
+    @method isNone
+    @for Ember
+    @param {Object} obj Value to test
+    @return {Boolean}
+  */
+  function isNone(obj) {
+    return obj === null || obj === undefined;
+  }
 
-      if (hasFunction) {
-        newBase._super = superFunction;
-      }
+  exports['default'] = isNone;
 
-      return newBase;
-    }
+});
+enifed('ember-metal/is_present', ['exports', 'ember-metal/is_blank'], function (exports, isBlank) {
+
+  'use strict';
 
-    function addNormalizedProperty(base, key, value, meta, descs, values, concats, mergings) {
-      if (value instanceof Descriptor) {
-        if (value === REQUIRED && descs[key]) { return CONTINUE; }
+  function isPresent(obj) {
+    return !isBlank['default'](obj);
+  }
+  exports['default'] = isPresent;
+
+});
+enifed('ember-metal/keys', ['exports', 'ember-metal/platform/define_property'], function (exports, define_property) {
+
+  'use strict';
+
+  var keys = Object.keys;
+
+  if (!keys || !define_property.canDefineNonEnumerableProperties) {
+    // modified from
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys
+    keys = (function () {
+      var hasOwnProperty = Object.prototype.hasOwnProperty;
+      var hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString');
+      var dontEnums = [
+        'toString',
+        'toLocaleString',
+        'valueOf',
+        'hasOwnProperty',
+        'isPrototypeOf',
+        'propertyIsEnumerable',
+        'constructor'
+      ];
+      var dontEnumsLength = dontEnums.length;
 
-        // Wrap descriptor function to implement
-        // __nextSuper() if needed
-        if (value.func) {
-          value = giveDescriptorSuper(meta, key, value, values, descs);
+      return function keys(obj) {
+        if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {
+          throw new TypeError('Object.keys called on non-object');
         }
 
-        descs[key]  = value;
-        values[key] = undefined;
-      } else {
-        if ((concats && a_indexOf.call(concats, key) >= 0) ||
-                    key === 'concatenatedProperties' ||
-                    key === 'mergedProperties') {
-          value = applyConcatenatedProperties(base, key, value, values);
-        } else if ((mergings && a_indexOf.call(mergings, key) >= 0)) {
-          value = applyMergedProperties(base, key, value, values);
-        } else if (isMethod(value)) {
-          value = giveMethodSuper(base, key, value, values, descs);
+        var result = [];
+        var prop, i;
+
+        for (prop in obj) {
+          if (prop !== '_super' &&
+            prop.lastIndexOf('__', 0) !== 0 &&
+            hasOwnProperty.call(obj, prop)) {
+            result.push(prop);
+          }
         }
 
-        descs[key] = undefined;
-        values[key] = value;
-      }
-    }
+        if (hasDontEnumBug) {
+          for (i = 0; i < dontEnumsLength; i++) {
+            if (hasOwnProperty.call(obj, dontEnums[i])) {
+              result.push(dontEnums[i]);
+            }
+          }
+        }
+        return result;
+      };
+    }());
+  }
 
-    function mergeMixins(mixins, m, descs, values, base, keys) {
-      var mixin, props, key, concats, mergings, meta;
+  exports['default'] = keys;
 
-      function removeKeys(keyName) {
-        delete descs[keyName];
-        delete values[keyName];
-      }
+});
+enifed('ember-metal/libraries', ['exports', 'ember-metal/core', 'ember-metal/enumerable_utils'], function (exports, Ember, enumerable_utils) {
 
-      for(var i=0, l=mixins.length; i<l; i++) {
-        mixin = mixins[i];
-        Ember.assert('Expected hash or Mixin instance, got ' + Object.prototype.toString.call(mixin),
-                     typeof mixin === 'object' && mixin !== null && Object.prototype.toString.call(mixin) !== '[object Array]');
+  'use strict';
 
-        props = mixinProperties(m, mixin);
-        if (props === CONTINUE) { continue; }
+  function Libraries() {
+    this._registry = [];
+    this._coreLibIndex = 0;
+  }
 
-        if (props) {
-          meta = metaFor(base);
-          if (base.willMergeMixin) { base.willMergeMixin(props); }
-          concats = concatenatedMixinProperties('concatenatedProperties', props, values, base);
-          mergings = concatenatedMixinProperties('mergedProperties', props, values, base);
+  Libraries.prototype = {
+    constructor: Libraries,
 
-          for (key in props) {
-            if (!props.hasOwnProperty(key)) { continue; }
-            keys.push(key);
-            addNormalizedProperty(base, key, props[key], meta, descs, values, concats, mergings);
-          }
+    _getLibraryByName: function(name) {
+      var libs = this._registry;
+      var count = libs.length;
 
-          // manually copy toString() because some JS engines do not enumerate it
-          if (props.hasOwnProperty('toString')) { base.toString = props.toString; }
-        } else if (mixin.mixins) {
-          mergeMixins(mixin.mixins, m, descs, values, base, keys);
-          if (mixin._without) { a_forEach.call(mixin._without, removeKeys); }
+      for (var i = 0; i < count; i++) {
+        if (libs[i].name === name) {
+          return libs[i];
         }
       }
-    }
+    },
 
-    var IS_BINDING = /^.+Binding$/;
+    register: function(name, version, isCoreLibrary) {
+      var index = this._registry.length;
 
-    function detectBinding(obj, key, value, m) {
-      if (IS_BINDING.test(key)) {
-        var bindings = m.bindings;
-        if (!bindings) {
-          bindings = m.bindings = {};
-        } else if (!m.hasOwnProperty('bindings')) {
-          bindings = m.bindings = o_create(m.bindings);
+      if (!this._getLibraryByName(name)) {
+        if (isCoreLibrary) {
+          index = this._coreLibIndex++;
         }
-        bindings[key] = value;
+        this._registry.splice(index, 0, { name: name, version: version });
+      } else {
+        Ember['default'].warn('Library "' + name + '" is already registered with Ember.');
       }
-    }
+    },
 
-    function connectStreamBinding(obj, key, stream) {
-      var onNotify = function(stream) {
-        _suspendObserver(obj, key, null, didChange, function() {
-          trySet(obj, key, stream.value());
-        });
-      };
+    registerCoreLibrary: function(name, version) {
+      this.register(name, version, true);
+    },
 
-      var didChange = function() {
-        stream.setValue(get(obj, key), onNotify);
-      };
+    deRegister: function(name) {
+      var lib = this._getLibraryByName(name);
+      var index;
 
-      // Initialize value
-      set(obj, key, stream.value());
+      if (lib) {
+        index = enumerable_utils.indexOf(this._registry, lib);
+        this._registry.splice(index, 1);
+      }
+    },
 
-      addObserver(obj, key, null, didChange);
+    each: function(callback) {
+      Ember['default'].deprecate('Using Ember.libraries.each() is deprecated. Access to a list of registered libraries is currently a private API. If you are not knowingly accessing this method, your out-of-date Ember Inspector may be doing so.');
+      enumerable_utils.forEach(this._registry, function(lib) {
+        callback(lib.name, lib.version);
+      });
+    }
+  };
 
-      stream.subscribe(onNotify);
+  exports['default'] = Libraries;
 
-      if (obj._streamBindingSubscriptions === undefined) {
-        obj._streamBindingSubscriptions = o_create(null);
-      }
+});
+enifed('ember-metal/logger', ['exports', 'ember-metal/core', 'ember-metal/error'], function (exports, Ember, EmberError) {
 
-      obj._streamBindingSubscriptions[key] = onNotify;
-    }
+  'use strict';
 
-    function connectBindings(obj, m) {
-      // TODO Mixin.apply(instance) should disconnect binding if exists
-      var bindings = m.bindings;
-      var key, binding, to;
-      if (bindings) {
-        for (key in bindings) {
-          binding = bindings[key];
-          if (binding) {
-            to = key.slice(0, -7); // strip Binding off end
-            if (isStream(binding)) {
-              connectStreamBinding(obj, to, binding);
-              continue;
-            } else if (binding instanceof Binding) {
-              binding = binding.copy(); // copy prototypes' instance
-              binding.to(to);
-            } else { // binding is string path
-              binding = new Binding(to, binding);
-            }
-            binding.connect(obj);
-            obj[key] = binding;
-          }
-        }
-        // mark as applied
-        m.bindings = {};
-      }
-    }
+  function K() { return this; }
 
-    function finishPartial(obj, m) {
-      connectBindings(obj, m || metaFor(obj));
-      return obj;
+  function consoleMethod(name) {
+    var consoleObj, logToConsole;
+    if (Ember['default'].imports.console) {
+      consoleObj = Ember['default'].imports.console;
+    } else if (typeof console !== 'undefined') {
+      consoleObj = console;
     }
 
-    function followAlias(obj, desc, m, descs, values) {
-      var altKey = desc.methodName;
-      var value;
-      if (descs[altKey] || values[altKey]) {
-        value = values[altKey];
-        desc  = descs[altKey];
-      } else if (m.descs[altKey]) {
-        desc  = m.descs[altKey];
-        value = undefined;
+    var method = typeof consoleObj === 'object' ? consoleObj[name] : null;
+
+    if (method) {
+      // Older IE doesn't support bind, but Chrome needs it
+      if (typeof method.bind === 'function') {
+        logToConsole = method.bind(consoleObj);
+        logToConsole.displayName = 'console.' + name;
+        return logToConsole;
+      } else if (typeof method.apply === 'function') {
+        logToConsole = function() {
+          method.apply(consoleObj, arguments);
+        };
+        logToConsole.displayName = 'console.' + name;
+        return logToConsole;
       } else {
-        desc = undefined;
-        value = obj[altKey];
+        return function() {
+          var message = Array.prototype.join.call(arguments, ', ');
+          method(message);
+        };
       }
-
-      return { desc: desc, value: value };
     }
+  }
 
-    function updateObserversAndListeners(obj, key, observerOrListener, pathsKey, updateMethod) {
-      var paths = observerOrListener[pathsKey];
-
-      if (paths) {
-        for (var i=0, l=paths.length; i<l; i++) {
-          updateMethod(obj, paths[i], null, key);
-        }
+  function assertPolyfill(test, message) {
+    if (!test) {
+      try {
+        // attempt to preserve the stack
+        throw new EmberError['default']("assertion failed: " + message);
+      } catch(error) {
+        setTimeout(function() {
+          throw error;
+        }, 0);
       }
     }
+  }
+
+  /**
+    Inside Ember-Metal, simply uses the methods from `imports.console`.
+    Override this to provide more robust logging functionality.
+
+    @class Logger
+    @namespace Ember
+  */
+  exports['default'] = {
+    /**
+     Logs the arguments to the console.
+     You can pass as many arguments as you want and they will be joined together with a space.
 
-    function replaceObserversAndListeners(obj, key, observerOrListener) {
-      var prev = obj[key];
+      ```javascript
+      var foo = 1;
+      Ember.Logger.log('log value of foo:', foo);
+      // "log value of foo: 1" will be printed to the console
+      ```
 
-      if ('function' === typeof prev) {
-        updateObserversAndListeners(obj, key, prev, '__ember_observesBefore__', removeBeforeObserver);
-        updateObserversAndListeners(obj, key, prev, '__ember_observes__', removeObserver);
-        updateObserversAndListeners(obj, key, prev, '__ember_listens__', removeListener);
-      }
+     @method log
+     @for Ember.Logger
+     @param {*} arguments
+    */
+    log:   consoleMethod('log')   || K,
 
-      if ('function' === typeof observerOrListener) {
-        updateObserversAndListeners(obj, key, observerOrListener, '__ember_observesBefore__', addBeforeObserver);
-        updateObserversAndListeners(obj, key, observerOrListener, '__ember_observes__', addObserver);
-        updateObserversAndListeners(obj, key, observerOrListener, '__ember_listens__', addListener);
-      }
-    }
+    /**
+     Prints the arguments to the console with a warning icon.
+     You can pass as many arguments as you want and they will be joined together with a space.
 
-    function applyMixin(obj, mixins, partial) {
-      var descs = {};
-      var values = {};
-      var m = metaFor(obj);
-      var keys = [];
-      var key, value, desc;
+      ```javascript
+      Ember.Logger.warn('Something happened!');
+      // "Something happened!" will be printed to the console with a warning icon.
+      ```
 
-      obj._super = superFunction;
+     @method warn
+     @for Ember.Logger
+     @param {*} arguments
+    */
+    warn:  consoleMethod('warn')  || K,
 
-      // Go through all mixins and hashes passed in, and:
-      //
-      // * Handle concatenated properties
-      // * Handle merged properties
-      // * Set up _super wrapping if necessary
-      // * Set up computed property descriptors
-      // * Copying `toString` in broken browsers
-      mergeMixins(mixins, mixinsMeta(obj), descs, values, obj, keys);
-
-      for(var i = 0, l = keys.length; i < l; i++) {
-        key = keys[i];
-        if (key === 'constructor' || !values.hasOwnProperty(key)) { continue; }
+    /**
+     Prints the arguments to the console with an error icon, red text and a stack trace.
+     You can pass as many arguments as you want and they will be joined together with a space.
 
-        desc = descs[key];
-        value = values[key];
+      ```javascript
+      Ember.Logger.error('Danger! Danger!');
+      // "Danger! Danger!" will be printed to the console in red text.
+      ```
 
-        if (desc === REQUIRED) { continue; }
+     @method error
+     @for Ember.Logger
+     @param {*} arguments
+    */
+    error: consoleMethod('error') || K,
 
-        while (desc && desc instanceof Alias) {
-          var followed = followAlias(obj, desc, m, descs, values);
-          desc = followed.desc;
-          value = followed.value;
-        }
+    /**
+     Logs the arguments to the console.
+     You can pass as many arguments as you want and they will be joined together with a space.
 
-        if (desc === undefined && value === undefined) { continue; }
+      ```javascript
+      var foo = 1;
+      Ember.Logger.info('log value of foo:', foo);
+      // "log value of foo: 1" will be printed to the console
+      ```
 
-        replaceObserversAndListeners(obj, key, value);
-        detectBinding(obj, key, value, m);
-        defineProperty(obj, key, desc, value, m);
-      }
+     @method info
+     @for Ember.Logger
+     @param {*} arguments
+    */
+    info:  consoleMethod('info')  || K,
 
-      if (!partial) { // don't apply to prototype
-        finishPartial(obj, m);
-      }
+    /**
+     Logs the arguments to the console in blue text.
+     You can pass as many arguments as you want and they will be joined together with a space.
 
-      return obj;
-    }
+      ```javascript
+      var foo = 1;
+      Ember.Logger.debug('log value of foo:', foo);
+      // "log value of foo: 1" will be printed to the console
+      ```
 
-    /**
-      @method mixin
-      @for Ember
-      @param obj
-      @param mixins*
-      @return obj
+     @method debug
+     @for Ember.Logger
+     @param {*} arguments
     */
-    function mixin(obj) {
-      var args = a_slice.call(arguments, 1);
-      applyMixin(obj, args, false);
-      return obj;
-    }
+    debug: consoleMethod('debug') || consoleMethod('info') || K,
 
-    __exports__.mixin = mixin;/**
-      The `Ember.Mixin` class allows you to create mixins, whose properties can be
-      added to other classes. For instance,
+    /**
+     If the value passed into `Ember.Logger.assert` is not truthy it will throw an error with a stack trace.
 
       ```javascript
-      App.Editable = Ember.Mixin.create({
-        edit: function() {
-          console.log('starting to edit');
-          this.set('isEditing', true);
-        },
-        isEditing: false
-      });
+      Ember.Logger.assert(true); // undefined
+      Ember.Logger.assert(true === false); // Throws an Assertion failed error.
+      ```
 
-      // Mix mixins into classes by passing them as the first arguments to
-      // .extend.
-      App.CommentView = Ember.View.extend(App.Editable, {
-        template: Ember.Handlebars.compile('{{#if view.isEditing}}...{{else}}...{{/if}}')
-      });
+     @method assert
+     @for Ember.Logger
+     @param {Boolean} bool Value to test
+    */
+    assert: consoleMethod('assert') || assertPolyfill
+  };
 
-      commentView = App.CommentView.create();
-      commentView.edit(); // outputs 'starting to edit'
-      ```
+});
+enifed('ember-metal/map', ['exports', 'ember-metal/utils', 'ember-metal/array', 'ember-metal/platform/create', 'ember-metal/deprecate_property'], function (exports, utils, array, create, deprecate_property) {
 
-      Note that Mixins are created with `Ember.Mixin.create`, not
-      `Ember.Mixin.extend`.
+  'use strict';
 
-      Note that mixins extend a constructor's prototype so arrays and object literals
-      defined as properties will be shared amongst objects that implement the mixin.
-      If you want to define a property in a mixin that is not shared, you can define
-      it either as a computed property or have it be created on initialization of the object.
+  exports.OrderedSet = OrderedSet;
+  exports.Map = Map;
+  exports.MapWithDefault = MapWithDefault;
 
-      ```javascript
-      //filters array will be shared amongst any object implementing mixin
-      App.Filterable = Ember.Mixin.create({
-        filters: Ember.A()
-      });
+  /**
+  @module ember-metal
+  */
 
-      //filters will be a separate  array for every object implementing the mixin
-      App.Filterable = Ember.Mixin.create({
-        filters: Ember.computed(function(){return Ember.A();})
-      });
+  /*
+    JavaScript (before ES6) does not have a Map implementation. Objects,
+    which are often used as dictionaries, may only have Strings as keys.
 
-      //filters will be created as a separate array during the object's initialization
-      App.Filterable = Ember.Mixin.create({
-        init: function() {
-          this._super();
-          this.set("filters", Ember.A());
-        }
-      });
-      ```
+    Because Ember has a way to get a unique identifier for every object
+    via `Ember.guidFor`, we can implement a performant Map with arbitrary
+    keys. Because it is commonly used in low-level bookkeeping, Map is
+    implemented as a pure JavaScript object for performance.
 
-      @class Mixin
-      @namespace Ember
-    */
-    __exports__["default"] = Mixin;
-    function Mixin(args, properties) {
-      this.properties = properties;
+    This implementation follows the current iteration of the ES6 proposal for
+    maps (http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets),
+    with one exception:  as we do not have the luxury of in-VM iteration, we implement a
+    forEach method for iteration.
 
-      var length = args && args.length;
+    Map is mocked out to look like an Ember object, so you can do
+    `Ember.Map.create()` for symmetry with other Ember classes.
+  */
 
-      if (length > 0) {
-        var m = new Array(length);
+  function missingFunction(fn) {
+    throw new TypeError('' + Object.prototype.toString.call(fn) + " is not a function");
+  }
 
-        for (var i = 0; i < length; i++) {
-          var x = args[i];
-          if (x instanceof Mixin) {
-            m[i] = x;
-          } else {
-            m[i] = new Mixin(undefined, x);
-          }
-        }
+  function missingNew(name) {
+    throw new TypeError("Constructor " + name + "requires 'new'");
+  }
 
-        this.mixins = m;
-      } else {
-        this.mixins = undefined;
-      }
-      this.ownerConstructor = undefined;
+  function copyNull(obj) {
+    var output = create['default'](null);
+
+    for (var prop in obj) {
+      // hasOwnPropery is not needed because obj is Object.create(null);
+      output[prop] = obj[prop];
     }
 
-    Mixin._apply = applyMixin;
+    return output;
+  }
 
-    Mixin.applyPartial = function(obj) {
-      var args = a_slice.call(arguments, 1);
-      return applyMixin(obj, args, true);
-    };
+  function copyMap(original, newObject) {
+    var keys = original._keys.copy();
+    var values = copyNull(original._values);
 
-    Mixin.finishPartial = finishPartial;
+    newObject._keys = keys;
+    newObject._values = values;
+    newObject.size = original.size;
 
-    // ES6TODO: this relies on a global state?
-    Ember.anyUnprocessedMixins = false;
+    return newObject;
+  }
 
-    /**
-      @method create
-      @static
-      @param arguments*
-    */
-    Mixin.create = function() {
-      // ES6TODO: this relies on a global state?
-      Ember.anyUnprocessedMixins = true;
-      var M = this;
-      var length = arguments.length;
-      var args = new Array(length);
-      for (var i = 0; i < length; i++) {
-        args[i] = arguments[i];
-      }
-      return new M(args, undefined);
-    };
+  /**
+    This class is used internally by Ember and Ember Data.
+    Please do not use it at this time. We plan to clean it up
+    and add many tests soon.
 
-    var MixinPrototype = Mixin.prototype;
+    @class OrderedSet
+    @namespace Ember
+    @constructor
+    @private
+  */
+  function OrderedSet() {
 
-    /**
-      @method reopen
-      @param arguments*
-    */
-    MixinPrototype.reopen = function() {
-      var mixin;
+    if (this instanceof OrderedSet) {
+      this.clear();
+      this._silenceRemoveDeprecation = false;
+    } else {
+      missingNew("OrderedSet");
+    }
+  }
 
-      if (this.properties) {
-        mixin = new Mixin(undefined, this.properties);
-        this.properties = undefined;
-        this.mixins = [mixin];
-      } else if (!this.mixins) {
-        this.mixins = [];
-      }
+  /**
+    @method create
+    @static
+    @return {Ember.OrderedSet}
+  */
+  OrderedSet.create = function() {
+    var Constructor = this;
 
-      var len = arguments.length;
-      var mixins = this.mixins;
-      var idx;
+    return new Constructor();
+  };
 
-      for(idx=0; idx < len; idx++) {
-        mixin = arguments[idx];
-        Ember.assert('Expected hash or Mixin instance, got ' + Object.prototype.toString.call(mixin),
-                     typeof mixin === 'object' && mixin !== null &&
-                       Object.prototype.toString.call(mixin) !== '[object Array]');
+  OrderedSet.prototype = {
+    constructor: OrderedSet,
+    /**
+      @method clear
+    */
+    clear: function() {
+      this.presenceSet = create['default'](null);
+      this.list = [];
+      this.size = 0;
+    },
 
-        if (mixin instanceof Mixin) {
-          mixins.push(mixin);
-        } else {
-          mixins.push(new Mixin(undefined, mixin));
-        }
+    /**
+      @method add
+      @param obj
+      @param guid (optional, and for internal use)
+      @return {Ember.OrderedSet}
+    */
+    add: function(obj, _guid) {
+      var guid = _guid || utils.guidFor(obj);
+      var presenceSet = this.presenceSet;
+      var list = this.list;
+
+      if (presenceSet[guid] !== true) {
+        presenceSet[guid] = true;
+        this.size = list.push(obj);
       }
 
       return this;
-    };
+    },
 
     /**
-      @method apply
+      @deprecated
+
+      @method remove
       @param obj
-      @return applied object
+      @param _guid (optional and for internal use only)
+      @return {Boolean}
     */
-    MixinPrototype.apply = function(obj) {
-      return applyMixin(obj, [this], false);
-    };
-
-    MixinPrototype.applyPartial = function(obj) {
-      return applyMixin(obj, [this], true);
-    };
-
-    function _detect(curMixin, targetMixin, seen) {
-      var guid = guidFor(curMixin);
-
-      if (seen[guid]) { return false; }
-      seen[guid] = true;
+    remove: function(obj, _guid) {
+      Ember.deprecate(
+        'Calling `OrderedSet.prototype.remove` has been deprecated, please use `OrderedSet.prototype.delete` instead.',
+        this._silenceRemoveDeprecation
+      );
 
-      if (curMixin === targetMixin) { return true; }
-      var mixins = curMixin.mixins;
-      var loc = mixins ? mixins.length : 0;
-      while (--loc >= 0) {
-        if (_detect(mixins[loc], targetMixin, seen)) { return true; }
-      }
-      return false;
-    }
+      return this["delete"](obj, _guid);
+    },
 
     /**
-      @method detect
+      @since 1.8.0
+      @method delete
       @param obj
+      @param _guid (optional and for internal use only)
       @return {Boolean}
     */
-    MixinPrototype.detect = function(obj) {
-      if (!obj) { return false; }
-      if (obj instanceof Mixin) { return _detect(obj, this, {}); }
-      var m = obj['__ember_meta__'];
-      var mixins = m && m.mixins;
-      if (mixins) {
-        return !!mixins[guidFor(this)];
-      }
-      return false;
-    };
-
-    MixinPrototype.without = function() {
-      var ret = new Mixin([this]);
-      ret._without = a_slice.call(arguments);
-      return ret;
-    };
+    "delete": function(obj, _guid) {
+      var guid = _guid || utils.guidFor(obj);
+      var presenceSet = this.presenceSet;
+      var list = this.list;
 
-    function _keys(ret, mixin, seen) {
-      if (seen[guidFor(mixin)]) { return; }
-      seen[guidFor(mixin)] = true;
-
-      if (mixin.properties) {
-        var props = mixin.properties;
-        for (var key in props) {
-          if (props.hasOwnProperty(key)) { ret[key] = true; }
+      if (presenceSet[guid] === true) {
+        delete presenceSet[guid];
+        var index = array.indexOf.call(list, obj);
+        if (index > -1) {
+          list.splice(index, 1);
         }
-      } else if (mixin.mixins) {
-        a_forEach.call(mixin.mixins, function(x) { _keys(ret, x, seen); });
+        this.size = list.length;
+        return true;
+      } else {
+        return false;
       }
-    }
+    },
 
-    MixinPrototype.keys = function() {
-      var keys = {};
-      var seen = {};
-      var ret = [];
-      _keys(keys, this, seen);
-      for(var key in keys) {
-        if (keys.hasOwnProperty(key)) {
-          ret.push(key);
-        }
-      }
-      return ret;
-    };
+    /**
+      @method isEmpty
+      @return {Boolean}
+    */
+    isEmpty: function() {
+      return this.size === 0;
+    },
 
-    // returns the mixins currently applied to the specified object
-    // TODO: Make Ember.mixin
-    Mixin.mixins = function(obj) {
-      var m = obj['__ember_meta__'];
-      var mixins = m && m.mixins;
-      var ret = [];
+    /**
+      @method has
+      @param obj
+      @return {Boolean}
+    */
+    has: function(obj) {
+      if (this.size === 0) { return false; }
 
-      if (!mixins) { return ret; }
+      var guid = utils.guidFor(obj);
+      var presenceSet = this.presenceSet;
 
-      for (var key in mixins) {
-        var mixin = mixins[key];
+      return presenceSet[guid] === true;
+    },
 
-        // skip primitive mixins since these are always anonymous
-        if (!mixin.properties) { ret.push(mixin); }
+    /**
+      @method forEach
+      @param {Function} fn
+      @param self
+    */
+    forEach: function(fn /*, thisArg*/) {
+      if (typeof fn !== 'function') {
+        missingFunction(fn);
       }
 
-      return ret;
-    };
+      if (this.size === 0) { return; }
 
-    REQUIRED = new Descriptor();
-    REQUIRED.toString = function() { return '(Required Property)'; };
+      var list = this.list;
+      var length = arguments.length;
+      var i;
 
-    /**
-      Denotes a required property for a mixin
+      if (length === 2) {
+        for (i = 0; i < list.length; i++) {
+          fn.call(arguments[1], list[i]);
+        }
+      } else {
+        for (i = 0; i < list.length; i++) {
+          fn(list[i]);
+        }
+      }
+    },
 
-      @method required
-      @for Ember
+    /**
+      @method toArray
+      @return {Array}
     */
-    function required() {
-      return REQUIRED;
-    }
-
-    __exports__.required = required;function Alias(methodName) {
-      this.methodName = methodName;
-    }
-
-    Alias.prototype = new Descriptor();
+    toArray: function() {
+      return this.list.slice();
+    },
 
     /**
-      Makes a method available via an additional name.
-
-      ```javascript
-      App.Person = Ember.Object.extend({
-        name: function() {
-          return 'Tomhuda Katzdale';
-        },
-        moniker: Ember.aliasMethod('name')
-      });
-
-      var goodGuy = App.Person.create();
+      @method copy
+      @return {Ember.OrderedSet}
+    */
+    copy: function() {
+      var Constructor = this.constructor;
+      var set = new Constructor();
 
-      goodGuy.name();    // 'Tomhuda Katzdale'
-      goodGuy.moniker(); // 'Tomhuda Katzdale'
-      ```
+      set._silenceRemoveDeprecation = this._silenceRemoveDeprecation;
+      set.presenceSet = copyNull(this.presenceSet);
+      set.list = this.toArray();
+      set.size = this.size;
 
-      @method aliasMethod
-      @for Ember
-      @param {String} methodName name of the method to alias
-      @return {Ember.Descriptor}
-    */
-    function aliasMethod(methodName) {
-      return new Alias(methodName);
+      return set;
     }
+  };
 
-    __exports__.aliasMethod = aliasMethod;// ..........................................................
-    // OBSERVER HELPER
-    //
-
-    /**
-      Specify a method that observes property changes.
+  deprecate_property.deprecateProperty(OrderedSet.prototype, 'length', 'size');
 
-      ```javascript
-      Ember.Object.extend({
-        valueObserver: Ember.observer('value', function() {
-          // Executes whenever the "value" property changes
-        })
-      });
-      ```
+  /**
+    A Map stores values indexed by keys. Unlike JavaScript's
+    default Objects, the keys of a Map can be any JavaScript
+    object.
 
-      In the future this method may become asynchronous. If you want to ensure
-      synchronous behavior, use `immediateObserver`.
+    Internally, a Map has two data structures:
 
-      Also available as `Function.prototype.observes` if prototype extensions are
-      enabled.
+    1. `keys`: an OrderedSet of all of the existing keys
+    2. `values`: a JavaScript Object indexed by the `Ember.guidFor(key)`
 
-      @method observer
-      @for Ember
-      @param {String} propertyNames*
-      @param {Function} func
-      @return func
-    */
-    function observer() {
-      var func  = a_slice.call(arguments, -1)[0];
-      var paths;
+    When a key/value pair is added for the first time, we
+    add the key to the `keys` OrderedSet, and create or
+    replace an entry in `values`. When an entry is deleted,
+    we delete its entry in `keys` and `values`.
 
-      var addWatchedProperty = function (path) { paths.push(path); };
-      var _paths = a_slice.call(arguments, 0, -1);
+    @class Map
+    @namespace Ember
+    @private
+    @constructor
+  */
+  function Map() {
+    if (this instanceof this.constructor) {
+      this._keys = OrderedSet.create();
+      this._keys._silenceRemoveDeprecation = true;
+      this._values = create['default'](null);
+      this.size = 0;
+    } else {
+      missingNew("OrderedSet");
+    }
+  }
 
-      if (typeof func !== "function") {
-        // revert to old, soft-deprecated argument ordering
+  Ember.Map = Map;
 
-        func  = arguments[0];
-        _paths = a_slice.call(arguments, 1);
-      }
+  /**
+    @method create
+    @static
+  */
+  Map.create = function() {
+    var Constructor = this;
+    return new Constructor();
+  };
 
-      paths = [];
+  Map.prototype = {
+    constructor: Map,
 
-      for (var i=0; i<_paths.length; ++i) {
-        expandProperties(_paths[i], addWatchedProperty);
-      }
+    /**
+      This property will change as the number of objects in the map changes.
 
-      if (typeof func !== "function") {
-        throw new Ember.Error("Ember.observer called without a function");
-      }
+      @since 1.8.0
+      @property size
+      @type number
+      @default 0
+    */
+    size: 0,
 
-      func.__ember_observes__ = paths;
-      return func;
-    }
+    /**
+      Retrieve the value associated with a given key.
 
-    __exports__.observer = observer;/**
-      Specify a method that observes property changes.
+      @method get
+      @param {*} key
+      @return {*} the value associated with the key, or `undefined`
+    */
+    get: function(key) {
+      if (this.size === 0) { return; }
 
-      ```javascript
-      Ember.Object.extend({
-        valueObserver: Ember.immediateObserver('value', function() {
-          // Executes whenever the "value" property changes
-        })
-      });
-      ```
+      var values = this._values;
+      var guid = utils.guidFor(key);
 
-      In the future, `Ember.observer` may become asynchronous. In this event,
-      `Ember.immediateObserver` will maintain the synchronous behavior.
+      return values[guid];
+    },
 
-      Also available as `Function.prototype.observesImmediately` if prototype extensions are
-      enabled.
+    /**
+      Adds a value to the map. If a value for the given key has already been
+      provided, the new value will replace the old value.
 
-      @method immediateObserver
-      @for Ember
-      @param {String} propertyNames*
-      @param {Function} func
-      @return func
+      @method set
+      @param {*} key
+      @param {*} value
+      @return {Ember.Map}
     */
-    function immediateObserver() {
-      for (var i=0, l=arguments.length; i<l; i++) {
-        var arg = arguments[i];
-        Ember.assert("Immediate observers must observe internal properties only, not properties on other objects.",
-                     typeof arg !== "string" || arg.indexOf('.') === -1);
-      }
+    set: function(key, value) {
+      var keys = this._keys;
+      var values = this._values;
+      var guid = utils.guidFor(key);
 
-      return observer.apply(this, arguments);
-    }
+      // ensure we don't store -0
+      var k = key === -0 ? 0 : key;
+
+      keys.add(k, guid);
 
-    __exports__.immediateObserver = immediateObserver;/**
-      When observers fire, they are called with the arguments `obj`, `keyName`.
+      values[guid] = value;
 
-      Note, `@each.property` observer is called per each add or replace of an element
-      and it's not called with a specific enumeration item.
+      this.size = keys.size;
 
-      A `beforeObserver` fires before a property changes.
+      return this;
+    },
 
-      A `beforeObserver` is an alternative form of `.observesBefore()`.
+    /**
+      @deprecated see delete
+      Removes a value from the map for an associated key.
 
-      ```javascript
-      App.PersonView = Ember.View.extend({
-        friends: [{ name: 'Tom' }, { name: 'Stefan' }, { name: 'Kris' }],
+      @method remove
+      @param {*} key
+      @return {Boolean} true if an item was removed, false otherwise
+    */
+    remove: function(key) {
+      Ember.deprecate('Calling `Map.prototype.remove` has been deprecated, please use `Map.prototype.delete` instead.');
 
-        valueWillChange: Ember.beforeObserver('content.value', function(obj, keyName) {
-          this.changingFrom = obj.get(keyName);
-        }),
+      return this["delete"](key);
+    },
 
-        valueDidChange: Ember.observer('content.value', function(obj, keyName) {
-            // only run if updating a value already in the DOM
-            if (this.get('state') === 'inDOM') {
-              var color = obj.get(keyName) > this.changingFrom ? 'green' : 'red';
-              // logic
-            }
-        }),
+    /**
+      Removes a value from the map for an associated key.
 
-        friendsDidChange: Ember.observer('friends.@each.name', function(obj, keyName) {
-          // some logic
-          // obj.get(keyName) returns friends array
-        })
-      });
-      ```
+      @since 1.8.0
+      @method delete
+      @param {*} key
+      @return {Boolean} true if an item was removed, false otherwise
+    */
+    "delete": function(key) {
+      if (this.size === 0) { return false; }
+      // don't use ES6 "delete" because it will be annoying
+      // to use in browsers that are not ES6 friendly;
+      var keys = this._keys;
+      var values = this._values;
+      var guid = utils.guidFor(key);
+
+      if (keys["delete"](key, guid)) {
+        delete values[guid];
+        this.size = keys.size;
+        return true;
+      } else {
+        return false;
+      }
+    },
 
-      Also available as `Function.prototype.observesBefore` if prototype extensions are
-      enabled.
+    /**
+      Check whether a key is present.
 
-      @method beforeObserver
-      @for Ember
-      @param {String} propertyNames*
-      @param {Function} func
-      @return func
+      @method has
+      @param {*} key
+      @return {Boolean} true if the item was present, false otherwise
     */
-    function beforeObserver() {
-      var func  = a_slice.call(arguments, -1)[0];
-      var paths;
-
-      var addWatchedProperty = function(path) { paths.push(path); };
+    has: function(key) {
+      return this._keys.has(key);
+    },
 
-      var _paths = a_slice.call(arguments, 0, -1);
+    /**
+      Iterate over all the keys and values. Calls the function once
+      for each key, passing in value, key, and the map being iterated over,
+      in that order.
 
-      if (typeof func !== "function") {
-        // revert to old, soft-deprecated argument ordering
+      The keys are guaranteed to be iterated over in insertion order.
 
-        func  = arguments[0];
-        _paths = a_slice.call(arguments, 1);
+      @method forEach
+      @param {Function} callback
+      @param {*} self if passed, the `this` value inside the
+        callback. By default, `this` is the map.
+    */
+    forEach: function(callback /*, thisArg*/) {
+      if (typeof callback !== 'function') {
+        missingFunction(callback);
       }
 
-      paths = [];
+      if (this.size === 0) { return; }
 
-      for (var i=0; i<_paths.length; ++i) {
-        expandProperties(_paths[i], addWatchedProperty);
-      }
+      var length = arguments.length;
+      var map = this;
+      var cb, thisArg;
 
-      if (typeof func !== "function") {
-        throw new Ember.Error("Ember.beforeObserver called without a function");
+      if (length === 2) {
+        thisArg = arguments[1];
+        cb = function(key) {
+          callback.call(thisArg, map.get(key), key, map);
+        };
+      } else {
+        cb = function(key) {
+          callback(map.get(key), key, map);
+        };
       }
 
-      func.__ember_observesBefore__ = paths;
-      return func;
-    }
+      this._keys.forEach(cb);
+    },
 
-    __exports__.beforeObserver = beforeObserver;__exports__.IS_BINDING = IS_BINDING;
-    __exports__.Mixin = Mixin;
-  });
-enifed("ember-metal/observer",
-  ["ember-metal/watching","ember-metal/array","ember-metal/events","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var watch = __dependency1__.watch;
-    var unwatch = __dependency1__.unwatch;
-    var map = __dependency2__.map;
-    var listenersFor = __dependency3__.listenersFor;
-    var addListener = __dependency3__.addListener;
-    var removeListener = __dependency3__.removeListener;
-    var suspendListeners = __dependency3__.suspendListeners;
-    var suspendListener = __dependency3__.suspendListener;
     /**
-    @module ember-metal
+      @method clear
     */
-
-    var AFTER_OBSERVERS = ':change';
-    var BEFORE_OBSERVERS = ':before';
-
-    function changeEvent(keyName) {
-      return keyName + AFTER_OBSERVERS;
-    }
-
-    function beforeEvent(keyName) {
-      return keyName + BEFORE_OBSERVERS;
-    }
+    clear: function() {
+      this._keys.clear();
+      this._values = create['default'](null);
+      this.size = 0;
+    },
 
     /**
-      @method addObserver
-      @for Ember
-      @param obj
-      @param {String} path
-      @param {Object|Function} targetOrMethod
-      @param {Function|String} [method]
+      @method copy
+      @return {Ember.Map}
     */
-    function addObserver(obj, _path, target, method) {
-      addListener(obj, changeEvent(_path), target, method);
-      watch(obj, _path);
-
-      return this;
+    copy: function() {
+      return copyMap(this, new Map());
     }
+  };
 
-    __exports__.addObserver = addObserver;function observersFor(obj, path) {
-      return listenersFor(obj, changeEvent(path));
-    }
+  deprecate_property.deprecateProperty(Map.prototype, 'length', 'size');
 
-    __exports__.observersFor = observersFor;/**
-      @method removeObserver
-      @for Ember
-      @param obj
-      @param {String} path
-      @param {Object|Function} target
-      @param {Function|String} [method]
-    */
-    function removeObserver(obj, path, target, method) {
-      unwatch(obj, path);
-      removeListener(obj, changeEvent(path), target, method);
+  /**
+    @class MapWithDefault
+    @namespace Ember
+    @extends Ember.Map
+    @private
+    @constructor
+    @param [options]
+      @param {*} [options.defaultValue]
+  */
+  function MapWithDefault(options) {
+    this._super$constructor();
+    this.defaultValue = options.defaultValue;
+  }
 
-      return this;
+  /**
+    @method create
+    @static
+    @param [options]
+      @param {*} [options.defaultValue]
+    @return {Ember.MapWithDefault|Ember.Map} If options are passed, returns
+      `Ember.MapWithDefault` otherwise returns `Ember.Map`
+  */
+  MapWithDefault.create = function(options) {
+    if (options) {
+      return new MapWithDefault(options);
+    } else {
+      return new Map();
     }
+  };
 
-    __exports__.removeObserver = removeObserver;/**
-      @method addBeforeObserver
-      @for Ember
-      @param obj
-      @param {String} path
-      @param {Object|Function} target
-      @param {Function|String} [method]
-    */
-    function addBeforeObserver(obj, path, target, method) {
-      addListener(obj, beforeEvent(path), target, method);
-      watch(obj, path);
+  MapWithDefault.prototype = create['default'](Map.prototype);
+  MapWithDefault.prototype.constructor = MapWithDefault;
+  MapWithDefault.prototype._super$constructor = Map;
+  MapWithDefault.prototype._super$get = Map.prototype.get;
 
-      return this;
-    }
+  /**
+    Retrieve the value associated with a given key.
 
-    __exports__.addBeforeObserver = addBeforeObserver;// Suspend observer during callback.
-    //
-    // This should only be used by the target of the observer
-    // while it is setting the observed path.
-    function _suspendBeforeObserver(obj, path, target, method, callback) {
-      return suspendListener(obj, beforeEvent(path), target, method, callback);
-    }
+    @method get
+    @param {*} key
+    @return {*} the value associated with the key, or the default value
+  */
+  MapWithDefault.prototype.get = function(key) {
+    var hasValue = this.has(key);
 
-    __exports__._suspendBeforeObserver = _suspendBeforeObserver;function _suspendObserver(obj, path, target, method, callback) {
-      return suspendListener(obj, changeEvent(path), target, method, callback);
+    if (hasValue) {
+      return this._super$get(key);
+    } else {
+      var defaultValue = this.defaultValue(key);
+      this.set(key, defaultValue);
+      return defaultValue;
     }
+  };
 
-    __exports__._suspendObserver = _suspendObserver;function _suspendBeforeObservers(obj, paths, target, method, callback) {
-      var events = map.call(paths, beforeEvent);
-      return suspendListeners(obj, events, target, method, callback);
-    }
+  /**
+    @method copy
+    @return {Ember.MapWithDefault}
+  */
+  MapWithDefault.prototype.copy = function() {
+    var Constructor = this.constructor;
+    return copyMap(this, new Constructor({
+      defaultValue: this.defaultValue
+    }));
+  };
 
-    __exports__._suspendBeforeObservers = _suspendBeforeObservers;function _suspendObservers(obj, paths, target, method, callback) {
-      var events = map.call(paths, changeEvent);
-      return suspendListeners(obj, events, target, method, callback);
-    }
+  exports['default'] = Map;
 
-    __exports__._suspendObservers = _suspendObservers;function beforeObserversFor(obj, path) {
-      return listenersFor(obj, beforeEvent(path));
-    }
+});
+enifed('ember-metal/merge', ['exports', 'ember-metal/keys'], function (exports, keys) {
 
-    __exports__.beforeObserversFor = beforeObserversFor;/**
-      @method removeBeforeObserver
-      @for Ember
-      @param obj
-      @param {String} path
-      @param {Object|Function} target
-      @param {Function|String} [method]
-    */
-    function removeBeforeObserver(obj, path, target, method) {
-      unwatch(obj, path);
-      removeListener(obj, beforeEvent(path), target, method);
+  'use strict';
 
-      return this;
+  function merge(original, updates) {
+    if (!updates || typeof updates !== 'object') {
+      return original;
     }
 
-    __exports__.removeBeforeObserver = removeBeforeObserver;
-  });
-enifed("ember-metal/observer_set",
-  ["ember-metal/utils","ember-metal/events","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var guidFor = __dependency1__.guidFor;
-    var sendEvent = __dependency2__.sendEvent;
+    var props = keys['default'](updates);
+    var prop;
+    var length = props.length;
 
-    /*
-      this.observerSet = {
-        [senderGuid]: { // variable name: `keySet`
-          [keyName]: listIndex
-        }
-      },
-      this.observers = [
-        {
-          sender: obj,
-          keyName: keyName,
-          eventName: eventName,
-          listeners: [
-            [target, method, flags]
-          ]
-        },
-        ...
-      ]
-    */
-    __exports__["default"] = ObserverSet;
-    function ObserverSet() {
-      this.clear();
+    for (var i = 0; i < length; i++) {
+      prop = props[i];
+      original[prop] = updates[prop];
     }
 
+    return original;
+  }
+  exports['default'] = merge;
 
-    ObserverSet.prototype.add = function(sender, keyName, eventName) {
-      var observerSet = this.observerSet;
-      var observers = this.observers;
-      var senderGuid = guidFor(sender);
-      var keySet = observerSet[senderGuid];
-      var index;
+});
+enifed('ember-metal/mixin', ['exports', 'ember-metal/core', 'ember-metal/merge', 'ember-metal/array', 'ember-metal/platform/create', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/utils', 'ember-metal/expand_properties', 'ember-metal/properties', 'ember-metal/computed', 'ember-metal/binding', 'ember-metal/observer', 'ember-metal/events', 'ember-metal/streams/utils'], function (exports, Ember, merge, array, o_create, property_get, property_set, utils, expandProperties, properties, computed, ember_metal__binding, ember_metal__observer, events, streams__utils) {
 
-      if (!keySet) {
-        observerSet[senderGuid] = keySet = {};
-      }
-      index = keySet[keyName];
-      if (index === undefined) {
-        index = observers.push({
-          sender: sender,
-          keyName: keyName,
-          eventName: eventName,
-          listeners: []
-        }) - 1;
-        keySet[keyName] = index;
-      }
-      return observers[index].listeners;
-    };
 
-    ObserverSet.prototype.flush = function() {
-      var observers = this.observers;
-      var i, len, observer, sender;
-      this.clear();
-      for (i=0, len=observers.length; i < len; ++i) {
-        observer = observers[i];
-        sender = observer.sender;
-        if (sender.isDestroying || sender.isDestroyed) { continue; }
-        sendEvent(sender, observer.eventName, [sender, observer.keyName], observer.listeners);
-      }
-    };
+  exports.mixin = mixin;
+  exports.required = required;
+  exports.aliasMethod = aliasMethod;
+  exports.observer = observer;
+  exports.immediateObserver = immediateObserver;
+  exports.beforeObserver = beforeObserver;
+  exports.Mixin = Mixin;
 
-    ObserverSet.prototype.clear = function() {
-      this.observerSet = {};
-      this.observers = [];
-    };
-  });
-enifed("ember-metal/path_cache",
-  ["ember-metal/cache","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Cache = __dependency1__["default"];
+  // Remove "use strict"; from transpiled module until
+  // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
+  //
+  "REMOVE_USE_STRICT: true";
 
-    var IS_GLOBAL      = /^([A-Z$]|([0-9][A-Z$]))/;
-    var IS_GLOBAL_PATH = /^([A-Z$]|([0-9][A-Z$])).*[\.]/;
-    var HAS_THIS       = 'this.';
+  /**
+  @module ember
+  @submodule ember-metal
+  */
 
-    var isGlobalCache       = new Cache(1000, function(key) { return IS_GLOBAL.test(key);          });
-    var isGlobalPathCache   = new Cache(1000, function(key) { return IS_GLOBAL_PATH.test(key);     });
-    var hasThisCache        = new Cache(1000, function(key) { return key.lastIndexOf(HAS_THIS, 0) === 0; });
-    var firstDotIndexCache  = new Cache(1000, function(key) { return key.indexOf('.');             });
+  var REQUIRED;
+  var a_slice = [].slice;
 
-    var firstKeyCache = new Cache(1000, function(path) {
-      var index = firstDotIndexCache.get(path);
-      if (index === -1) {
-        return path;
+  function superFunction() {
+    var func = this.__nextSuper;
+    var ret;
+
+    if (func) {
+      var length = arguments.length;
+      this.__nextSuper = null;
+      if (length === 0) {
+        ret = func.call(this);
+      } else if (length === 1) {
+        ret = func.call(this, arguments[0]);
+      } else if (length === 2) {
+        ret = func.call(this, arguments[0], arguments[1]);
       } else {
-        return path.slice(0, index);
+        ret = func.apply(this, arguments);
       }
-    });
+      this.__nextSuper = func;
+      return ret;
+    }
+  }
 
-    var tailPathCache = new Cache(1000, function(path) {
-      var index = firstDotIndexCache.get(path);
-      if (index !== -1) {
-        return path.slice(index + 1);
-      }
-    });
+  // ensure we prime superFunction to mitigate
+  // v8 bug potentially incorrectly deopts this function: https://code.google.com/p/v8/issues/detail?id=3709
+  var primer = {
+    __nextSuper: function(a, b, c, d ) { }
+  };
+
+  superFunction.call(primer);
+  superFunction.call(primer, 1);
+  superFunction.call(primer, 1, 2);
+  superFunction.call(primer, 1, 2, 3);
+
+  function mixinsMeta(obj) {
+    var m = utils.meta(obj, true);
+    var ret = m.mixins;
+    if (!ret) {
+      ret = m.mixins = {};
+    } else if (!m.hasOwnProperty('mixins')) {
+      ret = m.mixins = o_create['default'](ret);
+    }
+    return ret;
+  }
 
-    var caches = {
-      isGlobalCache:      isGlobalCache,
-      isGlobalPathCache:  isGlobalPathCache,
-      hasThisCache:       hasThisCache,
-      firstDotIndexCache: firstDotIndexCache,
-      firstKeyCache:      firstKeyCache,
-      tailPathCache:      tailPathCache
-    };
-    __exports__.caches = caches;
-    function isGlobal(path) {
-      return isGlobalCache.get(path);
+  function isMethod(obj) {
+    return 'function' === typeof obj &&
+           obj.isMethod !== false &&
+           obj !== Boolean &&
+           obj !== Object &&
+           obj !== Number &&
+           obj !== Array &&
+           obj !== Date &&
+           obj !== String;
+  }
+
+  var CONTINUE = {};
+
+  function mixinProperties(mixinsMeta, mixin) {
+    var guid;
+
+    if (mixin instanceof Mixin) {
+      guid = utils.guidFor(mixin);
+      if (mixinsMeta[guid]) { return CONTINUE; }
+      mixinsMeta[guid] = mixin;
+      return mixin.properties;
+    } else {
+      return mixin; // apply anonymous mixin properties
     }
+  }
 
-    __exports__.isGlobal = isGlobal;function isGlobalPath(path) {
-      return isGlobalPathCache.get(path);
+  function concatenatedMixinProperties(concatProp, props, values, base) {
+    var concats;
+
+    // reset before adding each new mixin to pickup concats from previous
+    concats = values[concatProp] || base[concatProp];
+    if (props[concatProp]) {
+      concats = concats ? concats.concat(props[concatProp]) : props[concatProp];
     }
 
-    __exports__.isGlobalPath = isGlobalPath;function hasThis(path) {
-      return hasThisCache.get(path);
+    return concats;
+  }
+
+  function giveDescriptorSuper(meta, key, property, values, descs, base) {
+    var superProperty;
+
+    // Computed properties override methods, and do not call super to them
+    if (values[key] === undefined) {
+      // Find the original descriptor in a parent mixin
+      superProperty = descs[key];
     }
 
-    __exports__.hasThis = hasThis;function isPath(path) {
-      return firstDotIndexCache.get(path) !== -1;
+    // If we didn't find the original descriptor in a parent mixin, find
+    // it on the original object.
+    if (!superProperty) {
+      var possibleDesc = base[key];
+      var superDesc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
+
+      superProperty = superDesc;
     }
 
-    __exports__.isPath = isPath;function getFirstKey(path) {
-      return firstKeyCache.get(path);
+    if (superProperty === undefined || !(superProperty instanceof computed.ComputedProperty)) {
+      return property;
     }
 
-    __exports__.getFirstKey = getFirstKey;function getTailPath(path) {
-      return tailPathCache.get(path);
+    // Since multiple mixins may inherit from the same parent, we need
+    // to clone the computed property so that other mixins do not receive
+    // the wrapped version.
+    property = o_create['default'](property);
+    property._getter = utils.wrap(property._getter, superProperty._getter);
+    if (superProperty._setter) {
+      if (property._setter) {
+        property._setter = utils.wrap(property._setter, superProperty._setter);
+      } else {
+        property._setter = superProperty._setter;
+      }
     }
 
-    __exports__.getTailPath = getTailPath;
-  });
-enifed("ember-metal/platform",
-  ["ember-metal/platform/define_property","ember-metal/platform/define_properties","ember-metal/platform/create","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var hasES5CompliantDefineProperty = __dependency1__.hasES5CompliantDefineProperty;
-    var defineProperty = __dependency1__.defineProperty;
-    var defineProperties = __dependency2__["default"];
-    var create = __dependency3__["default"];
+    return property;
+  }
 
-    /**
-    @module ember-metal
-    */
+  var sourceAvailable = (function() {
+    return this;
+  }).toString().indexOf('return this;') > -1;
 
-    var hasPropertyAccessors = hasES5CompliantDefineProperty;
-    var canDefineNonEnumerableProperties = hasES5CompliantDefineProperty;
+  function giveMethodSuper(obj, key, method, values, descs) {
+    var superMethod;
 
-    /**
-      Platform specific methods and feature detectors needed by the framework.
+    // Methods overwrite computed properties, and do not call super to them.
+    if (descs[key] === undefined) {
+      // Find the original method in a parent mixin
+      superMethod = values[key];
+    }
 
-      @class platform
-      @namespace Ember
-      @static
-    */
+    // If we didn't find the original value in a parent mixin, find it in
+    // the original object
+    superMethod = superMethod || obj[key];
 
-    __exports__.create = create;
-    __exports__.defineProperty = defineProperty;
-    __exports__.defineProperties = defineProperties;
-    __exports__.hasPropertyAccessors = hasPropertyAccessors;
-    __exports__.canDefineNonEnumerableProperties = canDefineNonEnumerableProperties;
-  });
-enifed("ember-metal/platform/create",
-  ["ember-metal/platform/define_properties","exports"],
-  function(__dependency1__, __exports__) {
-        // Remove "use strict"; from transpiled module until
-    // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
-    //
-    // REMOVE_USE_STRICT: true
-    //
+    // Only wrap the new method if the original method was a function
+    if (superMethod === undefined || 'function' !== typeof superMethod) {
+      return method;
+    }
 
-    var defineProperties = __dependency1__["default"];
+    var hasSuper;
+    if (sourceAvailable) {
+      hasSuper = method.__hasSuper;
 
-    /**
-    @class platform
-    @namespace Ember
-    @static
-    */
+      if (hasSuper === undefined) {
+        hasSuper = method.toString().indexOf('_super') > -1;
+        method.__hasSuper = hasSuper;
+      }
+    }
 
-    /**
-      Identical to `Object.create()`. Implements if not available natively.
+    if (sourceAvailable === false || hasSuper) {
+      return utils.wrap(method, superMethod);
+    } else {
+      return method;
+    }
+  }
 
-      @since 1.8.0
-      @method create
-      @for Ember
-    */
-    var create;
-    // ES5 15.2.3.5
-    // http://es5.github.com/#x15.2.3.5
-    if (!(Object.create && !Object.create(null).hasOwnProperty)) {
-      /* jshint scripturl:true, proto:true */
-      // Contributed by Brandon Benvie, October, 2012
-      var createEmpty;
-      var supportsProto = !({'__proto__':null} instanceof Object);
-      // the following produces false positives
-      // in Opera Mini => not a reliable check
-      // Object.prototype.__proto__ === null
-      if (supportsProto || typeof document === 'undefined') {
-        createEmpty = function () {
-          return { "__proto__": null };
-        };
+  function applyConcatenatedProperties(obj, key, value, values) {
+    var baseValue = values[key] || obj[key];
+
+    if (baseValue) {
+      if ('function' === typeof baseValue.concat) {
+        if (value === null || value === undefined) {
+          return baseValue;
+        } else {
+          return baseValue.concat(value);
+        }
       } else {
-        // In old IE __proto__ can't be used to manually set `null`, nor does
-        // any other method exist to make an object that inherits from nothing,
-        // aside from Object.prototype itself. Instead, create a new global
-        // object and *steal* its Object.prototype and strip it bare. This is
-        // used as the prototype to create nullary objects.
-        createEmpty = function () {
-          var iframe = document.createElement('iframe');
-          var parent = document.body || document.documentElement;
-          iframe.style.display = 'none';
-          parent.appendChild(iframe);
-          iframe.src = 'javascript:';
-          var empty = iframe.contentWindow.Object.prototype;
-          parent.removeChild(iframe);
-          iframe = null;
-          delete empty.constructor;
-          delete empty.hasOwnProperty;
-          delete empty.propertyIsEnumerable;
-          delete empty.isPrototypeOf;
-          delete empty.toLocaleString;
-          delete empty.toString;
-          delete empty.valueOf;
-
-          function Empty() {}
-          Empty.prototype = empty;
-          // short-circuit future calls
-          createEmpty = function () {
-            return new Empty();
-          };
-          return new Empty();
-        };
+        return utils.makeArray(baseValue).concat(value);
       }
+    } else {
+      return utils.makeArray(value);
+    }
+  }
 
-      create = Object.create = function create(prototype, properties) {
+  function applyMergedProperties(obj, key, value, values) {
+    var baseValue = values[key] || obj[key];
 
-        var object;
-        function Type() {}  // An empty constructor.
+    Ember['default'].assert("You passed in `" + JSON.stringify(value) + "` as the value for `" + key +
+                 "` but `" + key + "` cannot be an Array", !utils.isArray(value));
 
-        if (prototype === null) {
-          object = createEmpty();
-        } else {
-          if (typeof prototype !== "object" && typeof prototype !== "function") {
-            // In the native implementation `parent` can be `null`
-            // OR *any* `instanceof Object`  (Object|Function|Array|RegExp|etc)
-            // Use `typeof` tho, b/c in old IE, DOM elements are not `instanceof Object`
-            // like they are in modern browsers. Using `Object.create` on DOM elements
-            // is...err...probably inappropriate, but the native version allows for it.
-            throw new TypeError("Object prototype may only be an Object or null"); // same msg as Chrome
-          }
+    if (!baseValue) { return value; }
 
-          Type.prototype = prototype;
+    var newBase = merge['default']({}, baseValue);
+    var hasFunction = false;
 
-          object = new Type();
-        }
+    for (var prop in value) {
+      if (!value.hasOwnProperty(prop)) { continue; }
 
-        if (properties !== undefined) {
-          defineProperties(object, properties);
-        }
+      var propValue = value[prop];
+      if (isMethod(propValue)) {
+        // TODO: support for Computed Properties, etc?
+        hasFunction = true;
+        newBase[prop] = giveMethodSuper(obj, prop, propValue, baseValue, {});
+      } else {
+        newBase[prop] = propValue;
+      }
+    }
 
-        return object;
-      };
-    } else {
-      create = Object.create;
+    if (hasFunction) {
+      newBase._super = superFunction;
     }
 
-    __exports__["default"] = create;
-  });
-enifed("ember-metal/platform/define_properties",
-  ["ember-metal/platform/define_property","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var defineProperty = __dependency1__.defineProperty;
+    return newBase;
+  }
 
-    var defineProperties = Object.defineProperties;
+  function addNormalizedProperty(base, key, value, meta, descs, values, concats, mergings) {
+    if (value instanceof properties.Descriptor) {
+      if (value === REQUIRED && descs[key]) { return CONTINUE; }
 
-    // ES5 15.2.3.7
-    // http://es5.github.com/#x15.2.3.7
-    if (!defineProperties) {
-      defineProperties = function defineProperties(object, properties) {
-        for (var property in properties) {
-          if (properties.hasOwnProperty(property) && property !== "__proto__") {
-            defineProperty(object, property, properties[property]);
-          }
-        }
-        return object;
-      };
+      // Wrap descriptor function to implement
+      // __nextSuper() if needed
+      if (value._getter) {
+        value = giveDescriptorSuper(meta, key, value, values, descs, base);
+      }
 
-      Object.defineProperties = defineProperties;
-    }
+      descs[key]  = value;
+      values[key] = undefined;
+    } else {
+      if ((concats && array.indexOf.call(concats, key) >= 0) ||
+                  key === 'concatenatedProperties' ||
+                  key === 'mergedProperties') {
+        value = applyConcatenatedProperties(base, key, value, values);
+      } else if ((mergings && array.indexOf.call(mergings, key) >= 0)) {
+        value = applyMergedProperties(base, key, value, values);
+      } else if (isMethod(value)) {
+        value = giveMethodSuper(base, key, value, values, descs);
+      }
 
-    __exports__["default"] = defineProperties;
-  });
-enifed("ember-metal/platform/define_property",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /*globals Node */
+      descs[key] = undefined;
+      values[key] = value;
+    }
+  }
 
-    /**
-    @class platform
-    @namespace Ember
-    @static
-    */
+  function mergeMixins(mixins, m, descs, values, base, keys) {
+    var currentMixin, props, key, concats, mergings, meta;
 
-    /**
-      Set to true if the platform supports native getters and setters.
+    function removeKeys(keyName) {
+      delete descs[keyName];
+      delete values[keyName];
+    }
 
-      @property hasPropertyAccessors
-      @final
-    */
+    for (var i=0, l=mixins.length; i<l; i++) {
+      currentMixin = mixins[i];
+      Ember['default'].assert('Expected hash or Mixin instance, got ' + Object.prototype.toString.call(currentMixin),
+                   typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]');
 
-    /**
-      Identical to `Object.defineProperty()`. Implements as much functionality
-      as possible if not available natively.
+      props = mixinProperties(m, currentMixin);
+      if (props === CONTINUE) { continue; }
 
-      @method defineProperty
-      @param {Object} obj The object to modify
-      @param {String} keyName property name to modify
-      @param {Object} desc descriptor hash
-      @return {void}
-    */
-    var defineProperty = (function checkCompliance(defineProperty) {
-      if (!defineProperty) return;
-      try {
-        var a = 5;
-        var obj = {};
-        defineProperty(obj, 'a', {
-          configurable: true,
-          enumerable: true,
-          get: function () {
-            return a;
-          },
-          set: function (v) {
-            a = v;
-          }
-        });
-        if (obj.a !== 5) return;
-        obj.a = 10;
-        if (a !== 10) return;
+      if (props) {
+        meta = utils.meta(base);
+        if (base.willMergeMixin) { base.willMergeMixin(props); }
+        concats = concatenatedMixinProperties('concatenatedProperties', props, values, base);
+        mergings = concatenatedMixinProperties('mergedProperties', props, values, base);
 
-        // check non-enumerability
-        defineProperty(obj, 'a', {
-          configurable: true,
-          enumerable: false,
-          writable: true,
-          value: true
-        });
-        for (var key in obj) {
-          if (key === 'a') return;
+        for (key in props) {
+          if (!props.hasOwnProperty(key)) { continue; }
+          keys.push(key);
+          addNormalizedProperty(base, key, props[key], meta, descs, values, concats, mergings);
         }
 
-        // Detects a bug in Android <3.2 where you cannot redefine a property using
-        // Object.defineProperty once accessors have already been set.
-        if (obj.a !== true) return;
+        // manually copy toString() because some JS engines do not enumerate it
+        if (props.hasOwnProperty('toString')) { base.toString = props.toString; }
+      } else if (currentMixin.mixins) {
+        mergeMixins(currentMixin.mixins, m, descs, values, base, keys);
+        if (currentMixin._without) { array.forEach.call(currentMixin._without, removeKeys); }
+      }
+    }
+  }
 
-        // Detects a bug in Android <3 where redefining a property without a value changes the value
-        // Object.defineProperty once accessors have already been set.
-        defineProperty(obj, 'a', {
-          enumerable: false
-        });
-        if (obj.a !== true) return;
+  var IS_BINDING = /^.+Binding$/;
 
-        // defineProperty is compliant
-        return defineProperty;
-      } catch (e) {
-        // IE8 defines Object.defineProperty but calling it on an Object throws
-        return;
+  function detectBinding(obj, key, value, m) {
+    if (IS_BINDING.test(key)) {
+      var bindings = m.bindings;
+      if (!bindings) {
+        bindings = m.bindings = {};
+      } else if (!m.hasOwnProperty('bindings')) {
+        bindings = m.bindings = o_create['default'](m.bindings);
       }
-    })(Object.defineProperty);
+      bindings[key] = value;
+    }
+  }
 
-    var hasES5CompliantDefineProperty = !!defineProperty;
+  function connectStreamBinding(obj, key, stream) {
+    var onNotify = function(stream) {
+      ember_metal__observer._suspendObserver(obj, key, null, didChange, function() {
+        property_set.trySet(obj, key, stream.value());
+      });
+    };
 
-    if (hasES5CompliantDefineProperty && typeof document !== 'undefined') {
-      // This is for Safari 5.0, which supports Object.defineProperty, but not
-      // on DOM nodes.
-      var canDefinePropertyOnDOM = (function() {
-        try {
-          defineProperty(document.createElement('div'), 'definePropertyOnDOM', {});
-          return true;
-        } catch(e) { }
+    var didChange = function() {
+      stream.setValue(property_get.get(obj, key), onNotify);
+    };
 
-        return false;
-      })();
+    // Initialize value
+    property_set.set(obj, key, stream.value());
 
-      if (!canDefinePropertyOnDOM) {
-        defineProperty = function(obj, keyName, desc) {
-          var isNode;
+    ember_metal__observer.addObserver(obj, key, null, didChange);
 
-          if (typeof Node === "object") {
-            isNode = obj instanceof Node;
-          } else {
-            isNode = typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string";
-          }
+    stream.subscribe(onNotify);
 
-          if (isNode) {
-            // TODO: Should we have a warning here?
-            return (obj[keyName] = desc.value);
-          } else {
-            return Object.defineProperty(obj, keyName, desc);
+    if (obj._streamBindingSubscriptions === undefined) {
+      obj._streamBindingSubscriptions = o_create['default'](null);
+    }
+
+    obj._streamBindingSubscriptions[key] = onNotify;
+  }
+
+  function connectBindings(obj, m) {
+    // TODO Mixin.apply(instance) should disconnect binding if exists
+    var bindings = m.bindings;
+    var key, binding, to;
+    if (bindings) {
+      for (key in bindings) {
+        binding = bindings[key];
+        if (binding) {
+          to = key.slice(0, -7); // strip Binding off end
+          if (streams__utils.isStream(binding)) {
+            connectStreamBinding(obj, to, binding);
+            continue;
+          } else if (binding instanceof ember_metal__binding.Binding) {
+            binding = binding.copy(); // copy prototypes' instance
+            binding.to(to);
+          } else { // binding is string path
+            binding = new ember_metal__binding.Binding(to, binding);
           }
-        };
+          binding.connect(obj);
+          obj[key] = binding;
+        }
       }
+      // mark as applied
+      m.bindings = {};
     }
+  }
 
-    if (!hasES5CompliantDefineProperty) {
-      defineProperty = function defineProperty(obj, keyName, desc) {
-        if (!desc.get) { obj[keyName] = desc.value; }
-      };
+  function finishPartial(obj, m) {
+    connectBindings(obj, m || utils.meta(obj));
+    return obj;
+  }
+
+  function followAlias(obj, desc, m, descs, values) {
+    var altKey = desc.methodName;
+    var value;
+    var possibleDesc;
+    if (descs[altKey] || values[altKey]) {
+      value = values[altKey];
+      desc  = descs[altKey];
+    } else if ((possibleDesc = obj[altKey]) && possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) {
+      desc  = possibleDesc;
+      value = undefined;
+    } else {
+      desc = undefined;
+      value = obj[altKey];
     }
 
-    __exports__.hasES5CompliantDefineProperty = hasES5CompliantDefineProperty;
-    __exports__.defineProperty = defineProperty;
-  });
-enifed("ember-metal/properties",
-  ["ember-metal/core","ember-metal/utils","ember-metal/platform","ember-metal/property_events","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    /**
-    @module ember-metal
-    */
+    return { desc: desc, value: value };
+  }
 
-    var Ember = __dependency1__["default"];
-    var metaFor = __dependency2__.meta;
-    var objectDefineProperty = __dependency3__.defineProperty;
-    var hasPropertyAccessors = __dependency3__.hasPropertyAccessors;
-    var overrideChains = __dependency4__.overrideChains;
-    // ..........................................................
-    // DESCRIPTOR
-    //
+  function updateObserversAndListeners(obj, key, observerOrListener, pathsKey, updateMethod) {
+    var paths = observerOrListener[pathsKey];
 
-    /**
-      Objects of this type can implement an interface to respond to requests to
-      get and set. The default implementation handles simple properties.
+    if (paths) {
+      for (var i=0, l=paths.length; i<l; i++) {
+        updateMethod(obj, paths[i], null, key);
+      }
+    }
+  }
 
-      You generally won't need to create or subclass this directly.
+  function replaceObserversAndListeners(obj, key, observerOrListener) {
+    var prev = obj[key];
 
-      @class Descriptor
-      @namespace Ember
-      @private
-      @constructor
-    */
-    function Descriptor() {}
+    if ('function' === typeof prev) {
+      updateObserversAndListeners(obj, key, prev, '__ember_observesBefore__', ember_metal__observer.removeBeforeObserver);
+      updateObserversAndListeners(obj, key, prev, '__ember_observes__', ember_metal__observer.removeObserver);
+      updateObserversAndListeners(obj, key, prev, '__ember_listens__', events.removeListener);
+    }
+
+    if ('function' === typeof observerOrListener) {
+      updateObserversAndListeners(obj, key, observerOrListener, '__ember_observesBefore__', ember_metal__observer.addBeforeObserver);
+      updateObserversAndListeners(obj, key, observerOrListener, '__ember_observes__', ember_metal__observer.addObserver);
+      updateObserversAndListeners(obj, key, observerOrListener, '__ember_listens__', events.addListener);
+    }
+  }
 
-    __exports__.Descriptor = Descriptor;// ..........................................................
-    // DEFINING PROPERTIES API
+  function applyMixin(obj, mixins, partial) {
+    var descs = {};
+    var values = {};
+    var m = utils.meta(obj);
+    var keys = [];
+    var key, value, desc;
+
+    obj._super = superFunction;
+
+    // Go through all mixins and hashes passed in, and:
     //
+    // * Handle concatenated properties
+    // * Handle merged properties
+    // * Set up _super wrapping if necessary
+    // * Set up computed property descriptors
+    // * Copying `toString` in broken browsers
+    mergeMixins(mixins, mixinsMeta(obj), descs, values, obj, keys);
 
-    function MANDATORY_SETTER_FUNCTION(name) {
-      return function SETTER_FUNCTION(value) {
-        Ember.assert("You must use Ember.set() to set the `" + name + "` property (of " + this + ") to `" + value + "`.", false);
-      };
+    for (var i = 0, l = keys.length; i < l; i++) {
+      key = keys[i];
+      if (key === 'constructor' || !values.hasOwnProperty(key)) { continue; }
+
+      desc = descs[key];
+      value = values[key];
+
+      if (desc === REQUIRED) { continue; }
+
+      while (desc && desc instanceof Alias) {
+        var followed = followAlias(obj, desc, m, descs, values);
+        desc = followed.desc;
+        value = followed.value;
+      }
+
+      if (desc === undefined && value === undefined) { continue; }
+
+      replaceObserversAndListeners(obj, key, value);
+      detectBinding(obj, key, value, m);
+      properties.defineProperty(obj, key, desc, value, m);
     }
 
-    __exports__.MANDATORY_SETTER_FUNCTION = MANDATORY_SETTER_FUNCTION;function DEFAULT_GETTER_FUNCTION(name) {
-      return function GETTER_FUNCTION() {
-        var meta = this['__ember_meta__'];
-        return meta && meta.values[name];
-      };
+    if (!partial) { // don't apply to prototype
+      finishPartial(obj, m);
     }
 
-    __exports__.DEFAULT_GETTER_FUNCTION = DEFAULT_GETTER_FUNCTION;/**
-      NOTE: This is a low-level method used by other parts of the API. You almost
-      never want to call this method directly. Instead you should use
-      `Ember.mixin()` to define new properties.
+    return obj;
+  }
 
-      Defines a property on an object. This method works much like the ES5
-      `Object.defineProperty()` method except that it can also accept computed
-      properties and other special descriptors.
+  /**
+    @method mixin
+    @for Ember
+    @param obj
+    @param mixins*
+    @return obj
+  */
+  function mixin(obj) {
+    var args = a_slice.call(arguments, 1);
+    applyMixin(obj, args, false);
+    return obj;
+  }
 
-      Normally this method takes only three parameters. However if you pass an
-      instance of `Ember.Descriptor` as the third param then you can pass an
-      optional value as the fourth parameter. This is often more efficient than
-      creating new descriptor hashes for each property.
+  /**
+    The `Ember.Mixin` class allows you to create mixins, whose properties can be
+    added to other classes. For instance,
 
-      ## Examples
+    ```javascript
+    App.Editable = Ember.Mixin.create({
+      edit: function() {
+        console.log('starting to edit');
+        this.set('isEditing', true);
+      },
+      isEditing: false
+    });
 
-      ```javascript
-      // ES5 compatible mode
-      Ember.defineProperty(contact, 'firstName', {
-        writable: true,
-        configurable: false,
-        enumerable: true,
-        value: 'Charles'
-      });
+    // Mix mixins into classes by passing them as the first arguments to
+    // .extend.
+    App.CommentView = Ember.View.extend(App.Editable, {
+      template: Ember.Handlebars.compile('{{#if view.isEditing}}...{{else}}...{{/if}}')
+    });
 
-      // define a simple property
-      Ember.defineProperty(contact, 'lastName', undefined, 'Jolley');
+    commentView = App.CommentView.create();
+    commentView.edit(); // outputs 'starting to edit'
+    ```
 
-      // define a computed property
-      Ember.defineProperty(contact, 'fullName', Ember.computed(function() {
-        return this.firstName+' '+this.lastName;
-      }).property('firstName', 'lastName'));
-      ```
+    Note that Mixins are created with `Ember.Mixin.create`, not
+    `Ember.Mixin.extend`.
 
-      @private
-      @method defineProperty
-      @for Ember
-      @param {Object} obj the object to define this property on. This may be a prototype.
-      @param {String} keyName the name of the property
-      @param {Ember.Descriptor} [desc] an instance of `Ember.Descriptor` (typically a
-        computed property) or an ES5 descriptor.
-        You must provide this or `data` but not both.
-      @param {*} [data] something other than a descriptor, that will
-        become the explicit value of this property.
-    */
-    function defineProperty(obj, keyName, desc, data, meta) {
-      var descs, existingDesc, watching, value;
+    Note that mixins extend a constructor's prototype so arrays and object literals
+    defined as properties will be shared amongst objects that implement the mixin.
+    If you want to define a property in a mixin that is not shared, you can define
+    it either as a computed property or have it be created on initialization of the object.
 
-      if (!meta) meta = metaFor(obj);
-      descs = meta.descs;
-      existingDesc = meta.descs[keyName];
-      var watchEntry = meta.watching[keyName];
+    ```javascript
+    //filters array will be shared amongst any object implementing mixin
+    App.Filterable = Ember.Mixin.create({
+      filters: Ember.A()
+    });
 
-      watching = watchEntry !== undefined && watchEntry > 0;
+    //filters will be a separate  array for every object implementing the mixin
+    App.Filterable = Ember.Mixin.create({
+      filters: Ember.computed(function() {return Ember.A();})
+    });
 
-      if (existingDesc instanceof Descriptor) {
-        existingDesc.teardown(obj, keyName);
+    //filters will be created as a separate array during the object's initialization
+    App.Filterable = Ember.Mixin.create({
+      init: function() {
+        this._super.apply(this, arguments);
+        this.set("filters", Ember.A());
       }
+    });
+    ```
 
-      if (desc instanceof Descriptor) {
-        value = desc;
+    @class Mixin
+    @namespace Ember
+  */
+  exports['default'] = Mixin;
+  function Mixin(args, properties) {
+    this.properties = properties;
 
-        descs[keyName] = desc;
-        
-          if (watching && hasPropertyAccessors) {
-            objectDefineProperty(obj, keyName, {
-              configurable: true,
-              enumerable: true,
-              writable: true,
-              value: undefined // make enumerable
-            });
-          } else {
-            obj[keyName] = undefined; // make enumerable
-          }
-                if (desc.setup) { desc.setup(obj, keyName); }
-      } else {
-        descs[keyName] = undefined; // shadow descriptor in proto
-        if (desc == null) {
-          value = data;
-
-          
-            if (watching && hasPropertyAccessors) {
-              meta.values[keyName] = data;
-              objectDefineProperty(obj, keyName, {
-                configurable: true,
-                enumerable: true,
-                set: MANDATORY_SETTER_FUNCTION(keyName),
-                get: DEFAULT_GETTER_FUNCTION(keyName)
-              });
-            } else {
-              obj[keyName] = data;
-            }
-                  } else {
-          value = desc;
+    var length = args && args.length;
+
+    if (length > 0) {
+      var m = new Array(length);
 
-          // compatibility with ES5
-          objectDefineProperty(obj, keyName, desc);
+      for (var i = 0; i < length; i++) {
+        var x = args[i];
+        if (x instanceof Mixin) {
+          m[i] = x;
+        } else {
+          m[i] = new Mixin(undefined, x);
         }
       }
 
-      // if key is being watched, override chains that
-      // were initialized with the prototype
-      if (watching) { overrideChains(obj, keyName, meta); }
+      this.mixins = m;
+    } else {
+      this.mixins = undefined;
+    }
+    this.ownerConstructor = undefined;
+  }
+
+  Mixin._apply = applyMixin;
 
-      // The `value` passed to the `didDefineProperty` hook is
-      // either the descriptor or data, whichever was passed.
-      if (obj.didDefineProperty) { obj.didDefineProperty(obj, keyName, value); }
+  Mixin.applyPartial = function(obj) {
+    var args = a_slice.call(arguments, 1);
+    return applyMixin(obj, args, true);
+  };
 
-      return this;
+  Mixin.finishPartial = finishPartial;
+
+  // ES6TODO: this relies on a global state?
+  Ember['default'].anyUnprocessedMixins = false;
+
+  /**
+    @method create
+    @static
+    @param arguments*
+  */
+  Mixin.create = function() {
+    // ES6TODO: this relies on a global state?
+    Ember['default'].anyUnprocessedMixins = true;
+    var M = this;
+    var length = arguments.length;
+    var args = new Array(length);
+    for (var i = 0; i < length; i++) {
+      args[i] = arguments[i];
+    }
+    return new M(args, undefined);
+  };
+
+  var MixinPrototype = Mixin.prototype;
+
+  /**
+    @method reopen
+    @param arguments*
+  */
+  MixinPrototype.reopen = function() {
+    var currentMixin;
+
+    if (this.properties) {
+      currentMixin = new Mixin(undefined, this.properties);
+      this.properties = undefined;
+      this.mixins = [currentMixin];
+    } else if (!this.mixins) {
+      this.mixins = [];
+    }
+
+    var len = arguments.length;
+    var mixins = this.mixins;
+    var idx;
+
+    for (idx=0; idx < len; idx++) {
+      currentMixin = arguments[idx];
+      Ember['default'].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);
+      } else {
+        mixins.push(new Mixin(undefined, currentMixin));
+      }
     }
 
-    __exports__.defineProperty = defineProperty;
-  });
-enifed("ember-metal/property_events",
-  ["ember-metal/utils","ember-metal/events","ember-metal/observer_set","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var guidFor = __dependency1__.guidFor;
-    var tryFinally = __dependency1__.tryFinally;
-    var sendEvent = __dependency2__.sendEvent;
-    var accumulateListeners = __dependency2__.accumulateListeners;
-    var ObserverSet = __dependency3__["default"];
+    return this;
+  };
 
-    var beforeObserverSet = new ObserverSet();
-    var observerSet = new ObserverSet();
-    var deferred = 0;
+  /**
+    @method apply
+    @param obj
+    @return applied object
+  */
+  MixinPrototype.apply = function(obj) {
+    return applyMixin(obj, [this], false);
+  };
 
-    // ..........................................................
-    // PROPERTY CHANGES
-    //
+  MixinPrototype.applyPartial = function(obj) {
+    return applyMixin(obj, [this], true);
+  };
 
-    /**
-      This function is called just before an object property is about to change.
-      It will notify any before observers and prepare caches among other things.
+  function _detect(curMixin, targetMixin, seen) {
+    var guid = utils.guidFor(curMixin);
 
-      Normally you will not need to call this method directly but if for some
-      reason you can't directly watch a property you can invoke this method
-      manually along with `Ember.propertyDidChange()` which you should call just
-      after the property value changes.
+    if (seen[guid]) { return false; }
+    seen[guid] = true;
 
-      @method propertyWillChange
-      @for Ember
-      @param {Object} obj The object with the property that will change
-      @param {String} keyName The property key (or path) that will change.
-      @return {void}
-    */
-    function propertyWillChange(obj, keyName) {
-      var m = obj['__ember_meta__'];
-      var watching = (m && m.watching[keyName] > 0) || keyName === 'length';
-      var proto = m && m.proto;
-      var desc = m && m.descs[keyName];
+    if (curMixin === targetMixin) { return true; }
+    var mixins = curMixin.mixins;
+    var loc = mixins ? mixins.length : 0;
+    while (--loc >= 0) {
+      if (_detect(mixins[loc], targetMixin, seen)) { return true; }
+    }
+    return false;
+  }
 
-      if (!watching) {
-        return;
-      }
+  /**
+    @method detect
+    @param obj
+    @return {Boolean}
+  */
+  MixinPrototype.detect = function(obj) {
+    if (!obj) { return false; }
+    if (obj instanceof Mixin) { return _detect(obj, this, {}); }
+    var m = obj['__ember_meta__'];
+    var mixins = m && m.mixins;
+    if (mixins) {
+      return !!mixins[utils.guidFor(this)];
+    }
+    return false;
+  };
+
+  MixinPrototype.without = function() {
+    var ret = new Mixin([this]);
+    ret._without = a_slice.call(arguments);
+    return ret;
+  };
+
+  function _keys(ret, mixin, seen) {
+    if (seen[utils.guidFor(mixin)]) { return; }
+    seen[utils.guidFor(mixin)] = true;
+
+    if (mixin.properties) {
+      var props = mixin.properties;
+      for (var key in props) {
+        if (props.hasOwnProperty(key)) { ret[key] = true; }
+      }
+    } else if (mixin.mixins) {
+      array.forEach.call(mixin.mixins, function(x) { _keys(ret, x, seen); });
+    }
+  }
 
-      if (proto === obj) {
-        return;
+  MixinPrototype.keys = function() {
+    var keys = {};
+    var seen = {};
+    var ret = [];
+    _keys(keys, this, seen);
+    for (var key in keys) {
+      if (keys.hasOwnProperty(key)) {
+        ret.push(key);
       }
+    }
+    return ret;
+  };
 
-      if (desc && desc.willChange) {
-        desc.willChange(obj, keyName);
-      }
+  // returns the mixins currently applied to the specified object
+  // TODO: Make Ember.mixin
+  Mixin.mixins = function(obj) {
+    var m = obj['__ember_meta__'];
+    var mixins = m && m.mixins;
+    var ret = [];
+
+    if (!mixins) { return ret; }
+
+    for (var key in mixins) {
+      var currentMixin = mixins[key];
 
-      dependentKeysWillChange(obj, keyName, m);
-      chainsWillChange(obj, keyName, m);
-      notifyBeforeObservers(obj, keyName);
+      // skip primitive mixins since these are always anonymous
+      if (!currentMixin.properties) { ret.push(currentMixin); }
     }
 
-    /**
-      This function is called just after an object property has changed.
-      It will notify any observers and clear caches among other things.
+    return ret;
+  };
 
-      Normally you will not need to call this method directly but if for some
-      reason you can't directly watch a property you can invoke this method
-      manually along with `Ember.propertyWillChange()` which you should call just
-      before the property value changes.
+  REQUIRED = new properties.Descriptor();
+  REQUIRED.toString = function() { return '(Required Property)'; };
 
-      @method propertyDidChange
-      @for Ember
-      @param {Object} obj The object with the property that will change
-      @param {String} keyName The property key (or path) that will change.
-      @return {void}
-    */
-    function propertyDidChange(obj, keyName) {
-      var m = obj['__ember_meta__'];
-      var watching = (m && m.watching[keyName] > 0) || keyName === 'length';
-      var proto = m && m.proto;
-      var desc = m && m.descs[keyName];
+  /**
+    Denotes a required property for a mixin
 
-      if (proto === obj) {
-        return;
-      }
+    @method required
+    @for Ember
+  */
+  function required() {
+    return REQUIRED;
+  }
 
-      // shouldn't this mean that we're watching this key?
-      if (desc && desc.didChange) {
-        desc.didChange(obj, keyName);
-      }
+  function Alias(methodName) {
+    this.isDescriptor = true;
+    this.methodName = methodName;
+  }
 
-      if (!watching && keyName !== 'length') {
-        return;
-      }
+  Alias.prototype = new properties.Descriptor();
 
-      if (m && m.deps && m.deps[keyName]) {
-        dependentKeysDidChange(obj, keyName, m);
-      }
+  /**
+    Makes a method available via an additional name.
 
-      chainsDidChange(obj, keyName, m, false);
-      notifyObservers(obj, keyName);
-    }
+    ```javascript
+    App.Person = Ember.Object.extend({
+      name: function() {
+        return 'Tomhuda Katzdale';
+      },
+      moniker: Ember.aliasMethod('name')
+    });
 
-    var WILL_SEEN, DID_SEEN;
-    // called whenever a property is about to change to clear the cache of any dependent keys (and notify those properties of changes, etc...)
-    function dependentKeysWillChange(obj, depKey, meta) {
-      if (obj.isDestroying) { return; }
+    var goodGuy = App.Person.create();
 
-      var deps;
-      if (meta && meta.deps && (deps = meta.deps[depKey])) {
-        var seen = WILL_SEEN;
-        var top = !seen;
+    goodGuy.name();    // 'Tomhuda Katzdale'
+    goodGuy.moniker(); // 'Tomhuda Katzdale'
+    ```
 
-        if (top) {
-          seen = WILL_SEEN = {};
-        }
+    @method aliasMethod
+    @for Ember
+    @param {String} methodName name of the method to alias
+    @return {Ember.Descriptor}
+  */
+  function aliasMethod(methodName) {
+    return new Alias(methodName);
+  }
 
-        iterDeps(propertyWillChange, obj, deps, depKey, seen, meta);
+  // ..........................................................
+  // OBSERVER HELPER
+  //
 
-        if (top) {
-          WILL_SEEN = null;
-        }
-      }
-    }
+  /**
+    Specify a method that observes property changes.
 
-    // called whenever a property has just changed to update dependent keys
-    function dependentKeysDidChange(obj, depKey, meta) {
-      if (obj.isDestroying) { return; }
+    ```javascript
+    Ember.Object.extend({
+      valueObserver: Ember.observer('value', function() {
+        // Executes whenever the "value" property changes
+      })
+    });
+    ```
 
-      var deps;
-      if (meta && meta.deps && (deps = meta.deps[depKey])) {
-        var seen = DID_SEEN;
-        var top = !seen;
+    In the future this method may become asynchronous. If you want to ensure
+    synchronous behavior, use `immediateObserver`.
 
-        if (top) {
-          seen = DID_SEEN = {};
-        }
+    Also available as `Function.prototype.observes` if prototype extensions are
+    enabled.
 
-        iterDeps(propertyDidChange, obj, deps, depKey, seen, meta);
+    @method observer
+    @for Ember
+    @param {String} propertyNames*
+    @param {Function} func
+    @return func
+  */
+  function observer() {
+    var func  = a_slice.call(arguments, -1)[0];
+    var paths;
 
-        if (top) {
-          DID_SEEN = null;
-        }
-      }
-    }
+    var addWatchedProperty = function (path) { paths.push(path); };
+    var _paths = a_slice.call(arguments, 0, -1);
 
-    function keysOf(obj) {
-      var keys = [];
+    if (typeof func !== "function") {
+      // revert to old, soft-deprecated argument ordering
 
-      for (var key in obj) {
-        keys.push(key);
-      }
+      func  = arguments[0];
+      _paths = a_slice.call(arguments, 1);
+    }
+
+    paths = [];
 
-      return keys;
+    for (var i=0; i<_paths.length; ++i) {
+      expandProperties['default'](_paths[i], addWatchedProperty);
     }
 
-    function iterDeps(method, obj, deps, depKey, seen, meta) {
-      var keys, key, i, desc;
-      var guid = guidFor(obj);
-      var current = seen[guid];
+    if (typeof func !== "function") {
+      throw new Ember['default'].Error("Ember.observer called without a function");
+    }
 
-      if (!current) {
-        current = seen[guid] = {};
-      }
+    func.__ember_observes__ = paths;
+    return func;
+  }
 
-      if (current[depKey]) {
-        return;
-      }
+  /**
+    Specify a method that observes property changes.
 
-      current[depKey] = true;
+    ```javascript
+    Ember.Object.extend({
+      valueObserver: Ember.immediateObserver('value', function() {
+        // Executes whenever the "value" property changes
+      })
+    });
+    ```
 
-      if (deps) {
-        keys = keysOf(deps);
-        var descs = meta.descs;
-        for (i=0; i<keys.length; i++) {
-          key = keys[i];
-          desc = descs[key];
+    In the future, `Ember.observer` may become asynchronous. In this event,
+    `Ember.immediateObserver` will maintain the synchronous behavior.
 
-          if (desc && desc._suspended === obj) {
-            continue;
-          }
+    Also available as `Function.prototype.observesImmediately` if prototype extensions are
+    enabled.
 
-          method(obj, key);
-        }
-      }
+    @method immediateObserver
+    @for Ember
+    @param {String} propertyNames*
+    @param {Function} func
+    @return func
+  */
+  function immediateObserver() {
+    for (var i=0, l=arguments.length; i<l; i++) {
+      var arg = arguments[i];
+      Ember['default'].assert("Immediate observers must observe internal properties only, not properties on other objects.",
+                   typeof arg !== "string" || arg.indexOf('.') === -1);
     }
 
-    function chainsWillChange(obj, keyName, m) {
-      if (!(m.hasOwnProperty('chainWatchers') &&
-            m.chainWatchers[keyName])) {
-        return;
-      }
+    return observer.apply(this, arguments);
+  }
 
-      var nodes = m.chainWatchers[keyName];
-      var events = [];
-      var i, l;
+  /**
+    When observers fire, they are called with the arguments `obj`, `keyName`.
 
-      for(i = 0, l = nodes.length; i < l; i++) {
-        nodes[i].willChange(events);
-      }
+    Note, `@each.property` observer is called per each add or replace of an element
+    and it's not called with a specific enumeration item.
 
-      for (i = 0, l = events.length; i < l; i += 2) {
-        propertyWillChange(events[i], events[i+1]);
-      }
-    }
+    A `beforeObserver` fires before a property changes.
 
-    function chainsDidChange(obj, keyName, m, suppressEvents) {
-      if (!(m && m.hasOwnProperty('chainWatchers') &&
-            m.chainWatchers[keyName])) {
-        return;
-      }
+    A `beforeObserver` is an alternative form of `.observesBefore()`.
 
-      var nodes = m.chainWatchers[keyName];
-      var events = suppressEvents ? null : [];
-      var i, l;
+    ```javascript
+    App.PersonView = Ember.View.extend({
+      friends: [{ name: 'Tom' }, { name: 'Stefan' }, { name: 'Kris' }],
 
-      for(i = 0, l = nodes.length; i < l; i++) {
-        nodes[i].didChange(events);
-      }
+      valueWillChange: Ember.beforeObserver('content.value', function(obj, keyName) {
+        this.changingFrom = obj.get(keyName);
+      }),
 
-      if (suppressEvents) {
-        return;
-      }
+      valueDidChange: Ember.observer('content.value', function(obj, keyName) {
+          // only run if updating a value already in the DOM
+          if (this.get('state') === 'inDOM') {
+            var color = obj.get(keyName) > this.changingFrom ? 'green' : 'red';
+            // logic
+          }
+      }),
 
-      for (i = 0, l = events.length; i < l; i += 2) {
-        propertyDidChange(events[i], events[i+1]);
-      }
-    }
+      friendsDidChange: Ember.observer('friends.@each.name', function(obj, keyName) {
+        // some logic
+        // obj.get(keyName) returns friends array
+      })
+    });
+    ```
 
-    function overrideChains(obj, keyName, m) {
-      chainsDidChange(obj, keyName, m, true);
-    }
+    Also available as `Function.prototype.observesBefore` if prototype extensions are
+    enabled.
 
-    /**
-      @method beginPropertyChanges
-      @chainable
-      @private
-    */
-    function beginPropertyChanges() {
-      deferred++;
-    }
+    @method beforeObserver
+    @for Ember
+    @param {String} propertyNames*
+    @param {Function} func
+    @return func
+  */
+  function beforeObserver() {
+    var func  = a_slice.call(arguments, -1)[0];
+    var paths;
 
-    /**
-      @method endPropertyChanges
-      @private
-    */
-    function endPropertyChanges() {
-      deferred--;
-      if (deferred<=0) {
-        beforeObserverSet.clear();
-        observerSet.flush();
-      }
-    }
+    var addWatchedProperty = function(path) { paths.push(path); };
 
-    /**
-      Make a series of property changes together in an
-      exception-safe way.
+    var _paths = a_slice.call(arguments, 0, -1);
 
-      ```javascript
-      Ember.changeProperties(function() {
-        obj1.set('foo', mayBlowUpWhenSet);
-        obj2.set('bar', baz);
-      });
-      ```
+    if (typeof func !== "function") {
+      // revert to old, soft-deprecated argument ordering
 
-      @method changeProperties
-      @param {Function} callback
-      @param [binding]
-    */
-    function changeProperties(callback, binding) {
-      beginPropertyChanges();
-      tryFinally(callback, endPropertyChanges, binding);
+      func  = arguments[0];
+      _paths = a_slice.call(arguments, 1);
     }
 
-    function notifyBeforeObservers(obj, keyName) {
-      if (obj.isDestroying) { return; }
+    paths = [];
 
-      var eventName = keyName + ':before';
-      var listeners, added;
-      if (deferred) {
-        listeners = beforeObserverSet.add(obj, keyName, eventName);
-        added = accumulateListeners(obj, eventName, listeners);
-        sendEvent(obj, eventName, [obj, keyName], added);
-      } else {
-        sendEvent(obj, eventName, [obj, keyName]);
-      }
+    for (var i=0; i<_paths.length; ++i) {
+      expandProperties['default'](_paths[i], addWatchedProperty);
     }
 
-    function notifyObservers(obj, keyName) {
-      if (obj.isDestroying) { return; }
-
-      var eventName = keyName + ':change';
-      var listeners;
-      if (deferred) {
-        listeners = observerSet.add(obj, keyName, eventName);
-        accumulateListeners(obj, eventName, listeners);
-      } else {
-        sendEvent(obj, eventName, [obj, keyName]);
-      }
+    if (typeof func !== "function") {
+      throw new Ember['default'].Error("Ember.beforeObserver called without a function");
     }
 
-    __exports__.propertyWillChange = propertyWillChange;
-    __exports__.propertyDidChange = propertyDidChange;
-    __exports__.overrideChains = overrideChains;
-    __exports__.beginPropertyChanges = beginPropertyChanges;
-    __exports__.endPropertyChanges = endPropertyChanges;
-    __exports__.changeProperties = changeProperties;
-  });
-enifed("ember-metal/property_get",
-  ["ember-metal/core","ember-metal/error","ember-metal/path_cache","ember-metal/platform","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    /**
-    @module ember-metal
-    */
+    func.__ember_observesBefore__ = paths;
+    return func;
+  }
 
-    var Ember = __dependency1__["default"];
-    var EmberError = __dependency2__["default"];
-    var isGlobalPath = __dependency3__.isGlobalPath;
-    var isPath = __dependency3__.isPath;
-    var pathHasThis = __dependency3__.hasThis;
-    var hasPropertyAccessors = __dependency4__.hasPropertyAccessors;
+  exports.IS_BINDING = IS_BINDING;
 
-    var FIRST_KEY = /^([^\.]+)/;
+});
+enifed('ember-metal/observer', ['exports', 'ember-metal/watching', 'ember-metal/array', 'ember-metal/events'], function (exports, watching, array, ember_metal__events) {
 
-    // ..........................................................
-    // GET AND SET
-    //
-    // If we are on a platform that supports accessors we can use those.
-    // Otherwise simulate accessors by looking up the property directly on the
-    // object.
+  'use strict';
 
-    /**
-      Gets the value of a property on an object. If the property is computed,
-      the function will be invoked. If the property is not defined but the
-      object implements the `unknownProperty` method then that will be invoked.
+  exports.addObserver = addObserver;
+  exports.observersFor = observersFor;
+  exports.removeObserver = removeObserver;
+  exports.addBeforeObserver = addBeforeObserver;
+  exports._suspendBeforeObserver = _suspendBeforeObserver;
+  exports._suspendObserver = _suspendObserver;
+  exports._suspendBeforeObservers = _suspendBeforeObservers;
+  exports._suspendObservers = _suspendObservers;
+  exports.beforeObserversFor = beforeObserversFor;
+  exports.removeBeforeObserver = removeBeforeObserver;
 
-      If you plan to run on IE8 and older browsers then you should use this
-      method anytime you want to retrieve a property on an object that you don't
-      know for sure is private. (Properties beginning with an underscore '_'
-      are considered private.)
+  var AFTER_OBSERVERS = ':change';
+  var BEFORE_OBSERVERS = ':before';
 
-      On all newer browsers, you only need to use this method to retrieve
-      properties if the property might not be defined on the object and you want
-      to respect the `unknownProperty` handler. Otherwise you can ignore this
-      method.
+  function changeEvent(keyName) {
+    return keyName + AFTER_OBSERVERS;
+  }
 
-      Note that if the object itself is `undefined`, this method will throw
-      an error.
+  function beforeEvent(keyName) {
+    return keyName + BEFORE_OBSERVERS;
+  }
 
-      @method get
-      @for Ember
-      @param {Object} obj The object to retrieve from.
-      @param {String} keyName The property key to retrieve
-      @return {Object} the property value or `null`.
-    */
-    var get = function get(obj, keyName) {
-      // Helpers that operate with 'this' within an #each
-      if (keyName === '') {
-        return obj;
-      }
+  /**
+    @method addObserver
+    @for Ember
+    @param obj
+    @param {String} path
+    @param {Object|Function} targetOrMethod
+    @param {Function|String} [method]
+  */
+  function addObserver(obj, _path, target, method) {
+    ember_metal__events.addListener(obj, changeEvent(_path), target, method);
+    watching.watch(obj, _path);
+
+    return this;
+  }
 
-      if (!keyName && 'string' === typeof obj) {
-        keyName = obj;
-        obj = null;
-      }
+  function observersFor(obj, path) {
+    return ember_metal__events.listenersFor(obj, changeEvent(path));
+  }
 
-      Ember.assert("Cannot call get with "+ keyName +" key.", !!keyName);
-      Ember.assert("Cannot call get with '"+ keyName +"' on an undefined object.", obj !== undefined);
+  /**
+    @method removeObserver
+    @for Ember
+    @param obj
+    @param {String} path
+    @param {Object|Function} target
+    @param {Function|String} [method]
+  */
+  function removeObserver(obj, path, target, method) {
+    watching.unwatch(obj, path);
+    ember_metal__events.removeListener(obj, changeEvent(path), target, method);
+
+    return this;
+  }
 
-      if (obj === null) {
-        var value = _getPath(obj, keyName);
-        Ember.deprecate(
-          "Ember.get fetched '"+keyName+"' from the global context. This behavior will change in the future (issue #3852)",
-          !value || (obj && obj !== Ember.lookup) || isPath(keyName) || isGlobalPath(keyName+".") // Add a . to ensure simple paths are matched.
-        );
-        return value;
-      }
+  /**
+    @method addBeforeObserver
+    @for Ember
+    @param obj
+    @param {String} path
+    @param {Object|Function} target
+    @param {Function|String} [method]
+  */
+  function addBeforeObserver(obj, path, target, method) {
+    ember_metal__events.addListener(obj, beforeEvent(path), target, method);
+    watching.watch(obj, path);
+
+    return this;
+  }
 
-      var meta = obj['__ember_meta__'];
-      var desc = meta && meta.descs[keyName];
-      var ret;
+  // Suspend observer during callback.
+  //
+  // This should only be used by the target of the observer
+  // while it is setting the observed path.
+  function _suspendBeforeObserver(obj, path, target, method, callback) {
+    return ember_metal__events.suspendListener(obj, beforeEvent(path), target, method, callback);
+  }
 
-      if (desc === undefined && isPath(keyName)) {
-        return _getPath(obj, keyName);
-      }
+  function _suspendObserver(obj, path, target, method, callback) {
+    return ember_metal__events.suspendListener(obj, changeEvent(path), target, method, callback);
+  }
 
-      if (desc) {
-        return desc.get(obj, keyName);
-      } else {
-        
-          if (hasPropertyAccessors && meta && meta.watching[keyName] > 0) {
-            ret = meta.values[keyName];
-          } else {
-            ret = obj[keyName];
-          }
-        
-        if (ret === undefined &&
-            'object' === typeof obj && !(keyName in obj) && 'function' === typeof obj.unknownProperty) {
-          return obj.unknownProperty(keyName);
-        }
+  function _suspendBeforeObservers(obj, paths, target, method, callback) {
+    var events = array.map.call(paths, beforeEvent);
+    return ember_metal__events.suspendListeners(obj, events, target, method, callback);
+  }
 
-        return ret;
-      }
-    };
+  function _suspendObservers(obj, paths, target, method, callback) {
+    var events = array.map.call(paths, changeEvent);
+    return ember_metal__events.suspendListeners(obj, events, target, method, callback);
+  }
 
-    /**
-      Normalizes a target/path pair to reflect that actual target/path that should
-      be observed, etc. This takes into account passing in global property
-      paths (i.e. a path beginning with a capital letter not defined on the
-      target).
+  function beforeObserversFor(obj, path) {
+    return ember_metal__events.listenersFor(obj, beforeEvent(path));
+  }
 
-      @private
-      @method normalizeTuple
-      @for Ember
-      @param {Object} target The current target. May be `null`.
-      @param {String} path A path on the target or a global property path.
-      @return {Array} a temporary array with the normalized target/path pair.
-    */
-    function normalizeTuple(target, path) {
-      var hasThis  = pathHasThis(path);
-      var isGlobal = !hasThis && isGlobalPath(path);
-      var key;
+  /**
+    @method removeBeforeObserver
+    @for Ember
+    @param obj
+    @param {String} path
+    @param {Object|Function} target
+    @param {Function|String} [method]
+  */
+  function removeBeforeObserver(obj, path, target, method) {
+    watching.unwatch(obj, path);
+    ember_metal__events.removeListener(obj, beforeEvent(path), target, method);
+
+    return this;
+  }
 
-      if (!target || isGlobal) target = Ember.lookup;
-      if (hasThis) path = path.slice(5);
+});
+enifed('ember-metal/observer_set', ['exports', 'ember-metal/utils', 'ember-metal/events'], function (exports, utils, events) {
 
-      Ember.deprecate(
-        "normalizeTuple will return '"+path+"' as a non-global. This behavior will change in the future (issue #3852)",
-        target === Ember.lookup || !target || hasThis || isGlobal || !isGlobalPath(path+'.')
-      );
+  'use strict';
+
+  exports['default'] = ObserverSet;
+  function ObserverSet() {
+    this.clear();
+  }
 
-      if (target === Ember.lookup) {
-        key = path.match(FIRST_KEY)[0];
-        target = get(target, key);
-        path   = path.slice(key.length+1);
-      }
 
-      // must return some kind of path to be valid else other things will break.
-      if (!path || path.length===0) throw new EmberError('Path cannot be empty');
+  ObserverSet.prototype.add = function(sender, keyName, eventName) {
+    var observerSet = this.observerSet;
+    var observers = this.observers;
+    var senderGuid = utils.guidFor(sender);
+    var keySet = observerSet[senderGuid];
+    var index;
 
-      return [ target, path ];
+    if (!keySet) {
+      observerSet[senderGuid] = keySet = {};
     }
+    index = keySet[keyName];
+    if (index === undefined) {
+      index = observers.push({
+        sender: sender,
+        keyName: keyName,
+        eventName: eventName,
+        listeners: []
+      }) - 1;
+      keySet[keyName] = index;
+    }
+    return observers[index].listeners;
+  };
+
+  ObserverSet.prototype.flush = function() {
+    var observers = this.observers;
+    var i, len, observer, sender;
+    this.clear();
+    for (i=0, len=observers.length; i < len; ++i) {
+      observer = observers[i];
+      sender = observer.sender;
+      if (sender.isDestroying || sender.isDestroyed) { continue; }
+      events.sendEvent(sender, observer.eventName, [sender, observer.keyName], observer.listeners);
+    }
+  };
+
+  ObserverSet.prototype.clear = function() {
+    this.observerSet = {};
+    this.observers = [];
+  };
+
+});
+enifed('ember-metal/path_cache', ['exports', 'ember-metal/cache'], function (exports, Cache) {
+
+  'use strict';
+
+  exports.isGlobal = isGlobal;
+  exports.isGlobalPath = isGlobalPath;
+  exports.hasThis = hasThis;
+  exports.isPath = isPath;
+  exports.getFirstKey = getFirstKey;
+  exports.getTailPath = getTailPath;
+
+  var IS_GLOBAL      = /^([A-Z$]|([0-9][A-Z$]))/;
+  var IS_GLOBAL_PATH = /^([A-Z$]|([0-9][A-Z$])).*[\.]/;
+  var HAS_THIS       = 'this.';
+
+  var isGlobalCache       = new Cache['default'](1000, function(key) { return IS_GLOBAL.test(key);          });
+  var isGlobalPathCache   = new Cache['default'](1000, function(key) { return IS_GLOBAL_PATH.test(key);     });
+  var hasThisCache        = new Cache['default'](1000, function(key) { return key.lastIndexOf(HAS_THIS, 0) === 0; });
+  var firstDotIndexCache  = new Cache['default'](1000, function(key) { return key.indexOf('.');             });
+
+  var firstKeyCache = new Cache['default'](1000, function(path) {
+    var index = firstDotIndexCache.get(path);
+    if (index === -1) {
+      return path;
+    } else {
+      return path.slice(0, index);
+    }
+  });
 
-    function _getPath(root, path) {
-      var hasThis, parts, tuple, idx, len;
+  var tailPathCache = new Cache['default'](1000, function(path) {
+    var index = firstDotIndexCache.get(path);
+    if (index !== -1) {
+      return path.slice(index + 1);
+    }
+  });
 
-      // If there is no root and path is a key name, return that
-      // property from the global object.
-      // E.g. get('Ember') -> Ember
-      if (root === null && !isPath(path)) {
-        return get(Ember.lookup, path);
-      }
+  var caches = {
+    isGlobalCache:      isGlobalCache,
+    isGlobalPathCache:  isGlobalPathCache,
+    hasThisCache:       hasThisCache,
+    firstDotIndexCache: firstDotIndexCache,
+    firstKeyCache:      firstKeyCache,
+    tailPathCache:      tailPathCache
+  };
 
-      // detect complicated paths and normalize them
-      hasThis = pathHasThis(path);
+  function isGlobal(path) {
+    return isGlobalCache.get(path);
+  }
 
-      if (!root || hasThis) {
-        tuple = normalizeTuple(root, path);
-        root = tuple[0];
-        path = tuple[1];
-        tuple.length = 0;
-      }
+  function isGlobalPath(path) {
+    return isGlobalPathCache.get(path);
+  }
 
-      parts = path.split(".");
-      len = parts.length;
-      for (idx = 0; root != null && idx < len; idx++) {
-        root = get(root, parts[idx], true);
-        if (root && root.isDestroyed) { return undefined; }
-      }
-      return root;
-    }
+  function hasThis(path) {
+    return hasThisCache.get(path);
+  }
 
-    function getWithDefault(root, key, defaultValue) {
-      var value = get(root, key);
+  function isPath(path) {
+    return firstDotIndexCache.get(path) !== -1;
+  }
 
-      if (value === undefined) { return defaultValue; }
-      return value;
-    }
+  function getFirstKey(path) {
+    return firstKeyCache.get(path);
+  }
 
-    __exports__.getWithDefault = getWithDefault;__exports__["default"] = get;
-    __exports__.get = get;
-    __exports__.normalizeTuple = normalizeTuple;
-    __exports__._getPath = _getPath;
-  });
-enifed("ember-metal/property_set",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/property_events","ember-metal/properties","ember-metal/error","ember-metal/path_cache","ember-metal/platform","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var getPath = __dependency2__._getPath;
-    var propertyWillChange = __dependency3__.propertyWillChange;
-    var propertyDidChange = __dependency3__.propertyDidChange;
-    var defineProperty = __dependency4__.defineProperty;
-    var EmberError = __dependency5__["default"];
-    var isPath = __dependency6__.isPath;
-    var hasPropertyAccessors = __dependency7__.hasPropertyAccessors;
+  function getTailPath(path) {
+    return tailPathCache.get(path);
+  }
 
-    var IS_GLOBAL = /^([A-Z$]|([0-9][A-Z$]))/;
+  exports.caches = caches;
+
+});
+enifed('ember-metal/platform/create', ['exports', 'ember-metal/platform/define_properties'], function (exports, defineProperties) {
+
+
+  // Remove "use strict"; from transpiled module until
+  // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
+  //
+  "REMOVE_USE_STRICT: true";
+
+  var create;
+  // ES5 15.2.3.5
+  // http://es5.github.com/#x15.2.3.5
+  if (!(Object.create && !Object.create(null).hasOwnProperty)) {
+    /* jshint scripturl:true, proto:true */
+    // Contributed by Brandon Benvie, October, 2012
+    var createEmpty;
+    var supportsProto = !({ '__proto__': null } instanceof Object);
+    // the following produces false positives
+    // in Opera Mini => not a reliable check
+    // Object.prototype.__proto__ === null
+    if (supportsProto || typeof document === 'undefined') {
+      createEmpty = function () {
+        return { "__proto__": null };
+      };
+    } else {
+      // In old IE __proto__ can't be used to manually set `null`, nor does
+      // any other method exist to make an object that inherits from nothing,
+      // aside from Object.prototype itself. Instead, create a new global
+      // object and *steal* its Object.prototype and strip it bare. This is
+      // used as the prototype to create nullary objects.
+      createEmpty = function () {
+        var iframe = document.createElement('iframe');
+        var parent = document.body || document.documentElement;
+        iframe.style.display = 'none';
+        parent.appendChild(iframe);
+        iframe.src = 'javascript:';
+        var empty = iframe.contentWindow.Object.prototype;
+        parent.removeChild(iframe);
+        iframe = null;
+        delete empty.constructor;
+        delete empty.hasOwnProperty;
+        delete empty.propertyIsEnumerable;
+        delete empty.isPrototypeOf;
+        delete empty.toLocaleString;
+        delete empty.toString;
+        delete empty.valueOf;
+
+        function Empty() {}
+        Empty.prototype = empty;
+        // short-circuit future calls
+        createEmpty = function () {
+          return new Empty();
+        };
+        return new Empty();
+      };
+    }
 
-    /**
-      Sets the value of a property on an object, respecting computed properties
-      and notifying observers and other listeners of the change. If the
-      property is not defined but the object implements the `setUnknownProperty`
-      method then that will be invoked as well.
+    create = Object.create = function create(prototype, properties) {
 
-      @method set
-      @for Ember
-      @param {Object} obj The object to modify.
-      @param {String} keyName The property key to set
-      @param {Object} value The value to set
-      @return {Object} the passed value.
-    */
-    var set = function set(obj, keyName, value, tolerant) {
-      if (typeof obj === 'string') {
-        Ember.assert("Path '" + obj + "' must be global if no obj is given.", IS_GLOBAL.test(obj));
-        value = keyName;
-        keyName = obj;
-        obj = null;
-      }
+      var object;
+      function Type() {}  // An empty constructor.
 
-      Ember.assert("Cannot call set with "+ keyName +" key.", !!keyName);
+      if (prototype === null) {
+        object = createEmpty();
+      } else {
+        if (typeof prototype !== "object" && typeof prototype !== "function") {
+          // In the native implementation `parent` can be `null`
+          // OR *any* `instanceof Object`  (Object|Function|Array|RegExp|etc)
+          // Use `typeof` tho, b/c in old IE, DOM elements are not `instanceof Object`
+          // like they are in modern browsers. Using `Object.create` on DOM elements
+          // is...err...probably inappropriate, but the native version allows for it.
+          throw new TypeError("Object prototype may only be an Object or null"); // same msg as Chrome
+        }
 
-      if (!obj) {
-        return setPath(obj, keyName, value, tolerant);
-      }
+        Type.prototype = prototype;
 
-      var meta = obj['__ember_meta__'];
-      var desc = meta && meta.descs[keyName];
-      var isUnknown, currentValue;
+        object = new Type();
+      }
 
-      if (desc === undefined && isPath(keyName)) {
-        return setPath(obj, keyName, value, tolerant);
+      if (properties !== undefined) {
+        defineProperties['default'](object, properties);
       }
 
-      Ember.assert("You need to provide an object and key to `set`.", !!obj && keyName !== undefined);
-      Ember.assert('calling set on destroyed object', !obj.isDestroyed);
+      return object;
+    };
+  } else {
+    create = Object.create;
+  }
 
-      if (desc !== undefined) {
-        desc.set(obj, keyName, value);
-      } else {
+  exports['default'] = create;
 
-        if (typeof obj === 'object' && obj !== null && value !== undefined && obj[keyName] === value) {
-          return value;
-        }
+});
+enifed('ember-metal/platform/define_properties', ['exports', 'ember-metal/platform/define_property'], function (exports, define_property) {
 
-        isUnknown = 'object' === typeof obj && !(keyName in obj);
+  'use strict';
 
-        // setUnknownProperty is called if `obj` is an object,
-        // the property does not already exist, and the
-        // `setUnknownProperty` method exists on the object
-        if (isUnknown && 'function' === typeof obj.setUnknownProperty) {
-          obj.setUnknownProperty(keyName, value);
-        } else if (meta && meta.watching[keyName] > 0) {
-          if (meta.proto !== obj) {
-            
-              if (hasPropertyAccessors) {
-                currentValue = meta.values[keyName];
-              } else {
-                currentValue = obj[keyName];
-              }
-                      }
-          // only trigger a change if the value has changed
-          if (value !== currentValue) {
-            propertyWillChange(obj, keyName);
-            
-              if (hasPropertyAccessors) {
-                if (
-                  (currentValue === undefined && !(keyName in obj)) ||
-                  !Object.prototype.propertyIsEnumerable.call(obj, keyName)
-                ) {
-                  defineProperty(obj, keyName, null, value); // setup mandatory setter
-                } else {
-                  meta.values[keyName] = value;
-                }
-              } else {
-                obj[keyName] = value;
-              }
-                        propertyDidChange(obj, keyName);
-          }
-        } else {
-          obj[keyName] = value;
+  var defineProperties = Object.defineProperties;
+
+  // ES5 15.2.3.7
+  // http://es5.github.com/#x15.2.3.7
+  if (!defineProperties) {
+    defineProperties = function defineProperties(object, properties) {
+      for (var property in properties) {
+        if (properties.hasOwnProperty(property) && property !== "__proto__") {
+          define_property.defineProperty(object, property, properties[property]);
         }
       }
-      return value;
+      return object;
     };
 
-    function setPath(root, path, value, tolerant) {
-      var keyName;
-
-      // get the last part of the path
-      keyName = path.slice(path.lastIndexOf('.') + 1);
-
-      // get the first part of the part
-      path    = (path === keyName) ? keyName : path.slice(0, path.length-(keyName.length+1));
-
-      // unless the path is this, look up the first part to
-      // get the root
-      if (path !== 'this') {
-        root = getPath(root, path);
-      }
+    Object.defineProperties = defineProperties;
+  }
 
-      if (!keyName || keyName.length === 0) {
-        throw new EmberError('Property set failed: You passed an empty path');
-      }
+  exports['default'] = defineProperties;
 
-      if (!root) {
-        if (tolerant) { return; }
-        else { throw new EmberError('Property set failed: object in path "'+path+'" could not be found or was destroyed.'); }
-      }
+});
+enifed('ember-metal/platform/define_property', ['exports'], function (exports) {
 
-      return set(root, keyName, value);
-    }
+  'use strict';
 
-    /**
-      Error-tolerant form of `Ember.set`. Will not blow up if any part of the
-      chain is `undefined`, `null`, or destroyed.
+  /*globals Node */
 
-      This is primarily used when syncing bindings, which may try to update after
-      an object has been destroyed.
+  /**
+  @class platform
+  @namespace Ember
+  @static
+  */
 
-      @method trySet
-      @for Ember
-      @param {Object} obj The object to modify.
-      @param {String} path The property path to set
-      @param {Object} value The value to set
-    */
-    function trySet(root, path, value) {
-      return set(root, path, value, true);
-    }
+  /**
+    Set to true if the platform supports native getters and setters.
 
-    __exports__.trySet = trySet;__exports__.set = set;
-  });
-enifed("ember-metal/run_loop",
-  ["ember-metal/core","ember-metal/utils","ember-metal/array","ember-metal/property_events","backburner","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var apply = __dependency2__.apply;
-    var GUID_KEY = __dependency2__.GUID_KEY;
-    var indexOf = __dependency3__.indexOf;
-    var beginPropertyChanges = __dependency4__.beginPropertyChanges;
-    var endPropertyChanges = __dependency4__.endPropertyChanges;
-    var Backburner = __dependency5__["default"];
+    @property hasPropertyAccessors
+    @final
+  */
 
-    function onBegin(current) {
-      run.currentRunLoop = current;
-    }
+  /**
+    Identical to `Object.defineProperty()`. Implements as much functionality
+    as possible if not available natively.
 
-    function onEnd(current, next) {
-      run.currentRunLoop = next;
+    @method defineProperty
+    @param {Object} obj The object to modify
+    @param {String} keyName property name to modify
+    @param {Object} desc descriptor hash
+    @return {void}
+  */
+  var defineProperty = (function checkCompliance(defineProperty) {
+    if (!defineProperty) {
+      return;
     }
 
-    // ES6TODO: should Backburner become es6?
-    var backburner = new Backburner(['sync', 'actions', 'destroy'], {
-      GUID_KEY: GUID_KEY,
-      sync: {
-        before: beginPropertyChanges,
-        after: endPropertyChanges
-      },
-      defaultQueue: 'actions',
-      onBegin: onBegin,
-      onEnd: onEnd,
-      onErrorTarget: Ember,
-      onErrorMethod: 'onerror'
-    });
-    var slice = [].slice;
+    try {
+      var a = 5;
+      var obj = {};
+      defineProperty(obj, 'a', {
+        configurable: true,
+        enumerable: true,
+        get: function () {
+          return a;
+        },
+        set: function (v) {
+          a = v;
+        }
+      });
+      if (obj.a !== 5) {
+        return;
+      }
 
-    // ..........................................................
-    // run - this is ideally the only public API the dev sees
-    //
+      obj.a = 10;
+      if (a !== 10) {
+        return;
+      }
 
-    /**
-      Runs the passed target and method inside of a RunLoop, ensuring any
-      deferred actions including bindings and views updates are flushed at the
-      end.
+      // check non-enumerability
+      defineProperty(obj, 'a', {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: true
+      });
+      for (var key in obj) {
+        if (key === 'a') {
+          return;
+        }
+      }
 
-      Normally you should not need to invoke this method yourself. However if
-      you are implementing raw event handlers when interfacing with other
-      libraries or plugins, you should probably wrap all of your code inside this
-      call.
+      // Detects a bug in Android <3.2 where you cannot redefine a property using
+      // Object.defineProperty once accessors have already been set.
+      if (obj.a !== true) {
+        return;
+      }
 
-      ```javascript
-      run(function() {
-        // code to be executed within a RunLoop
+      // Detects a bug in Android <3 where redefining a property without a value changes the value
+      // Object.defineProperty once accessors have already been set.
+      defineProperty(obj, 'a', {
+        enumerable: false
       });
-      ```
+      if (obj.a !== true) {
+        return;
+      }
 
-      @class run
-      @namespace Ember
-      @static
-      @constructor
-      @param {Object} [target] target of method to call
-      @param {Function|String} method Method to invoke.
-        May be a function or a string. If you pass a string
-        then it will be looked up on the passed target.
-      @param {Object} [args*] Any additional arguments you wish to pass to the method.
-      @return {Object} return value from invoking the passed function.
-    */
-    __exports__["default"] = run;
-    function run() {
-      return backburner.run.apply(backburner, arguments);
+      // defineProperty is compliant
+      return defineProperty;
+    } catch (e) {
+      // IE8 defines Object.defineProperty but calling it on an Object throws
+      return;
     }
+  })(Object.defineProperty);
 
-    /**
-      If no run-loop is present, it creates a new one. If a run loop is
-      present it will queue itself to run on the existing run-loops action
-      queue.
+  var hasES5CompliantDefineProperty = !!defineProperty;
 
-      Please note: This is not for normal usage, and should be used sparingly.
+  if (hasES5CompliantDefineProperty && typeof document !== 'undefined') {
+    // This is for Safari 5.0, which supports Object.defineProperty, but not
+    // on DOM nodes.
+    var canDefinePropertyOnDOM = (function() {
+      try {
+        defineProperty(document.createElement('div'), 'definePropertyOnDOM', {});
+        return true;
+      } catch(e) { }
 
-      If invoked when not within a run loop:
+      return false;
+    })();
 
-      ```javascript
-      run.join(function() {
-        // creates a new run-loop
-      });
-      ```
+    if (!canDefinePropertyOnDOM) {
+      defineProperty = function(obj, keyName, desc) {
+        var isNode;
 
-      Alternatively, if called within an existing run loop:
+        if (typeof Node === "object") {
+          isNode = obj instanceof Node;
+        } else {
+          isNode = typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string";
+        }
 
-      ```javascript
-      run(function() {
-        // creates a new run-loop
-        run.join(function() {
-          // joins with the existing run-loop, and queues for invocation on
-          // the existing run-loops action queue.
-        });
-      });
-      ```
+        if (isNode) {
+          // TODO: Should we have a warning here?
+          return (obj[keyName] = desc.value);
+        } else {
+          return Object.defineProperty(obj, keyName, desc);
+        }
+      };
+    }
+  }
 
-      @method join
-      @namespace Ember
-      @param {Object} [target] target of method to call
-      @param {Function|String} method Method to invoke.
-        May be a function or a string. If you pass a string
-        then it will be looked up on the passed target.
-      @param {Object} [args*] Any additional arguments you wish to pass to the method.
-      @return {Object} Return value from invoking the passed function. Please note,
-      when called within an existing loop, no return value is possible.
-    */
-    run.join = function() {
-      return backburner.join.apply(backburner, arguments);
+  if (!hasES5CompliantDefineProperty) {
+    defineProperty = function definePropertyPolyfill(obj, keyName, desc) {
+      if (!desc.get) { obj[keyName] = desc.value; }
     };
+  }
 
-    /**
-      Allows you to specify which context to call the specified function in while
-      adding the execution of that function to the Ember run loop. This ability
-      makes this method a great way to asynchronusly integrate third-party libraries
-      into your Ember application.
-
-      `run.bind` takes two main arguments, the desired context and the function to
-      invoke in that context. Any additional arguments will be supplied as arguments
-      to the function that is passed in.
+  var hasPropertyAccessors = hasES5CompliantDefineProperty;
+  var canDefineNonEnumerableProperties = hasES5CompliantDefineProperty;
 
-      Let's use the creation of a TinyMCE component as an example. Currently,
-      TinyMCE provides a setup configuration option we can use to do some processing
-      after the TinyMCE instance is initialized but before it is actually rendered.
-      We can use that setup option to do some additional setup for our component.
-      The component itself could look something like the following:
+  exports.hasES5CompliantDefineProperty = hasES5CompliantDefineProperty;
+  exports.defineProperty = defineProperty;
+  exports.hasPropertyAccessors = hasPropertyAccessors;
+  exports.canDefineNonEnumerableProperties = canDefineNonEnumerableProperties;
 
-      ```javascript
-      App.RichTextEditorComponent = Ember.Component.extend({
-        initializeTinyMCE: function(){
-          tinymce.init({
-            selector: '#' + this.$().prop('id'),
-            setup: Ember.run.bind(this, this.setupEditor)
-          });
-        }.on('didInsertElement'),
+});
+enifed('ember-metal/properties', ['exports', 'ember-metal/core', 'ember-metal/utils', 'ember-metal/platform/define_property', 'ember-metal/property_events'], function (exports, Ember, utils, define_property, property_events) {
 
-        setupEditor: function(editor) {
-          this.set('editor', editor);
-          editor.on('change', function(){ console.log('content changed!')} );
-        }
-      });
-      ```
+  'use strict';
 
-      In this example, we use Ember.run.bind to bind the setupEditor message to the
-      context of the App.RichTextEditorComponent and to have the invocation of that
-      method be safely handled and excuted by the Ember run loop.
+  exports.Descriptor = Descriptor;
+  exports.MANDATORY_SETTER_FUNCTION = MANDATORY_SETTER_FUNCTION;
+  exports.DEFAULT_GETTER_FUNCTION = DEFAULT_GETTER_FUNCTION;
+  exports.defineProperty = defineProperty;
 
-      @method bind
-      @namespace Ember
-      @param {Object} [target] target of method to call
-      @param {Function|String} method Method to invoke.
-        May be a function or a string. If you pass a string
-        then it will be looked up on the passed target.
-      @param {Object} [args*] Any additional arguments you wish to pass to the method.
-      @return {Function} returns a new function that will always have a particular context
-      @since 1.4.0
-    */
-    run.bind = function(target, method /* args */) {
-      var args = slice.call(arguments);
-      return function() {
-        return run.join.apply(run, args.concat(slice.call(arguments)));
-      };
-    };
+  /**
+  @module ember-metal
+  */
 
-    run.backburner = backburner;
-    run.currentRunLoop = null;
-    run.queues = backburner.queueNames;
+  function Descriptor() {
+    this.isDescriptor = true;
+  }
 
-    /**
-      Begins a new RunLoop. Any deferred actions invoked after the begin will
-      be buffered until you invoke a matching call to `run.end()`. This is
-      a lower-level way to use a RunLoop instead of using `run()`.
+  // ..........................................................
+  // DEFINING PROPERTIES API
+  //
 
-      ```javascript
-      run.begin();
-      // code to be executed within a RunLoop
-      run.end();
-      ```
+  function MANDATORY_SETTER_FUNCTION(name) {
+    return function SETTER_FUNCTION(value) {
+      Ember['default'].assert("You must use Ember.set() to set the `" + name + "` property (of " + this + ") to `" + value + "`.", false);
+    };
+  }
 
-      @method begin
-      @return {void}
-    */
-    run.begin = function() {
-      backburner.begin();
+  function DEFAULT_GETTER_FUNCTION(name) {
+    return function GETTER_FUNCTION() {
+      var meta = this['__ember_meta__'];
+      return meta && meta.values[name];
     };
+  }
 
-    /**
-      Ends a RunLoop. This must be called sometime after you call
-      `run.begin()` to flush any deferred actions. This is a lower-level way
-      to use a RunLoop instead of using `run()`.
+  /**
+    NOTE: This is a low-level method used by other parts of the API. You almost
+    never want to call this method directly. Instead you should use
+    `Ember.mixin()` to define new properties.
 
-      ```javascript
-      run.begin();
-      // code to be executed within a RunLoop
-      run.end();
-      ```
+    Defines a property on an object. This method works much like the ES5
+    `Object.defineProperty()` method except that it can also accept computed
+    properties and other special descriptors.
 
-      @method end
-      @return {void}
-    */
-    run.end = function() {
-      backburner.end();
-    };
+    Normally this method takes only three parameters. However if you pass an
+    instance of `Ember.Descriptor` as the third param then you can pass an
+    optional value as the fourth parameter. This is often more efficient than
+    creating new descriptor hashes for each property.
 
-    /**
-      Array of named queues. This array determines the order in which queues
-      are flushed at the end of the RunLoop. You can define your own queues by
-      simply adding the queue name to this array. Normally you should not need
-      to inspect or modify this property.
+    ## Examples
 
-      @property queues
-      @type Array
-      @default ['sync', 'actions', 'destroy']
-    */
+    ```javascript
+    // ES5 compatible mode
+    Ember.defineProperty(contact, 'firstName', {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: 'Charles'
+    });
 
-    /**
-      Adds the passed target/method and any optional arguments to the named
-      queue to be executed at the end of the RunLoop. If you have not already
-      started a RunLoop when calling this method one will be started for you
-      automatically.
+    // define a simple property
+    Ember.defineProperty(contact, 'lastName', undefined, 'Jolley');
 
-      At the end of a RunLoop, any methods scheduled in this way will be invoked.
-      Methods will be invoked in an order matching the named queues defined in
-      the `run.queues` property.
+    // define a computed property
+    Ember.defineProperty(contact, 'fullName', Ember.computed(function() {
+      return this.firstName+' '+this.lastName;
+    }).property('firstName', 'lastName'));
+    ```
 
-      ```javascript
-      run.schedule('sync', this, function() {
-        // this will be executed in the first RunLoop queue, when bindings are synced
-        console.log("scheduled on sync queue");
-      });
+    @private
+    @method defineProperty
+    @for Ember
+    @param {Object} obj the object to define this property on. This may be a prototype.
+    @param {String} keyName the name of the property
+    @param {Ember.Descriptor} [desc] an instance of `Ember.Descriptor` (typically a
+      computed property) or an ES5 descriptor.
+      You must provide this or `data` but not both.
+    @param {*} [data] something other than a descriptor, that will
+      become the explicit value of this property.
+  */
+  function defineProperty(obj, keyName, desc, data, meta) {
+    var possibleDesc, existingDesc, watching, value;
 
-      run.schedule('actions', this, function() {
-        // this will be executed in the 'actions' queue, after bindings have synced.
-        console.log("scheduled on actions queue");
-      });
+    if (!meta) {
+      meta = utils.meta(obj);
+    }
+    var watchEntry = meta.watching[keyName];
+    possibleDesc = obj[keyName];
+    existingDesc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
 
-      // Note the functions will be run in order based on the run queues order.
-      // Output would be:
-      //   scheduled on sync queue
-      //   scheduled on actions queue
-      ```
+    watching = watchEntry !== undefined && watchEntry > 0;
 
-      @method schedule
-      @param {String} queue The name of the queue to schedule against.
-        Default queues are 'sync' and 'actions'
-      @param {Object} [target] target object to use as the context when invoking a method.
-      @param {String|Function} method The method to invoke. If you pass a string it
-        will be resolved on the target object at the time the scheduled item is
-        invoked allowing you to change the target function.
-      @param {Object} [arguments*] Optional arguments to be passed to the queued method.
-      @return {void}
-    */
-    run.schedule = function(queue, target, method) {
-      checkAutoRun();
-      backburner.schedule.apply(backburner, arguments);
-    };
+    if (existingDesc) {
+      existingDesc.teardown(obj, keyName);
+    }
 
-    // Used by global test teardown
-    run.hasScheduledTimers = function() {
-      return backburner.hasTimers();
-    };
+    if (desc instanceof Descriptor) {
+      value = desc;
 
-    // Used by global test teardown
-    run.cancelTimers = function () {
-      backburner.cancelTimers();
-    };
 
-    /**
-      Immediately flushes any events scheduled in the 'sync' queue. Bindings
-      use this queue so this method is a useful way to immediately force all
-      bindings in the application to sync.
+        if (watching && define_property.hasPropertyAccessors) {
+          define_property.defineProperty(obj, keyName, {
+            configurable: true,
+            enumerable: true,
+            writable: true,
+            value: value
+          });
+        } else {
+          obj[keyName] = value;
+        }
+            if (desc.setup) { desc.setup(obj, keyName); }
+    } else {
+      if (desc == null) {
+        value = data;
 
-      You should call this method anytime you need any changed state to propagate
-      throughout the app immediately without repainting the UI (which happens
-      in the later 'render' queue added by the `ember-views` package).
 
-      ```javascript
-      run.sync();
-      ```
+          if (watching && define_property.hasPropertyAccessors) {
+            meta.values[keyName] = data;
+            define_property.defineProperty(obj, keyName, {
+              configurable: true,
+              enumerable: true,
+              set: MANDATORY_SETTER_FUNCTION(keyName),
+              get: DEFAULT_GETTER_FUNCTION(keyName)
+            });
+          } else {
+            obj[keyName] = data;
+          }
+              } else {
+        value = desc;
 
-      @method sync
-      @return {void}
-    */
-    run.sync = function() {
-      if (backburner.currentInstance) {
-        backburner.currentInstance.queues.sync.flush();
+        // compatibility with ES5
+        define_property.defineProperty(obj, keyName, desc);
       }
-    };
+    }
 
-    /**
-      Invokes the passed target/method and optional arguments after a specified
-      period of time. The last parameter of this method must always be a number
-      of milliseconds.
+    // if key is being watched, override chains that
+    // were initialized with the prototype
+    if (watching) { property_events.overrideChains(obj, keyName, meta); }
 
-      You should use this method whenever you need to run some action after a
-      period of time instead of using `setTimeout()`. This method will ensure that
-      items that expire during the same script execution cycle all execute
-      together, which is often more efficient than using a real setTimeout.
+    // The `value` passed to the `didDefineProperty` hook is
+    // either the descriptor or data, whichever was passed.
+    if (obj.didDefineProperty) { obj.didDefineProperty(obj, keyName, value); }
 
-      ```javascript
-      run.later(myContext, function() {
-        // code here will execute within a RunLoop in about 500ms with this == myContext
-      }, 500);
-      ```
-
-      @method later
-      @param {Object} [target] target of method to invoke
-      @param {Function|String} method The method to invoke.
-        If you pass a string it will be resolved on the
-        target at the time the method is invoked.
-      @param {Object} [args*] Optional arguments to pass to the timeout.
-      @param {Number} wait Number of milliseconds to wait.
-      @return {Object} Timer information for use in cancelling, see `run.cancel`.
-    */
-    run.later = function(/*target, method*/) {
-      return backburner.later.apply(backburner, arguments);
-    };
+    return this;
+  }
 
-    /**
-      Schedule a function to run one time during the current RunLoop. This is equivalent
-      to calling `scheduleOnce` with the "actions" queue.
+});
+enifed('ember-metal/property_events', ['exports', 'ember-metal/utils', 'ember-metal/events', 'ember-metal/observer_set'], function (exports, utils, ember_metal__events, ObserverSet) {
+
+  'use strict';
+
+  exports.propertyWillChange = propertyWillChange;
+  exports.propertyDidChange = propertyDidChange;
+  exports.overrideChains = overrideChains;
+  exports.beginPropertyChanges = beginPropertyChanges;
+  exports.endPropertyChanges = endPropertyChanges;
+  exports.changeProperties = changeProperties;
+
+  var beforeObserverSet = new ObserverSet['default']();
+  var observerSet = new ObserverSet['default']();
+  var deferred = 0;
+
+  // ..........................................................
+  // PROPERTY CHANGES
+  //
+
+  /**
+    This function is called just before an object property is about to change.
+    It will notify any before observers and prepare caches among other things.
+
+    Normally you will not need to call this method directly but if for some
+    reason you can't directly watch a property you can invoke this method
+    manually along with `Ember.propertyDidChange()` which you should call just
+    after the property value changes.
+
+    @method propertyWillChange
+    @for Ember
+    @param {Object} obj The object with the property that will change
+    @param {String} keyName The property key (or path) that will change.
+    @return {void}
+  */
+  function propertyWillChange(obj, keyName) {
+    var m = obj['__ember_meta__'];
+    var watching = (m && m.watching[keyName] > 0) || keyName === 'length';
+    var proto = m && m.proto;
+    var possibleDesc = obj[keyName];
+    var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
+
+    if (!watching) {
+      return;
+    }
 
-      @method once
-      @param {Object} [target] The target of the method to invoke.
-      @param {Function|String} method The method to invoke.
-        If you pass a string it will be resolved on the
-        target at the time the method is invoked.
-      @param {Object} [args*] Optional arguments to pass to the timeout.
-      @return {Object} Timer information for use in cancelling, see `run.cancel`.
-    */
-    run.once = function(/*target, method */) {
-      checkAutoRun();
-      var length = arguments.length;
-      var args = new Array(length);
-      args[0] = 'actions';
-      for (var i = 0; i < length; i++) {
-        args[i + 1] = arguments[i];
-      }
-      return apply(backburner, backburner.scheduleOnce, args);
-    };
+    if (proto === obj) {
+      return;
+    }
 
-    /**
-      Schedules a function to run one time in a given queue of the current RunLoop.
-      Calling this method with the same queue/target/method combination will have
-      no effect (past the initial call).
+    if (desc && desc.willChange) {
+      desc.willChange(obj, keyName);
+    }
 
-      Note that although you can pass optional arguments these will not be
-      considered when looking for duplicates. New arguments will replace previous
-      calls.
+    dependentKeysWillChange(obj, keyName, m);
+    chainsWillChange(obj, keyName, m);
+    notifyBeforeObservers(obj, keyName);
+  }
 
-      ```javascript
-      run(function() {
-        var sayHi = function() { console.log('hi'); }
-        run.scheduleOnce('afterRender', myContext, sayHi);
-        run.scheduleOnce('afterRender', myContext, sayHi);
-        // sayHi will only be executed once, in the afterRender queue of the RunLoop
-      });
-      ```
+  /**
+    This function is called just after an object property has changed.
+    It will notify any observers and clear caches among other things.
+
+    Normally you will not need to call this method directly but if for some
+    reason you can't directly watch a property you can invoke this method
+    manually along with `Ember.propertyWillChange()` which you should call just
+    before the property value changes.
+
+    @method propertyDidChange
+    @for Ember
+    @param {Object} obj The object with the property that will change
+    @param {String} keyName The property key (or path) that will change.
+    @return {void}
+  */
+  function propertyDidChange(obj, keyName) {
+    var m = obj['__ember_meta__'];
+    var watching = (m && m.watching[keyName] > 0) || keyName === 'length';
+    var proto = m && m.proto;
+    var possibleDesc = obj[keyName];
+    var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
+
+    if (proto === obj) {
+      return;
+    }
 
-      Also note that passing an anonymous function to `run.scheduleOnce` will
-      not prevent additional calls with an identical anonymous function from
-      scheduling the items multiple times, e.g.:
+    // shouldn't this mean that we're watching this key?
+    if (desc && desc.didChange) {
+      desc.didChange(obj, keyName);
+    }
 
-      ```javascript
-      function scheduleIt() {
-        run.scheduleOnce('actions', myContext, function() { console.log("Closure"); });
-      }
-      scheduleIt();
-      scheduleIt();
-      // "Closure" will print twice, even though we're using `run.scheduleOnce`,
-      // because the function we pass to it is anonymous and won't match the
-      // previously scheduled operation.
-      ```
-
-      Available queues, and their order, can be found at `run.queues`
-
-      @method scheduleOnce
-      @param {String} [queue] The name of the queue to schedule against. Default queues are 'sync' and 'actions'.
-      @param {Object} [target] The target of the method to invoke.
-      @param {Function|String} method The method to invoke.
-        If you pass a string it will be resolved on the
-        target at the time the method is invoked.
-      @param {Object} [args*] Optional arguments to pass to the timeout.
-      @return {Object} Timer information for use in cancelling, see `run.cancel`.
-    */
-    run.scheduleOnce = function(/*queue, target, method*/) {
-      checkAutoRun();
-      return backburner.scheduleOnce.apply(backburner, arguments);
-    };
+    if (!watching && keyName !== 'length') {
+      return;
+    }
 
-    /**
-      Schedules an item to run from within a separate run loop, after
-      control has been returned to the system. This is equivalent to calling
-      `run.later` with a wait time of 1ms.
+    if (m && m.deps && m.deps[keyName]) {
+      dependentKeysDidChange(obj, keyName, m);
+    }
 
-      ```javascript
-      run.next(myContext, function() {
-        // code to be executed in the next run loop,
-        // which will be scheduled after the current one
-      });
-      ```
+    chainsDidChange(obj, keyName, m, false);
+    notifyObservers(obj, keyName);
+  }
 
-      Multiple operations scheduled with `run.next` will coalesce
-      into the same later run loop, along with any other operations
-      scheduled by `run.later` that expire right around the same
-      time that `run.next` operations will fire.
+  var WILL_SEEN, DID_SEEN;
+  // called whenever a property is about to change to clear the cache of any dependent keys (and notify those properties of changes, etc...)
+  function dependentKeysWillChange(obj, depKey, meta) {
+    if (obj.isDestroying) { return; }
 
-      Note that there are often alternatives to using `run.next`.
-      For instance, if you'd like to schedule an operation to happen
-      after all DOM element operations have completed within the current
-      run loop, you can make use of the `afterRender` run loop queue (added
-      by the `ember-views` package, along with the preceding `render` queue
-      where all the DOM element operations happen). Example:
+    var deps;
+    if (meta && meta.deps && (deps = meta.deps[depKey])) {
+      var seen = WILL_SEEN;
+      var top = !seen;
 
-      ```javascript
-      App.MyCollectionView = Ember.CollectionView.extend({
-        didInsertElement: function() {
-          run.scheduleOnce('afterRender', this, 'processChildElements');
-        },
-        processChildElements: function() {
-          // ... do something with collectionView's child view
-          // elements after they've finished rendering, which
-          // can't be done within the CollectionView's
-          // `didInsertElement` hook because that gets run
-          // before the child elements have been added to the DOM.
-        }
-      });
-      ```
+      if (top) {
+        seen = WILL_SEEN = {};
+      }
 
-      One benefit of the above approach compared to using `run.next` is
-      that you will be able to perform DOM/CSS operations before unprocessed
-      elements are rendered to the screen, which may prevent flickering or
-      other artifacts caused by delaying processing until after rendering.
+      iterDeps(propertyWillChange, obj, deps, depKey, seen, meta);
 
-      The other major benefit to the above approach is that `run.next`
-      introduces an element of non-determinism, which can make things much
-      harder to test, due to its reliance on `setTimeout`; it's much harder
-      to guarantee the order of scheduled operations when they are scheduled
-      outside of the current run loop, i.e. with `run.next`.
+      if (top) {
+        WILL_SEEN = null;
+      }
+    }
+  }
 
-      @method next
-      @param {Object} [target] target of method to invoke
-      @param {Function|String} method The method to invoke.
-        If you pass a string it will be resolved on the
-        target at the time the method is invoked.
-      @param {Object} [args*] Optional arguments to pass to the timeout.
-      @return {Object} Timer information for use in cancelling, see `run.cancel`.
-    */
-    run.next = function() {
-      var args = slice.call(arguments);
-      args.push(1);
-      return apply(backburner, backburner.later, args);
-    };
+  // called whenever a property has just changed to update dependent keys
+  function dependentKeysDidChange(obj, depKey, meta) {
+    if (obj.isDestroying) { return; }
 
-    /**
-      Cancels a scheduled item. Must be a value returned by `run.later()`,
-      `run.once()`, `run.next()`, `run.debounce()`, or
-      `run.throttle()`.
+    var deps;
+    if (meta && meta.deps && (deps = meta.deps[depKey])) {
+      var seen = DID_SEEN;
+      var top = !seen;
 
-      ```javascript
-      var runNext = run.next(myContext, function() {
-        // will not be executed
-      });
-      run.cancel(runNext);
+      if (top) {
+        seen = DID_SEEN = {};
+      }
 
-      var runLater = run.later(myContext, function() {
-        // will not be executed
-      }, 500);
-      run.cancel(runLater);
+      iterDeps(propertyDidChange, obj, deps, depKey, seen, meta);
 
-      var runOnce = run.once(myContext, function() {
-        // will not be executed
-      });
-      run.cancel(runOnce);
+      if (top) {
+        DID_SEEN = null;
+      }
+    }
+  }
 
-      var throttle = run.throttle(myContext, function() {
-        // will not be executed
-      }, 1, false);
-      run.cancel(throttle);
+  function keysOf(obj) {
+    var keys = [];
 
-      var debounce = run.debounce(myContext, function() {
-        // will not be executed
-      }, 1);
-      run.cancel(debounce);
+    for (var key in obj) {
+      keys.push(key);
+    }
 
-      var debounceImmediate = run.debounce(myContext, function() {
-        // will be executed since we passed in true (immediate)
-      }, 100, true);
-      // the 100ms delay until this method can be called again will be cancelled
-      run.cancel(debounceImmediate);
-      ```
+    return keys;
+  }
 
-      @method cancel
-      @param {Object} timer Timer object to cancel
-      @return {Boolean} true if cancelled or false/undefined if it wasn't found
-    */
-    run.cancel = function(timer) {
-      return backburner.cancel(timer);
-    };
+  function iterDeps(method, obj, deps, depKey, seen, meta) {
+    var keys, key, i, possibleDesc, desc;
+    var guid = utils.guidFor(obj);
+    var current = seen[guid];
 
-    /**
-      Delay calling the target method until the debounce period has elapsed
-      with no additional debounce calls. If `debounce` is called again before
-      the specified time has elapsed, the timer is reset and the entire period
-      must pass again before the target method is called.
+    if (!current) {
+      current = seen[guid] = {};
+    }
 
-      This method should be used when an event may be called multiple times
-      but the action should only be called once when the event is done firing.
-      A common example is for scroll events where you only want updates to
-      happen once scrolling has ceased.
+    if (current[depKey]) {
+      return;
+    }
 
-      ```javascript
-        var myFunc = function() { console.log(this.name + ' ran.'); };
-        var myContext = {name: 'debounce'};
+    current[depKey] = true;
 
-        run.debounce(myContext, myFunc, 150);
+    if (deps) {
+      keys = keysOf(deps);
+      for (i=0; i<keys.length; i++) {
+        key = keys[i];
+        possibleDesc = obj[key];
+        desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
 
-        // less than 150ms passes
+        if (desc && desc._suspended === obj) {
+          continue;
+        }
 
-        run.debounce(myContext, myFunc, 150);
+        method(obj, key);
+      }
+    }
+  }
 
-        // 150ms passes
-        // myFunc is invoked with context myContext
-        // console logs 'debounce ran.' one time.
-      ```
+  function chainsWillChange(obj, keyName, m) {
+    if (!(m.hasOwnProperty('chainWatchers') &&
+          m.chainWatchers[keyName])) {
+      return;
+    }
 
-      Immediate allows you to run the function immediately, but debounce
-      other calls for this function until the wait time has elapsed. If
-      `debounce` is called again before the specified time has elapsed,
-      the timer is reset and the entire period must pass again before
-      the method can be called again.
+    var nodes = m.chainWatchers[keyName];
+    var events = [];
+    var i, l;
 
-      ```javascript
-        var myFunc = function() { console.log(this.name + ' ran.'); };
-        var myContext = {name: 'debounce'};
+    for (i = 0, l = nodes.length; i < l; i++) {
+      nodes[i].willChange(events);
+    }
 
-        run.debounce(myContext, myFunc, 150, true);
+    for (i = 0, l = events.length; i < l; i += 2) {
+      propertyWillChange(events[i], events[i+1]);
+    }
+  }
 
-        // console logs 'debounce ran.' one time immediately.
-        // 100ms passes
+  function chainsDidChange(obj, keyName, m, suppressEvents) {
+    if (!(m && m.hasOwnProperty('chainWatchers') &&
+          m.chainWatchers[keyName])) {
+      return;
+    }
 
-        run.debounce(myContext, myFunc, 150, true);
+    var nodes = m.chainWatchers[keyName];
+    var events = suppressEvents ? null : [];
+    var i, l;
 
-        // 150ms passes and nothing else is logged to the console and
-        // the debouncee is no longer being watched
+    for (i = 0, l = nodes.length; i < l; i++) {
+      nodes[i].didChange(events);
+    }
 
-        run.debounce(myContext, myFunc, 150, true);
+    if (suppressEvents) {
+      return;
+    }
 
-        // console logs 'debounce ran.' one time immediately.
-        // 150ms passes and nothing else is logged to the console and
-        // the debouncee is no longer being watched
+    for (i = 0, l = events.length; i < l; i += 2) {
+      propertyDidChange(events[i], events[i+1]);
+    }
+  }
 
-      ```
+  function overrideChains(obj, keyName, m) {
+    chainsDidChange(obj, keyName, m, true);
+  }
 
-      @method debounce
-      @param {Object} [target] target of method to invoke
-      @param {Function|String} method The method to invoke.
-        May be a function or a string. If you pass a string
-        then it will be looked up on the passed target.
-      @param {Object} [args*] Optional arguments to pass to the timeout.
-      @param {Number} wait Number of milliseconds to wait.
-      @param {Boolean} immediate Trigger the function on the leading instead
-        of the trailing edge of the wait interval. Defaults to false.
-      @return {Array} Timer information for use in cancelling, see `run.cancel`.
-    */
-    run.debounce = function() {
-      return backburner.debounce.apply(backburner, arguments);
-    };
+  /**
+    @method beginPropertyChanges
+    @chainable
+    @private
+  */
+  function beginPropertyChanges() {
+    deferred++;
+  }
 
-    /**
-      Ensure that the target method is never called more frequently than
-      the specified spacing period. The target method is called immediately.
+  /**
+    @method endPropertyChanges
+    @private
+  */
+  function endPropertyChanges() {
+    deferred--;
+    if (deferred<=0) {
+      beforeObserverSet.clear();
+      observerSet.flush();
+    }
+  }
 
-      ```javascript
-        var myFunc = function() { console.log(this.name + ' ran.'); };
-        var myContext = {name: 'throttle'};
-
-        run.throttle(myContext, myFunc, 150);
-        // myFunc is invoked with context myContext
-        // console logs 'throttle ran.'
-
-        // 50ms passes
-        run.throttle(myContext, myFunc, 150);
-
-        // 50ms passes
-        run.throttle(myContext, myFunc, 150);
-
-        // 150ms passes
-        run.throttle(myContext, myFunc, 150);
-        // myFunc is invoked with context myContext
-        // console logs 'throttle ran.'
-      ```
-
-      @method throttle
-      @param {Object} [target] target of method to invoke
-      @param {Function|String} method The method to invoke.
-        May be a function or a string. If you pass a string
-        then it will be looked up on the passed target.
-      @param {Object} [args*] Optional arguments to pass to the timeout.
-      @param {Number} spacing Number of milliseconds to space out requests.
-      @param {Boolean} immediate Trigger the function on the leading instead
-        of the trailing edge of the wait interval. Defaults to true.
-      @return {Array} Timer information for use in cancelling, see `run.cancel`.
-    */
-    run.throttle = function() {
-      return backburner.throttle.apply(backburner, arguments);
-    };
+  /**
+    Make a series of property changes together in an
+    exception-safe way.
 
-    // Make sure it's not an autorun during testing
-    function checkAutoRun() {
-      if (!run.currentRunLoop) {
-        Ember.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", !Ember.testing);
-      }
-    }
+    ```javascript
+    Ember.changeProperties(function() {
+      obj1.set('foo', mayBlowUpWhenSet);
+      obj2.set('bar', baz);
+    });
+    ```
 
-    /**
-      Add a new named queue after the specified queue.
+    @method changeProperties
+    @param {Function} callback
+    @param [binding]
+  */
+  function changeProperties(callback, binding) {
+    beginPropertyChanges();
+    utils.tryFinally(callback, endPropertyChanges, binding);
+  }
 
-      The queue to add will only be added once.
+  function notifyBeforeObservers(obj, keyName) {
+    if (obj.isDestroying) { return; }
 
-      @method _addQueue
-      @param {String} name the name of the queue to add.
-      @param {String} after the name of the queue to add after.
-      @private
-    */
-    run._addQueue = function(name, after) {
-      if (indexOf.call(run.queues, name) === -1) {
-        run.queues.splice(indexOf.call(run.queues, after)+1, 0, name);
-      }
-    };
-  });
-enifed("ember-metal/set_properties",
-  ["ember-metal/property_events","ember-metal/property_set","ember-metal/keys","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var changeProperties = __dependency1__.changeProperties;
-    var set = __dependency2__.set;
-    var keys = __dependency3__["default"];
+    var eventName = keyName + ':before';
+    var listeners, added;
+    if (deferred) {
+      listeners = beforeObserverSet.add(obj, keyName, eventName);
+      added = ember_metal__events.accumulateListeners(obj, eventName, listeners);
+      ember_metal__events.sendEvent(obj, eventName, [obj, keyName], added);
+    } else {
+      ember_metal__events.sendEvent(obj, eventName, [obj, keyName]);
+    }
+  }
 
-    /**
-      Set a list of properties on an object. These properties are set inside
-      a single `beginPropertyChanges` and `endPropertyChanges` batch, so
-      observers will be buffered.
+  function notifyObservers(obj, keyName) {
+    if (obj.isDestroying) { return; }
 
-      ```javascript
-      var anObject = Ember.Object.create();
+    var eventName = keyName + ':change';
+    var listeners;
+    if (deferred) {
+      listeners = observerSet.add(obj, keyName, eventName);
+      ember_metal__events.accumulateListeners(obj, eventName, listeners);
+    } else {
+      ember_metal__events.sendEvent(obj, eventName, [obj, keyName]);
+    }
+  }
 
-      anObject.setProperties({
-        firstName: 'Stanley',
-        lastName: 'Stuart',
-        age: 21
-      });
-      ```
+});
+enifed('ember-metal/property_get', ['exports', 'ember-metal/core', 'ember-metal/error', 'ember-metal/path_cache', 'ember-metal/platform/define_property'], function (exports, Ember, EmberError, path_cache, define_property) {
+
+  'use strict';
+
+  exports.get = get;
+  exports.normalizeTuple = normalizeTuple;
+  exports._getPath = _getPath;
+  exports.getWithDefault = getWithDefault;
+
+  /**
+  @module ember-metal
+  */
+
+  var FIRST_KEY = /^([^\.]+)/;
+
+  // ..........................................................
+  // GET AND SET
+  //
+  // If we are on a platform that supports accessors we can use those.
+  // Otherwise simulate accessors by looking up the property directly on the
+  // object.
+
+  /**
+    Gets the value of a property on an object. If the property is computed,
+    the function will be invoked. If the property is not defined but the
+    object implements the `unknownProperty` method then that will be invoked.
+
+    If you plan to run on IE8 and older browsers then you should use this
+    method anytime you want to retrieve a property on an object that you don't
+    know for sure is private. (Properties beginning with an underscore '_'
+    are considered private.)
+
+    On all newer browsers, you only need to use this method to retrieve
+    properties if the property might not be defined on the object and you want
+    to respect the `unknownProperty` handler. Otherwise you can ignore this
+    method.
+
+    Note that if the object itself is `undefined`, this method will throw
+    an error.
+
+    @method get
+    @for Ember
+    @param {Object} obj The object to retrieve from.
+    @param {String} keyName The property key to retrieve
+    @return {Object} the property value or `null`.
+  */
+  function get(obj, keyName) {
+    // Helpers that operate with 'this' within an #each
+    if (keyName === '') {
+      return obj;
+    }
 
-      @method setProperties
-      @param obj
-      @param {Object} properties
-      @return obj
-    */
-    __exports__["default"] = function setProperties(obj, properties) {
-      if (!properties || typeof properties !== "object") { return obj; }
-      changeProperties(function() {
-        var props = keys(properties);
-        var propertyName;
+    if (!keyName && 'string' === typeof obj) {
+      keyName = obj;
+      obj = null;
+    }
 
-        for (var i = 0, l = props.length; i < l; i++) {
-          propertyName = props[i];
+    Ember['default'].assert("Cannot call get with "+ keyName +" key.", !!keyName);
+    Ember['default'].assert("Cannot call get with '"+ keyName +"' on an undefined object.", obj !== undefined);
 
-          set(obj, propertyName, properties[propertyName]);
-        }
-      });
-      return obj;
+    if (obj === null) {
+      var value = _getPath(obj, keyName);
+      Ember['default'].deprecate(
+        "Ember.get fetched '"+keyName+"' from the global context. This behavior will change in the future (issue #3852)",
+        !value || (obj && obj !== Ember['default'].lookup) || path_cache.isPath(keyName) || path_cache.isGlobalPath(keyName+".") // Add a . to ensure simple paths are matched.
+      );
+      return value;
     }
-  });
-enifed("ember-metal/streams/simple",
-  ["ember-metal/merge","ember-metal/streams/stream","ember-metal/platform","ember-metal/streams/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    var merge = __dependency1__["default"];
-    var Stream = __dependency2__["default"];
-    var create = __dependency3__.create;
-    var read = __dependency4__.read;
-    var isStream = __dependency4__.isStream;
 
-    function SimpleStream(source) {
-      this.init();
-      this.source = source;
+    var meta = obj['__ember_meta__'];
+    var possibleDesc = obj[keyName];
+    var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
+    var ret;
 
-      if (isStream(source)) {
-        source.subscribe(this._didChange, this);
+    if (desc === undefined && path_cache.isPath(keyName)) {
+      return _getPath(obj, keyName);
+    }
+
+    if (desc) {
+      return desc.get(obj, keyName);
+    } else {
+
+        if (define_property.hasPropertyAccessors && meta && meta.watching[keyName] > 0) {
+          ret = meta.values[keyName];
+        } else {
+          ret = obj[keyName];
+        }
+
+      if (ret === undefined &&
+          'object' === typeof obj && !(keyName in obj) && 'function' === typeof obj.unknownProperty) {
+        return obj.unknownProperty(keyName);
       }
+
+      return ret;
     }
+  }
 
-    SimpleStream.prototype = create(Stream.prototype);
+  /**
+    Normalizes a target/path pair to reflect that actual target/path that should
+    be observed, etc. This takes into account passing in global property
+    paths (i.e. a path beginning with a capital letter not defined on the
+    target).
 
-    merge(SimpleStream.prototype, {
-      valueFn: function() {
-        return read(this.source);
-      },
+    @private
+    @method normalizeTuple
+    @for Ember
+    @param {Object} target The current target. May be `null`.
+    @param {String} path A path on the target or a global property path.
+    @return {Array} a temporary array with the normalized target/path pair.
+  */
+  function normalizeTuple(target, path) {
+    var hasThis  = path_cache.hasThis(path);
+    var isGlobal = !hasThis && path_cache.isGlobalPath(path);
+    var key;
+
+    if (!target || isGlobal) {
+      target = Ember['default'].lookup;
+    }
 
-      setValue: function(value) {
-        var source = this.source;
+    if (hasThis) {
+      path = path.slice(5);
+    }
 
-        if (isStream(source)) {
-          source.setValue(value);
-        }
-      },
+    Ember['default'].deprecate(
+      "normalizeTuple will return '"+path+"' as a non-global. This behavior will change in the future (issue #3852)",
+      target === Ember['default'].lookup || !target || hasThis || isGlobal || !path_cache.isGlobalPath(path+'.')
+    );
 
-      setSource: function(nextSource) {
-        var prevSource = this.source;
-        if (nextSource !== prevSource) {
-          if (isStream(prevSource)) {
-            prevSource.unsubscribe(this._didChange, this);
-          }
+    if (target === Ember['default'].lookup) {
+      key = path.match(FIRST_KEY)[0];
+      target = get(target, key);
+      path   = path.slice(key.length+1);
+    }
 
-          if (isStream(nextSource)) {
-            nextSource.subscribe(this._didChange, this);
-          }
+    // must return some kind of path to be valid else other things will break.
+    if (!path || path.length===0) {
+      throw new EmberError['default']('Path cannot be empty');
+    }
 
-          this.source = nextSource;
-          this.notify();
-        }
-      },
+    return [target, path];
+  }
 
-      _didChange: function() {
-        this.notify();
-      },
+  function _getPath(root, path) {
+    var hasThis, parts, tuple, idx, len;
 
-      _super$destroy: Stream.prototype.destroy,
+    // If there is no root and path is a key name, return that
+    // property from the global object.
+    // E.g. get('Ember') -> Ember
+    if (root === null && !path_cache.isPath(path)) {
+      return get(Ember['default'].lookup, path);
+    }
 
-      destroy: function() {
-        if (this._super$destroy()) {
-          if (isStream(this.source)) {
-            this.source.unsubscribe(this._didChange, this);
-          }
-          this.source = undefined;
-          return true;
-        }
-      }
-    });
+    // detect complicated paths and normalize them
+    hasThis = path_cache.hasThis(path);
 
-    __exports__["default"] = SimpleStream;
-  });
-enifed("ember-metal/streams/stream",
-  ["ember-metal/platform","ember-metal/path_cache","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var create = __dependency1__.create;
-    var getFirstKey = __dependency2__.getFirstKey;
-    var getTailPath = __dependency2__.getTailPath;
+    if (!root || hasThis) {
+      tuple = normalizeTuple(root, path);
+      root = tuple[0];
+      path = tuple[1];
+      tuple.length = 0;
+    }
 
-    function Stream(fn) {
-      this.init();
-      this.valueFn = fn;
+    parts = path.split(".");
+    len = parts.length;
+    for (idx = 0; root != null && idx < len; idx++) {
+      root = get(root, parts[idx], true);
+      if (root && root.isDestroyed) { return undefined; }
     }
+    return root;
+  }
 
-    Stream.prototype = {
-      isStream: true,
+  function getWithDefault(root, key, defaultValue) {
+    var value = get(root, key);
 
-      init: function() {
-        this.state = 'dirty';
-        this.cache = undefined;
-        this.subscribers = undefined;
-        this.children = undefined;
-        this._label = undefined;
-      },
+    if (value === undefined) { return defaultValue; }
+    return value;
+  }
 
-      get: function(path) {
-        var firstKey = getFirstKey(path);
-        var tailPath = getTailPath(path);
+  exports['default'] = get;
 
-        if (this.children === undefined) {
-          this.children = create(null);
-        }
+});
+enifed('ember-metal/property_set', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_events', 'ember-metal/properties', 'ember-metal/error', 'ember-metal/path_cache', 'ember-metal/platform/define_property'], function (exports, Ember, property_get, property_events, properties, EmberError, path_cache, define_property) {
 
-        var keyStream = this.children[firstKey];
+  'use strict';
 
-        if (keyStream === undefined) {
-          keyStream = this._makeChildStream(firstKey, path);
-          this.children[firstKey] = keyStream;
-        }
+  exports.set = set;
+  exports.trySet = trySet;
 
-        if (tailPath === undefined) {
-          return keyStream;
-        } else {
-          return keyStream.get(tailPath);
-        }
-      },
+  var IS_GLOBAL = /^([A-Z$]|([0-9][A-Z$]))/;
 
-      value: function() {
-        if (this.state === 'clean') {
-          return this.cache;
-        } else if (this.state === 'dirty') {
-          this.state = 'clean';
-          return this.cache = this.valueFn();
-        }
-        // TODO: Ensure value is never called on a destroyed stream
-        // so that we can uncomment this assertion.
-        //
-        // Ember.assert("Stream error: value was called in an invalid state: " + this.state);
-      },
+  /**
+    Sets the value of a property on an object, respecting computed properties
+    and notifying observers and other listeners of the change. If the
+    property is not defined but the object implements the `setUnknownProperty`
+    method then that will be invoked as well.
 
-      valueFn: function() {
-        throw new Error("Stream error: valueFn not implemented");
-      },
+    @method set
+    @for Ember
+    @param {Object} obj The object to modify.
+    @param {String} keyName The property key to set
+    @param {Object} value The value to set
+    @return {Object} the passed value.
+  */
+  function set(obj, keyName, value, tolerant) {
+    if (typeof obj === 'string') {
+      Ember['default'].assert("Path '" + obj + "' must be global if no obj is given.", IS_GLOBAL.test(obj));
+      value = keyName;
+      keyName = obj;
+      obj = null;
+    }
 
-      setValue: function() {
-        throw new Error("Stream error: setValue not implemented");
-      },
+    Ember['default'].assert("Cannot call set with "+ keyName +" key.", !!keyName);
 
-      notify: function() {
-        this.notifyExcept();
-      },
+    if (!obj) {
+      return setPath(obj, keyName, value, tolerant);
+    }
 
-      notifyExcept: function(callbackToSkip, contextToSkip) {
-        if (this.state === 'clean') {
-          this.state = 'dirty';
-          this._notifySubscribers(callbackToSkip, contextToSkip);
-        }
-      },
+    var meta = obj['__ember_meta__'];
+    var possibleDesc = obj[keyName];
+    var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
 
-      subscribe: function(callback, context) {
-        if (this.subscribers === undefined) {
-          this.subscribers = [callback, context];
-        } else {
-          this.subscribers.push(callback, context);
-        }
-      },
+    var isUnknown, currentValue;
 
-      unsubscribe: function(callback, context) {
-        var subscribers = this.subscribers;
+    if (desc === undefined && path_cache.isPath(keyName)) {
+      return setPath(obj, keyName, value, tolerant);
+    }
 
-        if (subscribers !== undefined) {
-          for (var i = 0, l = subscribers.length; i < l; i += 2) {
-            if (subscribers[i] === callback && subscribers[i+1] === context) {
-              subscribers.splice(i, 2);
-              return;
-            }
-          }
-        }
-      },
+    Ember['default'].assert("You need to provide an object and key to `set`.", !!obj && keyName !== undefined);
+    Ember['default'].assert('calling set on destroyed object', !obj.isDestroyed);
 
-      _notifySubscribers: function(callbackToSkip, contextToSkip) {
-        var subscribers = this.subscribers;
+    if (desc) {
+      desc.set(obj, keyName, value);
+    } else {
 
-        if (subscribers !== undefined) {
-          for (var i = 0, l = subscribers.length; i < l; i += 2) {
-            var callback = subscribers[i];
-            var context = subscribers[i+1];
+      if (typeof obj === 'object' && obj !== null && value !== undefined && obj[keyName] === value) {
+        return value;
+      }
 
-            if (callback === callbackToSkip && context === contextToSkip) {
-              continue;
-            }
+      isUnknown = 'object' === typeof obj && !(keyName in obj);
 
-            if (context === undefined) {
-              callback(this);
+      // setUnknownProperty is called if `obj` is an object,
+      // the property does not already exist, and the
+      // `setUnknownProperty` method exists on the object
+      if (isUnknown && 'function' === typeof obj.setUnknownProperty) {
+        obj.setUnknownProperty(keyName, value);
+      } else if (meta && meta.watching[keyName] > 0) {
+        if (meta.proto !== obj) {
+
+            if (define_property.hasPropertyAccessors) {
+              currentValue = meta.values[keyName];
             } else {
-              callback.call(context, this);
+              currentValue = obj[keyName];
             }
-          }
+                  }
+        // only trigger a change if the value has changed
+        if (value !== currentValue) {
+          property_events.propertyWillChange(obj, keyName);
+
+            if (define_property.hasPropertyAccessors) {
+              if (
+                (currentValue === undefined && !(keyName in obj)) ||
+                !Object.prototype.propertyIsEnumerable.call(obj, keyName)
+              ) {
+                properties.defineProperty(obj, keyName, null, value); // setup mandatory setter
+              } else {
+                meta.values[keyName] = value;
+              }
+            } else {
+              obj[keyName] = value;
+            }
+                    property_events.propertyDidChange(obj, keyName);
         }
-      },
-
-      destroy: function() {
-        if (this.state !== 'destroyed') {
-          this.state = 'destroyed';
-
-          var children = this.children;
-          for (var key in children) {
-            children[key].destroy();
-          }
+      } else {
+        obj[keyName] = value;
+      }
+    }
+    return value;
+  }
 
-          return true;
-        }
-      },
+  function setPath(root, path, value, tolerant) {
+    var keyName;
 
-      isGlobal: function() {
-        var stream = this;
-        while (stream !== undefined) {
-          if (stream._isRoot) {
-            return stream._isGlobal;
-          }
-          stream = stream.source;
-        }
-      }
-    };
+    // get the last part of the path
+    keyName = path.slice(path.lastIndexOf('.') + 1);
 
-    __exports__["default"] = Stream;
-  });
-enifed("ember-metal/streams/stream_binding",
-  ["ember-metal/platform","ember-metal/merge","ember-metal/run_loop","ember-metal/streams/stream","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    var create = __dependency1__.create;
-    var merge = __dependency2__["default"];
-    var run = __dependency3__["default"];
-    var Stream = __dependency4__["default"];
+    // get the first part of the part
+    path    = (path === keyName) ? keyName : path.slice(0, path.length-(keyName.length+1));
 
-    function StreamBinding(stream) {
-      Ember.assert("StreamBinding error: tried to bind to object that is not a stream", stream && stream.isStream);
+    // unless the path is this, look up the first part to
+    // get the root
+    if (path !== 'this') {
+      root = property_get._getPath(root, path);
+    }
 
-      this.init();
-      this.stream = stream;
-      this.senderCallback = undefined;
-      this.senderContext = undefined;
-      this.senderValue = undefined;
+    if (!keyName || keyName.length === 0) {
+      throw new EmberError['default']('Property set failed: You passed an empty path');
+    }
 
-      stream.subscribe(this._onNotify, this);
+    if (!root) {
+      if (tolerant) {
+        return;
+      } else {
+        throw new EmberError['default']('Property set failed: object in path "'+path+'" could not be found or was destroyed.');
+      }
     }
 
-    StreamBinding.prototype = create(Stream.prototype);
+    return set(root, keyName, value);
+  }
 
-    merge(StreamBinding.prototype, {
-      valueFn: function() {
-        return this.stream.value();
-      },
+  /**
+    Error-tolerant form of `Ember.set`. Will not blow up if any part of the
+    chain is `undefined`, `null`, or destroyed.
+
+    This is primarily used when syncing bindings, which may try to update after
+    an object has been destroyed.
+
+    @method trySet
+    @for Ember
+    @param {Object} obj The object to modify.
+    @param {String} path The property path to set
+    @param {Object} value The value to set
+  */
+  function trySet(root, path, value) {
+    return set(root, path, value, true);
+  }
 
-      _onNotify: function() {
-        this._scheduleSync(undefined, undefined, this);
-      },
+});
+enifed('ember-metal/run_loop', ['exports', 'ember-metal/core', 'ember-metal/utils', 'ember-metal/array', 'ember-metal/property_events', 'backburner'], function (exports, Ember, utils, array, property_events, Backburner) {
 
-      setValue: function(value, callback, context) {
-        this._scheduleSync(value, callback, context);
-      },
+  'use strict';
 
-      _scheduleSync: function(value, callback, context) {
-        if (this.senderCallback === undefined && this.senderContext === undefined) {
-          this.senderCallback = callback;
-          this.senderContext = context;
-          this.senderValue = value;
-          run.schedule('sync', this, this._sync);
-        } else if (this.senderContext !== this) {
-          this.senderCallback = callback;
-          this.senderContext = context;
-          this.senderValue = value;
-        }
-      },
+  function onBegin(current) {
+    run.currentRunLoop = current;
+  }
 
-      _sync: function() {
-        if (this.state === 'destroyed') {
-          return;
-        }
+  function onEnd(current, next) {
+    run.currentRunLoop = next;
+  }
 
-        if (this.senderContext !== this) {
-          this.stream.setValue(this.senderValue);
-        }
+  // ES6TODO: should Backburner become es6?
+  var backburner = new Backburner['default'](['sync', 'actions', 'destroy'], {
+    GUID_KEY: utils.GUID_KEY,
+    sync: {
+      before: property_events.beginPropertyChanges,
+      after: property_events.endPropertyChanges
+    },
+    defaultQueue: 'actions',
+    onBegin: onBegin,
+    onEnd: onEnd,
+    onErrorTarget: Ember['default'],
+    onErrorMethod: 'onerror'
+  });
+  var slice = [].slice;
+
+  // ..........................................................
+  // run - this is ideally the only public API the dev sees
+  //
+
+  /**
+    Runs the passed target and method inside of a RunLoop, ensuring any
+    deferred actions including bindings and views updates are flushed at the
+    end.
+
+    Normally you should not need to invoke this method yourself. However if
+    you are implementing raw event handlers when interfacing with other
+    libraries or plugins, you should probably wrap all of your code inside this
+    call.
 
-        var senderCallback = this.senderCallback;
-        var senderContext = this.senderContext;
-        this.senderCallback = undefined;
-        this.senderContext = undefined;
-        this.senderValue = undefined;
+    ```javascript
+    run(function() {
+      // code to be executed within a RunLoop
+    });
+    ```
 
-        // Force StreamBindings to always notify
-        this.state = 'clean';
+    @class run
+    @namespace Ember
+    @static
+    @constructor
+    @param {Object} [target] target of method to call
+    @param {Function|String} method Method to invoke.
+      May be a function or a string. If you pass a string
+      then it will be looked up on the passed target.
+    @param {Object} [args*] Any additional arguments you wish to pass to the method.
+    @return {Object} return value from invoking the passed function.
+  */
+  exports['default'] = run;
+  function run() {
+    return backburner.run.apply(backburner, arguments);
+  }
 
-        this.notifyExcept(senderCallback, senderContext);
-      },
+  /**
+    If no run-loop is present, it creates a new one. If a run loop is
+    present it will queue itself to run on the existing run-loops action
+    queue.
 
-      _super$destroy: Stream.prototype.destroy,
+    Please note: This is not for normal usage, and should be used sparingly.
 
-      destroy: function() {
-        if (this._super$destroy()) {
-          this.stream.unsubscribe(this._onNotify, this);
-          return true;
-        }
-      }
-    });
+    If invoked when not within a run loop:
 
-    __exports__["default"] = StreamBinding;
-  });
-enifed("ember-metal/streams/utils",
-  ["./stream","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Stream = __dependency1__["default"];
+    ```javascript
+    run.join(function() {
+      // creates a new run-loop
+    });
+    ```
 
-    /**
-     Check whether an object is a stream or not
+    Alternatively, if called within an existing run loop:
 
-     @private
-     @function isStream
-     @param {Object|Stream} object object to check whether it is a stream
-     @return {Boolean} `true` if the object is a stream, `false` otherwise
-    */
-    function isStream(object) {
-      return object && object.isStream;
-    }
+    ```javascript
+    run(function() {
+      // creates a new run-loop
+      run.join(function() {
+        // joins with the existing run-loop, and queues for invocation on
+        // the existing run-loops action queue.
+      });
+    });
+    ```
 
-    __exports__.isStream = isStream;/**
-     A method of subscribing to a stream which is safe for use with a non-stream
-     object. If a non-stream object is passed, the function does nothing.
+    @method join
+    @namespace Ember
+    @param {Object} [target] target of method to call
+    @param {Function|String} method Method to invoke.
+      May be a function or a string. If you pass a string
+      then it will be looked up on the passed target.
+    @param {Object} [args*] Any additional arguments you wish to pass to the method.
+    @return {Object} Return value from invoking the passed function. Please note,
+    when called within an existing loop, no return value is possible.
+  */
+  run.join = function() {
+    return backburner.join.apply(backburner, arguments);
+  };
+
+  /**
+    Allows you to specify which context to call the specified function in while
+    adding the execution of that function to the Ember run loop. This ability
+    makes this method a great way to asynchronously integrate third-party libraries
+    into your Ember application.
+
+    `run.bind` takes two main arguments, the desired context and the function to
+    invoke in that context. Any additional arguments will be supplied as arguments
+    to the function that is passed in.
+
+    Let's use the creation of a TinyMCE component as an example. Currently,
+    TinyMCE provides a setup configuration option we can use to do some processing
+    after the TinyMCE instance is initialized but before it is actually rendered.
+    We can use that setup option to do some additional setup for our component.
+    The component itself could look something like the following:
 
-     @private
-     @function subscribe
-     @param {Object|Stream} object object or stream to potentially subscribe to
-     @param {Function} callback function to run when stream value changes
-     @param {Object} [context] the callback will be executed with this context if it
-                               is provided
-     */
-    function subscribe(object, callback, context) {
-      if (object && object.isStream) {
-        object.subscribe(callback, context);
-      }
-    }
+    ```javascript
+    App.RichTextEditorComponent = Ember.Component.extend({
+      initializeTinyMCE: function() {
+        tinymce.init({
+          selector: '#' + this.$().prop('id'),
+          setup: Ember.run.bind(this, this.setupEditor)
+        });
+      }.on('didInsertElement'),
 
-    __exports__.subscribe = subscribe;/**
-     A method of unsubscribing from a stream which is safe for use with a non-stream
-     object. If a non-stream object is passed, the function does nothing.
+      setupEditor: function(editor) {
+        this.set('editor', editor);
 
-     @private
-     @function unsubscribe
-     @param {Object|Stream} object object or stream to potentially unsubscribe from
-     @param {Function} callback function originally passed to `subscribe()`
-     @param {Object} [context] object originally passed to `subscribe()`
-     */
-    function unsubscribe(object, callback, context) {
-      if (object && object.isStream) {
-        object.unsubscribe(callback, context);
+        editor.on('change', function() {
+          console.log('content changed!');
+        });
       }
-    }
+    });
+    ```
 
-    __exports__.unsubscribe = unsubscribe;/**
-     Retrieve the value of a stream, or in the case a non-stream object is passed,
-     return the object itself.
+    In this example, we use Ember.run.bind to bind the setupEditor message to the
+    context of the App.RichTextEditorComponent and to have the invocation of that
+    method be safely handled and executed by the Ember run loop.
 
-     @private
-     @function read
-     @param {Object|Stream} object object to return the value of
-     @return the stream's current value, or the non-stream object itself
-     */
-    function read(object) {
-      if (object && object.isStream) {
-        return object.value();
-      } else {
-        return object;
-      }
-    }
+    @method bind
+    @namespace Ember
+    @param {Object} [target] target of method to call
+    @param {Function|String} method Method to invoke.
+      May be a function or a string. If you pass a string
+      then it will be looked up on the passed target.
+    @param {Object} [args*] Any additional arguments you wish to pass to the method.
+    @return {Function} returns a new function that will always have a particular context
+    @since 1.4.0
+  */
+  run.bind = function(target, method /* args */) {
+    var args = slice.call(arguments);
+    return function() {
+      return run.join.apply(run, args.concat(slice.call(arguments)));
+    };
+  };
+
+  run.backburner = backburner;
+  run.currentRunLoop = null;
+  run.queues = backburner.queueNames;
+
+  /**
+    Begins a new RunLoop. Any deferred actions invoked after the begin will
+    be buffered until you invoke a matching call to `run.end()`. This is
+    a lower-level way to use a RunLoop instead of using `run()`.
 
-    __exports__.read = read;/**
-     Map an array, replacing any streams with their values.
+    ```javascript
+    run.begin();
+    // code to be executed within a RunLoop
+    run.end();
+    ```
 
-     @private
-     @function readArray
-     @param {Array} array The array to read values from
-     @return {Array} a new array of the same length with the values of non-stream
-                     objects mapped from their original positions untouched, and
-                     the values of stream objects retaining their original position
-                     and replaced with the stream's current value.
-     */
-    function readArray(array) {
-      var length = array.length;
-      var ret = new Array(length);
-      for (var i = 0; i < length; i++) {
-        ret[i] = read(array[i]);
-      }
-      return ret;
-    }
+    @method begin
+    @return {void}
+  */
+  run.begin = function() {
+    backburner.begin();
+  };
 
-    __exports__.readArray = readArray;/**
-     Map a hash, replacing any stream property values with the current value of that
-     stream.
+  /**
+    Ends a RunLoop. This must be called sometime after you call
+    `run.begin()` to flush any deferred actions. This is a lower-level way
+    to use a RunLoop instead of using `run()`.
 
-     @private
-     @function readHash
-     @param {Object} object The hash to read keys and values from
-     @return {Object} a new object with the same keys as the passed object. The
-                      property values in the new object are the original values in
-                      the case of non-stream objects, and the streams' current
-                      values in the case of stream objects.
-     */
-    function readHash(object) {
-      var ret = {};
-      for (var key in object) {
-        ret[key] = read(object[key]);
-      }
-      return ret;
-    }
+    ```javascript
+    run.begin();
+    // code to be executed within a RunLoop
+    run.end();
+    ```
 
-    __exports__.readHash = readHash;/**
-     Check whether an array contains any stream values
+    @method end
+    @return {void}
+  */
+  run.end = function() {
+    backburner.end();
+  };
+
+  /**
+    Array of named queues. This array determines the order in which queues
+    are flushed at the end of the RunLoop. You can define your own queues by
+    simply adding the queue name to this array. Normally you should not need
+    to inspect or modify this property.
+
+    @property queues
+    @type Array
+    @default ['sync', 'actions', 'destroy']
+  */
+
+  /**
+    Adds the passed target/method and any optional arguments to the named
+    queue to be executed at the end of the RunLoop. If you have not already
+    started a RunLoop when calling this method one will be started for you
+    automatically.
+
+    At the end of a RunLoop, any methods scheduled in this way will be invoked.
+    Methods will be invoked in an order matching the named queues defined in
+    the `run.queues` property.
 
-     @private
-     @function scanArray
-     @param {Array} array array given to a handlebars helper
-     @return {Boolean} `true` if the array contains a stream/bound value, `false`
-                       otherwise
-    */
-    function scanArray(array) {
-      var length = array.length;
-      var containsStream = false;
-
-      for (var i = 0; i < length; i++){
-        if (isStream(array[i])) {
-          containsStream = true;
-          break;
-        }
-      }
+    ```javascript
+    run.schedule('sync', this, function() {
+      // this will be executed in the first RunLoop queue, when bindings are synced
+      console.log('scheduled on sync queue');
+    });
 
-      return containsStream;
-    }
+    run.schedule('actions', this, function() {
+      // this will be executed in the 'actions' queue, after bindings have synced.
+      console.log('scheduled on actions queue');
+    });
 
-    __exports__.scanArray = scanArray;/**
-     Check whether a hash has any stream property values
+    // Note the functions will be run in order based on the run queues order.
+    // Output would be:
+    //   scheduled on sync queue
+    //   scheduled on actions queue
+    ```
 
-     @private
-     @function scanHash
-     @param {Object} hash "hash" argument given to a handlebars helper
-     @return {Boolean} `true` if the object contains a stream/bound value, `false`
-                       otherwise
-     */
-    function scanHash(hash) {
-      var containsStream = false;
+    @method schedule
+    @param {String} queue The name of the queue to schedule against.
+      Default queues are 'sync' and 'actions'
+    @param {Object} [target] target object to use as the context when invoking a method.
+    @param {String|Function} method The method to invoke. If you pass a string it
+      will be resolved on the target object at the time the scheduled item is
+      invoked allowing you to change the target function.
+    @param {Object} [arguments*] Optional arguments to be passed to the queued method.
+    @return {void}
+  */
+  run.schedule = function(queue, target, method) {
+    checkAutoRun();
+    backburner.schedule.apply(backburner, arguments);
+  };
+
+  // Used by global test teardown
+  run.hasScheduledTimers = function() {
+    return backburner.hasTimers();
+  };
+
+  // Used by global test teardown
+  run.cancelTimers = function () {
+    backburner.cancelTimers();
+  };
+
+  /**
+    Immediately flushes any events scheduled in the 'sync' queue. Bindings
+    use this queue so this method is a useful way to immediately force all
+    bindings in the application to sync.
+
+    You should call this method anytime you need any changed state to propagate
+    throughout the app immediately without repainting the UI (which happens
+    in the later 'render' queue added by the `ember-views` package).
 
-      for (var prop in hash) {
-        if (isStream(hash[prop])) {
-          containsStream = true;
-          break;
-        }
-      }
+    ```javascript
+    run.sync();
+    ```
 
-      return containsStream;
+    @method sync
+    @return {void}
+  */
+  run.sync = function() {
+    if (backburner.currentInstance) {
+      backburner.currentInstance.queues.sync.flush();
     }
+  };
 
-    __exports__.scanHash = scanHash;/**
-     Join an array, with any streams replaced by their current values
-
-     @private
-     @function concat
-     @param {Array} array An array containing zero or more stream objects and
-                          zero or more non-stream objects
-     @param {String} separator string to be used to join array elements
-     @return {String} String with array elements concatenated and joined by the
-                      provided separator, and any stream array members having been
-                      replaced by the current value of the stream
-     */
-    function concat(array, separator) {
-      // TODO: Create subclass ConcatStream < Stream. Defer
-      // subscribing to streams until the value() is called.
-      var hasStream = scanArray(array);
-      if (hasStream) {
-        var i, l;
-        var stream = new Stream(function() {
-          return readArray(array).join(separator);
-        });
+  /**
+    Invokes the passed target/method and optional arguments after a specified
+    period of time. The last parameter of this method must always be a number
+    of milliseconds.
 
-        for (i = 0, l=array.length; i < l; i++) {
-          subscribe(array[i], stream.notify, stream);
-        }
+    You should use this method whenever you need to run some action after a
+    period of time instead of using `setTimeout()`. This method will ensure that
+    items that expire during the same script execution cycle all execute
+    together, which is often more efficient than using a real setTimeout.
 
-        return stream;
-      } else {
-        return array.join(separator);
-      }
-    }
+    ```javascript
+    run.later(myContext, function() {
+      // code here will execute within a RunLoop in about 500ms with this == myContext
+    }, 500);
+    ```
 
-    __exports__.concat = concat;/**
-     Generate a new stream by providing a source stream and a function that can
-     be used to transform the stream's value. In the case of a non-stream object,
-     returns the result of the function.
+    @method later
+    @param {Object} [target] target of method to invoke
+    @param {Function|String} method The method to invoke.
+      If you pass a string it will be resolved on the
+      target at the time the method is invoked.
+    @param {Object} [args*] Optional arguments to pass to the timeout.
+    @param {Number} wait Number of milliseconds to wait.
+    @return {*} Timer information for use in cancelling, see `run.cancel`.
+  */
+  run.later = function(/*target, method*/) {
+    return backburner.later.apply(backburner, arguments);
+  };
+
+  /**
+    Schedule a function to run one time during the current RunLoop. This is equivalent
+    to calling `scheduleOnce` with the "actions" queue.
+
+    @method once
+    @param {Object} [target] The target of the method to invoke.
+    @param {Function|String} method The method to invoke.
+      If you pass a string it will be resolved on the
+      target at the time the method is invoked.
+    @param {Object} [args*] Optional arguments to pass to the timeout.
+    @return {Object} Timer information for use in cancelling, see `run.cancel`.
+  */
+  run.once = function(/*target, method */) {
+    checkAutoRun();
+    var length = arguments.length;
+    var args = new Array(length);
+    args[0] = 'actions';
+    for (var i = 0; i < length; i++) {
+      args[i + 1] = arguments[i];
+    }
+    return utils.apply(backburner, backburner.scheduleOnce, args);
+  };
+
+  /**
+    Schedules a function to run one time in a given queue of the current RunLoop.
+    Calling this method with the same queue/target/method combination will have
+    no effect (past the initial call).
+
+    Note that although you can pass optional arguments these will not be
+    considered when looking for duplicates. New arguments will replace previous
+    calls.
 
-     The value to transform would typically be available to the function you pass
-     to `chain()` via scope. For example:
+    ```javascript
+    function sayHi() {
+      console.log('hi');
+    }
 
-     ```javascript
-         var source = ...;  // stream returning a number
-                                // or a numeric (non-stream) object
-         var result = chain(source, function(){
-           var currentValue = read(source);
-           return currentValue + 1;
-         });
-     ```
+    run(function() {
+      run.scheduleOnce('afterRender', myContext, sayHi);
+      run.scheduleOnce('afterRender', myContext, sayHi);
+      // sayHi will only be executed once, in the afterRender queue of the RunLoop
+    });
+    ```
 
-     In the example, result is a stream if source is a stream, or a number of
-     source was numeric.
+    Also note that passing an anonymous function to `run.scheduleOnce` will
+    not prevent additional calls with an identical anonymous function from
+    scheduling the items multiple times, e.g.:
 
-     @private
-     @function chain
-     @param {Object|Stream} value A stream or non-stream object
-     @param {Function} fn function to be run when the stream value changes, or to
-                          be run once in the case of a non-stream object
-     @return {Object|Stream} In the case of a stream `value` parameter, a new
-                             stream that will be updated with the return value of
-                             the provided function `fn`. In the case of a
-                             non-stream object, the return value of the provided
-                             function `fn`.
-     */
-    function chain(value, fn) {
-      if (isStream(value)) {
-        var stream = new Stream(fn);
-        subscribe(value, stream.notify, stream);
-        return stream;
-      } else {
-        return fn();
-      }
+    ```javascript
+    function scheduleIt() {
+      run.scheduleOnce('actions', myContext, function() {
+        console.log('Closure');
+      });
     }
 
-    __exports__.chain = chain;
-  });
-enifed("ember-metal/utils",
-  ["ember-metal/core","ember-metal/platform","ember-metal/array","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-        // Remove "use strict"; from transpiled module until
-    // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
-    //
-    // REMOVE_USE_STRICT: true
+    scheduleIt();
+    scheduleIt();
 
-    var Ember = __dependency1__["default"];
-    var o_defineProperty = __dependency2__.defineProperty;
-    var canDefineNonEnumerableProperties = __dependency2__.canDefineNonEnumerableProperties;
-    var hasPropertyAccessors = __dependency2__.hasPropertyAccessors;
-    var o_create = __dependency2__.create;
+    // "Closure" will print twice, even though we're using `run.scheduleOnce`,
+    // because the function we pass to it is anonymous and won't match the
+    // previously scheduled operation.
+    ```
 
-    var forEach = __dependency3__.forEach;
+    Available queues, and their order, can be found at `run.queues`
+
+    @method scheduleOnce
+    @param {String} [queue] The name of the queue to schedule against. Default queues are 'sync' and 'actions'.
+    @param {Object} [target] The target of the method to invoke.
+    @param {Function|String} method The method to invoke.
+      If you pass a string it will be resolved on the
+      target at the time the method is invoked.
+    @param {Object} [args*] Optional arguments to pass to the timeout.
+    @return {Object} Timer information for use in cancelling, see `run.cancel`.
+  */
+  run.scheduleOnce = function(/*queue, target, method*/) {
+    checkAutoRun();
+    return backburner.scheduleOnce.apply(backburner, arguments);
+  };
+
+  /**
+    Schedules an item to run from within a separate run loop, after
+    control has been returned to the system. This is equivalent to calling
+    `run.later` with a wait time of 1ms.
 
-    /**
-    @module ember-metal
-    */
+    ```javascript
+    run.next(myContext, function() {
+      // code to be executed in the next run loop,
+      // which will be scheduled after the current one
+    });
+    ```
 
-    /**
-      Previously we used `Ember.$.uuid`, however `$.uuid` has been removed from
-      jQuery master. We'll just bootstrap our own uuid now.
+    Multiple operations scheduled with `run.next` will coalesce
+    into the same later run loop, along with any other operations
+    scheduled by `run.later` that expire right around the same
+    time that `run.next` operations will fire.
 
-      @private
-      @return {Number} the uuid
-    */
-    var _uuid = 0;
+    Note that there are often alternatives to using `run.next`.
+    For instance, if you'd like to schedule an operation to happen
+    after all DOM element operations have completed within the current
+    run loop, you can make use of the `afterRender` run loop queue (added
+    by the `ember-views` package, along with the preceding `render` queue
+    where all the DOM element operations happen). Example:
 
-    /**
-      Generates a universally unique identifier. This method
-      is used internally by Ember for assisting with
-      the generation of GUID's and other unique identifiers
-      such as `bind-attr` data attributes.
+    ```javascript
+    App.MyCollectionView = Ember.CollectionView.extend({
+      didInsertElement: function() {
+        run.scheduleOnce('afterRender', this, 'processChildElements');
+      },
+      processChildElements: function() {
+        // ... do something with collectionView's child view
+        // elements after they've finished rendering, which
+        // can't be done within the CollectionView's
+        // `didInsertElement` hook because that gets run
+        // before the child elements have been added to the DOM.
+      }
+    });
+    ```
 
-      @public
-      @return {Number} [description]
-     */
-    function uuid() {
-      return ++_uuid;
-    }
+    One benefit of the above approach compared to using `run.next` is
+    that you will be able to perform DOM/CSS operations before unprocessed
+    elements are rendered to the screen, which may prevent flickering or
+    other artifacts caused by delaying processing until after rendering.
+
+    The other major benefit to the above approach is that `run.next`
+    introduces an element of non-determinism, which can make things much
+    harder to test, due to its reliance on `setTimeout`; it's much harder
+    to guarantee the order of scheduled operations when they are scheduled
+    outside of the current run loop, i.e. with `run.next`.
+
+    @method next
+    @param {Object} [target] target of method to invoke
+    @param {Function|String} method The method to invoke.
+      If you pass a string it will be resolved on the
+      target at the time the method is invoked.
+    @param {Object} [args*] Optional arguments to pass to the timeout.
+    @return {Object} Timer information for use in cancelling, see `run.cancel`.
+  */
+  run.next = function() {
+    var args = slice.call(arguments);
+    args.push(1);
+    return utils.apply(backburner, backburner.later, args);
+  };
+
+  /**
+    Cancels a scheduled item. Must be a value returned by `run.later()`,
+    `run.once()`, `run.next()`, `run.debounce()`, or
+    `run.throttle()`.
 
-    __exports__.uuid = uuid;/**
-      Prefix used for guids through out Ember.
-      @private
-      @property GUID_PREFIX
-      @for Ember
-      @type String
-      @final
-    */
-    var GUID_PREFIX = 'ember';
+    ```javascript
+    var runNext = run.next(myContext, function() {
+      // will not be executed
+    });
 
-    // Used for guid generation...
-    var numberCache  = [];
-    var stringCache  = {};
+    run.cancel(runNext);
 
-    /**
-      Strongly hint runtimes to intern the provided string.
+    var runLater = run.later(myContext, function() {
+      // will not be executed
+    }, 500);
 
-      When do I need to use this function?
+    run.cancel(runLater);
 
-      For the most part, never. Pre-mature optimization is bad, and often the
-      runtime does exactly what you need it to, and more often the trade-off isn't
-      worth it.
+    var runOnce = run.once(myContext, function() {
+      // will not be executed
+    });
 
-      Why?
+    run.cancel(runOnce);
 
-      Runtimes store strings in at least 2 different representations:
-      Ropes and Symbols (interned strings). The Rope provides a memory efficient
-      data-structure for strings created from concatenation or some other string
-      manipulation like splitting.
+    var throttle = run.throttle(myContext, function() {
+      // will not be executed
+    }, 1, false);
 
-      Unfortunately checking equality of different ropes can be quite costly as
-      runtimes must resort to clever string comparison algorithims. These
-      algorithims typically cost in proportion to the length of the string.
-      Luckily, this is where the Symbols (interned strings) shine. As Symbols are
-      unique by their string content, equality checks can be done by pointer
-      comparison.
+    run.cancel(throttle);
 
-      How do I know if my string is a rope or symbol?
+    var debounce = run.debounce(myContext, function() {
+      // will not be executed
+    }, 1);
 
-      Typically (warning general sweeping statement, but truthy in runtimes at
-      present) static strings created as part of the JS source are interned.
-      Strings often used for comparisons can be interned at runtime if some
-      criteria are met.  One of these criteria can be the size of the entire rope.
-      For example, in chrome 38 a rope longer then 12 characters will not
-      intern, nor will segments of that rope.
+    run.cancel(debounce);
 
-      Some numbers: http://jsperf.com/eval-vs-keys/8
+    var debounceImmediate = run.debounce(myContext, function() {
+      // will be executed since we passed in true (immediate)
+    }, 100, true);
 
-      Known Trickâ„¢
+    // the 100ms delay until this method can be called again will be cancelled
+    run.cancel(debounceImmediate);
+    ```
 
-      @private
-      @return {String} interned version of the provided string
-    */
-    function intern(str) {
-      var obj = {};
-      obj[str] = 1;
-      for (var key in obj) {
-        if (key === str) return key;
-      }
-      return str;
+    @method cancel
+    @param {Object} timer Timer object to cancel
+    @return {Boolean} true if cancelled or false/undefined if it wasn't found
+  */
+  run.cancel = function(timer) {
+    return backburner.cancel(timer);
+  };
+
+  /**
+    Delay calling the target method until the debounce period has elapsed
+    with no additional debounce calls. If `debounce` is called again before
+    the specified time has elapsed, the timer is reset and the entire period
+    must pass again before the target method is called.
+
+    This method should be used when an event may be called multiple times
+    but the action should only be called once when the event is done firing.
+    A common example is for scroll events where you only want updates to
+    happen once scrolling has ceased.
+
+    ```javascript
+    function whoRan() {
+      console.log(this.name + ' ran.');
     }
 
-    /**
-      A unique key used to assign guids and other private metadata to objects.
-      If you inspect an object in your browser debugger you will often see these.
-      They can be safely ignored.
+    var myContext = { name: 'debounce' };
 
-      On browsers that support it, these properties are added with enumeration
-      disabled so they won't show up when you iterate over your properties.
+    run.debounce(myContext, whoRan, 150);
 
-      @private
-      @property GUID_KEY
-      @for Ember
-      @type String
-      @final
-    */
-    var GUID_KEY = intern('__ember' + (+ new Date()));
+    // less than 150ms passes
+    run.debounce(myContext, whoRan, 150);
 
-    var GUID_DESC = {
-      writable:    false,
-      configurable: false,
-      enumerable:  false,
-      value: null
-    };
+    // 150ms passes
+    // whoRan is invoked with context myContext
+    // console logs 'debounce ran.' one time.
+    ```
 
-    /**
-      Generates a new guid, optionally saving the guid to the object that you
-      pass in. You will rarely need to use this method. Instead you should
-      call `Ember.guidFor(obj)`, which return an existing guid if available.
+    Immediate allows you to run the function immediately, but debounce
+    other calls for this function until the wait time has elapsed. If
+    `debounce` is called again before the specified time has elapsed,
+    the timer is reset and the entire period must pass again before
+    the method can be called again.
 
-      @private
-      @method generateGuid
-      @for Ember
-      @param {Object} [obj] Object the guid will be used for. If passed in, the guid will
-        be saved on the object and reused whenever you pass the same object
-        again.
-
-        If no object is passed, just generate a new guid.
-      @param {String} [prefix] Prefix to place in front of the guid. Useful when you want to
-        separate the guid into separate namespaces.
-      @return {String} the guid
-    */
-    function generateGuid(obj, prefix) {
-      if (!prefix) prefix = GUID_PREFIX;
-      var ret = (prefix + uuid());
-      if (obj) {
-        if (obj[GUID_KEY] === null) {
-          obj[GUID_KEY] = ret;
-        } else {
-          GUID_DESC.value = ret;
-          o_defineProperty(obj, GUID_KEY, GUID_DESC);
-        }
-      }
-      return ret;
+    ```javascript
+    function whoRan() {
+      console.log(this.name + ' ran.');
     }
 
-    __exports__.generateGuid = generateGuid;/**
-      Returns a unique id for the object. If the object does not yet have a guid,
-      one will be assigned to it. You can call this on any object,
-      `Ember.Object`-based or not, but be aware that it will add a `_guid`
-      property.
+    var myContext = { name: 'debounce' };
 
-      You can also use this method on DOM Element objects.
+    run.debounce(myContext, whoRan, 150, true);
 
-      @private
-      @method guidFor
-      @for Ember
-      @param {Object} obj any object, string, number, Element, or primitive
-      @return {String} the unique guid for this instance.
-    */
-    function guidFor(obj) {
+    // console logs 'debounce ran.' one time immediately.
+    // 100ms passes
+    run.debounce(myContext, whoRan, 150, true);
 
-      // special cases where we don't want to add a key to object
-      if (obj === undefined) return "(undefined)";
-      if (obj === null) return "(null)";
+    // 150ms passes and nothing else is logged to the console and
+    // the debouncee is no longer being watched
+    run.debounce(myContext, whoRan, 150, true);
 
-      var ret;
-      var type = typeof obj;
+    // console logs 'debounce ran.' one time immediately.
+    // 150ms passes and nothing else is logged to the console and
+    // the debouncee is no longer being watched
 
-      // Don't allow prototype changes to String etc. to change the guidFor
-      switch(type) {
-        case 'number':
-          ret = numberCache[obj];
-          if (!ret) ret = numberCache[obj] = 'nu'+obj;
-          return ret;
+    ```
 
-        case 'string':
-          ret = stringCache[obj];
-          if (!ret) ret = stringCache[obj] = 'st' + uuid();
-          return ret;
+    @method debounce
+    @param {Object} [target] target of method to invoke
+    @param {Function|String} method The method to invoke.
+      May be a function or a string. If you pass a string
+      then it will be looked up on the passed target.
+    @param {Object} [args*] Optional arguments to pass to the timeout.
+    @param {Number} wait Number of milliseconds to wait.
+    @param {Boolean} immediate Trigger the function on the leading instead
+      of the trailing edge of the wait interval. Defaults to false.
+    @return {Array} Timer information for use in cancelling, see `run.cancel`.
+  */
+  run.debounce = function() {
+    return backburner.debounce.apply(backburner, arguments);
+  };
+
+  /**
+    Ensure that the target method is never called more frequently than
+    the specified spacing period. The target method is called immediately.
 
-        case 'boolean':
-          return obj ? '(true)' : '(false)';
+    ```javascript
+    function whoRan() {
+      console.log(this.name + ' ran.');
+    }
 
-        default:
-          if (obj[GUID_KEY]) return obj[GUID_KEY];
-          if (obj === Object) return '(Object)';
-          if (obj === Array)  return '(Array)';
-          ret = GUID_PREFIX + uuid();
+    var myContext = { name: 'throttle' };
 
-          if (obj[GUID_KEY] === null) {
-            obj[GUID_KEY] = ret;
-          } else {
-            GUID_DESC.value = ret;
-            o_defineProperty(obj, GUID_KEY, GUID_DESC);
-          }
-          return ret;
-      }
-    }
+    run.throttle(myContext, whoRan, 150);
+    // whoRan is invoked with context myContext
+    // console logs 'throttle ran.'
 
-    __exports__.guidFor = guidFor;// ..........................................................
-    // META
-    //
+    // 50ms passes
+    run.throttle(myContext, whoRan, 150);
 
-    var META_DESC = {
-      writable: true,
-      configurable: false,
-      enumerable: false,
-      value: null
-    };
+    // 50ms passes
+    run.throttle(myContext, whoRan, 150);
 
-    function Meta(obj) {
-      this.descs = {};
-      this.watching = {};
-      this.cache = {};
-      this.cacheMeta = {};
-      this.source = obj;
-      this.deps = undefined;
-      this.listeners = undefined;
-      this.mixins = undefined;
-      this.bindings = undefined;
-      this.chains = undefined;
-      this.values = undefined;
-      this.proto = undefined;
+    // 150ms passes
+    run.throttle(myContext, whoRan, 150);
+    // whoRan is invoked with context myContext
+    // console logs 'throttle ran.'
+    ```
+
+    @method throttle
+    @param {Object} [target] target of method to invoke
+    @param {Function|String} method The method to invoke.
+      May be a function or a string. If you pass a string
+      then it will be looked up on the passed target.
+    @param {Object} [args*] Optional arguments to pass to the timeout.
+    @param {Number} spacing Number of milliseconds to space out requests.
+    @param {Boolean} immediate Trigger the function on the leading instead
+      of the trailing edge of the wait interval. Defaults to true.
+    @return {Array} Timer information for use in cancelling, see `run.cancel`.
+  */
+  run.throttle = function() {
+    return backburner.throttle.apply(backburner, arguments);
+  };
+
+  // Make sure it's not an autorun during testing
+  function checkAutoRun() {
+    if (!run.currentRunLoop) {
+      Ember['default'].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", !Ember['default'].testing);
     }
+  }
 
-    Meta.prototype = {
-      chainWatchers: null
-    };
+  /**
+    Add a new named queue after the specified queue.
 
-    if (!canDefineNonEnumerableProperties) {
-      // on platforms that don't support enumerable false
-      // make meta fail jQuery.isPlainObject() to hide from
-      // jQuery.extend() by having a property that fails
-      // hasOwnProperty check.
-      Meta.prototype.__preventPlainObject__ = true;
+    The queue to add will only be added once.
 
-      // Without non-enumerable properties, meta objects will be output in JSON
-      // unless explicitly suppressed
-      Meta.prototype.toJSON = function () { };
+    @method _addQueue
+    @param {String} name the name of the queue to add.
+    @param {String} after the name of the queue to add after.
+    @private
+  */
+  run._addQueue = function(name, after) {
+    if (array.indexOf.call(run.queues, name) === -1) {
+      run.queues.splice(array.indexOf.call(run.queues, after)+1, 0, name);
     }
+  };
 
-    // Placeholder for non-writable metas.
-    var EMPTY_META = new Meta(null);
-
-    
-      if (hasPropertyAccessors) {
-        EMPTY_META.values = {};
-      }
-    
+});
+enifed('ember-metal/set_properties', ['exports', 'ember-metal/property_events', 'ember-metal/property_set', 'ember-metal/keys'], function (exports, property_events, property_set, keys) {
 
-    /**
-      Retrieves the meta hash for an object. If `writable` is true ensures the
-      hash is writable for this object as well.
+  'use strict';
 
-      The meta object contains information about computed property descriptors as
-      well as any watched properties and other information. You generally will
-      not access this information directly but instead work with higher level
-      methods that manipulate this hash indirectly.
+  function setProperties(obj, properties) {
+    if (!properties || typeof properties !== "object") { return obj; }
+    property_events.changeProperties(function() {
+      var props = keys['default'](properties);
+      var propertyName;
 
-      @method meta
-      @for Ember
-      @private
+      for (var i = 0, l = props.length; i < l; i++) {
+        propertyName = props[i];
 
-      @param {Object} obj The object to retrieve meta for
-      @param {Boolean} [writable=true] Pass `false` if you do not intend to modify
-        the meta hash, allowing the method to avoid making an unnecessary copy.
-      @return {Object} the meta hash for an object
-    */
-    function meta(obj, writable) {
-      var ret = obj['__ember_meta__'];
-      if (writable===false) return ret || EMPTY_META;
+        property_set.set(obj, propertyName, properties[propertyName]);
+      }
+    });
+    return obj;
+  }
+  exports['default'] = setProperties;
 
-      if (!ret) {
-        if (canDefineNonEnumerableProperties) o_defineProperty(obj, '__ember_meta__', META_DESC);
+});
+enifed('ember-metal/streams/conditional', ['exports', 'ember-metal/streams/stream', 'ember-metal/streams/utils', 'ember-metal/platform/create'], function (exports, Stream, utils, create) {
 
-        ret = new Meta(obj);
+  'use strict';
 
-        
-          if (hasPropertyAccessors) {
-            ret.values = {};
-          }
-        
+  function conditional(test, consequent, alternate) {
+    if (utils.isStream(test)) {
+      return new ConditionalStream(test, consequent, alternate);
+    } else {
+      if (test) {
+        return consequent;
+      } else {
+        return alternate;
+      }
+    }
+  }
+  exports['default'] = conditional;
 
-        obj['__ember_meta__'] = ret;
+  function ConditionalStream(test, consequent, alternate) {
+    this.init();
 
-        // make sure we don't accidentally try to create constructor like desc
-        ret.descs.constructor = null;
+    this.oldTestResult = undefined;
+    this.test = test;
+    this.consequent = consequent;
+    this.alternate = alternate;
+  }
 
-      } else if (ret.source !== obj) {
-        if (canDefineNonEnumerableProperties) o_defineProperty(obj, '__ember_meta__', META_DESC);
+  ConditionalStream.prototype = create['default'](Stream['default'].prototype);
 
-        ret = o_create(ret);
-        ret.descs     = o_create(ret.descs);
-        ret.watching  = o_create(ret.watching);
-        ret.cache     = {};
-        ret.cacheMeta = {};
-        ret.source    = obj;
+  ConditionalStream.prototype.valueFn = function() {
+    var oldTestResult = this.oldTestResult;
+    var newTestResult = !!utils.read(this.test);
 
-        
-          if (hasPropertyAccessors) {
-            ret.values = o_create(ret.values);
-          }
-        
+    if (newTestResult !== oldTestResult) {
+      switch (oldTestResult) {
+        case true: utils.unsubscribe(this.consequent, this.notify, this); break;
+        case false: utils.unsubscribe(this.alternate, this.notify, this); break;
+        case undefined: utils.subscribe(this.test, this.notify, this);
+      }
 
-        obj['__ember_meta__'] = ret;
+      switch (newTestResult) {
+        case true: utils.subscribe(this.consequent, this.notify, this); break;
+        case false: utils.subscribe(this.alternate, this.notify, this);
       }
-      return ret;
-    }
 
-    function getMeta(obj, property) {
-      var _meta = meta(obj, false);
-      return _meta[property];
+      this.oldTestResult = newTestResult;
     }
 
-    __exports__.getMeta = getMeta;function setMeta(obj, property, value) {
-      var _meta = meta(obj, true);
-      _meta[property] = value;
-      return value;
-    }
+    return newTestResult ? utils.read(this.consequent) : utils.read(this.alternate);
+  };
 
-    __exports__.setMeta = setMeta;/**
-      @deprecated
-      @private
+});
+enifed('ember-metal/streams/simple', ['exports', 'ember-metal/merge', 'ember-metal/streams/stream', 'ember-metal/platform/create', 'ember-metal/streams/utils'], function (exports, merge, Stream, create, utils) {
 
-      In order to store defaults for a class, a prototype may need to create
-      a default meta object, which will be inherited by any objects instantiated
-      from the class's constructor.
+  'use strict';
 
-      However, the properties of that meta object are only shallow-cloned,
-      so if a property is a hash (like the event system's `listeners` hash),
-      it will by default be shared across all instances of that class.
+  function SimpleStream(source) {
+    this.init();
+    this.source = source;
 
-      This method allows extensions to deeply clone a series of nested hashes or
-      other complex objects. For instance, the event system might pass
-      `['listeners', 'foo:change', 'ember157']` to `prepareMetaPath`, which will
-      walk down the keys provided.
+    if (utils.isStream(source)) {
+      source.subscribe(this._didChange, this);
+    }
+  }
 
-      For each key, if the key does not exist, it is created. If it already
-      exists and it was inherited from its constructor, the constructor's
-      key is cloned.
+  SimpleStream.prototype = create['default'](Stream['default'].prototype);
 
-      You can also pass false for `writable`, which will simply return
-      undefined if `prepareMetaPath` discovers any part of the path that
-      shared or undefined.
+  merge['default'](SimpleStream.prototype, {
+    valueFn: function() {
+      return utils.read(this.source);
+    },
 
-      @method metaPath
-      @for Ember
-      @param {Object} obj The object whose meta we are examining
-      @param {Array} path An array of keys to walk down
-      @param {Boolean} writable whether or not to create a new meta
-        (or meta property) if one does not already exist or if it's
-        shared with its constructor
-    */
-    function metaPath(obj, path, writable) {
-      Ember.deprecate("Ember.metaPath is deprecated and will be removed from future releases.");
-      var _meta = meta(obj, writable);
-      var keyName, value;
+    setValue: function(value) {
+      var source = this.source;
+
+      if (utils.isStream(source)) {
+        source.setValue(value);
+      }
+    },
 
-      for (var i=0, l=path.length; i<l; i++) {
-        keyName = path[i];
-        value = _meta[keyName];
+    setSource: function(nextSource) {
+      var prevSource = this.source;
+      if (nextSource !== prevSource) {
+        if (utils.isStream(prevSource)) {
+          prevSource.unsubscribe(this._didChange, this);
+        }
 
-        if (!value) {
-          if (!writable) { return undefined; }
-          value = _meta[keyName] = { __ember_source__: obj };
-        } else if (value.__ember_source__ !== obj) {
-          if (!writable) { return undefined; }
-          value = _meta[keyName] = o_create(value);
-          value.__ember_source__ = obj;
+        if (utils.isStream(nextSource)) {
+          nextSource.subscribe(this._didChange, this);
         }
 
-        _meta = value;
+        this.source = nextSource;
+        this.notify();
       }
+    },
 
-      return value;
+    _didChange: function() {
+      this.notify();
+    },
+
+    _super$destroy: Stream['default'].prototype.destroy,
+
+    destroy: function() {
+      if (this._super$destroy()) {
+        if (utils.isStream(this.source)) {
+          this.source.unsubscribe(this._didChange, this);
+        }
+        this.source = undefined;
+        return true;
+      }
     }
+  });
 
-    __exports__.metaPath = metaPath;/**
-      Wraps the passed function so that `this._super` will point to the superFunc
-      when the function is invoked. This is the primitive we use to implement
-      calls to super.
+  exports['default'] = SimpleStream;
 
-      @private
-      @method wrap
-      @for Ember
-      @param {Function} func The function to call
-      @param {Function} superFunc The super function.
-      @return {Function} wrapped function.
-    */
+});
+enifed('ember-metal/streams/stream', ['exports', 'ember-metal/platform/create', 'ember-metal/path_cache'], function (exports, create, path_cache) {
 
-    function wrap(func, superFunc) {
-      function superWrapper() {
-        var ret;
-        var sup  = this && this.__nextSuper;
-        var length = arguments.length;
+  'use strict';
 
-        if (this) {
-          this.__nextSuper = superFunc;
-        }
+  function Stream(fn) {
+    this.init();
+    this.valueFn = fn;
+  }
 
-        if (length === 0) {
-          ret = func.call(this);
-        } else if (length === 1) {
-          ret = func.call(this, arguments[0]);
-        } else if (length === 2) {
-          ret = func.call(this, arguments[0], arguments[1]);
-        } else {
-          var args = new Array(length);
-          for (var i = 0; i < length; i++) {
-            args[i] = arguments[i];
-          }
-          ret = apply(this, func, args);
-        }
+  Stream.prototype = {
+    isStream: true,
 
-        if (this) {
-          this.__nextSuper = sup;
-        }
+    init: function() {
+      this.state = 'dirty';
+      this.cache = undefined;
+      this.subscribers = undefined;
+      this.children = undefined;
+      this._label = undefined;
+    },
 
-        return ret;
+    get: function(path) {
+      var firstKey = path_cache.getFirstKey(path);
+      var tailPath = path_cache.getTailPath(path);
+
+      if (this.children === undefined) {
+        this.children = create['default'](null);
       }
 
-      superWrapper.wrappedFunction = func;
-      superWrapper.wrappedFunction.__ember_arity__ = func.length;
-      superWrapper.__ember_observes__ = func.__ember_observes__;
-      superWrapper.__ember_observesBefore__ = func.__ember_observesBefore__;
-      superWrapper.__ember_listens__ = func.__ember_listens__;
+      var keyStream = this.children[firstKey];
 
-      return superWrapper;
-    }
+      if (keyStream === undefined) {
+        keyStream = this._makeChildStream(firstKey, path);
+        this.children[firstKey] = keyStream;
+      }
 
-    __exports__.wrap = wrap;var EmberArray;
+      if (tailPath === undefined) {
+        return keyStream;
+      } else {
+        return keyStream.get(tailPath);
+      }
+    },
 
-    /**
-      Returns true if the passed object is an array or Array-like.
+    value: function() {
+      if (this.state === 'clean') {
+        return this.cache;
+      } else if (this.state === 'dirty') {
+        this.state = 'clean';
+        return this.cache = this.valueFn();
+      }
+      // TODO: Ensure value is never called on a destroyed stream
+      // so that we can uncomment this assertion.
+      //
+      // Ember.assert("Stream error: value was called in an invalid state: " + this.state);
+    },
 
-      Ember Array Protocol:
+    valueFn: function() {
+      throw new Error("Stream error: valueFn not implemented");
+    },
 
-        - the object has an objectAt property
-        - the object is a native Array
-        - the object is an Object, and has a length property
+    setValue: function() {
+      throw new Error("Stream error: setValue not implemented");
+    },
 
-      Unlike `Ember.typeOf` this method returns true even if the passed object is
-      not formally array but appears to be array-like (i.e. implements `Ember.Array`)
+    notify: function() {
+      this.notifyExcept();
+    },
 
-      ```javascript
-      Ember.isArray();                                          // false
-      Ember.isArray([]);                                        // true
-      Ember.isArray(Ember.ArrayProxy.create({ content: [] }));  // true
-      ```
+    notifyExcept: function(callbackToSkip, contextToSkip) {
+      if (this.state === 'clean') {
+        this.state = 'dirty';
+        this._notifySubscribers(callbackToSkip, contextToSkip);
+      }
+    },
 
-      @method isArray
-      @for Ember
-      @param {Object} obj The object to test
-      @return {Boolean} true if the passed object is an array or Array-like
-    */
-    // ES6TODO: Move up to runtime? This is only use in ember-metal by concatenatedProperties
-    function isArray(obj) {
-      var modulePath, type;
+    subscribe: function(callback, context) {
+      if (this.subscribers === undefined) {
+        this.subscribers = [callback, context];
+      } else {
+        this.subscribers.push(callback, context);
+      }
+    },
+
+    unsubscribe: function(callback, context) {
+      var subscribers = this.subscribers;
 
-      if (typeof EmberArray === "undefined") {
-        modulePath = 'ember-runtime/mixins/array';
-        if (Ember.__loader.registry[modulePath]) {
-          EmberArray = Ember.__loader.require(modulePath)['default'];
+      if (subscribers !== undefined) {
+        for (var i = 0, l = subscribers.length; i < l; i += 2) {
+          if (subscribers[i] === callback && subscribers[i+1] === context) {
+            subscribers.splice(i, 2);
+            return;
+          }
         }
       }
+    },
 
-      if (!obj || obj.setInterval) { return false; }
-      if (Array.isArray && Array.isArray(obj)) { return true; }
-      if (EmberArray && EmberArray.detect(obj)) { return true; }
+    _notifySubscribers: function(callbackToSkip, contextToSkip) {
+      var subscribers = this.subscribers;
 
-      type = typeOf(obj);
-      if ('array' === type) { return true; }
-      if ((obj.length !== undefined) && 'object' === type) { return true; }
-      return false;
-    }
+      if (subscribers !== undefined) {
+        for (var i = 0, l = subscribers.length; i < l; i += 2) {
+          var callback = subscribers[i];
+          var context = subscribers[i+1];
 
-    /**
-      Forces the passed object to be part of an array. If the object is already
-      an array or array-like, it will return the object. Otherwise, it will add the object to
-      an array. If obj is `null` or `undefined`, it will return an empty array.
+          if (callback === callbackToSkip && context === contextToSkip) {
+            continue;
+          }
 
-      ```javascript
-      Ember.makeArray();            // []
-      Ember.makeArray(null);        // []
-      Ember.makeArray(undefined);   // []
-      Ember.makeArray('lindsay');   // ['lindsay']
-      Ember.makeArray([1, 2, 42]);  // [1, 2, 42]
+          if (context === undefined) {
+            callback(this);
+          } else {
+            callback.call(context, this);
+          }
+        }
+      }
+    },
 
-      var controller = Ember.ArrayProxy.create({ content: [] });
+    destroy: function() {
+      if (this.state !== 'destroyed') {
+        this.state = 'destroyed';
 
-      Ember.makeArray(controller) === controller;  // true
-      ```
+        var children = this.children;
+        for (var key in children) {
+          children[key].destroy();
+        }
 
-      @method makeArray
-      @for Ember
-      @param {Object} obj the object
-      @return {Array}
-    */
-    function makeArray(obj) {
-      if (obj === null || obj === undefined) { return []; }
-      return isArray(obj) ? obj : [obj];
+        return true;
+      }
+    },
+
+    isGlobal: function() {
+      var stream = this;
+      while (stream !== undefined) {
+        if (stream._isRoot) {
+          return stream._isGlobal;
+        }
+        stream = stream.source;
+      }
     }
+  };
 
-    __exports__.makeArray = makeArray;/**
-      Checks to see if the `methodName` exists on the `obj`.
+  exports['default'] = Stream;
 
-      ```javascript
-      var foo = { bar: function() { return 'bar'; }, baz: null };
+});
+enifed('ember-metal/streams/stream_binding', ['exports', 'ember-metal/platform/create', 'ember-metal/merge', 'ember-metal/run_loop', 'ember-metal/streams/stream'], function (exports, create, merge, run, Stream) {
 
-      Ember.canInvoke(foo, 'bar'); // true
-      Ember.canInvoke(foo, 'baz'); // false
-      Ember.canInvoke(foo, 'bat'); // false
-      ```
+  'use strict';
 
-      @method canInvoke
-      @for Ember
-      @param {Object} obj The object to check for the method
-      @param {String} methodName The method name to check for
-      @return {Boolean}
-    */
-    function canInvoke(obj, methodName) {
-      return !!(obj && typeof obj[methodName] === 'function');
-    }
+  function StreamBinding(stream) {
+    Ember.assert("StreamBinding error: tried to bind to object that is not a stream", stream && stream.isStream);
 
-    /**
-      Checks to see if the `methodName` exists on the `obj`,
-      and if it does, invokes it with the arguments passed.
+    this.init();
+    this.stream = stream;
+    this.senderCallback = undefined;
+    this.senderContext = undefined;
+    this.senderValue = undefined;
 
-      ```javascript
-      var d = new Date('03/15/2013');
+    stream.subscribe(this._onNotify, this);
+  }
 
-      Ember.tryInvoke(d, 'getTime');              // 1363320000000
-      Ember.tryInvoke(d, 'setFullYear', [2014]);  // 1394856000000
-      Ember.tryInvoke(d, 'noSuchMethod', [2014]); // undefined
-      ```
+  StreamBinding.prototype = create['default'](Stream['default'].prototype);
 
-      @method tryInvoke
-      @for Ember
-      @param {Object} obj The object to check for the method
-      @param {String} methodName The method name to check for
-      @param {Array} [args] The arguments to pass to the method
-      @return {*} the return value of the invoked method or undefined if it cannot be invoked
-    */
-    function tryInvoke(obj, methodName, args) {
-      if (canInvoke(obj, methodName)) {
-        return args ? applyStr(obj, methodName, args) : applyStr(obj, methodName);
+  merge['default'](StreamBinding.prototype, {
+    valueFn: function() {
+      return this.stream.value();
+    },
+
+    _onNotify: function() {
+      this._scheduleSync(undefined, undefined, this);
+    },
+
+    setValue: function(value, callback, context) {
+      this._scheduleSync(value, callback, context);
+    },
+
+    _scheduleSync: function(value, callback, context) {
+      if (this.senderCallback === undefined && this.senderContext === undefined) {
+        this.senderCallback = callback;
+        this.senderContext = context;
+        this.senderValue = value;
+        run['default'].schedule('sync', this, this._sync);
+      } else if (this.senderContext !== this) {
+        this.senderCallback = callback;
+        this.senderContext = context;
+        this.senderValue = value;
       }
-    }
+    },
 
-    __exports__.tryInvoke = tryInvoke;// https://github.com/emberjs/ember.js/pull/1617
-    var needsFinallyFix = (function() {
-      var count = 0;
-      try{
-        try { }
-        finally {
-          count++;
-          throw new Error('needsFinallyFixTest');
-        }
-      } catch (e) {}
+    _sync: function() {
+      if (this.state === 'destroyed') {
+        return;
+      }
 
-      return count !== 1;
-    })();
+      if (this.senderContext !== this) {
+        this.stream.setValue(this.senderValue);
+      }
 
-    /**
-      Provides try/finally functionality, while working
-      around Safari's double finally bug.
+      var senderCallback = this.senderCallback;
+      var senderContext = this.senderContext;
+      this.senderCallback = undefined;
+      this.senderContext = undefined;
+      this.senderValue = undefined;
 
-      ```javascript
-      var tryable = function() {
-        someResource.lock();
-        runCallback(); // May throw error.
-      };
+      // Force StreamBindings to always notify
+      this.state = 'clean';
 
-      var finalizer = function() {
-        someResource.unlock();
-      };
+      this.notifyExcept(senderCallback, senderContext);
+    },
 
-      Ember.tryFinally(tryable, finalizer);
-      ```
+    _super$destroy: Stream['default'].prototype.destroy,
 
-      @method tryFinally
-      @for Ember
-      @param {Function} tryable The function to run the try callback
-      @param {Function} finalizer The function to run the finally callback
-      @param {Object} [binding] The optional calling object. Defaults to 'this'
-      @return {*} The return value is the that of the finalizer,
-      unless that value is undefined, in which case it is the return value
-      of the tryable
-    */
+    destroy: function() {
+      if (this._super$destroy()) {
+        this.stream.unsubscribe(this._onNotify, this);
+        return true;
+      }
+    }
+  });
 
-    var tryFinally;
-    if (needsFinallyFix) {
-      tryFinally = function(tryable, finalizer, binding) {
-        var result, finalResult, finalError;
+  exports['default'] = StreamBinding;
 
-        binding = binding || this;
+});
+enifed('ember-metal/streams/utils', ['exports', './stream'], function (exports, Stream) {
 
-        try {
-          result = tryable.call(binding);
-        } finally {
-          try {
-            finalResult = finalizer.call(binding);
-          } catch (e) {
-            finalError = e;
-          }
-        }
+  'use strict';
 
-        if (finalError) { throw finalError; }
+  exports.isStream = isStream;
+  exports.subscribe = subscribe;
+  exports.unsubscribe = unsubscribe;
+  exports.read = read;
+  exports.readArray = readArray;
+  exports.readHash = readHash;
+  exports.scanArray = scanArray;
+  exports.scanHash = scanHash;
+  exports.concat = concat;
+  exports.chain = chain;
 
-        return (finalResult === undefined) ? result : finalResult;
-      };
-    } else {
-      tryFinally = function(tryable, finalizer, binding) {
-        var result, finalResult;
+  function isStream(object) {
+    return object && object.isStream;
+  }
 
-        binding = binding || this;
+  /**
+   A method of subscribing to a stream which is safe for use with a non-stream
+   object. If a non-stream object is passed, the function does nothing.
+
+   @public
+   @for Ember.stream
+   @function subscribe
+   @param {Object|Stream} object object or stream to potentially subscribe to
+   @param {Function} callback function to run when stream value changes
+   @param {Object} [context] the callback will be executed with this context if it
+                             is provided
+   */
+  function subscribe(object, callback, context) {
+    if (object && object.isStream) {
+      object.subscribe(callback, context);
+    }
+  }
 
-        try {
-          result = tryable.call(binding);
-        } finally {
-          finalResult = finalizer.call(binding);
-        }
+  /**
+   A method of unsubscribing from a stream which is safe for use with a non-stream
+   object. If a non-stream object is passed, the function does nothing.
+
+   @public
+   @for Ember.stream
+   @function unsubscribe
+   @param {Object|Stream} object object or stream to potentially unsubscribe from
+   @param {Function} callback function originally passed to `subscribe()`
+   @param {Object} [context] object originally passed to `subscribe()`
+   */
+  function unsubscribe(object, callback, context) {
+    if (object && object.isStream) {
+      object.unsubscribe(callback, context);
+    }
+  }
 
-        return (finalResult === undefined) ? result : finalResult;
-      };
+  /**
+   Retrieve the value of a stream, or in the case a non-stream object is passed,
+   return the object itself.
+
+   @public
+   @for Ember.stream
+   @function read
+   @param {Object|Stream} object object to return the value of
+   @return the stream's current value, or the non-stream object itself
+   */
+  function read(object) {
+    if (object && object.isStream) {
+      return object.value();
+    } else {
+      return object;
     }
+  }
 
-    /**
-      Provides try/catch/finally functionality, while working
-      around Safari's double finally bug.
+  /**
+   Map an array, replacing any streams with their values.
+
+   @public
+   @for Ember.stream
+   @function readArray
+   @param {Array} array The array to read values from
+   @return {Array} a new array of the same length with the values of non-stream
+                   objects mapped from their original positions untouched, and
+                   the values of stream objects retaining their original position
+                   and replaced with the stream's current value.
+   */
+  function readArray(array) {
+    var length = array.length;
+    var ret = new Array(length);
+    for (var i = 0; i < length; i++) {
+      ret[i] = read(array[i]);
+    }
+    return ret;
+  }
 
-      ```javascript
-      var tryable = function() {
-        for (i = 0, l = listeners.length; i < l; i++) {
-          listener = listeners[i];
-          beforeValues[i] = listener.before(name, time(), payload);
-        }
+  /**
+   Map a hash, replacing any stream property values with the current value of that
+   stream.
+
+   @public
+   @for Ember.stream
+   @function readHash
+   @param {Object} object The hash to read keys and values from
+   @return {Object} a new object with the same keys as the passed object. The
+                    property values in the new object are the original values in
+                    the case of non-stream objects, and the streams' current
+                    values in the case of stream objects.
+   */
+  function readHash(object) {
+    var ret = {};
+    for (var key in object) {
+      ret[key] = read(object[key]);
+    }
+    return ret;
+  }
 
-        return callback.call(binding);
-      };
+  /**
+   Check whether an array contains any stream values
 
-      var catchable = function(e) {
-        payload = payload || {};
-        payload.exception = e;
-      };
+   @public
+   @for Ember.stream
+   @function scanArray
+   @param {Array} array array given to a handlebars helper
+   @return {Boolean} `true` if the array contains a stream/bound value, `false`
+                     otherwise
+  */
+  function scanArray(array) {
+    var length = array.length;
+    var containsStream = false;
 
-      var finalizer = function() {
-        for (i = 0, l = listeners.length; i < l; i++) {
-          listener = listeners[i];
-          listener.after(name, time(), payload, beforeValues[i]);
-        }
-      };
+    for (var i = 0; i < length; i++) {
+      if (isStream(array[i])) {
+        containsStream = true;
+        break;
+      }
+    }
 
-      Ember.tryCatchFinally(tryable, catchable, finalizer);
-      ```
+    return containsStream;
+  }
 
-      @method tryCatchFinally
-      @for Ember
-      @param {Function} tryable The function to run the try callback
-      @param {Function} catchable The function to run the catchable callback
-      @param {Function} finalizer The function to run the finally callback
-      @param {Object} [binding] The optional calling object. Defaults to 'this'
-      @return {*} The return value is the that of the finalizer,
-      unless that value is undefined, in which case it is the return value
-      of the tryable.
-    */
-    var tryCatchFinally;
-    if (needsFinallyFix) {
-      tryCatchFinally = function(tryable, catchable, finalizer, binding) {
-        var result, finalResult, finalError;
+  /**
+   Check whether a hash has any stream property values
 
-        binding = binding || this;
+   @public
+   @for Ember.stream
+   @function scanHash
+   @param {Object} hash "hash" argument given to a handlebars helper
+   @return {Boolean} `true` if the object contains a stream/bound value, `false`
+                     otherwise
+   */
+  function scanHash(hash) {
+    var containsStream = false;
 
-        try {
-          result = tryable.call(binding);
-        } catch(error) {
-          result = catchable.call(binding, error);
-        } finally {
-          try {
-            finalResult = finalizer.call(binding);
-          } catch (e) {
-            finalError = e;
-          }
-        }
+    for (var prop in hash) {
+      if (isStream(hash[prop])) {
+        containsStream = true;
+        break;
+      }
+    }
 
-        if (finalError) { throw finalError; }
+    return containsStream;
+  }
 
-        return (finalResult === undefined) ? result : finalResult;
-      };
+  /**
+   Join an array, with any streams replaced by their current values
+
+   @public
+   @for Ember.stream
+   @function concat
+   @param {Array} array An array containing zero or more stream objects and
+                        zero or more non-stream objects
+   @param {String} separator string to be used to join array elements
+   @return {String} String with array elements concatenated and joined by the
+                    provided separator, and any stream array members having been
+                    replaced by the current value of the stream
+   */
+  function concat(array, separator) {
+    // TODO: Create subclass ConcatStream < Stream. Defer
+    // subscribing to streams until the value() is called.
+    var hasStream = scanArray(array);
+    if (hasStream) {
+      var i, l;
+      var stream = new Stream['default'](function() {
+        return readArray(array).join(separator);
+      });
+
+      for (i = 0, l=array.length; i < l; i++) {
+        subscribe(array[i], stream.notify, stream);
+      }
+
+      return stream;
     } else {
-      tryCatchFinally = function(tryable, catchable, finalizer, binding) {
-        var result, finalResult;
+      return array.join(separator);
+    }
+  }
 
-        binding = binding || this;
+  /**
+   Generate a new stream by providing a source stream and a function that can
+   be used to transform the stream's value. In the case of a non-stream object,
+   returns the result of the function.
 
-        try {
-          result = tryable.call(binding);
-        } catch(error) {
-          result = catchable.call(binding, error);
-        } finally {
-          finalResult = finalizer.call(binding);
-        }
+   The value to transform would typically be available to the function you pass
+   to `chain()` via scope. For example:
 
-        return (finalResult === undefined) ? result : finalResult;
-      };
+   ```javascript
+       var source = ...;  // stream returning a number
+                              // or a numeric (non-stream) object
+       var result = chain(source, function() {
+         var currentValue = read(source);
+         return currentValue + 1;
+       });
+   ```
+
+   In the example, result is a stream if source is a stream, or a number of
+   source was numeric.
+
+   @public
+   @for Ember.stream
+   @function chain
+   @param {Object|Stream} value A stream or non-stream object
+   @param {Function} fn function to be run when the stream value changes, or to
+                        be run once in the case of a non-stream object
+   @return {Object|Stream} In the case of a stream `value` parameter, a new
+                           stream that will be updated with the return value of
+                           the provided function `fn`. In the case of a
+                           non-stream object, the return value of the provided
+                           function `fn`.
+   */
+  function chain(value, fn) {
+    if (isStream(value)) {
+      var stream = new Stream['default'](fn);
+      subscribe(value, stream.notify, stream);
+      return stream;
+    } else {
+      return fn();
     }
+  }
 
-    // ........................................
-    // TYPING & ARRAY MESSAGING
-    //
+});
+enifed('ember-metal/utils', ['exports', 'ember-metal/core', 'ember-metal/platform/create', 'ember-metal/platform/define_property', 'ember-metal/array'], function (exports, Ember, o_create, define_property, array) {
+
+
+  exports.uuid = uuid;
+  exports.generateGuid = generateGuid;
+  exports.guidFor = guidFor;
+  exports.getMeta = getMeta;
+  exports.setMeta = setMeta;
+  exports.metaPath = metaPath;
+  exports.wrap = wrap;
+  exports.makeArray = makeArray;
+  exports.tryInvoke = tryInvoke;
+  exports.inspect = inspect;
+  exports.apply = apply;
+  exports.applyStr = applyStr;
+  exports.meta = meta;
+  exports.typeOf = typeOf;
+  exports.isArray = isArray;
+  exports.canInvoke = canInvoke;
+
+  // Remove "use strict"; from transpiled module until
+  // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
+  //
+  "REMOVE_USE_STRICT: true";
+
+  var _uuid = 0;
+
+  /**
+    Generates a universally unique identifier. This method
+    is used internally by Ember for assisting with
+    the generation of GUID's and other unique identifiers
+    such as `bind-attr` data attributes.
+
+    @public
+    @return {Number} [description]
+   */
+  function uuid() {
+    return ++_uuid;
+  }
 
-    var TYPE_MAP = {};
-    var t = "Boolean Number String Function Array Date RegExp Object".split(" ");
-    forEach.call(t, function(name) {
-      TYPE_MAP[ "[object " + name + "]" ] = name.toLowerCase();
-    });
+  /**
+    Prefix used for guids through out Ember.
+    @private
+    @property GUID_PREFIX
+    @for Ember
+    @type String
+    @final
+  */
+  var GUID_PREFIX = 'ember';
 
-    var toString = Object.prototype.toString;
+  // Used for guid generation...
+  var numberCache  = [];
+  var stringCache  = {};
 
-    var EmberObject;
+  /**
+    Strongly hint runtimes to intern the provided string.
 
-    /**
-      Returns a consistent type for the passed item.
+    When do I need to use this function?
 
-      Use this instead of the built-in `typeof` to get the type of an item.
-      It will return the same result across all browsers and includes a bit
-      more detail. Here is what will be returned:
+    For the most part, never. Pre-mature optimization is bad, and often the
+    runtime does exactly what you need it to, and more often the trade-off isn't
+    worth it.
 
-          | Return Value  | Meaning                                              |
-          |---------------|------------------------------------------------------|
-          | 'string'      | String primitive or String object.                   |
-          | 'number'      | Number primitive or Number object.                   |
-          | 'boolean'     | Boolean primitive or Boolean object.                 |
-          | 'null'        | Null value                                           |
-          | 'undefined'   | Undefined value                                      |
-          | 'function'    | A function                                           |
-          | 'array'       | An instance of Array                                 |
-          | 'regexp'      | An instance of RegExp                                |
-          | 'date'        | An instance of Date                                  |
-          | 'class'       | An Ember class (created using Ember.Object.extend()) |
-          | 'instance'    | An Ember object instance                             |
-          | 'error'       | An instance of the Error object                      |
-          | 'object'      | A JavaScript object not inheriting from Ember.Object |
+    Why?
 
-      Examples:
+    Runtimes store strings in at least 2 different representations:
+    Ropes and Symbols (interned strings). The Rope provides a memory efficient
+    data-structure for strings created from concatenation or some other string
+    manipulation like splitting.
 
-      ```javascript
-      Ember.typeOf();                       // 'undefined'
-      Ember.typeOf(null);                   // 'null'
-      Ember.typeOf(undefined);              // 'undefined'
-      Ember.typeOf('michael');              // 'string'
-      Ember.typeOf(new String('michael'));  // 'string'
-      Ember.typeOf(101);                    // 'number'
-      Ember.typeOf(new Number(101));        // 'number'
-      Ember.typeOf(true);                   // 'boolean'
-      Ember.typeOf(new Boolean(true));      // 'boolean'
-      Ember.typeOf(Ember.makeArray);        // 'function'
-      Ember.typeOf([1, 2, 90]);             // 'array'
-      Ember.typeOf(/abc/);                  // 'regexp'
-      Ember.typeOf(new Date());             // 'date'
-      Ember.typeOf(Ember.Object.extend());  // 'class'
-      Ember.typeOf(Ember.Object.create());  // 'instance'
-      Ember.typeOf(new Error('teamocil'));  // 'error'
+    Unfortunately checking equality of different ropes can be quite costly as
+    runtimes must resort to clever string comparison algorithms. These
+    algorithms typically cost in proportion to the length of the string.
+    Luckily, this is where the Symbols (interned strings) shine. As Symbols are
+    unique by their string content, equality checks can be done by pointer
+    comparison.
 
-      // 'normal' JavaScript object
-      Ember.typeOf({ a: 'b' });             // 'object'
-      ```
+    How do I know if my string is a rope or symbol?
 
-      @method typeOf
-      @for Ember
-      @param {Object} item the item to check
-      @return {String} the type
-    */
-    function typeOf(item) {
-      var ret, modulePath;
+    Typically (warning general sweeping statement, but truthy in runtimes at
+    present) static strings created as part of the JS source are interned.
+    Strings often used for comparisons can be interned at runtime if some
+    criteria are met.  One of these criteria can be the size of the entire rope.
+    For example, in chrome 38 a rope longer then 12 characters will not
+    intern, nor will segments of that rope.
 
-      // ES6TODO: Depends on Ember.Object which is defined in runtime.
-      if (typeof EmberObject === "undefined") {
-        modulePath = 'ember-runtime/system/object';
-        if (Ember.__loader.registry[modulePath]) {
-          EmberObject = Ember.__loader.require(modulePath)['default'];
-        }
-      }
+    Some numbers: http://jsperf.com/eval-vs-keys/8
 
-      ret = (item === null || item === undefined) ? String(item) : TYPE_MAP[toString.call(item)] || 'object';
+    Known Trick™
 
-      if (ret === 'function') {
-        if (EmberObject && EmberObject.detect(item)) ret = 'class';
-      } else if (ret === 'object') {
-        if (item instanceof Error) ret = 'error';
-        else if (EmberObject && item instanceof EmberObject) ret = 'instance';
-        else if (item instanceof Date) ret = 'date';
+    @private
+    @return {String} interned version of the provided string
+  */
+  function intern(str) {
+    var obj = {};
+    obj[str] = 1;
+    for (var key in obj) {
+      if (key === str) {
+        return key;
       }
+    }
+    return str;
+  }
 
-      return ret;
+  /**
+    A unique key used to assign guids and other private metadata to objects.
+    If you inspect an object in your browser debugger you will often see these.
+    They can be safely ignored.
+
+    On browsers that support it, these properties are added with enumeration
+    disabled so they won't show up when you iterate over your properties.
+
+    @private
+    @property GUID_KEY
+    @for Ember
+    @type String
+    @final
+  */
+  var GUID_KEY = intern('__ember' + (+ new Date()));
+
+  var GUID_DESC = {
+    writable:     true,
+    configurable: true,
+    enumerable:   false,
+    value: null
+  };
+
+  var undefinedDescriptor = {
+    configurable: true,
+    writable: true,
+    enumerable: false,
+    value: undefined
+  };
+
+  var nullDescriptor = {
+    configurable: true,
+    writable: true,
+    enumerable: false,
+    value: null
+  };
+
+  var META_DESC = {
+    writable: true,
+    configurable: true,
+    enumerable: false,
+    value: null
+  };
+
+  var EMBER_META_PROPERTY = {
+    name: '__ember_meta__',
+    descriptor: META_DESC
+  };
+
+  var GUID_KEY_PROPERTY = {
+    name: GUID_KEY,
+    descriptor: nullDescriptor
+  };
+
+  var NEXT_SUPER_PROPERTY = {
+    name: '__nextSuper',
+    descriptor: undefinedDescriptor
+  };
+
+
+  /**
+    Generates a new guid, optionally saving the guid to the object that you
+    pass in. You will rarely need to use this method. Instead you should
+    call `Ember.guidFor(obj)`, which return an existing guid if available.
+
+    @private
+    @method generateGuid
+    @for Ember
+    @param {Object} [obj] Object the guid will be used for. If passed in, the guid will
+      be saved on the object and reused whenever you pass the same object
+      again.
+
+      If no object is passed, just generate a new guid.
+    @param {String} [prefix] Prefix to place in front of the guid. Useful when you want to
+      separate the guid into separate namespaces.
+    @return {String} the guid
+  */
+  function generateGuid(obj, prefix) {
+    if (!prefix) {
+      prefix = GUID_PREFIX;
+    }
+
+    var ret = (prefix + uuid());
+    if (obj) {
+      if (obj[GUID_KEY] === null) {
+        obj[GUID_KEY] = ret;
+      } else {
+        GUID_DESC.value = ret;
+        if (obj.__defineNonEnumerable) {
+          obj.__defineNonEnumerable(GUID_KEY_PROPERTY);
+        } else {
+          define_property.defineProperty(obj, GUID_KEY, GUID_DESC);
+        }
+      }
     }
+    return ret;
+  }
 
-    /**
-      Convenience method to inspect an object. This method will attempt to
-      convert the object into a useful string description.
+  /**
+    Returns a unique id for the object. If the object does not yet have a guid,
+    one will be assigned to it. You can call this on any object,
+    `Ember.Object`-based or not, but be aware that it will add a `_guid`
+    property.
 
-      It is a pretty simple implementation. If you want something more robust,
-      use something like JSDump: https://github.com/NV/jsDump
+    You can also use this method on DOM Element objects.
 
-      @method inspect
-      @for Ember
-      @param {Object} obj The object you want to inspect.
-      @return {String} A description of the object
-      @since 1.4.0
-    */
-    function inspect(obj) {
-      var type = typeOf(obj);
-      if (type === 'array') {
-        return '[' + obj + ']';
-      }
-      if (type !== 'object') {
-        return obj + '';
-      }
+    @private
+    @method guidFor
+    @for Ember
+    @param {Object} obj any object, string, number, Element, or primitive
+    @return {String} the unique guid for this instance.
+  */
+  function guidFor(obj) {
 
-      var v;
-      var ret = [];
-      for(var key in obj) {
-        if (obj.hasOwnProperty(key)) {
-          v = obj[key];
-          if (v === 'toString') { continue; } // ignore useless items
-          if (typeOf(v) === 'function') { v = "function() { ... }"; }
+    // special cases where we don't want to add a key to object
+    if (obj === undefined) {
+      return "(undefined)";
+    }
 
-          if (v && typeof v.toString !== 'function') {
-            ret.push(key + ": " + toString.call(v));
-          } else {
-            ret.push(key + ": " + v);
-          }
-        }
-      }
-      return "{" + ret.join(", ") + "}";
+    if (obj === null) {
+      return "(null)";
     }
 
-    __exports__.inspect = inspect;// The following functions are intentionally minified to keep the functions
-    // below Chrome's function body size inlining limit of 600 chars.
+    var ret;
+    var type = typeof obj;
 
-    function apply(t /* target */, m /* method */, a /* args */) {
-      var l = a && a.length;
-      if (!a || !l) { return m.call(t); }
-      switch (l) {
-        case 1:  return m.call(t, a[0]);
-        case 2:  return m.call(t, a[0], a[1]);
-        case 3:  return m.call(t, a[0], a[1], a[2]);
-        case 4:  return m.call(t, a[0], a[1], a[2], a[3]);
-        case 5:  return m.call(t, a[0], a[1], a[2], a[3], a[4]);
-        default: return m.apply(t, a);
-      }
-    }
+    // Don't allow prototype changes to String etc. to change the guidFor
+    switch (type) {
+      case 'number':
+        ret = numberCache[obj];
 
-    __exports__.apply = apply;function applyStr(t /* target */, m /* method */, a /* args */) {
-      var l = a && a.length;
-      if (!a || !l) { return t[m](); }
-      switch (l) {
-        case 1:  return t[m](a[0]);
-        case 2:  return t[m](a[0], a[1]);
-        case 3:  return t[m](a[0], a[1], a[2]);
-        case 4:  return t[m](a[0], a[1], a[2], a[3]);
-        case 5:  return t[m](a[0], a[1], a[2], a[3], a[4]);
-        default: return t[m].apply(t, a);
-      }
-    }
+        if (!ret) {
+          ret = numberCache[obj] = 'nu'+obj;
+        }
 
-    __exports__.applyStr = applyStr;__exports__.GUID_KEY = GUID_KEY;
-    __exports__.META_DESC = META_DESC;
-    __exports__.EMPTY_META = EMPTY_META;
-    __exports__.meta = meta;
-    __exports__.typeOf = typeOf;
-    __exports__.tryCatchFinally = tryCatchFinally;
-    __exports__.isArray = isArray;
-    __exports__.canInvoke = canInvoke;
-    __exports__.tryFinally = tryFinally;
-  });
-enifed("ember-metal/watch_key",
-  ["ember-metal/core","ember-metal/utils","ember-metal/platform","ember-metal/properties","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var metaFor = __dependency2__.meta;
-    var typeOf = __dependency2__.typeOf;
-    var o_defineProperty = __dependency3__.defineProperty;
-    var hasPropertyAccessors = __dependency3__.hasPropertyAccessors;
-    var MANDATORY_SETTER_FUNCTION = __dependency4__.MANDATORY_SETTER_FUNCTION;
-    var DEFAULT_GETTER_FUNCTION = __dependency4__.DEFAULT_GETTER_FUNCTION;
+        return ret;
+
+      case 'string':
+        ret = stringCache[obj];
 
-    function watchKey(obj, keyName, meta) {
-      // can't watch length on Array - it is special...
-      if (keyName === 'length' && typeOf(obj) === 'array') { return; }
+        if (!ret) {
+          ret = stringCache[obj] = 'st' + uuid();
+        }
+
+        return ret;
+
+      case 'boolean':
+        return obj ? '(true)' : '(false)';
 
-      var m = meta || metaFor(obj), watching = m.watching;
+      default:
+        if (obj[GUID_KEY]) {
+          return obj[GUID_KEY];
+        }
+
+        if (obj === Object) {
+          return '(Object)';
+        }
 
-      // activate watching first time
-      if (!watching[keyName]) {
-        watching[keyName] = 1;
+        if (obj === Array) {
+          return '(Array)';
+        }
 
-        var desc = m.descs[keyName];
-        if (desc && desc.willWatch) { desc.willWatch(obj, keyName); }
+        ret = GUID_PREFIX + uuid();
 
-        if ('function' === typeof obj.willWatchProperty) {
-          obj.willWatchProperty(keyName);
-        }
+        if (obj[GUID_KEY] === null) {
+          obj[GUID_KEY] = ret;
+        } else {
+          GUID_DESC.value = ret;
 
-        
-          if (hasPropertyAccessors) {
-            handleMandatorySetter(m, obj, keyName);
+          if (obj.__defineNonEnumerable) {
+            obj.__defineNonEnumerable(GUID_KEY_PROPERTY);
+          } else {
+            define_property.defineProperty(obj, GUID_KEY, GUID_DESC);
           }
-        
-      } else {
-        watching[keyName] = (watching[keyName] || 0) + 1;
-      }
+        }
+        return ret;
     }
+  }
 
-    __exports__.watchKey = watchKey;
-    
-      var handleMandatorySetter = function handleMandatorySetter(m, obj, keyName) {
-        var descriptor = Object.getOwnPropertyDescriptor && Object.getOwnPropertyDescriptor(obj, keyName);
-        var configurable = descriptor ? descriptor.configurable : true;
-        var isWritable = descriptor ? descriptor.writable : true;
-        var hasValue = descriptor ? 'value' in descriptor : true;
-
-        // this x in Y deopts, so keeping it in this function is better;
-        if (configurable && isWritable && hasValue && keyName in obj) {
-          m.values[keyName] = obj[keyName];
-          o_defineProperty(obj, keyName, {
-            configurable: true,
-            enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName),
-            set: MANDATORY_SETTER_FUNCTION(keyName),
-            get: DEFAULT_GETTER_FUNCTION(keyName)
-          });
-        }
-      };
-    
+  // ..........................................................
+  // META
+  //
+  function Meta(obj) {
+    this.watching = {};
+    this.cache = undefined;
+    this.cacheMeta = undefined;
+    this.source = obj;
+    this.deps = undefined;
+    this.listeners = undefined;
+    this.mixins = undefined;
+    this.bindings = undefined;
+    this.chains = undefined;
+    this.values = undefined;
+    this.proto = undefined;
+  }
 
-    function unwatchKey(obj, keyName, meta) {
-      var m = meta || metaFor(obj);
-      var watching = m.watching;
+  Meta.prototype = {
+    chainWatchers: null // FIXME
+  };
 
-      if (watching[keyName] === 1) {
-        watching[keyName] = 0;
+  if (!define_property.canDefineNonEnumerableProperties) {
+    // on platforms that don't support enumerable false
+    // make meta fail jQuery.isPlainObject() to hide from
+    // jQuery.extend() by having a property that fails
+    // hasOwnProperty check.
+    Meta.prototype.__preventPlainObject__ = true;
 
-        var desc = m.descs[keyName];
-        if (desc && desc.didUnwatch) { desc.didUnwatch(obj, keyName); }
+    // Without non-enumerable properties, meta objects will be output in JSON
+    // unless explicitly suppressed
+    Meta.prototype.toJSON = function () { };
+  }
 
-        if ('function' === typeof obj.didUnwatchProperty) {
-          obj.didUnwatchProperty(keyName);
-        }
+  // Placeholder for non-writable metas.
+  var EMPTY_META = new Meta(null);
 
-        
-          if (hasPropertyAccessors && keyName in obj) {
-            o_defineProperty(obj, keyName, {
-              configurable: true,
-              enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName),
-              set: function(val) {
-                // redefine to set as enumerable
-                o_defineProperty(obj, keyName, {
-                  configurable: true,
-                  writable: true,
-                  enumerable: true,
-                  value: val
-                });
-                delete m.values[keyName];
-              },
-              get: DEFAULT_GETTER_FUNCTION(keyName)
-            });
-          }
-        
-      } else if (watching[keyName] > 1) {
-        watching[keyName]--;
-      }
-    }
 
-    __exports__.unwatchKey = unwatchKey;
-  });
-enifed("ember-metal/watch_path",
-  ["ember-metal/utils","ember-metal/chains","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var metaFor = __dependency1__.meta;
-    var typeOf = __dependency1__.typeOf;
-    var ChainNode = __dependency2__.ChainNode;
-
-    // get the chains for the current object. If the current object has
-    // chains inherited from the proto they will be cloned and reconfigured for
-    // the current object.
-    function chainsFor(obj, meta) {
-      var m = meta || metaFor(obj);
-      var ret = m.chains;
-      if (!ret) {
-        ret = m.chains = new ChainNode(null, null, obj);
-      } else if (ret.value() !== obj) {
-        ret = m.chains = ret.copy(obj);
-      }
-      return ret;
+    if (define_property.hasPropertyAccessors) {
+      EMPTY_META.values = {};
     }
 
-    function watchPath(obj, keyPath, meta) {
-      // can't watch length on Array - it is special...
-      if (keyPath === 'length' && typeOf(obj) === 'array') { return; }
 
-      var m = meta || metaFor(obj);
-      var watching = m.watching;
+  /**
+    Retrieves the meta hash for an object. If `writable` is true ensures the
+    hash is writable for this object as well.
 
-      if (!watching[keyPath]) { // activate watching first time
-        watching[keyPath] = 1;
-        chainsFor(obj, m).add(keyPath);
-      } else {
-        watching[keyPath] = (watching[keyPath] || 0) + 1;
-      }
-    }
+    The meta object contains information about computed property descriptors as
+    well as any watched properties and other information. You generally will
+    not access this information directly but instead work with higher level
+    methods that manipulate this hash indirectly.
 
-    __exports__.watchPath = watchPath;function unwatchPath(obj, keyPath, meta) {
-      var m = meta || metaFor(obj);
-      var watching = m.watching;
+    @method meta
+    @for Ember
+    @private
 
-      if (watching[keyPath] === 1) {
-        watching[keyPath] = 0;
-        chainsFor(obj, m).remove(keyPath);
-      } else if (watching[keyPath] > 1) {
-        watching[keyPath]--;
-      }
+    @param {Object} obj The object to retrieve meta for
+    @param {Boolean} [writable=true] Pass `false` if you do not intend to modify
+      the meta hash, allowing the method to avoid making an unnecessary copy.
+    @return {Object} the meta hash for an object
+  */
+  function meta(obj, writable) {
+    var ret = obj.__ember_meta__;
+    if (writable===false) {
+      return ret || EMPTY_META;
     }
 
-    __exports__.unwatchPath = unwatchPath;
-  });
-enifed("ember-metal/watching",
-  ["ember-metal/utils","ember-metal/chains","ember-metal/watch_key","ember-metal/watch_path","ember-metal/path_cache","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
-    /**
-    @module ember-metal
-    */
+    if (!ret) {
+      if (define_property.canDefineNonEnumerableProperties) {
+        if (obj.__defineNonEnumerable) {
+          obj.__defineNonEnumerable(EMBER_META_PROPERTY);
+        } else {
+          define_property.defineProperty(obj, '__ember_meta__', META_DESC);
+        }
+      }
 
-    var typeOf = __dependency1__.typeOf;
-    var removeChainWatcher = __dependency2__.removeChainWatcher;
-    var flushPendingChains = __dependency2__.flushPendingChains;
-    var watchKey = __dependency3__.watchKey;
-    var unwatchKey = __dependency3__.unwatchKey;
-    var watchPath = __dependency4__.watchPath;
-    var unwatchPath = __dependency4__.unwatchPath;
+      ret = new Meta(obj);
 
-    var isPath = __dependency5__.isPath;
 
-    /**
-      Starts watching a property on an object. Whenever the property changes,
-      invokes `Ember.propertyWillChange` and `Ember.propertyDidChange`. This is the
-      primitive used by observers and dependent keys; usually you will never call
-      this method directly but instead use higher level methods like
-      `Ember.addObserver()`
+        if (define_property.hasPropertyAccessors) {
+          ret.values = {};
+        }
 
-      @private
-      @method watch
-      @for Ember
-      @param obj
-      @param {String} keyName
-    */
-    function watch(obj, _keyPath, m) {
-      // can't watch length on Array - it is special...
-      if (_keyPath === 'length' && typeOf(obj) === 'array') { return; }
 
-      if (!isPath(_keyPath)) {
-        watchKey(obj, _keyPath, m);
+      obj.__ember_meta__ = ret;
+    } else if (ret.source !== obj) {
+      if (obj.__defineNonEnumerable) {
+        obj.__defineNonEnumerable(EMBER_META_PROPERTY);
       } else {
-        watchPath(obj, _keyPath, m);
+        define_property.defineProperty(obj, '__ember_meta__', META_DESC);
       }
-    }
 
-    __exports__.watch = watch;
+      ret = o_create['default'](ret);
+      ret.watching  = o_create['default'](ret.watching);
+      ret.cache     = undefined;
+      ret.cacheMeta = undefined;
+      ret.source    = obj;
 
-    function isWatching(obj, key) {
-      var meta = obj['__ember_meta__'];
-      return (meta && meta.watching[key]) > 0;
-    }
 
-    __exports__.isWatching = isWatching;watch.flushPending = flushPendingChains;
+        if (define_property.hasPropertyAccessors) {
+          ret.values = o_create['default'](ret.values);
+        }
 
-    function unwatch(obj, _keyPath, m) {
-      // can't watch length on Array - it is special...
-      if (_keyPath === 'length' && typeOf(obj) === 'array') { return; }
 
-      if (!isPath(_keyPath)) {
-        unwatchKey(obj, _keyPath, m);
-      } else {
-        unwatchPath(obj, _keyPath, m);
-      }
+      obj['__ember_meta__'] = ret;
     }
+    return ret;
+  }
 
-    __exports__.unwatch = unwatch;var NODE_STACK = [];
+  function getMeta(obj, property) {
+    var _meta = meta(obj, false);
+    return _meta[property];
+  }
 
-    /**
-      Tears down the meta on an object so that it can be garbage collected.
-      Multiple calls will have no effect.
+  function setMeta(obj, property, value) {
+    var _meta = meta(obj, true);
+    _meta[property] = value;
+    return value;
+  }
 
-      @method destroy
-      @for Ember
-      @param {Object} obj  the object to destroy
-      @return {void}
-    */
-    function destroy(obj) {
-      var meta = obj['__ember_meta__'], node, nodes, key, nodeObject;
-      if (meta) {
-        obj['__ember_meta__'] = null;
-        // remove chainWatchers to remove circular references that would prevent GC
-        node = meta.chains;
-        if (node) {
-          NODE_STACK.push(node);
-          // process tree
-          while (NODE_STACK.length > 0) {
-            node = NODE_STACK.pop();
-            // push children
-            nodes = node._chains;
-            if (nodes) {
-              for (key in nodes) {
-                if (nodes.hasOwnProperty(key)) {
-                  NODE_STACK.push(nodes[key]);
-                }
-              }
-            }
-            // remove chainWatcher in node object
-            if (node._watching) {
-              nodeObject = node._object;
-              if (nodeObject) {
-                removeChainWatcher(nodeObject, node._key, node);
-              }
-            }
-          }
+  /**
+    @deprecated
+    @private
+
+    In order to store defaults for a class, a prototype may need to create
+    a default meta object, which will be inherited by any objects instantiated
+    from the class's constructor.
+
+    However, the properties of that meta object are only shallow-cloned,
+    so if a property is a hash (like the event system's `listeners` hash),
+    it will by default be shared across all instances of that class.
+
+    This method allows extensions to deeply clone a series of nested hashes or
+    other complex objects. For instance, the event system might pass
+    `['listeners', 'foo:change', 'ember157']` to `prepareMetaPath`, which will
+    walk down the keys provided.
+
+    For each key, if the key does not exist, it is created. If it already
+    exists and it was inherited from its constructor, the constructor's
+    key is cloned.
+
+    You can also pass false for `writable`, which will simply return
+    undefined if `prepareMetaPath` discovers any part of the path that
+    shared or undefined.
+
+    @method metaPath
+    @for Ember
+    @param {Object} obj The object whose meta we are examining
+    @param {Array} path An array of keys to walk down
+    @param {Boolean} writable whether or not to create a new meta
+      (or meta property) if one does not already exist or if it's
+      shared with its constructor
+  */
+  function metaPath(obj, path, writable) {
+    Ember['default'].deprecate("Ember.metaPath is deprecated and will be removed from future releases.");
+    var _meta = meta(obj, writable);
+    var keyName, value;
+
+    for (var i=0, l=path.length; i<l; i++) {
+      keyName = path[i];
+      value = _meta[keyName];
+
+      if (!value) {
+        if (!writable) { return undefined; }
+        value = _meta[keyName] = { __ember_source__: obj };
+      } else if (value.__ember_source__ !== obj) {
+        if (!writable) { return undefined; }
+        value = _meta[keyName] = o_create['default'](value);
+        value.__ember_source__ = obj;
+      }
+
+      _meta = value;
+    }
+
+    return value;
+  }
+
+  /**
+    Wraps the passed function so that `this._super` will point to the superFunc
+    when the function is invoked. This is the primitive we use to implement
+    calls to super.
+
+    @private
+    @method wrap
+    @for Ember
+    @param {Function} func The function to call
+    @param {Function} superFunc The super function.
+    @return {Function} wrapped function.
+  */
+
+  function wrap(func, superFunc) {
+    function superWrapper() {
+      var ret;
+      var sup  = this && this.__nextSuper;
+      var length = arguments.length;
+
+      if (this) {
+        this.__nextSuper = superFunc;
+      }
+
+      if (length === 0) {
+        ret = func.call(this);
+      } else if (length === 1) {
+        ret = func.call(this, arguments[0]);
+      } else if (length === 2) {
+        ret = func.call(this, arguments[0], arguments[1]);
+      } else {
+        var args = new Array(length);
+        for (var i = 0; i < length; i++) {
+          args[i] = arguments[i];
         }
+        ret = apply(this, func, args);
+      }
+
+      if (this) {
+        this.__nextSuper = sup;
       }
+
+      return ret;
     }
 
-    __exports__.destroy = destroy;
-  });
-enifed("ember-routing-htmlbars",
-  ["ember-metal/core","ember-htmlbars/helpers","ember-routing-htmlbars/helpers/outlet","ember-routing-htmlbars/helpers/render","ember-routing-htmlbars/helpers/link-to","ember-routing-htmlbars/helpers/action","ember-routing-htmlbars/helpers/query-params","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
-    "use strict";
-    /**
-    Ember Routing HTMLBars Helpers
+    superWrapper.wrappedFunction = func;
+    superWrapper.__ember_observes__ = func.__ember_observes__;
+    superWrapper.__ember_observesBefore__ = func.__ember_observesBefore__;
+    superWrapper.__ember_listens__ = func.__ember_listens__;
 
-    @module ember
-    @submodule ember-routing-htmlbars
-    @requires ember-routing
-    */
+    return superWrapper;
+  }
 
-    var Ember = __dependency1__["default"];
+  var EmberArray;
 
-    var registerHelper = __dependency2__.registerHelper;
+  /**
+    Returns true if the passed object is an array or Array-like.
 
-    var outletHelper = __dependency3__.outletHelper;
-    var renderHelper = __dependency4__.renderHelper;
-    var linkToHelper = __dependency5__.linkToHelper;
-    var deprecatedLinkToHelper = __dependency5__.deprecatedLinkToHelper;
-    var actionHelper = __dependency6__.actionHelper;
-    var queryParamsHelper = __dependency7__.queryParamsHelper;
+    Ember Array Protocol:
 
-    registerHelper('outlet', outletHelper);
-    registerHelper('render', renderHelper);
-    registerHelper('link-to', linkToHelper);
-    registerHelper('linkTo', deprecatedLinkToHelper);
-    registerHelper('action', actionHelper);
-    registerHelper('query-params', queryParamsHelper);
+      - the object has an objectAt property
+      - the object is a native Array
+      - the object is an Object, and has a length property
 
-    __exports__["default"] = Ember;
-  });
-enifed("ember-routing-htmlbars/helpers/action",
-  ["ember-metal/core","ember-metal/utils","ember-metal/run_loop","ember-views/streams/utils","ember-views/system/utils","ember-views/system/action_manager","ember-metal/array","ember-metal/streams/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-routing-htmlbars
-    */
+    Unlike `Ember.typeOf` this method returns true even if the passed object is
+    not formally array but appears to be array-like (i.e. implements `Ember.Array`)
 
-    var Ember = __dependency1__["default"];
-    // Handlebars, uuid, FEATURES, assert, deprecate
-    var uuid = __dependency2__.uuid;
-    var run = __dependency3__["default"];
-    var readUnwrappedModel = __dependency4__.readUnwrappedModel;
-    var isSimpleClick = __dependency5__.isSimpleClick;
-    var ActionManager = __dependency6__["default"];
-    var indexOf = __dependency7__.indexOf;
-    var isStream = __dependency8__.isStream;
+    ```javascript
+    Ember.isArray();                                          // false
+    Ember.isArray([]);                                        // true
+    Ember.isArray(Ember.ArrayProxy.create({ content: [] }));  // true
+    ```
 
-    function actionArgs(parameters, actionName) {
-      var ret, i, l;
+    @method isArray
+    @for Ember
+    @param {Object} obj The object to test
+    @return {Boolean} true if the passed object is an array or Array-like
+  */
+  // ES6TODO: Move up to runtime? This is only use in ember-metal by concatenatedProperties
+  function isArray(obj) {
+    var modulePath, type;
 
-      if (actionName === undefined) {
-        ret = new Array(parameters.length);
-        for (i=0, l=parameters.length;i<l;i++) {
-          ret[i] = readUnwrappedModel(parameters[i]);
-        }
-      } else {
-        ret = new Array(parameters.length + 1);
-        ret[0] = actionName;
-        for (i=0, l=parameters.length;i<l; i++) {
-          ret[i + 1] = readUnwrappedModel(parameters[i]);
-        }
+    if (typeof EmberArray === "undefined") {
+      modulePath = 'ember-runtime/mixins/array';
+      if (Ember['default'].__loader.registry[modulePath]) {
+        EmberArray = Ember['default'].__loader.require(modulePath)['default'];
       }
-
-      return ret;
     }
 
-    var ActionHelper = {};
+    if (!obj || obj.setInterval) { return false; }
+    if (Array.isArray && Array.isArray(obj)) { return true; }
+    if (EmberArray && EmberArray.detect(obj)) { return true; }
 
-    // registeredActions is re-exported for compatibility with older plugins
-    // that were using this undocumented API.
-    ActionHelper.registeredActions = ActionManager.registeredActions;
+    type = typeOf(obj);
+    if ('array' === type) { return true; }
+    if ((obj.length !== undefined) && 'object' === type) { return true; }
+    return false;
+  }
 
-    __exports__.ActionHelper = ActionHelper;
+  /**
+    Forces the passed object to be part of an array. If the object is already
+    an array or array-like, it will return the object. Otherwise, it will add the object to
+    an array. If obj is `null` or `undefined`, it will return an empty array.
 
-    var keys = ["alt", "shift", "meta", "ctrl"];
+    ```javascript
+    Ember.makeArray();            // []
+    Ember.makeArray(null);        // []
+    Ember.makeArray(undefined);   // []
+    Ember.makeArray('lindsay');   // ['lindsay']
+    Ember.makeArray([1, 2, 42]);  // [1, 2, 42]
 
-    var POINTER_EVENT_TYPE_REGEX = /^click|mouse|touch/;
+    var controller = Ember.ArrayProxy.create({ content: [] });
 
-    var isAllowedEvent = function(event, allowedKeys) {
-      if (typeof allowedKeys === "undefined") {
-        if (POINTER_EVENT_TYPE_REGEX.test(event.type)) {
-          return isSimpleClick(event);
-        } else {
-          allowedKeys = '';
-        }
-      }
+    Ember.makeArray(controller) === controller;  // true
+    ```
 
-      if (allowedKeys.indexOf("any") >= 0) {
-        return true;
-      }
+    @method makeArray
+    @for Ember
+    @param {Object} obj the object
+    @return {Array}
+  */
+  function makeArray(obj) {
+    if (obj === null || obj === undefined) { return []; }
+    return isArray(obj) ? obj : [obj];
+  }
 
-      for (var i=0, l=keys.length;i<l;i++) {
-        if (event[keys[i] + "Key"] && allowedKeys.indexOf(keys[i]) === -1) {
-          return false;
-        }
-      }
+  /**
+    Checks to see if the `methodName` exists on the `obj`.
 
-      return true;
-    };
+    ```javascript
+    var foo = { bar: function() { return 'bar'; }, baz: null };
+
+    Ember.canInvoke(foo, 'bar'); // true
+    Ember.canInvoke(foo, 'baz'); // false
+    Ember.canInvoke(foo, 'bat'); // false
+    ```
+
+    @method canInvoke
+    @for Ember
+    @param {Object} obj The object to check for the method
+    @param {String} methodName The method name to check for
+    @return {Boolean}
+  */
+  function canInvoke(obj, methodName) {
+    return !!(obj && typeof obj[methodName] === 'function');
+  }
+
+  /**
+    Checks to see if the `methodName` exists on the `obj`,
+    and if it does, invokes it with the arguments passed.
+
+    ```javascript
+    var d = new Date('03/15/2013');
 
-    var keyEvents = ['keyUp', 'keyPress', 'keyDown'];
+    Ember.tryInvoke(d, 'getTime');              // 1363320000000
+    Ember.tryInvoke(d, 'setFullYear', [2014]);  // 1394856000000
+    Ember.tryInvoke(d, 'noSuchMethod', [2014]); // undefined
+    ```
 
-    function ignoreKeyEvent(eventName, event, keyCode) {
-      var any = 'any';
-      keyCode = keyCode || any;
-      return indexOf.call(keyEvents, eventName) !== -1 && keyCode !== any && keyCode !== event.which.toString();
+    @method tryInvoke
+    @for Ember
+    @param {Object} obj The object to check for the method
+    @param {String} methodName The method name to check for
+    @param {Array} [args] The arguments to pass to the method
+    @return {*} the return value of the invoked method or undefined if it cannot be invoked
+  */
+  function tryInvoke(obj, methodName, args) {
+    if (canInvoke(obj, methodName)) {
+      return args ? applyStr(obj, methodName, args) : applyStr(obj, methodName);
     }
+  }
+
+  // https://github.com/emberjs/ember.js/pull/1617
+  var needsFinallyFix = (function() {
+    var count = 0;
+    try {
+      // jscs:disable
+      try {
+      } finally {
+        count++;
+        throw new Error('needsFinallyFixTest');
+      }
+      // jscs:enable
+    } catch (e) {}
 
-    ActionHelper.registerAction = function(actionNameOrStream, options, allowedKeys) {
-      var actionId = uuid();
-      var eventName = options.eventName;
-      var parameters = options.parameters;
+    return count !== 1;
+  })();
 
-      ActionManager.registeredActions[actionId] = {
-        eventName: eventName,
-        handler: function handleRegisteredAction(event) {
-          if (!isAllowedEvent(event, allowedKeys)) { return true; }
+  /**
+    Provides try/finally functionality, while working
+    around Safari's double finally bug.
 
-          if (options.preventDefault !== false) {
-            event.preventDefault();
-          }
+    ```javascript
+    var tryable = function() {
+      someResource.lock();
+      runCallback(); // May throw error.
+    };
 
-          if (options.bubbles === false) {
-            event.stopPropagation();
-          }
+    var finalizer = function() {
+      someResource.unlock();
+    };
 
-          var target = options.target.value();
+    Ember.tryFinally(tryable, finalizer);
+    ```
 
-          
-          var actionName;
+    @method tryFinally
+    @for Ember
+    @param {Function} tryable The function to run the try callback
+    @param {Function} finalizer The function to run the finally callback
+    @param {Object} [binding] The optional calling object. Defaults to 'this'
+    @return {*} The return value is the that of the finalizer,
+    unless that value is undefined, in which case it is the return value
+    of the tryable
+  */
 
-          if (isStream(actionNameOrStream)) {
-            actionName = actionNameOrStream.value();
+  var tryFinally;
+  if (needsFinallyFix) {
+    tryFinally = function(tryable, finalizer, binding) {
+      var result, finalResult, finalError;
 
-            Ember.assert("You specified a quoteless path to the {{action}} helper " +
-                         "which did not resolve to an action name (a string). " +
-                         "Perhaps you meant to use a quoted actionName? (e.g. {{action 'save'}}).",
-                         typeof actionName === 'string');
-          } else {
-            actionName = actionNameOrStream;
-          }
+      binding = binding || this;
 
-          run(function runRegisteredAction() {
-            if (target.send) {
-              target.send.apply(target, actionArgs(parameters, actionName));
-            } else {
-              Ember.assert("The action '" + actionName + "' did not exist on " + target, typeof target[actionName] === 'function');
-              target[actionName].apply(target, actionArgs(parameters));
-            }
-          });
+      try {
+        result = tryable.call(binding);
+      } finally {
+        try {
+          finalResult = finalizer.call(binding);
+        } catch (e) {
+          finalError = e;
         }
-      };
+      }
 
-      options.view.on('willClearRender', function() {
-        delete ActionManager.registeredActions[actionId];
-      });
+      if (finalError) { throw finalError; }
 
-      return actionId;
+      return (finalResult === undefined) ? result : finalResult;
     };
+  } else {
+    tryFinally = function(tryable, finalizer, binding) {
+      var result, finalResult;
 
-    /**
-      The `{{action}}` helper provides a useful shortcut for registering an HTML
-      element within a template for a single DOM event and forwarding that
-      interaction to the template's controller or specified `target` option.
-
-      If the controller does not implement the specified action, the event is sent
-      to the current route, and it bubbles up the route hierarchy from there.
+      binding = binding || this;
 
-      For more advanced event handling see [Ember.Component](/api/classes/Ember.Component.html)
+      try {
+        result = tryable.call(binding);
+      } finally {
+        finalResult = finalizer.call(binding);
+      }
 
+      return (finalResult === undefined) ? result : finalResult;
+    };
+  }
 
-      ### Use
-      Given the following application Handlebars template on the page
+  /**
+    Provides try/catch/finally functionality, while working
+    around Safari's double finally bug.
 
-      ```handlebars
-      <div {{action 'anActionName'}}>
-        click me
-      </div>
-      ```
+    ```javascript
+    var tryable = function() {
+      for (i = 0, l = listeners.length; i < l; i++) {
+        listener = listeners[i];
+        beforeValues[i] = listener.before(name, time(), payload);
+      }
 
-      And application code
+      return callback.call(binding);
+    };
 
-      ```javascript
-      App.ApplicationController = Ember.Controller.extend({
-        actions: {
-          anActionName: function() {
-          }
-        }
-      });
-      ```
+    var catchable = function(e) {
+      payload = payload || {};
+      payload.exception = e;
+    };
 
-      Will result in the following rendered HTML
+    var finalizer = function() {
+      for (i = 0, l = listeners.length; i < l; i++) {
+        listener = listeners[i];
+        listener.after(name, time(), payload, beforeValues[i]);
+      }
+    };
 
-      ```html
-      <div class="ember-view">
-        <div data-ember-action="1">
-          click me
-        </div>
-      </div>
-      ```
+    Ember.tryCatchFinally(tryable, catchable, finalizer);
+    ```
 
-      Clicking "click me" will trigger the `anActionName` action of the
-      `App.ApplicationController`. In this case, no additional parameters will be passed.
+    @method tryCatchFinally
+    @for Ember
+    @param {Function} tryable The function to run the try callback
+    @param {Function} catchable The function to run the catchable callback
+    @param {Function} finalizer The function to run the finally callback
+    @param {Object} [binding] The optional calling object. Defaults to 'this'
+    @return {*} The return value is the that of the finalizer,
+    unless that value is undefined, in which case it is the return value
+    of the tryable.
+  */
+  var tryCatchFinally;
+  if (needsFinallyFix) {
+    tryCatchFinally = function(tryable, catchable, finalizer, binding) {
+      var result, finalResult, finalError;
+
+      binding = binding || this;
 
-      If you provide additional parameters to the helper:
+      try {
+        result = tryable.call(binding);
+      } catch(error) {
+        result = catchable.call(binding, error);
+      } finally {
+        try {
+          finalResult = finalizer.call(binding);
+        } catch (e) {
+          finalError = e;
+        }
+      }
 
-      ```handlebars
-      <button {{action 'edit' post}}>Edit</button>
-      ```
+      if (finalError) { throw finalError; }
 
-      Those parameters will be passed along as arguments to the JavaScript
-      function implementing the action.
+      return (finalResult === undefined) ? result : finalResult;
+    };
+  } else {
+    tryCatchFinally = function(tryable, catchable, finalizer, binding) {
+      var result, finalResult;
 
-      ### Event Propagation
+      binding = binding || this;
 
-      Events triggered through the action helper will automatically have
-      `.preventDefault()` called on them. You do not need to do so in your event
-      handlers. If you need to allow event propagation (to handle file inputs for
-      example) you can supply the `preventDefault=false` option to the `{{action}}` helper:
+      try {
+        result = tryable.call(binding);
+      } catch(error) {
+        result = catchable.call(binding, error);
+      } finally {
+        finalResult = finalizer.call(binding);
+      }
 
-      ```handlebars
-      <div {{action "sayHello" preventDefault=false}}>
-        <input type="file" />
-        <input type="checkbox" />
-      </div>
-      ```
+      return (finalResult === undefined) ? result : finalResult;
+    };
+  }
 
-      To disable bubbling, pass `bubbles=false` to the helper:
+  // ........................................
+  // TYPING & ARRAY MESSAGING
+  //
 
-      ```handlebars
-      <button {{action 'edit' post bubbles=false}}>Edit</button>
-      ```
+  var TYPE_MAP = {};
+  var t = "Boolean Number String Function Array Date RegExp Object".split(" ");
+  array.forEach.call(t, function(name) {
+    TYPE_MAP["[object " + name + "]"] = name.toLowerCase();
+  });
 
-      If you need the default handler to trigger you should either register your
-      own event handler, or use event methods on your view class. See [Ember.View](/api/classes/Ember.View.html)
-      'Responding to Browser Events' for more information.
+  var toString = Object.prototype.toString;
 
-      ### Specifying DOM event type
+  var EmberObject;
 
-      By default the `{{action}}` helper registers for DOM `click` events. You can
-      supply an `on` option to the helper to specify a different DOM event name:
+  /**
+    Returns a consistent type for the passed item.
 
-      ```handlebars
-      <div {{action "anActionName" on="doubleClick"}}>
-        click me
-      </div>
-      ```
+    Use this instead of the built-in `typeof` to get the type of an item.
+    It will return the same result across all browsers and includes a bit
+    more detail. Here is what will be returned:
 
-      See `Ember.View` 'Responding to Browser Events' for a list of
-      acceptable DOM event names.
+        | Return Value  | Meaning                                              |
+        |---------------|------------------------------------------------------|
+        | 'string'      | String primitive or String object.                   |
+        | 'number'      | Number primitive or Number object.                   |
+        | 'boolean'     | Boolean primitive or Boolean object.                 |
+        | 'null'        | Null value                                           |
+        | 'undefined'   | Undefined value                                      |
+        | 'function'    | A function                                           |
+        | 'array'       | An instance of Array                                 |
+        | 'regexp'      | An instance of RegExp                                |
+        | 'date'        | An instance of Date                                  |
+        | 'class'       | An Ember class (created using Ember.Object.extend()) |
+        | 'instance'    | An Ember object instance                             |
+        | 'error'       | An instance of the Error object                      |
+        | 'object'      | A JavaScript object not inheriting from Ember.Object |
 
-      ### Specifying whitelisted modifier keys
+    Examples:
 
-      By default the `{{action}}` helper will ignore click event with pressed modifier
-      keys. You can supply an `allowedKeys` option to specify which keys should not be ignored.
+    ```javascript
+    Ember.typeOf();                       // 'undefined'
+    Ember.typeOf(null);                   // 'null'
+    Ember.typeOf(undefined);              // 'undefined'
+    Ember.typeOf('michael');              // 'string'
+    Ember.typeOf(new String('michael'));  // 'string'
+    Ember.typeOf(101);                    // 'number'
+    Ember.typeOf(new Number(101));        // 'number'
+    Ember.typeOf(true);                   // 'boolean'
+    Ember.typeOf(new Boolean(true));      // 'boolean'
+    Ember.typeOf(Ember.makeArray);        // 'function'
+    Ember.typeOf([1, 2, 90]);             // 'array'
+    Ember.typeOf(/abc/);                  // 'regexp'
+    Ember.typeOf(new Date());             // 'date'
+    Ember.typeOf(Ember.Object.extend());  // 'class'
+    Ember.typeOf(Ember.Object.create());  // 'instance'
+    Ember.typeOf(new Error('teamocil'));  // 'error'
+
+    // 'normal' JavaScript object
+    Ember.typeOf({ a: 'b' });             // 'object'
+    ```
 
-      ```handlebars
-      <div {{action "anActionName" allowedKeys="alt"}}>
-        click me
-      </div>
-      ```
+    @method typeOf
+    @for Ember
+    @param {Object} item the item to check
+    @return {String} the type
+  */
+  function typeOf(item) {
+    var ret, modulePath;
 
-      This way the `{{action}}` will fire when clicking with the alt key pressed down.
+    // ES6TODO: Depends on Ember.Object which is defined in runtime.
+    if (typeof EmberObject === "undefined") {
+      modulePath = 'ember-runtime/system/object';
+      if (Ember['default'].__loader.registry[modulePath]) {
+        EmberObject = Ember['default'].__loader.require(modulePath)['default'];
+      }
+    }
 
-      Alternatively, supply "any" to the `allowedKeys` option to accept any combination of modifier keys.
+    ret = (item === null || item === undefined) ? String(item) : TYPE_MAP[toString.call(item)] || 'object';
 
-      ```handlebars
-      <div {{action "anActionName" allowedKeys="any"}}>
-        click me with any key pressed
-      </div>
-      ```
+    if (ret === 'function') {
+      if (EmberObject && EmberObject.detect(item)) {
+        ret = 'class';
+      }
+    } else if (ret === 'object') {
+      if (item instanceof Error) {
+        ret = 'error';
+      } else if (EmberObject && item instanceof EmberObject) {
+        ret = 'instance';
+      } else if (item instanceof Date) {
+        ret = 'date';
+      }
+    }
 
-      ### Specifying a Target
+    return ret;
+  }
 
-      There are several possible target objects for `{{action}}` helpers:
+  /**
+    Convenience method to inspect an object. This method will attempt to
+    convert the object into a useful string description.
+
+    It is a pretty simple implementation. If you want something more robust,
+    use something like JSDump: https://github.com/NV/jsDump
+
+    @method inspect
+    @for Ember
+    @param {Object} obj The object you want to inspect.
+    @return {String} A description of the object
+    @since 1.4.0
+  */
+  function inspect(obj) {
+    var type = typeOf(obj);
+    if (type === 'array') {
+      return '[' + obj + ']';
+    }
+    if (type !== 'object') {
+      return obj + '';
+    }
+
+    var v;
+    var ret = [];
+    for (var key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        v = obj[key];
+        if (v === 'toString') { continue; } // ignore useless items
+        if (typeOf(v) === 'function') { v = "function() { ... }"; }
+
+        if (v && typeof v.toString !== 'function') {
+          ret.push(key + ": " + toString.call(v));
+        } else {
+          ret.push(key + ": " + v);
+        }
+      }
+    }
+    return "{" + ret.join(", ") + "}";
+  }
 
-      In a typical Ember application, where templates are managed through use of the
-      `{{outlet}}` helper, actions will bubble to the current controller, then
-      to the current route, and then up the route hierarchy.
+  // The following functions are intentionally minified to keep the functions
+  // below Chrome's function body size inlining limit of 600 chars.
+  /**
+    @param {Object} target
+    @param {Function} method
+    @param {Array} args
+  */
+  function apply(t, m, a) {
+    var l = a && a.length;
+    if (!a || !l) { return m.call(t); }
+    switch (l) {
+      case 1:  return m.call(t, a[0]);
+      case 2:  return m.call(t, a[0], a[1]);
+      case 3:  return m.call(t, a[0], a[1], a[2]);
+      case 4:  return m.call(t, a[0], a[1], a[2], a[3]);
+      case 5:  return m.call(t, a[0], a[1], a[2], a[3], a[4]);
+      default: return m.apply(t, a);
+    }
+  }
 
-      Alternatively, a `target` option can be provided to the helper to change
-      which object will receive the method call. This option must be a path
-      to an object, accessible in the current context:
+  /**
+    @param {Object} target
+    @param {String} method
+    @param {Array} args
+  */
+  function applyStr(t, m, a) {
+    var l = a && a.length;
+    if (!a || !l) { return t[m](); }
+    switch (l) {
+      case 1:  return t[m](a[0]);
+      case 2:  return t[m](a[0], a[1]);
+      case 3:  return t[m](a[0], a[1], a[2]);
+      case 4:  return t[m](a[0], a[1], a[2], a[3]);
+      case 5:  return t[m](a[0], a[1], a[2], a[3], a[4]);
+      default: return t[m].apply(t, a);
+    }
+  }
 
-      ```handlebars
-      {{! the application template }}
-      <div {{action "anActionName" target=view}}>
-        click me
-      </div>
-      ```
+  exports.GUID_DESC = GUID_DESC;
+  exports.EMBER_META_PROPERTY = EMBER_META_PROPERTY;
+  exports.GUID_KEY_PROPERTY = GUID_KEY_PROPERTY;
+  exports.NEXT_SUPER_PROPERTY = NEXT_SUPER_PROPERTY;
+  exports.GUID_KEY = GUID_KEY;
+  exports.META_DESC = META_DESC;
+  exports.EMPTY_META = EMPTY_META;
+  exports.tryCatchFinally = tryCatchFinally;
+  exports.tryFinally = tryFinally;
 
-      ```javascript
-      App.ApplicationView = Ember.View.extend({
-        actions: {
-          anActionName: function(){}
-        }
-      });
+});
+enifed('ember-metal/watch_key', ['exports', 'ember-metal/core', 'ember-metal/utils', 'ember-metal/platform/define_property', 'ember-metal/properties'], function (exports, Ember, utils, define_property, properties) {
 
-      ```
+  'use strict';
 
-      ### Additional Parameters
+  exports.watchKey = watchKey;
+  exports.unwatchKey = unwatchKey;
 
-      You may specify additional parameters to the `{{action}}` helper. These
-      parameters are passed along as the arguments to the JavaScript function
-      implementing the action.
+  function watchKey(obj, keyName, meta) {
+    // can't watch length on Array - it is special...
+    if (keyName === 'length' && utils.typeOf(obj) === 'array') { return; }
 
-      ```handlebars
-      {{#each person in people}}
-        <div {{action "edit" person}}>
-          click me
-        </div>
-      {{/each}}
-      ```
+    var m = meta || utils.meta(obj);
+    var watching = m.watching;
 
-      Clicking "click me" will trigger the `edit` method on the current controller
-      with the value of `person` as a parameter.
+    // activate watching first time
+    if (!watching[keyName]) {
+      watching[keyName] = 1;
 
-      @method action
-      @for Ember.Handlebars.helpers
-      @param {String} actionName
-      @param {Object} [context]*
-      @param {Hash} options
-    */
-    function actionHelper(params, hash, options, env) {
+      var possibleDesc = obj[keyName];
+      var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
+      if (desc && desc.willWatch) { desc.willWatch(obj, keyName); }
 
-      var target;
-      if (!hash.target) {
-        target = this.getStream('controller');
-      } else if (isStream(hash.target)) {
-        target = hash.target;
-      } else {
-        target = this.getStream(hash.target);
+      if ('function' === typeof obj.willWatchProperty) {
+        obj.willWatchProperty(keyName);
       }
 
-      // Ember.assert("You specified a quoteless path to the {{action}} helper which did not resolve to an action name (a string). Perhaps you meant to use a quoted actionName? (e.g. {{action 'save'}}).", !params[0].isStream);
-      // Ember.deprecate("You specified a quoteless path to the {{action}} helper which did not resolve to an action name (a string). Perhaps you meant to use a quoted actionName? (e.g. {{action 'save'}}).", params[0].isStream);
 
-      var actionOptions = {
-        eventName: hash.on || "click",
-        parameters: params.slice(1),
-        view: this,
-        bubbles: hash.bubbles,
-        preventDefault: hash.preventDefault,
-        target: target,
-        withKeyCode: hash.withKeyCode
-      };
+        if (define_property.hasPropertyAccessors) {
+          handleMandatorySetter(m, obj, keyName);
+        }
 
-      var actionId = ActionHelper.registerAction(params[0], actionOptions, hash.allowedKeys);
-      env.dom.setAttribute(options.element, 'data-ember-action', actionId);
+    } else {
+      watching[keyName] = (watching[keyName] || 0) + 1;
     }
+  }
+
 
-    __exports__.actionHelper = actionHelper;
-  });
-enifed("ember-routing-htmlbars/helpers/link-to",
-  ["ember-metal/core","ember-routing-views/views/link","ember-metal/streams/utils","ember-runtime/mixins/controller","ember-htmlbars/utils/string","ember-htmlbars","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-routing-handlebars
-    */
 
-    var Ember = __dependency1__["default"];
-    // assert
-    var LinkView = __dependency2__.LinkView;
-    var read = __dependency3__.read;
-    var isStream = __dependency3__.isStream;
-    var ControllerMixin = __dependency4__["default"];
-    var escapeExpression = __dependency5__.escapeExpression;
+    var handleMandatorySetter = function handleMandatorySetter(m, obj, keyName) {
+      var descriptor = Object.getOwnPropertyDescriptor && Object.getOwnPropertyDescriptor(obj, keyName);
+      var configurable = descriptor ? descriptor.configurable : true;
+      var isWritable = descriptor ? descriptor.writable : true;
+      var hasValue = descriptor ? 'value' in descriptor : true;
+      var possibleDesc = descriptor && descriptor.value;
+      var isDescriptor = possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor;
 
-    // We need the HTMLBars view helper from ensure ember-htmlbars.
-    // This ensures it is loaded first:
+      if (isDescriptor) { return; }
 
-    /**
-      The `{{link-to}}` helper renders a link to the supplied
-      `routeName` passing an optionally supplied model to the
-      route as its `model` context of the route. The block
-      for `{{link-to}}` becomes the innerHTML of the rendered
-      element:
+      // this x in Y deopts, so keeping it in this function is better;
+      if (configurable && isWritable && hasValue && keyName in obj) {
+        m.values[keyName] = obj[keyName];
+        define_property.defineProperty(obj, keyName, {
+          configurable: true,
+          enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName),
+          set: properties.MANDATORY_SETTER_FUNCTION(keyName),
+          get: properties.DEFAULT_GETTER_FUNCTION(keyName)
+        });
+      }
+    };
 
-      ```handlebars
-      {{#link-to 'photoGallery'}}
-        Great Hamster Photos
-      {{/link-to}}
-      ```
 
-      You can also use an inline form of `{{link-to}}` helper by
-      passing the link text as the first argument
-      to the helper:
+  function unwatchKey(obj, keyName, meta) {
+    var m = meta || utils.meta(obj);
+    var watching = m.watching;
 
-      ```handlebars
-      {{link-to 'Great Hamster Photos' 'photoGallery'}}
-      ```
+    if (watching[keyName] === 1) {
+      watching[keyName] = 0;
 
-      Both will result in:
+      var possibleDesc = obj[keyName];
+      var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
+      if (desc && desc.didUnwatch) { desc.didUnwatch(obj, keyName); }
 
-      ```html
-      <a href="/hamster-photos">
-        Great Hamster Photos
-      </a>
-      ```
+      if ('function' === typeof obj.didUnwatchProperty) {
+        obj.didUnwatchProperty(keyName);
+      }
 
-      ### Supplying a tagName
-      By default `{{link-to}}` renders an `<a>` element. This can
-      be overridden for a single use of `{{link-to}}` by supplying
-      a `tagName` option:
 
-      ```handlebars
-      {{#link-to 'photoGallery' tagName="li"}}
-        Great Hamster Photos
-      {{/link-to}}
-      ```
+        if (!desc && define_property.hasPropertyAccessors && keyName in obj) {
+          define_property.defineProperty(obj, keyName, {
+            configurable: true,
+            enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName),
+            set: function(val) {
+              // redefine to set as enumerable
+              define_property.defineProperty(obj, keyName, {
+                configurable: true,
+                writable: true,
+                enumerable: true,
+                value: val
+              });
+              delete m.values[keyName];
+            },
+            get: properties.DEFAULT_GETTER_FUNCTION(keyName)
+          });
+        }
 
-      ```html
-      <li>
-        Great Hamster Photos
-      </li>
-      ```
+    } else if (watching[keyName] > 1) {
+      watching[keyName]--;
+    }
+  }
 
-      To override this option for your entire application, see
-      "Overriding Application-wide Defaults".
+});
+enifed('ember-metal/watch_path', ['exports', 'ember-metal/utils', 'ember-metal/chains'], function (exports, utils, chains) {
 
-      ### Disabling the `link-to` helper
-      By default `{{link-to}}` is enabled.
-      any passed value to `disabled` helper property will disable the `link-to` helper.
+  'use strict';
 
-      static use: the `disabled` option:
+  exports.watchPath = watchPath;
+  exports.unwatchPath = unwatchPath;
 
-      ```handlebars
-      {{#link-to 'photoGallery' disabled=true}}
-        Great Hamster Photos
-      {{/link-to}}
-      ```
+  function chainsFor(obj, meta) {
+    var m = meta || utils.meta(obj);
+    var ret = m.chains;
+    if (!ret) {
+      ret = m.chains = new chains.ChainNode(null, null, obj);
+    } else if (ret.value() !== obj) {
+      ret = m.chains = ret.copy(obj);
+    }
+    return ret;
+  }
 
-      dynamic use: the `disabledWhen` option:
+  function watchPath(obj, keyPath, meta) {
+    // can't watch length on Array - it is special...
+    if (keyPath === 'length' && utils.typeOf(obj) === 'array') { return; }
 
-      ```handlebars
-      {{#link-to 'photoGallery' disabledWhen=controller.someProperty}}
-        Great Hamster Photos
-      {{/link-to}}
-      ```
+    var m = meta || utils.meta(obj);
+    var watching = m.watching;
 
-      any passed value to `disabled` will disable it except `undefined`.
-      to ensure that only `true` disable the `link-to` helper you can
-      override the global behaviour of `Ember.LinkView`.
+    if (!watching[keyPath]) { // activate watching first time
+      watching[keyPath] = 1;
+      chainsFor(obj, m).add(keyPath);
+    } else {
+      watching[keyPath] = (watching[keyPath] || 0) + 1;
+    }
+  }
 
-      ```javascript
-      Ember.LinkView.reopen({
-        disabled: Ember.computed(function(key, value) {
-          if (value !== undefined) {
-            this.set('_isDisabled', value === true);
-          }
-          return value === true ? get(this, 'disabledClass') : false;
-        })
-      });
-      ```
+  function unwatchPath(obj, keyPath, meta) {
+    var m = meta || utils.meta(obj);
+    var watching = m.watching;
 
-      see "Overriding Application-wide Defaults" for more.
+    if (watching[keyPath] === 1) {
+      watching[keyPath] = 0;
+      chainsFor(obj, m).remove(keyPath);
+    } else if (watching[keyPath] > 1) {
+      watching[keyPath]--;
+    }
+  }
 
-      ### Handling `href`
-      `{{link-to}}` will use your application's Router to
-      fill the element's `href` property with a url that
-      matches the path to the supplied `routeName` for your
-      routers's configured `Location` scheme, which defaults
-      to Ember.HashLocation.
+});
+enifed('ember-metal/watching', ['exports', 'ember-metal/utils', 'ember-metal/chains', 'ember-metal/watch_key', 'ember-metal/watch_path', 'ember-metal/path_cache'], function (exports, utils, chains, watch_key, watch_path, path_cache) {
 
-      ### Handling current route
-      `{{link-to}}` will apply a CSS class name of 'active'
-      when the application's current route matches
-      the supplied routeName. For example, if the application's
-      current route is 'photoGallery.recent' the following
-      use of `{{link-to}}`:
+  'use strict';
 
-      ```handlebars
-      {{#link-to 'photoGallery.recent'}}
-        Great Hamster Photos from the last week
-      {{/link-to}}
-      ```
+  exports.watch = watch;
+  exports.isWatching = isWatching;
+  exports.unwatch = unwatch;
+  exports.destroy = destroy;
 
-      will result in
+  /**
+  @module ember-metal
+  */
 
-      ```html
-      <a href="/hamster-photos/this-week" class="active">
-        Great Hamster Photos
-      </a>
-      ```
+  function watch(obj, _keyPath, m) {
+    // can't watch length on Array - it is special...
+    if (_keyPath === 'length' && utils.typeOf(obj) === 'array') { return; }
 
-      The CSS class name used for active classes can be customized
-      for a single use of `{{link-to}}` by passing an `activeClass`
-      option:
+    if (!path_cache.isPath(_keyPath)) {
+      watch_key.watchKey(obj, _keyPath, m);
+    } else {
+      watch_path.watchPath(obj, _keyPath, m);
+    }
+  }
 
-      ```handlebars
-      {{#link-to 'photoGallery.recent' activeClass="current-url"}}
-        Great Hamster Photos from the last week
-      {{/link-to}}
-      ```
+  function isWatching(obj, key) {
+    var meta = obj['__ember_meta__'];
+    return (meta && meta.watching[key]) > 0;
+  }
 
-      ```html
-      <a href="/hamster-photos/this-week" class="current-url">
-        Great Hamster Photos
-      </a>
-      ```
+  watch.flushPending = chains.flushPendingChains;
 
-      To override this option for your entire application, see
-      "Overriding Application-wide Defaults".
+  function unwatch(obj, _keyPath, m) {
+    // can't watch length on Array - it is special...
+    if (_keyPath === 'length' && utils.typeOf(obj) === 'array') { return; }
 
-      ### Supplying a model
-      An optional model argument can be used for routes whose
-      paths contain dynamic segments. This argument will become
-      the model context of the linked route:
+    if (!path_cache.isPath(_keyPath)) {
+      watch_key.unwatchKey(obj, _keyPath, m);
+    } else {
+      watch_path.unwatchPath(obj, _keyPath, m);
+    }
+  }
 
-      ```javascript
-      App.Router.map(function() {
-        this.resource("photoGallery", {path: "hamster-photos/:photo_id"});
-      });
-      ```
+  var NODE_STACK = [];
+
+  /**
+    Tears down the meta on an object so that it can be garbage collected.
+    Multiple calls will have no effect.
+
+    @method destroy
+    @for Ember
+    @param {Object} obj  the object to destroy
+    @return {void}
+  */
+  function destroy(obj) {
+    var meta = obj['__ember_meta__'];
+    var node, nodes, key, nodeObject;
+
+    if (meta) {
+      obj['__ember_meta__'] = null;
+      // remove chainWatchers to remove circular references that would prevent GC
+      node = meta.chains;
+      if (node) {
+        NODE_STACK.push(node);
+        // process tree
+        while (NODE_STACK.length > 0) {
+          node = NODE_STACK.pop();
+          // push children
+          nodes = node._chains;
+          if (nodes) {
+            for (key in nodes) {
+              if (nodes.hasOwnProperty(key)) {
+                NODE_STACK.push(nodes[key]);
+              }
+            }
+          }
+          // remove chainWatcher in node object
+          if (node._watching) {
+            nodeObject = node._object;
+            if (nodeObject) {
+              chains.removeChainWatcher(nodeObject, node._key, node);
+            }
+          }
+        }
+      }
+    }
+  }
 
-      ```handlebars
-      {{#link-to 'photoGallery' aPhoto}}
-        {{aPhoto.title}}
-      {{/link-to}}
-      ```
+});
+enifed('ember-routing-htmlbars', ['exports', 'ember-metal/core', 'ember-htmlbars/helpers', 'ember-routing-htmlbars/helpers/outlet', 'ember-routing-htmlbars/helpers/render', 'ember-routing-htmlbars/helpers/link-to', 'ember-routing-htmlbars/helpers/action', 'ember-routing-htmlbars/helpers/query-params'], function (exports, Ember, helpers, outlet, render, link_to, action, query_params) {
 
-      ```html
-      <a href="/hamster-photos/42">
-        Tomster
-      </a>
-      ```
+  'use strict';
 
-      ### Supplying multiple models
-      For deep-linking to route paths that contain multiple
-      dynamic segments, multiple model arguments can be used.
-      As the router transitions through the route path, each
-      supplied model argument will become the context for the
-      route with the dynamic segments:
+  /**
+  Ember Routing HTMLBars Helpers
 
-      ```javascript
-      App.Router.map(function() {
-        this.resource("photoGallery", {path: "hamster-photos/:photo_id"}, function() {
-          this.route("comment", {path: "comments/:comment_id"});
-        });
-      });
-      ```
-      This argument will become the model context of the linked route:
+  @module ember
+  @submodule ember-routing-htmlbars
+  @requires ember-routing
+  */
 
-      ```handlebars
-      {{#link-to 'photoGallery.comment' aPhoto comment}}
-        {{comment.body}}
-      {{/link-to}}
-      ```
+  helpers.registerHelper('outlet', outlet.outletHelper);
+  helpers.registerHelper('render', render.renderHelper);
+  helpers.registerHelper('link-to', link_to.linkToHelper);
+  helpers.registerHelper('linkTo', link_to.deprecatedLinkToHelper);
+  helpers.registerHelper('action', action.actionHelper);
+  helpers.registerHelper('query-params', query_params.queryParamsHelper);
 
-      ```html
-      <a href="/hamster-photos/42/comment/718">
-        A+++ would snuggle again.
-      </a>
-      ```
+  exports['default'] = Ember['default'];
 
-      ### Supplying an explicit dynamic segment value
-      If you don't have a model object available to pass to `{{link-to}}`,
-      an optional string or integer argument can be passed for routes whose
-      paths contain dynamic segments. This argument will become the value
-      of the dynamic segment:
+});
+enifed('ember-routing-htmlbars/helpers/action', ['exports', 'ember-metal/core', 'ember-metal/utils', 'ember-metal/run_loop', 'ember-views/streams/utils', 'ember-views/system/utils', 'ember-views/system/action_manager', 'ember-metal/streams/utils'], function (exports, Ember, utils, run, streams__utils, system__utils, ActionManager, ember_metal__streams__utils) {
 
-      ```javascript
-      App.Router.map(function() {
-        this.resource("photoGallery", {path: "hamster-photos/:photo_id"});
-      });
-      ```
+  'use strict';
 
-      ```handlebars
-      {{#link-to 'photoGallery' aPhotoId}}
-        {{aPhoto.title}}
-      {{/link-to}}
-      ```
+  exports.actionHelper = actionHelper;
 
-      ```html
-      <a href="/hamster-photos/42">
-        Tomster
-      </a>
-      ```
+  /**
+  @module ember
+  @submodule ember-routing-htmlbars
+  */
 
-      When transitioning into the linked route, the `model` hook will
-      be triggered with parameters including this passed identifier.
+  function actionArgs(parameters, actionName) {
+    var ret, i, l;
 
-      ### Allowing Default Action
+    if (actionName === undefined) {
+      ret = new Array(parameters.length);
+      for (i=0, l=parameters.length;i<l;i++) {
+        ret[i] = streams__utils.readUnwrappedModel(parameters[i]);
+      }
+    } else {
+      ret = new Array(parameters.length + 1);
+      ret[0] = actionName;
+      for (i=0, l=parameters.length;i<l; i++) {
+        ret[i + 1] = streams__utils.readUnwrappedModel(parameters[i]);
+      }
+    }
 
-     By default the `{{link-to}}` helper prevents the default browser action
-     by calling `preventDefault()` as this sort of action bubbling is normally
-     handled internally and we do not want to take the browser to a new URL (for
-     example).
+    return ret;
+  }
 
-     If you need to override this behavior specify `preventDefault=false` in
-     your template:
+  var ActionHelper = {};
 
-      ```handlebars
-      {{#link-to 'photoGallery' aPhotoId preventDefault=false}}
-        {{aPhotoId.title}}
-      {{/link-to}}
-      ```
+  // registeredActions is re-exported for compatibility with older plugins
+  // that were using this undocumented API.
+  ActionHelper.registeredActions = ActionManager['default'].registeredActions;
 
-      ### Overriding attributes
-      You can override any given property of the Ember.LinkView
-      that is generated by the `{{link-to}}` helper by passing
-      key/value pairs, like so:
+  var keys = ["alt", "shift", "meta", "ctrl"];
 
-      ```handlebars
-      {{#link-to  aPhoto tagName='li' title='Following this link will change your life' classNames='pic sweet'}}
-        Uh-mazing!
-      {{/link-to}}
-      ```
+  var POINTER_EVENT_TYPE_REGEX = /^click|mouse|touch/;
 
-      See [Ember.LinkView](/api/classes/Ember.LinkView.html) for a
-      complete list of overrideable properties. Be sure to also
-      check out inherited properties of `LinkView`.
+  var isAllowedEvent = function(event, allowedKeys) {
+    if (typeof allowedKeys === "undefined") {
+      if (POINTER_EVENT_TYPE_REGEX.test(event.type)) {
+        return system__utils.isSimpleClick(event);
+      } else {
+        allowedKeys = '';
+      }
+    }
 
-      ### Overriding Application-wide Defaults
-      ``{{link-to}}`` creates an instance of Ember.LinkView
-      for rendering. To override options for your entire
-      application, reopen Ember.LinkView and supply the
-      desired values:
+    if (allowedKeys.indexOf("any") >= 0) {
+      return true;
+    }
 
-      ``` javascript
-      Ember.LinkView.reopen({
-        activeClass: "is-active",
-        tagName: 'li'
-      })
-      ```
+    for (var i=0, l=keys.length;i<l;i++) {
+      if (event[keys[i] + "Key"] && allowedKeys.indexOf(keys[i]) === -1) {
+        return false;
+      }
+    }
 
-      It is also possible to override the default event in
-      this manner:
+    return true;
+  };
 
-      ``` javascript
-      Ember.LinkView.reopen({
-        eventName: 'customEventName'
-      });
-      ```
+  ActionHelper.registerAction = function(actionNameOrStream, options, allowedKeys) {
+    var actionId = utils.uuid();
+    var eventName = options.eventName;
+    var parameters = options.parameters;
 
-      @method link-to
-      @for Ember.Handlebars.helpers
-      @param {String} routeName
-      @param {Object} [context]*
-      @param [options] {Object} Handlebars key/value pairs of options, you can override any property of Ember.LinkView
-      @return {String} HTML string
-      @see {Ember.LinkView}
-    */
-    function linkToHelper(params, hash, options, env) {
-      var shouldEscape = !hash.unescaped;
-      var queryParamsObject;
+    ActionManager['default'].registeredActions[actionId] = {
+      eventName: eventName,
+      handler: function handleRegisteredAction(event) {
+        if (!isAllowedEvent(event, allowedKeys)) { return true; }
 
-      Ember.assert("You must provide one or more parameters to the link-to helper.", params.length);
+        if (options.preventDefault !== false) {
+          event.preventDefault();
+        }
 
-      var lastParam = params[params.length - 1];
+        if (options.bubbles === false) {
+          event.stopPropagation();
+        }
 
-      if (lastParam && lastParam.isQueryParams) {
-        hash.queryParamsObject = queryParamsObject = params.pop();
-      }
+        var target = options.target.value();
 
-      if (hash.disabledWhen) {
-        hash.disabled = hash.disabledWhen;
-        delete hash.disabledWhen;
-      }
+        var actionName;
 
-      if (!options.template) {
-        var linkTitle = params.shift();
+        if (ember_metal__streams__utils.isStream(actionNameOrStream)) {
+          actionName = actionNameOrStream.value();
 
-        if (isStream(linkTitle)) {
-          hash.linkTitle = { stream: linkTitle };
+          Ember['default'].assert("You specified a quoteless path to the {{action}} helper " +
+                       "which did not resolve to an action name (a string). " +
+                       "Perhaps you meant to use a quoted actionName? (e.g. {{action 'save'}}).",
+                       typeof actionName === 'string');
+        } else {
+          actionName = actionNameOrStream;
         }
 
-        options.template = {
-          isHTMLBars: true,
-          render: function() {
-            var value = read(linkTitle);
-            if (value) {
-              return shouldEscape ? escapeExpression(value) : value;
-            } else {
-              return "";
-            }
+        run['default'](function runRegisteredAction() {
+          if (target.send) {
+            target.send.apply(target, actionArgs(parameters, actionName));
+          } else {
+            Ember['default'].assert("The action '" + actionName + "' did not exist on " + target, typeof target[actionName] === 'function');
+            target[actionName].apply(target, actionArgs(parameters));
           }
-        };
+        });
       }
+    };
 
-      for (var i = 0; i < params.length; i++) {
-        if (isStream(params[i])) {
-          var lazyValue = params[i];
+    options.view.on('willClearRender', function() {
+      delete ActionManager['default'].registeredActions[actionId];
+    });
 
-          if (!lazyValue._isController) {
-            while (ControllerMixin.detect(lazyValue.value())) {
-              lazyValue = lazyValue.get('model');
-            }
-          }
+    return actionId;
+  };
 
-          params[i] = lazyValue;
-        }
-      }
+  /**
+    The `{{action}}` helper provides a useful shortcut for registering an HTML
+    element within a template for a single DOM event and forwarding that
+    interaction to the template's controller or specified `target` option.
 
-      hash.params = params;
+    If the controller does not implement the specified action, the event is sent
+    to the current route, and it bubbles up the route hierarchy from there.
 
-      options.helperName = options.helperName || 'link-to';
+    For more advanced event handling see [Ember.Component](/api/classes/Ember.Component.html)
 
-      return env.helpers.view.helperFunction.call(this, [LinkView], hash, options, env);
-    }
 
-    /**
-      See [link-to](/api/classes/Ember.Handlebars.helpers.html#method_link-to)
+    ### Use
+    Given the following application Handlebars template on the page
 
-      @method linkTo
-      @for Ember.Handlebars.helpers
-      @deprecated
-      @param {String} routeName
-      @param {Object} [context]*
-      @return {String} HTML string
-    */
-    function deprecatedLinkToHelper(params, hash, options, env) {
-      Ember.deprecate("The 'linkTo' view helper is deprecated in favor of 'link-to'");
+    ```handlebars
+    <div {{action 'anActionName'}}>
+      click me
+    </div>
+    ```
 
-      return env.helpers['link-to'].helperFunction.call(this, params, hash, options, env);
-    }
+    And application code
 
-    __exports__.deprecatedLinkToHelper = deprecatedLinkToHelper;
-    __exports__.linkToHelper = linkToHelper;
-  });
-enifed("ember-routing-htmlbars/helpers/outlet",
-  ["ember-metal/core","ember-metal/property_set","ember-routing-views/views/outlet","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-routing-htmlbars
-    */
+    ```javascript
+    App.ApplicationController = Ember.Controller.extend({
+      actions: {
+        anActionName: function() {
+        }
+      }
+    });
+    ```
 
-    var Ember = __dependency1__["default"];
-    // assert
-    var set = __dependency2__.set;
-    var OutletView = __dependency3__.OutletView;
+    Will result in the following rendered HTML
 
-    /**
-      The `outlet` helper is a placeholder that the router will fill in with
-      the appropriate template based on the current state of the application.
+    ```html
+    <div class="ember-view">
+      <div data-ember-action="1">
+        click me
+      </div>
+    </div>
+    ```
 
-      ``` handlebars
-      {{outlet}}
-      ```
+    Clicking "click me" will trigger the `anActionName` action of the
+    `App.ApplicationController`. In this case, no additional parameters will be passed.
 
-      By default, a template based on Ember's naming conventions will be rendered
-      into the `outlet` (e.g. `App.PostsRoute` will render the `posts` template).
+    If you provide additional parameters to the helper:
 
-      You can render a different template by using the `render()` method in the
-      route's `renderTemplate` hook. The following will render the `favoritePost`
-      template into the `outlet`.
+    ```handlebars
+    <button {{action 'edit' post}}>Edit</button>
+    ```
 
-      ``` javascript
-      App.PostsRoute = Ember.Route.extend({
-        renderTemplate: function() {
-          this.render('favoritePost');
-        }
-      });
-      ```
+    Those parameters will be passed along as arguments to the JavaScript
+    function implementing the action.
 
-      You can create custom named outlets for more control.
+    ### Event Propagation
 
-      ``` handlebars
-      {{outlet 'favoritePost'}}
-      {{outlet 'posts'}}
-      ```
+    Events triggered through the action helper will automatically have
+    `.preventDefault()` called on them. You do not need to do so in your event
+    handlers. If you need to allow event propagation (to handle file inputs for
+    example) you can supply the `preventDefault=false` option to the `{{action}}` helper:
 
-      Then you can define what template is rendered into each outlet in your
-      route.
+    ```handlebars
+    <div {{action "sayHello" preventDefault=false}}>
+      <input type="file" />
+      <input type="checkbox" />
+    </div>
+    ```
 
+    To disable bubbling, pass `bubbles=false` to the helper:
 
-      ``` javascript
-      App.PostsRoute = Ember.Route.extend({
-        renderTemplate: function() {
-          this.render('favoritePost', { outlet: 'favoritePost' });
-          this.render('posts', { outlet: 'posts' });
-        }
-      });
-      ```
+    ```handlebars
+    <button {{action 'edit' post bubbles=false}}>Edit</button>
+    ```
 
-      You can specify the view that the outlet uses to contain and manage the
-      templates rendered into it.
+    If you need the default handler to trigger you should either register your
+    own event handler, or use event methods on your view class. See [Ember.View](/api/classes/Ember.View.html)
+    'Responding to Browser Events' for more information.
 
-      ``` handlebars
-      {{outlet view='sectionContainer'}}
-      ```
+    ### Specifying DOM event type
 
-      ``` javascript
-      App.SectionContainer = Ember.ContainerView.extend({
-        tagName: 'section',
-        classNames: ['special']
-      });
-      ```
+    By default the `{{action}}` helper registers for DOM `click` events. You can
+    supply an `on` option to the helper to specify a different DOM event name:
 
-      @method outlet
-      @for Ember.Handlebars.helpers
-      @param {String} property the property on the controller
-        that holds the view for this outlet
-      @return {String} HTML string
-    */
-    function outletHelper(params, hash, options, env) {
-      var outletSource;
-      var viewName;
-      var viewClass;
-      var viewFullName;
+    ```handlebars
+    <div {{action "anActionName" on="doubleClick"}}>
+      click me
+    </div>
+    ```
 
-      Ember.assert(
-        "Using {{outlet}} with an unquoted name is not supported.",
-        params.length === 0 || typeof params[0] === 'string'
-      );
+    See `Ember.View` 'Responding to Browser Events' for a list of
+    acceptable DOM event names.
 
-      var property = params[0] || 'main';
+    ### Specifying whitelisted modifier keys
 
-      outletSource = this;
-      while (!outletSource.get('template.isTop')) {
-        outletSource = outletSource.get('_parentView');
-      }
-      set(this, 'outletSource', outletSource);
+    By default the `{{action}}` helper will ignore click event with pressed modifier
+    keys. You can supply an `allowedKeys` option to specify which keys should not be ignored.
 
-      // provide controller override
-      viewName = hash.view;
+    ```handlebars
+    <div {{action "anActionName" allowedKeys="alt"}}>
+      click me
+    </div>
+    ```
 
-      if (viewName) {
-        viewFullName = 'view:' + viewName;
-        Ember.assert(
-          "Using a quoteless view parameter with {{outlet}} is not supported." +
-          " Please update to quoted usage '{{outlet ... view=\"" + viewName + "\"}}.",
-          typeof hash.view === 'string'
-        );
-        Ember.assert(
-          "The view name you supplied '" + viewName + "' did not resolve to a view.",
-          this.container.has(viewFullName)
-        );
-      }
+    This way the `{{action}}` will fire when clicking with the alt key pressed down.
 
-      viewClass = viewName ? this.container.lookupFactory(viewFullName) : hash.viewClass || OutletView;
+    Alternatively, supply "any" to the `allowedKeys` option to accept any combination of modifier keys.
 
-      hash.currentViewBinding = '_view.outletSource._outlets.' + property;
+    ```handlebars
+    <div {{action "anActionName" allowedKeys="any"}}>
+      click me with any key pressed
+    </div>
+    ```
 
-      options.helperName = options.helperName || 'outlet';
+    ### Specifying a Target
 
-      return env.helpers.view.helperFunction.call(this, [viewClass], hash, options, env);
-    }
+    There are several possible target objects for `{{action}}` helpers:
 
-    __exports__.outletHelper = outletHelper;
-  });
-enifed("ember-routing-htmlbars/helpers/query-params",
-  ["ember-metal/core","ember-routing/system/query_params","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-routing-htmlbars
-    */
+    In a typical Ember application, where templates are managed through use of the
+    `{{outlet}}` helper, actions will bubble to the current controller, then
+    to the current route, and then up the route hierarchy.
 
-    var Ember = __dependency1__["default"];
-    // assert
-    var QueryParams = __dependency2__["default"];
+    Alternatively, a `target` option can be provided to the helper to change
+    which object will receive the method call. This option must be a path
+    to an object, accessible in the current context:
 
-    /**
-      This is a sub-expression to be used in conjunction with the link-to helper.
-      It will supply url query parameters to the target route.
+    ```handlebars
+    {{! the application template }}
+    <div {{action "anActionName" target=view}}>
+      click me
+    </div>
+    ```
 
-      Example
+    ```javascript
+    App.ApplicationView = Ember.View.extend({
+      actions: {
+        anActionName: function() {}
+      }
+    });
 
-      {{#link-to 'posts' (query-params direction="asc")}}Sort{{/link-to}}
+    ```
 
-      @method query-params
-      @for Ember.Handlebars.helpers
-      @param {Object} hash takes a hash of query parameters
-      @return {String} HTML string
-    */
-    function queryParamsHelper(params, hash) {
-      Ember.assert("The `query-params` helper only accepts hash parameters, e.g. (query-params queryParamPropertyName='foo') as opposed to just (query-params 'foo')", params.length === 0);
+    ### Additional Parameters
 
-      return QueryParams.create({
-        values: hash
-      });
+    You may specify additional parameters to the `{{action}}` helper. These
+    parameters are passed along as the arguments to the JavaScript function
+    implementing the action.
+
+    ```handlebars
+    {{#each person in people}}
+      <div {{action "edit" person}}>
+        click me
+      </div>
+    {{/each}}
+    ```
+
+    Clicking "click me" will trigger the `edit` method on the current controller
+    with the value of `person` as a parameter.
+
+    @method action
+    @for Ember.Handlebars.helpers
+    @param {String} actionName
+    @param {Object} [context]*
+    @param {Hash} options
+  */
+  function actionHelper(params, hash, options, env) {
+    var view = env.data.view;
+    var target;
+    if (!hash.target) {
+      target = view.getStream('controller');
+    } else if (ember_metal__streams__utils.isStream(hash.target)) {
+      target = hash.target;
+    } else {
+      target = view.getStream(hash.target);
     }
 
-    __exports__.queryParamsHelper = queryParamsHelper;
-  });
-enifed("ember-routing-htmlbars/helpers/render",
-  ["ember-metal/core","ember-metal/error","ember-runtime/system/string","ember-routing/system/generate_controller","ember-htmlbars/helpers/view","ember-metal/streams/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-routing-htmlbars
-    */
+    // Ember.assert("You specified a quoteless path to the {{action}} helper which did not resolve to an action name (a string). Perhaps you meant to use a quoted actionName? (e.g. {{action 'save'}}).", !params[0].isStream);
+    // Ember.deprecate("You specified a quoteless path to the {{action}} helper which did not resolve to an action name (a string). Perhaps you meant to use a quoted actionName? (e.g. {{action 'save'}}).", params[0].isStream);
 
-    var Ember = __dependency1__["default"];
-    // assert, deprecate
-    var EmberError = __dependency2__["default"];
-    var camelize = __dependency3__.camelize;
-    var generateControllerFactory = __dependency4__.generateControllerFactory;
-    var generateController = __dependency4__["default"];
-    var ViewHelper = __dependency5__.ViewHelper;
-    var isStream = __dependency6__.isStream;
+    var actionOptions = {
+      eventName: hash.on || "click",
+      parameters: params.slice(1),
+      view: view,
+      bubbles: hash.bubbles,
+      preventDefault: hash.preventDefault,
+      target: target,
+      withKeyCode: hash.withKeyCode
+    };
 
-    /**
-      Calling ``{{render}}`` from within a template will insert another
-      template that matches the provided name. The inserted template will
-      access its properties on its own controller (rather than the controller
-      of the parent template).
+    var actionId = ActionHelper.registerAction(params[0], actionOptions, hash.allowedKeys);
+    env.dom.setAttribute(options.element, 'data-ember-action', actionId);
+  }
 
-      If a view class with the same name exists, the view class also will be used.
+  exports.ActionHelper = ActionHelper;
 
-      Note: A given controller may only be used *once* in your app in this manner.
-      A singleton instance of the controller will be created for you.
+});
+enifed('ember-routing-htmlbars/helpers/link-to', ['exports', 'ember-metal/core', 'ember-routing-views/views/link', 'ember-metal/streams/utils', 'ember-runtime/mixins/controller', 'ember-htmlbars/templates/link-to-escaped', 'ember-htmlbars/templates/link-to-unescaped', 'ember-htmlbars'], function (exports, Ember, link, utils, ControllerMixin, inlineEscapedLinkTo, inlineUnescapedLinkTo) {
 
-      Example:
+  'use strict';
 
-      ```javascript
-      App.NavigationController = Ember.Controller.extend({
-        who: "world"
-      });
-      ```
+  exports.deprecatedLinkToHelper = deprecatedLinkToHelper;
+  exports.linkToHelper = linkToHelper;
 
-      ```handlebars
-      <!-- navigation.hbs -->
-      Hello, {{who}}.
-      ```
+  /**
+  @module ember
+  @submodule ember-routing-htmlbars
+  */
 
-      ```handlebars
-      <!-- application.hbs -->
-      <h1>My great app</h1>
-      {{render "navigation"}}
-      ```
+  function linkToHelper(params, hash, options, env) {
+    var queryParamsObject;
+    var view = env.data.view;
 
-      ```html
-      <h1>My great app</h1>
-      <div class='ember-view'>
-        Hello, world.
-      </div>
-      ```
+    Ember['default'].assert("You must provide one or more parameters to the link-to helper.", params.length);
 
-      Optionally you may provide a second argument: a property path
-      that will be bound to the `model` property of the controller.
+    var lastParam = params[params.length - 1];
 
-      If a `model` property path is specified, then a new instance of the
-      controller will be created and `{{render}}` can be used multiple times
-      with the same name.
+    if (lastParam && lastParam.isQueryParams) {
+      hash.queryParamsObject = queryParamsObject = params.pop();
+    }
 
-     For example if you had this `author` template.
+    if (hash.disabledWhen) {
+      hash.disabled = hash.disabledWhen;
+      delete hash.disabledWhen;
+    }
 
-     ```handlebars
-    <div class="author">
-    Written by {{firstName}} {{lastName}}.
-    Total Posts: {{postCount}}
-    </div>
-    ```
+    if (!options.template) {
+      var linkTitle = params.shift();
+      var parseTextAsHTML = options.morph.parseTextAsHTML;
 
-    You could render it inside the `post` template using the `render` helper.
+      if (parseTextAsHTML) {
+        hash.layout = inlineUnescapedLinkTo['default'];
+      } else {
+        hash.layout = inlineEscapedLinkTo['default'];
+      }
 
-    ```handlebars
-    <div class="post">
-    <h1>{{title}}</h1>
-    <div>{{body}}</div>
-    {{render "author" author}}
-    </div>
-     ```
+      hash.linkTitle = linkTitle;
+    }
 
-      @method render
-      @for Ember.Handlebars.helpers
-      @param {String} name
-      @param {Object?} context
-      @param {Hash} options
-      @return {String} HTML string
-    */
-    function renderHelper(params, hash, options, env) {
-      var container, router, controller, view, initialContext;
+    for (var i = 0; i < params.length; i++) {
+      if (utils.isStream(params[i])) {
+        var lazyValue = params[i];
 
-      var name = params[0];
-      var context = params[1];
+        if (!lazyValue._isController) {
+          while (ControllerMixin['default'].detect(lazyValue.value())) {
+            Ember['default'].deprecate('Providing `{{link-to}}` with a param that is wrapped in a controller is deprecated. Please update `' + view + '` to use `{{link-to "post" someController.model}}` instead.');
 
-      container = this._keywords.controller.value().container;
-      router = container.lookup('router:main');
+            lazyValue = lazyValue.get('model');
+          }
+        }
 
-      Ember.assert(
-        "The first argument of {{render}} must be quoted, e.g. {{render \"sidebar\"}}.",
-        typeof name === 'string'
-      );
+        params[i] = lazyValue;
+      }
+    }
 
-      Ember.assert(
-        "The second argument of {{render}} must be a path, e.g. {{render \"post\" post}}.",
-        params.length < 2 || isStream(params[1])
-      );
+    hash.params = params;
 
+    options.helperName = options.helperName || 'link-to';
 
-      if (params.length === 1) {
-        // use the singleton controller
-        Ember.assert("You can only use the {{render}} helper once without a model object as its" +
-                     " second argument, as in {{render \"post\" post}}.", !router || !router._lookupActiveView(name));
-      } else if (params.length === 2) {
-        // create a new controller
-        initialContext = context.value();
-      } else {
-        throw new EmberError("You must pass a templateName to render");
-      }
+    return env.helpers.view.helperFunction.call(this, [link.LinkView], hash, options, env);
+  }
+
+  /**
+    See [link-to](/api/classes/Ember.Handlebars.helpers.html#method_link-to)
 
-      // # legacy namespace
-      name = name.replace(/\//g, '.');
-      // \ legacy slash as namespace support
+    @method linkTo
+    @for Ember.Handlebars.helpers
+    @deprecated
+    @param {String} routeName
+    @param {Object} [context]*
+    @return {String} HTML string
+  */
+  function deprecatedLinkToHelper(params, hash, options, env) {
+    Ember['default'].deprecate("The 'linkTo' view helper is deprecated in favor of 'link-to'");
 
+    return env.helpers['link-to'].helperFunction.call(this, params, hash, options, env);
+  }
 
-      view = container.lookup('view:' + name) || container.lookup('view:default');
+});
+enifed('ember-routing-htmlbars/helpers/outlet', ['exports', 'ember-metal/core'], function (exports, Ember) {
 
-      // provide controller override
-      var controllerName = hash.controller || name;
-      var controllerFullName = 'controller:' + controllerName;
+  'use strict';
 
-      Ember.assert("The controller name you supplied '" + controllerName +
-                   "' did not resolve to a controller.", !hash.controller || container.has(controllerFullName));
+  exports.outletHelper = outletHelper;
 
-      var parentController = this._keywords.controller.value();
+  /**
+  @module ember
+  @submodule ember-routing-htmlbars
+  */
 
-      // choose name
-      if (params.length > 1) {
-        var factory = container.lookupFactory(controllerFullName) ||
-                      generateControllerFactory(container, controllerName, initialContext);
+  function outletHelper(params, hash, options, env) {
+    var viewName;
+    var viewClass;
+    var viewFullName;
+    var view = env.data.view;
 
-        controller = factory.create({
-          modelBinding: context, // TODO: Use a StreamBinding
-          parentController: parentController,
-          target: parentController
-        });
+    Ember['default'].assert(
+      "Using {{outlet}} with an unquoted name is not supported.",
+      params.length === 0 || typeof params[0] === 'string'
+    );
 
-        view.one('willDestroyElement', function() {
-          controller.destroy();
-        });
-      } else {
-        controller = container.lookup(controllerFullName) ||
-                     generateController(container, controllerName);
+    var property = params[0] || 'main';
 
-        controller.setProperties({
-          target: parentController,
-          parentController: parentController
-        });
-      }
 
-      hash.viewName = camelize(name);
+    // provide controller override
+    viewName = hash.view;
 
-      var templateName = 'template:' + name;
-      Ember.assert("You used `{{render '" + name + "'}}`, but '" + name + "' can not be found as either" +
-                   " a template or a view.", container.has("view:" + name) || container.has(templateName) || !!options.template);
-      hash.template = container.lookup(templateName);
+    if (viewName) {
+      viewFullName = 'view:' + viewName;
+      Ember['default'].assert(
+        "Using a quoteless view parameter with {{outlet}} is not supported." +
+        " Please update to quoted usage '{{outlet ... view=\"" + viewName + "\"}}.",
+        typeof hash.view === 'string'
+      );
+      Ember['default'].assert(
+        "The view name you supplied '" + viewName + "' did not resolve to a view.",
+        view.container._registry.has(viewFullName)
+      );
+    }
 
-      hash.controller = controller;
+    viewClass = viewName ? view.container.lookupFactory(viewFullName) : hash.viewClass || view.container.lookupFactory('view:-outlet');
+    hash._outletName = property;
+    options.helperName = options.helperName || 'outlet';
+    return env.helpers.view.helperFunction.call(this, [viewClass], hash, options, env);
+  }
 
-      if (router && !initialContext) {
-        router._connectActiveView(name, view);
-      }
+});
+enifed('ember-routing-htmlbars/helpers/query-params', ['exports', 'ember-metal/core', 'ember-routing/system/query_params'], function (exports, Ember, QueryParams) {
 
-      options.helperName = options.helperName || ('render "' + name + '"');
+  'use strict';
 
-      ViewHelper.instanceHelper(view, hash, options, env);
-    }
+  exports.queryParamsHelper = queryParamsHelper;
 
-    __exports__.renderHelper = renderHelper;
-  });
-enifed("ember-routing-views",
-  ["ember-metal/core","ember-routing-views/views/link","ember-routing-views/views/outlet","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    /**
-    Ember Routing Views
+  /**
+  @module ember
+  @submodule ember-routing-htmlbars
+  */
 
-    @module ember
-    @submodule ember-routing-views
-    @requires ember-routing
-    */
+  function queryParamsHelper(params, hash) {
+    Ember['default'].assert("The `query-params` helper only accepts hash parameters, e.g. (query-params queryParamPropertyName='foo') as opposed to just (query-params 'foo')", params.length === 0);
 
-    var Ember = __dependency1__["default"];
+    return QueryParams['default'].create({
+      values: hash
+    });
+  }
 
-    var LinkView = __dependency2__.LinkView;
-    var OutletView = __dependency3__.OutletView;
+});
+enifed('ember-routing-htmlbars/helpers/render', ['exports', 'ember-metal/core', 'ember-metal/error', 'ember-runtime/system/string', 'ember-routing/system/generate_controller', 'ember-metal/streams/utils', 'ember-htmlbars/system/merge-view-bindings', 'ember-htmlbars/system/append-templated-view', 'ember-metal/platform/create'], function (exports, Ember, EmberError, string, generate_controller, utils, mergeViewBindings, appendTemplatedView, create) {
 
-    Ember.LinkView = LinkView;
-    Ember.OutletView = OutletView;
+  'use strict';
 
-    __exports__["default"] = Ember;
-  });
-enifed("ember-routing-views/views/link",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/merge","ember-metal/run_loop","ember-metal/computed","ember-runtime/system/string","ember-metal/keys","ember-views/system/utils","ember-views/views/component","ember-routing/utils","ember-metal/streams/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-routing-views
-    */
-
-    var Ember = __dependency1__["default"];
-    // FEATURES, Logger, assert
-
-    var get = __dependency2__.get;
-    var merge = __dependency3__["default"];
-    var run = __dependency4__["default"];
-    var computed = __dependency5__.computed;
-    var fmt = __dependency6__.fmt;
-    var keys = __dependency7__["default"];
-    var isSimpleClick = __dependency8__.isSimpleClick;
-    var EmberComponent = __dependency9__["default"];
-    var routeArgs = __dependency10__.routeArgs;
-    var read = __dependency11__.read;
-    var subscribe = __dependency11__.subscribe;
-
-    var numberOfContextsAcceptedByHandler = function(handler, handlerInfos) {
-      var req = 0;
-      for (var i = 0, l = handlerInfos.length; i < l; i++) {
-        req = req + handlerInfos[i].names.length;
-        if (handlerInfos[i].handler === handler)
-          break;
-      }
+  exports.renderHelper = renderHelper;
 
-      return req;
-    };
+  /**
+  @module ember
+  @submodule ember-routing-htmlbars
+  */
 
-    /**
-      `Ember.LinkView` renders an element whose `click` event triggers a
-      transition of the application's instance of `Ember.Router` to
-      a supplied route by name.
+  function renderHelper(params, hash, options, env) {
+    var currentView = env.data.view;
+    var container, router, controller, view, initialContext;
 
-      Instances of `LinkView` will most likely be created through
-      the `link-to` Handlebars helper, but properties of this class
-      can be overridden to customize application-wide behavior.
+    var name = params[0];
+    var context = params[1];
 
-      @class LinkView
-      @namespace Ember
-      @extends Ember.View
-      @see {Handlebars.helpers.link-to}
-    **/
-    var LinkView = Ember.LinkView = EmberComponent.extend({
-      tagName: 'a',
+    container = currentView._keywords.controller.value().container;
+    router = container.lookup('router:main');
 
-      /**
-        @deprecated Use current-when instead.
-        @property currentWhen
-      */
-      currentWhen: null,
+    Ember['default'].assert(
+      "The first argument of {{render}} must be quoted, e.g. {{render \"sidebar\"}}.",
+      typeof name === 'string'
+    );
 
-      /**
-        Used to determine when this LinkView is active.
+    Ember['default'].assert(
+      "The second argument of {{render}} must be a path, e.g. {{render \"post\" post}}.",
+      params.length < 2 || utils.isStream(params[1])
+    );
 
-        @property currentWhen
-      */
-      'current-when': null,
 
-      /**
-        Sets the `title` attribute of the `LinkView`'s HTML element.
+    if (params.length === 1) {
+      // use the singleton controller
+      Ember['default'].assert(
+        "You can only use the {{render}} helper once without a model object as " +
+        "its second argument, as in {{render \"post\" post}}.",
+        !router || !router._lookupActiveView(name)
+      );
+    } else if (params.length === 2) {
+      // create a new controller
+      initialContext = context.value();
+    } else {
+      throw new EmberError['default']("You must pass a templateName to render");
+    }
 
-        @property title
-        @default null
-      **/
-      title: null,
+    // # legacy namespace
+    name = name.replace(/\//g, '.');
+    // \ legacy slash as namespace support
 
-      /**
-        Sets the `rel` attribute of the `LinkView`'s HTML element.
+    var templateName = 'template:' + name;
+    Ember['default'].assert(
+      "You used `{{render '" + name + "'}}`, but '" + name + "' can not be " +
+      "found as either a template or a view.",
+      container._registry.has("view:" + name) || container._registry.has(templateName) || !!options.template
+    );
 
-        @property rel
-        @default null
-      **/
-      rel: null,
+    var template = options.template;
+    view = container.lookup('view:' + name);
+    if (!view) {
+      view = container.lookup('view:default');
+      template = template || container.lookup(templateName);
+    }
 
-      /**
-        Sets the `tabindex` attribute of the `LinkView`'s HTML element.
+    // provide controller override
+    var controllerName;
+    var controllerFullName;
 
-        @property tabindex
-        @default null
-      **/
-      tabindex: null,
+    if (hash.controller) {
+      controllerName = hash.controller;
+      controllerFullName = 'controller:' + controllerName;
+      delete hash.controller;
 
-      /**
-        Sets the `target` attribute of the `LinkView`'s HTML element.
+      Ember['default'].assert(
+        "The controller name you supplied '" + controllerName + "' " +
+        "did not resolve to a controller.",
+        container._registry.has(controllerFullName)
+      );
+    } else {
+      controllerName = name;
+      controllerFullName = 'controller:' + controllerName;
+    }
 
-        @since 1.8.0
-        @property target
-        @default null
-      **/
-      target: null,
+    var parentController = currentView._keywords.controller.value();
 
-      /**
-        The CSS class to apply to `LinkView`'s element when its `active`
-        property is `true`.
+    // choose name
+    if (params.length > 1) {
+      var factory = container.lookupFactory(controllerFullName) ||
+                    generate_controller.generateControllerFactory(container, controllerName, initialContext);
 
-        @property activeClass
-        @type String
-        @default active
-      **/
-      activeClass: 'active',
+      controller = factory.create({
+        modelBinding: context, // TODO: Use a StreamBinding
+        parentController: parentController,
+        target: parentController
+      });
 
-      /**
-        The CSS class to apply to `LinkView`'s element when its `loading`
-        property is `true`.
+      view.one('willDestroyElement', function() {
+        controller.destroy();
+      });
+    } else {
+      controller = container.lookup(controllerFullName) ||
+                   generate_controller["default"](container, controllerName);
 
-        @property loadingClass
-        @type String
-        @default loading
-      **/
-      loadingClass: 'loading',
+      controller.setProperties({
+        target: parentController,
+        parentController: parentController
+      });
+    }
 
-      /**
-        The CSS class to apply to a `LinkView`'s element when its `disabled`
-        property is `true`.
+    hash.viewName = string.camelize(name);
 
-        @property disabledClass
-        @type String
-        @default disabled
-      **/
-      disabledClass: 'disabled',
-      _isDisabled: false,
+    if (router && !initialContext) {
+      router._connectActiveView(name, view);
+    }
 
-      /**
-        Determines whether the `LinkView` will trigger routing via
-        the `replaceWith` routing strategy.
+    var props = {
+      template: template,
+      controller: controller,
+      helperName: 'render "' + name + '"'
+    };
 
-        @property replace
-        @type Boolean
-        @default false
-      **/
-      replace: false,
+    impersonateAnOutlet(currentView, view, name);
+    mergeViewBindings['default'](currentView, props, hash);
+    appendTemplatedView['default'](currentView, options.morph, view, props);
+  }
 
-      /**
-        By default the `{{link-to}}` helper will bind to the `href` and
-        `title` attributes. It's discouraged that you override these defaults,
-        however you can push onto the array if needed.
+  // Megahax to make outlets inside the render helper work, until we
+  // can kill that behavior at 2.0.
+  function impersonateAnOutlet(currentView, view, name) {
+    view._childOutlets = Ember['default'].A();
+    view._isOutlet = true;
+    view._outletName = '__ember_orphans__';
+    view._matchOutletName = name;
+    view.setOutletState = function(state) {
+      var ownState;
+      if (state && (ownState = state.outlets[this._matchOutletName])) {
+        this._outletState = {
+          render: { name: 'render helper stub' },
+          outlets: create['default'](null)
+        };
+        this._outletState.outlets[ownState.render.outlet] = ownState;
+        ownState.wasUsed = true;
+      } else {
+        this._outletState = null;
+      }
+      for (var i = 0; i < this._childOutlets.length; i++) {
+        var child = this._childOutlets[i];
+        child.setOutletState(this._outletState && this._outletState.outlets[child._outletName]);
+      }
+    };
 
-        @property attributeBindings
-        @type Array | String
-        @default ['href', 'title', 'rel', 'tabindex', 'target']
-       **/
-      attributeBindings: ['href', 'title', 'rel', 'tabindex'],
+    var pointer = currentView;
+    var po;
+    while (pointer && !pointer._isOutlet) {
+      pointer = pointer._parentView;
+    }
+    while (pointer && (po = pointer._parentOutlet())) {
+      pointer = po;
+    }
+    if (pointer) {
+      // we've found the toplevel outlet. Subscribe to its
+      // __ember_orphan__ child outlet, which is our hack convention for
+      // stashing outlet state that may target the render helper.
+      pointer._childOutlets.push(view);
+      if (pointer._outletState) {
+        view.setOutletState(pointer._outletState.outlets[view._outletName]);
+      }
+    }
+  }
 
-      /**
-        By default the `{{link-to}}` helper will bind to the `active`, `loading`, and
-        `disabled` classes. It is discouraged to override these directly.
+});
+enifed('ember-routing-views', ['exports', 'ember-metal/core', 'ember-routing-views/views/link', 'ember-routing-views/views/outlet'], function (exports, Ember, link, outlet) {
 
-        @property classNameBindings
-        @type Array
-        @default ['active', 'loading', 'disabled']
-       **/
-      classNameBindings: ['active', 'loading', 'disabled'],
+	'use strict';
 
-      /**
-        By default the `{{link-to}}` helper responds to the `click` event. You
-        can override this globally by setting this property to your custom
-        event name.
+	/**
+	Ember Routing Views
 
-        This is particularly useful on mobile when one wants to avoid the 300ms
-        click delay using some sort of custom `tap` event.
+	@module ember
+	@submodule ember-routing-views
+	@requires ember-routing
+	*/
 
-        @property eventName
-        @type String
-        @default click
-      */
-      eventName: 'click',
+	Ember['default'].LinkView = link.LinkView;
+	Ember['default'].OutletView = outlet.OutletView;
 
-      // this is doc'ed here so it shows up in the events
-      // section of the API documentation, which is where
-      // people will likely go looking for it.
-      /**
-        Triggers the `LinkView`'s routing behavior. If
-        `eventName` is changed to a value other than `click`
-        the routing behavior will trigger on that custom event
-        instead.
+	exports['default'] = Ember['default'];
 
-        @event click
-      **/
+});
+enifed('ember-routing-views/views/link', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/merge', 'ember-metal/run_loop', 'ember-metal/computed', 'ember-runtime/system/string', 'ember-metal/keys', 'ember-views/system/utils', 'ember-views/views/component', 'ember-routing/utils', 'ember-metal/streams/utils'], function (exports, Ember, property_get, merge, run, computed, string, keys, utils, EmberComponent, ember_routing__utils, streams__utils) {
 
-      /**
-        An overridable method called when LinkView objects are instantiated.
+  'use strict';
 
-        Example:
+  /**
+  @module ember
+  @submodule ember-routing-views
+  */
 
-        ```javascript
-        App.MyLinkView = Ember.LinkView.extend({
-          init: function() {
-            this._super();
-            Ember.Logger.log('Event is ' + this.get('eventName'));
-          }
-        });
-        ```
+  var numberOfContextsAcceptedByHandler = function(handler, handlerInfos) {
+    var req = 0;
+    for (var i = 0, l = handlerInfos.length; i < l; i++) {
+      req = req + handlerInfos[i].names.length;
+      if (handlerInfos[i].handler === handler) {
+        break;
+      }
+    }
 
-        NOTE: If you do override `init` for a framework class like `Ember.View` or
-        `Ember.ArrayController`, be sure to call `this._super()` in your
-        `init` declaration! If you don't, Ember may not have an opportunity to
-        do important setup work, and you'll see strange behavior in your
-        application.
+    return req;
+  };
 
-        @method init
-      */
-      init: function() {
-        this._super.apply(this, arguments);
+  var linkViewClassNameBindings = ['active', 'loading', 'disabled'];
 
-        Ember.deprecate('Using currentWhen with {{link-to}} is deprecated in favor of `current-when`.', !this.currentWhen);
+    linkViewClassNameBindings = ['active', 'loading', 'disabled', 'transitioningIn', 'transitioningOut'];
 
-        // Map desired event name to invoke function
-        var eventName = get(this, 'eventName');
-        this.on(eventName, this, this._invoke);
-      },
 
-      /**
-        This method is invoked by observers installed during `init` that fire
-        whenever the params change
+  /**
+    `Ember.LinkView` renders an element whose `click` event triggers a
+    transition of the application's instance of `Ember.Router` to
+    a supplied route by name.
 
-        @private
-        @method _paramsChanged
-        @since 1.3.0
-       */
-      _paramsChanged: function() {
-        this.notifyPropertyChange('resolvedParams');
-      },
+    Instances of `LinkView` will most likely be created through
+    the `link-to` Handlebars helper, but properties of this class
+    can be overridden to customize application-wide behavior.
 
-      /**
-       This is called to setup observers that will trigger a rerender.
+    @class LinkView
+    @namespace Ember
+    @extends Ember.View
+    @see {Handlebars.helpers.link-to}
+  **/
+  var LinkView = EmberComponent['default'].extend({
+    tagName: 'a',
 
-       @private
-       @method _setupPathObservers
-       @since 1.3.0
-      **/
-      _setupPathObservers: function(){
-        var params = this.params;
+    /**
+      @deprecated Use current-when instead.
+      @property currentWhen
+    */
+    currentWhen: null,
 
-        var scheduledRerender = this._wrapAsScheduled(this.rerender);
-        var scheduledParamsChanged = this._wrapAsScheduled(this._paramsChanged);
+    /**
+      Used to determine when this LinkView is active.
 
-        if (this.linkTitle) {
-          var linkTitle = this.linkTitle.stream || this.linkTitle;
-          subscribe(linkTitle, scheduledRerender, this);
-        }
+      @property currentWhen
+    */
+    'current-when': null,
 
-        for (var i = 0; i < params.length; i++) {
-          subscribe(params[i], scheduledParamsChanged, this);
-        }
+    /**
+      Sets the `title` attribute of the `LinkView`'s HTML element.
 
-        var queryParamsObject = this.queryParamsObject;
-        if (queryParamsObject) {
-          var values = queryParamsObject.values;
-          for (var k in values) {
-            if (!values.hasOwnProperty(k)) {
-              continue;
-            }
+      @property title
+      @default null
+    **/
+    title: null,
 
-            subscribe(values[k], scheduledParamsChanged, this);
-          }
-        }
-      },
+    /**
+      Sets the `rel` attribute of the `LinkView`'s HTML element.
 
-      afterRender: function(){
-        this._super.apply(this, arguments);
-        this._setupPathObservers();
-      },
+      @property rel
+      @default null
+    **/
+    rel: null,
 
-      /**
+    /**
+      Sets the `tabindex` attribute of the `LinkView`'s HTML element.
 
-        Accessed as a classname binding to apply the `LinkView`'s `disabledClass`
-        CSS `class` to the element when the link is disabled.
+      @property tabindex
+      @default null
+    **/
+    tabindex: null,
 
-        When `true` interactions with the element will not trigger route changes.
-        @property disabled
-      */
-      disabled: computed(function computeLinkViewDisabled(key, value) {
-        if (value !== undefined) { this.set('_isDisabled', value); }
+    /**
+      Sets the `target` attribute of the `LinkView`'s HTML element.
 
-        return value ? get(this, 'disabledClass') : false;
-      }),
+      @since 1.8.0
+      @property target
+      @default null
+    **/
+    target: null,
 
-      /**
-        Accessed as a classname binding to apply the `LinkView`'s `activeClass`
-        CSS `class` to the element when the link is active.
-
-        A `LinkView` is considered active when its `currentWhen` property is `true`
-        or the application's current route is the route the `LinkView` would trigger
-        transitions into.
-
-        The `currentWhen` property can match against multiple routes by separating
-        route names using the ` ` (space) character.
-
-        @property active
-      **/
-      active: computed('loadedParams', function computeLinkViewActive() {
-        if (get(this, 'loading')) { return false; }
-
-        var router = get(this, 'router');
-        var loadedParams = get(this, 'loadedParams');
-        var contexts = loadedParams.models;
-        var currentWhen = this['current-when'] || this.currentWhen;
-        var isCurrentWhenSpecified = Boolean(currentWhen);
-        currentWhen = currentWhen || loadedParams.targetRouteName;
-
-        function isActiveForRoute(routeName) {
-          var handlers = router.router.recognizer.handlersFor(routeName);
-          var leafName = handlers[handlers.length-1].handler;
-          var maximumContexts = numberOfContextsAcceptedByHandler(routeName, handlers);
-
-          // NOTE: any ugliness in the calculation of activeness is largely
-          // due to the fact that we support automatic normalizing of
-          // `resource` -> `resource.index`, even though there might be
-          // dynamic segments / query params defined on `resource.index`
-          // which complicates (and makes somewhat ambiguous) the calculation
-          // of activeness for links that link to `resource` instead of
-          // directly to `resource.index`.
-
-          // if we don't have enough contexts revert back to full route name
-          // this is because the leaf route will use one of the contexts
-          if (contexts.length > maximumContexts) {
-            routeName = leafName;
-          }
+    /**
+      The CSS class to apply to `LinkView`'s element when its `active`
+      property is `true`.
 
-          var args = routeArgs(routeName, contexts, null);
-          var isActive = router.isActive.apply(router, args);
-          if (!isActive) { return false; }
+      @property activeClass
+      @type String
+      @default active
+    **/
+    activeClass: 'active',
 
-          var emptyQueryParams = Ember.isEmpty(Ember.keys(loadedParams.queryParams));
+    /**
+      The CSS class to apply to `LinkView`'s element when its `loading`
+      property is `true`.
 
-          if (!isCurrentWhenSpecified && !emptyQueryParams && isActive) {
-            var visibleQueryParams = {};
-            merge(visibleQueryParams, loadedParams.queryParams);
-            router._prepareQueryParams(loadedParams.targetRouteName, loadedParams.models, visibleQueryParams);
-            isActive = shallowEqual(visibleQueryParams, router.router.state.queryParams);
-          }
+      @property loadingClass
+      @type String
+      @default loading
+    **/
+    loadingClass: 'loading',
 
-          return isActive;
-        }
+    /**
+      The CSS class to apply to a `LinkView`'s element when its `disabled`
+      property is `true`.
 
-        
-          currentWhen = currentWhen.split(' ');
-          for (var i = 0, len = currentWhen.length; i < len; i++) {
-            if (isActiveForRoute(currentWhen[i])) {
-              return get(this, 'activeClass');
-            }
-          }
-              }),
+      @property disabledClass
+      @type String
+      @default disabled
+    **/
+    disabledClass: 'disabled',
+    _isDisabled: false,
 
-      /**
-        Accessed as a classname binding to apply the `LinkView`'s `loadingClass`
-        CSS `class` to the element when the link is loading.
-
-        A `LinkView` is considered loading when it has at least one
-        parameter whose value is currently null or undefined. During
-        this time, clicking the link will perform no transition and
-        emit a warning that the link is still in a loading state.
-
-        @property loading
-      **/
-      loading: computed('loadedParams', function computeLinkViewLoading() {
-        if (!get(this, 'loadedParams')) { return get(this, 'loadingClass'); }
-      }),
+    /**
+      Determines whether the `LinkView` will trigger routing via
+      the `replaceWith` routing strategy.
 
-      /**
-        Returns the application's main router from the container.
+      @property replace
+      @type Boolean
+      @default false
+    **/
+    replace: false,
 
-        @private
-        @property router
-      **/
-      router: computed(function() {
-        var controller = get(this, 'controller');
-        if (controller && controller.container) {
-          return controller.container.lookup('router:main');
-        }
-      }),
+    /**
+      By default the `{{link-to}}` helper will bind to the `href` and
+      `title` attributes. It's discouraged that you override these defaults,
+      however you can push onto the array if needed.
 
-      /**
-        Event handler that invokes the link, activating the associated route.
+      @property attributeBindings
+      @type Array | String
+      @default ['href', 'title', 'rel', 'tabindex', 'target']
+     **/
+    attributeBindings: ['href', 'title', 'rel', 'tabindex', 'target'],
 
-        @private
-        @method _invoke
-        @param {Event} event
-      */
-      _invoke: function(event) {
-        if (!isSimpleClick(event)) { return true; }
-
-        if (this.preventDefault !== false) {
-          
-            var targetAttribute = get(this, 'target');
-            if (!targetAttribute || targetAttribute === '_self') {
-              event.preventDefault();
-            }
-                  }
+    /**
+      By default the `{{link-to}}` helper will bind to the `active`, `loading`, and
+      `disabled` classes. It is discouraged to override these directly.
 
-        if (this.bubbles === false) { event.stopPropagation(); }
+      @property classNameBindings
+      @type Array
+      @default ['active', 'loading', 'disabled']
+     **/
+    classNameBindings: linkViewClassNameBindings,
 
-        if (get(this, '_isDisabled')) { return false; }
+    /**
+      By default the `{{link-to}}` helper responds to the `click` event. You
+      can override this globally by setting this property to your custom
+      event name.
 
-        if (get(this, 'loading')) {
-          Ember.Logger.warn("This link-to is in an inactive loading state because at least one of its parameters presently has a null/undefined value, or the provided route name is invalid.");
-          return false;
-        }
+      This is particularly useful on mobile when one wants to avoid the 300ms
+      click delay using some sort of custom `tap` event.
 
-        
-          var targetAttribute2 = get(this, 'target');
-          if (targetAttribute2 && targetAttribute2 !== '_self') {
-            return false;
-          }
-        
+      @property eventName
+      @type String
+      @default click
+    */
+    eventName: 'click',
 
-        var router = get(this, 'router');
-        var loadedParams = get(this, 'loadedParams');
+    // this is doc'ed here so it shows up in the events
+    // section of the API documentation, which is where
+    // people will likely go looking for it.
+    /**
+      Triggers the `LinkView`'s routing behavior. If
+      `eventName` is changed to a value other than `click`
+      the routing behavior will trigger on that custom event
+      instead.
 
-        var transition = router._doTransition(loadedParams.targetRouteName, loadedParams.models, loadedParams.queryParams);
-        if (get(this, 'replace')) {
-          transition.method('replace');
-        }
+      @event click
+    **/
 
-        // Schedule eager URL update, but after we've given the transition
-        // a chance to synchronously redirect.
-        // We need to always generate the URL instead of using the href because
-        // the href will include any rootURL set, but the router expects a URL
-        // without it! Note that we don't use the first level router because it
-        // calls location.formatURL(), which also would add the rootURL!
-        var args = routeArgs(loadedParams.targetRouteName, loadedParams.models, transition.state.queryParams);
-        var url = router.router.generate.apply(router.router, args);
+    /**
+      An overridable method called when LinkView objects are instantiated.
 
-        run.scheduleOnce('routerTransitions', this, this._eagerUpdateUrl, transition, url);
-      },
+      Example:
 
-      /**
-        @private
-        @method _eagerUpdateUrl
-        @param transition
-        @param href
-       */
-      _eagerUpdateUrl: function(transition, href) {
-        if (!transition.isActive || !transition.urlMethod) {
-          // transition was aborted, already ran to completion,
-          // or it has a null url-updated method.
-          return;
+      ```javascript
+      App.MyLinkView = Ember.LinkView.extend({
+        init: function() {
+          this._super.apply(this, arguments);
+          Ember.Logger.log('Event is ' + this.get('eventName'));
         }
+      });
+      ```
 
-        if (href.indexOf('#') === 0) {
-          href = href.slice(1);
-        }
+      NOTE: If you do override `init` for a framework class like `Ember.View` or
+      `Ember.ArrayController`, be sure to call `this._super.apply(this, arguments)` in your
+      `init` declaration! If you don't, Ember may not have an opportunity to
+      do important setup work, and you'll see strange behavior in your
+      application.
 
-        // Re-use the routerjs hooks set up by the Ember router.
-        var routerjs = get(this, 'router.router');
-        if (transition.urlMethod === 'update') {
-          routerjs.updateURL(href);
-        } else if (transition.urlMethod === 'replace') {
-          routerjs.replaceURL(href);
-        }
+      @method init
+    */
+    init: function() {
+      this._super.apply(this, arguments);
 
-        // Prevent later update url refire.
-        transition.method(null);
-      },
+      Ember['default'].deprecate(
+        'Using currentWhen with {{link-to}} is deprecated in favor of `current-when`.',
+        !this.currentWhen
+      );
 
-      /**
-        Computed property that returns an array of the
-        resolved parameters passed to the `link-to` helper,
-        e.g.:
+      // Map desired event name to invoke function
+      var eventName = property_get.get(this, 'eventName');
+      this.on(eventName, this, this._invoke);
+    },
 
-        ```hbs
-        {{link-to a b '123' c}}
-        ```
+    /**
+      This method is invoked by observers installed during `init` that fire
+      whenever the params change
 
-        will generate a `resolvedParams` of:
+      @private
+      @method _paramsChanged
+      @since 1.3.0
+     */
+    _paramsChanged: function() {
+      this.notifyPropertyChange('resolvedParams');
+    },
 
-        ```js
-        [aObject, bObject, '123', cObject]
-        ```
+    /**
+     This is called to setup observers that will trigger a rerender.
 
-        @private
-        @property
-        @return {Array}
-       */
-      resolvedParams: computed('router.url', function() {
-        var params = this.params;
-        var targetRouteName;
-        var models = [];
-        var onlyQueryParamsSupplied = (params.length === 0);
+     @private
+     @method _setupPathObservers
+     @since 1.3.0
+    **/
+    _setupPathObservers: function() {
+      var params = this.params;
 
-        if (onlyQueryParamsSupplied) {
-          var appController = this.container.lookup('controller:application');
-          targetRouteName = get(appController, 'currentRouteName');
-        } else {
-          targetRouteName = read(params[0]);
+      var scheduledParamsChanged = this._wrapAsScheduled(this._paramsChanged);
 
-          for (var i = 1; i < params.length; i++) {
-            models.push(read(params[i]));
+      for (var i = 0; i < params.length; i++) {
+        streams__utils.subscribe(params[i], scheduledParamsChanged, this);
+      }
+
+      var queryParamsObject = this.queryParamsObject;
+      if (queryParamsObject) {
+        var values = queryParamsObject.values;
+        for (var k in values) {
+          if (!values.hasOwnProperty(k)) {
+            continue;
           }
+
+          streams__utils.subscribe(values[k], scheduledParamsChanged, this);
         }
+      }
+    },
 
-        var suppliedQueryParams = getResolvedQueryParams(this, targetRouteName);
+    afterRender: function() {
+      this._super.apply(this, arguments);
+      this._setupPathObservers();
+    },
 
-        return {
-          targetRouteName: targetRouteName,
-          models: models,
-          queryParams: suppliedQueryParams
-        };
-      }),
+    /**
 
-      /**
-        Computed property that returns the current route name,
-        dynamic segments, and query params. Returns falsy if
-        for null/undefined params to indicate that the link view
-        is still in a loading state.
+      Accessed as a classname binding to apply the `LinkView`'s `disabledClass`
+      CSS `class` to the element when the link is disabled.
 
-        @private
-        @property
-        @return {Array} An array with the route name and any dynamic segments
-      **/
-      loadedParams: computed('resolvedParams', function computeLinkViewRouteArgs() {
-        var router = get(this, 'router');
-        if (!router) { return; }
+      When `true` interactions with the element will not trigger route changes.
+      @property disabled
+    */
+    disabled: computed.computed(function computeLinkViewDisabled(key, value) {
+      if (value !== undefined) { this.set('_isDisabled', value); }
 
-        var resolvedParams = get(this, 'resolvedParams');
-        var namedRoute = resolvedParams.targetRouteName;
+      return value ? property_get.get(this, 'disabledClass') : false;
+    }),
 
-        if (!namedRoute) { return; }
+    /**
+      Accessed as a classname binding to apply the `LinkView`'s `activeClass`
+      CSS `class` to the element when the link is active.
 
-        Ember.assert(fmt("The attempt to link-to route '%@' failed. " +
-                         "The router did not find '%@' in its possible routes: '%@'",
-                         [namedRoute, namedRoute, keys(router.router.recognizer.names).join("', '")]),
-                         router.hasRoute(namedRoute));
+      A `LinkView` is considered active when its `currentWhen` property is `true`
+      or the application's current route is the route the `LinkView` would trigger
+      transitions into.
 
-        if (!paramsAreLoaded(resolvedParams.models)) { return; }
+      The `currentWhen` property can match against multiple routes by separating
+      route names using the ` ` (space) character.
 
-        return resolvedParams;
-      }),
+      @property active
+    **/
+    active: computed.computed('loadedParams', function computeLinkViewActive() {
+      var router = property_get.get(this, 'router');
+      if (!router) { return; }
+      return computeActive(this, router.currentState);
+    }),
 
-      queryParamsObject: null,
+    willBeActive: computed.computed('router.targetState', function() {
+      var router = property_get.get(this, 'router');
+      if (!router) { return; }
+      var targetState = router.targetState;
+      if (router.currentState === targetState) { return; }
 
-      /**
-        Sets the element's `href` attribute to the url for
-        the `LinkView`'s targeted route.
+      return !!computeActive(this, targetState);
+    }),
 
-        If the `LinkView`'s `tagName` is changed to a value other
-        than `a`, this property will be ignored.
+    transitioningIn: computed.computed('active', 'willBeActive', function() {
+      var willBeActive = property_get.get(this, 'willBeActive');
+      if (typeof willBeActive === 'undefined') { return false; }
 
-        @property href
-      **/
-      href: computed('loadedParams', function computeLinkViewHref() {
-        if (get(this, 'tagName') !== 'a') { return; }
+      return !property_get.get(this, 'active') && willBeActive && 'ember-transitioning-in';
+    }),
 
-        var router = get(this, 'router');
-        var loadedParams = get(this, 'loadedParams');
+    transitioningOut: computed.computed('active', 'willBeActive', function() {
+      var willBeActive = property_get.get(this, 'willBeActive');
+      if (typeof willBeActive === 'undefined') { return false; }
 
-        if (!loadedParams) {
-          return get(this, 'loadingHref');
-        }
+      return property_get.get(this, 'active') && !willBeActive && 'ember-transitioning-out';
+    }),
 
-        var visibleQueryParams = {};
-        merge(visibleQueryParams, loadedParams.queryParams);
-        router._prepareQueryParams(loadedParams.targetRouteName, loadedParams.models, visibleQueryParams);
+    /**
+      Accessed as a classname binding to apply the `LinkView`'s `loadingClass`
+      CSS `class` to the element when the link is loading.
 
-        var args = routeArgs(loadedParams.targetRouteName, loadedParams.models, visibleQueryParams);
-        var result = router.generate.apply(router, args);
-        return result;
-      }),
+      A `LinkView` is considered loading when it has at least one
+      parameter whose value is currently null or undefined. During
+      this time, clicking the link will perform no transition and
+      emit a warning that the link is still in a loading state.
 
-      /**
-        The default href value to use while a link-to is loading.
-        Only applies when tagName is 'a'
+      @property loading
+    **/
+    loading: computed.computed('loadedParams', function computeLinkViewLoading() {
+      if (!property_get.get(this, 'loadedParams')) { return property_get.get(this, 'loadingClass'); }
+    }),
 
-        @property loadingHref
-        @type String
-        @default #
-      */
-      loadingHref: '#'
-    });
+    /**
+      Returns the application's main router from the container.
 
-    LinkView.toString = function() { return "LinkView"; };
+      @private
+      @property router
+    **/
+    router: computed.computed(function() {
+      var controller = property_get.get(this, 'controller');
+      if (controller && controller.container) {
+        return controller.container.lookup('router:main');
+      }
+    }),
 
-    
-      LinkView.reopen({
-        attributeBindings: ['target'],
+    /**
+      Event handler that invokes the link, activating the associated route.
 
-        /**
-          Sets the `target` attribute of the `LinkView`'s anchor element.
+      @private
+      @method _invoke
+      @param {Event} event
+    */
+    _invoke: function(event) {
+      if (!utils.isSimpleClick(event)) { return true; }
 
-          @property target
-          @default null
-        **/
-        target: null
-      });
-    
+      if (this.preventDefault !== false) {
+        var targetAttribute = property_get.get(this, 'target');
+        if (!targetAttribute || targetAttribute === '_self') {
+          event.preventDefault();
+        }
+      }
 
-    function getResolvedQueryParams(linkView, targetRouteName) {
-      var queryParamsObject = linkView.queryParamsObject;
-      var resolvedQueryParams = {};
+      if (this.bubbles === false) { event.stopPropagation(); }
 
-      if (!queryParamsObject) { return resolvedQueryParams; }
+      if (property_get.get(this, '_isDisabled')) { return false; }
 
-      var values = queryParamsObject.values;
-      for (var key in values) {
-        if (!values.hasOwnProperty(key)) { continue; }
-        resolvedQueryParams[key] = read(values[key]);
+      if (property_get.get(this, 'loading')) {
+        Ember['default'].Logger.warn("This link-to is in an inactive loading state because at least one of its parameters presently has a null/undefined value, or the provided route name is invalid.");
+        return false;
       }
 
-      return resolvedQueryParams;
-    }
-
-    function paramsAreLoaded(params) {
-      for (var i = 0, len = params.length; i < len; ++i) {
-        var param = params[i];
-        if (param === null || typeof param === 'undefined') {
-          return false;
-        }
+      var targetAttribute2 = property_get.get(this, 'target');
+      if (targetAttribute2 && targetAttribute2 !== '_self') {
+        return false;
       }
-      return true;
-    }
 
-    function shallowEqual(a, b) {
-      var k;
-      for (k in a) {
-        if (a.hasOwnProperty(k) && a[k] !== b[k]) { return false; }
-      }
-      for (k in b) {
-        if (b.hasOwnProperty(k) && a[k] !== b[k]) { return false; }
+      var router = property_get.get(this, 'router');
+      var loadedParams = property_get.get(this, 'loadedParams');
+
+      var transition = router._doTransition(loadedParams.targetRouteName, loadedParams.models, loadedParams.queryParams);
+      if (property_get.get(this, 'replace')) {
+        transition.method('replace');
       }
-      return true;
-    }
 
-    __exports__.LinkView = LinkView;
-  });
-enifed("ember-routing-views/views/outlet",
-  ["ember-views/views/container_view","ember-views/views/metamorph_view","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-routing-views
-    */
 
-    var ContainerView = __dependency1__["default"];
-    var _Metamorph = __dependency2__._Metamorph;
+        return;
 
-    var OutletView = ContainerView.extend(_Metamorph);
-    __exports__.OutletView = OutletView;
-  });
-enifed("ember-routing",
-  ["ember-metal/core","ember-routing/ext/run_loop","ember-routing/ext/controller","ember-routing/ext/view","ember-routing/location/api","ember-routing/location/none_location","ember-routing/location/hash_location","ember-routing/location/history_location","ember-routing/location/auto_location","ember-routing/system/generate_controller","ember-routing/system/controller_for","ember-routing/system/dsl","ember-routing/system/router","ember-routing/system/route","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __exports__) {
-    "use strict";
-    /**
-    Ember Routing
 
-    @module ember
-    @submodule ember-routing
-    @requires ember-views
-    */
+      // Schedule eager URL update, but after we've given the transition
+      // a chance to synchronously redirect.
+      // We need to always generate the URL instead of using the href because
+      // the href will include any rootURL set, but the router expects a URL
+      // without it! Note that we don't use the first level router because it
+      // calls location.formatURL(), which also would add the rootURL!
+      var args = ember_routing__utils.routeArgs(loadedParams.targetRouteName, loadedParams.models, transition.state.queryParams);
+      var url = router.router.generate.apply(router.router, args);
 
-    var Ember = __dependency1__["default"];
+      run['default'].scheduleOnce('routerTransitions', this, this._eagerUpdateUrl, transition, url);
+    },
 
-    // ES6TODO: Cleanup modules with side-effects below
+    /**
+      @private
+      @method _eagerUpdateUrl
+      @param transition
+      @param href
+     */
+    _eagerUpdateUrl: function(transition, href) {
+      if (!transition.isActive || !transition.urlMethod) {
+        // transition was aborted, already ran to completion,
+        // or it has a null url-updated method.
+        return;
+      }
 
-    var EmberLocation = __dependency5__["default"];
-    var NoneLocation = __dependency6__["default"];
-    var HashLocation = __dependency7__["default"];
-    var HistoryLocation = __dependency8__["default"];
-    var AutoLocation = __dependency9__["default"];
+      if (href.indexOf('#') === 0) {
+        href = href.slice(1);
+      }
 
-    var generateControllerFactory = __dependency10__.generateControllerFactory;
-    var generateController = __dependency10__["default"];
-    var controllerFor = __dependency11__["default"];
-    var RouterDSL = __dependency12__["default"];
-    var Router = __dependency13__["default"];
-    var Route = __dependency14__["default"];
+      // Re-use the routerjs hooks set up by the Ember router.
+      var routerjs = property_get.get(this, 'router.router');
+      if (transition.urlMethod === 'update') {
+        routerjs.updateURL(href);
+      } else if (transition.urlMethod === 'replace') {
+        routerjs.replaceURL(href);
+      }
 
-    Ember.Location = EmberLocation;
-    Ember.AutoLocation = AutoLocation;
-    Ember.HashLocation = HashLocation;
-    Ember.HistoryLocation = HistoryLocation;
-    Ember.NoneLocation = NoneLocation;
+      // Prevent later update url refire.
+      transition.method(null);
+    },
 
-    Ember.controllerFor = controllerFor;
-    Ember.generateControllerFactory = generateControllerFactory;
-    Ember.generateController = generateController;
-    Ember.RouterDSL = RouterDSL;
-    Ember.Router = Router;
-    Ember.Route = Route;
+    /**
+      Computed property that returns an array of the
+      resolved parameters passed to the `link-to` helper,
+      e.g.:
 
-    __exports__["default"] = Ember;
-  });
-enifed("ember-routing/ext/controller",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/computed","ember-metal/utils","ember-metal/merge","ember-runtime/mixins/controller","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // FEATURES, deprecate
-    var get = __dependency2__.get;
-    var set = __dependency3__.set;
-    var computed = __dependency4__.computed;
-    var typeOf = __dependency5__.typeOf;
-    var meta = __dependency5__.meta;
-    var merge = __dependency6__["default"];
+      ```hbs
+      {{link-to a b '123' c}}
+      ```
 
-    var ControllerMixin = __dependency7__["default"];
+      will generate a `resolvedParams` of:
 
-    /**
-    @module ember
-    @submodule ember-routing
-    */
+      ```js
+      [aObject, bObject, '123', cObject]
+      ```
 
-    ControllerMixin.reopen({
-      concatenatedProperties: ['queryParams', '_pCacheMeta'],
+      @private
+      @property
+      @return {Array}
+     */
+    resolvedParams: computed.computed('router.url', function() {
+      var params = this.params;
+      var targetRouteName;
+      var models = [];
+      var onlyQueryParamsSupplied = (params.length === 0);
+
+      if (onlyQueryParamsSupplied) {
+        var appController = this.container.lookup('controller:application');
+        targetRouteName = property_get.get(appController, 'currentRouteName');
+      } else {
+        targetRouteName = streams__utils.read(params[0]);
 
-      init: function() {
-        this._super.apply(this, arguments);
-        listenForQueryParamChanges(this);
-      },
+        for (var i = 1; i < params.length; i++) {
+          models.push(streams__utils.read(params[i]));
+        }
+      }
 
-      /**
-        Defines which query parameters the controller accepts.
-        If you give the names ['category','page'] it will bind
-        the values of these query parameters to the variables
-        `this.category` and `this.page`
+      var suppliedQueryParams = getResolvedQueryParams(this, targetRouteName);
 
-        @property queryParams
-        @public
-      */
-      queryParams: null,
+      return {
+        targetRouteName: targetRouteName,
+        models: models,
+        queryParams: suppliedQueryParams
+      };
+    }),
 
-      /**
-        @property _qpDelegate
-        @private
-      */
-      _qpDelegate: null,
+    /**
+      Computed property that returns the current route name,
+      dynamic segments, and query params. Returns falsy if
+      for null/undefined params to indicate that the link view
+      is still in a loading state.
 
-      /**
-        @property _normalizedQueryParams
-        @private
-      */
-      _normalizedQueryParams: computed(function() {
-        var m = meta(this);
-        if (m.proto !== this) {
-          return get(m.proto, '_normalizedQueryParams');
-        }
+      @private
+      @property
+      @return {Array} An array with the route name and any dynamic segments
+    **/
+    loadedParams: computed.computed('resolvedParams', function computeLinkViewRouteArgs() {
+      var router = property_get.get(this, 'router');
+      if (!router) { return; }
 
-        var queryParams = get(this, 'queryParams');
-        if (queryParams._qpMap) {
-          return queryParams._qpMap;
-        }
+      var resolvedParams = property_get.get(this, 'resolvedParams');
+      var namedRoute = resolvedParams.targetRouteName;
 
-        var qpMap = queryParams._qpMap = {};
+      if (!namedRoute) { return; }
 
-        for (var i = 0, len = queryParams.length; i < len; ++i) {
-          accumulateQueryParamDescriptors(queryParams[i], qpMap);
-        }
+      Ember['default'].assert(string.fmt("The attempt to link-to route '%@' failed. " +
+                       "The router did not find '%@' in its possible routes: '%@'",
+                       [namedRoute, namedRoute, keys['default'](router.router.recognizer.names).join("', '")]),
+                       router.hasRoute(namedRoute));
 
-        return qpMap;
-      }),
+      if (!paramsAreLoaded(resolvedParams.models)) { return; }
 
-      /**
-        @property _cacheMeta
-        @private
-      */
-      _cacheMeta: computed(function() {
-        var m = meta(this);
-        if (m.proto !== this) {
-          return get(m.proto, '_cacheMeta');
-        }
+      return resolvedParams;
+    }),
 
-        var cacheMeta = {};
-        var qpMap = get(this, '_normalizedQueryParams');
-        for (var prop in qpMap) {
-          if (!qpMap.hasOwnProperty(prop)) { continue; }
+    queryParamsObject: null,
 
-          var qp = qpMap[prop];
-          var scope = qp.scope;
-          var parts;
+    /**
+      Sets the element's `href` attribute to the url for
+      the `LinkView`'s targeted route.
 
-          if (scope === 'controller') {
-            parts = [];
-          }
+      If the `LinkView`'s `tagName` is changed to a value other
+      than `a`, this property will be ignored.
 
-          cacheMeta[prop] = {
-            parts: parts, // provided by route if 'model' scope
-            values: null, // provided by route
-            scope: scope,
-            prefix: "",
-            def: get(this, prop)
-          };
-        }
+      @property href
+    **/
+    href: computed.computed('loadedParams', function computeLinkViewHref() {
+      if (property_get.get(this, 'tagName') !== 'a') { return; }
 
-        return cacheMeta;
-      }),
+      var router = property_get.get(this, 'router');
+      var loadedParams = property_get.get(this, 'loadedParams');
 
-      /**
-        @method _updateCacheParams
-        @private
-      */
-      _updateCacheParams: function(params) {
-        var cacheMeta = get(this, '_cacheMeta');
-        for (var prop in cacheMeta) {
-          if (!cacheMeta.hasOwnProperty(prop)) { continue; }
-          var propMeta = cacheMeta[prop];
-          propMeta.values = params;
-
-          var cacheKey = this._calculateCacheKey(propMeta.prefix, propMeta.parts, propMeta.values);
-          var cache = this._bucketCache;
-
-          if (cache) {
-            var value = cache.lookup(cacheKey, prop, propMeta.def);
-            set(this, prop, value);
-          }
-        }
-      },
+      if (!loadedParams) {
+        return property_get.get(this, 'loadingHref');
+      }
 
-      /**
-        @method _qpChanged
-        @private
-      */
-      _qpChanged: function(controller, _prop) {
-        var prop = _prop.substr(0, _prop.length-3);
-        var cacheMeta = get(controller, '_cacheMeta');
-        var propCache = cacheMeta[prop];
-        var cacheKey = controller._calculateCacheKey(propCache.prefix || "", propCache.parts, propCache.values);
-        var value = get(controller, prop);
-
-        // 1. Update model-dep cache
-        var cache = this._bucketCache;
-        if (cache) {
-          controller._bucketCache.stash(cacheKey, prop, value);
-        }
+      var visibleQueryParams = {};
+      merge['default'](visibleQueryParams, loadedParams.queryParams);
+      router._prepareQueryParams(loadedParams.targetRouteName, loadedParams.models, visibleQueryParams);
 
-        // 2. Notify a delegate (e.g. to fire a qp transition)
-        var delegate = controller._qpDelegate;
-        if (delegate) {
-          delegate(controller, prop);
-        }
-      },
+      var args = ember_routing__utils.routeArgs(loadedParams.targetRouteName, loadedParams.models, visibleQueryParams);
+      var result = router.generate.apply(router, args);
+      return result;
+    }),
 
-      /**
-        @method _calculateCacheKey
-        @private
-      */
-      _calculateCacheKey: function(prefix, _parts, values) {
-        var parts = _parts || [], suffixes = "";
-        for (var i = 0, len = parts.length; i < len; ++i) {
-          var part = parts[i];
-          var value = get(values, part);
-          suffixes += "::" + part + ":" + value;
-        }
-        return prefix + suffixes.replace(ALL_PERIODS_REGEX, '-');
-      },
+    /**
+      The default href value to use while a link-to is loading.
+      Only applies when tagName is 'a'
 
-      /**
-        Transition the application into another route. The route may
-        be either a single route or route path:
+      @property loadingHref
+      @type String
+      @default #
+    */
+    loadingHref: '#'
+  });
 
-        ```javascript
-        aController.transitionToRoute('blogPosts');
-        aController.transitionToRoute('blogPosts.recentEntries');
-        ```
+  LinkView.toString = function() { return "LinkView"; };
 
-        Optionally supply a model for the route in question. The model
-        will be serialized into the URL using the `serialize` hook of
-        the route:
+  function getResolvedQueryParams(linkView, targetRouteName) {
+    var queryParamsObject = linkView.queryParamsObject;
+    var resolvedQueryParams = {};
 
-        ```javascript
-        aController.transitionToRoute('blogPost', aPost);
-        ```
+    if (!queryParamsObject) { return resolvedQueryParams; }
 
-        If a literal is passed (such as a number or a string), it will
-        be treated as an identifier instead. In this case, the `model`
-        hook of the route will be triggered:
+    var values = queryParamsObject.values;
+    for (var key in values) {
+      if (!values.hasOwnProperty(key)) { continue; }
+      resolvedQueryParams[key] = streams__utils.read(values[key]);
+    }
 
-        ```javascript
-        aController.transitionToRoute('blogPost', 1);
-        ```
+    return resolvedQueryParams;
+  }
 
-        Multiple models will be applied last to first recursively up the
-        resource tree.
+  function paramsAreLoaded(params) {
+    for (var i = 0, len = params.length; i < len; ++i) {
+      var param = params[i];
+      if (param === null || typeof param === 'undefined') {
+        return false;
+      }
+    }
+    return true;
+  }
 
-        ```javascript
-        App.Router.map(function() {
-          this.resource('blogPost', {path:':blogPostId'}, function(){
-            this.resource('blogComment', {path: ':blogCommentId'});
-          });
-        });
+  function computeActive(route, routerState) {
+    if (property_get.get(route, 'loading')) { return false; }
 
-        aController.transitionToRoute('blogComment', aPost, aComment);
-        aController.transitionToRoute('blogComment', 1, 13);
-        ```
+    var currentWhen = route['current-when'] || route.currentWhen;
+    var isCurrentWhenSpecified = !!currentWhen;
+    currentWhen = currentWhen || property_get.get(route, 'loadedParams').targetRouteName;
+    currentWhen = currentWhen.split(' ');
+    for (var i = 0, len = currentWhen.length; i < len; i++) {
+      if (isActiveForRoute(route, currentWhen[i], isCurrentWhenSpecified, routerState)) {
+        return property_get.get(route, 'activeClass');
+      }
+    }
 
-        It is also possible to pass a URL (a string that starts with a
-        `/`). This is intended for testing and debugging purposes and
-        should rarely be used in production code.
+    return false;
+  }
 
-        ```javascript
-        aController.transitionToRoute('/');
-        aController.transitionToRoute('/blog/post/1/comment/13');
-        aController.transitionToRoute('/blog/posts?sort=title');
-        ```
+  function isActiveForRoute(route, routeName, isCurrentWhenSpecified, routerState) {
+    var router = property_get.get(route, 'router');
+    var loadedParams = property_get.get(route, 'loadedParams');
+    var contexts = loadedParams.models;
 
-        An options hash with a `queryParams` property may be provided as
-        the final argument to add query parameters to the destination URL.
+    var handlers = router.router.recognizer.handlersFor(routeName);
+    var leafName = handlers[handlers.length-1].handler;
+    var maximumContexts = numberOfContextsAcceptedByHandler(routeName, handlers);
 
-        ```javascript
-        aController.transitionToRoute('blogPost', 1, {
-          queryParams: {showComments: 'true'}
-        });
+    // NOTE: any ugliness in the calculation of activeness is largely
+    // due to the fact that we support automatic normalizing of
+    // `resource` -> `resource.index`, even though there might be
+    // dynamic segments / query params defined on `resource.index`
+    // which complicates (and makes somewhat ambiguous) the calculation
+    // of activeness for links that link to `resource` instead of
+    // directly to `resource.index`.
 
-        // if you just want to transition the query parameters without changing the route
-        aController.transitionToRoute({queryParams: {sort: 'date'}});
-        ```
+    // if we don't have enough contexts revert back to full route name
+    // this is because the leaf route will use one of the contexts
+    if (contexts.length > maximumContexts) {
+      routeName = leafName;
+    }
 
-        See also [replaceRoute](/api/classes/Ember.ControllerMixin.html#method_replaceRoute).
+    return routerState.isActiveIntent(routeName, contexts, loadedParams.queryParams, !isCurrentWhenSpecified);
+  }
 
-        @param {String} name the name of the route or a URL
-        @param {...Object} models the model(s) or identifier(s) to be used
-          while transitioning to the route.
-        @param {Object} [options] optional hash with a queryParams property
-          containing a mapping of query parameters
-        @for Ember.ControllerMixin
-        @method transitionToRoute
-      */
-      transitionToRoute: function() {
-        // target may be either another controller or a router
-        var target = get(this, 'target');
-        var method = target.transitionToRoute || target.transitionTo;
-        return method.apply(target, arguments);
-      },
+  exports.LinkView = LinkView;
 
-      /**
-        @deprecated
-        @for Ember.ControllerMixin
-        @method transitionTo
-      */
-      transitionTo: function() {
-        Ember.deprecate("transitionTo is deprecated. Please use transitionToRoute.");
-        return this.transitionToRoute.apply(this, arguments);
-      },
+});
+enifed('ember-routing-views/views/outlet', ['exports', 'ember-views/views/container_view', 'ember-views/views/metamorph_view', 'ember-metal/property_get'], function (exports, ContainerView, metamorph_view, property_get) {
 
-      /**
-        Transition into another route while replacing the current URL, if possible.
-        This will replace the current history entry instead of adding a new one.
-        Beside that, it is identical to `transitionToRoute` in all other respects.
+  'use strict';
 
-        ```javascript
-        aController.replaceRoute('blogPosts');
-        aController.replaceRoute('blogPosts.recentEntries');
-        ```
+  /**
+  @module ember
+  @submodule ember-routing-views
+  */
 
-        Optionally supply a model for the route in question. The model
-        will be serialized into the URL using the `serialize` hook of
-        the route:
+  var CoreOutletView = ContainerView['default'].extend({
+    init: function() {
+      this._super();
+      this._childOutlets = Ember.A();
+      this._outletState = null;
+    },
 
-        ```javascript
-        aController.replaceRoute('blogPost', aPost);
-        ```
+    _isOutlet: true,
 
-        If a literal is passed (such as a number or a string), it will
-        be treated as an identifier instead. In this case, the `model`
-        hook of the route will be triggered:
+    _parentOutlet: function() {
+      var parent = this._parentView;
+      while (parent && !parent._isOutlet) {
+        parent = parent._parentView;
+      }
+      return parent;
+    },
 
-        ```javascript
-        aController.replaceRoute('blogPost', 1);
-        ```
+    _linkParent: Ember.on('init', 'parentViewDidChange', function() {
+      var parent = this._parentOutlet();
+      if (parent) {
+        parent._childOutlets.push(this);
+        if (parent._outletState) {
+          this.setOutletState(parent._outletState.outlets[this._outletName]);
+        }
+      }
+    }),
 
-        Multiple models will be applied last to first recursively up the
-        resource tree.
+    willDestroy: function() {
+      var parent = this._parentOutlet();
+      if (parent) {
+        parent._childOutlets.removeObject(this);
+      }
+      this._super();
+    },
 
-        ```javascript
-        App.Router.map(function() {
-          this.resource('blogPost', {path:':blogPostId'}, function(){
-            this.resource('blogComment', {path: ':blogCommentId'});
-          });
-        });
 
-        aController.replaceRoute('blogComment', aPost, aComment);
-        aController.replaceRoute('blogComment', 1, 13);
-        ```
+    _diffState: function(state) {
+      while (state && emptyRouteState(state)) {
+        state = state.outlets.main;
+      }
+      var different = !sameRouteState(this._outletState, state);
+      this._outletState = state;
+      return different;
+    },
 
-        It is also possible to pass a URL (a string that starts with a
-        `/`). This is intended for testing and debugging purposes and
-        should rarely be used in production code.
+    setOutletState: function(state) {
+      if (!this._diffState(state)) {
+        var children = this._childOutlets;
+        for (var i = 0 ; i < children.length; i++) {
+          var child = children[i];
+          child.setOutletState(this._outletState && this._outletState.outlets[child._outletName]);
+        }
+      } else {
+        var view = this._buildView(this._outletState);
+        var length = property_get.get(this, 'length');
+        if (view) {
+          this.replace(0, length, [view]);
+        } else {
+          this.replace(0, length , []);
+        }
+      }
+    },
 
-        ```javascript
-        aController.replaceRoute('/');
-        aController.replaceRoute('/blog/post/1/comment/13');
-        ```
+    _buildView: function(state) {
+      if (!state) { return; }
 
-        @param {String} name the name of the route or a URL
-        @param {...Object} models the model(s) or identifier(s) to be used
-        while transitioning to the route.
-        @for Ember.ControllerMixin
-        @method replaceRoute
-      */
-      replaceRoute: function() {
-        // target may be either another controller or a router
-        var target = get(this, 'target');
-        var method = target.replaceRoute || target.replaceWith;
-        return method.apply(target, arguments);
-      },
+      var LOG_VIEW_LOOKUPS = property_get.get(this, 'namespace.LOG_VIEW_LOOKUPS');
+      var view;
+      var render = state.render;
+      var ViewClass = render.ViewClass;
+      var isDefaultView = false;
 
-      /**
-        @deprecated
-        @for Ember.ControllerMixin
-        @method replaceWith
-      */
-      replaceWith: function() {
-        Ember.deprecate("replaceWith is deprecated. Please use replaceRoute.");
-        return this.replaceRoute.apply(this, arguments);
+      if (!ViewClass) {
+        isDefaultView = true;
+        ViewClass = this.container.lookupFactory(this._isTopLevel ? 'view:toplevel' : 'view:default');
       }
-    });
 
-    var ALL_PERIODS_REGEX = /\./g;
+      view = ViewClass.create({
+        _debugTemplateName: render.name,
+        renderedName: render.name,
+        controller: render.controller
+      });
 
-    function accumulateQueryParamDescriptors(_desc, accum) {
-      var desc = _desc;
-      var tmp;
-      if (typeOf(desc) === 'string') {
-        tmp = {};
-        tmp[desc] = { as: null };
-        desc = tmp;
+      if (!property_get.get(view, 'template')) {
+        view.set('template', render.template);
       }
 
-      for (var key in desc) {
-        if (!desc.hasOwnProperty(key)) { return; }
+      if (LOG_VIEW_LOOKUPS) {
+        Ember.Logger.info("Rendering " + render.name + " with " + (render.isDefaultView ? "default view " : "") + view, { fullName: 'view:' + render.name });
+      }
 
-        var singleDesc = desc[key];
-        if (typeOf(singleDesc) === 'string') {
-          singleDesc = { as: singleDesc };
-        }
+      return view;
+    }
+  });
 
-        tmp = accum[key] || { as: null, scope: 'model' };
-        merge(tmp, singleDesc);
+  function emptyRouteState(state) {
+    return !state.render.ViewClass && !state.render.template;
+  }
 
-        accum[key] = tmp;
-      }
+  function sameRouteState(a, b) {
+    if (!a && !b) {
+      return true;
     }
-
-    function listenForQueryParamChanges(controller) {
-      var qpMap = get(controller, '_normalizedQueryParams');
-      for (var prop in qpMap) {
-        if (!qpMap.hasOwnProperty(prop)) { continue; }
-        controller.addObserver(prop + '.[]', controller, controller._qpChanged);
+    if (!a || !b) {
+      return false;
+    }
+    a = a.render;
+    b = b.render;
+    for (var key in a) {
+      if (a.hasOwnProperty(key)) {
+        // name is only here for logging & debugging. If two different
+        // names result in otherwise identical states, they're still
+        // identical.
+        if (a[key] !== b[key] && key !== 'name') {
+          return false;
+        }
       }
     }
+    return true;
+  }
 
+  var OutletView = CoreOutletView.extend(metamorph_view._Metamorph);
 
-    __exports__["default"] = ControllerMixin;
-  });
-enifed("ember-routing/ext/run_loop",
-  ["ember-metal/run_loop"],
-  function(__dependency1__) {
-    "use strict";
-    var run = __dependency1__["default"];
+  exports.CoreOutletView = CoreOutletView;
+  exports.OutletView = OutletView;
 
-    /**
-    @module ember
-    @submodule ember-views
-    */
+});
+enifed('ember-routing', ['exports', 'ember-metal/core', 'ember-routing/ext/run_loop', 'ember-routing/ext/controller', 'ember-routing/location/api', 'ember-routing/location/none_location', 'ember-routing/location/hash_location', 'ember-routing/location/history_location', 'ember-routing/location/auto_location', 'ember-routing/system/generate_controller', 'ember-routing/system/controller_for', 'ember-routing/system/dsl', 'ember-routing/system/router', 'ember-routing/system/route'], function (exports, Ember, __dep1__, __dep2__, EmberLocation, NoneLocation, HashLocation, HistoryLocation, AutoLocation, generate_controller, controllerFor, RouterDSL, Router, Route) {
 
-    // Add a new named queue after the 'actions' queue (where RSVP promises
-    // resolve), which is used in router transitions to prevent unnecessary
-    // loading state entry if all context promises resolve on the
-    // 'actions' queue first.
-    run._addQueue('routerTransitions', 'actions');
-  });
-enifed("ember-routing/ext/view",
-  ["ember-metal/property_get","ember-metal/property_set","ember-metal/run_loop","ember-views/views/view","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    var get = __dependency1__.get;
-    var set = __dependency2__.set;
-    var run = __dependency3__["default"];
-    var EmberView = __dependency4__["default"];
+  'use strict';
 
-    /**
-    @module ember
-    @submodule ember-routing
-    */
+  /**
+  Ember Routing
 
-    EmberView.reopen({
+  @module ember
+  @submodule ember-routing
+  @requires ember-views
+  */
 
-      /**
-        Sets the private `_outlets` object on the view.
+  Ember['default'].Location = EmberLocation['default'];
+  Ember['default'].AutoLocation = AutoLocation['default'];
+  Ember['default'].HashLocation = HashLocation['default'];
+  Ember['default'].HistoryLocation = HistoryLocation['default'];
+  Ember['default'].NoneLocation = NoneLocation['default'];
 
-        @method init
-       */
-      init: function() {
-        this._outlets = {};
-        this._super();
-      },
+  Ember['default'].controllerFor = controllerFor['default'];
+  Ember['default'].generateControllerFactory = generate_controller.generateControllerFactory;
+  Ember['default'].generateController = generate_controller["default"];
+  Ember['default'].RouterDSL = RouterDSL['default'];
+  Ember['default'].Router = Router['default'];
+  Ember['default'].Route = Route['default'];
 
-      /**
-        Manually fill any of a view's `{{outlet}}` areas with the
-        supplied view.
+  exports['default'] = Ember['default'];
 
-        Example
+});
+enifed('ember-routing/ext/controller', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/computed', 'ember-metal/utils', 'ember-metal/merge', 'ember-runtime/mixins/controller'], function (exports, Ember, property_get, property_set, computed, utils, merge, ControllerMixin) {
 
-        ```javascript
-        var MyView = Ember.View.extend({
-          template: Ember.Handlebars.compile('Child view: {{outlet "main"}} ')
-        });
-        var myView = MyView.create();
-        myView.appendTo('body');
-        // The html for myView now looks like:
-        // <div id="ember228" class="ember-view">Child view: </div>
+  'use strict';
 
-        var FooView = Ember.View.extend({
-          template: Ember.Handlebars.compile('<h1>Foo</h1> ')
-        });
-        var fooView = FooView.create();
-        myView.connectOutlet('main', fooView);
-        // The html for myView now looks like:
-        // <div id="ember228" class="ember-view">Child view:
-        //   <div id="ember234" class="ember-view"><h1>Foo</h1> </div>
-        // </div>
-        ```
-        @method connectOutlet
-        @param  {String} outletName A unique name for the outlet
-        @param  {Object} view       An Ember.View
-       */
-      connectOutlet: function(outletName, view) {
-        if (this._pendingDisconnections) {
-          delete this._pendingDisconnections[outletName];
-        }
+  ControllerMixin['default'].reopen({
+    concatenatedProperties: ['queryParams', '_pCacheMeta'],
 
-        if (this._hasEquivalentView(outletName, view)) {
-          view.destroy();
-          return;
-        }
+    init: function() {
+      this._super.apply(this, arguments);
+      listenForQueryParamChanges(this);
+    },
 
-        var outlets = get(this, '_outlets');
-        var container = get(this, 'container');
-        var router = container && container.lookup('router:main');
-        var renderedName = get(view, 'renderedName');
+    /**
+      Defines which query parameters the controller accepts.
+      If you give the names ['category','page'] it will bind
+      the values of these query parameters to the variables
+      `this.category` and `this.page`
 
-        set(outlets, outletName, view);
+      @property queryParams
+      @public
+    */
+    queryParams: null,
 
-        if (router && renderedName) {
-          router._connectActiveView(renderedName, view);
-        }
-      },
+    /**
+      @property _qpDelegate
+      @private
+    */
+    _qpDelegate: null,
 
-      /**
-        Determines if the view has already been created by checking if
-        the view has the same constructor, template, and context as the
-        view in the `_outlets` object.
+    /**
+      @property _normalizedQueryParams
+      @private
+    */
+    _normalizedQueryParams: computed.computed(function() {
+      var m = utils.meta(this);
+      if (m.proto !== this) {
+        return property_get.get(m.proto, '_normalizedQueryParams');
+      }
 
-        @private
-        @method _hasEquivalentView
-        @param  {String} outletName The name of the outlet we are checking
-        @param  {Object} view       An Ember.View
-        @return {Boolean}
-       */
-      _hasEquivalentView: function(outletName, view) {
-        var existingView = get(this, '_outlets.'+outletName);
-        return existingView &&
-          existingView.constructor === view.constructor &&
-          existingView.get('template') === view.get('template') &&
-          existingView.get('context') === view.get('context');
-      },
+      var queryParams = property_get.get(this, 'queryParams');
+      if (queryParams._qpMap) {
+        return queryParams._qpMap;
+      }
 
-      /**
-        Removes an outlet from the view.
+      var qpMap = queryParams._qpMap = {};
 
-        Example
+      for (var i = 0, len = queryParams.length; i < len; ++i) {
+        accumulateQueryParamDescriptors(queryParams[i], qpMap);
+      }
 
-        ```javascript
-        var MyView = Ember.View.extend({
-          template: Ember.Handlebars.compile('Child view: {{outlet "main"}} ')
-        });
-        var myView = MyView.create();
-        myView.appendTo('body');
-        // myView's html:
-        // <div id="ember228" class="ember-view">Child view: </div>
+      return qpMap;
+    }),
 
-        var FooView = Ember.View.extend({
-          template: Ember.Handlebars.compile('<h1>Foo</h1> ')
-        });
-        var fooView = FooView.create();
-        myView.connectOutlet('main', fooView);
-        // myView's html:
-        // <div id="ember228" class="ember-view">Child view:
-        //   <div id="ember234" class="ember-view"><h1>Foo</h1> </div>
-        // </div>
-
-        myView.disconnectOutlet('main');
-        // myView's html:
-        // <div id="ember228" class="ember-view">Child view: </div>
-        ```
+    /**
+      @property _cacheMeta
+      @private
+    */
+    _cacheMeta: computed.computed(function() {
+      var m = utils.meta(this);
+      if (m.proto !== this) {
+        return property_get.get(m.proto, '_cacheMeta');
+      }
 
-        @method disconnectOutlet
-        @param  {String} outletName The name of the outlet to be removed
-       */
-      disconnectOutlet: function(outletName) {
-        if (!this._pendingDisconnections) {
-          this._pendingDisconnections = {};
+      var cacheMeta = {};
+      var qpMap = property_get.get(this, '_normalizedQueryParams');
+      for (var prop in qpMap) {
+        if (!qpMap.hasOwnProperty(prop)) { continue; }
+
+        var qp = qpMap[prop];
+        var scope = qp.scope;
+        var parts;
+
+        if (scope === 'controller') {
+          parts = [];
         }
-        this._pendingDisconnections[outletName] = true;
-        run.once(this, '_finishDisconnections');
-      },
 
-      /**
-        Gets an outlet that is pending disconnection and then
-        nullifys the object on the `_outlet` object.
+        cacheMeta[prop] = {
+          parts: parts, // provided by route if 'model' scope
+          values: null, // provided by route
+          scope: scope,
+          prefix: "",
+          def: property_get.get(this, prop)
+        };
+      }
 
-        @private
-        @method _finishDisconnections
-       */
-      _finishDisconnections: function() {
-        if (this.isDestroyed) return; // _outlets will be gone anyway
-        var outlets = get(this, '_outlets');
-        var pendingDisconnections = this._pendingDisconnections;
-        this._pendingDisconnections = null;
+      return cacheMeta;
+    }),
 
-        for (var outletName in pendingDisconnections) {
-          set(outlets, outletName, null);
+    /**
+      @method _updateCacheParams
+      @private
+    */
+    _updateCacheParams: function(params) {
+      var cacheMeta = property_get.get(this, '_cacheMeta');
+      for (var prop in cacheMeta) {
+        if (!cacheMeta.hasOwnProperty(prop)) { continue; }
+        var propMeta = cacheMeta[prop];
+        propMeta.values = params;
+
+        var cacheKey = this._calculateCacheKey(propMeta.prefix, propMeta.parts, propMeta.values);
+        var cache = this._bucketCache;
+
+        if (cache) {
+          var value = cache.lookup(cacheKey, prop, propMeta.def);
+          property_set.set(this, prop, value);
         }
       }
-    });
+    },
 
-    __exports__["default"] = EmberView;
-  });
-enifed("ember-routing/location/api",
-  ["ember-metal/core","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // deprecate, assert
+    /**
+      @method _qpChanged
+      @private
+    */
+    _qpChanged: function(controller, _prop) {
+      var prop = _prop.substr(0, _prop.length-3);
+      var cacheMeta = property_get.get(controller, '_cacheMeta');
+      var propCache = cacheMeta[prop];
+      var cacheKey = controller._calculateCacheKey(propCache.prefix || "", propCache.parts, propCache.values);
+      var value = property_get.get(controller, prop);
+
+      // 1. Update model-dep cache
+      var cache = this._bucketCache;
+      if (cache) {
+        controller._bucketCache.stash(cacheKey, prop, value);
+      }
+
+      // 2. Notify a delegate (e.g. to fire a qp transition)
+      var delegate = controller._qpDelegate;
+      if (delegate) {
+        delegate(controller, prop);
+      }
+    },
 
     /**
-    @module ember
-    @submodule ember-routing
+      @method _calculateCacheKey
+      @private
     */
+    _calculateCacheKey: function(prefix, _parts, values) {
+      var parts = _parts || [];
+      var suffixes = "";
+      for (var i = 0, len = parts.length; i < len; ++i) {
+        var part = parts[i];
+        var value = property_get.get(values, part);
+        suffixes += "::" + part + ":" + value;
+      }
+      return prefix + suffixes.replace(ALL_PERIODS_REGEX, '-');
+    },
 
     /**
-      Ember.Location returns an instance of the correct implementation of
-      the `location` API.
+      Transition the application into another route. The route may
+      be either a single route or route path:
+
+      ```javascript
+      aController.transitionToRoute('blogPosts');
+      aController.transitionToRoute('blogPosts.recentEntries');
+      ```
 
-      ## Implementations
+      Optionally supply a model for the route in question. The model
+      will be serialized into the URL using the `serialize` hook of
+      the route:
 
-      You can pass an implementation name (`hash`, `history`, `none`) to force a
-      particular implementation to be used in your application.
+      ```javascript
+      aController.transitionToRoute('blogPost', aPost);
+      ```
 
-      ### HashLocation
+      If a literal is passed (such as a number or a string), it will
+      be treated as an identifier instead. In this case, the `model`
+      hook of the route will be triggered:
 
-      Using `HashLocation` results in URLs with a `#` (hash sign) separating the
-      server side URL portion of the URL from the portion that is used by Ember.
-      This relies upon the `hashchange` event existing in the browser.
+      ```javascript
+      aController.transitionToRoute('blogPost', 1);
+      ```
 
-      Example:
+      Multiple models will be applied last to first recursively up the
+      resource tree.
 
       ```javascript
       App.Router.map(function() {
-        this.resource('posts', function() {
-          this.route('new');
+        this.resource('blogPost', {path:':blogPostId'}, function() {
+          this.resource('blogComment', {path: ':blogCommentId'});
         });
       });
 
-      App.Router.reopen({
-        location: 'hash'
+      aController.transitionToRoute('blogComment', aPost, aComment);
+      aController.transitionToRoute('blogComment', 1, 13);
+      ```
+
+      It is also possible to pass a URL (a string that starts with a
+      `/`). This is intended for testing and debugging purposes and
+      should rarely be used in production code.
+
+      ```javascript
+      aController.transitionToRoute('/');
+      aController.transitionToRoute('/blog/post/1/comment/13');
+      aController.transitionToRoute('/blog/posts?sort=title');
+      ```
+
+      An options hash with a `queryParams` property may be provided as
+      the final argument to add query parameters to the destination URL.
+
+      ```javascript
+      aController.transitionToRoute('blogPost', 1, {
+        queryParams: {showComments: 'true'}
       });
+
+      // if you just want to transition the query parameters without changing the route
+      aController.transitionToRoute({queryParams: {sort: 'date'}});
       ```
 
-      This will result in a posts.new url of `/#/posts/new`.
+      See also [replaceRoute](/api/classes/Ember.ControllerMixin.html#method_replaceRoute).
 
-      ### HistoryLocation
+      @param {String} name the name of the route or a URL
+      @param {...Object} models the model(s) or identifier(s) to be used
+        while transitioning to the route.
+      @param {Object} [options] optional hash with a queryParams property
+        containing a mapping of query parameters
+      @for Ember.ControllerMixin
+      @method transitionToRoute
+    */
+    transitionToRoute: function() {
+      // target may be either another controller or a router
+      var target = property_get.get(this, 'target');
+      var method = target.transitionToRoute || target.transitionTo;
+      return method.apply(target, arguments);
+    },
 
-      Using `HistoryLocation` results in URLs that are indistinguishable from a
-      standard URL. This relies upon the browser's `history` API.
+    /**
+      @deprecated
+      @for Ember.ControllerMixin
+      @method transitionTo
+    */
+    transitionTo: function() {
+      Ember['default'].deprecate("transitionTo is deprecated. Please use transitionToRoute.");
+      return this.transitionToRoute.apply(this, arguments);
+    },
 
-      Example:
+    /**
+      Transition into another route while replacing the current URL, if possible.
+      This will replace the current history entry instead of adding a new one.
+      Beside that, it is identical to `transitionToRoute` in all other respects.
 
       ```javascript
-      App.Router.map(function() {
-        this.resource('posts', function() {
-          this.route('new');
-        });
-      });
-
-      App.Router.reopen({
-        location: 'history'
-      });
+      aController.replaceRoute('blogPosts');
+      aController.replaceRoute('blogPosts.recentEntries');
       ```
 
-      This will result in a posts.new url of `/posts/new`.
-
-      Keep in mind that your server must serve the Ember app at all the routes you
-      define.
+      Optionally supply a model for the route in question. The model
+      will be serialized into the URL using the `serialize` hook of
+      the route:
 
-      ### AutoLocation
+      ```javascript
+      aController.replaceRoute('blogPost', aPost);
+      ```
 
-      Using `AutoLocation`, the router will use the best Location class supported by
-      the browser it is running in.
+      If a literal is passed (such as a number or a string), it will
+      be treated as an identifier instead. In this case, the `model`
+      hook of the route will be triggered:
 
-      Browsers that support the `history` API will use `HistoryLocation`, those that
-      do not, but still support the `hashchange` event will use `HashLocation`, and
-      in the rare case neither is supported will use `NoneLocation`.
+      ```javascript
+      aController.replaceRoute('blogPost', 1);
+      ```
 
-      Example:
+      Multiple models will be applied last to first recursively up the
+      resource tree.
 
       ```javascript
       App.Router.map(function() {
-        this.resource('posts', function() {
-          this.route('new');
+        this.resource('blogPost', {path:':blogPostId'}, function() {
+          this.resource('blogComment', {path: ':blogCommentId'});
         });
       });
 
-      App.Router.reopen({
-        location: 'auto'
-      });
+      aController.replaceRoute('blogComment', aPost, aComment);
+      aController.replaceRoute('blogComment', 1, 13);
       ```
 
-      This will result in a posts.new url of `/posts/new` for modern browsers that
-      support the `history` api or `/#/posts/new` for older ones, like Internet
-      Explorer 9 and below.
-
-      When a user visits a link to your application, they will be automatically
-      upgraded or downgraded to the appropriate `Location` class, with the URL
-      transformed accordingly, if needed.
-
-      Keep in mind that since some of your users will use `HistoryLocation`, your
-      server must serve the Ember app at all the routes you define.
-
-      ### NoneLocation
+      It is also possible to pass a URL (a string that starts with a
+      `/`). This is intended for testing and debugging purposes and
+      should rarely be used in production code.
 
-      Using `NoneLocation` causes Ember to not store the applications URL state
-      in the actual URL. This is generally used for testing purposes, and is one
-      of the changes made when calling `App.setupForTesting()`.
-
-      ## Location API
-
-      Each location implementation must provide the following methods:
-
-      * implementation: returns the string name used to reference the implementation.
-      * getURL: returns the current URL.
-      * setURL(path): sets the current URL.
-      * replaceURL(path): replace the current URL (optional).
-      * onUpdateURL(callback): triggers the callback when the URL changes.
-      * formatURL(url): formats `url` to be placed into `href` attribute.
-
-      Calling setURL or replaceURL will not trigger onUpdateURL callbacks.
+      ```javascript
+      aController.replaceRoute('/');
+      aController.replaceRoute('/blog/post/1/comment/13');
+      ```
 
-      @class Location
-      @namespace Ember
-      @static
+      @param {String} name the name of the route or a URL
+      @param {...Object} models the model(s) or identifier(s) to be used
+      while transitioning to the route.
+      @for Ember.ControllerMixin
+      @method replaceRoute
     */
-    __exports__["default"] = {
-      /**
-       This is deprecated in favor of using the container to lookup the location
-       implementation as desired.
-
-       For example:
-
-       ```javascript
-       // Given a location registered as follows:
-       container.register('location:history-test', HistoryTestLocation);
+    replaceRoute: function() {
+      // target may be either another controller or a router
+      var target = property_get.get(this, 'target');
+      var method = target.replaceRoute || target.replaceWith;
+      return method.apply(target, arguments);
+    },
 
-       // You could create a new instance via:
-       container.lookup('location:history-test');
-       ```
+    /**
+      @deprecated
+      @for Ember.ControllerMixin
+      @method replaceWith
+    */
+    replaceWith: function() {
+      Ember['default'].deprecate("replaceWith is deprecated. Please use replaceRoute.");
+      return this.replaceRoute.apply(this, arguments);
+    }
+  });
 
-        @method create
-        @param {Object} options
-        @return {Object} an instance of an implementation of the `location` API
-        @deprecated Use the container to lookup the location implementation that you
-        need.
-      */
-      create: function(options) {
-        var implementation = options && options.implementation;
-        Ember.assert("Ember.Location.create: you must specify a 'implementation' option", !!implementation);
+  var ALL_PERIODS_REGEX = /\./g;
 
-        var implementationClass = this.implementations[implementation];
-        Ember.assert("Ember.Location.create: " + implementation + " is not a valid implementation", !!implementationClass);
+  function accumulateQueryParamDescriptors(_desc, accum) {
+    var desc = _desc;
+    var tmp;
+    if (utils.typeOf(desc) === 'string') {
+      tmp = {};
+      tmp[desc] = { as: null };
+      desc = tmp;
+    }
 
-        return implementationClass.create.apply(implementationClass, arguments);
-      },
+    for (var key in desc) {
+      if (!desc.hasOwnProperty(key)) { return; }
 
-      /**
-       This is deprecated in favor of using the container to register the
-       location implementation as desired.
+      var singleDesc = desc[key];
+      if (utils.typeOf(singleDesc) === 'string') {
+        singleDesc = { as: singleDesc };
+      }
 
-       Example:
+      tmp = accum[key] || { as: null, scope: 'model' };
+      merge['default'](tmp, singleDesc);
 
-       ```javascript
-       Application.initializer({
-        name: "history-test-location",
+      accum[key] = tmp;
+    }
+  }
 
-        initialize: function(container, application) {
-          application.register('location:history-test', HistoryTestLocation);
-        }
-       });
-       ```
+  function listenForQueryParamChanges(controller) {
+    var qpMap = property_get.get(controller, '_normalizedQueryParams');
+    for (var prop in qpMap) {
+      if (!qpMap.hasOwnProperty(prop)) { continue; }
+      controller.addObserver(prop + '.[]', controller, controller._qpChanged);
+    }
+  }
 
-       @method registerImplementation
-       @param {String} name
-       @param {Object} implementation of the `location` API
-       @deprecated Register your custom location implementation with the
-       container directly.
-      */
-      registerImplementation: function(name, implementation) {
-        Ember.deprecate('Using the Ember.Location.registerImplementation is no longer supported.' +
-                        ' Register your custom location implementation with the container instead.', false);
 
-        this.implementations[name] = implementation;
-      },
+  exports['default'] = ControllerMixin['default'];
 
-      implementations: {},
-      _location: window.location,
+});
+enifed('ember-routing/ext/run_loop', ['ember-metal/run_loop'], function (run) {
 
-      /**
-        Returns the current `location.hash` by parsing location.href since browsers
-        inconsistently URL-decode `location.hash`.
+	'use strict';
 
-        https://bugzilla.mozilla.org/show_bug.cgi?id=483304
+	run['default']._addQueue('routerTransitions', 'actions');
 
-        @private
-        @method getHash
-        @since 1.4.0
-      */
-      _getHash: function () {
-        // AutoLocation has it at _location, HashLocation at .location.
-        // Being nice and not changing
-        var href = (this._location || this.location).href;
-        var hashIndex = href.indexOf('#');
-
-        if (hashIndex === -1) {
-          return '';
-        } else {
-          return href.substr(hashIndex);
-        }
-      }
-    };
-  });
-enifed("ember-routing/location/auto_location",
-  ["ember-metal/core","ember-metal/property_set","ember-routing/location/api","ember-routing/location/history_location","ember-routing/location/hash_location","ember-routing/location/none_location","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // FEATURES
-    var set = __dependency2__.set;
+});
+enifed('ember-routing/location/api', ['exports', 'ember-metal/core', 'ember-metal/environment'], function (exports, Ember, environment) {
 
-    var EmberLocation = __dependency3__["default"];
-    var HistoryLocation = __dependency4__["default"];
-    var HashLocation = __dependency5__["default"];
-    var NoneLocation = __dependency6__["default"];
+  'use strict';
 
+  exports['default'] = {
     /**
-    @module ember
-    @submodule ember-routing
-    */
+     This is deprecated in favor of using the container to lookup the location
+     implementation as desired.
 
-    /**
-      Ember.AutoLocation will select the best location option based off browser
-      support with the priority order: history, hash, none.
+     For example:
 
-      Clean pushState paths accessed by hashchange-only browsers will be redirected
-      to the hash-equivalent and vice versa so future transitions are consistent.
+     ```javascript
+     // Given a location registered as follows:
+     container.register('location:history-test', HistoryTestLocation);
 
-      Keep in mind that since some of your users will use `HistoryLocation`, your
-      server must serve the Ember app at all the routes you define.
+     // You could create a new instance via:
+     container.lookup('location:history-test');
+     ```
 
-      @class AutoLocation
-      @namespace Ember
-      @static
+      @method create
+      @param {Object} options
+      @return {Object} an instance of an implementation of the `location` API
+      @deprecated Use the container to lookup the location implementation that you
+      need.
     */
-    __exports__["default"] = {
-
-      /**
-        @private
+    create: function(options) {
+      var implementation = options && options.implementation;
+      Ember['default'].assert("Ember.Location.create: you must specify a 'implementation' option", !!implementation);
 
-        This property is used by router:main to know whether to cancel the routing
-        setup process, which is needed while we redirect the browser.
+      var implementationClass = this.implementations[implementation];
+      Ember['default'].assert("Ember.Location.create: " + implementation + " is not a valid implementation", !!implementationClass);
 
-        @since 1.5.1
-        @property cancelRouterSetup
-        @default false
-      */
-      cancelRouterSetup: false,
-
-      /**
-        @private
+      return implementationClass.create.apply(implementationClass, arguments);
+    },
 
-        Will be pre-pended to path upon state change.
-
-        @since 1.5.1
-        @property rootURL
-        @default '/'
-      */
-      rootURL: '/',
-
-      /**
-        @private
+    /**
+     This is deprecated in favor of using the container to register the
+     location implementation as desired.
 
-        Attached for mocking in tests
+     Example:
 
-        @since 1.5.1
-        @property _window
-        @default window
-      */
-      _window: window,
+     ```javascript
+     Application.initializer({
+      name: "history-test-location",
 
-      /**
-        @private
+      initialize: function(container, application) {
+        application.register('location:history-test', HistoryTestLocation);
+      }
+     });
+     ```
 
-        Attached for mocking in tests
+     @method registerImplementation
+     @param {String} name
+     @param {Object} implementation of the `location` API
+     @deprecated Register your custom location implementation with the
+     container directly.
+    */
+    registerImplementation: function(name, implementation) {
+      Ember['default'].deprecate('Using the Ember.Location.registerImplementation is no longer supported.' +
+                      ' Register your custom location implementation with the container instead.');
 
-        @property location
-        @default window.location
-      */
-      _location: window.location,
+      this.implementations[name] = implementation;
+    },
 
-      /**
-        @private
+    implementations: {},
+    _location: environment['default'].location,
 
-        Attached for mocking in tests
+    /**
+      Returns the current `location.hash` by parsing location.href since browsers
+      inconsistently URL-decode `location.hash`.
 
-        @since 1.5.1
-        @property _history
-        @default window.history
-      */
-      _history: window.history,
+      https://bugzilla.mozilla.org/show_bug.cgi?id=483304
 
-      /**
-        @private
+      @private
+      @method getHash
+      @since 1.4.0
+    */
+    _getHash: function () {
+      // AutoLocation has it at _location, HashLocation at .location.
+      // Being nice and not changing
+      var href = (this._location || this.location).href;
+      var hashIndex = href.indexOf('#');
 
-        Attached for mocking in tests
+      if (hashIndex === -1) {
+        return '';
+      } else {
+        return href.substr(hashIndex);
+      }
+    }
+  };
 
-        @since 1.5.1
-        @property _HistoryLocation
-        @default Ember.HistoryLocation
-      */
-      _HistoryLocation: HistoryLocation,
+});
+enifed('ember-routing/location/auto_location', ['exports', 'ember-metal/core', 'ember-metal/property_set', 'ember-routing/location/api', 'ember-routing/location/history_location', 'ember-routing/location/hash_location', 'ember-routing/location/none_location', 'ember-metal/environment', 'ember-routing/location/feature_detect'], function (exports, Ember, property_set, EmberLocation, HistoryLocation, HashLocation, NoneLocation, environment, feature_detect) {
 
-      /**
-        @private
+  'use strict';
 
-        Attached for mocking in tests
+  exports['default'] = {
+    /**
+      @private
 
-        @since 1.5.1
-        @property _HashLocation
-        @default Ember.HashLocation
-      */
-      _HashLocation: HashLocation,
+      Attached for mocking in tests
 
-      /**
-        @private
+      @property location
+      @default environment.location
+    */
+    _location: environment['default'].location,
 
-        Attached for mocking in tests
+    /**
+      @private
 
-        @since 1.5.1
-        @property _NoneLocation
-        @default Ember.NoneLocation
-      */
-      _NoneLocation: NoneLocation,
+      Attached for mocking in tests
 
-      /**
-        @private
+      @since 1.5.1
+      @property _history
+      @default environment.history
+    */
+    _history: environment['default'].history,
 
-        Returns location.origin or builds it if device doesn't support it.
+    /**
+      @private
 
-        @method _getOrigin
-      */
-      _getOrigin: function () {
-        var location = this._location;
-        var origin = location.origin;
+      This property is used by router:main to know whether to cancel the routing
+      setup process, which is needed while we redirect the browser.
 
-        // Older browsers, especially IE, don't have origin
-        if (!origin) {
-          origin = location.protocol + '//' + location.hostname;
+      @since 1.5.1
+      @property cancelRouterSetup
+      @default false
+    */
+    cancelRouterSetup: false,
 
-          if (location.port) {
-            origin += ':' + location.port;
-          }
-        }
+    /**
+      @private
 
-        return origin;
-      },
+      Will be pre-pended to path upon state change.
 
-      /**
-        @private
+      @since 1.5.1
+      @property rootURL
+      @default '/'
+    */
+    rootURL: '/',
 
-        We assume that if the history object has a pushState method, the host should
-        support HistoryLocation.
+    /**
+      @private
 
-        @method _getSupportsHistory
-      */
-      _getSupportsHistory: function () {
-        // Boosted from Modernizr: https://github.com/Modernizr/Modernizr/blob/master/feature-detects/history.js
-        // The stock browser on Android 2.2 & 2.3 returns positive on history support
-        // Unfortunately support is really buggy and there is no clean way to detect
-        // these bugs, so we fall back to a user agent sniff :(
-        var userAgent = this._window.navigator.userAgent;
-
-        // We only want Android 2, stock browser, and not Chrome which identifies
-        // itself as 'Mobile Safari' as well
-        if (userAgent.indexOf('Android 2') !== -1 &&
-            userAgent.indexOf('Mobile Safari') !== -1 &&
-            userAgent.indexOf('Chrome') === -1) {
-          return false;
-        }
+      Attached for mocking in tests
 
-        return !!(this._history && 'pushState' in this._history);
-      },
+      @since 1.5.1
+      @property _HistoryLocation
+      @default Ember.HistoryLocation
+    */
+    _HistoryLocation: HistoryLocation['default'],
 
-      /**
-        @private
+    /**
+      @private
 
-        IE8 running in IE7 compatibility mode gives false positive, so we must also
-        check documentMode.
+      Attached for mocking in tests
 
-        @method _getSupportsHashChange
-      */
-      _getSupportsHashChange: function () {
-        var _window = this._window;
-        var documentMode = _window.document.documentMode;
+      @since 1.5.1
+      @property _HashLocation
+      @default Ember.HashLocation
+    */
+    _HashLocation: HashLocation['default'],
 
-        return ('onhashchange' in _window && (documentMode === undefined || documentMode > 7 ));
-      },
+    /**
+      @private
 
-      /**
-        @private
+      Attached for mocking in tests
 
-        Redirects the browser using location.replace, prepending the locatin.origin
-        to prevent phishing attempts
+      @since 1.5.1
+      @property _NoneLocation
+      @default Ember.NoneLocation
+    */
+    _NoneLocation: NoneLocation['default'],
 
-        @method _replacePath
-      */
-      _replacePath: function (path) {
-        this._location.replace(this._getOrigin() + path);
-      },
+    /**
+      @private
 
-      /**
-        @since 1.5.1
-        @private
-        @method _getRootURL
-      */
-      _getRootURL: function () {
-        return this.rootURL;
-      },
+      Returns location.origin or builds it if device doesn't support it.
 
-      /**
-        @private
+      @method _getOrigin
+    */
+    _getOrigin: function () {
+      var location = this._location;
+      var origin = location.origin;
 
-        Returns the current `location.pathname`, normalized for IE inconsistencies.
+      // Older browsers, especially IE, don't have origin
+      if (!origin) {
+        origin = location.protocol + '//' + location.hostname;
 
-        @method _getPath
-      */
-      _getPath: function () {
-        var pathname = this._location.pathname;
-        // Various versions of IE/Opera don't always return a leading slash
-        if (pathname.charAt(0) !== '/') {
-          pathname = '/' + pathname;
+        if (location.port) {
+          origin += ':' + location.port;
         }
+      }
 
-        return pathname;
-      },
+      return origin;
+    },
 
-      /**
-        @private
+    _userAgent: environment['default'].userAgent,
 
-        Returns normalized location.hash as an alias to Ember.Location._getHash
+    /**
+      @private
 
-        @since 1.5.1
-        @method _getHash
-      */
-      _getHash: EmberLocation._getHash,
+      @method _getSupportsHistory
+    */
+    _getSupportsHistory: function () {
+      return feature_detect.supportsHistory(environment['default'].userAgent, environment['default'].history);
+    },
 
-      /**
-        @private
+    /**
+      @private
 
-        Returns location.search
+      @method _getSupportsHashChange
+    */
+    _getSupportsHashChange: function () {
+      return feature_detect.supportsHashChange(document.documentMode, window);
+    },
 
-        @since 1.5.1
-        @method _getQuery
-      */
-      _getQuery: function () {
-        return this._location.search;
-      },
+    /**
+      @private
 
-      /**
-        @private
+      Redirects the browser using location.replace, prepending the location.origin
+      to prevent phishing attempts
 
-        Returns the full pathname including query and hash
+      @method _replacePath
+    */
+    _replacePath: function (path) {
+      this._location.replace(this._getOrigin() + path);
+    },
 
-        @method _getFullPath
-      */
-      _getFullPath: function () {
-        return this._getPath() + this._getQuery() + this._getHash();
-      },
+    /**
+      @since 1.5.1
+      @private
+      @method _getRootURL
+    */
+    _getRootURL: function () {
+      return this.rootURL;
+    },
 
-      /**
-        @private
+    /**
+      @private
 
-        Returns the current path as it should appear for HistoryLocation supported
-        browsers. This may very well differ from the real current path (e.g. if it
-        starts off as a hashed URL)
+      Returns the current `location.pathname`, normalized for IE inconsistencies.
 
-        @method _getHistoryPath
-      */
-      _getHistoryPath: function () {
-        var rootURL = this._getRootURL();
-        var path = this._getPath();
-        var hash = this._getHash();
-        var query = this._getQuery();
-        var rootURLIndex = path.indexOf(rootURL);
-        var routeHash, hashParts;
-
-        Ember.assert('Path ' + path + ' does not start with the provided rootURL ' + rootURL, rootURLIndex === 0);
-
-        // By convention, Ember.js routes using HashLocation are required to start
-        // with `#/`. Anything else should NOT be considered a route and should
-        // be passed straight through, without transformation.
-        if (hash.substr(0, 2) === '#/') {
-          // There could be extra hash segments after the route
-          hashParts = hash.substr(1).split('#');
-          // The first one is always the route url
-          routeHash = hashParts.shift();
-
-          // If the path already has a trailing slash, remove the one
-          // from the hashed route so we don't double up.
-          if (path.slice(-1) === '/') {
-              routeHash = routeHash.substr(1);
-          }
+      @method _getPath
+    */
+    _getPath: function () {
+      var pathname = this._location.pathname;
+      // Various versions of IE/Opera don't always return a leading slash
+      if (pathname.charAt(0) !== '/') {
+        pathname = '/' + pathname;
+      }
 
-          // This is the "expected" final order
-          path += routeHash;
-          path += query;
+      return pathname;
+    },
 
-          if (hashParts.length) {
-            path += '#' + hashParts.join('#');
-          }
-        } else {
-          path += query;
-          path += hash;
-        }
+    /**
+      @private
 
-        return path;
-      },
+      Returns normalized location.hash as an alias to Ember.Location._getHash
 
-      /**
-        @private
+      @since 1.5.1
+      @method _getHash
+    */
+    _getHash: EmberLocation['default']._getHash,
 
-        Returns the current path as it should appear for HashLocation supported
-        browsers. This may very well differ from the real current path.
+    /**
+      @private
 
-        @method _getHashPath
-      */
-      _getHashPath: function () {
-        var rootURL = this._getRootURL();
-        var path = rootURL;
-        var historyPath = this._getHistoryPath();
-        var routePath = historyPath.substr(rootURL.length);
-
-        if (routePath !== '') {
-          if (routePath.charAt(0) !== '/') {
-            routePath = '/' + routePath;
-          }
+      Returns location.search
 
-          path += '#' + routePath;
-        }
+      @since 1.5.1
+      @method _getQuery
+    */
+    _getQuery: function () {
+      return this._location.search;
+    },
 
-        return path;
-      },
+    /**
+      @private
 
-      /**
-        Selects the best location option based off browser support and returns an
-        instance of that Location class.
+      Returns the full pathname including query and hash
 
-        @see Ember.AutoLocation
-        @method create
-      */
-      create: function (options) {
-        if (options && options.rootURL) {
-          Ember.assert('rootURL must end with a trailing forward slash e.g. "/app/"',
-                       options.rootURL.charAt(options.rootURL.length-1) === '/');
-          this.rootURL = options.rootURL;
-        }
+      @method _getFullPath
+    */
+    _getFullPath: function () {
+      return this._getPath() + this._getQuery() + this._getHash();
+    },
 
-        var historyPath, hashPath;
-        var cancelRouterSetup = false;
-        var implementationClass = this._NoneLocation;
-        var currentPath = this._getFullPath();
+    /**
+      @private
 
-        if (this._getSupportsHistory()) {
-          historyPath = this._getHistoryPath();
+      Returns the current path as it should appear for HistoryLocation supported
+      browsers. This may very well differ from the real current path (e.g. if it
+      starts off as a hashed URL)
 
-          // Since we support history paths, let's be sure we're using them else
-          // switch the location over to it.
-          if (currentPath === historyPath) {
-            implementationClass = this._HistoryLocation;
-          } else {
-            
-              if (currentPath.substr(0, 2) === '/#') {
-                this._history.replaceState({ path: historyPath }, null, historyPath);
-                implementationClass = this._HistoryLocation;
-              } else {
-                cancelRouterSetup = true;
-                this._replacePath(historyPath);
-              }
-                      }
+      @method _getHistoryPath
+    */
+    _getHistoryPath: function () {
+      var rootURL = this._getRootURL();
+      var path = this._getPath();
+      var hash = this._getHash();
+      var query = this._getQuery();
+      var rootURLIndex = path.indexOf(rootURL);
+      var routeHash, hashParts;
 
-        } else if (this._getSupportsHashChange()) {
-          hashPath = this._getHashPath();
+      Ember['default'].assert('Path ' + path + ' does not start with the provided rootURL ' + rootURL, rootURLIndex === 0);
 
-          // Be sure we're using a hashed path, otherwise let's switch over it to so
-          // we start off clean and consistent. We'll count an index path with no
-          // hash as "good enough" as well.
-          if (currentPath === hashPath || (currentPath === '/' && hashPath === '/#/')) {
-            implementationClass = this._HashLocation;
-          } else {
-            // Our URL isn't in the expected hash-supported format, so we want to
-            // cancel the router setup and replace the URL to start off clean
-            cancelRouterSetup = true;
-            this._replacePath(hashPath);
-          }
+      // By convention, Ember.js routes using HashLocation are required to start
+      // with `#/`. Anything else should NOT be considered a route and should
+      // be passed straight through, without transformation.
+      if (hash.substr(0, 2) === '#/') {
+        // There could be extra hash segments after the route
+        hashParts = hash.substr(1).split('#');
+        // The first one is always the route url
+        routeHash = hashParts.shift();
+
+        // If the path already has a trailing slash, remove the one
+        // from the hashed route so we don't double up.
+        if (path.slice(-1) === '/') {
+          routeHash = routeHash.substr(1);
         }
 
-        var implementation = implementationClass.create.apply(implementationClass, arguments);
+        // This is the "expected" final order
+        path += routeHash;
+        path += query;
 
-        if (cancelRouterSetup) {
-          set(implementation, 'cancelRouterSetup', true);
+        if (hashParts.length) {
+          path += '#' + hashParts.join('#');
         }
-
-        return implementation;
+      } else {
+        path += query;
+        path += hash;
       }
-    };
-  });
-enifed("ember-routing/location/hash_location",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/run_loop","ember-metal/utils","ember-runtime/system/object","ember-routing/location/api","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var get = __dependency2__.get;
-    var set = __dependency3__.set;
-    var run = __dependency4__["default"];
-    var guidFor = __dependency5__.guidFor;
 
-    var EmberObject = __dependency6__["default"];
-    var EmberLocation = __dependency7__["default"];
+      return path;
+    },
 
     /**
-    @module ember
-    @submodule ember-routing
-    */
+      @private
 
-    /**
-      `Ember.HashLocation` implements the location API using the browser's
-      hash. At present, it relies on a `hashchange` event existing in the
-      browser.
+      Returns the current path as it should appear for HashLocation supported
+      browsers. This may very well differ from the real current path.
 
-      @class HashLocation
-      @namespace Ember
-      @extends Ember.Object
+      @method _getHashPath
     */
-    __exports__["default"] = EmberObject.extend({
-      implementation: 'hash',
+    _getHashPath: function () {
+      var rootURL = this._getRootURL();
+      var path = rootURL;
+      var historyPath = this._getHistoryPath();
+      var routePath = historyPath.substr(rootURL.length);
 
-      init: function() {
-        set(this, 'location', get(this, '_location') || window.location);
-      },
+      if (routePath !== '') {
+        if (routePath.charAt(0) !== '/') {
+          routePath = '/' + routePath;
+        }
 
-      /**
-        @private
+        path += '#' + routePath;
+      }
 
-        Returns normalized location.hash
+      return path;
+    },
 
-        @since 1.5.1
-        @method getHash
-      */
-      getHash: EmberLocation._getHash,
+    /**
+      Selects the best location option based off browser support and returns an
+      instance of that Location class.
 
-      /**
-        Returns the normalized URL, constructed from `location.hash`.
+      @see Ember.AutoLocation
+      @method create
+    */
+    create: function (options) {
+      if (options && options.rootURL) {
+        Ember['default'].assert('rootURL must end with a trailing forward slash e.g. "/app/"',
+                     options.rootURL.charAt(options.rootURL.length-1) === '/');
+        this.rootURL = options.rootURL;
+      }
 
-        e.g. `#/foo` => `/foo` as well as `#/foo#bar` => `/foo#bar`.
+      var historyPath, hashPath;
+      var cancelRouterSetup = false;
+      var implementationClass = this._NoneLocation;
+      var currentPath = this._getFullPath();
 
-        By convention, hashed paths must begin with a forward slash, otherwise they
-        are not treated as a path so we can distinguish intent.
+      if (this._getSupportsHistory()) {
+        historyPath = this._getHistoryPath();
 
-        @private
-        @method getURL
-      */
-      getURL: function() {
-        var originalPath = this.getHash().substr(1);
-        var outPath = originalPath;
-        
-        if (outPath.charAt(0) !== '/') {
-          outPath = '/';
-
-          // Only add the # if the path isn't empty.
-          // We do NOT want `/#` since the ampersand
-          // is only included (conventionally) when
-          // the location.hash has a value
-          if (originalPath) {
-            outPath += '#' + originalPath;
+        // Since we support history paths, let's be sure we're using them else
+        // switch the location over to it.
+        if (currentPath === historyPath) {
+          implementationClass = this._HistoryLocation;
+        } else {
+          if (currentPath.substr(0, 2) === '/#') {
+            this._history.replaceState({ path: historyPath }, null, historyPath);
+            implementationClass = this._HistoryLocation;
+          } else {
+            cancelRouterSetup = true;
+            this._replacePath(historyPath);
           }
         }
 
-        return outPath;
-      },
+      } else if (this._getSupportsHashChange()) {
+        hashPath = this._getHashPath();
 
-      /**
-        Set the `location.hash` and remembers what was set. This prevents
-        `onUpdateURL` callbacks from triggering when the hash was set by
-        `HashLocation`.
+        // Be sure we're using a hashed path, otherwise let's switch over it to so
+        // we start off clean and consistent. We'll count an index path with no
+        // hash as "good enough" as well.
+        if (currentPath === hashPath || (currentPath === '/' && hashPath === '/#/')) {
+          implementationClass = this._HashLocation;
+        } else {
+          // Our URL isn't in the expected hash-supported format, so we want to
+          // cancel the router setup and replace the URL to start off clean
+          cancelRouterSetup = true;
+          this._replacePath(hashPath);
+        }
+      }
 
-        @private
-        @method setURL
-        @param path {String}
-      */
-      setURL: function(path) {
-        get(this, 'location').hash = path;
-        set(this, 'lastSetURL', path);
-      },
+      var implementation = implementationClass.create.apply(implementationClass, arguments);
 
-      /**
-        Uses location.replace to update the url without a page reload
-        or history modification.
+      if (cancelRouterSetup) {
+        property_set.set(implementation, 'cancelRouterSetup', true);
+      }
 
-        @private
-        @method replaceURL
-        @param path {String}
-      */
-      replaceURL: function(path) {
-        get(this, 'location').replace('#' + path);
-        set(this, 'lastSetURL', path);
-      },
+      return implementation;
+    }
+  };
 
-      /**
-        Register a callback to be invoked when the hash changes. These
-        callbacks will execute when the user presses the back or forward
-        button, but not after `setURL` is invoked.
+});
+enifed('ember-routing/location/feature_detect', ['exports'], function (exports) {
 
-        @private
-        @method onUpdateURL
-        @param callback {Function}
-      */
-      onUpdateURL: function(callback) {
-        var self = this;
-        var guid = guidFor(this);
+  'use strict';
 
-        Ember.$(window).on('hashchange.ember-location-'+guid, function() {
-          run(function() {
-            var path = self.getURL();
-            if (get(self, 'lastSetURL') === path) { return; }
+  exports.supportsHashChange = supportsHashChange;
+  exports.supportsHistory = supportsHistory;
 
-            set(self, 'lastSetURL', null);
+  /*
+    `documentMode` only exist in Internet Explorer, and it's tested because IE8 running in
+    IE7 compatibility mode claims to support `onhashchange` but actually does not.
 
-            callback(path);
-          });
-        });
-      },
+    `global` is an object that may have an `onhashchange` property.
 
-      /**
-        Given a URL, formats it to be placed into the page as part
-        of an element's `href` attribute.
+    @private
+    @function supportsHashChange
+  */
+  function supportsHashChange(documentMode, global) {
+    return ('onhashchange' in global) && (documentMode === undefined || documentMode > 7);
+  }
 
-        This is used, for example, when using the {{action}} helper
-        to generate a URL based on an event.
+  /*
+    `userAgent` is a user agent string. We use user agent testing here, because
+    the stock Android browser in Gingerbread has a buggy versions of this API,
+    Before feature detecting, we blacklist a browser identifying as both Android 2
+    and Mobile Safari, but not Chrome.
+
+    @private
+    @function supportsHistory
+  */
+
+  function supportsHistory(userAgent, history) {
+    // Boosted from Modernizr: https://github.com/Modernizr/Modernizr/blob/master/feature-detects/history.js
+    // The stock browser on Android 2.2 & 2.3 returns positive on history support
+    // Unfortunately support is really buggy and there is no clean way to detect
+    // these bugs, so we fall back to a user agent sniff :(
+
+    // We only want Android 2, stock browser, and not Chrome which identifies
+    // itself as 'Mobile Safari' as well
+    if (userAgent.indexOf('Android 2') !== -1 &&
+        userAgent.indexOf('Mobile Safari') !== -1 &&
+        userAgent.indexOf('Chrome') === -1) {
+      return false;
+    }
 
-        @private
-        @method formatURL
-        @param url {String}
-      */
-      formatURL: function(url) {
-        return '#' + url;
-      },
+    return !!(history && 'pushState' in history);
+  }
 
-      /**
-        Cleans up the HashLocation event listener.
+});
+enifed('ember-routing/location/hash_location', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-metal/utils', 'ember-runtime/system/object', 'ember-routing/location/api'], function (exports, Ember, property_get, property_set, run, utils, EmberObject, EmberLocation) {
 
-        @private
-        @method willDestroy
-      */
-      willDestroy: function() {
-        var guid = guidFor(this);
+  'use strict';
 
-        Ember.$(window).off('hashchange.ember-location-'+guid);
-      }
-    });
-  });
-enifed("ember-routing/location/history_location",
-  ["ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-runtime/system/object","ember-routing/location/api","ember-views/system/jquery","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
-    var get = __dependency1__.get;
-    var set = __dependency2__.set;
-    var guidFor = __dependency3__.guidFor;
+  exports['default'] = EmberObject['default'].extend({
+    implementation: 'hash',
 
-    var EmberObject = __dependency4__["default"];
-    var EmberLocation = __dependency5__["default"];
-    var jQuery = __dependency6__["default"];
+    init: function() {
+      property_set.set(this, 'location', property_get.get(this, '_location') || window.location);
+    },
 
     /**
-    @module ember
-    @submodule ember-routing
-    */
-
-    var popstateFired = false;
-    var supportsHistoryState = window.history && 'state' in window.history;
+      @private
 
-    /**
-      Ember.HistoryLocation implements the location API using the browser's
-      history.pushState API.
+      Returns normalized location.hash
 
-      @class HistoryLocation
-      @namespace Ember
-      @extends Ember.Object
+      @since 1.5.1
+      @method getHash
     */
-    __exports__["default"] = EmberObject.extend({
-      implementation: 'history',
-
-      init: function() {
-        set(this, 'location', get(this, 'location') || window.location);
-        set(this, 'baseURL', jQuery('base').attr('href') || '');
-      },
+    getHash: EmberLocation['default']._getHash,
 
-      /**
-        Used to set state on first call to setURL
-
-        @private
-        @method initState
-      */
-      initState: function() {
-        set(this, 'history', get(this, 'history') || window.history);
-        this.replaceState(this.formatURL(this.getURL()));
-      },
+    /**
+      Returns the normalized URL, constructed from `location.hash`.
 
-      /**
-        Will be pre-pended to path upon state change
+      e.g. `#/foo` => `/foo` as well as `#/foo#bar` => `/foo#bar`.
 
-        @property rootURL
-        @default '/'
-      */
-      rootURL: '/',
+      By convention, hashed paths must begin with a forward slash, otherwise they
+      are not treated as a path so we can distinguish intent.
 
-      /**
-        Returns the current `location.pathname` without `rootURL` or `baseURL`
+      @private
+      @method getURL
+    */
+    getURL: function() {
+      var originalPath = this.getHash().substr(1);
+      var outPath = originalPath;
 
-        @private
-        @method getURL
-        @return url {String}
-      */
-      getURL: function() {
-        var rootURL = get(this, 'rootURL');
-        var location = get(this, 'location');
-        var path = location.pathname;
-        var baseURL = get(this, 'baseURL');
+      if (outPath.charAt(0) !== '/') {
+        outPath = '/';
 
-        rootURL = rootURL.replace(/\/$/, '');
-        baseURL = baseURL.replace(/\/$/, '');
+        // Only add the # if the path isn't empty.
+        // We do NOT want `/#` since the ampersand
+        // is only included (conventionally) when
+        // the location.hash has a value
+        if (originalPath) {
+          outPath += '#' + originalPath;
+        }
+      }
 
-        var url = path.replace(baseURL, '').replace(rootURL, '');
-        var search = location.search || '';
+      return outPath;
+    },
 
-        url += search;
-        url += this.getHash();
+    /**
+      Set the `location.hash` and remembers what was set. This prevents
+      `onUpdateURL` callbacks from triggering when the hash was set by
+      `HashLocation`.
 
-        return url;
-      },
+      @private
+      @method setURL
+      @param path {String}
+    */
+    setURL: function(path) {
+      property_get.get(this, 'location').hash = path;
+      property_set.set(this, 'lastSetURL', path);
+    },
 
-      /**
-        Uses `history.pushState` to update the url without a page reload.
+    /**
+      Uses location.replace to update the url without a page reload
+      or history modification.
 
-        @private
-        @method setURL
-        @param path {String}
-      */
-      setURL: function(path) {
-        var state = this.getState();
-        path = this.formatURL(path);
+      @private
+      @method replaceURL
+      @param path {String}
+    */
+    replaceURL: function(path) {
+      property_get.get(this, 'location').replace('#' + path);
+      property_set.set(this, 'lastSetURL', path);
+    },
 
-        if (!state || state.path !== path) {
-          this.pushState(path);
-        }
-      },
+    /**
+      Register a callback to be invoked when the hash changes. These
+      callbacks will execute when the user presses the back or forward
+      button, but not after `setURL` is invoked.
 
-      /**
-        Uses `history.replaceState` to update the url without a page reload
-        or history modification.
+      @private
+      @method onUpdateURL
+      @param callback {Function}
+    */
+    onUpdateURL: function(callback) {
+      var self = this;
+      var guid = utils.guidFor(this);
 
-        @private
-        @method replaceURL
-        @param path {String}
-      */
-      replaceURL: function(path) {
-        var state = this.getState();
-        path = this.formatURL(path);
+      Ember['default'].$(window).on('hashchange.ember-location-'+guid, function() {
+        run['default'](function() {
+          var path = self.getURL();
+          if (property_get.get(self, 'lastSetURL') === path) { return; }
 
-        if (!state || state.path !== path) {
-          this.replaceState(path);
-        }
-      },
+          property_set.set(self, 'lastSetURL', null);
 
-      /**
-       Get the current `history.state`. Checks for if a polyfill is
-       required and if so fetches this._historyState. The state returned
-       from getState may be null if an iframe has changed a window's
-       history.
-
-       @private
-       @method getState
-       @return state {Object}
-      */
-      getState: function() {
-        return supportsHistoryState ? get(this, 'history').state : this._historyState;
-      },
+          callback(path);
+        });
+      });
+    },
 
-      /**
-       Pushes a new state.
+    /**
+      Given a URL, formats it to be placed into the page as part
+      of an element's `href` attribute.
 
-       @private
-       @method pushState
-       @param path {String}
-      */
-      pushState: function(path) {
-        var state = { path: path };
+      This is used, for example, when using the {{action}} helper
+      to generate a URL based on an event.
 
-        get(this, 'history').pushState(state, null, path);
+      @private
+      @method formatURL
+      @param url {String}
+    */
+    formatURL: function(url) {
+      return '#' + url;
+    },
 
-        // store state if browser doesn't support `history.state`
-        if (!supportsHistoryState) {
-          this._historyState = state;
-        }
+    /**
+      Cleans up the HashLocation event listener.
 
-        // used for webkit workaround
-        this._previousURL = this.getURL();
-      },
+      @private
+      @method willDestroy
+    */
+    willDestroy: function() {
+      var guid = utils.guidFor(this);
 
-      /**
-       Replaces the current state.
+      Ember['default'].$(window).off('hashchange.ember-location-'+guid);
+    }
+  });
 
-       @private
-       @method replaceState
-       @param path {String}
-      */
-      replaceState: function(path) {
-        var state = { path: path };
-        get(this, 'history').replaceState(state, null, path);
+});
+enifed('ember-routing/location/history_location', ['exports', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/utils', 'ember-runtime/system/object', 'ember-routing/location/api', 'ember-views/system/jquery'], function (exports, property_get, property_set, utils, EmberObject, EmberLocation, jQuery) {
 
-        // store state if browser doesn't support `history.state`
-        if (!supportsHistoryState) {
-          this._historyState = state;
-        }
+  'use strict';
 
-        // used for webkit workaround
-        this._previousURL = this.getURL();
-      },
+  var popstateFired = false;
 
-      /**
-        Register a callback to be invoked whenever the browser
-        history changes, including using forward and back buttons.
+  /**
+    Ember.HistoryLocation implements the location API using the browser's
+    history.pushState API.
 
-        @private
-        @method onUpdateURL
-        @param callback {Function}
-      */
-      onUpdateURL: function(callback) {
-        var guid = guidFor(this);
-        var self = this;
+    @class HistoryLocation
+    @namespace Ember
+    @extends Ember.Object
+  */
+  exports['default'] = EmberObject['default'].extend({
+    implementation: 'history',
 
-        jQuery(window).on('popstate.ember-location-'+guid, function(e) {
-          // Ignore initial page load popstate event in Chrome
-          if (!popstateFired) {
-            popstateFired = true;
-            if (self.getURL() === self._previousURL) { return; }
-          }
-          callback(self.getURL());
-        });
-      },
+    init: function() {
+      property_set.set(this, 'location', property_get.get(this, 'location') || window.location);
+      property_set.set(this, 'baseURL', jQuery['default']('base').attr('href') || '');
+    },
 
-      /**
-        Used when using `{{action}}` helper.  The url is always appended to the rootURL.
+    /**
+      Used to set state on first call to setURL
 
-        @private
-        @method formatURL
-        @param url {String}
-        @return formatted url {String}
-      */
-      formatURL: function(url) {
-        var rootURL = get(this, 'rootURL');
-        var baseURL = get(this, 'baseURL');
+      @private
+      @method initState
+    */
+    initState: function() {
+      property_set.set(this, 'history', property_get.get(this, 'history') || window.history);
+      this.replaceState(this.formatURL(this.getURL()));
+    },
 
-        if (url !== '') {
-          rootURL = rootURL.replace(/\/$/, '');
-          baseURL = baseURL.replace(/\/$/, '');
-        } else if(baseURL.match(/^\//) && rootURL.match(/^\//)) {
-          baseURL = baseURL.replace(/\/$/, '');
-        }
+    /**
+      Will be pre-pended to path upon state change
 
-        return baseURL + rootURL + url;
-      },
+      @property rootURL
+      @default '/'
+    */
+    rootURL: '/',
 
-      /**
-        Cleans up the HistoryLocation event listener.
+    /**
+      Returns the current `location.pathname` without `rootURL` or `baseURL`
 
-        @private
-        @method willDestroy
-      */
-      willDestroy: function() {
-        var guid = guidFor(this);
+      @private
+      @method getURL
+      @return url {String}
+    */
+    getURL: function() {
+      var rootURL = property_get.get(this, 'rootURL');
+      var location = property_get.get(this, 'location');
+      var path = location.pathname;
+      var baseURL = property_get.get(this, 'baseURL');
 
-        jQuery(window).off('popstate.ember-location-'+guid);
-      },
+      rootURL = rootURL.replace(/\/$/, '');
+      baseURL = baseURL.replace(/\/$/, '');
 
-      /**
-        @private
+      var url = path.replace(baseURL, '').replace(rootURL, '');
+      var search = location.search || '';
 
-        Returns normalized location.hash
+      url += search;
+      url += this.getHash();
 
-        @method getHash
-      */
-      getHash: EmberLocation._getHash
-    });
-  });
-enifed("ember-routing/location/none_location",
-  ["ember-metal/property_get","ember-metal/property_set","ember-runtime/system/object","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var get = __dependency1__.get;
-    var set = __dependency2__.set;
-    var EmberObject = __dependency3__["default"];
+      return url;
+    },
 
     /**
-    @module ember
-    @submodule ember-routing
+      Uses `history.pushState` to update the url without a page reload.
+
+      @private
+      @method setURL
+      @param path {String}
     */
+    setURL: function(path) {
+      var state = this._historyState;
+      path = this.formatURL(path);
+
+      if (!state || state.path !== path) {
+        this.pushState(path);
+      }
+    },
 
     /**
-      Ember.NoneLocation does not interact with the browser. It is useful for
-      testing, or when you need to manage state with your Router, but temporarily
-      don't want it to muck with the URL (for example when you embed your
-      application in a larger page).
+      Uses `history.replaceState` to update the url without a page reload
+      or history modification.
 
-      @class NoneLocation
-      @namespace Ember
-      @extends Ember.Object
+      @private
+      @method replaceURL
+      @param path {String}
     */
-    __exports__["default"] = EmberObject.extend({
-      implementation: 'none',
-      path: '',
+    replaceURL: function(path) {
+      var state = this._historyState;
+      path = this.formatURL(path);
 
-      /**
-        Returns the current path.
+      if (!state || state.path !== path) {
+        this.replaceState(path);
+      }
+    },
 
-        @private
-        @method getURL
-        @return {String} path
-      */
-      getURL: function() {
-        return get(this, 'path');
-      },
+    /**
+     Pushes a new state.
 
-      /**
-        Set the path and remembers what was set. Using this method
-        to change the path will not invoke the `updateURL` callback.
+     @private
+     @method pushState
+     @param path {String}
+    */
+    pushState: function(path) {
+      var state = { path: path };
 
-        @private
-        @method setURL
-        @param path {String}
-      */
-      setURL: function(path) {
-        set(this, 'path', path);
-      },
+      property_get.get(this, 'history').pushState(null, null, path);
 
-      /**
-        Register a callback to be invoked when the path changes. These
-        callbacks will execute when the user presses the back or forward
-        button, but not after `setURL` is invoked.
+      this._historyState = state;
 
-        @private
-        @method onUpdateURL
-        @param callback {Function}
-      */
-      onUpdateURL: function(callback) {
-        this.updateCallback = callback;
-      },
+      // used for webkit workaround
+      this._previousURL = this.getURL();
+    },
 
-      /**
-        Sets the path and calls the `updateURL` callback.
+    /**
+     Replaces the current state.
 
-        @private
-        @method handleURL
-        @param callback {Function}
-      */
-      handleURL: function(url) {
-        set(this, 'path', url);
-        this.updateCallback(url);
-      },
+     @private
+     @method replaceState
+     @param path {String}
+    */
+    replaceState: function(path) {
+      var state = { path: path };
+      property_get.get(this, 'history').replaceState(null, null, path);
 
-      /**
-        Given a URL, formats it to be placed into the page as part
-        of an element's `href` attribute.
+      this._historyState = state;
 
-        This is used, for example, when using the {{action}} helper
-        to generate a URL based on an event.
+      // used for webkit workaround
+      this._previousURL = this.getURL();
+    },
 
-        @private
-        @method formatURL
-        @param url {String}
-        @return {String} url
-      */
-      formatURL: function(url) {
-        // The return value is not overly meaningful, but we do not want to throw
-        // errors when test code renders templates containing {{action href=true}}
-        // helpers.
-        return url;
-      }
-    });
-  });
-enifed("ember-routing/system/cache",
-  ["ember-runtime/system/object","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var EmberObject = __dependency1__["default"];
+    /**
+      Register a callback to be invoked whenever the browser
+      history changes, including using forward and back buttons.
 
-    __exports__["default"] = EmberObject.extend({
-      init: function() {
-        this.cache = {};
-      },
-      has: function(bucketKey) {
-        return bucketKey in this.cache;
-      },
-      stash: function(bucketKey, key, value) {
-        var bucket = this.cache[bucketKey];
-        if (!bucket) {
-          bucket = this.cache[bucketKey] = {};
-        }
-        bucket[key] = value;
-      },
-      lookup: function(bucketKey, prop, defaultValue) {
-        var cache = this.cache;
-        if (!(bucketKey in cache)) {
-          return defaultValue;
-        }
-        var bucket = cache[bucketKey];
-        if (prop in bucket) {
-          return bucket[prop];
-        } else {
-          return defaultValue;
+      @private
+      @method onUpdateURL
+      @param callback {Function}
+    */
+    onUpdateURL: function(callback) {
+      var guid = utils.guidFor(this);
+      var self = this;
+
+      jQuery['default'](window).on('popstate.ember-location-'+guid, function(e) {
+        // Ignore initial page load popstate event in Chrome
+        if (!popstateFired) {
+          popstateFired = true;
+          if (self.getURL() === self._previousURL) { return; }
         }
-      },
-      cache: null
-    });
-  });
-enifed("ember-routing/system/controller_for",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
+        callback(self.getURL());
+      });
+    },
+
     /**
-    @module ember
-    @submodule ember-routing
+      Used when using `{{action}}` helper.  The url is always appended to the rootURL.
+
+      @private
+      @method formatURL
+      @param url {String}
+      @return formatted url {String}
     */
+    formatURL: function(url) {
+      var rootURL = property_get.get(this, 'rootURL');
+      var baseURL = property_get.get(this, 'baseURL');
 
-    /**
+      if (url !== '') {
+        rootURL = rootURL.replace(/\/$/, '');
+        baseURL = baseURL.replace(/\/$/, '');
+      } else if (baseURL.match(/^\//) && rootURL.match(/^\//)) {
+        baseURL = baseURL.replace(/\/$/, '');
+      }
 
-      Finds a controller instance.
+      return baseURL + rootURL + url;
+    },
+
+    /**
+      Cleans up the HistoryLocation event listener.
 
-      @for Ember
-      @method controllerFor
       @private
+      @method willDestroy
     */
-    __exports__["default"] = function controllerFor(container, controllerName, lookupOptions) {
-      return container.lookup('controller:' + controllerName, lookupOptions);
-    }
-  });
-enifed("ember-routing/system/dsl",
-  ["ember-metal/core","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // FEATURES, assert
+    willDestroy: function() {
+      var guid = utils.guidFor(this);
+
+      jQuery['default'](window).off('popstate.ember-location-'+guid);
+    },
 
     /**
-    @module ember
-    @submodule ember-routing
+      @private
+
+      Returns normalized location.hash
+
+      @method getHash
     */
+    getHash: EmberLocation['default']._getHash
+  });
 
-    function DSL(name) {
-      this.parent = name;
-      this.matches = [];
-    }
-    __exports__["default"] = DSL;
+});
+enifed('ember-routing/location/none_location', ['exports', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-runtime/system/object'], function (exports, property_get, property_set, EmberObject) {
 
-    DSL.prototype = {
-      route: function(name, options, callback) {
-        if (arguments.length === 2 && typeof options === 'function') {
-          callback = options;
-          options = {};
-        }
+  'use strict';
 
-        if (arguments.length === 1) {
-          options = {};
-        }
+  exports['default'] = EmberObject['default'].extend({
+    implementation: 'none',
+    path: '',
 
-        var type = options.resetNamespace === true ? 'resource' : 'route';
-        Ember.assert("'basic' cannot be used as a " + type + " name.", name !== 'basic');
+    /**
+      Returns the current path.
 
-        
-        if (callback) {
-          var fullName = getFullName(this, name, options.resetNamespace);
-          var dsl = new DSL(fullName);
-          createRoute(dsl, 'loading');
-          createRoute(dsl, 'error', { path: "/_unused_dummy_error_path_route_" + name + "/:error" });
+      @private
+      @method getURL
+      @return {String} path
+    */
+    getURL: function() {
+      return property_get.get(this, 'path');
+    },
 
-          callback.call(dsl);
+    /**
+      Set the path and remembers what was set. Using this method
+      to change the path will not invoke the `updateURL` callback.
 
-          createRoute(this, name, options, dsl.generate());
-        } else {
-          createRoute(this, name, options);
-        }
-      },
+      @private
+      @method setURL
+      @param path {String}
+    */
+    setURL: function(path) {
+      property_set.set(this, 'path', path);
+    },
 
-      push: function(url, name, callback) {
-        var parts = name.split('.');
-        if (url === "" || url === "/" || parts[parts.length-1] === "index") { this.explicitIndex = true; }
+    /**
+      Register a callback to be invoked when the path changes. These
+      callbacks will execute when the user presses the back or forward
+      button, but not after `setURL` is invoked.
 
-        this.matches.push([url, name, callback]);
-      },
+      @private
+      @method onUpdateURL
+      @param callback {Function}
+    */
+    onUpdateURL: function(callback) {
+      this.updateCallback = callback;
+    },
 
-      resource: function(name, options, callback) {
-        if (arguments.length === 2 && typeof options === 'function') {
-          callback = options;
-          options = {};
-        }
+    /**
+      Sets the path and calls the `updateURL` callback.
 
-        if (arguments.length === 1) {
-          options = {};
-        }
+      @private
+      @method handleURL
+      @param callback {Function}
+    */
+    handleURL: function(url) {
+      property_set.set(this, 'path', url);
+      this.updateCallback(url);
+    },
 
-        options.resetNamespace = true;
-        this.route(name, options, callback);
-      },
+    /**
+      Given a URL, formats it to be placed into the page as part
+      of an element's `href` attribute.
 
-      generate: function() {
-        var dslMatches = this.matches;
+      This is used, for example, when using the {{action}} helper
+      to generate a URL based on an event.
 
-        if (!this.explicitIndex) {
-          this.route("index", { path: "/" });
-        }
+      @private
+      @method formatURL
+      @param url {String}
+      @return {String} url
+    */
+    formatURL: function(url) {
+      // The return value is not overly meaningful, but we do not want to throw
+      // errors when test code renders templates containing {{action href=true}}
+      // helpers.
+      return url;
+    }
+  });
 
-        return function(match) {
-          for (var i=0, l=dslMatches.length; i<l; i++) {
-            var dslMatch = dslMatches[i];
-            match(dslMatch[0]).to(dslMatch[1], dslMatch[2]);
-          }
-        };
-      }
-    };
+});
+enifed('ember-routing/system/cache', ['exports', 'ember-runtime/system/object'], function (exports, EmberObject) {
 
-    function canNest(dsl) {
-      return dsl.parent && dsl.parent !== 'application';
-    }
+  'use strict';
 
-    function getFullName(dsl, name, resetNamespace) {
-      if (canNest(dsl) && resetNamespace !== true) {
-        return dsl.parent + "." + name;
+  exports['default'] = EmberObject['default'].extend({
+    init: function() {
+      this.cache = {};
+    },
+    has: function(bucketKey) {
+      return bucketKey in this.cache;
+    },
+    stash: function(bucketKey, key, value) {
+      var bucket = this.cache[bucketKey];
+      if (!bucket) {
+        bucket = this.cache[bucketKey] = {};
+      }
+      bucket[key] = value;
+    },
+    lookup: function(bucketKey, prop, defaultValue) {
+      var cache = this.cache;
+      if (!(bucketKey in cache)) {
+        return defaultValue;
+      }
+      var bucket = cache[bucketKey];
+      if (prop in bucket) {
+        return bucket[prop];
       } else {
-        return name;
+        return defaultValue;
       }
-    }
-
-    function createRoute(dsl, name, options, callback) {
-      options = options || {};
+    },
+    cache: null
+  });
 
-      var fullName = getFullName(dsl, name, options.resetNamespace);
+});
+enifed('ember-routing/system/controller_for', ['exports'], function (exports) {
 
-      if (typeof options.path !== 'string') {
-        options.path = "/" + name;
-      }
+  'use strict';
 
-      dsl.push(options.path, fullName, callback);
-    }
+  /**
+  @module ember
+  @submodule ember-routing
+  */
 
-    DSL.map = function(callback) {
-      var dsl = new DSL();
-      callback.call(dsl);
-      return dsl;
-    };
-  });
-enifed("ember-routing/system/generate_controller",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Logger
-    var get = __dependency2__.get;
-    var isArray = __dependency3__.isArray;
+  /**
 
-    /**
-    @module ember
-    @submodule ember-routing
-    */
+    Finds a controller instance.
 
-    /**
-      Generates a controller factory
+    @for Ember
+    @method controllerFor
+    @private
+  */
+  function controllerFor(container, controllerName, lookupOptions) {
+    return container.lookup('controller:' + controllerName, lookupOptions);
+  }
+  exports['default'] = controllerFor;
 
-      The type of the generated controller factory is derived
-      from the context. If the context is an array an array controller
-      is generated, if an object, an object controller otherwise, a basic
-      controller is generated.
+});
+enifed('ember-routing/system/dsl', ['exports', 'ember-metal/core', 'ember-metal/array'], function (exports, Ember, array) {
 
-      You can customize your generated controllers by defining
-      `App.ObjectController` or `App.ArrayController`.
+  'use strict';
 
-      @for Ember
-      @method generateControllerFactory
-      @private
-    */
+  function DSL(name, options) {
+    this.parent = name;
+    this.enableLoadingSubstates = options && options.enableLoadingSubstates;
+    this.matches = [];
+  }
+  exports['default'] = DSL;
 
-    function generateControllerFactory(container, controllerName, context) {
-      var Factory, fullName, factoryName, controllerType;
+  DSL.prototype = {
+    route: function(name, options, callback) {
+      if (arguments.length === 2 && typeof options === 'function') {
+        callback = options;
+        options = {};
+      }
 
-      if (context && isArray(context)) {
-        controllerType = 'array';
-      } else if (context) {
-        controllerType = 'object';
-      } else {
-        controllerType = 'basic';
+      if (arguments.length === 1) {
+        options = {};
       }
 
-      factoryName = 'controller:' + controllerType;
+      var type = options.resetNamespace === true ? 'resource' : 'route';
+      Ember['default'].assert(
+        "'" + name + "' cannot be used as a " + type + " name.",
+        (function() {
+          if (options.overrideNameAssertion === true) { return true; }
 
-      Factory = container.lookupFactory(factoryName).extend({
-        isGenerated: true,
-        toString: function() {
-          return "(generated " + controllerName + " controller)";
-        }
-      });
+          return array.indexOf.call(['array', 'basic', 'object', 'application'], name) === -1;
+        })()
+      );
 
-      fullName = 'controller:' + controllerName;
 
-      container.register(fullName,  Factory);
+        if (this.enableLoadingSubstates) {
+          createRoute(this, name + '_loading', { resetNamespace: options.resetNamespace });
+          createRoute(this, name + '_error', { path: "/_unused_dummy_error_path_route_" + name + "/:error" });
+        }
 
-      return Factory;
-    }
 
-    __exports__.generateControllerFactory = generateControllerFactory;/**
-      Generates and instantiates a controller.
+      if (callback) {
+        var fullName = getFullName(this, name, options.resetNamespace);
+        var dsl = new DSL(fullName, {
+          enableLoadingSubstates: this.enableLoadingSubstates
+        });
 
-      The type of the generated controller factory is derived
-      from the context. If the context is an array an array controller
-      is generated, if an object, an object controller otherwise, a basic
-      controller is generated.
+        createRoute(dsl, 'loading');
+        createRoute(dsl, 'error', { path: "/_unused_dummy_error_path_route_" + name + "/:error" });
 
-      @for Ember
-      @method generateController
-      @private
-      @since 1.3.0
-    */
-    __exports__["default"] = function generateController(container, controllerName, context) {
-      generateControllerFactory(container, controllerName, context);
-      var fullName = 'controller:' + controllerName;
-      var instance = container.lookup(fullName);
+        callback.call(dsl);
 
-      if (get(instance, 'namespace.LOG_ACTIVE_GENERATION')) {
-        Ember.Logger.info("generated -> " + fullName, { fullName: fullName });
+        createRoute(this, name, options, dsl.generate());
+      } else {
+        createRoute(this, name, options);
       }
+    },
 
-      return instance;
-    }
-  });
-enifed("ember-routing/system/query_params",
-  ["ember-runtime/system/object","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var EmberObject = __dependency1__["default"];
+    push: function(url, name, callback) {
+      var parts = name.split('.');
+      if (url === "" || url === "/" || parts[parts.length-1] === "index") { this.explicitIndex = true; }
 
-    __exports__["default"] = EmberObject.extend({
-      isQueryParams: true,
-      values: null
-    });
-  });
-enifed("ember-routing/system/route",
-  ["ember-metal/core","ember-metal/error","ember-metal/property_get","ember-metal/property_set","ember-metal/get_properties","ember-metal/enumerable_utils","ember-metal/is_none","ember-metal/computed","ember-metal/merge","ember-metal/utils","ember-metal/run_loop","ember-metal/keys","ember-runtime/copy","ember-runtime/system/string","ember-runtime/system/object","ember-runtime/mixins/evented","ember-runtime/mixins/action_handler","ember-routing/system/generate_controller","ember-routing/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // FEATURES, A, deprecate, assert, Logger
-    var EmberError = __dependency2__["default"];
-    var get = __dependency3__.get;
-    var set = __dependency4__.set;
-    var getProperties = __dependency5__["default"];
-    var forEach = __dependency6__.forEach;
-    var replace = __dependency6__.replace;
-    var isNone = __dependency7__["default"];
-    var computed = __dependency8__.computed;
-    var merge = __dependency9__["default"];
-    var isArray = __dependency10__.isArray;
-    var typeOf = __dependency10__.typeOf;
-    var run = __dependency11__["default"];
-    var keys = __dependency12__["default"];
-    var copy = __dependency13__["default"];
-    var classify = __dependency14__.classify;
-    var EmberObject = __dependency15__["default"];
-    var Evented = __dependency16__["default"];
-    var ActionHandler = __dependency17__["default"];
-    var generateController = __dependency18__["default"];
-    var stashParamNames = __dependency19__.stashParamNames;
+      this.matches.push([url, name, callback]);
+    },
 
-    var slice = Array.prototype.slice;
+    resource: function(name, options, callback) {
+      if (arguments.length === 2 && typeof options === 'function') {
+        callback = options;
+        options = {};
+      }
 
-    function K() { return this; }
+      if (arguments.length === 1) {
+        options = {};
+      }
 
-    /**
-    @module ember
-    @submodule ember-routing
-    */
+      options.resetNamespace = true;
+      this.route(name, options, callback);
+    },
 
-    /**
-      The `Ember.Route` class is used to define individual routes. Refer to
-      the [routing guide](http://emberjs.com/guides/routing/) for documentation.
+    generate: function() {
+      var dslMatches = this.matches;
 
-      @class Route
-      @namespace Ember
-      @extends Ember.Object
-      @uses Ember.ActionHandler
-    */
-    var Route = EmberObject.extend(ActionHandler, {
-      /**
-        Configuration hash for this route's queryParams. The possible
-        configuration options and their defaults are as follows
-        (assuming a query param whose URL key is `page`):
+      if (!this.explicitIndex) {
+        this.route("index", { path: "/" });
+      }
 
-        ```javascript
-        queryParams: {
-          page: {
-            // By default, controller query param properties don't
-            // cause a full transition when they are changed, but
-            // rather only cause the URL to update. Setting
-            // `refreshModel` to true will cause an "in-place"
-            // transition to occur, whereby the model hooks for
-            // this route (and any child routes) will re-fire, allowing
-            // you to reload models (e.g., from the server) using the
-            // updated query param values.
-            refreshModel: false,
-
-            // By default, changes to controller query param properties
-            // cause the URL to update via `pushState`, which means an
-            // item will be added to the browser's history, allowing
-            // you to use the back button to restore the app to the
-            // previous state before the query param property was changed.
-            // Setting `replace` to true will use `replaceState` (or its
-            // hash location equivalent), which causes no browser history
-            // item to be added. This options name and default value are
-            // the same as the `link-to` helper's `replace` option.
-            replace: false
-          }
+      return function(match) {
+        for (var i=0, l=dslMatches.length; i<l; i++) {
+          var dslMatch = dslMatches[i];
+          match(dslMatch[0]).to(dslMatch[1], dslMatch[2]);
         }
-        ```
+      };
+    }
+  };
 
-        @property queryParams
-        @for Ember.Route
-        @type Hash
-      */
-      queryParams: {},
+  function canNest(dsl) {
+    return dsl.parent && dsl.parent !== 'application';
+  }
 
-      /**
-        @private
+  function getFullName(dsl, name, resetNamespace) {
+    if (canNest(dsl) && resetNamespace !== true) {
+      return dsl.parent + "." + name;
+    } else {
+      return name;
+    }
+  }
 
-        @property _qp
-      */
-      _qp: computed(function() {
-        var controllerName = this.controllerName || this.routeName;
-        var controllerClass = this.container.lookupFactory('controller:' + controllerName);
+  function createRoute(dsl, name, options, callback) {
+    options = options || {};
 
-        if (!controllerClass) {
-          return defaultQPMeta;
-        }
+    var fullName = getFullName(dsl, name, options.resetNamespace);
 
-        var controllerProto = controllerClass.proto();
-        var qpProps = get(controllerProto, '_normalizedQueryParams');
-        var cacheMeta = get(controllerProto, '_cacheMeta');
+    if (typeof options.path !== 'string') {
+      options.path = "/" + name;
+    }
 
-        var qps = [], map = {}, self = this;
-        for (var propName in qpProps) {
-          if (!qpProps.hasOwnProperty(propName)) { continue; }
+    dsl.push(options.path, fullName, callback);
+  }
 
-          var desc = qpProps[propName];
-          var urlKey = desc.as || this.serializeQueryParamKey(propName);
-          var defaultValue = get(controllerProto, propName);
+  DSL.map = function(callback) {
+    var dsl = new DSL();
+    callback.call(dsl);
+    return dsl;
+  };
 
-          if (isArray(defaultValue)) {
-            defaultValue = Ember.A(defaultValue.slice());
-          }
+});
+enifed('ember-routing/system/generate_controller', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/utils'], function (exports, Ember, property_get, utils) {
 
-          var type = typeOf(defaultValue);
-          var defaultValueSerialized = this.serializeQueryParam(defaultValue, urlKey, type);
-          var fprop = controllerName + ':' + propName;
-          var qp = {
-            def: defaultValue,
-            sdef: defaultValueSerialized,
-            type: type,
-            urlKey: urlKey,
-            prop: propName,
-            fprop: fprop,
-            ctrl: controllerName,
-            cProto: controllerProto,
-            svalue: defaultValueSerialized,
-            cacheType: desc.scope,
-            route: this,
-            cacheMeta: cacheMeta[propName]
-          };
+  'use strict';
 
-          map[propName] = map[urlKey] = map[fprop] = qp;
-          qps.push(qp);
-        }
+  exports.generateControllerFactory = generateControllerFactory;
 
-        return {
-          qps: qps,
-          map: map,
-          states: {
-            active: function(controller, prop) {
-              return self._activeQPChanged(controller, map[prop]);
-            },
-            allowOverrides: function(controller, prop) {
-              return self._updatingQPChanged(controller, map[prop]);
-            },
-            changingKeys: function(controller, prop) {
-              return self._updateSerializedQPValue(controller, map[prop]);
-            }
-          }
-        };
-      }),
+  function generateControllerFactory(container, controllerName, context) {
+    var Factory, fullName, factoryName, controllerType;
 
-      /**
-        @private
+    if (context && utils.isArray(context)) {
+      controllerType = 'array';
+    } else if (context) {
+      controllerType = 'object';
+    } else {
+      controllerType = 'basic';
+    }
 
-        @property _names
-      */
-      _names: null,
+    factoryName = 'controller:' + controllerType;
 
-      /**
-        @private
+    Factory = container.lookupFactory(factoryName).extend({
+      isGenerated: true,
+      toString: function() {
+        return "(generated " + controllerName + " controller)";
+      }
+    });
 
-        @method _stashNames
-      */
-      _stashNames: function(_handlerInfo, dynamicParent) {
-        var handlerInfo = _handlerInfo;
-        if (this._names) { return; }
-        var names = this._names = handlerInfo._names;
+    fullName = 'controller:' + controllerName;
 
-        if (!names.length) {
-          handlerInfo = dynamicParent;
-          names = handlerInfo && handlerInfo._names || [];
-        }
+    container._registry.register(fullName, Factory);
 
-        var qps = get(this, '_qp.qps');
-        var len = qps.length;
+    return Factory;
+  }
 
-        var namePaths = new Array(names.length);
-        for (var a = 0, nlen = names.length; a < nlen; ++a) {
-          namePaths[a] = handlerInfo.name + '.' + names[a];
-        }
+  /**
+    Generates and instantiates a controller.
 
-        for (var i = 0; i < len; ++i) {
-          var qp = qps[i];
-          var cacheMeta = qp.cacheMeta;
-          if (cacheMeta.scope === 'model') {
-            cacheMeta.parts = namePaths;
-          }
-          cacheMeta.prefix = qp.ctrl;
-        }
-      },
+    The type of the generated controller factory is derived
+    from the context. If the context is an array an array controller
+    is generated, if an object, an object controller otherwise, a basic
+    controller is generated.
 
-      /**
-        @private
+    @for Ember
+    @method generateController
+    @private
+    @since 1.3.0
+  */
+  function generateController(container, controllerName, context) {
+    generateControllerFactory(container, controllerName, context);
+    var fullName = 'controller:' + controllerName;
+    var instance = container.lookup(fullName);
 
-        @property _updateSerializedQPValue
-      */
-      _updateSerializedQPValue: function(controller, qp) {
-        var value = get(controller, qp.prop);
-        qp.svalue = this.serializeQueryParam(value, qp.urlKey, qp.type);
-      },
+    if (property_get.get(instance, 'namespace.LOG_ACTIVE_GENERATION')) {
+      Ember['default'].Logger.info("generated -> " + fullName, { fullName: fullName });
+    }
 
-      /**
-        @private
+    return instance;
+  }
+  exports['default'] = generateController;
 
-        @property _activeQPChanged
-      */
-      _activeQPChanged: function(controller, qp) {
-        var value = get(controller, qp.prop);
-        this.router._queuedQPChanges[qp.fprop] = value;
-        run.once(this, this._fireQueryParamTransition);
-      },
+});
+enifed('ember-routing/system/query_params', ['exports', 'ember-runtime/system/object'], function (exports, EmberObject) {
 
-      /**
-        @private
-        @method _updatingQPChanged
-      */
-      _updatingQPChanged: function(controller, qp) {
-        var router = this.router;
-        if (!router._qpUpdates) {
-          router._qpUpdates = {};
-        }
-        router._qpUpdates[qp.urlKey] = true;
-      },
+  'use strict';
 
-      mergedProperties: ['events', 'queryParams'],
+  exports['default'] = EmberObject['default'].extend({
+    isQueryParams: true,
+    values: null
+  });
 
-      /**
-        Retrieves parameters, for current route using the state.params
-        variable and getQueryParamsFor, using the supplied routeName.
+});
+enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-metal/error', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/get_properties', 'ember-metal/enumerable_utils', 'ember-metal/is_none', 'ember-metal/computed', 'ember-metal/merge', 'ember-metal/utils', 'ember-metal/run_loop', 'ember-metal/keys', 'ember-runtime/copy', 'ember-runtime/system/string', 'ember-runtime/system/object', 'ember-runtime/mixins/evented', 'ember-runtime/mixins/action_handler', 'ember-routing/system/generate_controller', 'ember-routing/utils'], function (exports, Ember, EmberError, property_get, property_set, getProperties, enumerable_utils, isNone, computed, merge, utils, run, keys, copy, string, EmberObject, Evented, ActionHandler, generateController, ember_routing__utils) {
 
-        @method paramsFor
-        @param {String} routename
+  'use strict';
 
-      */
-      paramsFor: function(name) {
-        var route = this.container.lookup('route:' + name);
+  var slice = Array.prototype.slice;
 
-        if (!route) {
-          return {};
-        }
+  function K() { return this; }
 
-        var transition = this.router.router.activeTransition;
-        var state = transition ? transition.state : this.router.router.state;
+  /**
+  @module ember
+  @submodule ember-routing
+  */
 
-        var params = {};
-        merge(params, state.params[name]);
-        merge(params, getQueryParamsFor(route, state));
+  /**
+    The `Ember.Route` class is used to define individual routes. Refer to
+    the [routing guide](http://emberjs.com/guides/routing/) for documentation.
 
-        return params;
-      },
+    @class Route
+    @namespace Ember
+    @extends Ember.Object
+    @uses Ember.ActionHandler
+    @uses Ember.Evented
+  */
+  var Route = EmberObject['default'].extend(ActionHandler['default'], Evented['default'], {
+    /**
+      Configuration hash for this route's queryParams. The possible
+      configuration options and their defaults are as follows
+      (assuming a query param whose URL key is `page`):
+
+      ```javascript
+      queryParams: {
+        page: {
+          // By default, controller query param properties don't
+          // cause a full transition when they are changed, but
+          // rather only cause the URL to update. Setting
+          // `refreshModel` to true will cause an "in-place"
+          // transition to occur, whereby the model hooks for
+          // this route (and any child routes) will re-fire, allowing
+          // you to reload models (e.g., from the server) using the
+          // updated query param values.
+          refreshModel: false,
+
+          // By default, changes to controller query param properties
+          // cause the URL to update via `pushState`, which means an
+          // item will be added to the browser's history, allowing
+          // you to use the back button to restore the app to the
+          // previous state before the query param property was changed.
+          // Setting `replace` to true will use `replaceState` (or its
+          // hash location equivalent), which causes no browser history
+          // item to be added. This options name and default value are
+          // the same as the `link-to` helper's `replace` option.
+          replace: false
+        }
+      }
+      ```
+
+      @property queryParams
+      @for Ember.Route
+      @type Hash
+    */
+    queryParams: {},
 
-      /**
-        Serializes the query parameter key
+    /**
+      @private
 
-        @method serializeQueryParamKey
-        @param {String} controllerPropertyName
-      */
-      serializeQueryParamKey: function(controllerPropertyName) {
-        return controllerPropertyName;
-      },
+      @property _qp
+    */
+    _qp: computed.computed(function() {
+      var controllerName = this.controllerName || this.routeName;
+      var controllerClass = this.container.lookupFactory('controller:' + controllerName);
 
-      /**
-        Serializes value of the query parameter based on defaultValueType
+      if (!controllerClass) {
+        return defaultQPMeta;
+      }
 
-        @method serializeQueryParam
-        @param {Object} value
-        @param {String} urlKey
-        @param {String} defaultValueType
-      */
-      serializeQueryParam: function(value, urlKey, defaultValueType) {
-        // urlKey isn't used here, but anyone overriding
-        // can use it to provide serialization specific
-        // to a certain query param.
-        if (defaultValueType === 'array') {
-          return JSON.stringify(value);
-        }
-        return '' + value;
-      },
+      var controllerProto = controllerClass.proto();
+      var qpProps = property_get.get(controllerProto, '_normalizedQueryParams');
+      var cacheMeta = property_get.get(controllerProto, '_cacheMeta');
 
-      /**
-        Deserializes value of the query parameter based on defaultValueType
+      var qps = [];
+      var map = {};
+      var self = this;
+      for (var propName in qpProps) {
+        if (!qpProps.hasOwnProperty(propName)) { continue; }
 
-        @method deserializeQueryParam
-        @param {Object} value
-        @param {String} urlKey
-        @param {String} defaultValueType
-      */
-      deserializeQueryParam: function(value, urlKey, defaultValueType) {
-        // urlKey isn't used here, but anyone overriding
-        // can use it to provide deserialization specific
-        // to a certain query param.
-
-        // Use the defaultValueType of the default value (the initial value assigned to a
-        // controller query param property), to intelligently deserialize and cast.
-        if (defaultValueType === 'boolean') {
-          return (value === 'true') ? true : false;
-        } else if (defaultValueType === 'number') {
-          return (Number(value)).valueOf();
-        } else if (defaultValueType === 'array') {
-          return Ember.A(JSON.parse(value));
+        var desc = qpProps[propName];
+        var urlKey = desc.as || this.serializeQueryParamKey(propName);
+        var defaultValue = property_get.get(controllerProto, propName);
+
+        if (utils.isArray(defaultValue)) {
+          defaultValue = Ember['default'].A(defaultValue.slice());
         }
-        return value;
-      },
 
+        var type = utils.typeOf(defaultValue);
+        var defaultValueSerialized = this.serializeQueryParam(defaultValue, urlKey, type);
+        var fprop = controllerName + ':' + propName;
+        var qp = {
+          def: defaultValue,
+          sdef: defaultValueSerialized,
+          type: type,
+          urlKey: urlKey,
+          prop: propName,
+          fprop: fprop,
+          ctrl: controllerName,
+          cProto: controllerProto,
+          svalue: defaultValueSerialized,
+          cacheType: desc.scope,
+          route: this,
+          cacheMeta: cacheMeta[propName]
+        };
 
-      /**
-        @private
-        @property _fireQueryParamTransition
-      */
-      _fireQueryParamTransition: function() {
-        this.transitionTo({ queryParams: this.router._queuedQPChanges });
-        this.router._queuedQPChanges = {};
-      },
+        map[propName] = map[urlKey] = map[fprop] = qp;
+        qps.push(qp);
+      }
 
-      /**
-        @private
+      return {
+        qps: qps,
+        map: map,
+        states: {
+          active: function(controller, prop) {
+            return self._activeQPChanged(controller, map[prop]);
+          },
+          allowOverrides: function(controller, prop) {
+            return self._updatingQPChanged(controller, map[prop]);
+          },
+          changingKeys: function(controller, prop) {
+            return self._updateSerializedQPValue(controller, map[prop]);
+          }
+        }
+      };
+    }),
 
-        @property _optionsForQueryParam
-      */
-      _optionsForQueryParam: function(qp) {
-        return get(this, 'queryParams.' + qp.urlKey) || get(this, 'queryParams.' + qp.prop) || {};
-      },
+    /**
+      @private
 
-      /**
-        A hook you can use to reset controller values either when the model
-        changes or the route is exiting.
+      @property _names
+    */
+    _names: null,
 
-        ```javascript
-        App.ArticlesRoute = Ember.Route.extend({
-          // ...
+    /**
+      @private
 
-          resetController: function (controller, isExiting, transition) {
-            if (isExiting) {
-              controller.set('page', 1);
-            }
-          }
-        });
-        ```
+      @method _stashNames
+    */
+    _stashNames: function(_handlerInfo, dynamicParent) {
+      var handlerInfo = _handlerInfo;
+      if (this._names) { return; }
+      var names = this._names = handlerInfo._names;
 
-        @method resetController
-        @param {Controller} controller instance
-        @param {Boolean} isExiting
-        @param {Object} transition
-        @since 1.7.0
-      */
-      resetController: K,
+      if (!names.length) {
+        handlerInfo = dynamicParent;
+        names = handlerInfo && handlerInfo._names || [];
+      }
 
-      /**
-        @private
+      var qps = property_get.get(this, '_qp.qps');
+      var len = qps.length;
 
-        @method exit
-      */
-      exit: function() {
-        this.deactivate();
-        
-          this.trigger('deactivate');
-        
-        this.teardownViews();
-      },
+      var namePaths = new Array(names.length);
+      for (var a = 0, nlen = names.length; a < nlen; ++a) {
+        namePaths[a] = handlerInfo.name + '.' + names[a];
+      }
 
-      /**
-        @private
+      for (var i = 0; i < len; ++i) {
+        var qp = qps[i];
+        var cacheMeta = qp.cacheMeta;
+        if (cacheMeta.scope === 'model') {
+          cacheMeta.parts = namePaths;
+        }
+        cacheMeta.prefix = qp.ctrl;
+      }
+    },
 
-        @method _reset
-        @since 1.7.0
-      */
-      _reset: function(isExiting, transition) {
-        var controller = this.controller;
+    /**
+      @private
 
-        controller._qpDelegate = get(this, '_qp.states.inactive');
+      @property _updateSerializedQPValue
+    */
+    _updateSerializedQPValue: function(controller, qp) {
+      var value = property_get.get(controller, qp.prop);
+      qp.svalue = this.serializeQueryParam(value, qp.urlKey, qp.type);
+    },
 
-        this.resetController(controller, isExiting, transition);
-      },
+    /**
+      @private
 
-      /**
-        @private
+      @property _activeQPChanged
+    */
+    _activeQPChanged: function(controller, qp) {
+      var value = property_get.get(controller, qp.prop);
+      this.router._queuedQPChanges[qp.fprop] = value;
+      run['default'].once(this, this._fireQueryParamTransition);
+    },
 
-        @method enter
-      */
-      enter: function() {
-        this.activate();
-        
-          this.trigger('activate');
-        
-      },
+    /**
+      @private
+      @method _updatingQPChanged
+    */
+    _updatingQPChanged: function(controller, qp) {
+      var router = this.router;
+      if (!router._qpUpdates) {
+        router._qpUpdates = {};
+      }
+      router._qpUpdates[qp.urlKey] = true;
+    },
 
-      /**
-        The name of the view to use by default when rendering this routes template.
+    mergedProperties: ['events', 'queryParams'],
 
-        When rendering a template, the route will, by default, determine the
-        template and view to use from the name of the route itself. If you need to
-        define a specific view, set this property.
+    /**
+      Retrieves parameters, for current route using the state.params
+      variable and getQueryParamsFor, using the supplied routeName.
 
-        This is useful when multiple routes would benefit from using the same view
-        because it doesn't require a custom `renderTemplate` method. For example,
-        the following routes will all render using the `App.PostsListView` view:
+      @method paramsFor
+      @param {String} name
 
-        ```javascript
-        var PostsList = Ember.Route.extend({
-          viewName: 'postsList'
-        });
+    */
+    paramsFor: function(name) {
+      var route = this.container.lookup('route:' + name);
 
-        App.PostsIndexRoute = PostsList.extend();
-        App.PostsArchivedRoute = PostsList.extend();
-        ```
+      if (!route) {
+        return {};
+      }
 
-        @property viewName
-        @type String
-        @default null
-        @since 1.4.0
-      */
-      viewName: null,
+      var transition = this.router.router.activeTransition;
+      var state = transition ? transition.state : this.router.router.state;
 
-      /**
-        The name of the template to use by default when rendering this routes
-        template.
+      var params = {};
+      merge['default'](params, state.params[name]);
+      merge['default'](params, getQueryParamsFor(route, state));
 
-        This is similar with `viewName`, but is useful when you just want a custom
-        template without a view.
+      return params;
+    },
 
-        ```javascript
-        var PostsList = Ember.Route.extend({
-          templateName: 'posts/list'
-        });
+    /**
+      Serializes the query parameter key
 
-        App.PostsIndexRoute = PostsList.extend();
-        App.PostsArchivedRoute = PostsList.extend();
-        ```
+      @method serializeQueryParamKey
+      @param {String} controllerPropertyName
+    */
+    serializeQueryParamKey: function(controllerPropertyName) {
+      return controllerPropertyName;
+    },
 
-        @property templateName
-        @type String
-        @default null
-        @since 1.4.0
-      */
-      templateName: null,
+    /**
+      Serializes value of the query parameter based on defaultValueType
 
-      /**
-        The name of the controller to associate with this route.
+      @method serializeQueryParam
+      @param {Object} value
+      @param {String} urlKey
+      @param {String} defaultValueType
+    */
+    serializeQueryParam: function(value, urlKey, defaultValueType) {
+      // urlKey isn't used here, but anyone overriding
+      // can use it to provide serialization specific
+      // to a certain query param.
+      if (defaultValueType === 'array') {
+        return JSON.stringify(value);
+      }
+      return '' + value;
+    },
 
-        By default, Ember will lookup a route's controller that matches the name
-        of the route (i.e. `App.PostController` for `App.PostRoute`). However,
-        if you would like to define a specific controller to use, you can do so
-        using this property.
+    /**
+      Deserializes value of the query parameter based on defaultValueType
 
-        This is useful in many ways, as the controller specified will be:
+      @method deserializeQueryParam
+      @param {Object} value
+      @param {String} urlKey
+      @param {String} defaultValueType
+    */
+    deserializeQueryParam: function(value, urlKey, defaultValueType) {
+      // urlKey isn't used here, but anyone overriding
+      // can use it to provide deserialization specific
+      // to a certain query param.
 
-        * passed to the `setupController` method.
-        * used as the controller for the view being rendered by the route.
-        * returned from a call to `controllerFor` for the route.
+      // Use the defaultValueType of the default value (the initial value assigned to a
+      // controller query param property), to intelligently deserialize and cast.
+      if (defaultValueType === 'boolean') {
+        return (value === 'true') ? true : false;
+      } else if (defaultValueType === 'number') {
+        return (Number(value)).valueOf();
+      } else if (defaultValueType === 'array') {
+        return Ember['default'].A(JSON.parse(value));
+      }
+      return value;
+    },
 
-        @property controllerName
-        @type String
-        @default null
-        @since 1.4.0
-      */
-      controllerName: null,
 
-      /**
-        The `willTransition` action is fired at the beginning of any
-        attempted transition with a `Transition` object as the sole
-        argument. This action can be used for aborting, redirecting,
-        or decorating the transition from the currently active routes.
+    /**
+      @private
+      @property _fireQueryParamTransition
+    */
+    _fireQueryParamTransition: function() {
+      this.transitionTo({ queryParams: this.router._queuedQPChanges });
+      this.router._queuedQPChanges = {};
+    },
 
-        A good example is preventing navigation when a form is
-        half-filled out:
+    /**
+      @private
 
-        ```javascript
-        App.ContactFormRoute = Ember.Route.extend({
-          actions: {
-            willTransition: function(transition) {
-              if (this.controller.get('userHasEnteredData')) {
-                this.controller.displayNavigationConfirm();
-                transition.abort();
-              }
-            }
-          }
-        });
-        ```
+      @property _optionsForQueryParam
+    */
+    _optionsForQueryParam: function(qp) {
+      return property_get.get(this, 'queryParams.' + qp.urlKey) || property_get.get(this, 'queryParams.' + qp.prop) || {};
+    },
 
-        You can also redirect elsewhere by calling
-        `this.transitionTo('elsewhere')` from within `willTransition`.
-        Note that `willTransition` will not be fired for the
-        redirecting `transitionTo`, since `willTransition` doesn't
-        fire when there is already a transition underway. If you want
-        subsequent `willTransition` actions to fire for the redirecting
-        transition, you must first explicitly call
-        `transition.abort()`.
-
-        @event willTransition
-        @param {Transition} transition
-      */
+    /**
+      A hook you can use to reset controller values either when the model
+      changes or the route is exiting.
 
-      /**
-        The `didTransition` action is fired after a transition has
-        successfully been completed. This occurs after the normal model
-        hooks (`beforeModel`, `model`, `afterModel`, `setupController`)
-        have resolved. The `didTransition` action has no arguments,
-        however, it can be useful for tracking page views or resetting
-        state on the controller.
+      ```javascript
+      App.ArticlesRoute = Ember.Route.extend({
+        // ...
 
-        ```javascript
-        App.LoginRoute = Ember.Route.extend({
-          actions: {
-            didTransition: function() {
-              this.controller.get('errors.base').clear();
-              return true; // Bubble the didTransition event
-            }
+        resetController: function (controller, isExiting, transition) {
+          if (isExiting) {
+            controller.set('page', 1);
           }
-        });
-        ```
+        }
+      });
+      ```
+
+      @method resetController
+      @param {Controller} controller instance
+      @param {Boolean} isExiting
+      @param {Object} transition
+      @since 1.7.0
+    */
+    resetController: K,
+
+    /**
+      @private
 
-        @event didTransition
-        @since 1.2.0
-      */
+      @method exit
+    */
+    exit: function() {
+      this.deactivate();
+      this.trigger('deactivate');
+      this.teardownViews();
+    },
 
-      /**
-        The `loading` action is fired on the route when a route's `model`
-        hook returns a promise that is not already resolved. The current
-        `Transition` object is the first parameter and the route that
-        triggered the loading event is the second parameter.
+    /**
+      @private
 
-        ```javascript
-        App.ApplicationRoute = Ember.Route.extend({
-          actions: {
-            loading: function(transition, route) {
-              var view = Ember.View.create({
-                classNames: ['app-loading']
-              })
-              .append();
-
-              this.router.one('didTransition', function() {
-                view.destroy();
-              });
+      @method _reset
+      @since 1.7.0
+    */
+    _reset: function(isExiting, transition) {
+      var controller = this.controller;
 
-              return true; // Bubble the loading event
-            }
-          }
-        });
-        ```
+      controller._qpDelegate = property_get.get(this, '_qp.states.inactive');
 
-        @event loading
-        @param {Transition} transition
-        @param {Ember.Route} route The route that triggered the loading event
-        @since 1.2.0
-      */
+      this.resetController(controller, isExiting, transition);
+    },
 
-      /**
-        When attempting to transition into a route, any of the hooks
-        may return a promise that rejects, at which point an `error`
-        action will be fired on the partially-entered routes, allowing
-        for per-route error handling logic, or shared error handling
-        logic defined on a parent route.
+    /**
+      @private
 
-        Here is an example of an error handler that will be invoked
-        for rejected promises from the various hooks on the route,
-        as well as any unhandled errors from child routes:
+      @method enter
+    */
+    enter: function() {
+      this.connections = [];
+      this.activate();
+      this.trigger('activate');
+    },
 
-        ```javascript
-        App.AdminRoute = Ember.Route.extend({
-          beforeModel: function() {
-            return Ember.RSVP.reject('bad things!');
-          },
+    /**
+      The name of the view to use by default when rendering this routes template.
 
-          actions: {
-            error: function(error, transition) {
-              // Assuming we got here due to the error in `beforeModel`,
-              // we can expect that error === "bad things!",
-              // but a promise model rejecting would also
-              // call this hook, as would any errors encountered
-              // in `afterModel`.
+      When rendering a template, the route will, by default, determine the
+      template and view to use from the name of the route itself. If you need to
+      define a specific view, set this property.
 
-              // The `error` hook is also provided the failed
-              // `transition`, which can be stored and later
-              // `.retry()`d if desired.
+      This is useful when multiple routes would benefit from using the same view
+      because it doesn't require a custom `renderTemplate` method. For example,
+      the following routes will all render using the `App.PostsListView` view:
 
-              this.transitionTo('login');
-            }
-          }
-        });
-        ```
+      ```javascript
+      var PostsList = Ember.Route.extend({
+        viewName: 'postsList'
+      });
 
-        `error` actions that bubble up all the way to `ApplicationRoute`
-        will fire a default error handler that logs the error. You can
-        specify your own global default error handler by overriding the
-        `error` handler on `ApplicationRoute`:
+      App.PostsIndexRoute = PostsList.extend();
+      App.PostsArchivedRoute = PostsList.extend();
+      ```
 
-        ```javascript
-        App.ApplicationRoute = Ember.Route.extend({
-          actions: {
-            error: function(error, transition) {
-              this.controllerFor('banner').displayError(error.message);
-            }
-          }
-        });
-        ```
-        @event error
-        @param {Error} error
-        @param {Transition} transition
-      */
+      @property viewName
+      @type String
+      @default null
+      @since 1.4.0
+    */
+    viewName: null,
 
-      /**
-        The controller associated with this route.
+    /**
+      The name of the template to use by default when rendering this routes
+      template.
 
-        Example
+      This is similar with `viewName`, but is useful when you just want a custom
+      template without a view.
 
-        ```javascript
-        App.FormRoute = Ember.Route.extend({
-          actions: {
-            willTransition: function(transition) {
-              if (this.controller.get('userHasEnteredData') &&
-                  !confirm('Are you sure you want to abandon progress?')) {
-                transition.abort();
-              } else {
-                // Bubble the `willTransition` action so that
-                // parent routes can decide whether or not to abort.
-                return true;
-              }
-            }
-          }
-        });
-        ```
+      ```javascript
+      var PostsList = Ember.Route.extend({
+        templateName: 'posts/list'
+      });
 
-        @property controller
-        @type Ember.Controller
-        @since 1.6.0
-      */
+      App.PostsIndexRoute = PostsList.extend();
+      App.PostsArchivedRoute = PostsList.extend();
+      ```
 
-      _actions: {
+      @property templateName
+      @type String
+      @default null
+      @since 1.4.0
+    */
+    templateName: null,
 
-        queryParamsDidChange: function(changed, totalPresent, removed) {
-          var qpMap = get(this, '_qp').map;
+    /**
+      The name of the controller to associate with this route.
 
-          var totalChanged = keys(changed).concat(keys(removed));
-          for (var i = 0, len = totalChanged.length; i < len; ++i) {
-            var qp = qpMap[totalChanged[i]];
-            if (qp && get(this._optionsForQueryParam(qp), 'refreshModel')) {
-              this.refresh();
-            }
-          }
+      By default, Ember will lookup a route's controller that matches the name
+      of the route (i.e. `App.PostController` for `App.PostRoute`). However,
+      if you would like to define a specific controller to use, you can do so
+      using this property.
 
-          return true;
-        },
+      This is useful in many ways, as the controller specified will be:
 
-        finalizeQueryParamChange: function(params, finalParams, transition) {
-          if (this.routeName !== 'application') { return true; }
-
-          // Transition object is absent for intermediate transitions.
-          if (!transition) { return; }
-
-          var handlerInfos = transition.state.handlerInfos;
-          var router = this.router;
-          var qpMeta = router._queryParamsFor(handlerInfos[handlerInfos.length-1].name);
-          var changes = router._qpUpdates;
-          var replaceUrl;
-
-          stashParamNames(router, handlerInfos);
-
-          for (var i = 0, len = qpMeta.qps.length; i < len; ++i) {
-            var qp = qpMeta.qps[i];
-            var route = qp.route;
-            var controller = route.controller;
-            var presentKey = qp.urlKey in params && qp.urlKey;
-
-            // Do a reverse lookup to see if the changed query
-            // param URL key corresponds to a QP property on
-            // this controller.
-            var value, svalue;
-            if (changes && qp.urlKey in changes) {
-              // Value updated in/before setupController
-              value = get(controller, qp.prop);
-              svalue = route.serializeQueryParam(value, qp.urlKey, qp.type);
-            } else {
-              if (presentKey) {
-                svalue = params[presentKey];
-                value = route.deserializeQueryParam(svalue, qp.urlKey, qp.type);
-              } else {
-                // No QP provided; use default value.
-                svalue = qp.sdef;
-                value = copyDefaultValue(qp.def);
-              }
-            }
+      * passed to the `setupController` method.
+      * used as the controller for the view being rendered by the route.
+      * returned from a call to `controllerFor` for the route.
 
-            controller._qpDelegate = get(this, '_qp.states.inactive');
-
-            var thisQueryParamChanged = (svalue !== qp.svalue);
-            if (thisQueryParamChanged) {
-              if (transition.queryParamsOnly && replaceUrl !== false) {
-                var options = route._optionsForQueryParam(qp);
-                var replaceConfigValue = get(options, 'replace');
-                if (replaceConfigValue) {
-                  replaceUrl = true;
-                } else if (replaceConfigValue === false) {
-                  // Explicit pushState wins over any other replaceStates.
-                  replaceUrl = false;
-                }
-              }
+      @property controllerName
+      @type String
+      @default null
+      @since 1.4.0
+    */
+    controllerName: null,
 
-              set(controller, qp.prop, value);
-            }
+    /**
+      The `willTransition` action is fired at the beginning of any
+      attempted transition with a `Transition` object as the sole
+      argument. This action can be used for aborting, redirecting,
+      or decorating the transition from the currently active routes.
 
-            // Stash current serialized value of controller.
-            qp.svalue = svalue;
+      A good example is preventing navigation when a form is
+      half-filled out:
 
-            var thisQueryParamHasDefaultValue = (qp.sdef === svalue);
-            if (!thisQueryParamHasDefaultValue) {
-              finalParams.push({
-                value: svalue,
-                visible: true,
-                key: presentKey || qp.urlKey
-              });
+      ```javascript
+      App.ContactFormRoute = Ember.Route.extend({
+        actions: {
+          willTransition: function(transition) {
+            if (this.controller.get('userHasEnteredData')) {
+              this.controller.displayNavigationConfirm();
+              transition.abort();
             }
           }
+        }
+      });
+      ```
 
-          if (replaceUrl) {
-            transition.method('replace');
-          }
+      You can also redirect elsewhere by calling
+      `this.transitionTo('elsewhere')` from within `willTransition`.
+      Note that `willTransition` will not be fired for the
+      redirecting `transitionTo`, since `willTransition` doesn't
+      fire when there is already a transition underway. If you want
+      subsequent `willTransition` actions to fire for the redirecting
+      transition, you must first explicitly call
+      `transition.abort()`.
 
-          forEach(qpMeta.qps, function(qp) {
-            var routeQpMeta = get(qp.route, '_qp');
-            var finalizedController = qp.route.controller;
-            finalizedController._qpDelegate = get(routeQpMeta, 'states.active');
-          });
+      @event willTransition
+      @param {Transition} transition
+    */
 
-          router._qpUpdates = null;
-        }
-      },
+    /**
+      The `didTransition` action is fired after a transition has
+      successfully been completed. This occurs after the normal model
+      hooks (`beforeModel`, `model`, `afterModel`, `setupController`)
+      have resolved. The `didTransition` action has no arguments,
+      however, it can be useful for tracking page views or resetting
+      state on the controller.
 
-      /**
-        @deprecated
+      ```javascript
+      App.LoginRoute = Ember.Route.extend({
+        actions: {
+          didTransition: function() {
+            this.controller.get('errors.base').clear();
+            return true; // Bubble the didTransition event
+          }
+        }
+      });
+      ```
 
-        Please use `actions` instead.
-        @method events
-      */
-      events: null,
+      @event didTransition
+      @since 1.2.0
+    */
 
-      /**
-        This hook is executed when the router completely exits this route. It is
-        not executed when the model for the route changes.
+    /**
+      The `loading` action is fired on the route when a route's `model`
+      hook returns a promise that is not already resolved. The current
+      `Transition` object is the first parameter and the route that
+      triggered the loading event is the second parameter.
 
-        @method deactivate
-      */
-      deactivate: K,
+      ```javascript
+      App.ApplicationRoute = Ember.Route.extend({
+        actions: {
+          loading: function(transition, route) {
+            var view = Ember.View.create({
+              classNames: ['app-loading']
+            })
+            .append();
 
-      /**
-        This hook is executed when the router enters the route. It is not executed
-        when the model for the route changes.
+            this.router.one('didTransition', function() {
+              view.destroy();
+            });
 
-        @method activate
-      */
-      activate: K,
+            return true; // Bubble the loading event
+          }
+        }
+      });
+      ```
 
-      /**
-        Transition the application into another route. The route may
-        be either a single route or route path:
+      @event loading
+      @param {Transition} transition
+      @param {Ember.Route} route The route that triggered the loading event
+      @since 1.2.0
+    */
 
-        ```javascript
-        this.transitionTo('blogPosts');
-        this.transitionTo('blogPosts.recentEntries');
-        ```
+    /**
+      When attempting to transition into a route, any of the hooks
+      may return a promise that rejects, at which point an `error`
+      action will be fired on the partially-entered routes, allowing
+      for per-route error handling logic, or shared error handling
+      logic defined on a parent route.
 
-        Optionally supply a model for the route in question. The model
-        will be serialized into the URL using the `serialize` hook of
-        the route:
+      Here is an example of an error handler that will be invoked
+      for rejected promises from the various hooks on the route,
+      as well as any unhandled errors from child routes:
 
-        ```javascript
-        this.transitionTo('blogPost', aPost);
-        ```
+      ```javascript
+      App.AdminRoute = Ember.Route.extend({
+        beforeModel: function() {
+          return Ember.RSVP.reject('bad things!');
+        },
 
-        If a literal is passed (such as a number or a string), it will
-        be treated as an identifier instead. In this case, the `model`
-        hook of the route will be triggered:
+        actions: {
+          error: function(error, transition) {
+            // Assuming we got here due to the error in `beforeModel`,
+            // we can expect that error === "bad things!",
+            // but a promise model rejecting would also
+            // call this hook, as would any errors encountered
+            // in `afterModel`.
 
-        ```javascript
-        this.transitionTo('blogPost', 1);
-        ```
+            // The `error` hook is also provided the failed
+            // `transition`, which can be stored and later
+            // `.retry()`d if desired.
 
-        Multiple models will be applied last to first recursively up the
-        resource tree.
+            this.transitionTo('login');
+          }
+        }
+      });
+      ```
 
-        ```javascript
-        App.Router.map(function() {
-          this.resource('blogPost', { path:':blogPostId' }, function() {
-            this.resource('blogComment', { path: ':blogCommentId' });
-          });
-        });
+      `error` actions that bubble up all the way to `ApplicationRoute`
+      will fire a default error handler that logs the error. You can
+      specify your own global default error handler by overriding the
+      `error` handler on `ApplicationRoute`:
 
-        this.transitionTo('blogComment', aPost, aComment);
-        this.transitionTo('blogComment', 1, 13);
-        ```
+      ```javascript
+      App.ApplicationRoute = Ember.Route.extend({
+        actions: {
+          error: function(error, transition) {
+            this.controllerFor('banner').displayError(error.message);
+          }
+        }
+      });
+      ```
+      @event error
+      @param {Error} error
+      @param {Transition} transition
+    */
 
-        It is also possible to pass a URL (a string that starts with a
-        `/`). This is intended for testing and debugging purposes and
-        should rarely be used in production code.
+    /**
+      This event is triggered when the router enters the route. It is
+      not executed when the model for the route changes.
 
-        ```javascript
-        this.transitionTo('/');
-        this.transitionTo('/blog/post/1/comment/13');
-        this.transitionTo('/blog/posts?sort=title');
-        ```
+      ```javascript
+      App.ApplicationRoute = Ember.Route.extend({
+        collectAnalytics: function(){
+          collectAnalytics();
+        }.on('activate')
+      });
+      ```
 
-        An options hash with a `queryParams` property may be provided as
-        the final argument to add query parameters to the destination URL.
+      @event activate
+      @since 1.9.0
+    */
 
-        ```javascript
-        this.transitionTo('blogPost', 1, {
-          queryParams: {showComments: 'true'}
-        });
+    /**
+      This event is triggered when the router completely exits this
+      route. It is not executed when the model for the route changes.
 
-        // if you just want to transition the query parameters without changing the route
-        this.transitionTo({queryParams: {sort: 'date'}});
-        ```
+      ```javascript
+      App.IndexRoute = Ember.Route.extend({
+        trackPageLeaveAnalytics: function(){
+          trackPageLeaveAnalytics();
+        }.on('deactivate')
+      });
+      ```
 
-        See also 'replaceWith'.
+      @event deactivate
+      @since 1.9.0
+    */
 
-        Simple Transition Example
+    /**
+      The controller associated with this route.
 
-        ```javascript
-        App.Router.map(function() {
-          this.route('index');
-          this.route('secret');
-          this.route('fourOhFour', { path: '*:' });
-        });
+      Example
 
-        App.IndexRoute = Ember.Route.extend({
-          actions: {
-            moveToSecret: function(context) {
-              if (authorized()) {
-                this.transitionTo('secret', context);
-              } else {
-                this.transitionTo('fourOhFour');
-              }
+      ```javascript
+      App.FormRoute = Ember.Route.extend({
+        actions: {
+          willTransition: function(transition) {
+            if (this.controller.get('userHasEnteredData') &&
+                !confirm('Are you sure you want to abandon progress?')) {
+              transition.abort();
+            } else {
+              // Bubble the `willTransition` action so that
+              // parent routes can decide whether or not to abort.
+              return true;
             }
           }
-        });
-        ```
+        }
+      });
+      ```
 
-        Transition to a nested route
+      @property controller
+      @type Ember.Controller
+      @since 1.6.0
+    */
 
-        ```javascript
-        App.Router.map(function() {
-          this.resource('articles', { path: '/articles' }, function() {
-            this.route('new');
-          });
-        });
+    _actions: {
 
-        App.IndexRoute = Ember.Route.extend({
-          actions: {
-            transitionToNewArticle: function() {
-              this.transitionTo('articles.new');
-            }
-          }
-        });
-        ```
+      queryParamsDidChange: function(changed, totalPresent, removed) {
+        var qpMap = property_get.get(this, '_qp').map;
 
-        Multiple Models Example
+        var totalChanged = keys['default'](changed).concat(keys['default'](removed));
+        for (var i = 0, len = totalChanged.length; i < len; ++i) {
+          var qp = qpMap[totalChanged[i]];
+          if (qp && property_get.get(this._optionsForQueryParam(qp), 'refreshModel')) {
+            this.refresh();
+          }
+        }
 
-        ```javascript
-        App.Router.map(function() {
-          this.route('index');
+        return true;
+      },
 
-          this.resource('breakfast', { path: ':breakfastId' }, function() {
-            this.resource('cereal', { path: ':cerealId' });
-          });
-        });
+      finalizeQueryParamChange: function(params, finalParams, transition) {
+        if (this.routeName !== 'application') { return true; }
 
-        App.IndexRoute = Ember.Route.extend({
-          actions: {
-            moveToChocolateCereal: function() {
-              var cereal = { cerealId: 'ChocolateYumminess' };
-              var breakfast = { breakfastId: 'CerealAndMilk' };
+        // Transition object is absent for intermediate transitions.
+        if (!transition) { return; }
 
-              this.transitionTo('cereal', breakfast, cereal);
+        var handlerInfos = transition.state.handlerInfos;
+        var router = this.router;
+        var qpMeta = router._queryParamsFor(handlerInfos[handlerInfos.length-1].name);
+        var changes = router._qpUpdates;
+        var replaceUrl;
+
+        ember_routing__utils.stashParamNames(router, handlerInfos);
+
+        for (var i = 0, len = qpMeta.qps.length; i < len; ++i) {
+          var qp = qpMeta.qps[i];
+          var route = qp.route;
+          var controller = route.controller;
+          var presentKey = qp.urlKey in params && qp.urlKey;
+
+          // Do a reverse lookup to see if the changed query
+          // param URL key corresponds to a QP property on
+          // this controller.
+          var value, svalue;
+          if (changes && qp.urlKey in changes) {
+            // Value updated in/before setupController
+            value = property_get.get(controller, qp.prop);
+            svalue = route.serializeQueryParam(value, qp.urlKey, qp.type);
+          } else {
+            if (presentKey) {
+              svalue = params[presentKey];
+              value = route.deserializeQueryParam(svalue, qp.urlKey, qp.type);
+            } else {
+              // No QP provided; use default value.
+              svalue = qp.sdef;
+              value = copyDefaultValue(qp.def);
             }
           }
-        });
-        ```
 
-        Nested Route with Query String Example
-
-        ```javascript
-        App.Router.map(function() {
-          this.resource('fruits', function() {
-            this.route('apples');
-          });
-        });
+          controller._qpDelegate = property_get.get(this, '_qp.states.inactive');
 
-        App.IndexRoute = Ember.Route.extend({
-          actions: {
-            transitionToApples: function() {
-              this.transitionTo('fruits.apples', {queryParams: {color: 'red'}});
+          var thisQueryParamChanged = (svalue !== qp.svalue);
+          if (thisQueryParamChanged) {
+            if (transition.queryParamsOnly && replaceUrl !== false) {
+              var options = route._optionsForQueryParam(qp);
+              var replaceConfigValue = property_get.get(options, 'replace');
+              if (replaceConfigValue) {
+                replaceUrl = true;
+              } else if (replaceConfigValue === false) {
+                // Explicit pushState wins over any other replaceStates.
+                replaceUrl = false;
+              }
             }
-          }
-        });
-        ```
-
-        @method transitionTo
-        @param {String} name the name of the route or a URL
-        @param {...Object} models the model(s) or identifier(s) to be used while
-          transitioning to the route.
-        @param {Object} [options] optional hash with a queryParams property
-          containing a mapping of query parameters
-        @return {Transition} the transition object associated with this
-          attempted transition
-      */
-      transitionTo: function(name, context) {
-        var router = this.router;
-        return router.transitionTo.apply(router, arguments);
-      },
 
-      /**
-        Perform a synchronous transition into another route without attempting
-        to resolve promises, update the URL, or abort any currently active
-        asynchronous transitions (i.e. regular transitions caused by
-        `transitionTo` or URL changes).
+            property_set.set(controller, qp.prop, value);
+          }
 
-        This method is handy for performing intermediate transitions on the
-        way to a final destination route, and is called internally by the
-        default implementations of the `error` and `loading` handlers.
+          // Stash current serialized value of controller.
+          qp.svalue = svalue;
 
-        @method intermediateTransitionTo
-        @param {String} name the name of the route
-        @param {...Object} models the model(s) to be used while transitioning
-        to the route.
-        @since 1.2.0
-       */
-      intermediateTransitionTo: function() {
-        var router = this.router;
-        router.intermediateTransitionTo.apply(router, arguments);
-      },
+          var thisQueryParamHasDefaultValue = (qp.sdef === svalue);
+          if (!thisQueryParamHasDefaultValue) {
+            finalParams.push({
+              value: svalue,
+              visible: true,
+              key: presentKey || qp.urlKey
+            });
+          }
+        }
 
-      /**
-        Refresh the model on this route and any child routes, firing the
-        `beforeModel`, `model`, and `afterModel` hooks in a similar fashion
-        to how routes are entered when transitioning in from other route.
-        The current route params (e.g. `article_id`) will be passed in
-        to the respective model hooks, and if a different model is returned,
-        `setupController` and associated route hooks will re-fire as well.
-
-        An example usage of this method is re-querying the server for the
-        latest information using the same parameters as when the route
-        was first entered.
-
-        Note that this will cause `model` hooks to fire even on routes
-        that were provided a model object when the route was initially
-        entered.
-
-        @method refresh
-        @return {Transition} the transition object associated with this
-          attempted transition
-        @since 1.4.0
-       */
-      refresh: function() {
-        return this.router.router.refresh(this);
-      },
+        if (replaceUrl) {
+          transition.method('replace');
+        }
 
-      /**
-        Transition into another route while replacing the current URL, if possible.
-        This will replace the current history entry instead of adding a new one.
-        Beside that, it is identical to `transitionTo` in all other respects. See
-        'transitionTo' for additional information regarding multiple models.
+        enumerable_utils.forEach(qpMeta.qps, function(qp) {
+          var routeQpMeta = property_get.get(qp.route, '_qp');
+          var finalizedController = qp.route.controller;
+          finalizedController._qpDelegate = property_get.get(routeQpMeta, 'states.active');
+        });
 
-        Example
+        router._qpUpdates = null;
+      }
+    },
 
-        ```javascript
-        App.Router.map(function() {
-          this.route('index');
-          this.route('secret');
-        });
+    /**
+      @deprecated
 
-        App.SecretRoute = Ember.Route.extend({
-          afterModel: function() {
-            if (!authorized()){
-              this.replaceWith('index');
-            }
-          }
-        });
-        ```
+      Please use `actions` instead.
+      @method events
+    */
+    events: null,
 
-        @method replaceWith
-        @param {String} name the name of the route or a URL
-        @param {...Object} models the model(s) or identifier(s) to be used while
-          transitioning to the route.
-        @return {Transition} the transition object associated with this
-          attempted transition
-      */
-      replaceWith: function() {
-        var router = this.router;
-        return router.replaceWith.apply(router, arguments);
-      },
+    /**
+      This hook is executed when the router completely exits this route. It is
+      not executed when the model for the route changes.
 
-      /**
-        Sends an action to the router, which will delegate it to the currently
-        active route hierarchy per the bubbling rules explained under `actions`.
+      @method deactivate
+    */
+    deactivate: K,
 
-        Example
+    /**
+      This hook is executed when the router enters the route. It is not executed
+      when the model for the route changes.
 
-        ```javascript
-        App.Router.map(function() {
-          this.route('index');
-        });
+      @method activate
+    */
+    activate: K,
 
-        App.ApplicationRoute = Ember.Route.extend({
-          actions: {
-            track: function(arg) {
-              console.log(arg, 'was clicked');
-            }
-          }
-        });
+    /**
+      Transition the application into another route. The route may
+      be either a single route or route path:
 
-        App.IndexRoute = Ember.Route.extend({
-          actions: {
-            trackIfDebug: function(arg) {
-              if (debug) {
-                this.send('track', arg);
-              }
-            }
-          }
-        });
-        ```
+      ```javascript
+      this.transitionTo('blogPosts');
+      this.transitionTo('blogPosts.recentEntries');
+      ```
 
-        @method send
-        @param {String} name the name of the action to trigger
-        @param {...*} args
-      */
-      send: function() {
-        if (this.router || !Ember.testing) {
-          this.router.send.apply(this.router, arguments);
-        } else {
-          var name = arguments[0];
-          var args = slice.call(arguments, 1);
-          var action = this._actions[name];
-          if (action) {
-            return this._actions[name].apply(this, args);
-          }
-        }
-      },
+      Optionally supply a model for the route in question. The model
+      will be serialized into the URL using the `serialize` hook of
+      the route:
 
-      /**
-        This hook is the entry point for router.js
+      ```javascript
+      this.transitionTo('blogPost', aPost);
+      ```
 
-        @private
-        @method setup
-      */
-      setup: function(context, transition) {
-        var controllerName = this.controllerName || this.routeName;
-        var controller = this.controllerFor(controllerName, true);
+      If a literal is passed (such as a number or a string), it will
+      be treated as an identifier instead. In this case, the `model`
+      hook of the route will be triggered:
 
-        if (!controller) {
-          controller =  this.generateController(controllerName, context);
-        }
+      ```javascript
+      this.transitionTo('blogPost', 1);
+      ```
 
-        // Assign the route's controller so that it can more easily be
-        // referenced in action handlers
-        this.controller = controller;
+      Multiple models will be applied last to first recursively up the
+      resource tree.
 
-        if (this.setupControllers) {
-          Ember.deprecate("Ember.Route.setupControllers is deprecated. Please use Ember.Route.setupController(controller, model) instead.");
-          this.setupControllers(controller, context);
-        } else {
-          var states = get(this, '_qp.states');
-          if (transition) {
-            // Update the model dep values used to calculate cache keys.
-            stashParamNames(this.router, transition.state.handlerInfos);
-            controller._qpDelegate = states.changingKeys;
-            controller._updateCacheParams(transition.params);
-          }
-          controller._qpDelegate = states.allowOverrides;
+      ```javascript
+      App.Router.map(function() {
+        this.resource('blogPost', { path:':blogPostId' }, function() {
+          this.resource('blogComment', { path: ':blogCommentId' });
+        });
+      });
 
-          if (transition) {
-            var qpValues = getQueryParamsFor(this, transition.state);
-            controller.setProperties(qpValues);
-          }
+      this.transitionTo('blogComment', aPost, aComment);
+      this.transitionTo('blogComment', 1, 13);
+      ```
 
-          this.setupController(controller, context, transition);
-        }
+      It is also possible to pass a URL (a string that starts with a
+      `/`). This is intended for testing and debugging purposes and
+      should rarely be used in production code.
 
-        if (this.renderTemplates) {
-          Ember.deprecate("Ember.Route.renderTemplates is deprecated. Please use Ember.Route.renderTemplate(controller, model) instead.");
-          this.renderTemplates(context);
-        } else {
-          this.renderTemplate(controller, context);
-        }
-      },
+      ```javascript
+      this.transitionTo('/');
+      this.transitionTo('/blog/post/1/comment/13');
+      this.transitionTo('/blog/posts?sort=title');
+      ```
 
-      /**
-        This hook is the first of the route entry validation hooks
-        called when an attempt is made to transition into a route
-        or one of its children. It is called before `model` and
-        `afterModel`, and is appropriate for cases when:
-
-        1) A decision can be made to redirect elsewhere without
-           needing to resolve the model first.
-        2) Any async operations need to occur first before the
-           model is attempted to be resolved.
-
-        This hook is provided the current `transition` attempt
-        as a parameter, which can be used to `.abort()` the transition,
-        save it for a later `.retry()`, or retrieve values set
-        on it from a previous hook. You can also just call
-        `this.transitionTo` to another route to implicitly
-        abort the `transition`.
-
-        You can return a promise from this hook to pause the
-        transition until the promise resolves (or rejects). This could
-        be useful, for instance, for retrieving async code from
-        the server that is required to enter a route.
+      An options hash with a `queryParams` property may be provided as
+      the final argument to add query parameters to the destination URL.
 
-        ```javascript
-        App.PostRoute = Ember.Route.extend({
-          beforeModel: function(transition) {
-            if (!App.Post) {
-              return Ember.$.getScript('/models/post.js');
-            }
-          }
-        });
-        ```
+      ```javascript
+      this.transitionTo('blogPost', 1, {
+        queryParams: {showComments: 'true'}
+      });
 
-        If `App.Post` doesn't exist in the above example,
-        `beforeModel` will use jQuery's `getScript`, which
-        returns a promise that resolves after the server has
-        successfully retrieved and executed the code from the
-        server. Note that if an error were to occur, it would
-        be passed to the `error` hook on `Ember.Route`, but
-        it's also possible to handle errors specific to
-        `beforeModel` right from within the hook (to distinguish
-        from the shared error handling behavior of the `error`
-        hook):
+      // if you just want to transition the query parameters without changing the route
+      this.transitionTo({queryParams: {sort: 'date'}});
+      ```
 
-        ```javascript
-        App.PostRoute = Ember.Route.extend({
-          beforeModel: function(transition) {
-            if (!App.Post) {
-              var self = this;
-              return Ember.$.getScript('post.js').then(null, function(e) {
-                self.transitionTo('help');
-
-                // Note that the above transitionTo will implicitly
-                // halt the transition. If you were to return
-                // nothing from this promise reject handler,
-                // according to promise semantics, that would
-                // convert the reject into a resolve and the
-                // transition would continue. To propagate the
-                // error so that it'd be handled by the `error`
-                // hook, you would have to
-                return Ember.RSVP.reject(e);
-              });
-            }
-          }
-        });
-        ```
+      See also 'replaceWith'.
 
-        @method beforeModel
-        @param {Transition} transition
-        @return {Promise} if the value returned from this hook is
-          a promise, the transition will pause until the transition
-          resolves. Otherwise, non-promise return values are not
-          utilized in any way.
-      */
-      beforeModel: K,
+      Simple Transition Example
 
-      /**
-        This hook is called after this route's model has resolved.
-        It follows identical async/promise semantics to `beforeModel`
-        but is provided the route's resolved model in addition to
-        the `transition`, and is therefore suited to performing
-        logic that can only take place after the model has already
-        resolved.
+      ```javascript
+      App.Router.map(function() {
+        this.route('index');
+        this.route('secret');
+        this.route('fourOhFour', { path: '*:' });
+      });
 
-        ```javascript
-        App.PostsRoute = Ember.Route.extend({
-          afterModel: function(posts, transition) {
-            if (posts.get('length') === 1) {
-              this.transitionTo('post.show', posts.get('firstObject'));
+      App.IndexRoute = Ember.Route.extend({
+        actions: {
+          moveToSecret: function(context) {
+            if (authorized()) {
+              this.transitionTo('secret', context);
+            } else {
+              this.transitionTo('fourOhFour');
             }
           }
-        });
-        ```
+        }
+      });
+      ```
 
-        Refer to documentation for `beforeModel` for a description
-        of transition-pausing semantics when a promise is returned
-        from this hook.
-
-        @method afterModel
-        @param {Object} resolvedModel the value returned from `model`,
-          or its resolved value if it was a promise
-        @param {Transition} transition
-        @return {Promise} if the value returned from this hook is
-          a promise, the transition will pause until the transition
-          resolves. Otherwise, non-promise return values are not
-          utilized in any way.
-       */
-      afterModel: K,
+      Transition to a nested route
 
-      /**
-        A hook you can implement to optionally redirect to another route.
-
-        If you call `this.transitionTo` from inside of this hook, this route
-        will not be entered in favor of the other hook.
-
-        `redirect` and `afterModel` behave very similarly and are
-        called almost at the same time, but they have an important
-        distinction in the case that, from one of these hooks, a
-        redirect into a child route of this route occurs: redirects
-        from `afterModel` essentially invalidate the current attempt
-        to enter this route, and will result in this route's `beforeModel`,
-        `model`, and `afterModel` hooks being fired again within
-        the new, redirecting transition. Redirects that occur within
-        the `redirect` hook, on the other hand, will _not_ cause
-        these hooks to be fired again the second time around; in
-        other words, by the time the `redirect` hook has been called,
-        both the resolved model and attempted entry into this route
-        are considered to be fully validated.
-
-        @method redirect
-        @param {Object} model the model for this route
-        @param {Transition} transition the transition object associated with the current transition
-      */
-      redirect: K,
+      ```javascript
+      App.Router.map(function() {
+        this.resource('articles', { path: '/articles' }, function() {
+          this.route('new');
+        });
+      });
 
-      /**
-        Called when the context is changed by router.js.
+      App.IndexRoute = Ember.Route.extend({
+        actions: {
+          transitionToNewArticle: function() {
+            this.transitionTo('articles.new');
+          }
+        }
+      });
+      ```
 
-        @private
-        @method contextDidChange
-      */
-      contextDidChange: function() {
-        this.currentModel = this.context;
-      },
+      Multiple Models Example
 
-      /**
-        A hook you can implement to convert the URL into the model for
-        this route.
+      ```javascript
+      App.Router.map(function() {
+        this.route('index');
 
-        ```javascript
-        App.Router.map(function() {
-          this.resource('post', { path: '/posts/:post_id' });
+        this.resource('breakfast', { path: ':breakfastId' }, function() {
+          this.resource('cereal', { path: ':cerealId' });
         });
-        ```
+      });
 
-        The model for the `post` route is `store.find('post', params.post_id)`.
+      App.IndexRoute = Ember.Route.extend({
+        actions: {
+          moveToChocolateCereal: function() {
+            var cereal = { cerealId: 'ChocolateYumminess' };
+            var breakfast = { breakfastId: 'CerealAndMilk' };
 
-        By default, if your route has a dynamic segment ending in `_id`:
+            this.transitionTo('cereal', breakfast, cereal);
+          }
+        }
+      });
+      ```
 
-        * The model class is determined from the segment (`post_id`'s
-          class is `App.Post`)
-        * The find method is called on the model class with the value of
-          the dynamic segment.
+      Nested Route with Query String Example
 
-        Note that for routes with dynamic segments, this hook is not always
-        executed. If the route is entered through a transition (e.g. when
-        using the `link-to` Handlebars helper or the `transitionTo` method
-        of routes), and a model context is already provided this hook
-        is not called.
+      ```javascript
+      App.Router.map(function() {
+        this.resource('fruits', function() {
+          this.route('apples');
+        });
+      });
 
-        A model context does not include a primitive string or number,
-        which does cause the model hook to be called.
+      App.IndexRoute = Ember.Route.extend({
+        actions: {
+          transitionToApples: function() {
+            this.transitionTo('fruits.apples', {queryParams: {color: 'red'}});
+          }
+        }
+      });
+      ```
 
-        Routes without dynamic segments will always execute the model hook.
+      @method transitionTo
+      @param {String} name the name of the route or a URL
+      @param {...Object} models the model(s) or identifier(s) to be used while
+        transitioning to the route.
+      @param {Object} [options] optional hash with a queryParams property
+        containing a mapping of query parameters
+      @return {Transition} the transition object associated with this
+        attempted transition
+    */
+    transitionTo: function(name, context) {
+      var router = this.router;
+      return router.transitionTo.apply(router, arguments);
+    },
 
-        ```javascript
-        // no dynamic segment, model hook always called
-        this.transitionTo('posts');
+    /**
+      Perform a synchronous transition into another route without attempting
+      to resolve promises, update the URL, or abort any currently active
+      asynchronous transitions (i.e. regular transitions caused by
+      `transitionTo` or URL changes).
 
-        // model passed in, so model hook not called
-        thePost = store.find('post', 1);
-        this.transitionTo('post', thePost);
+      This method is handy for performing intermediate transitions on the
+      way to a final destination route, and is called internally by the
+      default implementations of the `error` and `loading` handlers.
 
-        // integer passed in, model hook is called
-        this.transitionTo('post', 1);
-        ```
+      @method intermediateTransitionTo
+      @param {String} name the name of the route
+      @param {...Object} models the model(s) to be used while transitioning
+      to the route.
+      @since 1.2.0
+     */
+    intermediateTransitionTo: function() {
+      var router = this.router;
+      router.intermediateTransitionTo.apply(router, arguments);
+    },
+
+    /**
+      Refresh the model on this route and any child routes, firing the
+      `beforeModel`, `model`, and `afterModel` hooks in a similar fashion
+      to how routes are entered when transitioning in from other route.
+      The current route params (e.g. `article_id`) will be passed in
+      to the respective model hooks, and if a different model is returned,
+      `setupController` and associated route hooks will re-fire as well.
+
+      An example usage of this method is re-querying the server for the
+      latest information using the same parameters as when the route
+      was first entered.
+
+      Note that this will cause `model` hooks to fire even on routes
+      that were provided a model object when the route was initially
+      entered.
+
+      @method refresh
+      @return {Transition} the transition object associated with this
+        attempted transition
+      @since 1.4.0
+     */
+    refresh: function() {
+      return this.router.router.refresh(this);
+    },
 
+    /**
+      Transition into another route while replacing the current URL, if possible.
+      This will replace the current history entry instead of adding a new one.
+      Beside that, it is identical to `transitionTo` in all other respects. See
+      'transitionTo' for additional information regarding multiple models.
 
-        This hook follows the asynchronous/promise semantics
-        described in the documentation for `beforeModel`. In particular,
-        if a promise returned from `model` fails, the error will be
-        handled by the `error` hook on `Ember.Route`.
+      Example
 
-        Example
+      ```javascript
+      App.Router.map(function() {
+        this.route('index');
+        this.route('secret');
+      });
 
-        ```javascript
-        App.PostRoute = Ember.Route.extend({
-          model: function(params) {
-            return this.store.find('post', params.post_id);
+      App.SecretRoute = Ember.Route.extend({
+        afterModel: function() {
+          if (!authorized()){
+            this.replaceWith('index');
           }
-        });
-        ```
+        }
+      });
+      ```
 
-        @method model
-        @param {Object} params the parameters extracted from the URL
-        @param {Transition} transition
-        @return {Object|Promise} the model for this route. If
-          a promise is returned, the transition will pause until
-          the promise resolves, and the resolved value of the promise
-          will be used as the model for this route.
-      */
-      model: function(params, transition) {
-        var match, name, sawParams, value;
+      @method replaceWith
+      @param {String} name the name of the route or a URL
+      @param {...Object} models the model(s) or identifier(s) to be used while
+        transitioning to the route.
+      @return {Transition} the transition object associated with this
+        attempted transition
+    */
+    replaceWith: function() {
+      var router = this.router;
+      return router.replaceWith.apply(router, arguments);
+    },
 
-        var queryParams = get(this, '_qp.map');
+    /**
+      Sends an action to the router, which will delegate it to the currently
+      active route hierarchy per the bubbling rules explained under `actions`.
 
-        for (var prop in params) {
-          if (prop === 'queryParams' || (queryParams && prop in queryParams)) {
-            continue;
-          }
+      Example
 
-          if (match = prop.match(/^(.*)_id$/)) {
-            name = match[1];
-            value = params[prop];
+      ```javascript
+      App.Router.map(function() {
+        this.route('index');
+      });
+
+      App.ApplicationRoute = Ember.Route.extend({
+        actions: {
+          track: function(arg) {
+            console.log(arg, 'was clicked');
           }
-          sawParams = true;
         }
+      });
 
-        if (!name && sawParams) { return copy(params); }
-        else if (!name) {
-          if (transition.resolveIndex < 1) { return; }
-
-          var parentModel = transition.state.handlerInfos[transition.resolveIndex-1].context;
-
-          return parentModel;
+      App.IndexRoute = Ember.Route.extend({
+        actions: {
+          trackIfDebug: function(arg) {
+            if (debug) {
+              this.send('track', arg);
+            }
+          }
         }
+      });
+      ```
 
-        return this.findModel(name, value);
-      },
-
-      /**
-        @private
-        @method deserialize
-        @param {Object} params the parameters extracted from the URL
-        @param {Transition} transition
-        @return {Object|Promise} the model for this route.
+      @method send
+      @param {String} name the name of the action to trigger
+      @param {...*} args
+    */
+    send: function() {
+      if (this.router || !Ember['default'].testing) {
+        this.router.send.apply(this.router, arguments);
+      } else {
+        var name = arguments[0];
+        var args = slice.call(arguments, 1);
+        var action = this._actions[name];
+        if (action) {
+          return this._actions[name].apply(this, args);
+        }
+      }
+    },
 
-        Router.js hook.
-       */
-      deserialize: function(params, transition) {
-        return this.model(this.paramsFor(this.routeName), transition);
-      },
+    /**
+      This hook is the entry point for router.js
 
-      /**
+      @private
+      @method setup
+    */
+    setup: function(context, transition) {
+      var controllerName = this.controllerName || this.routeName;
+      var controller = this.controllerFor(controllerName, true);
 
-        @method findModel
-        @param {String} type the model type
-        @param {Object} value the value passed to find
-      */
-      findModel: function(){
-        var store = get(this, 'store');
-        return store.find.apply(store, arguments);
-      },
+      if (!controller) {
+        controller =  this.generateController(controllerName, context);
+      }
 
-      /**
-        Store property provides a hook for data persistence libraries to inject themselves.
+      // Assign the route's controller so that it can more easily be
+      // referenced in action handlers
+      this.controller = controller;
 
-        By default, this store property provides the exact same functionality previously
-        in the model hook.
+      if (this.setupControllers) {
+        Ember['default'].deprecate("Ember.Route.setupControllers is deprecated. Please use Ember.Route.setupController(controller, model) instead.");
+        this.setupControllers(controller, context);
+      } else {
+        var states = property_get.get(this, '_qp.states');
+        if (transition) {
+          // Update the model dep values used to calculate cache keys.
+          ember_routing__utils.stashParamNames(this.router, transition.state.handlerInfos);
+          controller._qpDelegate = states.changingKeys;
+          controller._updateCacheParams(transition.params);
+        }
+        controller._qpDelegate = states.allowOverrides;
 
-        Currently, the required interface is:
+        if (transition) {
+          var qpValues = getQueryParamsFor(this, transition.state);
+          controller.setProperties(qpValues);
+        }
 
-        `store.find(modelName, findArguments)`
+        this.setupController(controller, context, transition);
+      }
 
-        @method store
-        @param {Object} store
-      */
-      store: computed(function(){
-        var container = this.container;
-        var routeName = this.routeName;
-        var namespace = get(this, 'router.namespace');
+      if (this.renderTemplates) {
+        Ember['default'].deprecate("Ember.Route.renderTemplates is deprecated. Please use Ember.Route.renderTemplate(controller, model) instead.");
+        this.renderTemplates(context);
+      } else {
+        this.renderTemplate(controller, context);
+      }
+    },
 
-        return {
-          find: function(name, value) {
-            var modelClass = container.lookupFactory('model:' + name);
+    /**
+      This hook is the first of the route entry validation hooks
+      called when an attempt is made to transition into a route
+      or one of its children. It is called before `model` and
+      `afterModel`, and is appropriate for cases when:
 
-            Ember.assert("You used the dynamic segment " + name + "_id in your route " +
-                         routeName + ", but " + namespace + "." + classify(name) +
-                         " did not exist and you did not override your route's `model` " +
-                         "hook.", !!modelClass);
+      1) A decision can be made to redirect elsewhere without
+         needing to resolve the model first.
+      2) Any async operations need to occur first before the
+         model is attempted to be resolved.
 
-            if (!modelClass) { return; }
+      This hook is provided the current `transition` attempt
+      as a parameter, which can be used to `.abort()` the transition,
+      save it for a later `.retry()`, or retrieve values set
+      on it from a previous hook. You can also just call
+      `this.transitionTo` to another route to implicitly
+      abort the `transition`.
 
-            Ember.assert(classify(name) + ' has no method `find`.', typeof modelClass.find === 'function');
+      You can return a promise from this hook to pause the
+      transition until the promise resolves (or rejects). This could
+      be useful, for instance, for retrieving async code from
+      the server that is required to enter a route.
 
-            return modelClass.find(value);
+      ```javascript
+      App.PostRoute = Ember.Route.extend({
+        beforeModel: function(transition) {
+          if (!App.Post) {
+            return Ember.$.getScript('/models/post.js');
           }
-        };
-      }),
-
-      /**
-        A hook you can implement to convert the route's model into parameters
-        for the URL.
+        }
+      });
+      ```
 
-        ```javascript
-        App.Router.map(function() {
-          this.resource('post', { path: '/posts/:post_id' });
-        });
+      If `App.Post` doesn't exist in the above example,
+      `beforeModel` will use jQuery's `getScript`, which
+      returns a promise that resolves after the server has
+      successfully retrieved and executed the code from the
+      server. Note that if an error were to occur, it would
+      be passed to the `error` hook on `Ember.Route`, but
+      it's also possible to handle errors specific to
+      `beforeModel` right from within the hook (to distinguish
+      from the shared error handling behavior of the `error`
+      hook):
 
-        App.PostRoute = Ember.Route.extend({
-          model: function(params) {
-            // the server returns `{ id: 12 }`
-            return Ember.$.getJSON('/posts/' + params.post_id);
-          },
+      ```javascript
+      App.PostRoute = Ember.Route.extend({
+        beforeModel: function(transition) {
+          if (!App.Post) {
+            var self = this;
+            return Ember.$.getScript('post.js').then(null, function(e) {
+              self.transitionTo('help');
 
-          serialize: function(model) {
-            // this will make the URL `/posts/12`
-            return { post_id: model.id };
+              // Note that the above transitionTo will implicitly
+              // halt the transition. If you were to return
+              // nothing from this promise reject handler,
+              // according to promise semantics, that would
+              // convert the reject into a resolve and the
+              // transition would continue. To propagate the
+              // error so that it'd be handled by the `error`
+              // hook, you would have to
+              return Ember.RSVP.reject(e);
+            });
           }
-        });
-        ```
-
-        The default `serialize` method will insert the model's `id` into the
-        route's dynamic segment (in this case, `:post_id`) if the segment contains '_id'.
-        If the route has multiple dynamic segments or does not contain '_id', `serialize`
-        will return `Ember.getProperties(model, params)`
-
-        This method is called when `transitionTo` is called with a context
-        in order to populate the URL.
+        }
+      });
+      ```
 
-        @method serialize
-        @param {Object} model the route's model
-        @param {Array} params an Array of parameter names for the current
-          route (in the example, `['post_id']`.
-        @return {Object} the serialized parameters
-      */
-      serialize: function(model, params) {
-        if (params.length < 1) { return; }
-        if (!model) { return; }
+      @method beforeModel
+      @param {Transition} transition
+      @return {Promise} if the value returned from this hook is
+        a promise, the transition will pause until the transition
+        resolves. Otherwise, non-promise return values are not
+        utilized in any way.
+    */
+    beforeModel: K,
 
-        var name = params[0], object = {};
+    /**
+      This hook is called after this route's model has resolved.
+      It follows identical async/promise semantics to `beforeModel`
+      but is provided the route's resolved model in addition to
+      the `transition`, and is therefore suited to performing
+      logic that can only take place after the model has already
+      resolved.
 
-        if (params.length === 1) {
-          if (name in model) {
-            object[name] = get(model, name);
-          } else if (/_id$/.test(name)) {
-            object[name] = get(model, "id");
+      ```javascript
+      App.PostsRoute = Ember.Route.extend({
+        afterModel: function(posts, transition) {
+          if (posts.get('length') === 1) {
+            this.transitionTo('post.show', posts.get('firstObject'));
           }
-        } else {
-          object = getProperties(model, params);
         }
+      });
+      ```
 
-        return object;
-      },
+      Refer to documentation for `beforeModel` for a description
+      of transition-pausing semantics when a promise is returned
+      from this hook.
 
-      /**
-        A hook you can use to setup the controller for the current route.
+      @method afterModel
+      @param {Object} resolvedModel the value returned from `model`,
+        or its resolved value if it was a promise
+      @param {Transition} transition
+      @return {Promise} if the value returned from this hook is
+        a promise, the transition will pause until the transition
+        resolves. Otherwise, non-promise return values are not
+        utilized in any way.
+     */
+    afterModel: K,
 
-        This method is called with the controller for the current route and the
-        model supplied by the `model` hook.
+    /**
+      A hook you can implement to optionally redirect to another route.
 
-        By default, the `setupController` hook sets the `model` property of
-        the controller to the `model`.
+      If you call `this.transitionTo` from inside of this hook, this route
+      will not be entered in favor of the other hook.
 
-        If you implement the `setupController` hook in your Route, it will
-        prevent this default behavior. If you want to preserve that behavior
-        when implementing your `setupController` function, make sure to call
-        `_super`:
+      `redirect` and `afterModel` behave very similarly and are
+      called almost at the same time, but they have an important
+      distinction in the case that, from one of these hooks, a
+      redirect into a child route of this route occurs: redirects
+      from `afterModel` essentially invalidate the current attempt
+      to enter this route, and will result in this route's `beforeModel`,
+      `model`, and `afterModel` hooks being fired again within
+      the new, redirecting transition. Redirects that occur within
+      the `redirect` hook, on the other hand, will _not_ cause
+      these hooks to be fired again the second time around; in
+      other words, by the time the `redirect` hook has been called,
+      both the resolved model and attempted entry into this route
+      are considered to be fully validated.
 
-        ```javascript
-        App.PhotosRoute = Ember.Route.extend({
-          model: function() {
-            return this.store.find('photo');
-          },
+      @method redirect
+      @param {Object} model the model for this route
+      @param {Transition} transition the transition object associated with the current transition
+    */
+    redirect: K,
 
-          setupController: function (controller, model) {
-            // Call _super for default behavior
-            this._super(controller, model);
-            // Implement your custom setup after
-            this.controllerFor('application').set('showingPhotos', true);
-          }
-        });
-        ```
+    /**
+      Called when the context is changed by router.js.
 
-        This means that your template will get a proxy for the model as its
-        context, and you can act as though the model itself was the context.
+      @private
+      @method contextDidChange
+    */
+    contextDidChange: function() {
+      this.currentModel = this.context;
+    },
 
-        The provided controller will be one resolved based on the name
-        of this route.
+    /**
+      A hook you can implement to convert the URL into the model for
+      this route.
 
-        If no explicit controller is defined, Ember will automatically create
-        an appropriate controller for the model.
+      ```javascript
+      App.Router.map(function() {
+        this.resource('post', { path: '/posts/:post_id' });
+      });
+      ```
 
-        * if the model is an `Ember.Array` (including record arrays from Ember
-          Data), the controller is an `Ember.ArrayController`.
-        * otherwise, the controller is an `Ember.ObjectController`.
+      The model for the `post` route is `store.find('post', params.post_id)`.
 
-        As an example, consider the router:
+      By default, if your route has a dynamic segment ending in `_id`:
 
-        ```javascript
-        App.Router.map(function() {
-          this.resource('post', { path: '/posts/:post_id' });
-        });
-        ```
+      * The model class is determined from the segment (`post_id`'s
+        class is `App.Post`)
+      * The find method is called on the model class with the value of
+        the dynamic segment.
 
-        For the `post` route, a controller named `App.PostController` would
-        be used if it is defined. If it is not defined, an `Ember.ObjectController`
-        instance would be used.
+      Note that for routes with dynamic segments, this hook is not always
+      executed. If the route is entered through a transition (e.g. when
+      using the `link-to` Handlebars helper or the `transitionTo` method
+      of routes), and a model context is already provided this hook
+      is not called.
 
-        Example
+      A model context does not include a primitive string or number,
+      which does cause the model hook to be called.
 
-        ```javascript
-        App.PostRoute = Ember.Route.extend({
-          setupController: function(controller, model) {
-            controller.set('model', model);
-          }
-        });
-        ```
+      Routes without dynamic segments will always execute the model hook.
 
-        @method setupController
-        @param {Controller} controller instance
-        @param {Object} model
-      */
-      setupController: function(controller, context, transition) {
-        if (controller && (context !== undefined)) {
-          set(controller, 'model', context);
-        }
-      },
+      ```javascript
+      // no dynamic segment, model hook always called
+      this.transitionTo('posts');
 
-      /**
-        Returns the controller for a particular route or name.
+      // model passed in, so model hook not called
+      thePost = store.find('post', 1);
+      this.transitionTo('post', thePost);
 
-        The controller instance must already have been created, either through entering the
-        associated route or using `generateController`.
+      // integer passed in, model hook is called
+      this.transitionTo('post', 1);
+      ```
 
-        ```javascript
-        App.PostRoute = Ember.Route.extend({
-          setupController: function(controller, post) {
-            this._super(controller, post);
-            this.controllerFor('posts').set('currentPost', post);
-          }
-        });
-        ```
 
-        @method controllerFor
-        @param {String} name the name of the route or controller
-        @return {Ember.Controller}
-      */
-      controllerFor: function(name, _skipAssert) {
-        var container = this.container;
-        var route = container.lookup('route:'+name);
-        var controller;
+      This hook follows the asynchronous/promise semantics
+      described in the documentation for `beforeModel`. In particular,
+      if a promise returned from `model` fails, the error will be
+      handled by the `error` hook on `Ember.Route`.
+
+      Example
 
-        if (route && route.controllerName) {
-          name = route.controllerName;
+      ```javascript
+      App.PostRoute = Ember.Route.extend({
+        model: function(params) {
+          return this.store.find('post', params.post_id);
         }
+      });
+      ```
 
-        controller = container.lookup('controller:' + name);
+      @method model
+      @param {Object} params the parameters extracted from the URL
+      @param {Transition} transition
+      @return {Object|Promise} the model for this route. If
+        a promise is returned, the transition will pause until
+        the promise resolves, and the resolved value of the promise
+        will be used as the model for this route.
+    */
+    model: function(params, transition) {
+      var match, name, sawParams, value;
 
-        // NOTE: We're specifically checking that skipAssert is true, because according
-        //   to the old API the second parameter was model. We do not want people who
-        //   passed a model to skip the assertion.
-        Ember.assert("The controller named '"+name+"' could not be found. Make sure " +
-                     "that this route exists and has already been entered at least " +
-                     "once. If you are accessing a controller not associated with a " +
-                     "route, make sure the controller class is explicitly defined.",
-                     controller || _skipAssert === true);
+      var queryParams = property_get.get(this, '_qp.map');
 
-        return controller;
-      },
+      for (var prop in params) {
+        if (prop === 'queryParams' || (queryParams && prop in queryParams)) {
+          continue;
+        }
 
-      /**
-        Generates a controller for a route.
+        if (match = prop.match(/^(.*)_id$/)) {
+          name = match[1];
+          value = params[prop];
+        }
+        sawParams = true;
+      }
 
-        If the optional model is passed then the controller type is determined automatically,
-        e.g., an ArrayController for arrays.
+      if (!name && sawParams) {
+        return copy['default'](params);
+      } else if (!name) {
+        if (transition.resolveIndex < 1) { return; }
 
-        Example
+        var parentModel = transition.state.handlerInfos[transition.resolveIndex-1].context;
 
-        ```javascript
-        App.PostRoute = Ember.Route.extend({
-          setupController: function(controller, post) {
-            this._super(controller, post);
-            this.generateController('posts', post);
-          }
-        });
-        ```
+        return parentModel;
+      }
 
-        @method generateController
-        @param {String} name the name of the controller
-        @param {Object} model the model to infer the type of the controller (optional)
-      */
-      generateController: function(name, model) {
-        var container = this.container;
+      return this.findModel(name, value);
+    },
 
-        model = model || this.modelFor(name);
+    /**
+      @private
+      @method deserialize
+      @param {Object} params the parameters extracted from the URL
+      @param {Transition} transition
+      @return {Object|Promise} the model for this route.
 
-        return generateController(container, name, model);
-      },
+      Router.js hook.
+     */
+    deserialize: function(params, transition) {
+      return this.model(this.paramsFor(this.routeName), transition);
+    },
 
-      /**
-        Returns the model of a parent (or any ancestor) route
-        in a route hierarchy.  During a transition, all routes
-        must resolve a model object, and if a route
-        needs access to a parent route's model in order to
-        resolve a model (or just reuse the model from a parent),
-        it can call `this.modelFor(theNameOfParentRoute)` to
-        retrieve it.
+    /**
 
-        Example
+      @method findModel
+      @param {String} type the model type
+      @param {Object} value the value passed to find
+    */
+    findModel: function() {
+      var store = property_get.get(this, 'store');
+      return store.find.apply(store, arguments);
+    },
 
-        ```javascript
-        App.Router.map(function() {
-            this.resource('post', { path: '/post/:post_id' }, function() {
-                this.resource('comments');
-            });
-        });
+    /**
+      Store property provides a hook for data persistence libraries to inject themselves.
 
-        App.CommentsRoute = Ember.Route.extend({
-            afterModel: function() {
-                this.set('post', this.modelFor('post'));
-            }
-        });
-        ```
+      By default, this store property provides the exact same functionality previously
+      in the model hook.
 
-        @method modelFor
-        @param {String} name the name of the route
-        @return {Object} the model object
-      */
-      modelFor: function(name) {
-        var route = this.container.lookup('route:' + name);
-        var transition = this.router ? this.router.router.activeTransition : null;
+      Currently, the required interface is:
 
-        // If we are mid-transition, we want to try and look up
-        // resolved parent contexts on the current transitionEvent.
-        if (transition) {
-          var modelLookupName = (route && route.routeName) || name;
-          if (transition.resolvedModels.hasOwnProperty(modelLookupName)) {
-            return transition.resolvedModels[modelLookupName];
-          }
-        }
+      `store.find(modelName, findArguments)`
 
-        return route && route.currentModel;
-      },
+      @method store
+      @param {Object} store
+    */
+    store: computed.computed(function() {
+      var container = this.container;
+      var routeName = this.routeName;
+      var namespace = property_get.get(this, 'router.namespace');
 
-      /**
-        A hook you can use to render the template for the current route.
+      return {
+        find: function(name, value) {
+          var modelClass = container.lookupFactory('model:' + name);
 
-        This method is called with the controller for the current route and the
-        model supplied by the `model` hook. By default, it renders the route's
-        template, configured with the controller for the route.
+          Ember['default'].assert("You used the dynamic segment " + name + "_id in your route " +
+                       routeName + ", but " + namespace + "." + string.classify(name) +
+                       " did not exist and you did not override your route's `model` " +
+                       "hook.", !!modelClass);
 
-        This method can be overridden to set up and render additional or
-        alternative templates.
+          if (!modelClass) { return; }
 
-        ```javascript
-        App.PostsRoute = Ember.Route.extend({
-          renderTemplate: function(controller, model) {
-            var favController = this.controllerFor('favoritePost');
-
-            // Render the `favoritePost` template into
-            // the outlet `posts`, and display the `favoritePost`
-            // controller.
-            this.render('favoritePost', {
-              outlet: 'posts',
-              controller: favController
-            });
-          }
-        });
-        ```
+          Ember['default'].assert(string.classify(name) + ' has no method `find`.', typeof modelClass.find === 'function');
 
-        @method renderTemplate
-        @param {Object} controller the route's controller
-        @param {Object} model the route's model
-      */
-      renderTemplate: function(controller, model) {
-        this.render();
-      },
+          return modelClass.find(value);
+        }
+      };
+    }),
 
-      /**
-        `render` is used to render a template into a region of another template
-        (indicated by an `{{outlet}}`). `render` is used both during the entry
-        phase of routing (via the `renderTemplate` hook) and later in response to
-        user interaction.
+    /**
+      A hook you can implement to convert the route's model into parameters
+      for the URL.
 
-        For example, given the following minimal router and templates:
+      ```javascript
+      App.Router.map(function() {
+        this.resource('post', { path: '/posts/:post_id' });
+      });
 
-        ```javascript
-        Router.map(function() {
-          this.resource('photos');
-        });
-        ```
+      App.PostRoute = Ember.Route.extend({
+        model: function(params) {
+          // the server returns `{ id: 12 }`
+          return Ember.$.getJSON('/posts/' + params.post_id);
+        },
 
-        ```handlebars
-        <!-- application.hbs -->
-        <div class='something-in-the-app-hbs'>
-          {{outlet "anOutletName"}}
-        </div>
-        ```
+        serialize: function(model) {
+          // this will make the URL `/posts/12`
+          return { post_id: model.id };
+        }
+      });
+      ```
 
-        ```handlebars
-        <!-- photos.hbs -->
-        <h1>Photos</h1>
-        ```
+      The default `serialize` method will insert the model's `id` into the
+      route's dynamic segment (in this case, `:post_id`) if the segment contains '_id'.
+      If the route has multiple dynamic segments or does not contain '_id', `serialize`
+      will return `Ember.getProperties(model, params)`
 
-        You can render `photos.hbs` into the `"anOutletName"` outlet of
-        `application.hbs` by calling `render`:
+      This method is called when `transitionTo` is called with a context
+      in order to populate the URL.
 
-        ```javascript
-        // posts route
-        Ember.Route.extend({
-          renderTemplate: function(){
-            this.render('photos', {
-              into: 'application',
-              outlet: 'anOutletName'
-            })
-          }
-        });
-        ```
+      @method serialize
+      @param {Object} model the route's model
+      @param {Array} params an Array of parameter names for the current
+        route (in the example, `['post_id']`.
+      @return {Object} the serialized parameters
+    */
+    serialize: function(model, params) {
+      if (params.length < 1) { return; }
+      if (!model) { return; }
 
-        `render` additionally allows you to supply which `view`, `controller`, and
-        `model` objects should be loaded and associated with the rendered template.
+      var name = params[0];
+      var object = {};
 
+      if (params.length === 1) {
+        if (name in model) {
+          object[name] = property_get.get(model, name);
+        } else if (/_id$/.test(name)) {
+          object[name] = property_get.get(model, "id");
+        }
+      } else {
+        object = getProperties['default'](model, params);
+      }
 
-        ```javascript
-        // posts route
-        Ember.Route.extend({
-          renderTemplate: function(controller, model){
-            this.render('posts', {    // the template to render, referenced by name
-              into: 'application',    // the template to render into, referenced by name
-              outlet: 'anOutletName', // the outlet inside `options.template` to render into.
-              view: 'aViewName',      // the view to use for this template, referenced by name
-              controller: 'someControllerName', // the controller to use for this template, referenced by name
-              model: model            // the model to set on `options.controller`.
-            })
-          }
-        });
-        ```
+      return object;
+    },
 
-        The string values provided for the template name, view, and controller
-        will eventually pass through to the resolver for lookup. See
-        Ember.Resolver for how these are mapped to JavaScript objects in your
-        application.
+    /**
+      A hook you can use to setup the controller for the current route.
 
-        Not all options need to be passed to `render`. Default values will be used
-        based on the name of the route specified in the router or the Route's
-        `controllerName`, `viewName` and `templateName` properties.
+      This method is called with the controller for the current route and the
+      model supplied by the `model` hook.
 
-        For example:
+      By default, the `setupController` hook sets the `model` property of
+      the controller to the `model`.
 
-        ```javascript
-        // router
-        Router.map(function() {
-          this.route('index');
-          this.resource('post', { path: '/posts/:post_id' });
-        });
-        ```
+      If you implement the `setupController` hook in your Route, it will
+      prevent this default behavior. If you want to preserve that behavior
+      when implementing your `setupController` function, make sure to call
+      `_super`:
 
-        ```javascript
-        // post route
-        PostRoute = App.Route.extend({
-          renderTemplate: function() {
-            this.render(); // all defaults apply
-          }
-        });
-        ```
+      ```javascript
+      App.PhotosRoute = Ember.Route.extend({
+        model: function() {
+          return this.store.find('photo');
+        },
 
-        The name of the `PostRoute`, defined by the router, is `post`.
+        setupController: function (controller, model) {
+          // Call _super for default behavior
+          this._super(controller, model);
+          // Implement your custom setup after
+          this.controllerFor('application').set('showingPhotos', true);
+        }
+      });
+      ```
 
-        The following equivalent default options will be applied when
-        the Route calls `render`:
+      This means that your template will get a proxy for the model as its
+      context, and you can act as though the model itself was the context.
 
-        ```javascript
-        //
-        this.render('post', {  // the template name associated with 'post' Route
-          into: 'application', // the parent route to 'post' Route
-          outlet: 'main',      // {{outlet}} and {{outlet 'main' are synonymous}},
-          view: 'post',        // the view associated with the 'post' Route
-          controller: 'post',  // the controller associated with the 'post' Route
-        })
-        ```
+      The provided controller will be one resolved based on the name
+      of this route.
 
-        By default the controller's `model` will be the route's model, so it does not
-        need to be passed unless you wish to change which model is being used.
-
-        @method render
-        @param {String} name the name of the template to render
-        @param {Object} [options] the options
-        @param {String} [options.into] the template to render into,
-                        referenced by name. Defaults to the parent template
-        @param {String} [options.outlet] the outlet inside `options.template` to render into.
-                        Defaults to 'main'
-        @param {String} [options.controller] the controller to use for this template,
-                        referenced by name. Defaults to the Route's paired controller
-        @param {String} [options.model] the model object to set on `options.controller`
-                        Defaults to the return value of the Route's model hook
-      */
-      render: function(_name, options) {
-        Ember.assert("The name in the given arguments is undefined", arguments.length > 0 ? !isNone(arguments[0]) : true);
+      If no explicit controller is defined, Ember will automatically create
+      an appropriate controller for the model.
 
-        var namePassed = typeof _name === 'string' && !!_name;
-        var name;
+      * if the model is an `Ember.Array` (including record arrays from Ember
+        Data), the controller is an `Ember.ArrayController`.
+      * otherwise, the controller is an `Ember.ObjectController`.
 
-        if (typeof _name === 'object' && !options) {
-          name = this.routeName;
-          options = _name;
-        } else {
-          name = _name;
-        }
+      As an example, consider the router:
 
-        var templateName;
+      ```javascript
+      App.Router.map(function() {
+        this.resource('post', { path: '/posts/:post_id' });
+      });
+      ```
 
-        if (name) {
-          name = name.replace(/\//g, '.');
-          templateName = name;
-        } else {
-          name = this.routeName;
-          templateName = this.templateName || name;
+      For the `post` route, a controller named `App.PostController` would
+      be used if it is defined. If it is not defined, an `Ember.ObjectController`
+      instance would be used.
+
+      Example
+
+      ```javascript
+      App.PostRoute = Ember.Route.extend({
+        setupController: function(controller, model) {
+          controller.set('model', model);
         }
+      });
+      ```
+
+      @method setupController
+      @param {Controller} controller instance
+      @param {Object} model
+    */
+    setupController: function(controller, context, transition) {
+      if (controller && (context !== undefined)) {
+        property_set.set(controller, 'model', context);
+      }
+    },
 
-        var renderOptions = buildRenderOptions(this, namePassed, name, options);
+    /**
+      Returns the controller for a particular route or name.
 
-        var LOG_VIEW_LOOKUPS = get(this.router, 'namespace.LOG_VIEW_LOOKUPS');
-        var viewName = options && options.view || namePassed && name || this.viewName || name;
-        var view, template;
+      The controller instance must already have been created, either through entering the
+      associated route or using `generateController`.
 
-        var ViewClass = this.container.lookupFactory('view:' + viewName);
-        if (ViewClass) {
-          view = setupView(ViewClass, renderOptions);
-          if (!get(view, 'template')) {
-            view.set('template', this.container.lookup('template:' + templateName));
-          }
-          if (LOG_VIEW_LOOKUPS) {
-            Ember.Logger.info("Rendering " + renderOptions.name + " with " + view, { fullName: 'view:' + renderOptions.name });
-          }
-        } else {
-          template = this.container.lookup('template:' + templateName);
-          if (!template) {
-            Ember.assert("Could not find \"" + name + "\" template or view.", arguments.length === 0 || Ember.isEmpty(arguments[0]));
-            if (LOG_VIEW_LOOKUPS) {
-              Ember.Logger.info("Could not find \"" + name + "\" template or view. Nothing will be rendered", { fullName: 'template:' + name });
-            }
-            return;
-          }
-          var defaultView = renderOptions.into ? 'view:default' : 'view:toplevel';
-          ViewClass = this.container.lookupFactory(defaultView);
-          view = setupView(ViewClass, renderOptions);
-          if (!get(view, 'template')) {
-            view.set('template', template);
-          }
-          if (LOG_VIEW_LOOKUPS) {
-            Ember.Logger.info("Rendering " + renderOptions.name + " with default view " + view, { fullName: 'view:' + renderOptions.name });
-          }
+      ```javascript
+      App.PostRoute = Ember.Route.extend({
+        setupController: function(controller, post) {
+          this._super(controller, post);
+          this.controllerFor('posts').set('currentPost', post);
         }
+      });
+      ```
 
-        if (renderOptions.outlet === 'main') { this.lastRenderedTemplate = name; }
-        appendView(this, view, renderOptions);
-      },
-
-      /**
-        Disconnects a view that has been rendered into an outlet.
+      @method controllerFor
+      @param {String} name the name of the route or controller
+      @return {Ember.Controller}
+    */
+    controllerFor: function(name, _skipAssert) {
+      var container = this.container;
+      var route = container.lookup('route:'+name);
+      var controller;
 
-        You may pass any or all of the following options to `disconnectOutlet`:
+      if (route && route.controllerName) {
+        name = route.controllerName;
+      }
 
-        * `outlet`: the name of the outlet to clear (default: 'main')
-        * `parentView`: the name of the view containing the outlet to clear
-           (default: the view rendered by the parent route)
+      controller = container.lookup('controller:' + name);
 
-        Example:
+      // NOTE: We're specifically checking that skipAssert is true, because according
+      //   to the old API the second parameter was model. We do not want people who
+      //   passed a model to skip the assertion.
+      Ember['default'].assert("The controller named '"+name+"' could not be found. Make sure " +
+                   "that this route exists and has already been entered at least " +
+                   "once. If you are accessing a controller not associated with a " +
+                   "route, make sure the controller class is explicitly defined.",
+                   controller || _skipAssert === true);
 
-        ```javascript
-        App.ApplicationRoute = App.Route.extend({
-          actions: {
-            showModal: function(evt) {
-              this.render(evt.modalName, {
-                outlet: 'modal',
-                into: 'application'
-              });
-            },
-            hideModal: function(evt) {
-              this.disconnectOutlet({
-                outlet: 'modal',
-                parentView: 'application'
-              });
-            }
-          }
-        });
-        ```
+      return controller;
+    },
 
-        Alternatively, you can pass the `outlet` name directly as a string.
+    /**
+      Generates a controller for a route.
 
-        Example:
+      If the optional model is passed then the controller type is determined automatically,
+      e.g., an ArrayController for arrays.
 
-        ```javascript
-        hideModal: function(evt) {
-          this.disconnectOutlet('modal');
-        }
-        ```
+      Example
 
-        @method disconnectOutlet
-        @param {Object|String} options the options hash or outlet name
-      */
-      disconnectOutlet: function(options) {
-        if (!options || typeof options === "string") {
-          var outletName = options;
-          options = {};
-          options.outlet = outletName;
+      ```javascript
+      App.PostRoute = Ember.Route.extend({
+        setupController: function(controller, post) {
+          this._super(controller, post);
+          this.generateController('posts', post);
         }
-        options.parentView = options.parentView ? options.parentView.replace(/\//g, '.') : parentTemplate(this);
-        options.outlet = options.outlet || 'main';
-
-        var parentView = this.router._lookupActiveView(options.parentView);
-        if (parentView) { parentView.disconnectOutlet(options.outlet); }
-      },
+      });
+      ```
 
-      willDestroy: function() {
-        this.teardownViews();
-      },
+      @method generateController
+      @param {String} name the name of the controller
+      @param {Object} model the model to infer the type of the controller (optional)
+    */
+    generateController: function(name, model) {
+      var container = this.container;
 
-      /**
-        @private
+      model = model || this.modelFor(name);
 
-        @method teardownViews
-      */
-      teardownViews: function() {
-        // Tear down the top level view
-        if (this.teardownTopLevelView) { this.teardownTopLevelView(); }
-
-        // Tear down any outlets rendered with 'into'
-        var teardownOutletViews = this.teardownOutletViews || [];
-        forEach(teardownOutletViews, function(teardownOutletView) {
-          teardownOutletView();
-        });
+      return generateController['default'](container, name, model);
+    },
 
-        delete this.teardownTopLevelView;
-        delete this.teardownOutletViews;
-        delete this.lastRenderedTemplate;
-      }
-    });
+    /**
+      Returns the model of a parent (or any ancestor) route
+      in a route hierarchy.  During a transition, all routes
+      must resolve a model object, and if a route
+      needs access to a parent route's model in order to
+      resolve a model (or just reuse the model from a parent),
+      it can call `this.modelFor(theNameOfParentRoute)` to
+      retrieve it.
 
-    
-      // TODO add mixin directly to `Route` class definition above, once this
-      // feature is merged:
-      Route.reopen(Evented);
-    
+      Example
 
-    var defaultQPMeta = {
-      qps: [],
-      map: {},
-      states: {}
-    };
+      ```javascript
+      App.Router.map(function() {
+          this.resource('post', { path: '/post/:post_id' }, function() {
+              this.resource('comments');
+          });
+      });
 
-    function parentRoute(route) {
-      var handlerInfo = handlerInfoFor(route, route.router.router.state.handlerInfos, -1);
-      return handlerInfo && handlerInfo.handler;
-    }
+      App.CommentsRoute = Ember.Route.extend({
+          afterModel: function() {
+              this.set('post', this.modelFor('post'));
+          }
+      });
+      ```
 
-    function handlerInfoFor(route, handlerInfos, _offset) {
-      if (!handlerInfos) { return; }
+      @method modelFor
+      @param {String} name the name of the route
+      @return {Object} the model object
+    */
+    modelFor: function(name) {
+      var route = this.container.lookup('route:' + name);
+      var transition = this.router ? this.router.router.activeTransition : null;
 
-      var offset = _offset || 0;
-      var current;
-      for (var i=0, l=handlerInfos.length; i<l; i++) {
-        current = handlerInfos[i].handler;
-        if (current === route) { return handlerInfos[i+offset]; }
+      // If we are mid-transition, we want to try and look up
+      // resolved parent contexts on the current transitionEvent.
+      if (transition) {
+        var modelLookupName = (route && route.routeName) || name;
+        if (transition.resolvedModels.hasOwnProperty(modelLookupName)) {
+          return transition.resolvedModels[modelLookupName];
+        }
       }
-    }
 
-    function parentTemplate(route) {
-      var parent = parentRoute(route);
-      var template;
+      return route && route.currentModel;
+    },
 
-      if (!parent) { return; }
+    /**
+      A hook you can use to render the template for the current route.
 
-      if (template = parent.lastRenderedTemplate) {
-        return template;
-      } else {
-        return parentTemplate(parent);
-      }
-    }
+      This method is called with the controller for the current route and the
+      model supplied by the `model` hook. By default, it renders the route's
+      template, configured with the controller for the route.
 
-    function buildRenderOptions(route, namePassed, name, options) {
-      var controller = options && options.controller;
+      This method can be overridden to set up and render additional or
+      alternative templates.
 
-      if (!controller) {
-        if (namePassed) {
-          controller = route.container.lookup('controller:' + name) || route.controllerName || route.routeName;
-        } else {
-          controller = route.controllerName || route.container.lookup('controller:' + name);
+      ```javascript
+      App.PostsRoute = Ember.Route.extend({
+        renderTemplate: function(controller, model) {
+          var favController = this.controllerFor('favoritePost');
+
+          // Render the `favoritePost` template into
+          // the outlet `posts`, and display the `favoritePost`
+          // controller.
+          this.render('favoritePost', {
+            outlet: 'posts',
+            controller: favController
+          });
         }
-      }
+      });
+      ```
 
-      if (typeof controller === 'string') {
-        var controllerName = controller;
-        controller = route.container.lookup('controller:' + controllerName);
-        if (!controller) {
-          throw new EmberError("You passed `controller: '" + controllerName + "'` into the `render` method, but no such controller could be found.");
-        }
-      }
+      @method renderTemplate
+      @param {Object} controller the route's controller
+      @param {Object} model the route's model
+    */
+    renderTemplate: function(controller, model) {
+      this.render();
+    },
 
-      if (options && options.model) {
-        controller.set('model', options.model);
-      }
+    /**
+      `render` is used to render a template into a region of another template
+      (indicated by an `{{outlet}}`). `render` is used both during the entry
+      phase of routing (via the `renderTemplate` hook) and later in response to
+      user interaction.
 
-      var renderOptions = {
-        into: options && options.into ? options.into.replace(/\//g, '.') : parentTemplate(route),
-        outlet: (options && options.outlet) || 'main',
-        name: name,
-        controller: controller
-      };
+      For example, given the following minimal router and templates:
 
-      Ember.assert("An outlet ("+renderOptions.outlet+") was specified but was not found.", renderOptions.outlet === 'main' || renderOptions.into);
+      ```javascript
+      Router.map(function() {
+        this.resource('photos');
+      });
+      ```
 
-      return renderOptions;
-    }
+      ```handlebars
+      <!-- application.hbs -->
+      <div class='something-in-the-app-hbs'>
+        {{outlet "anOutletName"}}
+      </div>
+      ```
 
-    function setupView(ViewClass, options) {
-      return ViewClass.create({
-        _debugTemplateName: options.name,
-        renderedName: options.name,
-        controller: options.controller
-      });
-    }
+      ```handlebars
+      <!-- photos.hbs -->
+      <h1>Photos</h1>
+      ```
 
-    function appendView(route, view, options) {
-      if (options.into) {
-        var parentView = route.router._lookupActiveView(options.into);
-        var teardownOutletView = generateOutletTeardown(parentView, options.outlet);
-        if (!route.teardownOutletViews) { route.teardownOutletViews = []; }
-        replace(route.teardownOutletViews, 0, 0, [teardownOutletView]);
-        parentView.connectOutlet(options.outlet, view);
-      } else {
-        var rootElement = get(route.router, 'namespace.rootElement');
-        // tear down view if one is already rendered
-        if (route.teardownTopLevelView) {
-          route.teardownTopLevelView();
+      You can render `photos.hbs` into the `"anOutletName"` outlet of
+      `application.hbs` by calling `render`:
+
+      ```javascript
+      // posts route
+      Ember.Route.extend({
+        renderTemplate: function() {
+          this.render('photos', {
+            into: 'application',
+            outlet: 'anOutletName'
+          })
         }
-        route.router._connectActiveView(options.name, view);
-        route.teardownTopLevelView = generateTopLevelTeardown(view);
-        view.appendTo(rootElement);
-      }
-    }
+      });
+      ```
 
-    function generateTopLevelTeardown(view) {
-      return function() {
-        view.destroy();
-      };
-    }
+      `render` additionally allows you to supply which `view`, `controller`, and
+      `model` objects should be loaded and associated with the rendered template.
 
-    function generateOutletTeardown(parentView, outlet) {
-      return function() {
-        parentView.disconnectOutlet(outlet);
-      };
-    }
 
-    function getFullQueryParams(router, state) {
-      if (state.fullQueryParams) { return state.fullQueryParams; }
+      ```javascript
+      // posts route
+      Ember.Route.extend({
+        renderTemplate: function(controller, model){
+          this.render('posts', {    // the template to render, referenced by name
+            into: 'application',    // the template to render into, referenced by name
+            outlet: 'anOutletName', // the outlet inside `options.template` to render into.
+            view: 'aViewName',      // the view to use for this template, referenced by name
+            controller: 'someControllerName', // the controller to use for this template, referenced by name
+            model: model            // the model to set on `options.controller`.
+          })
+        }
+      });
+      ```
 
-      state.fullQueryParams = {};
-      merge(state.fullQueryParams, state.queryParams);
+      The string values provided for the template name, view, and controller
+      will eventually pass through to the resolver for lookup. See
+      Ember.Resolver for how these are mapped to JavaScript objects in your
+      application.
 
-      var targetRouteName = state.handlerInfos[state.handlerInfos.length-1].name;
-      router._deserializeQueryParams(targetRouteName, state.fullQueryParams);
-      return state.fullQueryParams;
-    }
+      Not all options need to be passed to `render`. Default values will be used
+      based on the name of the route specified in the router or the Route's
+      `controllerName`, `viewName` and `templateName` properties.
 
-    function getQueryParamsFor(route, state) {
-      state.queryParamsFor = state.queryParamsFor || {};
-      var name = route.routeName;
+      For example:
 
-      if (state.queryParamsFor[name]) { return state.queryParamsFor[name]; }
+      ```javascript
+      // router
+      Router.map(function() {
+        this.route('index');
+        this.resource('post', { path: '/posts/:post_id' });
+      });
+      ```
 
-      var fullQueryParams = getFullQueryParams(route.router, state);
+      ```javascript
+      // post route
+      PostRoute = App.Route.extend({
+        renderTemplate: function() {
+          this.render(); // all defaults apply
+        }
+      });
+      ```
 
-      var params = state.queryParamsFor[name] = {};
+      The name of the `PostRoute`, defined by the router, is `post`.
 
-      // Copy over all the query params for this route/controller into params hash.
-      var qpMeta = get(route, '_qp');
-      var qps = qpMeta.qps;
-      for (var i = 0, len = qps.length; i < len; ++i) {
-        // Put deserialized qp on params hash.
-        var qp = qps[i];
+      The following equivalent default options will be applied when
+      the Route calls `render`:
 
-        var qpValueWasPassedIn = (qp.prop in fullQueryParams);
-        params[qp.prop] = qpValueWasPassedIn ?
-                          fullQueryParams[qp.prop] :
-                          copyDefaultValue(qp.def);
-      }
+      ```javascript
+      //
+      this.render('post', {  // the template name associated with 'post' Route
+        into: 'application', // the parent route to 'post' Route
+        outlet: 'main',      // {{outlet}} and {{outlet 'main' are synonymous}},
+        view: 'post',        // the view associated with the 'post' Route
+        controller: 'post',  // the controller associated with the 'post' Route
+      })
+      ```
 
-      return params;
-    }
+      By default the controller's `model` will be the route's model, so it does not
+      need to be passed unless you wish to change which model is being used.
+
+      @method render
+      @param {String} name the name of the template to render
+      @param {Object} [options] the options
+      @param {String} [options.into] the template to render into,
+                      referenced by name. Defaults to the parent template
+      @param {String} [options.outlet] the outlet inside `options.template` to render into.
+                      Defaults to 'main'
+      @param {String|Object} [options.controller] the controller to use for this template,
+                      referenced by name or as a controller instance. Defaults to the Route's paired controller
+      @param {Object} [options.model] the model object to set on `options.controller`.
+                      Defaults to the return value of the Route's model hook
+    */
+    render: function(_name, options) {
+      Ember['default'].assert("The name in the given arguments is undefined", arguments.length > 0 ? !isNone['default'](arguments[0]) : true);
+
+      var namePassed = typeof _name === 'string' && !!_name;
+      var isDefaultRender = arguments.length === 0 || Ember['default'].isEmpty(arguments[0]);
+      var name;
 
-    function copyDefaultValue(value) {
-      if (isArray(value)) {
-        return Ember.A(value.slice());
+      if (typeof _name === 'object' && !options) {
+        name = this.routeName;
+        options = _name;
+      } else {
+        name = _name;
       }
-      return value;
-    }
 
-    __exports__["default"] = Route;
-  });
-enifed("ember-routing/system/router",
-  ["ember-metal/core","ember-metal/error","ember-metal/property_get","ember-metal/property_set","ember-metal/properties","ember-metal/computed","ember-metal/merge","ember-metal/run_loop","ember-runtime/system/string","ember-runtime/system/object","ember-runtime/mixins/evented","ember-routing/system/dsl","ember-views/views/view","ember-routing/location/api","ember-views/views/metamorph_view","ember-routing/utils","ember-metal/platform","router","router/transition","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // FEATURES, Logger, assert
-    var EmberError = __dependency2__["default"];
-    var get = __dependency3__.get;
-    var set = __dependency4__.set;
-    var defineProperty = __dependency5__.defineProperty;
-    var computed = __dependency6__.computed;
-    var merge = __dependency7__["default"];
-    var run = __dependency8__["default"];
-
-    var fmt = __dependency9__.fmt;
-    var EmberObject = __dependency10__["default"];
-    var Evented = __dependency11__["default"];
-    var EmberRouterDSL = __dependency12__["default"];
-    var EmberView = __dependency13__["default"];
-    var EmberLocation = __dependency14__["default"];
-    var _MetamorphView = __dependency15__["default"];
-    var routeArgs = __dependency16__.routeArgs;
-    var getActiveTargetName = __dependency16__.getActiveTargetName;
-    var stashParamNames = __dependency16__.stashParamNames;
-    var create = __dependency17__.create;
+      var renderOptions = buildRenderOptions(this, namePassed, isDefaultRender, name, options);
+      this.connections.push(renderOptions);
+      run['default'].once(this.router, '_setOutlets');
+    },
 
     /**
-    @module ember
-    @submodule ember-routing
-    */
+      Disconnects a view that has been rendered into an outlet.
 
-    var Router = __dependency18__["default"];
+      You may pass any or all of the following options to `disconnectOutlet`:
 
-    function K() { return this; }
+      * `outlet`: the name of the outlet to clear (default: 'main')
+      * `parentView`: the name of the view containing the outlet to clear
+         (default: the view rendered by the parent route)
 
-    var slice = [].slice;
+      Example:
 
-    /**
-      The `Ember.Router` class manages the application state and URLs. Refer to
-      the [routing guide](http://emberjs.com/guides/routing/) for documentation.
+      ```javascript
+      App.ApplicationRoute = App.Route.extend({
+        actions: {
+          showModal: function(evt) {
+            this.render(evt.modalName, {
+              outlet: 'modal',
+              into: 'application'
+            });
+          },
+          hideModal: function(evt) {
+            this.disconnectOutlet({
+              outlet: 'modal',
+              parentView: 'application'
+            });
+          }
+        }
+      });
+      ```
 
-      @class Router
-      @namespace Ember
-      @extends Ember.Object
-      @uses Ember.Evented
-    */
-    var EmberRouter = EmberObject.extend(Evented, {
-      /**
-        The `location` property determines the type of URL's that your
-        application will use.
+      Alternatively, you can pass the `outlet` name directly as a string.
+
+      Example:
+
+      ```javascript
+      hideModal: function(evt) {
+        this.disconnectOutlet('modal');
+      }
+      ```
 
-        The following location types are currently available:
+      @method disconnectOutlet
+      @param {Object|String} options the options hash or outlet name
+    */
+    disconnectOutlet: function(options) {
+      var outletName;
+      var parentView;
+      if (!options || typeof options === "string") {
+        outletName = options;
+      } else {
+        outletName = options.outlet;
+        parentView = options.parentView;
+      }
+      parentView = parentView && parentView.replace(/\//g, '.');
+      outletName = outletName || 'main';
+      this._disconnectOutlet(outletName, parentView);
+      for (var i = 0; i < this.router.router.currentHandlerInfos.length; i++) {
+        // This non-local state munging is sadly necessary to maintain
+        // backward compatibility with our existing semantics, which allow
+        // any route to disconnectOutlet things originally rendered by any
+        // other route. This should all get cut in 2.0.
+        this.router.router.
+          currentHandlerInfos[i].handler._disconnectOutlet(outletName, parentView);
+      }
+    },
+
+    _disconnectOutlet: function(outletName, parentView) {
+      var parent = parentRoute(this);
+      if (parent && parentView === parent.routeName) {
+        parentView = undefined;
+      }
+      for (var i = 0; i < this.connections.length; i++) {
+        var connection = this.connections[i];
+        if (connection.outlet === outletName && connection.into === parentView) {
+          // This neuters the disconnected outlet such that it doesn't
+          // render anything, but it leaves an entry in the outlet
+          // hierarchy so that any existing other renders that target it
+          // don't suddenly blow up. They will still stick themselves
+          // into its outlets, which won't render anywhere. All of this
+          // statefulness should get the machete in 2.0.
+          this.connections[i] = {
+            into: connection.into,
+            outlet: connection.outlet,
+            name: connection.name
+          };
+          run['default'].once(this.router, '_setOutlets');
+        }
+      }
+    },
 
-        * `hash`
-        * `history`
-        * `none`
+    willDestroy: function() {
+      this.teardownViews();
+    },
 
-        @property location
-        @default 'hash'
-        @see {Ember.Location}
-      */
-      location: 'hash',
+    /**
+      @private
 
-      /**
-       Represents the URL of the root of the application, often '/'. This prefix is
-       assumed on all routes defined on this router.
+      @method teardownViews
+    */
+    teardownViews: function() {
+      if (this.connections && this.connections.length > 0) {
+        this.connections = [];
+        run['default'].once(this.router, '_setOutlets');
+      }
+    }
+  });
 
-       @property rootURL
-       @default '/'
-      */
-      rootURL: '/',
+  var defaultQPMeta = {
+    qps: [],
+    map: {},
+    states: {}
+  };
 
-      init: function() {
-        this.router = this.constructor.router || this.constructor.map(K);
-        this._activeViews = {};
-        this._setupLocation();
-        this._qpCache = {};
-        this._queuedQPChanges = {};
+  function parentRoute(route) {
+    var handlerInfo = handlerInfoFor(route, route.router.router.state.handlerInfos, -1);
+    return handlerInfo && handlerInfo.handler;
+  }
 
-        if (get(this, 'namespace.LOG_TRANSITIONS_INTERNAL')) {
-          this.router.log = Ember.Logger.debug;
-        }
-      },
+  function handlerInfoFor(route, handlerInfos, _offset) {
+    if (!handlerInfos) { return; }
 
-      /**
-        Represents the current URL.
+    var offset = _offset || 0;
+    var current;
+    for (var i=0, l=handlerInfos.length; i<l; i++) {
+      current = handlerInfos[i].handler;
+      if (current === route) { return handlerInfos[i+offset]; }
+    }
+  }
 
-        @method url
-        @return {String} The current URL.
-      */
-      url: computed(function() {
-        return get(this, 'location').getURL();
-      }),
+  function buildRenderOptions(route, namePassed, isDefaultRender, name, options) {
+    var controller = options && options.controller;
+    var templateName;
+    var viewName;
+    var ViewClass;
+    var template;
+    var LOG_VIEW_LOOKUPS = property_get.get(route.router, 'namespace.LOG_VIEW_LOOKUPS');
+    var into = options && options.into && options.into.replace(/\//g, '.');
+    var outlet = (options && options.outlet) || 'main';
+
+    if (name) {
+      name = name.replace(/\//g, '.');
+      templateName = name;
+    } else {
+      name = route.routeName;
+      templateName = route.templateName || name;
+    }
 
-      /**
-        Initializes the current router instance and sets up the change handling
-        event listeners used by the instances `location` implementation.
+    if (!controller) {
+      if (namePassed) {
+        controller = route.container.lookup('controller:' + name) || route.controllerName || route.routeName;
+      } else {
+        controller = route.controllerName || route.container.lookup('controller:' + name);
+      }
+    }
 
-        A property named `initialURL` will be used to determine the initial URL.
-        If no value is found `/` will be used.
+    if (typeof controller === 'string') {
+      var controllerName = controller;
+      controller = route.container.lookup('controller:' + controllerName);
+      if (!controller) {
+        throw new EmberError['default']("You passed `controller: '" + controllerName + "'` into the `render` method, but no such controller could be found.");
+      }
+    }
 
-        @method startRouting
-        @private
-      */
-      startRouting: function() {
-        this.router = this.router || this.constructor.map(K);
+    if (options && options.model) {
+      controller.set('model', options.model);
+    }
 
-        var router = this.router;
-        var location = get(this, 'location');
-        var container = this.container;
-        var self = this;
-        var initialURL = get(this, 'initialURL');
-        var initialTransition;
+    viewName = options && options.view || namePassed && name || route.viewName || name;
+    ViewClass = route.container.lookupFactory('view:' + viewName);
+    template = route.container.lookup('template:' + templateName);
+    if (!ViewClass && !template) {
+      Ember['default'].assert("Could not find \"" + name + "\" template or view.", isDefaultRender);
+      if (LOG_VIEW_LOOKUPS) {
+        Ember['default'].Logger.info("Could not find \"" + name + "\" template or view. Nothing will be rendered", { fullName: 'template:' + name });
+      }
+    }
 
-        // Allow the Location class to cancel the router setup while it refreshes
-        // the page
-        if (get(location, 'cancelRouterSetup')) {
-          return;
-        }
+    var parent;
+    if (into && (parent = parentRoute(route)) && into === parentRoute(route).routeName) {
+      into = undefined;
+    }
 
-        this._setupRouter(router, location);
+    var renderOptions = {
+      into: into,
+      outlet: outlet,
+      name: name,
+      controller: controller,
+      ViewClass: ViewClass,
+      template: template
+    };
 
-        container.register('view:default', _MetamorphView);
-        container.register('view:toplevel', EmberView.extend());
+    return renderOptions;
+  }
 
-        location.onUpdateURL(function(url) {
-          self.handleURL(url);
-        });
+  function getFullQueryParams(router, state) {
+    if (state.fullQueryParams) { return state.fullQueryParams; }
 
-        if (typeof initialURL === "undefined") {
-          initialURL = location.getURL();
-        }
-        initialTransition = this.handleURL(initialURL);
-        if (initialTransition && initialTransition.error) {
-          throw initialTransition.error;
-        }
-      },
+    state.fullQueryParams = {};
+    merge['default'](state.fullQueryParams, state.queryParams);
 
-      /**
-        Handles updating the paths and notifying any listeners of the URL
-        change.
+    var targetRouteName = state.handlerInfos[state.handlerInfos.length-1].name;
+    router._deserializeQueryParams(targetRouteName, state.fullQueryParams);
+    return state.fullQueryParams;
+  }
 
-        Triggers the router level `didTransition` hook.
+  function getQueryParamsFor(route, state) {
+    state.queryParamsFor = state.queryParamsFor || {};
+    var name = route.routeName;
 
-        @method didTransition
-        @private
-        @since 1.2.0
-      */
-      didTransition: function(infos) {
-        updatePaths(this);
+    if (state.queryParamsFor[name]) { return state.queryParamsFor[name]; }
 
-        this._cancelLoadingEvent();
+    var fullQueryParams = getFullQueryParams(route.router, state);
 
-        this.notifyPropertyChange('url');
+    var params = state.queryParamsFor[name] = {};
 
-        // Put this in the runloop so url will be accurate. Seems
-        // less surprising than didTransition being out of sync.
-        run.once(this, this.trigger, 'didTransition');
+    // Copy over all the query params for this route/controller into params hash.
+    var qpMeta = property_get.get(route, '_qp');
+    var qps = qpMeta.qps;
+    for (var i = 0, len = qps.length; i < len; ++i) {
+      // Put deserialized qp on params hash.
+      var qp = qps[i];
 
-        if (get(this, 'namespace').LOG_TRANSITIONS) {
-          Ember.Logger.log("Transitioned into '" + EmberRouter._routePath(infos) + "'");
-        }
-      },
+      var qpValueWasPassedIn = (qp.prop in fullQueryParams);
+      params[qp.prop] = qpValueWasPassedIn ?
+                        fullQueryParams[qp.prop] :
+                        copyDefaultValue(qp.def);
+    }
 
-      handleURL: function(url) {
-        // Until we have an ember-idiomatic way of accessing #hashes, we need to
-        // remove it because router.js doesn't know how to handle it.
-        url = url.split(/#(.+)?/)[0];
-        return this._doURLTransition('handleURL', url);
-      },
+    return params;
+  }
 
-      _doURLTransition: function(routerJsMethod, url) {
-        var transition = this.router[routerJsMethod](url || '/');
-        listenForTransitionErrors(transition);
-        return transition;
-      },
+  function copyDefaultValue(value) {
+    if (utils.isArray(value)) {
+      return Ember['default'].A(value.slice());
+    }
+    return value;
+  }
 
-      transitionTo: function() {
-        var args = slice.call(arguments);
-        var queryParams;
-        if (resemblesURL(args[0])) {
-          return this._doURLTransition('transitionTo', args[0]);
-        }
+  exports['default'] = Route;
 
-        var possibleQueryParams = args[args.length-1];
-        if (possibleQueryParams && possibleQueryParams.hasOwnProperty('queryParams')) {
-          queryParams = args.pop().queryParams;
-        } else {
-          queryParams = {};
-        }
+});
+enifed('ember-routing/system/router', ['exports', 'ember-metal/core', 'ember-metal/error', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/properties', 'ember-metal/computed', 'ember-metal/merge', 'ember-metal/run_loop', 'ember-runtime/system/string', 'ember-runtime/system/object', 'ember-runtime/mixins/evented', 'ember-routing/system/dsl', 'ember-routing/location/api', 'ember-routing/utils', 'ember-metal/platform/create', './router_state', 'router', 'router/transition'], function (exports, Ember, EmberError, property_get, property_set, properties, computed, merge, run, string, EmberObject, Evented, EmberRouterDSL, EmberLocation, utils, create, RouterState, Router) {
 
-        var targetRouteName = args.shift();
-        return this._doTransition(targetRouteName, args, queryParams);
-      },
+  'use strict';
 
-      intermediateTransitionTo: function() {
-        this.router.intermediateTransitionTo.apply(this.router, arguments);
+  function K() { return this; }
 
-        updatePaths(this);
+  var slice = [].slice;
 
-        var infos = this.router.currentHandlerInfos;
-        if (get(this, 'namespace').LOG_TRANSITIONS) {
-          Ember.Logger.log("Intermediate-transitioned into '" + EmberRouter._routePath(infos) + "'");
-        }
-      },
+  /**
+    The `Ember.Router` class manages the application state and URLs. Refer to
+    the [routing guide](http://emberjs.com/guides/routing/) for documentation.
 
-      replaceWith: function() {
-        return this.transitionTo.apply(this, arguments).method('replace');
-      },
+    @class Router
+    @namespace Ember
+    @extends Ember.Object
+    @uses Ember.Evented
+  */
+  var EmberRouter = EmberObject['default'].extend(Evented['default'], {
+    /**
+      The `location` property determines the type of URL's that your
+      application will use.
 
-      generate: function() {
-        var url = this.router.generate.apply(this.router, arguments);
-        return this.location.formatURL(url);
-      },
+      The following location types are currently available:
 
-      /**
-        Determines if the supplied route is currently active.
+      * `hash`
+      * `history`
+      * `none`
 
-        @method isActive
-        @param routeName
-        @return {Boolean}
-        @private
-      */
-      isActive: function(routeName) {
-        var router = this.router;
-        return router.isActive.apply(router, arguments);
-      },
+      @property location
+      @default 'hash'
+      @see {Ember.Location}
+    */
+    location: 'hash',
 
-      /**
-        An alternative form of `isActive` that doesn't require
-        manual concatenation of the arguments into a single
-        array.
-
-        @method isActiveIntent
-        @param routeName
-        @param models
-        @param queryParams
-        @return {Boolean}
-        @private
-        @since 1.7.0
-      */
-      isActiveIntent: function(routeName, models, queryParams) {
-        var router = this.router;
-        return router.isActive.apply(router, arguments);
-      },
+    /**
+     Represents the URL of the root of the application, often '/'. This prefix is
+     assumed on all routes defined on this router.
 
-      send: function(name, context) {
-        this.router.trigger.apply(this.router, arguments);
-      },
+     @property rootURL
+     @default '/'
+    */
+    rootURL: '/',
 
-      /**
-        Does this router instance have the given route.
+    _initRouterJs: function(moduleBasedResolver) {
+      var router = this.router = new Router['default']();
+      router.triggerEvent = triggerEvent;
 
-        @method hasRoute
-        @return {Boolean}
-        @private
-      */
-      hasRoute: function(route) {
-        return this.router.hasRoute(route);
-      },
+      router._triggerWillChangeContext = K;
+      router._triggerWillLeave = K;
 
-      /**
-        Resets the state of the router by clearing the current route
-        handlers and deactivating them.
+      var dslCallbacks = this.constructor.dslCallbacks || [K];
+      var dsl = new EmberRouterDSL['default'](null, {
+        enableLoadingSubstates: !!moduleBasedResolver
+      });
 
-        @private
-        @method reset
-       */
-      reset: function() {
-        this.router.reset();
-      },
+      function generateDSL() {
+        this.resource('application', { path: "/", overrideNameAssertion: true }, function() {
+          for (var i=0; i < dslCallbacks.length; i++) {
+            dslCallbacks[i].call(this);
+          }
+        });
+      }
 
-      _lookupActiveView: function(templateName) {
-        var active = this._activeViews[templateName];
-        return active && active[0];
-      },
+      generateDSL.call(dsl);
 
-      _connectActiveView: function(templateName, view) {
-        var existing = this._activeViews[templateName];
+      if (property_get.get(this, 'namespace.LOG_TRANSITIONS_INTERNAL')) {
+        router.log = Ember['default'].Logger.debug;
+      }
 
-        if (existing) {
-          existing[0].off('willDestroyElement', this, existing[1]);
-        }
+      router.map(dsl.generate());
+    },
 
-        function disconnectActiveView() {
-          delete this._activeViews[templateName];
-        }
+    init: function() {
+      this._activeViews = {};
+      this._setupLocation();
+      this._qpCache = {};
+      this._queuedQPChanges = {};
+    },
 
-        this._activeViews[templateName] = [view, disconnectActiveView];
-        view.one('willDestroyElement', this, disconnectActiveView);
-      },
+    /**
+      Represents the current URL.
 
-      _setupLocation: function() {
-        var location = get(this, 'location');
-        var rootURL = get(this, 'rootURL');
+      @method url
+      @return {String} The current URL.
+    */
+    url: computed.computed(function() {
+      return property_get.get(this, 'location').getURL();
+    }),
 
-        if (rootURL && this.container && !this.container.has('-location-setting:root-url')) {
-          this.container.register('-location-setting:root-url', rootURL, {
-            instantiate: false
-          });
-        }
+    /**
+      Initializes the current router instance and sets up the change handling
+      event listeners used by the instances `location` implementation.
 
-        if ('string' === typeof location && this.container) {
-          var resolvedLocation = this.container.lookup('location:' + location);
+      A property named `initialURL` will be used to determine the initial URL.
+      If no value is found `/` will be used.
 
-          if ('undefined' !== typeof resolvedLocation) {
-            location = set(this, 'location', resolvedLocation);
-          } else {
-            // Allow for deprecated registration of custom location API's
-            var options = {
-              implementation: location
-            };
+      @method startRouting
+      @private
+    */
+    startRouting: function(moduleBasedResolver) {
+      var initialURL = property_get.get(this, 'initialURL');
+      var location = property_get.get(this, 'location');
 
-            location = set(this, 'location', EmberLocation.create(options));
-          }
+      if (this.setupRouter(moduleBasedResolver, location)) {
+        if (typeof initialURL === "undefined") {
+          initialURL = property_get.get(this, 'location').getURL();
         }
-
-        if (location !== null && typeof location === 'object') {
-          if (rootURL && typeof rootURL === 'string') {
-            location.rootURL = rootURL;
-          }
-
-          // ensure that initState is called AFTER the rootURL is set on
-          // the location instance
-          if (typeof location.initState === 'function') {
-            location.initState();
-          }
+        var initialTransition = this.handleURL(initialURL);
+        if (initialTransition && initialTransition.error) {
+          throw initialTransition.error;
         }
-      },
+      }
+    },
 
-      _getHandlerFunction: function() {
-        var seen = create(null);
-        var container = this.container;
-        var DefaultRoute = container.lookupFactory('route:basic');
-        var self = this;
+    setupRouter: function(moduleBasedResolver) {
+      this._initRouterJs(moduleBasedResolver);
 
-        return function(name) {
-          var routeName = 'route:' + name;
-          var handler = container.lookup(routeName);
+      var router = this.router;
+      var location = property_get.get(this, 'location');
+      var self = this;
 
-          if (seen[name]) {
-            return handler;
-          }
+      // Allow the Location class to cancel the router setup while it refreshes
+      // the page
+      if (property_get.get(location, 'cancelRouterSetup')) {
+        return false;
+      }
 
-          seen[name] = true;
+      this._setupRouter(router, location);
 
-          if (!handler) {
-            container.register(routeName, DefaultRoute.extend());
-            handler = container.lookup(routeName);
+      location.onUpdateURL(function(url) {
+        self.handleURL(url);
+      });
 
-            if (get(self, 'namespace.LOG_ACTIVE_GENERATION')) {
-              Ember.Logger.info("generated -> " + routeName, { fullName: routeName });
-            }
-          }
+      return true;
+    },
 
-          handler.routeName = name;
-          return handler;
-        };
-      },
+    /**
+      Handles updating the paths and notifying any listeners of the URL
+      change.
 
-      _setupRouter: function(router, location) {
-        var lastURL, emberRouter = this;
+      Triggers the router level `didTransition` hook.
 
-        router.getHandler = this._getHandlerFunction();
+      @method didTransition
+      @private
+      @since 1.2.0
+    */
+    didTransition: function(infos) {
+      updatePaths(this);
 
-        var doUpdateURL = function() {
-          location.setURL(lastURL);
-        };
+      this._cancelSlowTransitionTimer();
 
-        router.updateURL = function(path) {
-          lastURL = path;
-          run.once(doUpdateURL);
-        };
+      this.notifyPropertyChange('url');
+      this.set('currentState', this.targetState);
 
-        if (location.replaceURL) {
-          var doReplaceURL = function() {
-            location.replaceURL(lastURL);
-          };
+      // Put this in the runloop so url will be accurate. Seems
+      // less surprising than didTransition being out of sync.
+      run['default'].once(this, this.trigger, 'didTransition');
 
-          router.replaceURL = function(path) {
-            lastURL = path;
-            run.once(doReplaceURL);
-          };
-        }
+      if (property_get.get(this, 'namespace').LOG_TRANSITIONS) {
+        Ember['default'].Logger.log("Transitioned into '" + EmberRouter._routePath(infos) + "'");
+      }
+    },
 
-        router.didTransition = function(infos) {
-          emberRouter.didTransition(infos);
-        };
-      },
+    _setOutlets: function() {
+      var handlerInfos = this.router.currentHandlerInfos;
+      var route;
+      var defaultParentState;
+      var liveRoutes = null;
 
-      _serializeQueryParams: function(targetRouteName, queryParams) {
-        var groupedByUrlKey = {};
+      if (!handlerInfos) {
+        return;
+      }
 
-        forEachQueryParam(this, targetRouteName, queryParams, function(key, value, qp) {
-          var urlKey = qp.urlKey;
-          if (!groupedByUrlKey[urlKey]) {
-            groupedByUrlKey[urlKey] = [];
+      for (var i = 0; i < handlerInfos.length; i++) {
+        route = handlerInfos[i].handler;
+        var connections = route.connections;
+        var ownState;
+        for (var j = 0; j < connections.length; j++) {
+          var appended = appendLiveRoute(liveRoutes, defaultParentState, connections[j]);
+          liveRoutes = appended.liveRoutes;
+          if (appended.ownState.render.name === route.routeName || appended.ownState.render.outlet === 'main') {
+            ownState = appended.ownState;
           }
-          groupedByUrlKey[urlKey].push({
-            qp: qp,
-            value: value
-          });
-          delete queryParams[key];
-        });
-
-        for (var key in groupedByUrlKey) {
-          var qps = groupedByUrlKey[key];
-          Ember.assert(fmt("You're not allowed to have more than one controller " +
-                           "property map to the same query param key, but both " +
-                           "`%@` and `%@` map to `%@`. You can fix this by mapping " +
-                           "one of the controller properties to a different query " +
-                           "param key via the `as` config option, e.g. `%@: { as: 'other-%@' }`",
-                           [qps[0].qp.fprop, qps[1] ? qps[1].qp.fprop : "", qps[0].qp.urlKey, qps[0].qp.prop, qps[0].qp.prop]), qps.length <= 1);
-          var qp = qps[0].qp;
-          queryParams[qp.urlKey] = qp.route.serializeQueryParam(qps[0].value, qp.urlKey, qp.type);
         }
-      },
-
-      _deserializeQueryParams: function(targetRouteName, queryParams) {
-        forEachQueryParam(this, targetRouteName, queryParams, function(key, value, qp) {
-          delete queryParams[key];
-          queryParams[qp.prop] = qp.route.deserializeQueryParam(value, qp.urlKey, qp.type);
-        });
-      },
-
-      _pruneDefaultQueryParamValues: function(targetRouteName, queryParams) {
-        var qps = this._queryParamsFor(targetRouteName);
-        for (var key in queryParams) {
-          var qp = qps.map[key];
-          if (qp && qp.sdef === queryParams[key]) {
-            delete queryParams[key];
-          }
+        if (connections.length === 0) {
+          ownState = representEmptyRoute(liveRoutes, defaultParentState, route);
         }
-      },
+        defaultParentState = ownState;
+      }
+      if (!this._toplevelView) {
+        var OutletView = this.container.lookupFactory('view:-outlet');
+        this._toplevelView = OutletView.create({ _isTopLevel: true });
+        var instance = this.container.lookup('-application-instance:main');
+        instance.didCreateRootView(this._toplevelView);
+      }
+      this._toplevelView.setOutletState(liveRoutes);
+    },
 
-      _doTransition: function(_targetRouteName, models, _queryParams) {
-        var targetRouteName = _targetRouteName || getActiveTargetName(this.router);
-        Ember.assert("The route " + targetRouteName + " was not found", targetRouteName && this.router.hasRoute(targetRouteName));
+    /**
+      Handles notifying any listeners of an impending URL
+      change.
 
-        var queryParams = {};
-        merge(queryParams, _queryParams);
-        this._prepareQueryParams(targetRouteName, models, queryParams);
+      Triggers the router level `willTransition` hook.
 
-        var transitionArgs = routeArgs(targetRouteName, models, queryParams);
-        var transitionPromise = this.router.transitionTo.apply(this.router, transitionArgs);
+      @method willTransition
+      @private
+      @since 1.11.0
+    */
+    willTransition: function(oldInfos, newInfos, transition) {
+      run['default'].once(this, this.trigger, 'willTransition', transition);
 
-        listenForTransitionErrors(transitionPromise);
+      if (property_get.get(this, 'namespace').LOG_TRANSITIONS) {
+        Ember['default'].Logger.log("Preparing to transition from '" + EmberRouter._routePath(oldInfos) + "' to '" + EmberRouter._routePath(newInfos) + "'");
+      }
+    },
 
-        return transitionPromise;
-      },
+    handleURL: function(url) {
+      // Until we have an ember-idiomatic way of accessing #hashes, we need to
+      // remove it because router.js doesn't know how to handle it.
+      url = url.split(/#(.+)?/)[0];
+      return this._doURLTransition('handleURL', url);
+    },
 
-      _prepareQueryParams: function(targetRouteName, models, queryParams) {
-        this._hydrateUnsuppliedQueryParams(targetRouteName, models, queryParams);
-        this._serializeQueryParams(targetRouteName, queryParams);
-        this._pruneDefaultQueryParamValues(targetRouteName, queryParams);
-      },
+    _doURLTransition: function(routerJsMethod, url) {
+      var transition = this.router[routerJsMethod](url || '/');
+      didBeginTransition(transition, this);
+      return transition;
+    },
 
-      /**
-        Returns a merged query params meta object for a given route.
-        Useful for asking a route what its known query params are.
-       */
-      _queryParamsFor: function(leafRouteName) {
-        if (this._qpCache[leafRouteName]) {
-          return this._qpCache[leafRouteName];
-        }
+    transitionTo: function() {
+      var args = slice.call(arguments);
+      var queryParams;
+      if (resemblesURL(args[0])) {
+        return this._doURLTransition('transitionTo', args[0]);
+      }
 
-        var map = {}, qps = [];
-        this._qpCache[leafRouteName] = {
-          map: map,
-          qps: qps
-        };
+      var possibleQueryParams = args[args.length-1];
+      if (possibleQueryParams && possibleQueryParams.hasOwnProperty('queryParams')) {
+        queryParams = args.pop().queryParams;
+      } else {
+        queryParams = {};
+      }
 
-        var routerjs = this.router;
-        var recogHandlerInfos = routerjs.recognizer.handlersFor(leafRouteName);
+      var targetRouteName = args.shift();
+      return this._doTransition(targetRouteName, args, queryParams);
+    },
 
-        for (var i = 0, len = recogHandlerInfos.length; i < len; ++i) {
-          var recogHandler = recogHandlerInfos[i];
-          var route = routerjs.getHandler(recogHandler.handler);
-          var qpMeta = get(route, '_qp');
+    intermediateTransitionTo: function() {
+      this.router.intermediateTransitionTo.apply(this.router, arguments);
 
-          if (!qpMeta) { continue; }
+      updatePaths(this);
 
-          merge(map, qpMeta.map);
-          qps.push.apply(qps, qpMeta.qps);
-        }
+      var infos = this.router.currentHandlerInfos;
+      if (property_get.get(this, 'namespace').LOG_TRANSITIONS) {
+        Ember['default'].Logger.log("Intermediate-transitioned into '" + EmberRouter._routePath(infos) + "'");
+      }
+    },
 
-        return {
-          qps: qps,
-          map: map
-        };
-      },
+    replaceWith: function() {
+      return this.transitionTo.apply(this, arguments).method('replace');
+    },
 
-      /*
-        becomeResolved: function(payload, resolvedContext) {
-          var params = this.serialize(resolvedContext);
+    generate: function() {
+      var url = this.router.generate.apply(this.router, arguments);
+      return this.location.formatURL(url);
+    },
 
-          if (payload) {
-            this.stashResolvedModel(payload, resolvedContext);
-            payload.params = payload.params || {};
-            payload.params[this.name] = params;
-          }
+    /**
+      Determines if the supplied route is currently active.
 
-          return this.factory('resolved', {
-            context: resolvedContext,
-            name: this.name,
-            handler: this.handler,
-            params: params
-          });
-        },
-      */
+      @method isActive
+      @param routeName
+      @return {Boolean}
+      @private
+    */
+    isActive: function(routeName) {
+      var router = this.router;
+      return router.isActive.apply(router, arguments);
+    },
 
-      _hydrateUnsuppliedQueryParams: function(leafRouteName, contexts, queryParams) {
-        var state = calculatePostTransitionState(this, leafRouteName, contexts);
-        var handlerInfos = state.handlerInfos;
-        var appCache = this._bucketCache;
+    /**
+      An alternative form of `isActive` that doesn't require
+      manual concatenation of the arguments into a single
+      array.
 
-        stashParamNames(this, handlerInfos);
+      @method isActiveIntent
+      @param routeName
+      @param models
+      @param queryParams
+      @return {Boolean}
+      @private
+      @since 1.7.0
+    */
+    isActiveIntent: function(routeName, models, queryParams) {
+      return this.currentState.isActiveIntent(routeName, models, queryParams);
+    },
 
-        for (var i = 0, len = handlerInfos.length; i < len; ++i) {
-          var route = handlerInfos[i].handler;
-          var qpMeta = get(route, '_qp');
-
-          for (var j = 0, qpLen = qpMeta.qps.length; j < qpLen; ++j) {
-            var qp = qpMeta.qps[j];
-            var presentProp = qp.prop in queryParams  && qp.prop ||
-                              qp.fprop in queryParams && qp.fprop;
-
-            if (presentProp) {
-              if (presentProp !== qp.fprop) {
-                queryParams[qp.fprop] = queryParams[presentProp];
-                delete queryParams[presentProp];
-              }
-            } else {
-              var controllerProto = qp.cProto;
-              var cacheMeta = get(controllerProto, '_cacheMeta');
+    send: function(name, context) {
+      this.router.trigger.apply(this.router, arguments);
+    },
 
-              var cacheKey = controllerProto._calculateCacheKey(qp.ctrl, cacheMeta[qp.prop].parts, state.params);
-              queryParams[qp.fprop] = appCache.lookup(cacheKey, qp.prop, qp.def);
-            }
-          }
-        }
-      },
+    /**
+      Does this router instance have the given route.
 
-      _scheduleLoadingEvent: function(transition, originRoute) {
-        this._cancelLoadingEvent();
-        this._loadingStateTimer = run.scheduleOnce('routerTransitions', this, '_fireLoadingEvent', transition, originRoute);
-      },
+      @method hasRoute
+      @return {Boolean}
+      @private
+    */
+    hasRoute: function(route) {
+      return this.router.hasRoute(route);
+    },
 
-      _fireLoadingEvent: function(transition, originRoute) {
-        if (!this.router.activeTransition) {
-          // Don't fire an event if we've since moved on from
-          // the transition that put us in a loading state.
-          return;
-        }
+    /**
+      Resets the state of the router by clearing the current route
+      handlers and deactivating them.
 
-        transition.trigger(true, 'loading', transition, originRoute);
-      },
+      @private
+      @method reset
+     */
+    reset: function() {
+      if (this.router) {
+        this.router.reset();
+      }
+    },
 
-      _cancelLoadingEvent: function () {
-        if (this._loadingStateTimer) {
-          run.cancel(this._loadingStateTimer);
-        }
-        this._loadingStateTimer = null;
+    willDestroy: function() {
+      if (this._toplevelView) {
+        this._toplevelView.destroy();
+        this._toplevelView = null;
       }
-    });
+      this._super.apply(this, arguments);
+      this.reset();
+    },
 
-    /*
-      Helper function for iterating root-ward, starting
-      from (but not including) the provided `originRoute`.
+    _lookupActiveView: function(templateName) {
+      var active = this._activeViews[templateName];
+      return active && active[0];
+    },
 
-      Returns true if the last callback fired requested
-      to bubble upward.
+    _connectActiveView: function(templateName, view) {
+      var existing = this._activeViews[templateName];
 
-      @private
-     */
-    function forEachRouteAbove(originRoute, transition, callback) {
-      var handlerInfos = transition.state.handlerInfos;
-      var originRouteFound = false;
-      var handlerInfo, route;
+      if (existing) {
+        existing[0].off('willDestroyElement', this, existing[1]);
+      }
 
-      for (var i = handlerInfos.length - 1; i >= 0; --i) {
-        handlerInfo = handlerInfos[i];
-        route = handlerInfo.handler;
+      function disconnectActiveView() {
+        delete this._activeViews[templateName];
+      }
 
-        if (!originRouteFound) {
-          if (originRoute === route) {
-            originRouteFound = true;
-          }
-          continue;
-        }
+      this._activeViews[templateName] = [view, disconnectActiveView];
+      view.one('willDestroyElement', this, disconnectActiveView);
+    },
 
-        if (callback(route, handlerInfos[i + 1].handler) !== true) {
-          return false;
-        }
+    _setupLocation: function() {
+      var location = property_get.get(this, 'location');
+      var rootURL = property_get.get(this, 'rootURL');
+
+      if (rootURL && this.container && !this.container._registry.has('-location-setting:root-url')) {
+        this.container._registry.register('-location-setting:root-url', rootURL, {
+          instantiate: false
+        });
       }
-      return true;
-    }
 
-    // These get invoked when an action bubbles above ApplicationRoute
-    // and are not meant to be overridable.
-    var defaultActionHandlers = {
+      if ('string' === typeof location && this.container) {
+        var resolvedLocation = this.container.lookup('location:' + location);
 
-      willResolveModel: function(transition, originRoute) {
-        originRoute.router._scheduleLoadingEvent(transition, originRoute);
-      },
+        if ('undefined' !== typeof resolvedLocation) {
+          location = property_set.set(this, 'location', resolvedLocation);
+        } else {
+          // Allow for deprecated registration of custom location API's
+          var options = {
+            implementation: location
+          };
 
-      error: function(error, transition, originRoute) {
-        // Attempt to find an appropriate error substate to enter.
-        var router = originRoute.router;
+          location = property_set.set(this, 'location', EmberLocation['default'].create(options));
+        }
+      }
 
-        var tryTopLevel = forEachRouteAbove(originRoute, transition, function(route, childRoute) {
-          var childErrorRouteName = findChildRouteName(route, childRoute, 'error');
-          if (childErrorRouteName) {
-            router.intermediateTransitionTo(childErrorRouteName, error);
-            return;
-          }
-          return true;
-        });
+      if (location !== null && typeof location === 'object') {
+        if (rootURL && typeof rootURL === 'string') {
+          location.rootURL = rootURL;
+        }
 
-        if (tryTopLevel) {
-          // Check for top-level error state to enter.
-          if (routeHasBeenDefined(originRoute.router, 'application_error')) {
-            router.intermediateTransitionTo('application_error', error);
-            return;
-          }
+        // ensure that initState is called AFTER the rootURL is set on
+        // the location instance
+        if (typeof location.initState === 'function') {
+          location.initState();
         }
+      }
+    },
 
-        logError(error, 'Error while processing route: ' + transition.targetName);
-      },
+    _getHandlerFunction: function() {
+      var seen = create['default'](null);
+      var container = this.container;
+      var DefaultRoute = container.lookupFactory('route:basic');
+      var self = this;
 
-      loading: function(transition, originRoute) {
-        // Attempt to find an appropriate loading substate to enter.
-        var router = originRoute.router;
+      return function(name) {
+        var routeName = 'route:' + name;
+        var handler = container.lookup(routeName);
 
-        var tryTopLevel = forEachRouteAbove(originRoute, transition, function(route, childRoute) {
-          var childLoadingRouteName = findChildRouteName(route, childRoute, 'loading');
+        if (seen[name]) {
+          return handler;
+        }
 
-          if (childLoadingRouteName) {
-            router.intermediateTransitionTo(childLoadingRouteName);
-            return;
-          }
+        seen[name] = true;
 
-          // Don't bubble above pivot route.
-          if (transition.pivotHandler !== route) {
-            return true;
-          }
-        });
+        if (!handler) {
+          container._registry.register(routeName, DefaultRoute.extend());
+          handler = container.lookup(routeName);
 
-        if (tryTopLevel) {
-          // Check for top-level loading state to enter.
-          if (routeHasBeenDefined(originRoute.router, 'application_loading')) {
-            router.intermediateTransitionTo('application_loading');
-            return;
+          if (property_get.get(self, 'namespace.LOG_ACTIVE_GENERATION')) {
+            Ember['default'].Logger.info("generated -> " + routeName, { fullName: routeName });
           }
         }
-      }
-    };
 
-    function logError(error, initialMessage) {
-      var errorArgs = [];
+        handler.routeName = name;
+        return handler;
+      };
+    },
 
-      if (initialMessage) { errorArgs.push(initialMessage); }
+    _setupRouter: function(router, location) {
+      var lastURL;
+      var emberRouter = this;
 
-      if (error) {
-        if (error.message) { errorArgs.push(error.message); }
-        if (error.stack)   { errorArgs.push(error.stack); }
+      router.getHandler = this._getHandlerFunction();
 
-        if (typeof error === "string") { errorArgs.push(error); }
-      }
+      var doUpdateURL = function() {
+        location.setURL(lastURL);
+      };
 
-      Ember.Logger.error.apply(this, errorArgs);
-    }
+      router.updateURL = function(path) {
+        lastURL = path;
+        run['default'].once(doUpdateURL);
+      };
 
-    function findChildRouteName(parentRoute, originatingChildRoute, name) {
-      var router = parentRoute.router;
-      var childName;
-      var targetChildRouteName = originatingChildRoute.routeName.split('.').pop();
-      var namespace = parentRoute.routeName === 'application' ? '' : parentRoute.routeName + '.';
+      if (location.replaceURL) {
+        var doReplaceURL = function() {
+          location.replaceURL(lastURL);
+        };
 
-      
-      // Second, try general loading state, e.g. 'loading'
-      childName = namespace + name;
-      if (routeHasBeenDefined(router, childName)) {
-        return childName;
+        router.replaceURL = function(path) {
+          lastURL = path;
+          run['default'].once(doReplaceURL);
+        };
       }
-    }
 
-    function routeHasBeenDefined(router, name) {
-      var container = router.container;
-      return router.hasRoute(name) &&
-             (container.has('template:' + name) || container.has('route:' + name));
-    }
+      router.didTransition = function(infos) {
+        emberRouter.didTransition(infos);
+      };
 
-    function triggerEvent(handlerInfos, ignoreFailure, args) {
-      var name = args.shift();
 
-      if (!handlerInfos) {
-        if (ignoreFailure) { return; }
-        throw new EmberError("Can't trigger action '" + name + "' because your app hasn't finished transitioning into its first route. To trigger an action on destination routes during a transition, you can call `.send()` on the `Transition` object passed to the `model/beforeModel/afterModel` hooks.");
-      }
+        router.willTransition = function(oldInfos, newInfos, transition) {
+          emberRouter.willTransition(oldInfos, newInfos, transition);
+        };
 
-      var eventWasHandled = false;
-      var handlerInfo, handler;
+    },
 
-      for (var i = handlerInfos.length - 1; i >= 0; i--) {
-        handlerInfo = handlerInfos[i];
-        handler = handlerInfo.handler;
+    _serializeQueryParams: function(targetRouteName, queryParams) {
+      var groupedByUrlKey = {};
 
-        if (handler._actions && handler._actions[name]) {
-          if (handler._actions[name].apply(handler, args) === true) {
-            eventWasHandled = true;
-          } else {
-            return;
-          }
+      forEachQueryParam(this, targetRouteName, queryParams, function(key, value, qp) {
+        var urlKey = qp.urlKey;
+        if (!groupedByUrlKey[urlKey]) {
+          groupedByUrlKey[urlKey] = [];
         }
-      }
-
-      if (defaultActionHandlers[name]) {
-        defaultActionHandlers[name].apply(null, args);
-        return;
-      }
+        groupedByUrlKey[urlKey].push({
+          qp: qp,
+          value: value
+        });
+        delete queryParams[key];
+      });
 
-      if (!eventWasHandled && !ignoreFailure) {
-        throw new EmberError("Nothing handled the action '" + name + "'. If you did handle the action, this error can be caused by returning true from an action handler in a controller, causing the action to bubble.");
+      for (var key in groupedByUrlKey) {
+        var qps = groupedByUrlKey[key];
+        Ember['default'].assert(string.fmt("You're not allowed to have more than one controller " +
+                         "property map to the same query param key, but both " +
+                         "`%@` and `%@` map to `%@`. You can fix this by mapping " +
+                         "one of the controller properties to a different query " +
+                         "param key via the `as` config option, e.g. `%@: { as: 'other-%@' }`",
+                         [qps[0].qp.fprop, qps[1] ? qps[1].qp.fprop : "", qps[0].qp.urlKey, qps[0].qp.prop, qps[0].qp.prop]), qps.length <= 1);
+        var qp = qps[0].qp;
+        queryParams[qp.urlKey] = qp.route.serializeQueryParam(qps[0].value, qp.urlKey, qp.type);
       }
-    }
+    },
 
-    function calculatePostTransitionState(emberRouter, leafRouteName, contexts) {
-      var routerjs = emberRouter.router;
-      var state = routerjs.applyIntent(leafRouteName, contexts);
-      var handlerInfos = state.handlerInfos;
-      var params = state.params;
+    _deserializeQueryParams: function(targetRouteName, queryParams) {
+      forEachQueryParam(this, targetRouteName, queryParams, function(key, value, qp) {
+        delete queryParams[key];
+        queryParams[qp.prop] = qp.route.deserializeQueryParam(value, qp.urlKey, qp.type);
+      });
+    },
 
-      for (var i = 0, len = handlerInfos.length; i < len; ++i) {
-        var handlerInfo = handlerInfos[i];
-        if (!handlerInfo.isResolved) {
-          handlerInfo = handlerInfo.becomeResolved(null, handlerInfo.context);
+    _pruneDefaultQueryParamValues: function(targetRouteName, queryParams) {
+      var qps = this._queryParamsFor(targetRouteName);
+      for (var key in queryParams) {
+        var qp = qps.map[key];
+        if (qp && qp.sdef === queryParams[key]) {
+          delete queryParams[key];
         }
-        params[handlerInfo.name] = handlerInfo.params;
       }
-      return state;
-    }
+    },
 
-    function updatePaths(router) {
-      var appController = router.container.lookup('controller:application');
+    _doTransition: function(_targetRouteName, models, _queryParams) {
+      var targetRouteName = _targetRouteName || utils.getActiveTargetName(this.router);
+      Ember['default'].assert("The route " + targetRouteName + " was not found", targetRouteName && this.router.hasRoute(targetRouteName));
 
-      if (!appController) {
-        // appController might not exist when top-level loading/error
-        // substates have been entered since ApplicationRoute hasn't
-        // actually been entered at that point.
-        return;
-      }
+      var queryParams = {};
+      merge['default'](queryParams, _queryParams);
+      this._prepareQueryParams(targetRouteName, models, queryParams);
 
-      var infos = router.router.currentHandlerInfos;
-      var path = EmberRouter._routePath(infos);
+      var transitionArgs = utils.routeArgs(targetRouteName, models, queryParams);
+      var transitionPromise = this.router.transitionTo.apply(this.router, transitionArgs);
 
-      if (!('currentPath' in appController)) {
-        defineProperty(appController, 'currentPath');
-      }
+      didBeginTransition(transitionPromise, this);
 
-      set(appController, 'currentPath', path);
+      return transitionPromise;
+    },
 
-      if (!('currentRouteName' in appController)) {
-        defineProperty(appController, 'currentRouteName');
+    _prepareQueryParams: function(targetRouteName, models, queryParams) {
+      this._hydrateUnsuppliedQueryParams(targetRouteName, models, queryParams);
+      this._serializeQueryParams(targetRouteName, queryParams);
+      this._pruneDefaultQueryParamValues(targetRouteName, queryParams);
+    },
+
+    /**
+      Returns a merged query params meta object for a given route.
+      Useful for asking a route what its known query params are.
+     */
+    _queryParamsFor: function(leafRouteName) {
+      if (this._qpCache[leafRouteName]) {
+        return this._qpCache[leafRouteName];
       }
 
-      set(appController, 'currentRouteName', infos[infos.length - 1].name);
-    }
+      var map = {};
+      var qps = [];
+      this._qpCache[leafRouteName] = {
+        map: map,
+        qps: qps
+      };
 
-    EmberRouter.reopenClass({
-      router: null,
+      var routerjs = this.router;
+      var recogHandlerInfos = routerjs.recognizer.handlersFor(leafRouteName);
 
-      /**
-        The `Router.map` function allows you to define mappings from URLs to routes
-        and resources in your application. These mappings are defined within the
-        supplied callback function using `this.resource` and `this.route`.
+      for (var i = 0, len = recogHandlerInfos.length; i < len; ++i) {
+        var recogHandler = recogHandlerInfos[i];
+        var route = routerjs.getHandler(recogHandler.handler);
+        var qpMeta = property_get.get(route, '_qp');
 
-        ```javascript
-        App.Router.map(function({
-          this.route('about');
-          this.resource('article');
-        }));
-        ```
+        if (!qpMeta) { continue; }
 
-        For more detailed examples please see
-        [the guides](http://emberjs.com/guides/routing/defining-your-routes/).
+        merge['default'](map, qpMeta.map);
+        qps.push.apply(qps, qpMeta.qps);
+      }
 
-        @method map
-        @param callback
-      */
-      map: function(callback) {
-        var router = this.router;
-        if (!router) {
-          router = new Router();
+      return {
+        qps: qps,
+        map: map
+      };
+    },
 
-          
-            router._triggerWillChangeContext = K;
-            router._triggerWillLeave = K;
-          
+    /*
+      becomeResolved: function(payload, resolvedContext) {
+        var params = this.serialize(resolvedContext);
 
-          router.callbacks = [];
-          router.triggerEvent = triggerEvent;
-          this.reopenClass({ router: router });
+        if (payload) {
+          this.stashResolvedModel(payload, resolvedContext);
+          payload.params = payload.params || {};
+          payload.params[this.name] = params;
         }
 
-        var dsl = EmberRouterDSL.map(function() {
-          this.resource('application', { path: "/" }, function() {
-            for (var i=0; i < router.callbacks.length; i++) {
-              router.callbacks[i].call(this);
-            }
-            callback.call(this);
-          });
+        return this.factory('resolved', {
+          context: resolvedContext,
+          name: this.name,
+          handler: this.handler,
+          params: params
         });
-
-        router.callbacks.push(callback);
-        router.map(dsl.generate());
-        return router;
       },
+    */
 
-      _routePath: function(handlerInfos) {
-        var path = [];
+    _hydrateUnsuppliedQueryParams: function(leafRouteName, contexts, queryParams) {
+      var state = calculatePostTransitionState(this, leafRouteName, contexts);
+      var handlerInfos = state.handlerInfos;
+      var appCache = this._bucketCache;
 
-        // We have to handle coalescing resource names that
-        // are prefixed with their parent's names, e.g.
-        // ['foo', 'foo.bar.baz'] => 'foo.bar.baz', not 'foo.foo.bar.baz'
+      utils.stashParamNames(this, handlerInfos);
 
-        function intersectionMatches(a1, a2) {
-          for (var i = 0, len = a1.length; i < len; ++i) {
-            if (a1[i] !== a2[i]) {
-              return false;
+      for (var i = 0, len = handlerInfos.length; i < len; ++i) {
+        var route = handlerInfos[i].handler;
+        var qpMeta = property_get.get(route, '_qp');
+
+        for (var j = 0, qpLen = qpMeta.qps.length; j < qpLen; ++j) {
+          var qp = qpMeta.qps[j];
+          var presentProp = qp.prop in queryParams  && qp.prop ||
+                            qp.fprop in queryParams && qp.fprop;
+
+          if (presentProp) {
+            if (presentProp !== qp.fprop) {
+              queryParams[qp.fprop] = queryParams[presentProp];
+              delete queryParams[presentProp];
             }
+          } else {
+            var controllerProto = qp.cProto;
+            var cacheMeta = property_get.get(controllerProto, '_cacheMeta');
+
+            var cacheKey = controllerProto._calculateCacheKey(qp.ctrl, cacheMeta[qp.prop].parts, state.params);
+            queryParams[qp.fprop] = appCache.lookup(cacheKey, qp.prop, qp.def);
           }
-          return true;
         }
+      }
+    },
 
-        var name, nameParts, oldNameParts;
-        for (var i=1, l=handlerInfos.length; i<l; i++) {
-          name = handlerInfos[i].name;
-          nameParts = name.split(".");
-          oldNameParts = slice.call(path);
-
-          while (oldNameParts.length) {
-            if (intersectionMatches(oldNameParts, nameParts)) {
-              break;
-            }
-            oldNameParts.shift();
-          }
+    _scheduleLoadingEvent: function(transition, originRoute) {
+      this._cancelSlowTransitionTimer();
+      this._slowTransitionTimer = run['default'].scheduleOnce('routerTransitions', this, '_handleSlowTransition', transition, originRoute);
+    },
 
-          path.push.apply(path, nameParts.slice(oldNameParts.length));
-        }
+    currentState: null,
+    targetState: null,
 
-        return path.join(".");
+    _handleSlowTransition: function(transition, originRoute) {
+      if (!this.router.activeTransition) {
+        // Don't fire an event if we've since moved on from
+        // the transition that put us in a loading state.
+        return;
       }
-    });
 
-    function listenForTransitionErrors(transition) {
-      transition.then(null, function(error) {
-        if (!error || !error.name) { return; }
+      this.set('targetState', RouterState['default'].create({
+        emberRouter: this,
+        routerJs: this.router,
+        routerJsState: this.router.activeTransition.state
+      }));
 
-        Ember.assert("The URL '" + error.message + "' did not match any routes in your application", error.name !== "UnrecognizedURLError");
+      transition.trigger(true, 'loading', transition, originRoute);
+    },
 
-        return error;
-      }, 'Ember: Process errors from Router');
+    _cancelSlowTransitionTimer: function () {
+      if (this._slowTransitionTimer) {
+        run['default'].cancel(this._slowTransitionTimer);
+      }
+      this._slowTransitionTimer = null;
     }
+  });
 
-    function resemblesURL(str) {
-      return typeof str === 'string' && ( str === '' || str.charAt(0) === '/');
-    }
+  /*
+    Helper function for iterating root-ward, starting
+    from (but not including) the provided `originRoute`.
 
-    function forEachQueryParam(router, targetRouteName, queryParams, callback) {
-      var qpCache = router._queryParamsFor(targetRouteName);
+    Returns true if the last callback fired requested
+    to bubble upward.
 
-      for (var key in queryParams) {
-        if (!queryParams.hasOwnProperty(key)) { continue; }
-        var value = queryParams[key];
-        var qp = qpCache.map[key];
+    @private
+   */
+  function forEachRouteAbove(originRoute, transition, callback) {
+    var handlerInfos = transition.state.handlerInfos;
+    var originRouteFound = false;
+    var handlerInfo, route;
 
-        if (qp) {
-          callback(key, value, qp);
+    for (var i = handlerInfos.length - 1; i >= 0; --i) {
+      handlerInfo = handlerInfos[i];
+      route = handlerInfo.handler;
+
+      if (!originRouteFound) {
+        if (originRoute === route) {
+          originRouteFound = true;
         }
+        continue;
       }
-    }
 
-    __exports__["default"] = EmberRouter;
-  });
-enifed("ember-routing/utils",
-  ["ember-metal/utils","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var typeOf = __dependency1__.typeOf;
-
-    function routeArgs(targetRouteName, models, queryParams) {
-      var args = [];
-      if (typeOf(targetRouteName) === 'string') {
-        args.push('' + targetRouteName);
+      if (callback(route, handlerInfos[i + 1].handler) !== true) {
+        return false;
       }
-      args.push.apply(args, models);
-      args.push({ queryParams: queryParams });
-      return args;
-    }
-
-    __exports__.routeArgs = routeArgs;function getActiveTargetName(router) {
-      var handlerInfos = router.activeTransition ?
-                         router.activeTransition.state.handlerInfos :
-                         router.state.handlerInfos;
-      return handlerInfos[handlerInfos.length - 1].name;
     }
+    return true;
+  }
 
-    __exports__.getActiveTargetName = getActiveTargetName;function stashParamNames(router, handlerInfos) {
-      if (handlerInfos._namesStashed) { return; }
+  // These get invoked when an action bubbles above ApplicationRoute
+  // and are not meant to be overridable.
+  var defaultActionHandlers = {
 
-      // This helper exists because router.js/route-recognizer.js awkwardly
-      // keeps separate a handlerInfo's list of parameter names depending
-      // on whether a URL transition or named transition is happening.
-      // Hopefully we can remove this in the future.
-      var targetRouteName = handlerInfos[handlerInfos.length-1].name;
-      var recogHandlers = router.router.recognizer.handlersFor(targetRouteName);
-      var dynamicParent = null;
+    willResolveModel: function(transition, originRoute) {
+      originRoute.router._scheduleLoadingEvent(transition, originRoute);
+    },
 
-      for (var i = 0, len = handlerInfos.length; i < len; ++i) {
-        var handlerInfo = handlerInfos[i];
-        var names = recogHandlers[i].names;
+    error: function(error, transition, originRoute) {
+      // Attempt to find an appropriate error substate to enter.
+      var router = originRoute.router;
 
-        if (names.length) {
-          dynamicParent = handlerInfo;
+      var tryTopLevel = forEachRouteAbove(originRoute, transition, function(route, childRoute) {
+        var childErrorRouteName = findChildRouteName(route, childRoute, 'error');
+        if (childErrorRouteName) {
+          router.intermediateTransitionTo(childErrorRouteName, error);
+          return;
         }
+        return true;
+      });
 
-        handlerInfo._names = names;
-
-        var route = handlerInfo.handler;
-        route._stashNames(handlerInfo, dynamicParent);
+      if (tryTopLevel) {
+        // Check for top-level error state to enter.
+        if (routeHasBeenDefined(originRoute.router, 'application_error')) {
+          router.intermediateTransitionTo('application_error', error);
+          return;
+        }
       }
 
-      handlerInfos._namesStashed = true;
-    }
+      logError(error, 'Error while processing route: ' + transition.targetName);
+    },
 
-    __exports__.stashParamNames = stashParamNames;
-  });
-enifed("ember-runtime",
-  ["ember-metal","ember-runtime/core","ember-runtime/compare","ember-runtime/copy","ember-runtime/inject","ember-runtime/system/namespace","ember-runtime/system/object","ember-runtime/system/tracked_array","ember-runtime/system/subarray","ember-runtime/system/container","ember-runtime/system/array_proxy","ember-runtime/system/object_proxy","ember-runtime/system/core_object","ember-runtime/system/each_proxy","ember-runtime/system/native_array","ember-runtime/system/set","ember-runtime/system/string","ember-runtime/system/deferred","ember-runtime/system/lazy_load","ember-runtime/mixins/array","ember-runtime/mixins/comparable","ember-runtime/mixins/copyable","ember-runtime/mixins/enumerable","ember-runtime/mixins/freezable","ember-runtime/mixins/-proxy","ember-runtime/mixins/observable","ember-runtime/mixins/action_handler","ember-runtime/mixins/deferred","ember-runtime/mixins/mutable_enumerable","ember-runtime/mixins/mutable_array","ember-runtime/mixins/target_action_support","ember-runtime/mixins/evented","ember-runtime/mixins/promise_proxy","ember-runtime/mixins/sortable","ember-runtime/computed/array_computed","ember-runtime/computed/reduce_computed","ember-runtime/computed/reduce_computed_macros","ember-runtime/controllers/array_controller","ember-runtime/controllers/object_controller","ember-runtime/controllers/controller","ember-runtime/mixins/controller","ember-runtime/system/service","ember-runtime/ext/rsvp","ember-runtime/ext/string","ember-runtime/ext/function","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __dependency21__, __dependency22__, __dependency23__, __dependency24__, __dependency25__, __dependency26__, __dependency27__, __dependency28__, __dependency29__, __dependency30__, __dependency31__, __dependency32__, __dependency33__, __dependency34__, __dependency35__, __dependency36__, __dependency37__, __dependency38__, __dependency39__, __dependency40__, __dependency41__, __dependency42__, __dependency43__, __dependency44__, __dependency45__, __exports__) {
-    "use strict";
-    /**
-    Ember Runtime
+    loading: function(transition, originRoute) {
+      // Attempt to find an appropriate loading substate to enter.
+      var router = originRoute.router;
 
-    @module ember
-    @submodule ember-runtime
-    @requires ember-metal
-    */
-
-    // BEGIN IMPORTS
-    var Ember = __dependency1__["default"];
-    var isEqual = __dependency2__.isEqual;
-    var compare = __dependency3__["default"];
-    var copy = __dependency4__["default"];
-    var inject = __dependency5__["default"];
-
-    var Namespace = __dependency6__["default"];
-    var EmberObject = __dependency7__["default"];
-    var TrackedArray = __dependency8__["default"];
-    var SubArray = __dependency9__["default"];
-    var Container = __dependency10__["default"];
-    var ArrayProxy = __dependency11__["default"];
-    var ObjectProxy = __dependency12__["default"];
-    var CoreObject = __dependency13__["default"];
-    var EachArray = __dependency14__.EachArray;
-    var EachProxy = __dependency14__.EachProxy;
-
-    var NativeArray = __dependency15__["default"];
-    var Set = __dependency16__["default"];
-    var EmberStringUtils = __dependency17__["default"];
-    var Deferred = __dependency18__["default"];
-    var onLoad = __dependency19__.onLoad;
-    var runLoadHooks = __dependency19__.runLoadHooks;
-
-    var EmberArray = __dependency20__["default"];
-    var Comparable = __dependency21__["default"];
-    var Copyable = __dependency22__["default"];
-    var Enumerable = __dependency23__["default"];
-    var Freezable = __dependency24__.Freezable;
-    var FROZEN_ERROR = __dependency24__.FROZEN_ERROR;
-    var _ProxyMixin = __dependency25__["default"];
-
-    var Observable = __dependency26__["default"];
-    var ActionHandler = __dependency27__["default"];
-    var DeferredMixin = __dependency28__["default"];
-    var MutableEnumerable = __dependency29__["default"];
-    var MutableArray = __dependency30__["default"];
-    var TargetActionSupport = __dependency31__["default"];
-    var Evented = __dependency32__["default"];
-    var PromiseProxyMixin = __dependency33__["default"];
-    var SortableMixin = __dependency34__["default"];
-    var arrayComputed = __dependency35__.arrayComputed;
-    var ArrayComputedProperty = __dependency35__.ArrayComputedProperty;
-
-    var reduceComputed = __dependency36__.reduceComputed;
-    var ReduceComputedProperty = __dependency36__.ReduceComputedProperty;
-
-    var sum = __dependency37__.sum;
-    var min = __dependency37__.min;
-    var max = __dependency37__.max;
-    var map = __dependency37__.map;
-    var sort = __dependency37__.sort;
-    var setDiff = __dependency37__.setDiff;
-    var mapBy = __dependency37__.mapBy;
-    var mapProperty = __dependency37__.mapProperty;
-    var filter = __dependency37__.filter;
-    var filterBy = __dependency37__.filterBy;
-    var filterProperty = __dependency37__.filterProperty;
-    var uniq = __dependency37__.uniq;
-    var union = __dependency37__.union;
-    var intersect = __dependency37__.intersect;
-
-    var ArrayController = __dependency38__["default"];
-    var ObjectController = __dependency39__["default"];
-    var Controller = __dependency40__["default"];
-    var ControllerMixin = __dependency41__["default"];
-
-    var Service = __dependency42__["default"];
-
-    var RSVP = __dependency43__["default"];
-        // just for side effect of extending Ember.RSVP
-      // just for side effect of extending String.prototype
-    // just for side effect of extending Function.prototype
-    // END IMPORTS
-
-    // BEGIN EXPORTS
-    Ember.compare = compare;
-    Ember.copy = copy;
-    Ember.isEqual = isEqual;
-
-    
-      Ember.inject = inject;
-    
-
-    Ember.Array = EmberArray;
-
-    Ember.Comparable = Comparable;
-    Ember.Copyable = Copyable;
-
-    Ember.SortableMixin = SortableMixin;
-
-    Ember.Freezable = Freezable;
-    Ember.FROZEN_ERROR = FROZEN_ERROR;
-
-    Ember.DeferredMixin = DeferredMixin;
-
-    Ember.MutableEnumerable = MutableEnumerable;
-    Ember.MutableArray = MutableArray;
-
-    Ember.TargetActionSupport = TargetActionSupport;
-    Ember.Evented = Evented;
-
-    Ember.PromiseProxyMixin = PromiseProxyMixin;
-
-    Ember.Observable = Observable;
-
-    Ember.arrayComputed = arrayComputed;
-    Ember.ArrayComputedProperty = ArrayComputedProperty;
-    Ember.reduceComputed = reduceComputed;
-    Ember.ReduceComputedProperty = ReduceComputedProperty;
-
-    // ES6TODO: this seems a less than ideal way/place to add properties to Ember.computed
-    var EmComputed = Ember.computed;
-
-    EmComputed.sum = sum;
-    EmComputed.min = min;
-    EmComputed.max = max;
-    EmComputed.map = map;
-    EmComputed.sort = sort;
-    EmComputed.setDiff = setDiff;
-    EmComputed.mapBy = mapBy;
-    EmComputed.mapProperty = mapProperty;
-    EmComputed.filter = filter;
-    EmComputed.filterBy = filterBy;
-    EmComputed.filterProperty = filterProperty;
-    EmComputed.uniq = uniq;
-    EmComputed.union = union;
-    EmComputed.intersect = intersect;
-
-    Ember.String = EmberStringUtils;
-    Ember.Object = EmberObject;
-    Ember.TrackedArray = TrackedArray;
-    Ember.SubArray = SubArray;
-    Ember.Container = Container;
-    Ember.Namespace = Namespace;
-    Ember.Enumerable = Enumerable;
-    Ember.ArrayProxy = ArrayProxy;
-    Ember.ObjectProxy = ObjectProxy;
-    Ember.ActionHandler = ActionHandler;
-    Ember.CoreObject = CoreObject;
-    Ember.EachArray = EachArray;
-    Ember.EachProxy = EachProxy;
-    Ember.NativeArray = NativeArray;
-    // ES6TODO: Currently we must rely on the global from ember-metal/core to avoid circular deps
-    // Ember.A = A;
-    Ember.Set = Set;
-    Ember.Deferred = Deferred;
-    Ember.onLoad = onLoad;
-    Ember.runLoadHooks = runLoadHooks;
-
-    Ember.ArrayController = ArrayController;
-    Ember.ObjectController = ObjectController;
-    Ember.Controller = Controller;
-    Ember.ControllerMixin = ControllerMixin;
-
-    
-      Ember.Service = Service;
-    
-
-    Ember._ProxyMixin = _ProxyMixin;
-
-    Ember.RSVP = RSVP;
-    // END EXPORTS
-
-    __exports__["default"] = Ember;
-  });
-enifed("ember-runtime/compare",
-  ["ember-metal/utils","ember-runtime/mixins/comparable","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var typeOf = __dependency1__.typeOf;
-    var Comparable = __dependency2__["default"];
-
-    var TYPE_ORDER = {
-      'undefined': 0,
-      'null': 1,
-      'boolean': 2,
-      'number': 3,
-      'string': 4,
-      'array': 5,
-      'object': 6,
-      'instance': 7,
-      'function': 8,
-      'class': 9,
-      'date': 10
-    };
+      var tryTopLevel = forEachRouteAbove(originRoute, transition, function(route, childRoute) {
+        var childLoadingRouteName = findChildRouteName(route, childRoute, 'loading');
 
-    //
-    // the spaceship operator
-    //
-    function spaceship(a, b) {
-      var diff = a - b;
-      return (diff > 0) - (diff < 0);
-    }
+        if (childLoadingRouteName) {
+          router.intermediateTransitionTo(childLoadingRouteName);
+          return;
+        }
 
-    /**
-     This will compare two javascript values of possibly different types.
-     It will tell you which one is greater than the other by returning:
+        // Don't bubble above pivot route.
+        if (transition.pivotHandler !== route) {
+          return true;
+        }
+      });
 
-      - -1 if the first is smaller than the second,
-      - 0 if both are equal,
-      - 1 if the first is greater than the second.
+      if (tryTopLevel) {
+        // Check for top-level loading state to enter.
+        if (routeHasBeenDefined(originRoute.router, 'application_loading')) {
+          router.intermediateTransitionTo('application_loading');
+          return;
+        }
+      }
+    }
+  };
 
-     The order is calculated based on `Ember.ORDER_DEFINITION`, if types are different.
-     In case they have the same type an appropriate comparison for this type is made.
+  function logError(_error, initialMessage) {
+    var errorArgs = [];
+    var error;
+    if (_error && typeof _error === 'object' && typeof _error.errorThrown === 'object') {
+      error = _error.errorThrown;
+    } else {
+      error = _error;
+    }
 
-      ```javascript
-      Ember.compare('hello', 'hello');  // 0
-      Ember.compare('abc', 'dfg');      // -1
-      Ember.compare(2, 1);              // 1
-      ```
+    if (initialMessage) { errorArgs.push(initialMessage); }
 
-     @method compare
-     @for Ember
-     @param {Object} v First value to compare
-     @param {Object} w Second value to compare
-     @return {Number} -1 if v < w, 0 if v = w and 1 if v > w.
-    */
-    __exports__["default"] = function compare(v, w) {
-      if (v === w) {
-        return 0;
-      }
+    if (error) {
+      if (error.message) { errorArgs.push(error.message); }
+      if (error.stack) { errorArgs.push(error.stack); }
 
-      var type1 = typeOf(v);
-      var type2 = typeOf(w);
+      if (typeof error === "string") { errorArgs.push(error); }
+    }
 
-      if (Comparable) {
-        if (type1 === 'instance' && Comparable.detect(v) && v.constructor.compare) {
-          return v.constructor.compare(v, w);
-        }
+    Ember['default'].Logger.error.apply(this, errorArgs);
+  }
 
-        if (type2 === 'instance' && Comparable.detect(w) && w.constructor.compare) {
-          return w.constructor.compare(w, v) * -1;
-        }
-      }
+  function findChildRouteName(parentRoute, originatingChildRoute, name) {
+    var router = parentRoute.router;
+    var childName;
+    var targetChildRouteName = originatingChildRoute.routeName.split('.').pop();
+    var namespace = parentRoute.routeName === 'application' ? '' : parentRoute.routeName + '.';
 
-      var res = spaceship(TYPE_ORDER[type1], TYPE_ORDER[type2]);
 
-      if (res !== 0) {
-        return res;
+      // First, try a named loading state, e.g. 'foo_loading'
+      childName = namespace + targetChildRouteName + '_' + name;
+      if (routeHasBeenDefined(router, childName)) {
+        return childName;
       }
 
-      // types are equal - so we have to check values now
-      switch (type1) {
-        case 'boolean':
-        case 'number':
-          return spaceship(v,w);
 
-        case 'string':
-          return spaceship(v.localeCompare(w), 0);
+    // Second, try general loading state, e.g. 'loading'
+    childName = namespace + name;
+    if (routeHasBeenDefined(router, childName)) {
+      return childName;
+    }
+  }
 
-        case 'array':
-          var vLen = v.length;
-          var wLen = w.length;
-          var len = Math.min(vLen, wLen);
+  function routeHasBeenDefined(router, name) {
+    var container = router.container;
+    return router.hasRoute(name) &&
+           (container._registry.has('template:' + name) || container._registry.has('route:' + name));
+  }
 
-          for (var i = 0; i < len; i++) {
-            var r = compare(v[i], w[i]);
-            if (r !== 0) {
-              return r;
-            }
-          }
+  function triggerEvent(handlerInfos, ignoreFailure, args) {
+    var name = args.shift();
 
-          // all elements are equal now
-          // shorter array should be ordered first
-          return spaceship(vLen, wLen);
+    if (!handlerInfos) {
+      if (ignoreFailure) { return; }
+      throw new EmberError['default']("Can't trigger action '" + name + "' because your app hasn't finished transitioning into its first route. To trigger an action on destination routes during a transition, you can call `.send()` on the `Transition` object passed to the `model/beforeModel/afterModel` hooks.");
+    }
 
-        case 'instance':
-          if (Comparable && Comparable.detect(v)) {
-            return v.compare(v, w);
-          }
-          return 0;
+    var eventWasHandled = false;
+    var handlerInfo, handler;
 
-        case 'date':
-          return spaceship(v.getTime(), w.getTime());
+    for (var i = handlerInfos.length - 1; i >= 0; i--) {
+      handlerInfo = handlerInfos[i];
+      handler = handlerInfo.handler;
 
-        default:
-          return 0;
+      if (handler._actions && handler._actions[name]) {
+        if (handler._actions[name].apply(handler, args) === true) {
+          eventWasHandled = true;
+        } else {
+          return;
+        }
       }
     }
-  });
-enifed("ember-runtime/computed/array_computed",
-  ["ember-metal/core","ember-runtime/computed/reduce_computed","ember-metal/enumerable_utils","ember-metal/platform","ember-metal/observer","ember-metal/error","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var ReduceComputedProperty = __dependency2__.ReduceComputedProperty;
-    var forEach = __dependency3__.forEach;
-    var o_create = __dependency4__.create;
-    var addObserver = __dependency5__.addObserver;
-    var EmberError = __dependency6__["default"];
-
-    var a_slice = [].slice;
-
-    function ArrayComputedProperty() {
-      var cp = this;
-
-      ReduceComputedProperty.apply(this, arguments);
-
-      this.func = (function(reduceFunc) {
-        return function (propertyName) {
-          if (!cp._hasInstanceMeta(this, propertyName)) {
-            // When we recompute an array computed property, we need already
-            // retrieved arrays to be updated; we can't simply empty the cache and
-            // hope the array is re-retrieved.
-            forEach(cp._dependentKeys, function(dependentKey) {
-              addObserver(this, dependentKey, function() {
-                cp.recomputeOnce.call(this, propertyName);
-              });
-            }, this);
-          }
 
-          return reduceFunc.apply(this, arguments);
-        };
-      })(this.func);
+    if (defaultActionHandlers[name]) {
+      defaultActionHandlers[name].apply(null, args);
+      return;
+    }
 
-      return this;
+    if (!eventWasHandled && !ignoreFailure) {
+      throw new EmberError['default']("Nothing handled the action '" + name + "'. If you did handle the action, this error can be caused by returning true from an action handler in a controller, causing the action to bubble.");
     }
+  }
 
-    ArrayComputedProperty.prototype = o_create(ReduceComputedProperty.prototype);
+  function calculatePostTransitionState(emberRouter, leafRouteName, contexts) {
+    var routerjs = emberRouter.router;
+    var state = routerjs.applyIntent(leafRouteName, contexts);
+    var handlerInfos = state.handlerInfos;
+    var params = state.params;
 
-    ArrayComputedProperty.prototype.initialValue = function () {
-      return Ember.A();
-    };
+    for (var i = 0, len = handlerInfos.length; i < len; ++i) {
+      var handlerInfo = handlerInfos[i];
+      if (!handlerInfo.isResolved) {
+        handlerInfo = handlerInfo.becomeResolved(null, handlerInfo.context);
+      }
+      params[handlerInfo.name] = handlerInfo.params;
+    }
+    return state;
+  }
 
-    ArrayComputedProperty.prototype.resetValue = function (array) {
-      array.clear();
-      return array;
-    };
+  function updatePaths(router) {
+    var appController = router.container.lookup('controller:application');
 
-    // This is a stopgap to keep the reference counts correct with lazy CPs.
-    ArrayComputedProperty.prototype.didChange = function (obj, keyName) {
+    if (!appController) {
+      // appController might not exist when top-level loading/error
+      // substates have been entered since ApplicationRoute hasn't
+      // actually been entered at that point.
       return;
-    };
+    }
 
-    /**
-      Creates a computed property which operates on dependent arrays and
-      is updated with "one at a time" semantics. When items are added or
-      removed from the dependent array(s) an array computed only operates
-      on the change instead of re-evaluating the entire array. This should
-      return an array, if you'd like to use "one at a time" semantics and
-      compute some value other then an array look at
-      `Ember.reduceComputed`.
+    var infos = router.router.currentHandlerInfos;
+    var path = EmberRouter._routePath(infos);
 
-      If there are more than one arguments the first arguments are
-      considered to be dependent property keys. The last argument is
-      required to be an options object. The options object can have the
-      following three properties.
+    if (!('currentPath' in appController)) {
+      properties.defineProperty(appController, 'currentPath');
+    }
 
-      `initialize` - An optional initialize function. Typically this will be used
-      to set up state on the instanceMeta object.
+    property_set.set(appController, 'currentPath', path);
 
-      `removedItem` - A function that is called each time an element is
-      removed from the array.
+    if (!('currentRouteName' in appController)) {
+      properties.defineProperty(appController, 'currentRouteName');
+    }
 
-      `addedItem` - A function that is called each time an element is
-      added to the array.
+    property_set.set(appController, 'currentRouteName', infos[infos.length - 1].name);
+  }
 
+  EmberRouter.reopenClass({
+    router: null,
 
-      The `initialize` function has the following signature:
+    /**
+      The `Router.map` function allows you to define mappings from URLs to routes
+      and resources in your application. These mappings are defined within the
+      supplied callback function using `this.resource` and `this.route`.
 
       ```javascript
-      function(array, changeMeta, instanceMeta)
+      App.Router.map(function({
+        this.route('about');
+        this.resource('article');
+      }));
       ```
 
-      `array` - The initial value of the arrayComputed, an empty array.
+      For more detailed examples please see
+      [the guides](http://emberjs.com/guides/routing/defining-your-routes/).
 
-      `changeMeta` - An object which contains meta information about the
-      computed. It contains the following properties:
+      @method map
+      @param callback
+    */
+    map: function(callback) {
 
-         - `property` the computed property
-         - `propertyName` the name of the property on the object
+      if (!this.dslCallbacks) {
+        this.dslCallbacks = [];
+        this.reopenClass({ dslCallbacks: this.dslCallbacks });
+      }
 
-      `instanceMeta` - An object that can be used to store meta
-      information needed for calculating your computed. For example a
-      unique computed might use this to store the number of times a given
-      element is found in the dependent array.
+      this.dslCallbacks.push(callback);
 
+      return this;
+    },
 
-      The `removedItem` and `addedItem` functions both have the following signature:
+    _routePath: function(handlerInfos) {
+      var path = [];
 
-      ```javascript
-      function(accumulatedValue, item, changeMeta, instanceMeta)
-      ```
+      // We have to handle coalescing resource names that
+      // are prefixed with their parent's names, e.g.
+      // ['foo', 'foo.bar.baz'] => 'foo.bar.baz', not 'foo.foo.bar.baz'
 
-      `accumulatedValue` - The value returned from the last time
-      `removedItem` or `addedItem` was called or an empty array.
+      function intersectionMatches(a1, a2) {
+        for (var i = 0, len = a1.length; i < len; ++i) {
+          if (a1[i] !== a2[i]) {
+            return false;
+          }
+        }
+        return true;
+      }
 
-      `item` - the element added or removed from the array
+      var name, nameParts, oldNameParts;
+      for (var i=1, l=handlerInfos.length; i<l; i++) {
+        name = handlerInfos[i].name;
+        nameParts = name.split(".");
+        oldNameParts = slice.call(path);
 
-      `changeMeta` - An object which contains meta information about the
-      change. It contains the following properties:
+        while (oldNameParts.length) {
+          if (intersectionMatches(oldNameParts, nameParts)) {
+            break;
+          }
+          oldNameParts.shift();
+        }
 
-        - `property` the computed property
-        - `propertyName` the name of the property on the object
-        - `index` the index of the added or removed item
-        - `item` the added or removed item: this is exactly the same as
-          the second arg
-        - `arrayChanged` the array that triggered the change. Can be
-          useful when depending on multiple arrays.
+        path.push.apply(path, nameParts.slice(oldNameParts.length));
+      }
 
-      For property changes triggered on an item property change (when
-      depKey is something like `someArray.@each.someProperty`),
-      `changeMeta` will also contain the following property:
+      return path.join(".");
+    }
+  });
 
-        - `previousValues` an object whose keys are the properties that changed on
-        the item, and whose values are the item's previous values.
+  function didBeginTransition(transition, router) {
+    var routerState = RouterState['default'].create({
+      emberRouter: router,
+      routerJs: router.router,
+      routerJsState: transition.state
+    });
 
-      `previousValues` is important Ember coalesces item property changes via
-      Ember.run.once. This means that by the time removedItem gets called, item has
-      the new values, but you may need the previous value (eg for sorting &
-      filtering).
+    if (!router.currentState) {
+      router.set('currentState', routerState);
+    }
+    router.set('targetState', routerState);
 
-      `instanceMeta` - An object that can be used to store meta
-      information needed for calculating your computed. For example a
-      unique computed might use this to store the number of times a given
-      element is found in the dependent array.
+    transition.then(null, function(error) {
+      if (!error || !error.name) { return; }
 
-      The `removedItem` and `addedItem` functions should return the accumulated
-      value. It is acceptable to not return anything (ie return undefined)
-      to invalidate the computation. This is generally not a good idea for
-      arrayComputed but it's used in eg max and min.
+      Ember['default'].assert("The URL '" + error.message + "' did not match any routes in your application", error.name !== "UnrecognizedURLError");
 
-      Example
+      return error;
+    }, 'Ember: Process errors from Router');
+  }
 
-      ```javascript
-      Ember.computed.map = function(dependentKey, callback) {
-        var options = {
-          addedItem: function(array, item, changeMeta, instanceMeta) {
-            var mapped = callback(item);
-            array.insertAt(changeMeta.index, mapped);
-            return array;
-          },
-          removedItem: function(array, item, changeMeta, instanceMeta) {
-            array.removeAt(changeMeta.index, 1);
-            return array;
-          }
-        };
+  function resemblesURL(str) {
+    return typeof str === 'string' && ( str === '' || str.charAt(0) === '/');
+  }
 
-        return Ember.arrayComputed(dependentKey, options);
-      };
-      ```
+  function forEachQueryParam(router, targetRouteName, queryParams, callback) {
+    var qpCache = router._queryParamsFor(targetRouteName);
 
-      @method arrayComputed
-      @for Ember
-      @param {String} [dependentKeys*]
-      @param {Object} options
-      @return {Ember.ComputedProperty}
-    */
-    function arrayComputed (options) {
-      var args;
+    for (var key in queryParams) {
+      if (!queryParams.hasOwnProperty(key)) { continue; }
+      var value = queryParams[key];
+      var qp = qpCache.map[key];
 
-      if (arguments.length > 1) {
-        args = a_slice.call(arguments, 0, -1);
-        options = a_slice.call(arguments, -1)[0];
+      if (qp) {
+        callback(key, value, qp);
       }
+    }
+  }
 
-      if (typeof options !== 'object') {
-        throw new EmberError('Array Computed Property declared without an options hash');
+  function findLiveRoute(liveRoutes, name) {
+    if (!liveRoutes) { return; }
+    var stack = [liveRoutes];
+    while (stack.length > 0) {
+      var test = stack.shift();
+      if (test.render.name === name) {
+        return test;
       }
-
-      var cp = new ArrayComputedProperty(options);
-
-      if (args) {
-        cp.property.apply(cp, args);
+      var outlets = test.outlets;
+      for (var outletName in outlets) {
+        stack.push(outlets[outletName]);
       }
-
-      return cp;
     }
+  }
 
-    __exports__.arrayComputed = arrayComputed;
-    __exports__.ArrayComputedProperty = ArrayComputedProperty;
-  });
-enifed("ember-runtime/computed/reduce_computed",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/error","ember-metal/property_events","ember-metal/expand_properties","ember-metal/observer","ember-metal/computed","ember-metal/platform","ember-metal/enumerable_utils","ember-runtime/system/tracked_array","ember-runtime/mixins/array","ember-metal/run_loop","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var e_get = __dependency2__.get;
-    var guidFor = __dependency3__.guidFor;
-    var metaFor = __dependency3__.meta;
-    var EmberError = __dependency4__["default"];
-    var propertyWillChange = __dependency5__.propertyWillChange;
-    var propertyDidChange = __dependency5__.propertyDidChange;
-    var expandProperties = __dependency6__["default"];
-    var addObserver = __dependency7__.addObserver;
-    var removeObserver = __dependency7__.removeObserver;
-    var addBeforeObserver = __dependency7__.addBeforeObserver;
-    var removeBeforeObserver = __dependency7__.removeBeforeObserver;
-    var ComputedProperty = __dependency8__.ComputedProperty;
-    var cacheFor = __dependency8__.cacheFor;
-    var o_create = __dependency9__.create;
-    var forEach = __dependency10__.forEach;
-    var TrackedArray = __dependency11__["default"];
-    var EmberArray = __dependency12__["default"];
-    var run = __dependency13__["default"];
-    var isArray = __dependency3__.isArray;
-
-    var cacheSet = cacheFor.set;
-    var cacheGet = cacheFor.get;
-    var cacheRemove = cacheFor.remove;
-    var a_slice = [].slice;
-    // Here we explicitly don't allow `@each.foo`; it would require some special
-    // testing, but there's no particular reason why it should be disallowed.
-    var eachPropertyPattern = /^(.*)\.@each\.(.*)/;
-    var doubleEachPropertyPattern = /(.*\.@each){2,}/;
-    var arrayBracketPattern = /\.\[\]$/;
-
-    function get(obj, key) {
-      if (key === '@this') {
-        return obj;
+  function appendLiveRoute(liveRoutes, defaultParentState, renderOptions) {
+    var target;
+    var myState = {
+      render: renderOptions,
+      outlets: create['default'](null)
+    };
+    if (renderOptions.into) {
+      target = findLiveRoute(liveRoutes, renderOptions.into);
+    } else {
+      target = defaultParentState;
+    }
+    if (target) {
+      property_set.set(target.outlets, renderOptions.outlet, myState);
+    } else {
+      if (renderOptions.into) {
+        // Megahax time. Post-2.0-breaking-changes, we will just assert
+        // right here that the user tried to target a nonexistent
+        // thing. But for now we still need to support the `render`
+        // helper, and people are allowed to target templates rendered
+        // by the render helper. So instead we defer doing anyting with
+        // these orphan renders until afterRender.
+        appendOrphan(liveRoutes, renderOptions.into, myState);
+      } else {
+        liveRoutes = myState;
       }
-
-      return e_get(obj, key);
     }
+    return {
+      liveRoutes: liveRoutes,
+      ownState: myState
+    };
+  }
 
-    /*
-      Tracks changes to dependent arrays, as well as to properties of items in
-      dependent arrays.
-
-      @class DependentArraysObserver
-    */
-    function DependentArraysObserver(callbacks, cp, instanceMeta, context, propertyName, sugarMeta) {
-      // user specified callbacks for `addedItem` and `removedItem`
-      this.callbacks = callbacks;
-
-      // the computed property: remember these are shared across instances
-      this.cp = cp;
-
-      // the ReduceComputedPropertyInstanceMeta this DependentArraysObserver is
-      // associated with
-      this.instanceMeta = instanceMeta;
-
-      // A map of array guids to dependentKeys, for the given context.  We track
-      // this because we want to set up the computed property potentially before the
-      // dependent array even exists, but when the array observer fires, we lack
-      // enough context to know what to update: we can recover that context by
-      // getting the dependentKey.
-      this.dependentKeysByGuid = {};
-
-      // a map of dependent array guids -> TrackedArray instances.  We use
-      // this to lazily recompute indexes for item property observers.
-      this.trackedArraysByGuid = {};
-
-      // We suspend observers to ignore replacements from `reset` when totally
-      // recomputing.  Unfortunately we cannot properly suspend the observers
-      // because we only have the key; instead we make the observers no-ops
-      this.suspended = false;
+  function appendOrphan(liveRoutes, into, myState) {
+    if (!liveRoutes.outlets.__ember_orphans__) {
+      liveRoutes.outlets.__ember_orphans__ = {
+        render: {
+          name: '__ember_orphans__'
+        },
+        outlets: create['default'](null)
+      };
+    }
+    liveRoutes.outlets.__ember_orphans__.outlets[into] = myState;
+    Ember['default'].run.schedule('afterRender', function() {
+      // `wasUsed` gets set by the render helper. See the function
+      // `impersonateAnOutlet`.
+      Ember['default'].assert("You attempted to render into '" + into + "' but it was not found",
+                   liveRoutes.outlets.__ember_orphans__.outlets[into].wasUsed);
+    });
+  }
 
-      // This is used to coalesce item changes from property observers within a
-      // single item.
-      this.changedItems = {};
-      // This is used to coalesce item changes for multiple items that depend on
-      // some shared state.
-      this.changedItemCount = 0;
+  function representEmptyRoute(liveRoutes, defaultParentState, route) {
+    // the route didn't render anything
+    var alreadyAppended = findLiveRoute(liveRoutes, route.routeName);
+    if (alreadyAppended) {
+      // But some other route has already rendered our default
+      // template, so that becomes the default target for any
+      // children we may have.
+      return alreadyAppended;
+    } else {
+      // Create an entry to represent our default template name,
+      // just so other routes can target it and inherit its place
+      // in the outlet hierarchy.
+      defaultParentState.outlets.main = {
+        render: {
+          name: route.routeName,
+          outlet: 'main'
+        },
+        outlets: {}
+      };
+      return defaultParentState;
     }
+  }
 
-    function ItemPropertyObserverContext (dependentArray, index, trackedArray) {
-      Ember.assert('Internal error: trackedArray is null or undefined', trackedArray);
-
-      this.dependentArray = dependentArray;
-      this.index = index;
-      this.item = dependentArray.objectAt(index);
-      this.trackedArray = trackedArray;
-      this.beforeObserver = null;
-      this.observer = null;
-      this.destroyed = false;
-    }
+  exports['default'] = EmberRouter;
 
-    DependentArraysObserver.prototype = {
-      setValue: function (newValue) {
-        this.instanceMeta.setValue(newValue, true);
-      },
+});
+enifed('ember-routing/system/router_state', ['exports', 'ember-metal/core', 'ember-runtime/system/object', 'ember-metal/merge'], function (exports, Ember, EmberObject, merge) {
 
-      getValue: function () {
-        return this.instanceMeta.getValue();
-      },
+  'use strict';
 
-      setupObservers: function (dependentArray, dependentKey) {
-        this.dependentKeysByGuid[guidFor(dependentArray)] = dependentKey;
+  var RouterState = EmberObject['default'].extend({
+    emberRouter: null,
+    routerJs: null,
+    routerJsState: null,
 
-        dependentArray.addArrayObserver(this, {
-          willChange: 'dependentArrayWillChange',
-          didChange: 'dependentArrayDidChange'
-        });
+    isActiveIntent: function(routeName, models, queryParams, queryParamsMustMatch) {
+      var state = this.routerJsState;
+      if (!this.routerJs.isActiveIntent(routeName, models, null, state)) { return false; }
 
-        if (this.cp._itemPropertyKeys[dependentKey]) {
-          this.setupPropertyObservers(dependentKey, this.cp._itemPropertyKeys[dependentKey]);
-        }
-      },
+      var emptyQueryParams = Ember['default'].isEmpty(Ember['default'].keys(queryParams));
 
-      teardownObservers: function (dependentArray, dependentKey) {
-        var itemPropertyKeys = this.cp._itemPropertyKeys[dependentKey] || [];
+      if (queryParamsMustMatch && !emptyQueryParams) {
+        var visibleQueryParams = {};
+        merge['default'](visibleQueryParams, queryParams);
 
-        delete this.dependentKeysByGuid[guidFor(dependentArray)];
+        this.emberRouter._prepareQueryParams(routeName, models, visibleQueryParams);
+        return shallowEqual(visibleQueryParams, state.queryParams);
+      }
 
-        this.teardownPropertyObservers(dependentKey, itemPropertyKeys);
+      return true;
+    }
+  });
 
-        dependentArray.removeArrayObserver(this, {
-          willChange: 'dependentArrayWillChange',
-          didChange: 'dependentArrayDidChange'
-        });
-      },
+  function shallowEqual(a, b) {
+    var k;
+    for (k in a) {
+      if (a.hasOwnProperty(k) && a[k] !== b[k]) { return false; }
+    }
+    for (k in b) {
+      if (b.hasOwnProperty(k) && a[k] !== b[k]) { return false; }
+    }
+    return true;
+  }
 
-      suspendArrayObservers: function (callback, binding) {
-        var oldSuspended = this.suspended;
-        this.suspended = true;
-        callback.call(binding);
-        this.suspended = oldSuspended;
-      },
+  exports['default'] = RouterState;
 
-      setupPropertyObservers: function (dependentKey, itemPropertyKeys) {
-        var dependentArray = get(this.instanceMeta.context, dependentKey);
-        var length = get(dependentArray, 'length');
-        var observerContexts = new Array(length);
+});
+enifed('ember-routing/utils', ['exports', 'ember-metal/utils'], function (exports, utils) {
 
-        this.resetTransformations(dependentKey, observerContexts);
+  'use strict';
 
-        forEach(dependentArray, function (item, index) {
-          var observerContext = this.createPropertyObserverContext(dependentArray, index, this.trackedArraysByGuid[dependentKey]);
-          observerContexts[index] = observerContext;
+  exports.routeArgs = routeArgs;
+  exports.getActiveTargetName = getActiveTargetName;
+  exports.stashParamNames = stashParamNames;
 
-          forEach(itemPropertyKeys, function (propertyKey) {
-            addBeforeObserver(item, propertyKey, this, observerContext.beforeObserver);
-            addObserver(item, propertyKey, this, observerContext.observer);
-          }, this);
-        }, this);
-      },
+  function routeArgs(targetRouteName, models, queryParams) {
+    var args = [];
+    if (utils.typeOf(targetRouteName) === 'string') {
+      args.push('' + targetRouteName);
+    }
+    args.push.apply(args, models);
+    args.push({ queryParams: queryParams });
+    return args;
+  }
 
-      teardownPropertyObservers: function (dependentKey, itemPropertyKeys) {
-        var dependentArrayObserver = this;
-        var trackedArray = this.trackedArraysByGuid[dependentKey];
-        var beforeObserver, observer, item;
+  function getActiveTargetName(router) {
+    var handlerInfos = router.activeTransition ?
+                       router.activeTransition.state.handlerInfos :
+                       router.state.handlerInfos;
+    return handlerInfos[handlerInfos.length - 1].name;
+  }
 
-        if (!trackedArray) { return; }
+  function stashParamNames(router, handlerInfos) {
+    if (handlerInfos._namesStashed) { return; }
 
-        trackedArray.apply(function (observerContexts, offset, operation) {
-          if (operation === TrackedArray.DELETE) { return; }
+    // This helper exists because router.js/route-recognizer.js awkwardly
+    // keeps separate a handlerInfo's list of parameter names depending
+    // on whether a URL transition or named transition is happening.
+    // Hopefully we can remove this in the future.
+    var targetRouteName = handlerInfos[handlerInfos.length-1].name;
+    var recogHandlers = router.router.recognizer.handlersFor(targetRouteName);
+    var dynamicParent = null;
 
-          forEach(observerContexts, function (observerContext) {
-            observerContext.destroyed = true;
-            beforeObserver = observerContext.beforeObserver;
-            observer = observerContext.observer;
-            item = observerContext.item;
+    for (var i = 0, len = handlerInfos.length; i < len; ++i) {
+      var handlerInfo = handlerInfos[i];
+      var names = recogHandlers[i].names;
 
-            forEach(itemPropertyKeys, function (propertyKey) {
-              removeBeforeObserver(item, propertyKey, dependentArrayObserver, beforeObserver);
-              removeObserver(item, propertyKey, dependentArrayObserver, observer);
-            });
-          });
-        });
-      },
+      if (names.length) {
+        dynamicParent = handlerInfo;
+      }
 
-      createPropertyObserverContext: function (dependentArray, index, trackedArray) {
-        var observerContext = new ItemPropertyObserverContext(dependentArray, index, trackedArray);
+      handlerInfo._names = names;
 
-        this.createPropertyObserver(observerContext);
+      var route = handlerInfo.handler;
+      route._stashNames(handlerInfo, dynamicParent);
+    }
 
-        return observerContext;
-      },
+    handlerInfos._namesStashed = true;
+  }
 
-      createPropertyObserver: function (observerContext) {
-        var dependentArrayObserver = this;
+});
+enifed('ember-runtime', ['exports', 'ember-metal', 'ember-runtime/core', 'ember-runtime/compare', 'ember-runtime/copy', 'ember-runtime/inject', 'ember-runtime/system/namespace', 'ember-runtime/system/object', 'ember-runtime/system/tracked_array', 'ember-runtime/system/subarray', 'ember-runtime/system/container', 'ember-runtime/system/array_proxy', 'ember-runtime/system/object_proxy', 'ember-runtime/system/core_object', 'ember-runtime/system/each_proxy', 'ember-runtime/system/native_array', 'ember-runtime/system/set', 'ember-runtime/system/string', 'ember-runtime/system/deferred', 'ember-runtime/system/lazy_load', 'ember-runtime/mixins/array', 'ember-runtime/mixins/comparable', 'ember-runtime/mixins/copyable', 'ember-runtime/mixins/enumerable', 'ember-runtime/mixins/freezable', 'ember-runtime/mixins/-proxy', 'ember-runtime/mixins/observable', 'ember-runtime/mixins/action_handler', 'ember-runtime/mixins/deferred', 'ember-runtime/mixins/mutable_enumerable', 'ember-runtime/mixins/mutable_array', 'ember-runtime/mixins/target_action_support', 'ember-runtime/mixins/evented', 'ember-runtime/mixins/promise_proxy', 'ember-runtime/mixins/sortable', 'ember-runtime/computed/array_computed', 'ember-runtime/computed/reduce_computed', 'ember-runtime/computed/reduce_computed_macros', 'ember-runtime/controllers/array_controller', 'ember-runtime/controllers/object_controller', 'ember-runtime/controllers/controller', 'ember-runtime/mixins/controller', 'ember-runtime/system/service', 'ember-runtime/ext/rsvp', 'ember-runtime/ext/string', 'ember-runtime/ext/function'], function (exports, Ember, core, compare, copy, inject, Namespace, EmberObject, TrackedArray, SubArray, container, ArrayProxy, ObjectProxy, CoreObject, each_proxy, NativeArray, Set, EmberStringUtils, Deferred, lazy_load, EmberArray, Comparable, Copyable, Enumerable, freezable, _ProxyMixin, Observable, ActionHandler, DeferredMixin, MutableEnumerable, MutableArray, TargetActionSupport, Evented, PromiseProxyMixin, SortableMixin, array_computed, reduce_computed, reduce_computed_macros, ArrayController, ObjectController, Controller, ControllerMixin, Service, RSVP) {
+
+  'use strict';
 
-        observerContext.beforeObserver = function (obj, keyName) {
-          return dependentArrayObserver.itemPropertyWillChange(obj, keyName, observerContext.dependentArray, observerContext);
-        };
+  /**
+  Ember Runtime
 
-        observerContext.observer = function (obj, keyName) {
-          return dependentArrayObserver.itemPropertyDidChange(obj, keyName, observerContext.dependentArray, observerContext);
-        };
-      },
+  @module ember
+  @submodule ember-runtime
+  @requires ember-metal
+  */
+
+  // BEGIN IMPORTS
+  Ember['default'].compare = compare['default'];
+  Ember['default'].copy = copy['default'];
+  Ember['default'].isEqual = core.isEqual;
+
+  Ember['default'].inject = inject['default'];
+
+  Ember['default'].Array = EmberArray['default'];
+
+  Ember['default'].Comparable = Comparable['default'];
+  Ember['default'].Copyable = Copyable['default'];
+
+  Ember['default'].SortableMixin = SortableMixin['default'];
+
+  Ember['default'].Freezable = freezable.Freezable;
+  Ember['default'].FROZEN_ERROR = freezable.FROZEN_ERROR;
+
+  Ember['default'].DeferredMixin = DeferredMixin['default'];
+
+  Ember['default'].MutableEnumerable = MutableEnumerable['default'];
+  Ember['default'].MutableArray = MutableArray['default'];
+
+  Ember['default'].TargetActionSupport = TargetActionSupport['default'];
+  Ember['default'].Evented = Evented['default'];
+
+  Ember['default'].PromiseProxyMixin = PromiseProxyMixin['default'];
+
+  Ember['default'].Observable = Observable['default'];
+
+  Ember['default'].arrayComputed = array_computed.arrayComputed;
+  Ember['default'].ArrayComputedProperty = array_computed.ArrayComputedProperty;
+  Ember['default'].reduceComputed = reduce_computed.reduceComputed;
+  Ember['default'].ReduceComputedProperty = reduce_computed.ReduceComputedProperty;
+
+  // ES6TODO: this seems a less than ideal way/place to add properties to Ember.computed
+  var EmComputed = Ember['default'].computed;
+
+  EmComputed.sum = reduce_computed_macros.sum;
+  EmComputed.min = reduce_computed_macros.min;
+  EmComputed.max = reduce_computed_macros.max;
+  EmComputed.map = reduce_computed_macros.map;
+  EmComputed.sort = reduce_computed_macros.sort;
+  EmComputed.setDiff = reduce_computed_macros.setDiff;
+  EmComputed.mapBy = reduce_computed_macros.mapBy;
+  EmComputed.mapProperty = reduce_computed_macros.mapProperty;
+  EmComputed.filter = reduce_computed_macros.filter;
+  EmComputed.filterBy = reduce_computed_macros.filterBy;
+  EmComputed.filterProperty = reduce_computed_macros.filterProperty;
+  EmComputed.uniq = reduce_computed_macros.uniq;
+  EmComputed.union = reduce_computed_macros.union;
+  EmComputed.intersect = reduce_computed_macros.intersect;
+
+  Ember['default'].String = EmberStringUtils['default'];
+  Ember['default'].Object = EmberObject['default'];
+  Ember['default'].TrackedArray = TrackedArray['default'];
+  Ember['default'].SubArray = SubArray['default'];
+  Ember['default'].Container = container.Container;
+  Ember['default'].Registry = container.Registry;
+  Ember['default'].Namespace = Namespace['default'];
+  Ember['default'].Enumerable = Enumerable['default'];
+  Ember['default'].ArrayProxy = ArrayProxy['default'];
+  Ember['default'].ObjectProxy = ObjectProxy['default'];
+  Ember['default'].ActionHandler = ActionHandler['default'];
+  Ember['default'].CoreObject = CoreObject['default'];
+  Ember['default'].EachArray = each_proxy.EachArray;
+  Ember['default'].EachProxy = each_proxy.EachProxy;
+  Ember['default'].NativeArray = NativeArray['default'];
+  // ES6TODO: Currently we must rely on the global from ember-metal/core to avoid circular deps
+  // Ember.A = A;
+  Ember['default'].Set = Set['default'];
+  Ember['default'].Deferred = Deferred['default'];
+  Ember['default'].onLoad = lazy_load.onLoad;
+  Ember['default'].runLoadHooks = lazy_load.runLoadHooks;
+
+  Ember['default'].ArrayController = ArrayController['default'];
+  Ember['default'].ObjectController = ObjectController['default'];
+  Ember['default'].Controller = Controller['default'];
+  Ember['default'].ControllerMixin = ControllerMixin['default'];
+
+  Ember['default'].Service = Service['default'];
+
+  Ember['default']._ProxyMixin = _ProxyMixin['default'];
+
+  Ember['default'].RSVP = RSVP['default'];
+  // END EXPORTS
+
+  exports['default'] = Ember['default'];
+
+});
+enifed('ember-runtime/compare', ['exports', 'ember-metal/utils', 'ember-runtime/mixins/comparable'], function (exports, utils, Comparable) {
+
+  'use strict';
+
+  var TYPE_ORDER = {
+    'undefined': 0,
+    'null': 1,
+    'boolean': 2,
+    'number': 3,
+    'string': 4,
+    'array': 5,
+    'object': 6,
+    'instance': 7,
+    'function': 8,
+    'class': 9,
+    'date': 10
+  };
+
+  //
+  // the spaceship operator
+  //
+  function spaceship(a, b) {
+    var diff = a - b;
+    return (diff > 0) - (diff < 0);
+  }
 
-      resetTransformations: function (dependentKey, observerContexts) {
-        this.trackedArraysByGuid[dependentKey] = new TrackedArray(observerContexts);
-      },
+  /**
+   This will compare two javascript values of possibly different types.
+   It will tell you which one is greater than the other by returning:
 
-      trackAdd: function (dependentKey, index, newItems) {
-        var trackedArray = this.trackedArraysByGuid[dependentKey];
+    - -1 if the first is smaller than the second,
+    - 0 if both are equal,
+    - 1 if the first is greater than the second.
 
-        if (trackedArray) {
-          trackedArray.addItems(index, newItems);
-        }
-      },
+   The order is calculated based on `Ember.ORDER_DEFINITION`, if types are different.
+   In case they have the same type an appropriate comparison for this type is made.
 
-      trackRemove: function (dependentKey, index, removedCount) {
-        var trackedArray = this.trackedArraysByGuid[dependentKey];
+    ```javascript
+    Ember.compare('hello', 'hello');  // 0
+    Ember.compare('abc', 'dfg');      // -1
+    Ember.compare(2, 1);              // 1
+    ```
 
-        if (trackedArray) {
-          return trackedArray.removeItems(index, removedCount);
-        }
+   @method compare
+   @for Ember
+   @param {Object} v First value to compare
+   @param {Object} w Second value to compare
+   @return {Number} -1 if v < w, 0 if v = w and 1 if v > w.
+  */
+  function compare(v, w) {
+    if (v === w) {
+      return 0;
+    }
 
-        return [];
-      },
+    var type1 = utils.typeOf(v);
+    var type2 = utils.typeOf(w);
 
-      updateIndexes: function (trackedArray, array) {
-        var length = get(array, 'length');
-        // OPTIMIZE: we could stop updating once we hit the object whose observer
-        // fired; ie partially apply the transformations
-        trackedArray.apply(function (observerContexts, offset, operation, operationIndex) {
-          // we don't even have observer contexts for removed items, even if we did,
-          // they no longer have any index in the array
-          if (operation === TrackedArray.DELETE) { return; }
-          if (operationIndex === 0 && operation === TrackedArray.RETAIN && observerContexts.length === length && offset === 0) {
-            // If we update many items we don't want to walk the array each time: we
-            // only need to update the indexes at most once per run loop.
-            return;
-          }
+    if (Comparable['default']) {
+      if (type1 === 'instance' && Comparable['default'].detect(v) && v.constructor.compare) {
+        return v.constructor.compare(v, w);
+      }
 
-          forEach(observerContexts, function (context, index) {
-            context.index = index + offset;
-          });
-        });
-      },
+      if (type2 === 'instance' && Comparable['default'].detect(w) && w.constructor.compare) {
+        return w.constructor.compare(w, v) * -1;
+      }
+    }
 
-      dependentArrayWillChange: function (dependentArray, index, removedCount, addedCount) {
-        if (this.suspended) { return; }
+    var res = spaceship(TYPE_ORDER[type1], TYPE_ORDER[type2]);
 
-        var removedItem = this.callbacks.removedItem;
-        var changeMeta;
-        var guid = guidFor(dependentArray);
-        var dependentKey = this.dependentKeysByGuid[guid];
-        var itemPropertyKeys = this.cp._itemPropertyKeys[dependentKey] || [];
-        var length = get(dependentArray, 'length');
-        var normalizedIndex = normalizeIndex(index, length, 0);
-        var normalizedRemoveCount = normalizeRemoveCount(normalizedIndex, length, removedCount);
-        var item, itemIndex, sliceIndex, observerContexts;
+    if (res !== 0) {
+      return res;
+    }
 
-        observerContexts = this.trackRemove(dependentKey, normalizedIndex, normalizedRemoveCount);
+    // types are equal - so we have to check values now
+    switch (type1) {
+      case 'boolean':
+      case 'number':
+        return spaceship(v, w);
 
-        function removeObservers(propertyKey) {
-          observerContexts[sliceIndex].destroyed = true;
-          removeBeforeObserver(item, propertyKey, this, observerContexts[sliceIndex].beforeObserver);
-          removeObserver(item, propertyKey, this, observerContexts[sliceIndex].observer);
-        }
+      case 'string':
+        return spaceship(v.localeCompare(w), 0);
 
-        for (sliceIndex = normalizedRemoveCount - 1; sliceIndex >= 0; --sliceIndex) {
-          itemIndex = normalizedIndex + sliceIndex;
-          if (itemIndex >= length) { break; }
+      case 'array':
+        var vLen = v.length;
+        var wLen = w.length;
+        var len = Math.min(vLen, wLen);
 
-          item = dependentArray.objectAt(itemIndex);
+        for (var i = 0; i < len; i++) {
+          var r = compare(v[i], w[i]);
+          if (r !== 0) {
+            return r;
+          }
+        }
 
-          forEach(itemPropertyKeys, removeObservers, this);
+        // all elements are equal now
+        // shorter array should be ordered first
+        return spaceship(vLen, wLen);
 
-          changeMeta = new ChangeMeta(dependentArray, item, itemIndex, this.instanceMeta.propertyName, this.cp, normalizedRemoveCount);
-          this.setValue(removedItem.call(
-            this.instanceMeta.context, this.getValue(), item, changeMeta, this.instanceMeta.sugarMeta));
+      case 'instance':
+        if (Comparable['default'] && Comparable['default'].detect(v)) {
+          return v.compare(v, w);
         }
-        this.callbacks.flushedChanges.call(this.instanceMeta.context, this.getValue(), this.instanceMeta.sugarMeta);
-      },
-
-      dependentArrayDidChange: function (dependentArray, index, removedCount, addedCount) {
-        if (this.suspended) { return; }
-
-        var addedItem = this.callbacks.addedItem;
-        var guid = guidFor(dependentArray);
-        var dependentKey = this.dependentKeysByGuid[guid];
-        var observerContexts = new Array(addedCount);
-        var itemPropertyKeys = this.cp._itemPropertyKeys[dependentKey];
-        var length = get(dependentArray, 'length');
-        var normalizedIndex = normalizeIndex(index, length, addedCount);
-        var endIndex = normalizedIndex + addedCount;
-        var changeMeta, observerContext;
-
-        forEach(dependentArray.slice(normalizedIndex, endIndex), function (item, sliceIndex) {
-          if (itemPropertyKeys) {
-            observerContext = this.createPropertyObserverContext(dependentArray, normalizedIndex + sliceIndex,
-              this.trackedArraysByGuid[dependentKey]);
-            observerContexts[sliceIndex] = observerContext;
-
-            forEach(itemPropertyKeys, function (propertyKey) {
-              addBeforeObserver(item, propertyKey, this, observerContext.beforeObserver);
-              addObserver(item, propertyKey, this, observerContext.observer);
-            }, this);
-          }
+        return 0;
 
-          changeMeta = new ChangeMeta(dependentArray, item, normalizedIndex + sliceIndex, this.instanceMeta.propertyName, this.cp, addedCount);
-          this.setValue(addedItem.call(
-            this.instanceMeta.context, this.getValue(), item, changeMeta, this.instanceMeta.sugarMeta));
-        }, this);
-        this.callbacks.flushedChanges.call(this.instanceMeta.context, this.getValue(), this.instanceMeta.sugarMeta);
-        this.trackAdd(dependentKey, normalizedIndex, observerContexts);
-      },
+      case 'date':
+        return spaceship(v.getTime(), w.getTime());
 
-      itemPropertyWillChange: function (obj, keyName, array, observerContext) {
-        var guid = guidFor(obj);
+      default:
+        return 0;
+    }
+  }
+  exports['default'] = compare;
 
-        if (!this.changedItems[guid]) {
-          this.changedItems[guid] = {
-            array: array,
-            observerContext: observerContext,
-            obj: obj,
-            previousValues: {}
-          };
-        }
+});
+enifed('ember-runtime/computed/array_computed', ['exports', 'ember-metal/core', 'ember-runtime/computed/reduce_computed', 'ember-metal/enumerable_utils', 'ember-metal/platform/create', 'ember-metal/observer', 'ember-metal/error'], function (exports, Ember, reduce_computed, enumerable_utils, o_create, observer, EmberError) {
 
-        ++this.changedItemCount;
-        this.changedItems[guid].previousValues[keyName] = get(obj, keyName);
-      },
+  'use strict';
 
-      itemPropertyDidChange: function (obj, keyName, array, observerContext) {
-        if (--this.changedItemCount === 0) {
-          this.flushChanges();
-        }
-      },
+  exports.arrayComputed = arrayComputed;
+  exports.ArrayComputedProperty = ArrayComputedProperty;
 
-      flushChanges: function () {
-        var changedItems = this.changedItems;
-        var key, c, changeMeta;
+  var a_slice = [].slice;
 
-        for (key in changedItems) {
-          c = changedItems[key];
-          if (c.observerContext.destroyed) { continue; }
+  function ArrayComputedProperty() {
+    var cp = this;
 
-          this.updateIndexes(c.observerContext.trackedArray, c.observerContext.dependentArray);
+    reduce_computed.ReduceComputedProperty.apply(this, arguments);
 
-          changeMeta = new ChangeMeta(c.array, c.obj, c.observerContext.index, this.instanceMeta.propertyName, this.cp, changedItems.length, c.previousValues);
-          this.setValue(
-            this.callbacks.removedItem.call(this.instanceMeta.context, this.getValue(), c.obj, changeMeta, this.instanceMeta.sugarMeta));
-          this.setValue(
-            this.callbacks.addedItem.call(this.instanceMeta.context, this.getValue(), c.obj, changeMeta, this.instanceMeta.sugarMeta));
+    this._getter = (function(reduceFunc) {
+      return function (propertyName) {
+        if (!cp._hasInstanceMeta(this, propertyName)) {
+          // When we recompute an array computed property, we need already
+          // retrieved arrays to be updated; we can't simply empty the cache and
+          // hope the array is re-retrieved.
+          enumerable_utils.forEach(cp._dependentKeys, function(dependentKey) {
+            observer.addObserver(this, dependentKey, function() {
+              cp.recomputeOnce.call(this, propertyName);
+            });
+          }, this);
         }
 
-        this.changedItems = {};
-        this.callbacks.flushedChanges.call(this.instanceMeta.context, this.getValue(), this.instanceMeta.sugarMeta);
-      }
-    };
-
-    function normalizeIndex(index, length, newItemsOffset) {
-      if (index < 0) {
-        return Math.max(0, length + index);
-      } else if (index < length) {
-        return index;
-      } else /* index > length */ {
-        return Math.min(length - newItemsOffset, index);
-      }
-    }
-
-    function normalizeRemoveCount(index, length, removedCount) {
-      return Math.min(removedCount, length - index);
-    }
+        return reduceFunc.apply(this, arguments);
+      };
+    })(this._getter);
 
-    function ChangeMeta(dependentArray, item, index, propertyName, property, changedCount, previousValues){
-      this.arrayChanged = dependentArray;
-      this.index = index;
-      this.item = item;
-      this.propertyName = propertyName;
-      this.property = property;
-      this.changedCount = changedCount;
+    return this;
+  }
 
-      if (previousValues) {
-        // previous values only available for item property changes
-        this.previousValues = previousValues;
-      }
-    }
+  ArrayComputedProperty.prototype = o_create['default'](reduce_computed.ReduceComputedProperty.prototype);
 
-    function addItems(dependentArray, callbacks, cp, propertyName, meta) {
-      forEach(dependentArray, function (item, index) {
-        meta.setValue( callbacks.addedItem.call(
-          this, meta.getValue(), item, new ChangeMeta(dependentArray, item, index, propertyName, cp, dependentArray.length), meta.sugarMeta));
-      }, this);
-      callbacks.flushedChanges.call(this, meta.getValue(), meta.sugarMeta);
-    }
+  ArrayComputedProperty.prototype.initialValue = function () {
+    return Ember['default'].A();
+  };
 
-    function reset(cp, propertyName) {
-      var hadMeta = cp._hasInstanceMeta(this, propertyName);
-      var meta = cp._instanceMeta(this, propertyName);
+  ArrayComputedProperty.prototype.resetValue = function (array) {
+    array.clear();
+    return array;
+  };
 
-      if (hadMeta) { meta.setValue(cp.resetValue(meta.getValue())); }
+  // This is a stopgap to keep the reference counts correct with lazy CPs.
+  ArrayComputedProperty.prototype.didChange = function (obj, keyName) {
+    return;
+  };
 
-      if (cp.options.initialize) {
-        cp.options.initialize.call(this, meta.getValue(), {
-          property: cp,
-          propertyName: propertyName
-        }, meta.sugarMeta);
-      }
-    }
+  /**
+    Creates a computed property which operates on dependent arrays and
+    is updated with "one at a time" semantics. When items are added or
+    removed from the dependent array(s) an array computed only operates
+    on the change instead of re-evaluating the entire array. This should
+    return an array, if you'd like to use "one at a time" semantics and
+    compute some value other then an array look at
+    `Ember.reduceComputed`.
 
-    function partiallyRecomputeFor(obj, dependentKey) {
-      if (arrayBracketPattern.test(dependentKey)) {
-        return false;
-      }
+    If there are more than one arguments the first arguments are
+    considered to be dependent property keys. The last argument is
+    required to be an options object. The options object can have the
+    following three properties.
 
-      var value = get(obj, dependentKey);
-      return EmberArray.detect(value);
-    }
+    `initialize` - An optional initialize function. Typically this will be used
+    to set up state on the instanceMeta object.
 
-    function ReduceComputedPropertyInstanceMeta(context, propertyName, initialValue) {
-      this.context = context;
-      this.propertyName = propertyName;
-      this.cache = metaFor(context).cache;
-      this.dependentArrays = {};
-      this.sugarMeta = {};
-      this.initialValue = initialValue;
-    }
+    `removedItem` - A function that is called each time an element is
+    removed from the array.
 
-    ReduceComputedPropertyInstanceMeta.prototype = {
-      getValue: function () {
-        var value = cacheGet(this.cache, this.propertyName);
+    `addedItem` - A function that is called each time an element is
+    added to the array.
 
-        if (value !== undefined) {
-          return value;
-        } else {
-          return this.initialValue;
-        }
-      },
 
-      setValue: function(newValue, triggerObservers) {
-        // This lets sugars force a recomputation, handy for very simple
-        // implementations of eg max.
-        if (newValue === cacheGet(this.cache, this.propertyName)) {
-          return;
-        }
+    The `initialize` function has the following signature:
 
-        if (triggerObservers) {
-          propertyWillChange(this.context, this.propertyName);
-        }
+    ```javascript
+    function(array, changeMeta, instanceMeta)
+    ```
 
-        if (newValue === undefined) {
-          cacheRemove(this.cache, this.propertyName);
-        } else {
-          cacheSet(this.cache, this.propertyName, newValue);
-        }
+    `array` - The initial value of the arrayComputed, an empty array.
 
-        if (triggerObservers) {
-          propertyDidChange(this.context, this.propertyName);
-        }
-      }
-    };
+    `changeMeta` - An object which contains meta information about the
+    computed. It contains the following properties:
 
-    /**
-      A computed property whose dependent keys are arrays and which is updated with
-      "one at a time" semantics.
+       - `property` the computed property
+       - `propertyName` the name of the property on the object
 
-      @class ReduceComputedProperty
-      @namespace Ember
-      @extends Ember.ComputedProperty
-      @constructor
-    */
+    `instanceMeta` - An object that can be used to store meta
+    information needed for calculating your computed. For example a
+    unique computed might use this to store the number of times a given
+    element is found in the dependent array.
 
-    __exports__.ReduceComputedProperty = ReduceComputedProperty;
-    // TODO: default export
 
-    function ReduceComputedProperty(options) {
-      var cp = this;
+    The `removedItem` and `addedItem` functions both have the following signature:
 
-      this.options = options;
-      this._dependentKeys = null;
-      this._cacheable = true;
-      // A map of dependentKey -> [itemProperty, ...] that tracks what properties of
-      // items in the array we must track to update this property.
-      this._itemPropertyKeys = {};
-      this._previousItemPropertyKeys = {};
-
-      this.readOnly();
-
-      this.recomputeOnce = function(propertyName) {
-        // What we really want to do is coalesce by <cp, propertyName>.
-        // We need a form of `scheduleOnce` that accepts an arbitrary token to
-        // coalesce by, in addition to the target and method.
-        run.once(this, recompute, propertyName);
-      };
+    ```javascript
+    function(accumulatedValue, item, changeMeta, instanceMeta)
+    ```
 
-      var recompute = function(propertyName) {
-        var meta = cp._instanceMeta(this, propertyName);
-        var callbacks = cp._callbacks();
+    `accumulatedValue` - The value returned from the last time
+    `removedItem` or `addedItem` was called or an empty array.
 
-        reset.call(this, cp, propertyName);
+    `item` - the element added or removed from the array
 
-        meta.dependentArraysObserver.suspendArrayObservers(function () {
-          forEach(cp._dependentKeys, function (dependentKey) {
-            Ember.assert(
-              'dependent array ' + dependentKey + ' must be an `Ember.Array`.  ' +
-              'If you are not extending arrays, you will need to wrap native arrays with `Ember.A`',
-              !(isArray(get(this, dependentKey)) && !EmberArray.detect(get(this, dependentKey))));
+    `changeMeta` - An object which contains meta information about the
+    change. It contains the following properties:
 
-            if (!partiallyRecomputeFor(this, dependentKey)) { return; }
+      - `property` the computed property
+      - `propertyName` the name of the property on the object
+      - `index` the index of the added or removed item
+      - `item` the added or removed item: this is exactly the same as
+        the second arg
+      - `arrayChanged` the array that triggered the change. Can be
+        useful when depending on multiple arrays.
 
-            var dependentArray = get(this, dependentKey);
-            var previousDependentArray = meta.dependentArrays[dependentKey];
+    For property changes triggered on an item property change (when
+    depKey is something like `someArray.@each.someProperty`),
+    `changeMeta` will also contain the following property:
 
-            if (dependentArray === previousDependentArray) {
-              // The array may be the same, but our item property keys may have
-              // changed, so we set them up again.  We can't easily tell if they've
-              // changed: the array may be the same object, but with different
-              // contents.
-              if (cp._previousItemPropertyKeys[dependentKey]) {
-                delete cp._previousItemPropertyKeys[dependentKey];
-                meta.dependentArraysObserver.setupPropertyObservers(dependentKey, cp._itemPropertyKeys[dependentKey]);
-              }
-            } else {
-              meta.dependentArrays[dependentKey] = dependentArray;
+      - `previousValues` an object whose keys are the properties that changed on
+      the item, and whose values are the item's previous values.
 
-              if (previousDependentArray) {
-                meta.dependentArraysObserver.teardownObservers(previousDependentArray, dependentKey);
-              }
+    `previousValues` is important Ember coalesces item property changes via
+    Ember.run.once. This means that by the time removedItem gets called, item has
+    the new values, but you may need the previous value (eg for sorting &
+    filtering).
 
-              if (dependentArray) {
-                meta.dependentArraysObserver.setupObservers(dependentArray, dependentKey);
-              }
-            }
-          }, this);
-        }, this);
+    `instanceMeta` - An object that can be used to store meta
+    information needed for calculating your computed. For example a
+    unique computed might use this to store the number of times a given
+    element is found in the dependent array.
 
-        forEach(cp._dependentKeys, function(dependentKey) {
-          if (!partiallyRecomputeFor(this, dependentKey)) { return; }
+    The `removedItem` and `addedItem` functions should return the accumulated
+    value. It is acceptable to not return anything (ie return undefined)
+    to invalidate the computation. This is generally not a good idea for
+    arrayComputed but it's used in eg max and min.
 
-          var dependentArray = get(this, dependentKey);
+    Example
 
-          if (dependentArray) {
-            addItems.call(this, dependentArray, callbacks, cp, propertyName, meta);
-          }
-        }, this);
+    ```javascript
+    Ember.computed.map = function(dependentKey, callback) {
+      var options = {
+        addedItem: function(array, item, changeMeta, instanceMeta) {
+          var mapped = callback(item);
+          array.insertAt(changeMeta.index, mapped);
+          return array;
+        },
+        removedItem: function(array, item, changeMeta, instanceMeta) {
+          array.removeAt(changeMeta.index, 1);
+          return array;
+        }
       };
 
+      return Ember.arrayComputed(dependentKey, options);
+    };
+    ```
 
-      this.func = function (propertyName) {
-        Ember.assert('Computed reduce values require at least one dependent key', cp._dependentKeys);
+    @method arrayComputed
+    @for Ember
+    @param {String} [dependentKeys*]
+    @param {Object} options
+    @return {Ember.ComputedProperty}
+  */
+  function arrayComputed(options) {
+    var args;
 
-        recompute.call(this, propertyName);
+    if (arguments.length > 1) {
+      args = a_slice.call(arguments, 0, -1);
+      options = a_slice.call(arguments, -1)[0];
+    }
 
-        return cp._instanceMeta(this, propertyName).getValue();
-      };
+    if (typeof options !== 'object') {
+      throw new EmberError['default']('Array Computed Property declared without an options hash');
     }
 
-    ReduceComputedProperty.prototype = o_create(ComputedProperty.prototype);
+    var cp = new ArrayComputedProperty(options);
 
-    function defaultCallback(computedValue) {
-      return computedValue;
+    if (args) {
+      cp.property.apply(cp, args);
     }
 
-    ReduceComputedProperty.prototype._callbacks = function () {
-      if (!this.callbacks) {
-        var options = this.options;
+    return cp;
+  }
 
-        this.callbacks = {
-          removedItem: options.removedItem || defaultCallback,
-          addedItem: options.addedItem || defaultCallback,
-          flushedChanges: options.flushedChanges || defaultCallback
-        };
-      }
+});
+enifed('ember-runtime/computed/reduce_computed', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/utils', 'ember-metal/error', 'ember-metal/property_events', 'ember-metal/expand_properties', 'ember-metal/observer', 'ember-metal/computed', 'ember-metal/platform/create', 'ember-metal/enumerable_utils', 'ember-runtime/system/tracked_array', 'ember-runtime/mixins/array', 'ember-metal/run_loop'], function (exports, Ember, property_get, utils, EmberError, property_events, expandProperties, ember_metal__observer, computed, o_create, enumerable_utils, TrackedArray, EmberArray, run) {
 
-      return this.callbacks;
-    };
+  'use strict';
 
-    ReduceComputedProperty.prototype._hasInstanceMeta = function (context, propertyName) {
-      return !!metaFor(context).cacheMeta[propertyName];
-    };
+  exports.ReduceComputedProperty = ReduceComputedProperty;
+  exports.reduceComputed = reduceComputed;
 
-    ReduceComputedProperty.prototype._instanceMeta = function (context, propertyName) {
-      var cacheMeta = metaFor(context).cacheMeta;
-      var meta = cacheMeta[propertyName];
+  var cacheSet = computed.cacheFor.set;
+  var cacheGet = computed.cacheFor.get;
+  var cacheRemove = computed.cacheFor.remove;
+  var a_slice = [].slice;
+  // Here we explicitly don't allow `@each.foo`; it would require some special
+  // testing, but there's no particular reason why it should be disallowed.
+  var eachPropertyPattern = /^(.*)\.@each\.(.*)/;
+  var doubleEachPropertyPattern = /(.*\.@each){2,}/;
+  var arrayBracketPattern = /\.\[\]$/;
 
-      if (!meta) {
-        meta = cacheMeta[propertyName] = new ReduceComputedPropertyInstanceMeta(context, propertyName, this.initialValue());
-        meta.dependentArraysObserver = new DependentArraysObserver(this._callbacks(), this, meta, context, propertyName, meta.sugarMeta);
-      }
+  function get(obj, key) {
+    if (key === '@this') {
+      return obj;
+    }
 
-      return meta;
-    };
+    return property_get.get(obj, key);
+  }
 
-    ReduceComputedProperty.prototype.initialValue = function () {
-      if (typeof this.options.initialValue === 'function') {
-        return this.options.initialValue();
-      }
-      else {
-        return this.options.initialValue;
-      }
-    };
+  /*
+    Tracks changes to dependent arrays, as well as to properties of items in
+    dependent arrays.
+
+    @class DependentArraysObserver
+  */
+  function DependentArraysObserver(callbacks, cp, instanceMeta, context, propertyName, sugarMeta) {
+    // user specified callbacks for `addedItem` and `removedItem`
+    this.callbacks = callbacks;
+
+    // the computed property: remember these are shared across instances
+    this.cp = cp;
+
+    // the ReduceComputedPropertyInstanceMeta this DependentArraysObserver is
+    // associated with
+    this.instanceMeta = instanceMeta;
+
+    // A map of array guids to dependentKeys, for the given context.  We track
+    // this because we want to set up the computed property potentially before the
+    // dependent array even exists, but when the array observer fires, we lack
+    // enough context to know what to update: we can recover that context by
+    // getting the dependentKey.
+    this.dependentKeysByGuid = {};
+
+    // a map of dependent array guids -> TrackedArray instances.  We use
+    // this to lazily recompute indexes for item property observers.
+    this.trackedArraysByGuid = {};
+
+    // We suspend observers to ignore replacements from `reset` when totally
+    // recomputing.  Unfortunately we cannot properly suspend the observers
+    // because we only have the key; instead we make the observers no-ops
+    this.suspended = false;
+
+    // This is used to coalesce item changes from property observers within a
+    // single item.
+    this.changedItems = {};
+    // This is used to coalesce item changes for multiple items that depend on
+    // some shared state.
+    this.changedItemCount = 0;
+  }
 
-    ReduceComputedProperty.prototype.resetValue = function (value) {
-      return this.initialValue();
-    };
+  function ItemPropertyObserverContext(dependentArray, index, trackedArray) {
+    Ember['default'].assert('Internal error: trackedArray is null or undefined', trackedArray);
 
-    ReduceComputedProperty.prototype.itemPropertyKey = function (dependentArrayKey, itemPropertyKey) {
-      this._itemPropertyKeys[dependentArrayKey] = this._itemPropertyKeys[dependentArrayKey] || [];
-      this._itemPropertyKeys[dependentArrayKey].push(itemPropertyKey);
-    };
+    this.dependentArray = dependentArray;
+    this.index = index;
+    this.item = dependentArray.objectAt(index);
+    this.trackedArray = trackedArray;
+    this.beforeObserver = null;
+    this.observer = null;
+    this.destroyed = false;
+  }
 
-    ReduceComputedProperty.prototype.clearItemPropertyKeys = function (dependentArrayKey) {
-      if (this._itemPropertyKeys[dependentArrayKey]) {
-        this._previousItemPropertyKeys[dependentArrayKey] = this._itemPropertyKeys[dependentArrayKey];
-        this._itemPropertyKeys[dependentArrayKey] = [];
-      }
-    };
+  DependentArraysObserver.prototype = {
+    setValue: function (newValue) {
+      this.instanceMeta.setValue(newValue, true);
+    },
 
-    ReduceComputedProperty.prototype.property = function () {
-      var cp = this;
-      var args = a_slice.call(arguments);
-      var propertyArgs = {};
-      var match, dependentArrayKey;
-
-      forEach(args, function (dependentKey) {
-        if (doubleEachPropertyPattern.test(dependentKey)) {
-          throw new EmberError('Nested @each properties not supported: ' + dependentKey);
-        } else if (match = eachPropertyPattern.exec(dependentKey)) {
-          dependentArrayKey = match[1];
-
-          var itemPropertyKeyPattern = match[2];
-          var addItemPropertyKey = function (itemPropertyKey) {
-            cp.itemPropertyKey(dependentArrayKey, itemPropertyKey);
-          };
+    getValue: function () {
+      return this.instanceMeta.getValue();
+    },
 
-          expandProperties(itemPropertyKeyPattern, addItemPropertyKey);
-          propertyArgs[guidFor(dependentArrayKey)] = dependentArrayKey;
-        } else {
-          propertyArgs[guidFor(dependentKey)] = dependentKey;
-        }
+    setupObservers: function (dependentArray, dependentKey) {
+      this.dependentKeysByGuid[utils.guidFor(dependentArray)] = dependentKey;
+
+      dependentArray.addArrayObserver(this, {
+        willChange: 'dependentArrayWillChange',
+        didChange: 'dependentArrayDidChange'
       });
 
-      var propertyArgsToArray = [];
-      for (var guid in propertyArgs) {
-        propertyArgsToArray.push(propertyArgs[guid]);
+      if (this.cp._itemPropertyKeys[dependentKey]) {
+        this.setupPropertyObservers(dependentKey, this.cp._itemPropertyKeys[dependentKey]);
       }
+    },
 
-      return ComputedProperty.prototype.property.apply(this, propertyArgsToArray);
-    };
-
-    /**
-      Creates a computed property which operates on dependent arrays and
-      is updated with "one at a time" semantics. When items are added or
-      removed from the dependent array(s) a reduce computed only operates
-      on the change instead of re-evaluating the entire array.
-
-      If there are more than one arguments the first arguments are
-      considered to be dependent property keys. The last argument is
-      required to be an options object. The options object can have the
-      following four properties:
-
-      `initialValue` - A value or function that will be used as the initial
-      value for the computed. If this property is a function the result of calling
-      the function will be used as the initial value. This property is required.
+    teardownObservers: function (dependentArray, dependentKey) {
+      var itemPropertyKeys = this.cp._itemPropertyKeys[dependentKey] || [];
 
-      `initialize` - An optional initialize function. Typically this will be used
-      to set up state on the instanceMeta object.
+      delete this.dependentKeysByGuid[utils.guidFor(dependentArray)];
 
-      `removedItem` - A function that is called each time an element is removed
-      from the array.
+      this.teardownPropertyObservers(dependentKey, itemPropertyKeys);
 
-      `addedItem` - A function that is called each time an element is added to
-      the array.
+      dependentArray.removeArrayObserver(this, {
+        willChange: 'dependentArrayWillChange',
+        didChange: 'dependentArrayDidChange'
+      });
+    },
 
+    suspendArrayObservers: function (callback, binding) {
+      var oldSuspended = this.suspended;
+      this.suspended = true;
+      callback.call(binding);
+      this.suspended = oldSuspended;
+    },
 
-      The `initialize` function has the following signature:
+    setupPropertyObservers: function (dependentKey, itemPropertyKeys) {
+      var dependentArray = get(this.instanceMeta.context, dependentKey);
+      var length = get(dependentArray, 'length');
+      var observerContexts = new Array(length);
 
-      ```javascript
-      function(initialValue, changeMeta, instanceMeta)
-      ```
+      this.resetTransformations(dependentKey, observerContexts);
 
-      `initialValue` - The value of the `initialValue` property from the
-      options object.
+      enumerable_utils.forEach(dependentArray, function (item, index) {
+        var observerContext = this.createPropertyObserverContext(dependentArray, index, this.trackedArraysByGuid[dependentKey]);
+        observerContexts[index] = observerContext;
 
-      `changeMeta` - An object which contains meta information about the
-      computed. It contains the following properties:
+        enumerable_utils.forEach(itemPropertyKeys, function (propertyKey) {
+          ember_metal__observer.addBeforeObserver(item, propertyKey, this, observerContext.beforeObserver);
+          ember_metal__observer.addObserver(item, propertyKey, this, observerContext.observer);
+        }, this);
+      }, this);
+    },
 
-         - `property` the computed property
-         - `propertyName` the name of the property on the object
+    teardownPropertyObservers: function (dependentKey, itemPropertyKeys) {
+      var dependentArrayObserver = this;
+      var trackedArray = this.trackedArraysByGuid[dependentKey];
+      var beforeObserver, observer, item;
 
-      `instanceMeta` - An object that can be used to store meta
-      information needed for calculating your computed. For example a
-      unique computed might use this to store the number of times a given
-      element is found in the dependent array.
+      if (!trackedArray) { return; }
 
+      trackedArray.apply(function (observerContexts, offset, operation) {
+        if (operation === TrackedArray['default'].DELETE) { return; }
 
-      The `removedItem` and `addedItem` functions both have the following signature:
+        enumerable_utils.forEach(observerContexts, function (observerContext) {
+          observerContext.destroyed = true;
+          beforeObserver = observerContext.beforeObserver;
+          observer = observerContext.observer;
+          item = observerContext.item;
 
-      ```javascript
-      function(accumulatedValue, item, changeMeta, instanceMeta)
-      ```
+          enumerable_utils.forEach(itemPropertyKeys, function (propertyKey) {
+            ember_metal__observer.removeBeforeObserver(item, propertyKey, dependentArrayObserver, beforeObserver);
+            ember_metal__observer.removeObserver(item, propertyKey, dependentArrayObserver, observer);
+          });
+        });
+      });
+    },
 
-      `accumulatedValue` - The value returned from the last time
-      `removedItem` or `addedItem` was called or `initialValue`.
+    createPropertyObserverContext: function (dependentArray, index, trackedArray) {
+      var observerContext = new ItemPropertyObserverContext(dependentArray, index, trackedArray);
 
-      `item` - the element added or removed from the array
+      this.createPropertyObserver(observerContext);
 
-      `changeMeta` - An object which contains meta information about the
-      change. It contains the following properties:
+      return observerContext;
+    },
 
-        - `property` the computed property
-        - `propertyName` the name of the property on the object
-        - `index` the index of the added or removed item
-        - `item` the added or removed item: this is exactly the same as
-          the second arg
-        - `arrayChanged` the array that triggered the change. Can be
-          useful when depending on multiple arrays.
+    createPropertyObserver: function (observerContext) {
+      var dependentArrayObserver = this;
 
-      For property changes triggered on an item property change (when
-      depKey is something like `someArray.@each.someProperty`),
-      `changeMeta` will also contain the following property:
+      observerContext.beforeObserver = function (obj, keyName) {
+        return dependentArrayObserver.itemPropertyWillChange(obj, keyName, observerContext.dependentArray, observerContext);
+      };
 
-        - `previousValues` an object whose keys are the properties that changed on
-        the item, and whose values are the item's previous values.
+      observerContext.observer = function (obj, keyName) {
+        return dependentArrayObserver.itemPropertyDidChange(obj, keyName, observerContext.dependentArray, observerContext);
+      };
+    },
 
-      `previousValues` is important Ember coalesces item property changes via
-      Ember.run.once. This means that by the time removedItem gets called, item has
-      the new values, but you may need the previous value (eg for sorting &
-      filtering).
+    resetTransformations: function (dependentKey, observerContexts) {
+      this.trackedArraysByGuid[dependentKey] = new TrackedArray['default'](observerContexts);
+    },
 
-      `instanceMeta` - An object that can be used to store meta
-      information needed for calculating your computed. For example a
-      unique computed might use this to store the number of times a given
-      element is found in the dependent array.
+    trackAdd: function (dependentKey, index, newItems) {
+      var trackedArray = this.trackedArraysByGuid[dependentKey];
 
-      The `removedItem` and `addedItem` functions should return the accumulated
-      value. It is acceptable to not return anything (ie return undefined)
-      to invalidate the computation. This is generally not a good idea for
-      arrayComputed but it's used in eg max and min.
+      if (trackedArray) {
+        trackedArray.addItems(index, newItems);
+      }
+    },
 
-      Note that observers will be fired if either of these functions return a value
-      that differs from the accumulated value.  When returning an object that
-      mutates in response to array changes, for example an array that maps
-      everything from some other array (see `Ember.computed.map`), it is usually
-      important that the *same* array be returned to avoid accidentally triggering observers.
+    trackRemove: function (dependentKey, index, removedCount) {
+      var trackedArray = this.trackedArraysByGuid[dependentKey];
 
-      Example
+      if (trackedArray) {
+        return trackedArray.removeItems(index, removedCount);
+      }
 
-      ```javascript
-      Ember.computed.max = function(dependentKey) {
-        return Ember.reduceComputed(dependentKey, {
-          initialValue: -Infinity,
+      return [];
+    },
 
-          addedItem: function(accumulatedValue, item, changeMeta, instanceMeta) {
-            return Math.max(accumulatedValue, item);
-          },
+    updateIndexes: function (trackedArray, array) {
+      var length = get(array, 'length');
+      // OPTIMIZE: we could stop updating once we hit the object whose observer
+      // fired; ie partially apply the transformations
+      trackedArray.apply(function (observerContexts, offset, operation, operationIndex) {
+        // we don't even have observer contexts for removed items, even if we did,
+        // they no longer have any index in the array
+        if (operation === TrackedArray['default'].DELETE) { return; }
+        if (operationIndex === 0 && operation === TrackedArray['default'].RETAIN && observerContexts.length === length && offset === 0) {
+          // If we update many items we don't want to walk the array each time: we
+          // only need to update the indexes at most once per run loop.
+          return;
+        }
 
-          removedItem: function(accumulatedValue, item, changeMeta, instanceMeta) {
-            if (item < accumulatedValue) {
-              return accumulatedValue;
-            }
-          }
+        enumerable_utils.forEach(observerContexts, function (context, index) {
+          context.index = index + offset;
         });
-      };
-      ```
+      });
+    },
 
-      Dependent keys may refer to `@this` to observe changes to the object itself,
-      which must be array-like, rather than a property of the object.  This is
-      mostly useful for array proxies, to ensure objects are retrieved via
-      `objectAtContent`.  This is how you could sort items by properties defined on an item controller.
+    dependentArrayWillChange: function (dependentArray, index, removedCount, addedCount) {
+      if (this.suspended) { return; }
 
-      Example
+      var removedItem = this.callbacks.removedItem;
+      var changeMeta;
+      var guid = utils.guidFor(dependentArray);
+      var dependentKey = this.dependentKeysByGuid[guid];
+      var itemPropertyKeys = this.cp._itemPropertyKeys[dependentKey] || [];
+      var length = get(dependentArray, 'length');
+      var normalizedIndex = normalizeIndex(index, length, 0);
+      var normalizedRemoveCount = normalizeRemoveCount(normalizedIndex, length, removedCount);
+      var item, itemIndex, sliceIndex, observerContexts;
 
-      ```javascript
-      App.PeopleController = Ember.ArrayController.extend({
-        itemController: 'person',
+      observerContexts = this.trackRemove(dependentKey, normalizedIndex, normalizedRemoveCount);
 
-        sortedPeople: Ember.computed.sort('@this.@each.reversedName', function(personA, personB) {
-          // `reversedName` isn't defined on Person, but we have access to it via
-          // the item controller App.PersonController.  If we'd used
-          // `content.@each.reversedName` above, we would be getting the objects
-          // directly and not have access to `reversedName`.
-          //
-          var reversedNameA = get(personA, 'reversedName');
-          var reversedNameB = get(personB, 'reversedName');
+      function removeObservers(propertyKey) {
+        observerContexts[sliceIndex].destroyed = true;
+        ember_metal__observer.removeBeforeObserver(item, propertyKey, this, observerContexts[sliceIndex].beforeObserver);
+        ember_metal__observer.removeObserver(item, propertyKey, this, observerContexts[sliceIndex].observer);
+      }
 
-          return Ember.compare(reversedNameA, reversedNameB);
-        })
-      });
+      for (sliceIndex = normalizedRemoveCount - 1; sliceIndex >= 0; --sliceIndex) {
+        itemIndex = normalizedIndex + sliceIndex;
+        if (itemIndex >= length) { break; }
 
-      App.PersonController = Ember.ObjectController.extend({
-        reversedName: function() {
-          return reverse(get(this, 'name'));
-        }.property('name')
-      });
-      ```
+        item = dependentArray.objectAt(itemIndex);
 
-      Dependent keys whose values are not arrays are treated as regular
-      dependencies: when they change, the computed property is completely
-      recalculated.  It is sometimes useful to have dependent arrays with similar
-      semantics.  Dependent keys which end in `.[]` do not use "one at a time"
-      semantics.  When an item is added or removed from such a dependency, the
-      computed property is completely recomputed.
+        enumerable_utils.forEach(itemPropertyKeys, removeObservers, this);
 
-      When the computed property is completely recomputed, the `accumulatedValue`
-      is discarded, it starts with `initialValue` again, and each item is passed
-      to `addedItem` in turn.
+        changeMeta = new ChangeMeta(dependentArray, item, itemIndex, this.instanceMeta.propertyName, this.cp, normalizedRemoveCount);
+        this.setValue(removedItem.call(
+          this.instanceMeta.context, this.getValue(), item, changeMeta, this.instanceMeta.sugarMeta));
+      }
+      this.callbacks.flushedChanges.call(this.instanceMeta.context, this.getValue(), this.instanceMeta.sugarMeta);
+    },
 
-      Example
+    dependentArrayDidChange: function (dependentArray, index, removedCount, addedCount) {
+      if (this.suspended) { return; }
 
-      ```javascript
-      Ember.Object.extend({
-        // When `string` is changed, `computed` is completely recomputed.
-        string: 'a string',
+      var addedItem = this.callbacks.addedItem;
+      var guid = utils.guidFor(dependentArray);
+      var dependentKey = this.dependentKeysByGuid[guid];
+      var observerContexts = new Array(addedCount);
+      var itemPropertyKeys = this.cp._itemPropertyKeys[dependentKey];
+      var length = get(dependentArray, 'length');
+      var normalizedIndex = normalizeIndex(index, length, addedCount);
+      var endIndex = normalizedIndex + addedCount;
+      var changeMeta, observerContext;
 
-        // When an item is added to `array`, `addedItem` is called.
-        array: [],
+      enumerable_utils.forEach(dependentArray.slice(normalizedIndex, endIndex), function (item, sliceIndex) {
+        if (itemPropertyKeys) {
+          observerContext = this.createPropertyObserverContext(dependentArray, normalizedIndex + sliceIndex,
+            this.trackedArraysByGuid[dependentKey]);
+          observerContexts[sliceIndex] = observerContext;
 
-        // When an item is added to `anotherArray`, `computed` is completely
-        // recomputed.
-        anotherArray: [],
+          enumerable_utils.forEach(itemPropertyKeys, function (propertyKey) {
+            ember_metal__observer.addBeforeObserver(item, propertyKey, this, observerContext.beforeObserver);
+            ember_metal__observer.addObserver(item, propertyKey, this, observerContext.observer);
+          }, this);
+        }
 
-        computed: Ember.reduceComputed('string', 'array', 'anotherArray.[]', {
-          addedItem: addedItemCallback,
-          removedItem: removedItemCallback
-        })
-      });
-      ```
+        changeMeta = new ChangeMeta(dependentArray, item, normalizedIndex + sliceIndex, this.instanceMeta.propertyName, this.cp, addedCount);
+        this.setValue(addedItem.call(
+          this.instanceMeta.context, this.getValue(), item, changeMeta, this.instanceMeta.sugarMeta));
+      }, this);
+      this.callbacks.flushedChanges.call(this.instanceMeta.context, this.getValue(), this.instanceMeta.sugarMeta);
+      this.trackAdd(dependentKey, normalizedIndex, observerContexts);
+    },
+
+    itemPropertyWillChange: function (obj, keyName, array, observerContext) {
+      var guid = utils.guidFor(obj);
+
+      if (!this.changedItems[guid]) {
+        this.changedItems[guid] = {
+          array: array,
+          observerContext: observerContext,
+          obj: obj,
+          previousValues: {}
+        };
+      }
 
-      @method reduceComputed
-      @for Ember
-      @param {String} [dependentKeys*]
-      @param {Object} options
-      @return {Ember.ComputedProperty}
-    */
-    function reduceComputed(options) {
-      var args;
+      ++this.changedItemCount;
+      this.changedItems[guid].previousValues[keyName] = get(obj, keyName);
+    },
 
-      if (arguments.length > 1) {
-        args = a_slice.call(arguments, 0, -1);
-        options = a_slice.call(arguments, -1)[0];
+    itemPropertyDidChange: function (obj, keyName, array, observerContext) {
+      if (--this.changedItemCount === 0) {
+        this.flushChanges();
       }
+    },
 
-      if (typeof options !== 'object') {
-        throw new EmberError('Reduce Computed Property declared without an options hash');
-      }
+    flushChanges: function () {
+      var changedItems = this.changedItems;
+      var key, c, changeMeta;
 
-      if (!('initialValue' in options)) {
-        throw new EmberError('Reduce Computed Property declared without an initial value');
-      }
+      for (key in changedItems) {
+        c = changedItems[key];
+        if (c.observerContext.destroyed) { continue; }
 
-      var cp = new ReduceComputedProperty(options);
+        this.updateIndexes(c.observerContext.trackedArray, c.observerContext.dependentArray);
 
-      if (args) {
-        cp.property.apply(cp, args);
+        changeMeta = new ChangeMeta(c.array, c.obj, c.observerContext.index, this.instanceMeta.propertyName, this.cp, changedItems.length, c.previousValues);
+        this.setValue(
+          this.callbacks.removedItem.call(this.instanceMeta.context, this.getValue(), c.obj, changeMeta, this.instanceMeta.sugarMeta));
+        this.setValue(
+          this.callbacks.addedItem.call(this.instanceMeta.context, this.getValue(), c.obj, changeMeta, this.instanceMeta.sugarMeta));
       }
 
-      return cp;
+      this.changedItems = {};
+      this.callbacks.flushedChanges.call(this.instanceMeta.context, this.getValue(), this.instanceMeta.sugarMeta);
     }
+  };
 
-    __exports__.reduceComputed = reduceComputed;
-  });
-enifed("ember-runtime/computed/reduce_computed_macros",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/error","ember-metal/enumerable_utils","ember-metal/run_loop","ember-metal/observer","ember-runtime/computed/array_computed","ember-runtime/computed/reduce_computed","ember-runtime/system/subarray","ember-metal/keys","ember-runtime/compare","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
-
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var get = __dependency2__.get;
-    var isArray = __dependency3__.isArray;
-    var guidFor = __dependency3__.guidFor;
-    var EmberError = __dependency4__["default"];
-    var forEach = __dependency5__.forEach;
-    var run = __dependency6__["default"];
-    var addObserver = __dependency7__.addObserver;
-    var arrayComputed = __dependency8__.arrayComputed;
-    var reduceComputed = __dependency9__.reduceComputed;
-    var SubArray = __dependency10__["default"];
-    var keys = __dependency11__["default"];
-    var compare = __dependency12__["default"];
-
-    var a_slice = [].slice;
-
-    /**
-     A computed property that returns the sum of the value
-     in the dependent array.
-
-     @method computed.sum
-     @for Ember
-     @param {String} dependentKey
-     @return {Ember.ComputedProperty} computes the sum of all values in the dependentKey's array
-     @since 1.4.0
-    */
-
-    function sum(dependentKey){
-      return reduceComputed(dependentKey, {
-        initialValue: 0,
-
-        addedItem: function(accumulatedValue, item, changeMeta, instanceMeta){
-          return accumulatedValue + item;
-        },
-
-        removedItem: function(accumulatedValue, item, changeMeta, instanceMeta){
-          return accumulatedValue - item;
-        }
-      });
+  function normalizeIndex(index, length, newItemsOffset) {
+    if (index < 0) {
+      return Math.max(0, length + index);
+    } else if (index < length) {
+      return index;
+    } else { // index > length
+      return Math.min(length - newItemsOffset, index);
     }
+  }
 
-    __exports__.sum = sum;/**
-      A computed property that calculates the maximum value in the
-      dependent array. This will return `-Infinity` when the dependent
-      array is empty.
+  function normalizeRemoveCount(index, length, removedCount) {
+    return Math.min(removedCount, length - index);
+  }
 
-      ```javascript
-      var Person = Ember.Object.extend({
-        childAges: Ember.computed.mapBy('children', 'age'),
-        maxChildAge: Ember.computed.max('childAges')
-      });
+  function ChangeMeta(dependentArray, item, index, propertyName, property, changedCount, previousValues) {
+    this.arrayChanged = dependentArray;
+    this.index = index;
+    this.item = item;
+    this.propertyName = propertyName;
+    this.property = property;
+    this.changedCount = changedCount;
 
-      var lordByron = Person.create({ children: [] });
+    if (previousValues) {
+      // previous values only available for item property changes
+      this.previousValues = previousValues;
+    }
+  }
 
-      lordByron.get('maxChildAge'); // -Infinity
-      lordByron.get('children').pushObject({
-        name: 'Augusta Ada Byron', age: 7
-      });
-      lordByron.get('maxChildAge'); // 7
-      lordByron.get('children').pushObjects([{
-        name: 'Allegra Byron',
-        age: 5
-      }, {
-        name: 'Elizabeth Medora Leigh',
-        age: 8
-      }]);
-      lordByron.get('maxChildAge'); // 8
-      ```
+  function addItems(dependentArray, callbacks, cp, propertyName, meta) {
+    enumerable_utils.forEach(dependentArray, function (item, index) {
+      meta.setValue(callbacks.addedItem.call(
+        this, meta.getValue(), item, new ChangeMeta(dependentArray, item, index, propertyName, cp, dependentArray.length), meta.sugarMeta));
+    }, this);
+    callbacks.flushedChanges.call(this, meta.getValue(), meta.sugarMeta);
+  }
 
-      @method computed.max
-      @for Ember
-      @param {String} dependentKey
-      @return {Ember.ComputedProperty} computes the largest value in the dependentKey's array
-    */
-    function max(dependentKey) {
-      return reduceComputed(dependentKey, {
-        initialValue: -Infinity,
+  function reset(cp, propertyName) {
+    var hadMeta = cp._hasInstanceMeta(this, propertyName);
+    var meta = cp._instanceMeta(this, propertyName);
 
-        addedItem: function (accumulatedValue, item, changeMeta, instanceMeta) {
-          return Math.max(accumulatedValue, item);
-        },
+    if (hadMeta) { meta.setValue(cp.resetValue(meta.getValue())); }
 
-        removedItem: function (accumulatedValue, item, changeMeta, instanceMeta) {
-          if (item < accumulatedValue) {
-            return accumulatedValue;
-          }
-        }
-      });
+    if (cp.options.initialize) {
+      cp.options.initialize.call(this, meta.getValue(), {
+        property: cp,
+        propertyName: propertyName
+      }, meta.sugarMeta);
     }
+  }
 
-    __exports__.max = max;/**
-      A computed property that calculates the minimum value in the
-      dependent array. This will return `Infinity` when the dependent
-      array is empty.
+  function partiallyRecomputeFor(obj, dependentKey) {
+    if (arrayBracketPattern.test(dependentKey)) {
+      return false;
+    }
 
-      ```javascript
-      var Person = Ember.Object.extend({
-        childAges: Ember.computed.mapBy('children', 'age'),
-        minChildAge: Ember.computed.min('childAges')
-      });
+    var value = get(obj, dependentKey);
+    return EmberArray['default'].detect(value);
+  }
 
-      var lordByron = Person.create({ children: [] });
+  function ReduceComputedPropertyInstanceMeta(context, propertyName, initialValue) {
+    this.context = context;
+    this.propertyName = propertyName;
+    var contextMeta = utils.meta(context);
+    var contextCache = contextMeta.cache;
+    if (!contextCache) { contextCache = contextMeta.cache = {}; }
+    this.cache = contextCache;
+    this.dependentArrays = {};
+    this.sugarMeta = {};
+    this.initialValue = initialValue;
+  }
 
-      lordByron.get('minChildAge'); // Infinity
-      lordByron.get('children').pushObject({
-        name: 'Augusta Ada Byron', age: 7
-      });
-      lordByron.get('minChildAge'); // 7
-      lordByron.get('children').pushObjects([{
-        name: 'Allegra Byron',
-        age: 5
-      }, {
-        name: 'Elizabeth Medora Leigh',
-        age: 8
-      }]);
-      lordByron.get('minChildAge'); // 5
-      ```
+  ReduceComputedPropertyInstanceMeta.prototype = {
+    getValue: function () {
+      var value = cacheGet(this.cache, this.propertyName);
 
-      @method computed.min
-      @for Ember
-      @param {String} dependentKey
-      @return {Ember.ComputedProperty} computes the smallest value in the dependentKey's array
-    */
-    function min(dependentKey) {
-      return reduceComputed(dependentKey, {
-        initialValue: Infinity,
+      if (value !== undefined) {
+        return value;
+      } else {
+        return this.initialValue;
+      }
+    },
 
-        addedItem: function (accumulatedValue, item, changeMeta, instanceMeta) {
-          return Math.min(accumulatedValue, item);
-        },
+    setValue: function(newValue, triggerObservers) {
+      // This lets sugars force a recomputation, handy for very simple
+      // implementations of eg max.
+      if (newValue === cacheGet(this.cache, this.propertyName)) {
+        return;
+      }
 
-        removedItem: function (accumulatedValue, item, changeMeta, instanceMeta) {
-          if (item > accumulatedValue) {
-            return accumulatedValue;
-          }
-        }
-      });
+      if (triggerObservers) {
+        property_events.propertyWillChange(this.context, this.propertyName);
+      }
+
+      if (newValue === undefined) {
+        cacheRemove(this.cache, this.propertyName);
+      } else {
+        cacheSet(this.cache, this.propertyName, newValue);
+      }
+
+      if (triggerObservers) {
+        property_events.propertyDidChange(this.context, this.propertyName);
+      }
     }
+  };
 
-    __exports__.min = min;/**
-      Returns an array mapped via the callback
+  /**
+    A computed property whose dependent keys are arrays and which is updated with
+    "one at a time" semantics.
 
-      The callback method you provide should have the following signature.
-      `item` is the current item in the iteration.
-      `index` is the integer index of the current item in the iteration.
+    @class ReduceComputedProperty
+    @namespace Ember
+    @extends Ember.ComputedProperty
+    @constructor
+  */
 
-      ```javascript
-      function(item, index);
-      ```
+  function ReduceComputedProperty(options) {
+    var cp = this;
 
-      Example
+    this.options = options;
+    this._dependentKeys = null;
+    this._cacheable = true;
+    // A map of dependentKey -> [itemProperty, ...] that tracks what properties of
+    // items in the array we must track to update this property.
+    this._itemPropertyKeys = {};
+    this._previousItemPropertyKeys = {};
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        excitingChores: Ember.computed.map('chores', function(chore, index) {
-          return chore.toUpperCase() + '!';
-        })
-      });
+    this.readOnly();
 
-      var hamster = Hamster.create({
-        chores: ['clean', 'write more unit tests']
-      });
+    this.recomputeOnce = function(propertyName) {
+      // What we really want to do is coalesce by <cp, propertyName>.
+      // We need a form of `scheduleOnce` that accepts an arbitrary token to
+      // coalesce by, in addition to the target and method.
+      run['default'].once(this, recompute, propertyName);
+    };
 
-      hamster.get('excitingChores'); // ['CLEAN!', 'WRITE MORE UNIT TESTS!']
-      ```
+    var recompute = function(propertyName) {
+      var meta = cp._instanceMeta(this, propertyName);
+      var callbacks = cp._callbacks();
 
-      @method computed.map
-      @for Ember
-      @param {String} dependentKey
-      @param {Function} callback
-      @return {Ember.ComputedProperty} an array mapped via the callback
-    */
-    function map(dependentKey, callback) {
-      var options = {
-        addedItem: function(array, item, changeMeta, instanceMeta) {
-          var mapped = callback.call(this, item, changeMeta.index);
-          array.insertAt(changeMeta.index, mapped);
-          return array;
-        },
-        removedItem: function(array, item, changeMeta, instanceMeta) {
-          array.removeAt(changeMeta.index, 1);
-          return array;
-        }
-      };
+      reset.call(this, cp, propertyName);
 
-      return arrayComputed(dependentKey, options);
-    }
+      meta.dependentArraysObserver.suspendArrayObservers(function () {
+        enumerable_utils.forEach(cp._dependentKeys, function (dependentKey) {
+          Ember['default'].assert(
+            'dependent array ' + dependentKey + ' must be an `Ember.Array`.  ' +
+            'If you are not extending arrays, you will need to wrap native arrays with `Ember.A`',
+            !(utils.isArray(get(this, dependentKey)) && !EmberArray['default'].detect(get(this, dependentKey))));
 
-    __exports__.map = map;/**
-      Returns an array mapped to the specified key.
+          if (!partiallyRecomputeFor(this, dependentKey)) { return; }
 
-      ```javascript
-      var Person = Ember.Object.extend({
-        childAges: Ember.computed.mapBy('children', 'age')
-      });
+          var dependentArray = get(this, dependentKey);
+          var previousDependentArray = meta.dependentArrays[dependentKey];
+
+          if (dependentArray === previousDependentArray) {
+            // The array may be the same, but our item property keys may have
+            // changed, so we set them up again.  We can't easily tell if they've
+            // changed: the array may be the same object, but with different
+            // contents.
+            if (cp._previousItemPropertyKeys[dependentKey]) {
+              delete cp._previousItemPropertyKeys[dependentKey];
+              meta.dependentArraysObserver.setupPropertyObservers(dependentKey, cp._itemPropertyKeys[dependentKey]);
+            }
+          } else {
+            meta.dependentArrays[dependentKey] = dependentArray;
 
-      var lordByron = Person.create({ children: [] });
+            if (previousDependentArray) {
+              meta.dependentArraysObserver.teardownObservers(previousDependentArray, dependentKey);
+            }
 
-      lordByron.get('childAges'); // []
-      lordByron.get('children').pushObject({ name: 'Augusta Ada Byron', age: 7 });
-      lordByron.get('childAges'); // [7]
-      lordByron.get('children').pushObjects([{
-        name: 'Allegra Byron',
-        age: 5
-      }, {
-        name: 'Elizabeth Medora Leigh',
-        age: 8
-      }]);
-      lordByron.get('childAges'); // [7, 5, 8]
-      ```
+            if (dependentArray) {
+              meta.dependentArraysObserver.setupObservers(dependentArray, dependentKey);
+            }
+          }
+        }, this);
+      }, this);
 
-      @method computed.mapBy
-      @for Ember
-      @param {String} dependentKey
-      @param {String} propertyKey
-      @return {Ember.ComputedProperty} an array mapped to the specified key
-    */
-    function mapBy (dependentKey, propertyKey) {
-      var callback = function(item) { return get(item, propertyKey); };
-      return map(dependentKey + '.@each.' + propertyKey, callback);
-    }
+      enumerable_utils.forEach(cp._dependentKeys, function(dependentKey) {
+        if (!partiallyRecomputeFor(this, dependentKey)) { return; }
 
-    __exports__.mapBy = mapBy;/**
-      @method computed.mapProperty
-      @for Ember
-      @deprecated Use `Ember.computed.mapBy` instead
-      @param dependentKey
-      @param propertyKey
-    */
-    var mapProperty = mapBy;
-    __exports__.mapProperty = mapProperty;
-    /**
-      Filters the array by the callback.
+        var dependentArray = get(this, dependentKey);
 
-      The callback method you provide should have the following signature.
-      `item` is the current item in the iteration.
-      `index` is the integer index of the current item in the iteration.
-      `array` is the dependant array itself.
+        if (dependentArray) {
+          addItems.call(this, dependentArray, callbacks, cp, propertyName, meta);
+        }
+      }, this);
+    };
 
-      ```javascript
-      function(item, index, array);
-      ```
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        remainingChores: Ember.computed.filter('chores', function(chore, index, array) {
-          return !chore.done;
-        })
-      });
+    this._getter = function (propertyName) {
+      Ember['default'].assert('Computed reduce values require at least one dependent key', cp._dependentKeys);
 
-      var hamster = Hamster.create({
-        chores: [
-          { name: 'cook', done: true },
-          { name: 'clean', done: true },
-          { name: 'write more unit tests', done: false }
-        ]
-      });
+      recompute.call(this, propertyName);
 
-      hamster.get('remainingChores'); // [{name: 'write more unit tests', done: false}]
-      ```
+      return cp._instanceMeta(this, propertyName).getValue();
+    };
+  }
 
-      @method computed.filter
-      @for Ember
-      @param {String} dependentKey
-      @param {Function} callback
-      @return {Ember.ComputedProperty} the filtered array
-    */
-    function filter(dependentKey, callback) {
-      var options = {
-        initialize: function (array, changeMeta, instanceMeta) {
-          instanceMeta.filteredArrayIndexes = new SubArray();
-        },
+  ReduceComputedProperty.prototype = o_create['default'](computed.ComputedProperty.prototype);
 
-        addedItem: function (array, item, changeMeta, instanceMeta) {
-          var match = !!callback.call(this, item, changeMeta.index, changeMeta.arrayChanged);
-          var filterIndex = instanceMeta.filteredArrayIndexes.addItem(changeMeta.index, match);
+  function defaultCallback(computedValue) {
+    return computedValue;
+  }
 
-          if (match) {
-            array.insertAt(filterIndex, item);
-          }
+  ReduceComputedProperty.prototype._callbacks = function () {
+    if (!this.callbacks) {
+      var options = this.options;
 
-          return array;
-        },
+      this.callbacks = {
+        removedItem: options.removedItem || defaultCallback,
+        addedItem: options.addedItem || defaultCallback,
+        flushedChanges: options.flushedChanges || defaultCallback
+      };
+    }
 
-        removedItem: function(array, item, changeMeta, instanceMeta) {
-          var filterIndex = instanceMeta.filteredArrayIndexes.removeItem(changeMeta.index);
+    return this.callbacks;
+  };
 
-          if (filterIndex > -1) {
-            array.removeAt(filterIndex);
-          }
+  ReduceComputedProperty.prototype._hasInstanceMeta = function (context, propertyName) {
+    var contextMeta = context.__ember_meta__;
+    var cacheMeta = contextMeta && contextMeta.cacheMeta;
+    return !!(cacheMeta && cacheMeta[propertyName]);
+  };
 
-          return array;
-        }
-      };
+  ReduceComputedProperty.prototype._instanceMeta = function (context, propertyName) {
+    var contextMeta = context.__ember_meta__;
+    var cacheMeta = contextMeta.cacheMeta;
+    var meta = cacheMeta && cacheMeta[propertyName];
 
-      return arrayComputed(dependentKey, options);
+    if (!cacheMeta) {
+      cacheMeta = contextMeta.cacheMeta = {};
+    }
+    if (!meta) {
+      meta = cacheMeta[propertyName] = new ReduceComputedPropertyInstanceMeta(context, propertyName, this.initialValue());
+      meta.dependentArraysObserver = new DependentArraysObserver(this._callbacks(), this, meta, context, propertyName, meta.sugarMeta);
     }
 
-    __exports__.filter = filter;/**
-      Filters the array by the property and value
+    return meta;
+  };
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        remainingChores: Ember.computed.filterBy('chores', 'done', false)
-      });
+  ReduceComputedProperty.prototype.initialValue = function () {
+    if (typeof this.options.initialValue === 'function') {
+      return this.options.initialValue();
+    } else {
+      return this.options.initialValue;
+    }
+  };
 
-      var hamster = Hamster.create({
-        chores: [
-          { name: 'cook', done: true },
-          { name: 'clean', done: true },
-          { name: 'write more unit tests', done: false }
-        ]
-      });
+  ReduceComputedProperty.prototype.resetValue = function (value) {
+    return this.initialValue();
+  };
 
-      hamster.get('remainingChores'); // [{ name: 'write more unit tests', done: false }]
-      ```
+  ReduceComputedProperty.prototype.itemPropertyKey = function (dependentArrayKey, itemPropertyKey) {
+    this._itemPropertyKeys[dependentArrayKey] = this._itemPropertyKeys[dependentArrayKey] || [];
+    this._itemPropertyKeys[dependentArrayKey].push(itemPropertyKey);
+  };
 
-      @method computed.filterBy
-      @for Ember
-      @param {String} dependentKey
-      @param {String} propertyKey
-      @param {*} value
-      @return {Ember.ComputedProperty} the filtered array
-    */
-    function filterBy (dependentKey, propertyKey, value) {
-      var callback;
+  ReduceComputedProperty.prototype.clearItemPropertyKeys = function (dependentArrayKey) {
+    if (this._itemPropertyKeys[dependentArrayKey]) {
+      this._previousItemPropertyKeys[dependentArrayKey] = this._itemPropertyKeys[dependentArrayKey];
+      this._itemPropertyKeys[dependentArrayKey] = [];
+    }
+  };
 
-      if (arguments.length === 2) {
-        callback = function(item) {
-          return get(item, propertyKey);
+  ReduceComputedProperty.prototype.property = function () {
+    var cp = this;
+    var args = a_slice.call(arguments);
+    var propertyArgs = {};
+    var match, dependentArrayKey;
+
+    enumerable_utils.forEach(args, function (dependentKey) {
+      if (doubleEachPropertyPattern.test(dependentKey)) {
+        throw new EmberError['default']('Nested @each properties not supported: ' + dependentKey);
+      } else if (match = eachPropertyPattern.exec(dependentKey)) {
+        dependentArrayKey = match[1];
+
+        var itemPropertyKeyPattern = match[2];
+        var addItemPropertyKey = function (itemPropertyKey) {
+          cp.itemPropertyKey(dependentArrayKey, itemPropertyKey);
         };
+
+        expandProperties['default'](itemPropertyKeyPattern, addItemPropertyKey);
+        propertyArgs[utils.guidFor(dependentArrayKey)] = dependentArrayKey;
       } else {
-        callback = function(item) {
-          return get(item, propertyKey) === value;
-        };
+        propertyArgs[utils.guidFor(dependentKey)] = dependentKey;
       }
+    });
 
-      return filter(dependentKey + '.@each.' + propertyKey, callback);
+    var propertyArgsToArray = [];
+    for (var guid in propertyArgs) {
+      propertyArgsToArray.push(propertyArgs[guid]);
     }
 
-    __exports__.filterBy = filterBy;/**
-      @method computed.filterProperty
-      @for Ember
-      @param dependentKey
-      @param propertyKey
-      @param value
-      @deprecated Use `Ember.computed.filterBy` instead
-    */
-    var filterProperty = filterBy;
-    __exports__.filterProperty = filterProperty;
-    /**
-      A computed property which returns a new array with all the unique
-      elements from one or more dependent arrays.
+    return computed.ComputedProperty.prototype.property.apply(this, propertyArgsToArray);
+  };
 
-      Example
+  /**
+    Creates a computed property which operates on dependent arrays and
+    is updated with "one at a time" semantics. When items are added or
+    removed from the dependent array(s) a reduce computed only operates
+    on the change instead of re-evaluating the entire array.
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        uniqueFruits: Ember.computed.uniq('fruits')
-      });
+    If there are more than one arguments the first arguments are
+    considered to be dependent property keys. The last argument is
+    required to be an options object. The options object can have the
+    following four properties:
 
-      var hamster = Hamster.create({
-        fruits: [
-          'banana',
-          'grape',
-          'kale',
-          'banana'
-        ]
-      });
+    `initialValue` - A value or function that will be used as the initial
+    value for the computed. If this property is a function the result of calling
+    the function will be used as the initial value. This property is required.
 
-      hamster.get('uniqueFruits'); // ['banana', 'grape', 'kale']
-      ```
+    `initialize` - An optional initialize function. Typically this will be used
+    to set up state on the instanceMeta object.
 
-      @method computed.uniq
-      @for Ember
-      @param {String} propertyKey*
-      @return {Ember.ComputedProperty} computes a new array with all the
-      unique elements from the dependent array
-    */
-    function uniq() {
-      var args = a_slice.call(arguments);
+    `removedItem` - A function that is called each time an element is removed
+    from the array.
 
-      args.push({
-        initialize: function(array, changeMeta, instanceMeta) {
-          instanceMeta.itemCounts = {};
-        },
+    `addedItem` - A function that is called each time an element is added to
+    the array.
 
-        addedItem: function(array, item, changeMeta, instanceMeta) {
-          var guid = guidFor(item);
 
-          if (!instanceMeta.itemCounts[guid]) {
-            instanceMeta.itemCounts[guid] = 1;
-            array.pushObject(item);
-          } else {
-            ++instanceMeta.itemCounts[guid];
-          }
-          return array;
-        },
+    The `initialize` function has the following signature:
 
-        removedItem: function(array, item, _, instanceMeta) {
-          var guid = guidFor(item);
-          var itemCounts = instanceMeta.itemCounts;
+    ```javascript
+    function(initialValue, changeMeta, instanceMeta)
+    ```
 
-          if (--itemCounts[guid] === 0) {
-            array.removeObject(item);
-          }
+    `initialValue` - The value of the `initialValue` property from the
+    options object.
 
-          return array;
-        }
-      });
+    `changeMeta` - An object which contains meta information about the
+    computed. It contains the following properties:
 
-      return arrayComputed.apply(null, args);
-    }
+       - `property` the computed property
+       - `propertyName` the name of the property on the object
 
-    __exports__.uniq = uniq;/**
-      Alias for [Ember.computed.uniq](/api/#method_computed_uniq).
+    `instanceMeta` - An object that can be used to store meta
+    information needed for calculating your computed. For example a
+    unique computed might use this to store the number of times a given
+    element is found in the dependent array.
 
-      @method computed.union
-      @for Ember
-      @param {String} propertyKey*
-      @return {Ember.ComputedProperty} computes a new array with all the
-      unique elements from the dependent array
-    */
-    var union = uniq;
-    __exports__.union = union;
-    /**
-      A computed property which returns a new array with all the duplicated
-      elements from two or more dependent arrays.
 
-      Example
+    The `removedItem` and `addedItem` functions both have the following signature:
 
-      ```javascript
-      var obj = Ember.Object.createWithMixins({
-        adaFriends: ['Charles Babbage', 'John Hobhouse', 'William King', 'Mary Somerville'],
-        charlesFriends: ['William King', 'Mary Somerville', 'Ada Lovelace', 'George Peacock'],
-        friendsInCommon: Ember.computed.intersect('adaFriends', 'charlesFriends')
-      });
+    ```javascript
+    function(accumulatedValue, item, changeMeta, instanceMeta)
+    ```
 
-      obj.get('friendsInCommon'); // ['William King', 'Mary Somerville']
-      ```
+    `accumulatedValue` - The value returned from the last time
+    `removedItem` or `addedItem` was called or `initialValue`.
 
-      @method computed.intersect
-      @for Ember
-      @param {String} propertyKey*
-      @return {Ember.ComputedProperty} computes a new array with all the
-      duplicated elements from the dependent arrays
-    */
-    function intersect() {
-      var args = a_slice.call(arguments);
+    `item` - the element added or removed from the array
 
-      args.push({
-        initialize: function (array, changeMeta, instanceMeta) {
-          instanceMeta.itemCounts = {};
-        },
+    `changeMeta` - An object which contains meta information about the
+    change. It contains the following properties:
 
-        addedItem: function(array, item, changeMeta, instanceMeta) {
-          var itemGuid = guidFor(item);
-          var dependentGuid = guidFor(changeMeta.arrayChanged);
-          var numberOfDependentArrays = changeMeta.property._dependentKeys.length;
-          var itemCounts = instanceMeta.itemCounts;
+      - `property` the computed property
+      - `propertyName` the name of the property on the object
+      - `index` the index of the added or removed item
+      - `item` the added or removed item: this is exactly the same as
+        the second arg
+      - `arrayChanged` the array that triggered the change. Can be
+        useful when depending on multiple arrays.
 
-          if (!itemCounts[itemGuid]) {
-            itemCounts[itemGuid] = {};
-          }
+    For property changes triggered on an item property change (when
+    depKey is something like `someArray.@each.someProperty`),
+    `changeMeta` will also contain the following property:
 
-          if (itemCounts[itemGuid][dependentGuid] === undefined) {
-            itemCounts[itemGuid][dependentGuid] = 0;
-          }
+      - `previousValues` an object whose keys are the properties that changed on
+      the item, and whose values are the item's previous values.
 
-          if (++itemCounts[itemGuid][dependentGuid] === 1 &&
-              numberOfDependentArrays === keys(itemCounts[itemGuid]).length) {
-            array.addObject(item);
-          }
+    `previousValues` is important Ember coalesces item property changes via
+    Ember.run.once. This means that by the time removedItem gets called, item has
+    the new values, but you may need the previous value (eg for sorting &
+    filtering).
 
-          return array;
-        },
+    `instanceMeta` - An object that can be used to store meta
+    information needed for calculating your computed. For example a
+    unique computed might use this to store the number of times a given
+    element is found in the dependent array.
 
-        removedItem: function(array, item, changeMeta, instanceMeta) {
-          var itemGuid = guidFor(item);
-          var dependentGuid = guidFor(changeMeta.arrayChanged);
-          var numberOfArraysItemAppearsIn;
-          var itemCounts = instanceMeta.itemCounts;
+    The `removedItem` and `addedItem` functions should return the accumulated
+    value. It is acceptable to not return anything (ie return undefined)
+    to invalidate the computation. This is generally not a good idea for
+    arrayComputed but it's used in eg max and min.
 
-          if (itemCounts[itemGuid][dependentGuid] === undefined) {
-            itemCounts[itemGuid][dependentGuid] = 0;
-          }
+    Note that observers will be fired if either of these functions return a value
+    that differs from the accumulated value.  When returning an object that
+    mutates in response to array changes, for example an array that maps
+    everything from some other array (see `Ember.computed.map`), it is usually
+    important that the *same* array be returned to avoid accidentally triggering observers.
 
-          if (--itemCounts[itemGuid][dependentGuid] === 0) {
-            delete itemCounts[itemGuid][dependentGuid];
-            numberOfArraysItemAppearsIn = keys(itemCounts[itemGuid]).length;
+    Example
 
-            if (numberOfArraysItemAppearsIn === 0) {
-              delete itemCounts[itemGuid];
-            }
+    ```javascript
+    Ember.computed.max = function(dependentKey) {
+      return Ember.reduceComputed(dependentKey, {
+        initialValue: -Infinity,
 
-            array.removeObject(item);
-          }
+        addedItem: function(accumulatedValue, item, changeMeta, instanceMeta) {
+          return Math.max(accumulatedValue, item);
+        },
 
-          return array;
+        removedItem: function(accumulatedValue, item, changeMeta, instanceMeta) {
+          if (item < accumulatedValue) {
+            return accumulatedValue;
+          }
         }
       });
+    };
+    ```
 
-      return arrayComputed.apply(null, args);
-    }
+    Dependent keys may refer to `@this` to observe changes to the object itself,
+    which must be array-like, rather than a property of the object.  This is
+    mostly useful for array proxies, to ensure objects are retrieved via
+    `objectAtContent`.  This is how you could sort items by properties defined on an item controller.
 
-    __exports__.intersect = intersect;/**
-      A computed property which returns a new array with all the
-      properties from the first dependent array that are not in the second
-      dependent array.
+    Example
 
-      Example
+    ```javascript
+    App.PeopleController = Ember.ArrayController.extend({
+      itemController: 'person',
+
+      sortedPeople: Ember.computed.sort('@this.@each.reversedName', function(personA, personB) {
+        // `reversedName` isn't defined on Person, but we have access to it via
+        // the item controller App.PersonController.  If we'd used
+        // `content.@each.reversedName` above, we would be getting the objects
+        // directly and not have access to `reversedName`.
+        //
+        var reversedNameA = get(personA, 'reversedName');
+        var reversedNameB = get(personB, 'reversedName');
 
-      ```javascript
-      var Hamster = Ember.Object.extend({
-        likes: ['banana', 'grape', 'kale'],
-        wants: Ember.computed.setDiff('likes', 'fruits')
-      });
+        return Ember.compare(reversedNameA, reversedNameB);
+      })
+    });
 
-      var hamster = Hamster.create({
-        fruits: [
-          'grape',
-          'kale',
-        ]
-      });
+    App.PersonController = Ember.ObjectController.extend({
+      reversedName: function() {
+        return reverse(get(this, 'name'));
+      }.property('name')
+    });
+    ```
 
-      hamster.get('wants'); // ['banana']
-      ```
+    Dependent keys whose values are not arrays are treated as regular
+    dependencies: when they change, the computed property is completely
+    recalculated.  It is sometimes useful to have dependent arrays with similar
+    semantics.  Dependent keys which end in `.[]` do not use "one at a time"
+    semantics.  When an item is added or removed from such a dependency, the
+    computed property is completely recomputed.
 
-      @method computed.setDiff
-      @for Ember
-      @param {String} setAProperty
-      @param {String} setBProperty
-      @return {Ember.ComputedProperty} computes a new array with all the
-      items from the first dependent array that are not in the second
-      dependent array
-    */
-    function setDiff(setAProperty, setBProperty) {
-      if (arguments.length !== 2) {
-        throw new EmberError('setDiff requires exactly two dependent arrays.');
-      }
+    When the computed property is completely recomputed, the `accumulatedValue`
+    is discarded, it starts with `initialValue` again, and each item is passed
+    to `addedItem` in turn.
 
-      return arrayComputed(setAProperty, setBProperty, {
-        addedItem: function (array, item, changeMeta, instanceMeta) {
-          var setA = get(this, setAProperty);
-          var setB = get(this, setBProperty);
+    Example
 
-          if (changeMeta.arrayChanged === setA) {
-            if (!setB.contains(item)) {
-              array.addObject(item);
-            }
-          } else {
-            array.removeObject(item);
-          }
+    ```javascript
+    Ember.Object.extend({
+      // When `string` is changed, `computed` is completely recomputed.
+      string: 'a string',
 
-          return array;
-        },
+      // When an item is added to `array`, `addedItem` is called.
+      array: [],
 
-        removedItem: function (array, item, changeMeta, instanceMeta) {
-          var setA = get(this, setAProperty);
-          var setB = get(this, setBProperty);
+      // When an item is added to `anotherArray`, `computed` is completely
+      // recomputed.
+      anotherArray: [],
 
-          if (changeMeta.arrayChanged === setB) {
-            if (setA.contains(item)) {
-              array.addObject(item);
-            }
-          } else {
-            array.removeObject(item);
-          }
+      computed: Ember.reduceComputed('string', 'array', 'anotherArray.[]', {
+        addedItem: addedItemCallback,
+        removedItem: removedItemCallback
+      })
+    });
+    ```
 
-          return array;
-        }
-      });
+    @method reduceComputed
+    @for Ember
+    @param {String} [dependentKeys*]
+    @param {Object} options
+    @return {Ember.ComputedProperty}
+  */
+  function reduceComputed(options) {
+    var args;
+
+    if (arguments.length > 1) {
+      args = a_slice.call(arguments, 0, -1);
+      options = a_slice.call(arguments, -1)[0];
     }
 
-    __exports__.setDiff = setDiff;function binarySearch(array, item, low, high) {
-      var mid, midItem, res, guidMid, guidItem;
+    if (typeof options !== 'object') {
+      throw new EmberError['default']('Reduce Computed Property declared without an options hash');
+    }
 
-      if (arguments.length < 4) {
-        high = get(array, 'length');
-      }
+    if (!('initialValue' in options)) {
+      throw new EmberError['default']('Reduce Computed Property declared without an initial value');
+    }
 
-      if (arguments.length < 3) {
-        low = 0;
-      }
+    var cp = new ReduceComputedProperty(options);
 
-      if (low === high) {
-        return low;
-      }
+    if (args) {
+      cp.property.apply(cp, args);
+    }
 
-      mid = low + Math.floor((high - low) / 2);
-      midItem = array.objectAt(mid);
+    return cp;
+  }
 
-      guidMid = guidFor(midItem);
-      guidItem = guidFor(item);
+});
+enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/utils', 'ember-metal/error', 'ember-metal/enumerable_utils', 'ember-metal/run_loop', 'ember-metal/observer', 'ember-runtime/computed/array_computed', 'ember-runtime/computed/reduce_computed', 'ember-runtime/system/subarray', 'ember-metal/keys', 'ember-runtime/compare'], function (exports, Ember, property_get, utils, EmberError, enumerable_utils, run, observer, array_computed, reduce_computed, SubArray, keys, compare) {
 
-      if (guidMid === guidItem) {
-        return mid;
-      }
+  'use strict';
 
-      res = this.order(midItem, item);
+  exports.sum = sum;
+  exports.max = max;
+  exports.min = min;
+  exports.map = map;
+  exports.mapBy = mapBy;
+  exports.filter = filter;
+  exports.filterBy = filterBy;
+  exports.uniq = uniq;
+  exports.intersect = intersect;
+  exports.setDiff = setDiff;
+  exports.sort = sort;
 
-      if (res === 0) {
-        res = guidMid < guidItem ? -1 : 1;
-      }
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
+  var a_slice = [].slice;
 
-      if (res < 0) {
-        return this.binarySearch(array, item, mid+1, high);
-      } else if (res > 0) {
-        return this.binarySearch(array, item, low, mid);
-      }
+  /**
+   A computed property that returns the sum of the value
+   in the dependent array.
 
-      return mid;
-    }
+   @method sum
+   @for Ember.computed
+   @param {String} dependentKey
+   @return {Ember.ComputedProperty} computes the sum of all values in the dependentKey's array
+   @since 1.4.0
+  */
 
+  function sum(dependentKey) {
+    return reduce_computed.reduceComputed(dependentKey, {
+      initialValue: 0,
 
-    /**
-      A computed property which returns a new array with all the
-      properties from the first dependent array sorted based on a property
-      or sort function.
+      addedItem: function(accumulatedValue, item, changeMeta, instanceMeta) {
+        return accumulatedValue + item;
+      },
 
-      The callback method you provide should have the following signature:
+      removedItem: function(accumulatedValue, item, changeMeta, instanceMeta) {
+        return accumulatedValue - item;
+      }
+    });
+  }
 
-      ```javascript
-      function(itemA, itemB);
-      ```
+  /**
+    A computed property that calculates the maximum value in the
+    dependent array. This will return `-Infinity` when the dependent
+    array is empty.
 
-      - `itemA` the first item to compare.
-      - `itemB` the second item to compare.
+    ```javascript
+    var Person = Ember.Object.extend({
+      childAges: Ember.computed.mapBy('children', 'age'),
+      maxChildAge: Ember.computed.max('childAges')
+    });
 
-      This function should return negative number (e.g. `-1`) when `itemA` should come before
-      `itemB`. It should return positive number (e.g. `1`) when `itemA` should come after
-      `itemB`. If the `itemA` and `itemB` are equal this function should return `0`.
+    var lordByron = Person.create({ children: [] });
 
-      Therefore, if this function is comparing some numeric values, simple `itemA - itemB` or
-      `itemA.get( 'foo' ) - itemB.get( 'foo' )` can be used instead of series of `if`.
+    lordByron.get('maxChildAge'); // -Infinity
+    lordByron.get('children').pushObject({
+      name: 'Augusta Ada Byron', age: 7
+    });
+    lordByron.get('maxChildAge'); // 7
+    lordByron.get('children').pushObjects([{
+      name: 'Allegra Byron',
+      age: 5
+    }, {
+      name: 'Elizabeth Medora Leigh',
+      age: 8
+    }]);
+    lordByron.get('maxChildAge'); // 8
+    ```
 
-      Example
+    @method max
+    @for Ember.computed
+    @param {String} dependentKey
+    @return {Ember.ComputedProperty} computes the largest value in the dependentKey's array
+  */
+  function max(dependentKey) {
+    return reduce_computed.reduceComputed(dependentKey, {
+      initialValue: -Infinity,
 
-      ```javascript
-      var ToDoList = Ember.Object.extend({
-        // using standard ascending sort
-        todosSorting: ['name'],
-        sortedTodos: Ember.computed.sort('todos', 'todosSorting'),
-
-        // using descending sort
-        todosSortingDesc: ['name:desc'],
-        sortedTodosDesc: Ember.computed.sort('todos', 'todosSortingDesc'),
-
-        // using a custom sort function
-        priorityTodos: Ember.computed.sort('todos', function(a, b){
-          if (a.priority > b.priority) {
-            return 1;
-          } else if (a.priority < b.priority) {
-            return -1;
-          }
+      addedItem: function (accumulatedValue, item, changeMeta, instanceMeta) {
+        return Math.max(accumulatedValue, item);
+      },
 
-          return 0;
-        })
-      });
+      removedItem: function (accumulatedValue, item, changeMeta, instanceMeta) {
+        if (item < accumulatedValue) {
+          return accumulatedValue;
+        }
+      }
+    });
+  }
 
-      var todoList = ToDoList.create({todos: [
-        { name: 'Unit Test', priority: 2 },
-        { name: 'Documentation', priority: 3 },
-        { name: 'Release', priority: 1 }
-      ]});
+  /**
+    A computed property that calculates the minimum value in the
+    dependent array. This will return `Infinity` when the dependent
+    array is empty.
 
-      todoList.get('sortedTodos');      // [{ name:'Documentation', priority:3 }, { name:'Release', priority:1 }, { name:'Unit Test', priority:2 }]
-      todoList.get('sortedTodosDesc');  // [{ name:'Unit Test', priority:2 }, { name:'Release', priority:1 }, { name:'Documentation', priority:3 }]
-      todoList.get('priorityTodos');    // [{ name:'Release', priority:1 }, { name:'Unit Test', priority:2 }, { name:'Documentation', priority:3 }]
-      ```
+    ```javascript
+    var Person = Ember.Object.extend({
+      childAges: Ember.computed.mapBy('children', 'age'),
+      minChildAge: Ember.computed.min('childAges')
+    });
 
-      @method computed.sort
-      @for Ember
-      @param {String} dependentKey
-      @param {String or Function} sortDefinition a dependent key to an
-      array of sort properties (add `:desc` to the arrays sort properties to sort descending) or a function to use when sorting
-      @return {Ember.ComputedProperty} computes a new sorted array based
-      on the sort property array or callback function
-    */
-    function sort(itemsKey, sortDefinition) {
-      Ember.assert('Ember.computed.sort requires two arguments: an array key to sort and ' +
-        'either a sort properties key or sort function', arguments.length === 2);
+    var lordByron = Person.create({ children: [] });
 
-      if (typeof sortDefinition === 'function') {
-        return customSort(itemsKey, sortDefinition);
-      } else {
-        return propertySort(itemsKey, sortDefinition);
+    lordByron.get('minChildAge'); // Infinity
+    lordByron.get('children').pushObject({
+      name: 'Augusta Ada Byron', age: 7
+    });
+    lordByron.get('minChildAge'); // 7
+    lordByron.get('children').pushObjects([{
+      name: 'Allegra Byron',
+      age: 5
+    }, {
+      name: 'Elizabeth Medora Leigh',
+      age: 8
+    }]);
+    lordByron.get('minChildAge'); // 5
+    ```
+
+    @method min
+    @for Ember.computed
+    @param {String} dependentKey
+    @return {Ember.ComputedProperty} computes the smallest value in the dependentKey's array
+  */
+  function min(dependentKey) {
+    return reduce_computed.reduceComputed(dependentKey, {
+      initialValue: Infinity,
+
+      addedItem: function (accumulatedValue, item, changeMeta, instanceMeta) {
+        return Math.min(accumulatedValue, item);
+      },
+
+      removedItem: function (accumulatedValue, item, changeMeta, instanceMeta) {
+        if (item > accumulatedValue) {
+          return accumulatedValue;
+        }
       }
-    }
+    });
+  }
 
-    __exports__.sort = sort;function customSort(itemsKey, comparator) {
-      return arrayComputed(itemsKey, {
-        initialize: function (array, changeMeta, instanceMeta) {
-          instanceMeta.order = comparator;
-          instanceMeta.binarySearch = binarySearch;
-          instanceMeta.waitingInsertions = [];
-          instanceMeta.insertWaiting = function() {
-            var index, item;
-            var waiting = instanceMeta.waitingInsertions;
-            instanceMeta.waitingInsertions = [];
-            for (var i=0; i<waiting.length; i++) {
-              item = waiting[i];
-              index = instanceMeta.binarySearch(array, item);
-              array.insertAt(index, item);
-            }
-          };
-          instanceMeta.insertLater = function(item) {
-            this.waitingInsertions.push(item);
-          };
-        },
+  /**
+    Returns an array mapped via the callback
 
-        addedItem: function (array, item, changeMeta, instanceMeta) {
-          instanceMeta.insertLater(item);
-          return array;
-        },
+    The callback method you provide should have the following signature.
+    `item` is the current item in the iteration.
+    `index` is the integer index of the current item in the iteration.
 
-        removedItem: function (array, item, changeMeta, instanceMeta) {
-          array.removeObject(item);
-          return array;
-        },
+    ```javascript
+    function(item, index);
+    ```
+
+    Example
 
-        flushedChanges: function(array, instanceMeta) {
-          instanceMeta.insertWaiting();
-        }
-      });
-    }
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      excitingChores: Ember.computed.map('chores', function(chore, index) {
+        return chore.toUpperCase() + '!';
+      })
+    });
 
-    function propertySort(itemsKey, sortPropertiesKey) {
-      return arrayComputed(itemsKey, {
-        initialize: function (array, changeMeta, instanceMeta) {
-          function setupSortProperties() {
-            var sortPropertyDefinitions = get(this, sortPropertiesKey);
-            var sortProperties = instanceMeta.sortProperties = [];
-            var sortPropertyAscending = instanceMeta.sortPropertyAscending = {};
-            var sortProperty, idx, asc;
+    var hamster = Hamster.create({
+      chores: ['clean', 'write more unit tests']
+    });
 
-            Ember.assert('Cannot sort: \'' + sortPropertiesKey + '\' is not an array.',
-                         isArray(sortPropertyDefinitions));
+    hamster.get('excitingChores'); // ['CLEAN!', 'WRITE MORE UNIT TESTS!']
+    ```
 
-            changeMeta.property.clearItemPropertyKeys(itemsKey);
+    @method map
+    @for Ember.computed
+    @param {String} dependentKey
+    @param {Function} callback
+    @return {Ember.ComputedProperty} an array mapped via the callback
+  */
+  function map(dependentKey, callback) {
+    var options = {
+      addedItem: function(array, item, changeMeta, instanceMeta) {
+        var mapped = callback.call(this, item, changeMeta.index);
+        array.insertAt(changeMeta.index, mapped);
+        return array;
+      },
+      removedItem: function(array, item, changeMeta, instanceMeta) {
+        array.removeAt(changeMeta.index, 1);
+        return array;
+      }
+    };
 
-            forEach(sortPropertyDefinitions, function (sortPropertyDefinition) {
-              if ((idx = sortPropertyDefinition.indexOf(':')) !== -1) {
-                sortProperty = sortPropertyDefinition.substring(0, idx);
-                asc = sortPropertyDefinition.substring(idx+1).toLowerCase() !== 'desc';
-              } else {
-                sortProperty = sortPropertyDefinition;
-                asc = true;
-              }
+    return array_computed.arrayComputed(dependentKey, options);
+  }
 
-              sortProperties.push(sortProperty);
-              sortPropertyAscending[sortProperty] = asc;
-              changeMeta.property.itemPropertyKey(itemsKey, sortProperty);
-            });
+  /**
+    Returns an array mapped to the specified key.
 
-            sortPropertyDefinitions.addObserver('@each', this, updateSortPropertiesOnce);
-          }
+    ```javascript
+    var Person = Ember.Object.extend({
+      childAges: Ember.computed.mapBy('children', 'age')
+    });
 
-          function updateSortPropertiesOnce() {
-            run.once(this, updateSortProperties, changeMeta.propertyName);
-          }
+    var lordByron = Person.create({ children: [] });
+
+    lordByron.get('childAges'); // []
+    lordByron.get('children').pushObject({ name: 'Augusta Ada Byron', age: 7 });
+    lordByron.get('childAges'); // [7]
+    lordByron.get('children').pushObjects([{
+      name: 'Allegra Byron',
+      age: 5
+    }, {
+      name: 'Elizabeth Medora Leigh',
+      age: 8
+    }]);
+    lordByron.get('childAges'); // [7, 5, 8]
+    ```
 
-          function updateSortProperties(propertyName) {
-            setupSortProperties.call(this);
-            changeMeta.property.recomputeOnce.call(this, propertyName);
-          }
+    @method mapBy
+    @for Ember.computed
+    @param {String} dependentKey
+    @param {String} propertyKey
+    @return {Ember.ComputedProperty} an array mapped to the specified key
+  */
+  function mapBy(dependentKey, propertyKey) {
+    var callback = function(item) { return property_get.get(item, propertyKey); };
+    return map(dependentKey + '.@each.' + propertyKey, callback);
+  }
 
-          addObserver(this, sortPropertiesKey, updateSortPropertiesOnce);
-          setupSortProperties.call(this);
+  /**
+    @method mapProperty
+    @for Ember.computed
+    @deprecated Use `Ember.computed.mapBy` instead
+    @param dependentKey
+    @param propertyKey
+  */
+  var mapProperty = mapBy;
 
-          instanceMeta.order = function (itemA, itemB) {
-            var sortProperty, result, asc;
-            var keyA = this.keyFor(itemA);
-            var keyB = this.keyFor(itemB);
+  /**
+    Filters the array by the callback.
 
-            for (var i = 0; i < this.sortProperties.length; ++i) {
-              sortProperty = this.sortProperties[i];
+    The callback method you provide should have the following signature.
+    `item` is the current item in the iteration.
+    `index` is the integer index of the current item in the iteration.
+    `array` is the dependant array itself.
 
-              result = compare(keyA[sortProperty], keyB[sortProperty]);
+    ```javascript
+    function(item, index, array);
+    ```
 
-              if (result !== 0) {
-                asc = this.sortPropertyAscending[sortProperty];
-                return asc ? result : (-1 * result);
-              }
-            }
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      remainingChores: Ember.computed.filter('chores', function(chore, index, array) {
+        return !chore.done;
+      })
+    });
 
-            return 0;
-          };
+    var hamster = Hamster.create({
+      chores: [
+        { name: 'cook', done: true },
+        { name: 'clean', done: true },
+        { name: 'write more unit tests', done: false }
+      ]
+    });
 
-          instanceMeta.binarySearch = binarySearch;
-          setupKeyCache(instanceMeta);
-        },
+    hamster.get('remainingChores'); // [{name: 'write more unit tests', done: false}]
+    ```
 
-        addedItem: function (array, item, changeMeta, instanceMeta) {
-          var index = instanceMeta.binarySearch(array, item);
-          array.insertAt(index, item);
-          return array;
-        },
+    @method filter
+    @for Ember.computed
+    @param {String} dependentKey
+    @param {Function} callback
+    @return {Ember.ComputedProperty} the filtered array
+  */
+  function filter(dependentKey, callback) {
+    var options = {
+      initialize: function (array, changeMeta, instanceMeta) {
+        instanceMeta.filteredArrayIndexes = new SubArray['default']();
+      },
 
-        removedItem: function (array, item, changeMeta, instanceMeta) {
-          var index = instanceMeta.binarySearch(array, item);
-          array.removeAt(index);
-          instanceMeta.dropKeyFor(item);
-          return array;
-        }
-      });
-    }
+      addedItem: function (array, item, changeMeta, instanceMeta) {
+        var match = !!callback.call(this, item, changeMeta.index, changeMeta.arrayChanged);
+        var filterIndex = instanceMeta.filteredArrayIndexes.addItem(changeMeta.index, match);
 
-    function setupKeyCache(instanceMeta) {
-      instanceMeta.keyFor = function(item) {
-        var guid = guidFor(item);
-        if (this.keyCache[guid]) {
-          return this.keyCache[guid];
+        if (match) {
+          array.insertAt(filterIndex, item);
         }
-        var sortProperty;
-        var key = {};
-        for (var i = 0; i < this.sortProperties.length; ++i) {
-          sortProperty = this.sortProperties[i];
-          key[sortProperty] = get(item, sortProperty);
-        }
-        return this.keyCache[guid] = key;
-      };
 
-      instanceMeta.dropKeyFor = function(item) {
-        var guid = guidFor(item);
-        this.keyCache[guid] = null;
-      };
+        return array;
+      },
 
-      instanceMeta.keyCache = {};
-    }
-  });
-enifed("ember-runtime/controllers/array_controller",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/enumerable_utils","ember-runtime/system/array_proxy","ember-runtime/mixins/sortable","ember-runtime/mixins/controller","ember-metal/computed","ember-metal/error","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
+      removedItem: function(array, item, changeMeta, instanceMeta) {
+        var filterIndex = instanceMeta.filteredArrayIndexes.removeItem(changeMeta.index);
 
-    var Ember = __dependency1__["default"];
-    var get = __dependency2__.get;
-    var forEach = __dependency3__.forEach;
-    var replace = __dependency3__.replace;
-    var ArrayProxy = __dependency4__["default"];
-    var SortableMixin = __dependency5__["default"];
-    var ControllerMixin = __dependency6__["default"];
-    var computed = __dependency7__.computed;
-    var EmberError = __dependency8__["default"];
+        if (filterIndex > -1) {
+          array.removeAt(filterIndex);
+        }
 
+        return array;
+      }
+    };
 
-    /**
-      `Ember.ArrayController` provides a way for you to publish a collection of
-      objects so that you can easily bind to the collection from a Handlebars
-      `#each` helper, an `Ember.CollectionView`, or other controllers.
+    return array_computed.arrayComputed(dependentKey, options);
+  }
 
-      The advantage of using an `ArrayController` is that you only have to set up
-      your view bindings once; to change what's displayed, simply swap out the
-      `model` property on the controller.
+  /**
+    Filters the array by the property and value
 
-      For example, imagine you wanted to display a list of items fetched via an XHR
-      request. Create an `Ember.ArrayController` and set its `model` property:
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      remainingChores: Ember.computed.filterBy('chores', 'done', false)
+    });
 
-      ```javascript
-      MyApp.listController = Ember.ArrayController.create();
+    var hamster = Hamster.create({
+      chores: [
+        { name: 'cook', done: true },
+        { name: 'clean', done: true },
+        { name: 'write more unit tests', done: false }
+      ]
+    });
 
-      $.get('people.json', function(data) {
-        MyApp.listController.set('model', data);
-      });
-      ```
+    hamster.get('remainingChores'); // [{ name: 'write more unit tests', done: false }]
+    ```
 
-      Then, create a view that binds to your new controller:
+    @method filterBy
+    @for Ember.computed
+    @param {String} dependentKey
+    @param {String} propertyKey
+    @param {*} value
+    @return {Ember.ComputedProperty} the filtered array
+  */
+  function filterBy(dependentKey, propertyKey, value) {
+    var callback;
+
+    if (arguments.length === 2) {
+      callback = function(item) {
+        return property_get.get(item, propertyKey);
+      };
+    } else {
+      callback = function(item) {
+        return property_get.get(item, propertyKey) === value;
+      };
+    }
 
-      ```handlebars
-      {{#each person in MyApp.listController}}
-        {{person.firstName}} {{person.lastName}}
-      {{/each}}
-      ```
+    return filter(dependentKey + '.@each.' + propertyKey, callback);
+  }
 
-      Although you are binding to the controller, the behavior of this controller
-      is to pass through any methods or properties to the underlying array. This
-      capability comes from `Ember.ArrayProxy`, which this class inherits from.
+  /**
+    @method filterProperty
+    @for Ember.computed
+    @param dependentKey
+    @param propertyKey
+    @param value
+    @deprecated Use `Ember.computed.filterBy` instead
+  */
+  var filterProperty = filterBy;
 
-      Sometimes you want to display computed properties within the body of an
-      `#each` helper that depend on the underlying items in `model`, but are not
-      present on those items.   To do this, set `itemController` to the name of a
-      controller (probably an `ObjectController`) that will wrap each individual item.
+  /**
+    A computed property which returns a new array with all the unique
+    elements from one or more dependent arrays.
 
-      For example:
+    Example
 
-      ```handlebars
-      {{#each post in controller}}
-        <li>{{post.title}} ({{post.titleLength}} characters)</li>
-      {{/each}}
-      ```
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      uniqueFruits: Ember.computed.uniq('fruits')
+    });
 
-      ```javascript
-      App.PostsController = Ember.ArrayController.extend({
-        itemController: 'post'
-      });
+    var hamster = Hamster.create({
+      fruits: [
+        'banana',
+        'grape',
+        'kale',
+        'banana'
+      ]
+    });
 
-      App.PostController = Ember.ObjectController.extend({
-        // the `title` property will be proxied to the underlying post.
-        titleLength: function() {
-          return this.get('title').length;
-        }.property('title')
-      });
-      ```
+    hamster.get('uniqueFruits'); // ['banana', 'grape', 'kale']
+    ```
 
-      In some cases it is helpful to return a different `itemController` depending
-      on the particular item.  Subclasses can do this by overriding
-      `lookupItemController`.
+    @method uniq
+    @for Ember.computed
+    @param {String} propertyKey*
+    @return {Ember.ComputedProperty} computes a new array with all the
+    unique elements from the dependent array
+  */
+  function uniq() {
+    var args = a_slice.call(arguments);
 
-      For example:
+    args.push({
+      initialize: function(array, changeMeta, instanceMeta) {
+        instanceMeta.itemCounts = {};
+      },
 
-      ```javascript
-      App.MyArrayController = Ember.ArrayController.extend({
-        lookupItemController: function( object ) {
-          if (object.get('isSpecial')) {
-            return "special"; // use App.SpecialController
-          } else {
-            return "regular"; // use App.RegularController
-          }
+      addedItem: function(array, item, changeMeta, instanceMeta) {
+        var guid = utils.guidFor(item);
+
+        if (!instanceMeta.itemCounts[guid]) {
+          instanceMeta.itemCounts[guid] = 1;
+          array.pushObject(item);
+        } else {
+          ++instanceMeta.itemCounts[guid];
         }
-      });
-      ```
+        return array;
+      },
 
-      The itemController instances will have a `parentController` property set to
-      the `ArrayController` instance.
+      removedItem: function(array, item, _, instanceMeta) {
+        var guid = utils.guidFor(item);
+        var itemCounts = instanceMeta.itemCounts;
 
-      @class ArrayController
-      @namespace Ember
-      @extends Ember.ArrayProxy
-      @uses Ember.SortableMixin
-      @uses Ember.ControllerMixin
-    */
+        if (--itemCounts[guid] === 0) {
+          array.removeObject(item);
+        }
 
-    __exports__["default"] = ArrayProxy.extend(ControllerMixin, SortableMixin, {
+        return array;
+      }
+    });
 
-      /**
-        A string containing the controller name used to wrap items.
+    return array_computed.arrayComputed.apply(null, args);
+  }
 
-        For example:
+  /**
+    Alias for [Ember.computed.uniq](/api/#method_computed_uniq).
 
-        ```javascript
-        App.MyArrayController = Ember.ArrayController.extend({
-          itemController: 'myItem' // use App.MyItemController
-        });
-        ```
+    @method union
+    @for Ember.computed
+    @param {String} propertyKey*
+    @return {Ember.ComputedProperty} computes a new array with all the
+    unique elements from the dependent array
+  */
+  var union = uniq;
 
-        @property itemController
-        @type String
-        @default null
-      */
-      itemController: null,
+  /**
+    A computed property which returns a new array with all the duplicated
+    elements from two or more dependent arrays.
 
-      /**
-        Return the name of the controller to wrap items, or `null` if items should
-        be returned directly.  The default implementation simply returns the
-        `itemController` property, but subclasses can override this method to return
-        different controllers for different objects.
+    Example
 
-        For example:
+    ```javascript
+    var obj = Ember.Object.createWithMixins({
+      adaFriends: ['Charles Babbage', 'John Hobhouse', 'William King', 'Mary Somerville'],
+      charlesFriends: ['William King', 'Mary Somerville', 'Ada Lovelace', 'George Peacock'],
+      friendsInCommon: Ember.computed.intersect('adaFriends', 'charlesFriends')
+    });
 
-        ```javascript
-        App.MyArrayController = Ember.ArrayController.extend({
-          lookupItemController: function( object ) {
-            if (object.get('isSpecial')) {
-              return "special"; // use App.SpecialController
-            } else {
-              return "regular"; // use App.RegularController
-            }
-          }
-        });
-        ```
+    obj.get('friendsInCommon'); // ['William King', 'Mary Somerville']
+    ```
 
-        @method lookupItemController
-        @param {Object} object
-        @return {String}
-      */
-      lookupItemController: function(object) {
-        return get(this, 'itemController');
+    @method intersect
+    @for Ember.computed
+    @param {String} propertyKey*
+    @return {Ember.ComputedProperty} computes a new array with all the
+    duplicated elements from the dependent arrays
+  */
+  function intersect() {
+    var args = a_slice.call(arguments);
+
+    args.push({
+      initialize: function (array, changeMeta, instanceMeta) {
+        instanceMeta.itemCounts = {};
       },
 
-      objectAtContent: function(idx) {
-        var length = get(this, 'length');
-        var arrangedContent = get(this, 'arrangedContent');
-        var object = arrangedContent && arrangedContent.objectAt(idx);
-        var controllerClass;
+      addedItem: function(array, item, changeMeta, instanceMeta) {
+        var itemGuid = utils.guidFor(item);
+        var dependentGuid = utils.guidFor(changeMeta.arrayChanged);
+        var numberOfDependentArrays = changeMeta.property._dependentKeys.length;
+        var itemCounts = instanceMeta.itemCounts;
 
-        if (idx >= 0 && idx < length) {
-          controllerClass = this.lookupItemController(object);
+        if (!itemCounts[itemGuid]) {
+          itemCounts[itemGuid] = {};
+        }
 
-          if (controllerClass) {
-            return this.controllerAt(idx, object, controllerClass);
-          }
+        if (itemCounts[itemGuid][dependentGuid] === undefined) {
+          itemCounts[itemGuid][dependentGuid] = 0;
         }
 
-        // When `controllerClass` is falsy, we have not opted in to using item
-        // controllers, so return the object directly.
+        if (++itemCounts[itemGuid][dependentGuid] === 1 &&
+            numberOfDependentArrays === keys['default'](itemCounts[itemGuid]).length) {
+          array.addObject(item);
+        }
 
-        // When the index is out of range, we want to return the "out of range"
-        // value, whatever that might be.  Rather than make assumptions
-        // (e.g. guessing `null` or `undefined`) we defer this to `arrangedContent`.
-        return object;
+        return array;
       },
 
-      arrangedContentDidChange: function() {
-        this._super();
-        this._resetSubControllers();
-      },
+      removedItem: function(array, item, changeMeta, instanceMeta) {
+        var itemGuid = utils.guidFor(item);
+        var dependentGuid = utils.guidFor(changeMeta.arrayChanged);
+        var numberOfArraysItemAppearsIn;
+        var itemCounts = instanceMeta.itemCounts;
 
-      arrayContentDidChange: function(idx, removedCnt, addedCnt) {
-        var subControllers = this._subControllers;
+        if (itemCounts[itemGuid][dependentGuid] === undefined) {
+          itemCounts[itemGuid][dependentGuid] = 0;
+        }
 
-        if (subControllers.length) {
-          var subControllersToRemove = subControllers.slice(idx, idx + removedCnt);
+        if (--itemCounts[itemGuid][dependentGuid] === 0) {
+          delete itemCounts[itemGuid][dependentGuid];
+          numberOfArraysItemAppearsIn = keys['default'](itemCounts[itemGuid]).length;
 
-          forEach(subControllersToRemove, function(subController) {
-            if (subController) {
-              subController.destroy();
-            }
-          });
+          if (numberOfArraysItemAppearsIn === 0) {
+            delete itemCounts[itemGuid];
+          }
 
-          replace(subControllers, idx, removedCnt, new Array(addedCnt));
+          array.removeObject(item);
         }
 
-        // The shadow array of subcontrollers must be updated before we trigger
-        // observers, otherwise observers will get the wrong subcontainer when
-        // calling `objectAt`
-        this._super(idx, removedCnt, addedCnt);
-      },
+        return array;
+      }
+    });
 
-      init: function() {
-        this._super();
-        this._subControllers = [];
-      },
+    return array_computed.arrayComputed.apply(null, args);
+  }
 
-      model: computed(function () {
-        return Ember.A();
-      }),
+  /**
+    A computed property which returns a new array with all the
+    properties from the first dependent array that are not in the second
+    dependent array.
 
-      /**
-       * Flag to mark as being "virtual". Used to keep this instance
-       * from participating in the parentController hierarchy.
-       *
-       * @private
-       * @property _isVirtual
-       * @type Boolean
-       */
-      _isVirtual: false,
+    Example
 
-      controllerAt: function(idx, object, controllerClass) {
-        var container = get(this, 'container');
-        var subControllers = this._subControllers;
-        var fullName, subController, subControllerFactory, parentController, options;
+    ```javascript
+    var Hamster = Ember.Object.extend({
+      likes: ['banana', 'grape', 'kale'],
+      wants: Ember.computed.setDiff('likes', 'fruits')
+    });
 
-        if (subControllers.length > idx) {
-          subController = subControllers[idx];
+    var hamster = Hamster.create({
+      fruits: [
+        'grape',
+        'kale',
+      ]
+    });
 
-          if (subController) {
-            return subController;
-          }
-        }
+    hamster.get('wants'); // ['banana']
+    ```
 
-        if (this._isVirtual) {
-          parentController = get(this, 'parentController');
+    @method setDiff
+    @for Ember.computed
+    @param {String} setAProperty
+    @param {String} setBProperty
+    @return {Ember.ComputedProperty} computes a new array with all the
+    items from the first dependent array that are not in the second
+    dependent array
+  */
+  function setDiff(setAProperty, setBProperty) {
+    if (arguments.length !== 2) {
+      throw new EmberError['default']('setDiff requires exactly two dependent arrays.');
+    }
+
+    return array_computed.arrayComputed(setAProperty, setBProperty, {
+      addedItem: function (array, item, changeMeta, instanceMeta) {
+        var setA = property_get.get(this, setAProperty);
+        var setB = property_get.get(this, setBProperty);
+
+        if (changeMeta.arrayChanged === setA) {
+          if (!setB.contains(item)) {
+            array.addObject(item);
+          }
         } else {
-          parentController = this;
+          array.removeObject(item);
         }
 
-        
-          fullName = 'controller:' + controllerClass;
-
-          if (!container.has(fullName)) {
-            throw new EmberError('Could not resolve itemController: "' + controllerClass + '"');
-          }
-
-          subController = container.lookupFactory(fullName).create({
-            target: parentController,
-            parentController: parentController,
-            model: object
-          });
-        
-
-        subControllers[idx] = subController;
-
-        return subController;
+        return array;
       },
 
-      _subControllers: null,
-
-      _resetSubControllers: function() {
-        var controller;
-        var subControllers = this._subControllers;
+      removedItem: function (array, item, changeMeta, instanceMeta) {
+        var setA = property_get.get(this, setAProperty);
+        var setB = property_get.get(this, setBProperty);
 
-        if (subControllers.length) {
-          for (var i = 0, length = subControllers.length; length > i; i++) {
-            controller = subControllers[i];
-
-            if (controller) {
-              controller.destroy();
-            }
+        if (changeMeta.arrayChanged === setB) {
+          if (setA.contains(item)) {
+            array.addObject(item);
           }
-
-          subControllers.length = 0;
+        } else {
+          array.removeObject(item);
         }
-      },
 
-      willDestroy: function() {
-        this._resetSubControllers();
-        this._super();
+        return array;
       }
     });
-  });
-enifed("ember-runtime/controllers/controller",
-  ["ember-metal/core","ember-runtime/system/object","ember-runtime/mixins/controller","ember-runtime/inject","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var EmberObject = __dependency2__["default"];
-    var Mixin = __dependency3__["default"];
-    var createInjectionHelper = __dependency4__.createInjectionHelper;
-
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
+  }
 
-    /**
-      @class Controller
-      @namespace Ember
-      @extends Ember.Object
-      @uses Ember.ControllerMixin
-    */
-    var Controller = EmberObject.extend(Mixin);
+  function binarySearch(array, item, low, high) {
+    var mid, midItem, res, guidMid, guidItem;
 
-    function controllerInjectionHelper(factory) {
-      Ember.assert("Defining an injected controller property on a " +
-                   "non-controller is not allowed.", Controller.detect(factory));
+    if (arguments.length < 4) {
+      high = property_get.get(array, 'length');
     }
 
-    
-      /**
-        Creates a property that lazily looks up another controller in the container.
-        Can only be used when defining another controller.
+    if (arguments.length < 3) {
+      low = 0;
+    }
 
-        Example:
+    if (low === high) {
+      return low;
+    }
 
-        ```javascript
-        App.PostController = Ember.Controller.extend({
-          posts: Ember.inject.controller()
-        });
-        ```
+    mid = low + Math.floor((high - low) / 2);
+    midItem = array.objectAt(mid);
 
-        This example will create a `posts` property on the `post` controller that
-        looks up the `posts` controller in the container, making it easy to
-        reference other controllers. This is functionally equivalent to:
+    guidMid = utils.guidFor(midItem);
+    guidItem = utils.guidFor(item);
 
-        ```javascript
-        App.PostController = Ember.Controller.extend({
-          needs: 'posts',
-          posts: Ember.computed.alias('controllers.posts')
-        });
-        ```
+    if (guidMid === guidItem) {
+      return mid;
+    }
 
-        @method inject.controller
-        @for Ember
-        @param {String} name (optional) name of the controller to inject, defaults
-               to the property's name
-        @return {Ember.InjectedProperty} injection descriptor instance
-        */
-      createInjectionHelper('controller', controllerInjectionHelper);
-    
+    res = this.order(midItem, item);
 
-    __exports__["default"] = Controller;
-  });
-enifed("ember-runtime/controllers/object_controller",
-  ["ember-runtime/mixins/controller","ember-runtime/system/object_proxy","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var ControllerMixin = __dependency1__["default"];
-    var ObjectProxy = __dependency2__["default"];
+    if (res === 0) {
+      res = guidMid < guidItem ? -1 : 1;
+    }
 
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
 
-    /**
-      `Ember.ObjectController` is part of Ember's Controller layer. It is intended
-      to wrap a single object, proxying unhandled attempts to `get` and `set` to the underlying
-      model object, and to forward unhandled action attempts to its `target`.
+    if (res < 0) {
+      return this.binarySearch(array, item, mid+1, high);
+    } else if (res > 0) {
+      return this.binarySearch(array, item, low, mid);
+    }
 
-      `Ember.ObjectController` derives this functionality from its superclass
-      `Ember.ObjectProxy` and the `Ember.ControllerMixin` mixin.
+    return mid;
+  }
 
-      @class ObjectController
-      @namespace Ember
-      @extends Ember.ObjectProxy
-      @uses Ember.ControllerMixin
-    **/
-    __exports__["default"] = ObjectProxy.extend(ControllerMixin);
-  });
-enifed("ember-runtime/copy",
-  ["ember-metal/enumerable_utils","ember-metal/utils","ember-runtime/system/object","ember-runtime/mixins/copyable","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    var indexOf = __dependency1__.indexOf;
-    var typeOf = __dependency2__.typeOf;
-    var EmberObject = __dependency3__["default"];
-    var Copyable = __dependency4__["default"];
 
-    function _copy(obj, deep, seen, copies) {
-      var ret, loc, key;
+  /**
+    A computed property which returns a new array with all the
+    properties from the first dependent array sorted based on a property
+    or sort function.
 
-      // primitive data types are immutable, just return them.
-      if (typeof obj !== 'object' || obj === null) {
-        return obj;
-      }
+    The callback method you provide should have the following signature:
 
-      // avoid cyclical loops
-      if (deep && (loc = indexOf(seen, obj)) >= 0) {
-        return copies[loc];
-      }
+    ```javascript
+    function(itemA, itemB);
+    ```
 
-      Ember.assert('Cannot clone an Ember.Object that does not implement Ember.Copyable',
-        !(obj instanceof EmberObject) || (Copyable && Copyable.detect(obj)));
+    - `itemA` the first item to compare.
+    - `itemB` the second item to compare.
 
-      // IMPORTANT: this specific test will detect a native array only. Any other
-      // object will need to implement Copyable.
-      if (typeOf(obj) === 'array') {
-        ret = obj.slice();
+    This function should return negative number (e.g. `-1`) when `itemA` should come before
+    `itemB`. It should return positive number (e.g. `1`) when `itemA` should come after
+    `itemB`. If the `itemA` and `itemB` are equal this function should return `0`.
 
-        if (deep) {
-          loc = ret.length;
+    Therefore, if this function is comparing some numeric values, simple `itemA - itemB` or
+    `itemA.get( 'foo' ) - itemB.get( 'foo' )` can be used instead of series of `if`.
 
-          while (--loc >= 0) {
-            ret[loc] = _copy(ret[loc], deep, seen, copies);
-          }
-        }
-      } else if (Copyable && Copyable.detect(obj)) {
-        ret = obj.copy(deep, seen, copies);
-      } else if (obj instanceof Date) {
-        ret = new Date(obj.getTime());
-      } else {
-        ret = {};
+    Example
 
-        for (key in obj) {
-          // support Null prototype
-          if (!Object.prototype.hasOwnProperty.call(obj, key)) {
-            continue;
-          }
+    ```javascript
+    var ToDoList = Ember.Object.extend({
+      // using standard ascending sort
+      todosSorting: ['name'],
+      sortedTodos: Ember.computed.sort('todos', 'todosSorting'),
 
-          // Prevents browsers that don't respect non-enumerability from
-          // copying internal Ember properties
-          if (key.substring(0, 2) === '__') {
-            continue;
-          }
+      // using descending sort
+      todosSortingDesc: ['name:desc'],
+      sortedTodosDesc: Ember.computed.sort('todos', 'todosSortingDesc'),
 
-          ret[key] = deep ? _copy(obj[key], deep, seen, copies) : obj[key];
+      // using a custom sort function
+      priorityTodos: Ember.computed.sort('todos', function(a, b){
+        if (a.priority > b.priority) {
+          return 1;
+        } else if (a.priority < b.priority) {
+          return -1;
         }
-      }
-
-      if (deep) {
-        seen.push(obj);
-        copies.push(ret);
-      }
-
-      return ret;
-    }
-
-    /**
-      Creates a clone of the passed object. This function can take just about
-      any type of object and create a clone of it, including primitive values
-      (which are not actually cloned because they are immutable).
 
-      If the passed object implements the `copy()` method, then this function
-      will simply call that method and return the result. Please see
-      `Ember.Copyable` for further details.
+        return 0;
+      })
+    });
 
-      @method copy
-      @for Ember
-      @param {Object} obj The object to clone
-      @param {Boolean} deep If true, a deep copy of the object is made
-      @return {Object} The cloned object
-    */
-    __exports__["default"] = function copy(obj, deep) {
-      // fast paths
-      if ('object' !== typeof obj || obj === null) {
-        return obj; // can't copy primitives
-      }
+    var todoList = ToDoList.create({todos: [
+      { name: 'Unit Test', priority: 2 },
+      { name: 'Documentation', priority: 3 },
+      { name: 'Release', priority: 1 }
+    ]});
 
-      if (Copyable && Copyable.detect(obj)) {
-        return obj.copy(deep);
-      }
+    todoList.get('sortedTodos');      // [{ name:'Documentation', priority:3 }, { name:'Release', priority:1 }, { name:'Unit Test', priority:2 }]
+    todoList.get('sortedTodosDesc');  // [{ name:'Unit Test', priority:2 }, { name:'Release', priority:1 }, { name:'Documentation', priority:3 }]
+    todoList.get('priorityTodos');    // [{ name:'Release', priority:1 }, { name:'Unit Test', priority:2 }, { name:'Documentation', priority:3 }]
+    ```
 
-      return _copy(obj, deep, deep ? [] : null, deep ? [] : null);
+    @method sort
+    @for Ember.computed
+    @param {String} dependentKey
+    @param {String or Function} sortDefinition a dependent key to an
+    array of sort properties (add `:desc` to the arrays sort properties to sort descending) or a function to use when sorting
+    @return {Ember.ComputedProperty} computes a new sorted array based
+    on the sort property array or callback function
+  */
+  function sort(itemsKey, sortDefinition) {
+    Ember['default'].assert('Ember.computed.sort requires two arguments: an array key to sort and ' +
+      'either a sort properties key or sort function', arguments.length === 2);
+
+    if (typeof sortDefinition === 'function') {
+      return customSort(itemsKey, sortDefinition);
+    } else {
+      return propertySort(itemsKey, sortDefinition);
     }
-  });
-enifed("ember-runtime/core",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
+  }
 
-    /**
-      Compares two objects, returning true if they are logically equal. This is
-      a deeper comparison than a simple triple equal. For sets it will compare the
-      internal objects. For any other object that implements `isEqual()` it will
-      respect that method.
+  function customSort(itemsKey, comparator) {
+    return array_computed.arrayComputed(itemsKey, {
+      initialize: function (array, changeMeta, instanceMeta) {
+        instanceMeta.order = comparator;
+        instanceMeta.binarySearch = binarySearch;
+        instanceMeta.waitingInsertions = [];
+        instanceMeta.insertWaiting = function() {
+          var index, item;
+          var waiting = instanceMeta.waitingInsertions;
+          instanceMeta.waitingInsertions = [];
+          for (var i=0; i<waiting.length; i++) {
+            item = waiting[i];
+            index = instanceMeta.binarySearch(array, item);
+            array.insertAt(index, item);
+          }
+        };
+        instanceMeta.insertLater = function(item) {
+          this.waitingInsertions.push(item);
+        };
+      },
 
-      ```javascript
-      Ember.isEqual('hello', 'hello');  // true
-      Ember.isEqual(1, 2);              // false
-      Ember.isEqual([4, 2], [4, 2]);    // false
-      ```
+      addedItem: function (array, item, changeMeta, instanceMeta) {
+        instanceMeta.insertLater(item);
+        return array;
+      },
+
+      removedItem: function (array, item, changeMeta, instanceMeta) {
+        array.removeObject(item);
+        return array;
+      },
 
-      @method isEqual
-      @for Ember
-      @param {Object} a first object to compare
-      @param {Object} b second object to compare
-      @return {Boolean}
-    */
-    var isEqual = function isEqual(a, b) {
-      if (a && typeof a.isEqual === 'function') {
-        return a.isEqual(b);
+      flushedChanges: function(array, instanceMeta) {
+        instanceMeta.insertWaiting();
       }
+    });
+  }
 
-      if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime();
-      }
+  function propertySort(itemsKey, sortPropertiesKey) {
+    return array_computed.arrayComputed(itemsKey, {
+      initialize: function (array, changeMeta, instanceMeta) {
+        function setupSortProperties() {
+          var sortPropertyDefinitions = property_get.get(this, sortPropertiesKey);
+          var sortProperties = instanceMeta.sortProperties = [];
+          var sortPropertyAscending = instanceMeta.sortPropertyAscending = {};
+          var sortProperty, idx, asc;
 
-      return a === b;
-    };
-    __exports__.isEqual = isEqual;
-  });
-enifed("ember-runtime/ext/function",
-  ["ember-metal/core","ember-metal/expand_properties","ember-metal/computed","ember-metal/mixin"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
+          Ember['default'].assert('Cannot sort: \'' + sortPropertiesKey + '\' is not an array.',
+                       utils.isArray(sortPropertyDefinitions));
 
-    var Ember = __dependency1__["default"];
-    // Ember.EXTEND_PROTOTYPES, Ember.assert
-    var expandProperties = __dependency2__["default"];
-    var computed = __dependency3__.computed;
-    var observer = __dependency4__.observer;
+          changeMeta.property.clearItemPropertyKeys(itemsKey);
 
-    var a_slice = Array.prototype.slice;
-    var FunctionPrototype = Function.prototype;
+          enumerable_utils.forEach(sortPropertyDefinitions, function (sortPropertyDefinition) {
+            if ((idx = sortPropertyDefinition.indexOf(':')) !== -1) {
+              sortProperty = sortPropertyDefinition.substring(0, idx);
+              asc = sortPropertyDefinition.substring(idx+1).toLowerCase() !== 'desc';
+            } else {
+              sortProperty = sortPropertyDefinition;
+              asc = true;
+            }
 
-    if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Function) {
+            sortProperties.push(sortProperty);
+            sortPropertyAscending[sortProperty] = asc;
+            changeMeta.property.itemPropertyKey(itemsKey, sortProperty);
+          });
 
-      /**
-        The `property` extension of Javascript's Function prototype is available
-        when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is
-        `true`, which is the default.
+          sortPropertyDefinitions.addObserver('@each', this, updateSortPropertiesOnce);
+        }
 
-        Computed properties allow you to treat a function like a property:
+        function updateSortPropertiesOnce() {
+          run['default'].once(this, updateSortProperties, changeMeta.propertyName);
+        }
 
-        ```javascript
-        MyApp.President = Ember.Object.extend({
-          firstName: '',
-          lastName:  '',
+        function updateSortProperties(propertyName) {
+          setupSortProperties.call(this);
+          changeMeta.property.recomputeOnce.call(this, propertyName);
+        }
 
-          fullName: function() {
-            return this.get('firstName') + ' ' + this.get('lastName');
-          }.property() // Call this flag to mark the function as a property
-        });
+        observer.addObserver(this, sortPropertiesKey, updateSortPropertiesOnce);
+        setupSortProperties.call(this);
 
-        var president = MyApp.President.create({
-          firstName: 'Barack',
-          lastName: 'Obama'
-        });
+        instanceMeta.order = function (itemA, itemB) {
+          var sortProperty, result, asc;
+          var keyA = this.keyFor(itemA);
+          var keyB = this.keyFor(itemB);
 
-        president.get('fullName'); // 'Barack Obama'
-        ```
+          for (var i = 0; i < this.sortProperties.length; ++i) {
+            sortProperty = this.sortProperties[i];
 
-        Treating a function like a property is useful because they can work with
-        bindings, just like any other property.
+            result = compare['default'](keyA[sortProperty], keyB[sortProperty]);
 
-        Many computed properties have dependencies on other properties. For
-        example, in the above example, the `fullName` property depends on
-        `firstName` and `lastName` to determine its value. You can tell Ember
-        about these dependencies like this:
+            if (result !== 0) {
+              asc = this.sortPropertyAscending[sortProperty];
+              return asc ? result : (-1 * result);
+            }
+          }
 
-        ```javascript
-        MyApp.President = Ember.Object.extend({
-          firstName: '',
-          lastName:  '',
+          return 0;
+        };
 
-          fullName: function() {
-            return this.get('firstName') + ' ' + this.get('lastName');
+        instanceMeta.binarySearch = binarySearch;
+        setupKeyCache(instanceMeta);
+      },
 
-            // Tell Ember.js that this computed property depends on firstName
-            // and lastName
-          }.property('firstName', 'lastName')
-        });
-        ```
+      addedItem: function (array, item, changeMeta, instanceMeta) {
+        var index = instanceMeta.binarySearch(array, item);
+        array.insertAt(index, item);
+        return array;
+      },
 
-        Make sure you list these dependencies so Ember knows when to update
-        bindings that connect to a computed property. Changing a dependency
-        will not immediately trigger an update of the computed property, but
-        will instead clear the cache so that it is updated when the next `get`
-        is called on the property.
+      removedItem: function (array, item, changeMeta, instanceMeta) {
+        var index = instanceMeta.binarySearch(array, item);
+        array.removeAt(index);
+        instanceMeta.dropKeyFor(item);
+        return array;
+      }
+    });
+  }
 
-        See [Ember.ComputedProperty](/api/classes/Ember.ComputedProperty.html), [Ember.computed](/api/#method_computed).
+  function setupKeyCache(instanceMeta) {
+    instanceMeta.keyFor = function(item) {
+      var guid = utils.guidFor(item);
+      if (this.keyCache[guid]) {
+        return this.keyCache[guid];
+      }
+      var sortProperty;
+      var key = {};
+      for (var i = 0; i < this.sortProperties.length; ++i) {
+        sortProperty = this.sortProperties[i];
+        key[sortProperty] = property_get.get(item, sortProperty);
+      }
+      return this.keyCache[guid] = key;
+    };
 
-        @method property
-        @for Function
-      */
-      FunctionPrototype.property = function () {
-        var ret = computed(this);
-        // ComputedProperty.prototype.property expands properties; no need for us to
-        // do so here.
-        return ret.property.apply(ret, arguments);
-      };
+    instanceMeta.dropKeyFor = function(item) {
+      var guid = utils.guidFor(item);
+      this.keyCache[guid] = null;
+    };
 
-      /**
-        The `observes` extension of Javascript's Function prototype is available
-        when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is
-        true, which is the default.
+    instanceMeta.keyCache = {};
+  }
 
-        You can observe property changes simply by adding the `observes`
-        call to the end of your method declarations in classes that you write.
-        For example:
+  exports.mapProperty = mapProperty;
+  exports.filterProperty = filterProperty;
+  exports.union = union;
 
-        ```javascript
-        Ember.Object.extend({
-          valueObserver: function() {
-            // Executes whenever the "value" property changes
-          }.observes('value')
-        });
-        ```
+});
+enifed('ember-runtime/controllers/array_controller', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/enumerable_utils', 'ember-runtime/system/array_proxy', 'ember-runtime/mixins/sortable', 'ember-runtime/mixins/controller', 'ember-metal/computed', 'ember-metal/error', 'ember-runtime/mixins/array'], function (exports, Ember, property_get, enumerable_utils, ArrayProxy, SortableMixin, ControllerMixin, computed, EmberError, EmberArray) {
 
-        In the future this method may become asynchronous. If you want to ensure
-        synchronous behavior, use `observesImmediately`.
+  'use strict';
 
-        See `Ember.observer`.
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-        @method observes
-        @for Function
-      */
-      FunctionPrototype.observes = function() {
-        var length = arguments.length;
-        var args = new Array(length);
-        for (var x = 0; x < length; x++) {
-          args[x] = arguments[x];
-        }
-        return observer.apply(this, args.concat(this));
-      };
+  exports['default'] = ArrayProxy['default'].extend(ControllerMixin['default'], SortableMixin['default'], {
 
-      /**
-        The `observesImmediately` extension of Javascript's Function prototype is
-        available when `Ember.EXTEND_PROTOTYPES` or
-        `Ember.EXTEND_PROTOTYPES.Function` is true, which is the default.
+    /**
+      A string containing the controller name used to wrap items.
 
-        You can observe property changes simply by adding the `observesImmediately`
-        call to the end of your method declarations in classes that you write.
-        For example:
+      For example:
 
-        ```javascript
-        Ember.Object.extend({
-          valueObserver: function() {
-            // Executes immediately after the "value" property changes
-          }.observesImmediately('value')
-        });
-        ```
+      ```javascript
+      App.MyArrayController = Ember.ArrayController.extend({
+        itemController: 'myItem' // use App.MyItemController
+      });
+      ```
 
-        In the future, `observes` may become asynchronous. In this event,
-        `observesImmediately` will maintain the synchronous behavior.
+      @property itemController
+      @type String
+      @default null
+    */
+    itemController: null,
 
-        See `Ember.immediateObserver`.
+    /**
+      Return the name of the controller to wrap items, or `null` if items should
+      be returned directly.  The default implementation simply returns the
+      `itemController` property, but subclasses can override this method to return
+      different controllers for different objects.
 
-        @method observesImmediately
-        @for Function
-      */
-      FunctionPrototype.observesImmediately = function () {
-        Ember.assert('Immediate observers must observe internal properties only, ' +
-                     'not properties on other objects.', function checkIsInternalProperty() {
-          for(var i = 0, l = arguments.length; i < l; i++) {
-            if(arguments[i].indexOf('.') !== -1) {
-              return false;
-            }
+      For example:
+
+      ```javascript
+      App.MyArrayController = Ember.ArrayController.extend({
+        lookupItemController: function( object ) {
+          if (object.get('isSpecial')) {
+            return "special"; // use App.SpecialController
+          } else {
+            return "regular"; // use App.RegularController
           }
-          return true;
-        });
+        }
+      });
+      ```
 
-        // observes handles property expansion
-        return this.observes.apply(this, arguments);
-      };
+      @method lookupItemController
+      @param {Object} object
+      @return {String}
+    */
+    lookupItemController: function(object) {
+      return property_get.get(this, 'itemController');
+    },
 
-      /**
-        The `observesBefore` extension of Javascript's Function prototype is
-        available when `Ember.EXTEND_PROTOTYPES` or
-        `Ember.EXTEND_PROTOTYPES.Function` is true, which is the default.
+    objectAtContent: function(idx) {
+      var length = property_get.get(this, 'length');
+      var arrangedContent = property_get.get(this, 'arrangedContent');
+      var object = arrangedContent && arrangedContent.objectAt(idx);
+      var controllerClass;
 
-        You can get notified when a property change is about to happen by
-        by adding the `observesBefore` call to the end of your method
-        declarations in classes that you write. For example:
+      if (idx >= 0 && idx < length) {
+        controllerClass = this.lookupItemController(object);
 
-        ```javascript
-        Ember.Object.extend({
-          valueObserver: function() {
-            // Executes whenever the "value" property is about to change
-          }.observesBefore('value')
-        });
-        ```
+        if (controllerClass) {
+          return this.controllerAt(idx, object, controllerClass);
+        }
+      }
 
-        See `Ember.beforeObserver`.
+      // When `controllerClass` is falsy, we have not opted in to using item
+      // controllers, so return the object directly.
 
-        @method observesBefore
-        @for Function
-      */
-      FunctionPrototype.observesBefore = function () {
-        var watched = [];
-        var addWatchedProperty = function (obs) {
-          watched.push(obs);
-        };
+      // When the index is out of range, we want to return the "out of range"
+      // value, whatever that might be.  Rather than make assumptions
+      // (e.g. guessing `null` or `undefined`) we defer this to `arrangedContent`.
+      return object;
+    },
 
-        for (var i = 0, l = arguments.length; i < l; ++i) {
-          expandProperties(arguments[i], addWatchedProperty);
-        }
+    arrangedContentDidChange: function() {
+      this._super.apply(this, arguments);
+      this._resetSubControllers();
+    },
 
-        this.__ember_observesBefore__ = watched;
+    arrayContentDidChange: function(idx, removedCnt, addedCnt) {
+      var subControllers = this._subControllers;
 
-        return this;
-      };
+      if (subControllers.length) {
+        var subControllersToRemove = subControllers.slice(idx, idx + removedCnt);
 
-      /**
-        The `on` extension of Javascript's Function prototype is available
-        when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is
-        true, which is the default.
+        enumerable_utils.forEach(subControllersToRemove, function(subController) {
+          if (subController) {
+            subController.destroy();
+          }
+        });
 
-        You can listen for events simply by adding the `on` call to the end of
-        your method declarations in classes or mixins that you write. For example:
+        enumerable_utils.replace(subControllers, idx, removedCnt, new Array(addedCnt));
+      }
 
-        ```javascript
-        Ember.Mixin.create({
-          doSomethingWithElement: function() {
-            // Executes whenever the "didInsertElement" event fires
-          }.on('didInsertElement')
-        });
-        ```
+      // The shadow array of subcontrollers must be updated before we trigger
+      // observers, otherwise observers will get the wrong subcontainer when
+      // calling `objectAt`
+      this._super(idx, removedCnt, addedCnt);
+    },
 
-        See `Ember.on`.
+    init: function() {
+      this._super.apply(this, arguments);
+      this._subControllers = [];
+    },
 
-        @method on
-        @for Function
-      */
-      FunctionPrototype.on = function () {
-        var events = a_slice.call(arguments);
-        this.__ember_listens__ = events;
+    model: computed.computed(function (key, value) {
+      if (arguments.length > 1) {
+        Ember['default'].assert(
+          'ArrayController expects `model` to implement the Ember.Array mixin. ' +
+          'This can often be fixed by wrapping your model with `Ember.A()`.',
+          EmberArray['default'].detect(value)
+        );
 
-        return this;
-      };
-    }
-  });
-enifed("ember-runtime/ext/rsvp",
-  ["ember-metal/core","ember-metal/logger","ember-metal/run_loop","rsvp","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    /* globals RSVP:true */
+        return value;
+      }
 
-    var Ember = __dependency1__["default"];
-    var Logger = __dependency2__["default"];
-    var run = __dependency3__["default"];
+      return Ember['default'].A();
+    }),
+
+    /**
+     * Flag to mark as being "virtual". Used to keep this instance
+     * from participating in the parentController hierarchy.
+     *
+     * @private
+     * @property _isVirtual
+     * @type Boolean
+     */
+    _isVirtual: false,
 
-    // this is technically incorrect (per @wycats)
-    // it should be `import * as RSVP from 'rsvp';` but
-    // Esprima does not support this syntax yet (and neither does
-    // es6-module-transpiler 0.4.0 - 0.6.2).
-    var RSVP = __dependency4__;
+    controllerAt: function(idx, object, controllerClass) {
+      var container = property_get.get(this, 'container');
+      var subControllers = this._subControllers;
+      var fullName, subController, parentController;
 
-    var testModuleName = 'ember-testing/test';
-    var Test;
+      if (subControllers.length > idx) {
+        subController = subControllers[idx];
 
-    var asyncStart = function() {
-      if (Ember.Test && Ember.Test.adapter) {
-        Ember.Test.adapter.asyncStart();
+        if (subController) {
+          return subController;
+        }
       }
-    };
 
-    var asyncEnd = function() {
-      if (Ember.Test && Ember.Test.adapter) {
-        Ember.Test.adapter.asyncEnd();
+      if (this._isVirtual) {
+        parentController = property_get.get(this, 'parentController');
+      } else {
+        parentController = this;
       }
-    };
 
-    RSVP.configure('async', function(callback, promise) {
-      var async = !run.currentRunLoop;
+      fullName = 'controller:' + controllerClass;
 
-      if (Ember.testing && async) { asyncStart(); }
+      if (!container._registry.has(fullName)) {
+        throw new EmberError['default']('Could not resolve itemController: "' + controllerClass + '"');
+      }
 
-      run.backburner.schedule('actions', function(){
-        if (Ember.testing && async) { asyncEnd(); }
-        callback(promise);
+      subController = container.lookupFactory(fullName).create({
+        target: parentController,
+        parentController: parentController,
+        model: object
       });
-    });
 
-    RSVP.Promise.prototype.fail = function(callback, label){
-      Ember.deprecate('RSVP.Promise.fail has been renamed as RSVP.Promise.catch');
-      return this['catch'](callback, label);
-    };
+      subControllers[idx] = subController;
 
-    RSVP.onerrorDefault = function (e) {
-      var error;
+      return subController;
+    },
 
-      if (e && e.errorThrown) {
-        // jqXHR provides this
-        error = e.errorThrown;
-        if (typeof error === 'string') {
-          error = new Error(error);
-        }
-        error.__reason_with_error_thrown__ = e;
-      } else {
-        error = e;
-      }
+    _subControllers: null,
 
-      if (error && error.name !== 'TransitionAborted') {
-        if (Ember.testing) {
-          // ES6TODO: remove when possible
-          if (!Test && Ember.__loader.registry[testModuleName]) {
-            Test = requireModule(testModuleName)['default'];
-          }
+    _resetSubControllers: function() {
+      var controller;
+      var subControllers = this._subControllers;
 
-          if (Test && Test.adapter) {
-            Test.adapter.exception(error);
-            Logger.error(error.stack);
-          } else {
-            throw error;
+      if (subControllers.length) {
+        for (var i = 0, length = subControllers.length; length > i; i++) {
+          controller = subControllers[i];
+
+          if (controller) {
+            controller.destroy();
           }
-        } else if (Ember.onerror) {
-          Ember.onerror(error);
-        } else {
-          Logger.error(error.stack);
         }
-      }
-    };
 
-    RSVP.on('error', RSVP.onerrorDefault);
+        subControllers.length = 0;
+      }
+    },
 
-    __exports__["default"] = RSVP;
+    willDestroy: function() {
+      this._resetSubControllers();
+      this._super.apply(this, arguments);
+    }
   });
-enifed("ember-runtime/ext/string",
-  ["ember-metal/core","ember-runtime/system/string"],
-  function(__dependency1__, __dependency2__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
-
-    var Ember = __dependency1__["default"];
-    // Ember.EXTEND_PROTOTYPES, Ember.assert, Ember.FEATURES
-    var fmt = __dependency2__.fmt;
-    var w = __dependency2__.w;
-    var loc = __dependency2__.loc;
-    var camelize = __dependency2__.camelize;
-    var decamelize = __dependency2__.decamelize;
-    var dasherize = __dependency2__.dasherize;
-    var underscore = __dependency2__.underscore;
-    var capitalize = __dependency2__.capitalize;
-    var classify = __dependency2__.classify;
-
-    var StringPrototype = String.prototype;
 
-    if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) {
+});
+enifed('ember-runtime/controllers/controller', ['exports', 'ember-metal/core', 'ember-runtime/system/object', 'ember-runtime/mixins/controller', 'ember-runtime/inject'], function (exports, Ember, EmberObject, Mixin, inject) {
 
-      /**
-        See [Ember.String.fmt](/api/classes/Ember.String.html#method_fmt).
+  'use strict';
 
-        @method fmt
-        @for String
-      */
-      StringPrototype.fmt = function () {
-        return fmt(this, arguments);
-      };
+  var Controller = EmberObject['default'].extend(Mixin['default']);
 
-      /**
-        See [Ember.String.w](/api/classes/Ember.String.html#method_w).
+  function controllerInjectionHelper(factory) {
+    Ember['default'].assert("Defining an injected controller property on a " +
+                 "non-controller is not allowed.", Mixin['default'].detect(factory.PrototypeMixin));
+  }
 
-        @method w
-        @for String
-      */
-      StringPrototype.w = function () {
-        return w(this);
-      };
+  /**
+    Creates a property that lazily looks up another controller in the container.
+    Can only be used when defining another controller.
 
-      /**
-        See [Ember.String.loc](/api/classes/Ember.String.html#method_loc).
+    Example:
 
-        @method loc
-        @for String
-      */
-      StringPrototype.loc = function () {
-        return loc(this, arguments);
-      };
+    ```javascript
+    App.PostController = Ember.Controller.extend({
+      posts: Ember.inject.controller()
+    });
+    ```
 
-      /**
-        See [Ember.String.camelize](/api/classes/Ember.String.html#method_camelize).
+    This example will create a `posts` property on the `post` controller that
+    looks up the `posts` controller in the container, making it easy to
+    reference other controllers. This is functionally equivalent to:
 
-        @method camelize
-        @for String
-      */
-      StringPrototype.camelize = function () {
-        return camelize(this);
-      };
+    ```javascript
+    App.PostController = Ember.Controller.extend({
+      needs: 'posts',
+      posts: Ember.computed.alias('controllers.posts')
+    });
+    ```
 
-      /**
-        See [Ember.String.decamelize](/api/classes/Ember.String.html#method_decamelize).
+    @method controller
+    @since 1.10.0
+    @for Ember.inject
+    @param {String} name (optional) name of the controller to inject, defaults
+           to the property's name
+    @return {Ember.InjectedProperty} injection descriptor instance
+    */
+  inject.createInjectionHelper('controller', controllerInjectionHelper);
 
-        @method decamelize
-        @for String
-      */
-      StringPrototype.decamelize = function () {
-        return decamelize(this);
-      };
+  exports['default'] = Controller;
 
-      /**
-        See [Ember.String.dasherize](/api/classes/Ember.String.html#method_dasherize).
+});
+enifed('ember-runtime/controllers/object_controller', ['exports', 'ember-metal/core', 'ember-runtime/mixins/controller', 'ember-runtime/system/object_proxy'], function (exports, Ember, ControllerMixin, ObjectProxy) {
 
-        @method dasherize
-        @for String
-      */
-      StringPrototype.dasherize = function () {
-        return dasherize(this);
-      };
+  'use strict';
 
-      /**
-        See [Ember.String.underscore](/api/classes/Ember.String.html#method_underscore).
+  var objectControllerDeprecation = 'Ember.ObjectController is deprecated, ' +
+    'please use Ember.Controller and use `model.propertyName`.';
 
-        @method underscore
-        @for String
-      */
-      StringPrototype.underscore = function () {
-        return underscore(this);
-      };
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-      /**
-        See [Ember.String.classify](/api/classes/Ember.String.html#method_classify).
+  /**
+    `Ember.ObjectController` is part of Ember's Controller layer. It is intended
+    to wrap a single object, proxying unhandled attempts to `get` and `set` to the underlying
+    model object, and to forward unhandled action attempts to its `target`.
 
-        @method classify
-        @for String
-      */
-      StringPrototype.classify = function () {
-        return classify(this);
-      };
+    `Ember.ObjectController` derives this functionality from its superclass
+    `Ember.ObjectProxy` and the `Ember.ControllerMixin` mixin.
 
-      /**
-        See [Ember.String.capitalize](/api/classes/Ember.String.html#method_capitalize).
+    @class ObjectController
+    @namespace Ember
+    @extends Ember.ObjectProxy
+    @uses Ember.ControllerMixin
+    @deprecated
+  **/
+  exports['default'] = ObjectProxy['default'].extend(ControllerMixin['default'], {
+    init: function() {
+      this._super();
 
-        @method capitalize
-        @for String
-      */
-      StringPrototype.capitalize = function () {
-        return capitalize(this);
-      };
+      Ember['default'].deprecate(objectControllerDeprecation, this.isGenerated, {
+        url: 'http://emberjs.com/guides/deprecations/#toc_objectcontroller'
+      });
     }
   });
-enifed("ember-runtime/inject",
-  ["ember-metal/core","ember-metal/enumerable_utils","ember-metal/utils","ember-metal/injected_property","ember-metal/keys","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var indexOf = __dependency2__.indexOf;
-    var meta = __dependency3__.meta;
-    var InjectedProperty = __dependency4__["default"];
-    var keys = __dependency5__["default"];
 
-    /**
-      Namespace for injection helper methods.
+  exports.objectControllerDeprecation = objectControllerDeprecation;
 
-      @class inject
-      @namespace Ember
-      */
-    function inject() {
-      Ember.assert("Injected properties must be created through helpers, see `" +
-                   keys(inject).join("`, `") + "`");
-    }
+});
+enifed('ember-runtime/copy', ['exports', 'ember-metal/enumerable_utils', 'ember-metal/utils', 'ember-runtime/system/object', 'ember-runtime/mixins/copyable'], function (exports, enumerable_utils, utils, EmberObject, Copyable) {
 
-    // Dictionary of injection validations by type, added to by `createInjectionHelper`
-    var typeValidators = {};
+  'use strict';
 
-    /**
-      This method allows other Ember modules to register injection helpers for a
-      given container type. Helpers are exported to the `inject` namespace as the
-      container type itself.
+  function _copy(obj, deep, seen, copies) {
+    var ret, loc, key;
 
-      @private
-      @method createInjectionHelper
-      @namespace Ember
-      @param {String} type The container type the helper will inject
-      @param {Function} validator A validation callback that is executed at mixin-time
-    */
-    function createInjectionHelper(type, validator) {
-      typeValidators[type] = validator;
+    // primitive data types are immutable, just return them.
+    if (typeof obj !== 'object' || obj === null) {
+      return obj;
+    }
 
-      inject[type] = function(name) {
-        return new InjectedProperty(type, name);
-      };
+    // avoid cyclical loops
+    if (deep && (loc = enumerable_utils.indexOf(seen, obj)) >= 0) {
+      return copies[loc];
     }
 
-    __exports__.createInjectionHelper = createInjectionHelper;/**
-      Validation function that runs per-type validation functions once for each
-      injected type encountered.
+    Ember.assert('Cannot clone an Ember.Object that does not implement Ember.Copyable',
+      !(obj instanceof EmberObject['default']) || (Copyable['default'] && Copyable['default'].detect(obj)));
 
-      @private
-      @method validatePropertyInjections
-      @namespace Ember
-      @param {Object} factory The factory object
-    */
-    function validatePropertyInjections(factory) {
-      var proto = factory.proto();
-      var descs = meta(proto).descs;
-      var types = [];
-      var key, desc, validator, i, l;
+    // IMPORTANT: this specific test will detect a native array only. Any other
+    // object will need to implement Copyable.
+    if (utils.typeOf(obj) === 'array') {
+      ret = obj.slice();
+
+      if (deep) {
+        loc = ret.length;
 
-      for (key in descs) {
-        desc = descs[key];
-        if (desc instanceof InjectedProperty && indexOf(types, desc.type) === -1) {
-          types.push(desc.type);
+        while (--loc >= 0) {
+          ret[loc] = _copy(ret[loc], deep, seen, copies);
         }
       }
+    } else if (Copyable['default'] && Copyable['default'].detect(obj)) {
+      ret = obj.copy(deep, seen, copies);
+    } else if (obj instanceof Date) {
+      ret = new Date(obj.getTime());
+    } else {
+      ret = {};
 
-      if (types.length) {
-        for (i = 0, l = types.length; i < l; i++) {
-          validator = typeValidators[types[i]];
+      for (key in obj) {
+        // support Null prototype
+        if (!Object.prototype.hasOwnProperty.call(obj, key)) {
+          continue;
+        }
 
-          if (typeof validator === 'function') {
-            validator(factory);
-          }
+        // Prevents browsers that don't respect non-enumerability from
+        // copying internal Ember properties
+        if (key.substring(0, 2) === '__') {
+          continue;
         }
+
+        ret[key] = deep ? _copy(obj[key], deep, seen, copies) : obj[key];
       }
+    }
 
-      return true;
+    if (deep) {
+      seen.push(obj);
+      copies.push(ret);
     }
 
-    __exports__.validatePropertyInjections = validatePropertyInjections;__exports__["default"] = inject;
-  });
-enifed("ember-runtime/mixins/-proxy",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/observer","ember-metal/property_events","ember-metal/computed","ember-metal/properties","ember-metal/mixin","ember-runtime/system/string","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
+    return ret;
+  }
 
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var get = __dependency2__.get;
-    var set = __dependency3__.set;
-    var meta = __dependency4__.meta;
-    var addObserver = __dependency5__.addObserver;
-    var removeObserver = __dependency5__.removeObserver;
-    var addBeforeObserver = __dependency5__.addBeforeObserver;
-    var removeBeforeObserver = __dependency5__.removeBeforeObserver;
-    var propertyWillChange = __dependency6__.propertyWillChange;
-    var propertyDidChange = __dependency6__.propertyDidChange;
-    var computed = __dependency7__.computed;
-    var defineProperty = __dependency8__.defineProperty;
-    var Mixin = __dependency9__.Mixin;
-    var observer = __dependency9__.observer;
-    var fmt = __dependency10__.fmt;
+  /**
+    Creates a clone of the passed object. This function can take just about
+    any type of object and create a clone of it, including primitive values
+    (which are not actually cloned because they are immutable).
 
-    function contentPropertyWillChange(content, contentKey) {
-      var key = contentKey.slice(8); // remove "content."
-      if (key in this) { return; }  // if shadowed in proxy
-      propertyWillChange(this, key);
+    If the passed object implements the `copy()` method, then this function
+    will simply call that method and return the result. Please see
+    `Ember.Copyable` for further details.
+
+    @method copy
+    @for Ember
+    @param {Object} obj The object to clone
+    @param {Boolean} deep If true, a deep copy of the object is made
+    @return {Object} The cloned object
+  */
+  function copy(obj, deep) {
+    // fast paths
+    if ('object' !== typeof obj || obj === null) {
+      return obj; // can't copy primitives
     }
 
-    function contentPropertyDidChange(content, contentKey) {
-      var key = contentKey.slice(8); // remove "content."
-      if (key in this) { return; } // if shadowed in proxy
-      propertyDidChange(this, key);
+    if (Copyable['default'] && Copyable['default'].detect(obj)) {
+      return obj.copy(deep);
     }
 
-    /**
-      `Ember.ProxyMixin` forwards all properties not defined by the proxy itself
-      to a proxied `content` object.  See Ember.ObjectProxy for more details.
+    return _copy(obj, deep, deep ? [] : null, deep ? [] : null);
+  }
+  exports['default'] = copy;
 
-      @class ProxyMixin
-      @namespace Ember
-    */
-    __exports__["default"] = Mixin.create({
-      /**
-        The object whose properties will be forwarded.
+});
+enifed('ember-runtime/core', ['exports'], function (exports) {
 
-        @property content
-        @type Ember.Object
-        @default null
-      */
-      content: null,
-      _contentDidChange: observer('content', function() {
-        Ember.assert("Can't set Proxy's content to itself", get(this, 'content') !== this);
-      }),
+  'use strict';
 
-      isTruthy: computed.bool('content'),
+  exports.isEqual = isEqual;
 
-      _debugContainerKey: null,
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-      willWatchProperty: function (key) {
-        var contentKey = 'content.' + key;
-        addBeforeObserver(this, contentKey, null, contentPropertyWillChange);
-        addObserver(this, contentKey, null, contentPropertyDidChange);
-      },
+  /**
+    Compares two objects, returning true if they are logically equal. This is
+    a deeper comparison than a simple triple equal. For sets it will compare the
+    internal objects. For any other object that implements `isEqual()` it will
+    respect that method.
 
-      didUnwatchProperty: function (key) {
-        var contentKey = 'content.' + key;
-        removeBeforeObserver(this, contentKey, null, contentPropertyWillChange);
-        removeObserver(this, contentKey, null, contentPropertyDidChange);
-      },
+    ```javascript
+    Ember.isEqual('hello', 'hello');  // true
+    Ember.isEqual(1, 2);              // false
+    Ember.isEqual([4, 2], [4, 2]);    // false
+    ```
 
-      unknownProperty: function (key) {
-        var content = get(this, 'content');
-        if (content) {
-          return get(content, key);
-        }
-      },
+    @method isEqual
+    @for Ember
+    @param {Object} a first object to compare
+    @param {Object} b second object to compare
+    @return {Boolean}
+  */
+  function isEqual(a, b) {
+    if (a && typeof a.isEqual === 'function') {
+      return a.isEqual(b);
+    }
 
-      setUnknownProperty: function (key, value) {
-        var m = meta(this);
-        if (m.proto === this) {
-          // if marked as prototype then just defineProperty
-          // rather than delegate
-          defineProperty(this, key, null, value);
-          return value;
-        }
+    if (a instanceof Date && b instanceof Date) {
+      return a.getTime() === b.getTime();
+    }
 
-        var content = get(this, 'content');
-        Ember.assert(fmt("Cannot delegate set('%@', %@) to the 'content' property of" +
-                         " object proxy %@: its 'content' is undefined.", [key, value, this]), content);
-        return set(content, key, value);
-      }
+    return a === b;
+  }
 
-    });
-  });
-enifed("ember-runtime/mixins/action_handler",
-  ["ember-metal/merge","ember-metal/mixin","ember-metal/property_get","ember-metal/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
-    var merge = __dependency1__["default"];
-    var Mixin = __dependency2__.Mixin;
-    var get = __dependency3__.get;
-    var typeOf = __dependency4__.typeOf;
+});
+enifed('ember-runtime/ext/function', ['ember-metal/core', 'ember-metal/expand_properties', 'ember-metal/computed', 'ember-metal/mixin'], function (Ember, expandProperties, computed, mixin) {
+
+  'use strict';
+
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
+
+  var a_slice = Array.prototype.slice;
+  var FunctionPrototype = Function.prototype;
+
+  if (Ember['default'].EXTEND_PROTOTYPES === true || Ember['default'].EXTEND_PROTOTYPES.Function) {
 
     /**
-      The `Ember.ActionHandler` mixin implements support for moving an `actions`
-      property to an `_actions` property at extend time, and adding `_actions`
-      to the object's mergedProperties list.
+      The `property` extension of Javascript's Function prototype is available
+      when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is
+      `true`, which is the default.
+
+      Computed properties allow you to treat a function like a property:
+
+      ```javascript
+      MyApp.President = Ember.Object.extend({
+        firstName: '',
+        lastName:  '',
+
+        fullName: function() {
+          return this.get('firstName') + ' ' + this.get('lastName');
+        }.property() // Call this flag to mark the function as a property
+      });
+
+      var president = MyApp.President.create({
+        firstName: 'Barack',
+        lastName: 'Obama'
+      });
 
-      `Ember.ActionHandler` is available on some familiar classes including
-      `Ember.Route`, `Ember.View`, `Ember.Component`, and controllers such as
-      `Ember.Controller` and `Ember.ObjectController`.
-      (Internally the mixin is used by `Ember.CoreView`, `Ember.ControllerMixin`,
-      and `Ember.Route` and available to the above classes through
-      inheritance.)
+      president.get('fullName'); // 'Barack Obama'
+      ```
 
-      @class ActionHandler
-      @namespace Ember
-    */
-    var ActionHandler = Mixin.create({
-      mergedProperties: ['_actions'],
+      Treating a function like a property is useful because they can work with
+      bindings, just like any other property.
 
-      /**
-        The collection of functions, keyed by name, available on this
-        `ActionHandler` as action targets.
+      Many computed properties have dependencies on other properties. For
+      example, in the above example, the `fullName` property depends on
+      `firstName` and `lastName` to determine its value. You can tell Ember
+      about these dependencies like this:
 
-        These functions will be invoked when a matching `{{action}}` is triggered
-        from within a template and the application's current route is this route.
+      ```javascript
+      MyApp.President = Ember.Object.extend({
+        firstName: '',
+        lastName:  '',
 
-        Actions can also be invoked from other parts of your application
-        via `ActionHandler#send`.
+        fullName: function() {
+          return this.get('firstName') + ' ' + this.get('lastName');
 
-        The `actions` hash will inherit action handlers from
-        the `actions` hash defined on extended parent classes
-        or mixins rather than just replace the entire hash, e.g.:
+          // Tell Ember.js that this computed property depends on firstName
+          // and lastName
+        }.property('firstName', 'lastName')
+      });
+      ```
 
-        ```js
-        App.CanDisplayBanner = Ember.Mixin.create({
-          actions: {
-            displayBanner: function(msg) {
-              // ...
-            }
-          }
-        });
+      Make sure you list these dependencies so Ember knows when to update
+      bindings that connect to a computed property. Changing a dependency
+      will not immediately trigger an update of the computed property, but
+      will instead clear the cache so that it is updated when the next `get`
+      is called on the property.
 
-        App.WelcomeRoute = Ember.Route.extend(App.CanDisplayBanner, {
-          actions: {
-            playMusic: function() {
-              // ...
-            }
-          }
-        });
+      See [Ember.ComputedProperty](/api/classes/Ember.ComputedProperty.html), [Ember.computed](/api/#method_computed).
 
-        // `WelcomeRoute`, when active, will be able to respond
-        // to both actions, since the actions hash is merged rather
-        // then replaced when extending mixins / parent classes.
-        this.send('displayBanner');
-        this.send('playMusic');
-        ```
+      @method property
+      @for Function
+    */
+    FunctionPrototype.property = function () {
+      var ret = computed.computed(this);
+      // ComputedProperty.prototype.property expands properties; no need for us to
+      // do so here.
+      return ret.property.apply(ret, arguments);
+    };
 
-        Within a Controller, Route, View or Component's action handler,
-        the value of the `this` context is the Controller, Route, View or
-        Component object:
-
-        ```js
-        App.SongRoute = Ember.Route.extend({
-          actions: {
-            myAction: function() {
-              this.controllerFor("song");
-              this.transitionTo("other.route");
-              ...
-            }
-          }
-        });
-        ```
+    /**
+      The `observes` extension of Javascript's Function prototype is available
+      when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is
+      true, which is the default.
 
-        It is also possible to call `this._super()` from within an
-        action handler if it overrides a handler defined on a parent
-        class or mixin:
+      You can observe property changes simply by adding the `observes`
+      call to the end of your method declarations in classes that you write.
+      For example:
 
-        Take for example the following routes:
+      ```javascript
+      Ember.Object.extend({
+        valueObserver: function() {
+          // Executes whenever the "value" property changes
+        }.observes('value')
+      });
+      ```
 
-        ```js
-        App.DebugRoute = Ember.Mixin.create({
-          actions: {
-            debugRouteInformation: function() {
-              console.debug("trololo");
-            }
-          }
-        });
+      In the future this method may become asynchronous. If you want to ensure
+      synchronous behavior, use `observesImmediately`.
 
-        App.AnnoyingDebugRoute = Ember.Route.extend(App.DebugRoute, {
-          actions: {
-            debugRouteInformation: function() {
-              // also call the debugRouteInformation of mixed in App.DebugRoute
-              this._super();
+      See `Ember.observer`.
 
-              // show additional annoyance
-              window.alert(...);
-            }
-          }
-        });
-        ```
+      @method observes
+      @for Function
+    */
+    FunctionPrototype.observes = function() {
+      var length = arguments.length;
+      var args = new Array(length);
+      for (var x = 0; x < length; x++) {
+        args[x] = arguments[x];
+      }
+      return mixin.observer.apply(this, args.concat(this));
+    };
 
-        ## Bubbling
+    /**
+      The `observesImmediately` extension of Javascript's Function prototype is
+      available when `Ember.EXTEND_PROTOTYPES` or
+      `Ember.EXTEND_PROTOTYPES.Function` is true, which is the default.
 
-        By default, an action will stop bubbling once a handler defined
-        on the `actions` hash handles it. To continue bubbling the action,
-        you must return `true` from the handler:
+      You can observe property changes simply by adding the `observesImmediately`
+      call to the end of your method declarations in classes that you write.
+      For example:
 
-        ```js
-        App.Router.map(function() {
-          this.resource("album", function() {
-            this.route("song");
-          });
-        });
+      ```javascript
+      Ember.Object.extend({
+        valueObserver: function() {
+          // Executes immediately after the "value" property changes
+        }.observesImmediately('value')
+      });
+      ```
 
-        App.AlbumRoute = Ember.Route.extend({
-          actions: {
-            startPlaying: function() {
-            }
-          }
-        });
+      In the future, `observes` may become asynchronous. In this event,
+      `observesImmediately` will maintain the synchronous behavior.
 
-        App.AlbumSongRoute = Ember.Route.extend({
-          actions: {
-            startPlaying: function() {
-              // ...
+      See `Ember.immediateObserver`.
 
-              if (actionShouldAlsoBeTriggeredOnParentRoute) {
-                return true;
-              }
-            }
+      @method observesImmediately
+      @for Function
+    */
+    FunctionPrototype.observesImmediately = function () {
+      Ember['default'].assert('Immediate observers must observe internal properties only, ' +
+                   'not properties on other objects.', function checkIsInternalProperty() {
+        for (var i = 0, l = arguments.length; i < l; i++) {
+          if (arguments[i].indexOf('.') !== -1) {
+            return false;
           }
-        });
-        ```
+        }
+        return true;
+      });
 
-        @property actions
-        @type Hash
-        @default null
-      */
+      // observes handles property expansion
+      return this.observes.apply(this, arguments);
+    };
 
-      /**
-        Moves `actions` to `_actions` at extend time. Note that this currently
-        modifies the mixin themselves, which is technically dubious but
-        is practically of little consequence. This may change in the future.
+    /**
+      The `observesBefore` extension of Javascript's Function prototype is
+      available when `Ember.EXTEND_PROTOTYPES` or
+      `Ember.EXTEND_PROTOTYPES.Function` is true, which is the default.
 
-        @private
-        @method willMergeMixin
-      */
-      willMergeMixin: function(props) {
-        var hashName;
-
-        if (!props._actions) {
-          Ember.assert("'actions' should not be a function", typeof(props.actions) !== 'function');
-
-          if (typeOf(props.actions) === 'object') {
-            hashName = 'actions';
-          } else if (typeOf(props.events) === 'object') {
-            Ember.deprecate('Action handlers contained in an `events` object are deprecated in favor' +
-                            ' of putting them in an `actions` object', false);
-            hashName = 'events';
-          }
+      You can get notified when a property change is about to happen by
+      by adding the `observesBefore` call to the end of your method
+      declarations in classes that you write. For example:
 
-          if (hashName) {
-            props._actions = merge(props._actions || {}, props[hashName]);
-          }
+      ```javascript
+      Ember.Object.extend({
+        valueObserver: function() {
+          // Executes whenever the "value" property is about to change
+        }.observesBefore('value')
+      });
+      ```
 
-          delete props[hashName];
-        }
-      },
+      See `Ember.beforeObserver`.
 
-      /**
-        Triggers a named action on the `ActionHandler`. Any parameters
-        supplied after the `actionName` string will be passed as arguments
-        to the action target function.
-
-        If the `ActionHandler` has its `target` property set, actions may
-        bubble to the `target`. Bubbling happens when an `actionName` can
-        not be found in the `ActionHandler`'s `actions` hash or if the
-        action target function returns `true`.
-
-        Example
-
-        ```js
-        App.WelcomeRoute = Ember.Route.extend({
-          actions: {
-            playTheme: function() {
-               this.send('playMusic', 'theme.mp3');
-            },
-            playMusic: function(track) {
-              // ...
-            }
-          }
-        });
-        ```
+      @method observesBefore
+      @for Function
+    */
+    FunctionPrototype.observesBefore = function () {
+      var watched = [];
+      var addWatchedProperty = function (obs) {
+        watched.push(obs);
+      };
 
-        @method send
-        @param {String} actionName The action to trigger
-        @param {*} context a context to send with the action
-      */
-      send: function(actionName) {
-        var args = [].slice.call(arguments, 1);
-        var target;
+      for (var i = 0, l = arguments.length; i < l; ++i) {
+        expandProperties['default'](arguments[i], addWatchedProperty);
+      }
 
-        if (this._actions && this._actions[actionName]) {
-          if (this._actions[actionName].apply(this, args) === true) {
-            // handler returned true, so this action will bubble
-          } else {
-            return;
-          }
-        }
+      this.__ember_observesBefore__ = watched;
 
-        if (target = get(this, 'target')) {
-          Ember.assert("The `target` for " + this + " (" + target +
-                       ") does not have a `send` method", typeof target.send === 'function');
-          target.send.apply(target, arguments);
-        }
-      }
-    });
+      return this;
+    };
 
-    __exports__["default"] = ActionHandler;
-  });
-enifed("ember-runtime/mixins/array",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/computed","ember-metal/is_none","ember-runtime/mixins/enumerable","ember-metal/enumerable_utils","ember-metal/mixin","ember-metal/property_events","ember-metal/events","ember-metal/watching","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-runtime
-    */
+      The `on` extension of Javascript's Function prototype is available
+      when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is
+      true, which is the default.
 
-    // ..........................................................
-    // HELPERS
-    //
-    var Ember = __dependency1__["default"];
-    // ES6TODO: Ember.A
+      You can listen for events simply by adding the `on` call to the end of
+      your method declarations in classes or mixins that you write. For example:
 
-    var get = __dependency2__.get;
-    var computed = __dependency3__.computed;
-    var cacheFor = __dependency3__.cacheFor;
-    var isNone = __dependency4__["default"];
-    var Enumerable = __dependency5__["default"];
-    var map = __dependency6__.map;
-    var Mixin = __dependency7__.Mixin;
-    var required = __dependency7__.required;
-    var propertyWillChange = __dependency8__.propertyWillChange;
-    var propertyDidChange = __dependency8__.propertyDidChange;
-    var addListener = __dependency9__.addListener;
-    var removeListener = __dependency9__.removeListener;
-    var sendEvent = __dependency9__.sendEvent;
-    var hasListeners = __dependency9__.hasListeners;
-    var isWatching = __dependency10__.isWatching;
+      ```javascript
+      Ember.Mixin.create({
+        doSomethingWithElement: function() {
+          // Executes whenever the "didInsertElement" event fires
+        }.on('didInsertElement')
+      });
+      ```
 
-    function arrayObserversHelper(obj, target, opts, operation, notify) {
-      var willChange = (opts && opts.willChange) || 'arrayWillChange';
-      var didChange  = (opts && opts.didChange) || 'arrayDidChange';
-      var hasObservers = get(obj, 'hasArrayObservers');
+      See `Ember.on`.
 
-      if (hasObservers === notify) {
-        propertyWillChange(obj, 'hasArrayObservers');
-      }
+      @method on
+      @for Function
+    */
+    FunctionPrototype.on = function () {
+      var events = a_slice.call(arguments);
+      this.__ember_listens__ = events;
 
-      operation(obj, '@array:before', target, willChange);
-      operation(obj, '@array:change', target, didChange);
+      return this;
+    };
+  }
 
-      if (hasObservers === notify) {
-        propertyDidChange(obj, 'hasArrayObservers');
-      }
+});
+enifed('ember-runtime/ext/rsvp', ['exports', 'ember-metal/core', 'ember-metal/logger', 'ember-metal/run_loop', 'rsvp'], function (exports, Ember, Logger, run, RSVP) {
 
-      return obj;
-    }
+  'use strict';
 
-    // ..........................................................
-    // ARRAY
-    //
-    /**
-      This mixin implements Observer-friendly Array-like behavior. It is not a
-      concrete implementation, but it can be used up by other classes that want
-      to appear like arrays.
+  exports.onerrorDefault = onerrorDefault;
 
-      For example, ArrayProxy and ArrayController are both concrete classes that can
-      be instantiated to implement array-like behavior. Both of these classes use
-      the Array Mixin by way of the MutableArray mixin, which allows observable
-      changes to be made to the underlying array.
+  /* globals RSVP:true */
 
-      Unlike `Ember.Enumerable,` this mixin defines methods specifically for
-      collections that provide index-ordered access to their contents. When you
-      are designing code that needs to accept any kind of Array-like object, you
-      should use these methods instead of Array primitives because these will
-      properly notify observers of changes to the array.
+  var testModuleName = 'ember-testing/test';
+  var Test;
 
-      Although these methods are efficient, they do add a layer of indirection to
-      your application so it is a good idea to use them only when you need the
-      flexibility of using both true JavaScript arrays and "virtual" arrays such
-      as controllers and collections.
+  var asyncStart = function() {
+    if (Ember['default'].Test && Ember['default'].Test.adapter) {
+      Ember['default'].Test.adapter.asyncStart();
+    }
+  };
 
-      You can use the methods defined in this module to access and modify array
-      contents in a KVO-friendly way. You can also be notified whenever the
-      membership of an array changes by using `.observes('myArray.[]')`.
+  var asyncEnd = function() {
+    if (Ember['default'].Test && Ember['default'].Test.adapter) {
+      Ember['default'].Test.adapter.asyncEnd();
+    }
+  };
 
-      To support `Ember.Array` in your own class, you must override two
-      primitives to use it: `replace()` and `objectAt()`.
+  RSVP.configure('async', function(callback, promise) {
+    var async = !run['default'].currentRunLoop;
 
-      Note that the Ember.Array mixin also incorporates the `Ember.Enumerable`
-      mixin. All `Ember.Array`-like objects are also enumerable.
+    if (Ember['default'].testing && async) { asyncStart(); }
 
-      @class Array
-      @namespace Ember
-      @uses Ember.Enumerable
-      @since Ember 0.9.0
-    */
-    __exports__["default"] = Mixin.create(Enumerable, {
+    run['default'].backburner.schedule('actions', function() {
+      if (Ember['default'].testing && async) { asyncEnd(); }
+      callback(promise);
+    });
+  });
 
-      /**
-        Your array must support the `length` property. Your replace methods should
-        set this property whenever it changes.
+  RSVP.Promise.prototype.fail = function(callback, label) {
+    Ember['default'].deprecate('RSVP.Promise.fail has been renamed as RSVP.Promise.catch');
+    return this['catch'](callback, label);
+  };
 
-        @property {Number} length
-      */
-      length: required(),
+  function onerrorDefault(e) {
+    var error;
 
-      /**
-        Returns the object at the given `index`. If the given `index` is negative
-        or is greater or equal than the array length, returns `undefined`.
+    if (e && e.errorThrown) {
+      // jqXHR provides this
+      error = e.errorThrown;
+      if (typeof error === 'string') {
+        error = new Error(error);
+      }
+      error.__reason_with_error_thrown__ = e;
+    } else {
+      error = e;
+    }
 
-        This is one of the primitives you must implement to support `Ember.Array`.
-        If your object supports retrieving the value of an array item using `get()`
-        (i.e. `myArray.get(0)`), then you do not need to implement this method
-        yourself.
+    if (error && error.name !== 'TransitionAborted') {
+      if (Ember['default'].testing) {
+        // ES6TODO: remove when possible
+        if (!Test && Ember['default'].__loader.registry[testModuleName]) {
+          Test = requireModule(testModuleName)['default'];
+        }
 
-        ```javascript
-        var arr = ['a', 'b', 'c', 'd'];
+        if (Test && Test.adapter) {
+          Test.adapter.exception(error);
+          Logger['default'].error(error.stack);
+        } else {
+          throw error;
+        }
+      } else if (Ember['default'].onerror) {
+        Ember['default'].onerror(error);
+      } else {
+        Logger['default'].error(error.stack);
+      }
+    }
+  }
 
-        arr.objectAt(0);   // 'a'
-        arr.objectAt(3);   // 'd'
-        arr.objectAt(-1);  // undefined
-        arr.objectAt(4);   // undefined
-        arr.objectAt(5);   // undefined
-        ```
+  RSVP.on('error', onerrorDefault);
 
-        @method objectAt
-        @param {Number} idx The index of the item to return.
-        @return {*} item at index or undefined
-      */
-      objectAt: function(idx) {
-        if (idx < 0 || idx >= get(this, 'length')) {
-          return undefined;
-        }
+  exports['default'] = RSVP;
 
-        return get(this, idx);
-      },
+});
+enifed('ember-runtime/ext/string', ['ember-metal/core', 'ember-runtime/system/string'], function (Ember, string) {
 
-      /**
-        This returns the objects at the specified indexes, using `objectAt`.
+  'use strict';
 
-        ```javascript
-        var arr =Â ['a', 'b', 'c', 'd'];
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-        arr.objectsAt([0, 1, 2]);  // ['a', 'b', 'c']
-        arr.objectsAt([2, 3, 4]);  // ['c', 'd', undefined]
-        ```
+  var StringPrototype = String.prototype;
 
-        @method objectsAt
-        @param {Array} indexes An array of indexes of items to return.
-        @return {Array}
-       */
-      objectsAt: function(indexes) {
-        var self = this;
+  if (Ember['default'].EXTEND_PROTOTYPES === true || Ember['default'].EXTEND_PROTOTYPES.String) {
 
-        return map(indexes, function(idx) {
-          return self.objectAt(idx);
-        });
-      },
+    /**
+      See [Ember.String.fmt](/api/classes/Ember.String.html#method_fmt).
 
-      // overrides Ember.Enumerable version
-      nextObject: function(idx) {
-        return this.objectAt(idx);
-      },
+      @method fmt
+      @for String
+    */
+    StringPrototype.fmt = function () {
+      return string.fmt(this, arguments);
+    };
 
-      /**
-        This is the handler for the special array content property. If you get
-        this property, it will return this. If you set this property to a new
-        array, it will replace the current content.
+    /**
+      See [Ember.String.w](/api/classes/Ember.String.html#method_w).
 
-        This property overrides the default property defined in `Ember.Enumerable`.
+      @method w
+      @for String
+    */
+    StringPrototype.w = function () {
+      return string.w(this);
+    };
 
-        @property []
-        @return this
-      */
-      '[]': computed(function(key, value) {
-        if (value !== undefined) {
-          this.replace(0, get(this, 'length'), value);
-        }
+    /**
+      See [Ember.String.loc](/api/classes/Ember.String.html#method_loc).
 
-        return this;
-      }),
+      @method loc
+      @for String
+    */
+    StringPrototype.loc = function () {
+      return string.loc(this, arguments);
+    };
 
-      firstObject: computed(function() {
-        return this.objectAt(0);
-      }),
+    /**
+      See [Ember.String.camelize](/api/classes/Ember.String.html#method_camelize).
 
-      lastObject: computed(function() {
-        return this.objectAt(get(this, 'length') - 1);
-      }),
+      @method camelize
+      @for String
+    */
+    StringPrototype.camelize = function () {
+      return string.camelize(this);
+    };
 
-      // optimized version from Enumerable
-      contains: function(obj) {
-        return this.indexOf(obj) >= 0;
-      },
+    /**
+      See [Ember.String.decamelize](/api/classes/Ember.String.html#method_decamelize).
 
-      // Add any extra methods to Ember.Array that are native to the built-in Array.
-      /**
-        Returns a new array that is a slice of the receiver. This implementation
-        uses the observable array methods to retrieve the objects for the new
-        slice.
+      @method decamelize
+      @for String
+    */
+    StringPrototype.decamelize = function () {
+      return string.decamelize(this);
+    };
 
-        ```javascript
-        var arr = ['red', 'green', 'blue'];
+    /**
+      See [Ember.String.dasherize](/api/classes/Ember.String.html#method_dasherize).
 
-        arr.slice(0);       // ['red', 'green', 'blue']
-        arr.slice(0, 2);    // ['red', 'green']
-        arr.slice(1, 100);  // ['green', 'blue']
-        ```
+      @method dasherize
+      @for String
+    */
+    StringPrototype.dasherize = function () {
+      return string.dasherize(this);
+    };
 
-        @method slice
-        @param {Integer} beginIndex (Optional) index to begin slicing from.
-        @param {Integer} endIndex (Optional) index to end the slice at (but not included).
-        @return {Array} New array with specified slice
-      */
-      slice: function(beginIndex, endIndex) {
-        var ret = Ember.A();
-        var length = get(this, 'length');
+    /**
+      See [Ember.String.underscore](/api/classes/Ember.String.html#method_underscore).
 
-        if (isNone(beginIndex)) {
-          beginIndex = 0;
-        }
+      @method underscore
+      @for String
+    */
+    StringPrototype.underscore = function () {
+      return string.underscore(this);
+    };
 
-        if (isNone(endIndex) || (endIndex > length)) {
-          endIndex = length;
-        }
+    /**
+      See [Ember.String.classify](/api/classes/Ember.String.html#method_classify).
 
-        if (beginIndex < 0) {
-          beginIndex = length + beginIndex;
-        }
+      @method classify
+      @for String
+    */
+    StringPrototype.classify = function () {
+      return string.classify(this);
+    };
 
-        if (endIndex < 0) {
-          endIndex = length + endIndex;
-        }
+    /**
+      See [Ember.String.capitalize](/api/classes/Ember.String.html#method_capitalize).
 
-        while (beginIndex < endIndex) {
-          ret[ret.length] = this.objectAt(beginIndex++);
-        }
+      @method capitalize
+      @for String
+    */
+    StringPrototype.capitalize = function () {
+      return string.capitalize(this);
+    };
+  }
 
-        return ret;
-      },
+});
+enifed('ember-runtime/inject', ['exports', 'ember-metal/core', 'ember-metal/enumerable_utils', 'ember-metal/injected_property', 'ember-metal/keys'], function (exports, Ember, enumerable_utils, InjectedProperty, keys) {
 
-      /**
-        Returns the index of the given object's first occurrence.
-        If no `startAt` argument is given, the starting location to
-        search is 0. If it's negative, will count backward from
-        the end of the array. Returns -1 if no match is found.
+  'use strict';
 
-        ```javascript
-        var arr = ['a', 'b', 'c', 'd', 'a'];
-
-        arr.indexOf('a');       //  0
-        arr.indexOf('z');       // -1
-        arr.indexOf('a', 2);    //  4
-        arr.indexOf('a', -1);   //  4
-        arr.indexOf('b', 3);    // -1
-        arr.indexOf('a', 100);  // -1
-        ```
+  exports.createInjectionHelper = createInjectionHelper;
+  exports.validatePropertyInjections = validatePropertyInjections;
 
-        @method indexOf
-        @param {Object} object the item to search for
-        @param {Number} startAt optional starting location to search, default 0
-        @return {Number} index or -1 if not found
-      */
-      indexOf: function(object, startAt) {
-        var len = get(this, 'length');
-        var idx;
+  function inject() {
+    Ember['default'].assert("Injected properties must be created through helpers, see `" +
+                 keys['default'](inject).join("`, `") + "`");
+  }
 
-        if (startAt === undefined) {
-          startAt = 0;
-        }
+  // Dictionary of injection validations by type, added to by `createInjectionHelper`
+  var typeValidators = {};
 
-        if (startAt < 0) {
-          startAt += len;
-        }
+  /**
+    This method allows other Ember modules to register injection helpers for a
+    given container type. Helpers are exported to the `inject` namespace as the
+    container type itself.
 
-        for (idx = startAt; idx < len; idx++) {
-          if (this.objectAt(idx) === object) {
-            return idx;
-          }
-        }
+    @private
+    @method createInjectionHelper
+    @since 1.10.0
+    @for Ember
+    @param {String} type The container type the helper will inject
+    @param {Function} validator A validation callback that is executed at mixin-time
+  */
+  function createInjectionHelper(type, validator) {
+    typeValidators[type] = validator;
 
-        return -1;
-      },
+    inject[type] = function(name) {
+      return new InjectedProperty['default'](type, name);
+    };
+  }
 
-      /**
-        Returns the index of the given object's last occurrence.
-        If no `startAt` argument is given, the search starts from
-        the last position. If it's negative, will count backward
-        from the end of the array. Returns -1 if no match is found.
+  /**
+    Validation function that runs per-type validation functions once for each
+    injected type encountered.
 
-        ```javascript
-        var arr = ['a', 'b', 'c', 'd', 'a'];
-
-        arr.lastIndexOf('a');       //  4
-        arr.lastIndexOf('z');       // -1
-        arr.lastIndexOf('a', 2);    //  0
-        arr.lastIndexOf('a', -1);   //  4
-        arr.lastIndexOf('b', 3);    //  1
-        arr.lastIndexOf('a', 100);  //  4
-        ```
+    @private
+    @method validatePropertyInjections
+    @since 1.10.0
+    @for Ember
+    @param {Object} factory The factory object
+  */
+  function validatePropertyInjections(factory) {
+    var proto = factory.proto();
+    var types = [];
+    var key, desc, validator, i, l;
 
-        @method lastIndexOf
-        @param {Object} object the item to search for
-        @param {Number} startAt optional starting location to search, default 0
-        @return {Number} index or -1 if not found
-      */
-      lastIndexOf: function(object, startAt) {
-        var len = get(this, 'length');
-        var idx;
+    for (key in proto) {
+      desc = proto[key];
+      if (desc instanceof InjectedProperty['default'] && enumerable_utils.indexOf(types, desc.type) === -1) {
+        types.push(desc.type);
+      }
+    }
 
-        if (startAt === undefined || startAt >= len) {
-          startAt = len-1;
-        }
+    if (types.length) {
+      for (i = 0, l = types.length; i < l; i++) {
+        validator = typeValidators[types[i]];
 
-        if (startAt < 0) {
-          startAt += len;
+        if (typeof validator === 'function') {
+          validator(factory);
         }
+      }
+    }
 
-        for (idx = startAt; idx >= 0; idx--) {
-          if (this.objectAt(idx) === object) {
-            return idx;
-          }
-        }
+    return true;
+  }
 
-        return -1;
-      },
+  exports['default'] = inject;
 
-      // ..........................................................
-      // ARRAY OBSERVERS
-      //
+});
+enifed('ember-runtime/mixins/-proxy', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/utils', 'ember-metal/observer', 'ember-metal/property_events', 'ember-metal/computed', 'ember-metal/properties', 'ember-metal/mixin', 'ember-runtime/system/string'], function (exports, Ember, property_get, property_set, utils, observer, property_events, computed, properties, mixin, string) {
 
-      /**
-        Adds an array observer to the receiving array. The array observer object
-        normally must implement two methods:
-
-        * `arrayWillChange(observedObj, start, removeCount, addCount)` - This method will be
-          called just before the array is modified.
-        * `arrayDidChange(observedObj, start, removeCount, addCount)` - This method will be
-          called just after the array is modified.
-
-        Both callbacks will be passed the observed object, starting index of the
-        change as well a a count of the items to be removed and added. You can use
-        these callbacks to optionally inspect the array during the change, clear
-        caches, or do any other bookkeeping necessary.
-
-        In addition to passing a target, you can also include an options hash
-        which you can use to override the method names that will be invoked on the
-        target.
-
-        @method addArrayObserver
-        @param {Object} target The observer object.
-        @param {Hash} opts Optional hash of configuration options including
-          `willChange` and `didChange` option.
-        @return {Ember.Array} receiver
-      */
+  'use strict';
 
-      addArrayObserver: function(target, opts) {
-        return arrayObserversHelper(this, target, opts, addListener, false);
-      },
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-      /**
-        Removes an array observer from the object if the observer is current
-        registered. Calling this method multiple times with the same object will
-        have no effect.
-
-        @method removeArrayObserver
-        @param {Object} target The object observing the array.
-        @param {Hash} opts Optional hash of configuration options including
-          `willChange` and `didChange` option.
-        @return {Ember.Array} receiver
-      */
-      removeArrayObserver: function(target, opts) {
-        return arrayObserversHelper(this, target, opts, removeListener, true);
-      },
+  function contentPropertyWillChange(content, contentKey) {
+    var key = contentKey.slice(8); // remove "content."
+    if (key in this) { return; }  // if shadowed in proxy
+    property_events.propertyWillChange(this, key);
+  }
 
-      /**
-        Becomes true whenever the array currently has observers watching changes
-        on the array.
+  function contentPropertyDidChange(content, contentKey) {
+    var key = contentKey.slice(8); // remove "content."
+    if (key in this) { return; } // if shadowed in proxy
+    property_events.propertyDidChange(this, key);
+  }
 
-        @property {Boolean} hasArrayObservers
-      */
-      hasArrayObservers: computed(function() {
-        return hasListeners(this, '@array:change') || hasListeners(this, '@array:before');
-      }),
+  /**
+    `Ember.ProxyMixin` forwards all properties not defined by the proxy itself
+    to a proxied `content` object.  See Ember.ObjectProxy for more details.
 
-      /**
-        If you are implementing an object that supports `Ember.Array`, call this
-        method just before the array content changes to notify any observers and
-        invalidate any related properties. Pass the starting index of the change
-        as well as a delta of the amounts to change.
-
-        @method arrayContentWillChange
-        @param {Number} startIdx The starting index in the array that will change.
-        @param {Number} removeAmt The number of items that will be removed. If you
-          pass `null` assumes 0
-        @param {Number} addAmt The number of items that will be added. If you
-          pass `null` assumes 0.
-        @return {Ember.Array} receiver
-      */
-      arrayContentWillChange: function(startIdx, removeAmt, addAmt) {
-        var removing, lim;
+    @class ProxyMixin
+    @namespace Ember
+  */
+  exports['default'] = mixin.Mixin.create({
+    /**
+      The object whose properties will be forwarded.
+
+      @property content
+      @type Ember.Object
+      @default null
+    */
+    content: null,
+    _contentDidChange: mixin.observer('content', function() {
+      Ember['default'].assert("Can't set Proxy's content to itself", property_get.get(this, 'content') !== this);
+    }),
+
+    isTruthy: computed.computed.bool('content'),
+
+    _debugContainerKey: null,
+
+    willWatchProperty: function (key) {
+      var contentKey = 'content.' + key;
+      observer.addBeforeObserver(this, contentKey, null, contentPropertyWillChange);
+      observer.addObserver(this, contentKey, null, contentPropertyDidChange);
+    },
+
+    didUnwatchProperty: function (key) {
+      var contentKey = 'content.' + key;
+      observer.removeBeforeObserver(this, contentKey, null, contentPropertyWillChange);
+      observer.removeObserver(this, contentKey, null, contentPropertyDidChange);
+    },
+
+    unknownProperty: function (key) {
+      var content = property_get.get(this, 'content');
+      if (content) {
+        Ember['default'].deprecate(
+          string.fmt('You attempted to access `%@` from `%@`, but object proxying is deprecated. ' +
+              'Please use `model.%@` instead.', [key, this, key]),
+          !this.isController,
+          { url: 'http://emberjs.com/guides/deprecations/#toc_objectcontroller' }
+        );
+        return property_get.get(content, key);
+      }
+    },
+
+    setUnknownProperty: function (key, value) {
+      var m = utils.meta(this);
+      if (m.proto === this) {
+        // if marked as prototype then just defineProperty
+        // rather than delegate
+        properties.defineProperty(this, key, null, value);
+        return value;
+      }
 
-        // if no args are passed assume everything changes
-        if (startIdx === undefined) {
-          startIdx = 0;
-          removeAmt = addAmt = -1;
-        } else {
-          if (removeAmt === undefined) {
-            removeAmt = -1;
-          }
+      var content = property_get.get(this, 'content');
+      Ember['default'].assert(string.fmt("Cannot delegate set('%@', %@) to the 'content' property of" +
+                       " object proxy %@: its 'content' is undefined.", [key, value, this]), content);
 
-          if (addAmt === undefined) {
-            addAmt = -1;
-          }
-        }
+      Ember['default'].deprecate(
+        string.fmt('You attempted to set `%@` from `%@`, but object proxying is deprecated. ' +
+            'Please use `model.%@` instead.', [key, this, key]),
+        !this.isController,
+        { url: 'http://emberjs.com/guides/deprecations/#toc_objectcontroller' }
+      );
+      return property_set.set(content, key, value);
+    }
 
-        // Make sure the @each proxy is set up if anyone is observing @each
-        if (isWatching(this, '@each')) {
-          get(this, '@each');
-        }
+  });
 
-        sendEvent(this, '@array:before', [this, startIdx, removeAmt, addAmt]);
+});
+enifed('ember-runtime/mixins/action_handler', ['exports', 'ember-metal/merge', 'ember-metal/mixin', 'ember-metal/property_get', 'ember-metal/utils'], function (exports, merge, mixin, property_get, utils) {
 
-        if (startIdx >= 0 && removeAmt >= 0 && get(this, 'hasEnumerableObservers')) {
-          removing = [];
-          lim = startIdx + removeAmt;
+  'use strict';
 
-          for (var idx = startIdx; idx < lim; idx++) {
-            removing.push(this.objectAt(idx));
-          }
-        } else {
-          removing = removeAmt;
-        }
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
+  var ActionHandler = mixin.Mixin.create({
+    mergedProperties: ['_actions'],
 
-        this.enumerableContentWillChange(removing, addAmt);
+    /**
+      The collection of functions, keyed by name, available on this
+      `ActionHandler` as action targets.
 
-        return this;
-      },
+      These functions will be invoked when a matching `{{action}}` is triggered
+      from within a template and the application's current route is this route.
 
-      /**
-        If you are implementing an object that supports `Ember.Array`, call this
-        method just after the array content changes to notify any observers and
-        invalidate any related properties. Pass the starting index of the change
-        as well as a delta of the amounts to change.
-
-        @method arrayContentDidChange
-        @param {Number} startIdx The starting index in the array that did change.
-        @param {Number} removeAmt The number of items that were removed. If you
-          pass `null` assumes 0
-        @param {Number} addAmt The number of items that were added. If you
-          pass `null` assumes 0.
-        @return {Ember.Array} receiver
-      */
-      arrayContentDidChange: function(startIdx, removeAmt, addAmt) {
-        var adding, lim;
+      Actions can also be invoked from other parts of your application
+      via `ActionHandler#send`.
 
-        // if no args are passed assume everything changes
-        if (startIdx === undefined) {
-          startIdx = 0;
-          removeAmt = addAmt = -1;
-        } else {
-          if (removeAmt === undefined) {
-            removeAmt = -1;
+      The `actions` hash will inherit action handlers from
+      the `actions` hash defined on extended parent classes
+      or mixins rather than just replace the entire hash, e.g.:
+
+      ```js
+      App.CanDisplayBanner = Ember.Mixin.create({
+        actions: {
+          displayBanner: function(msg) {
+            // ...
           }
+        }
+      });
 
-          if (addAmt === undefined) {
-            addAmt = -1;
+      App.WelcomeRoute = Ember.Route.extend(App.CanDisplayBanner, {
+        actions: {
+          playMusic: function() {
+            // ...
           }
         }
+      });
 
-        if (startIdx >= 0 && addAmt >= 0 && get(this, 'hasEnumerableObservers')) {
-          adding = [];
-          lim = startIdx + addAmt;
+      // `WelcomeRoute`, when active, will be able to respond
+      // to both actions, since the actions hash is merged rather
+      // then replaced when extending mixins / parent classes.
+      this.send('displayBanner');
+      this.send('playMusic');
+      ```
+
+      Within a Controller, Route, View or Component's action handler,
+      the value of the `this` context is the Controller, Route, View or
+      Component object:
 
-          for (var idx = startIdx; idx < lim; idx++) {
-            adding.push(this.objectAt(idx));
+      ```js
+      App.SongRoute = Ember.Route.extend({
+        actions: {
+          myAction: function() {
+            this.controllerFor("song");
+            this.transitionTo("other.route");
+            ...
           }
-        } else {
-          adding = addAmt;
         }
+      });
+      ```
 
-        this.enumerableContentDidChange(removeAmt, adding);
-        sendEvent(this, '@array:change', [this, startIdx, removeAmt, addAmt]);
+      It is also possible to call `this._super.apply(this, arguments)` from within an
+      action handler if it overrides a handler defined on a parent
+      class or mixin:
 
-        var length = get(this, 'length');
-        var cachedFirst = cacheFor(this, 'firstObject');
-        var cachedLast = cacheFor(this, 'lastObject');
+      Take for example the following routes:
 
-        if (this.objectAt(0) !== cachedFirst) {
-          propertyWillChange(this, 'firstObject');
-          propertyDidChange(this, 'firstObject');
+      ```js
+      App.DebugRoute = Ember.Mixin.create({
+        actions: {
+          debugRouteInformation: function() {
+            console.debug("trololo");
+          }
         }
+      });
+
+      App.AnnoyingDebugRoute = Ember.Route.extend(App.DebugRoute, {
+        actions: {
+          debugRouteInformation: function() {
+            // also call the debugRouteInformation of mixed in App.DebugRoute
+            this._super.apply(this, arguments);
 
-        if (this.objectAt(length-1) !== cachedLast) {
-          propertyWillChange(this, 'lastObject');
-          propertyDidChange(this, 'lastObject');
+            // show additional annoyance
+            window.alert(...);
+          }
         }
+      });
+      ```
 
-        return this;
-      },
+      ## Bubbling
 
-      // ..........................................................
-      // ENUMERATED PROPERTIES
-      //
+      By default, an action will stop bubbling once a handler defined
+      on the `actions` hash handles it. To continue bubbling the action,
+      you must return `true` from the handler:
 
-      /**
-        Returns a special object that can be used to observe individual properties
-        on the array. Just get an equivalent property on this object and it will
-        return an enumerable that maps automatically to the named key on the
-        member objects.
+      ```js
+      App.Router.map(function() {
+        this.resource("album", function() {
+          this.route("song");
+        });
+      });
 
-        If you merely want to watch for any items being added or removed to the array,
-        use the `[]` property instead of `@each`.
+      App.AlbumRoute = Ember.Route.extend({
+        actions: {
+          startPlaying: function() {
+          }
+        }
+      });
 
-        @property @each
-      */
-      '@each': computed(function() {
-        if (!this.__each) {
-          // ES6TODO: GRRRRR
-          var EachProxy = requireModule('ember-runtime/system/each_proxy')['EachProxy'];
+      App.AlbumSongRoute = Ember.Route.extend({
+        actions: {
+          startPlaying: function() {
+            // ...
 
-          this.__each = new EachProxy(this);
+            if (actionShouldAlsoBeTriggeredOnParentRoute) {
+              return true;
+            }
+          }
         }
+      });
+      ```
 
-        return this.__each;
-      })
-    });
-  });
-enifed("ember-runtime/mixins/comparable",
-  ["ember-metal/mixin","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Mixin = __dependency1__.Mixin;
-    var required = __dependency1__.required;
-
-    /**
-    @module ember
-    @submodule ember-runtime
+      @property actions
+      @type Hash
+      @default null
     */
 
     /**
-      Implements some standard methods for comparing objects. Add this mixin to
-      any class you create that can compare its instances.
-
-      You should implement the `compare()` method.
+      Moves `actions` to `_actions` at extend time. Note that this currently
+      modifies the mixin themselves, which is technically dubious but
+      is practically of little consequence. This may change in the future.
 
-      @class Comparable
-      @namespace Ember
-      @since Ember 0.9
+      @private
+      @method willMergeMixin
     */
-    __exports__["default"] = Mixin.create({
+    willMergeMixin: function(props) {
+      var hashName;
 
-      /**
-        Override to return the result of the comparison of the two parameters. The
-        compare method should return:
+      if (!props._actions) {
+        Ember.assert("'actions' should not be a function", typeof(props.actions) !== 'function');
 
-        - `-1` if `a < b`
-        - `0` if `a == b`
-        - `1` if `a > b`
+        if (utils.typeOf(props.actions) === 'object') {
+          hashName = 'actions';
+        } else if (utils.typeOf(props.events) === 'object') {
+          Ember.deprecate('Action handlers contained in an `events` object are deprecated in favor' +
+                          ' of putting them in an `actions` object');
+          hashName = 'events';
+        }
 
-        Default implementation raises an exception.
+        if (hashName) {
+          props._actions = merge['default'](props._actions || {}, props[hashName]);
+        }
 
-        @method compare
-        @param a {Object} the first object to compare
-        @param b {Object} the second object to compare
-        @return {Integer} the result of the comparison
-      */
-      compare: required(Function)
-    });
-  });
-enifed("ember-runtime/mixins/controller",
-  ["ember-metal/mixin","ember-metal/computed","ember-runtime/mixins/action_handler","ember-runtime/mixins/controller_content_model_alias_deprecation","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    var Mixin = __dependency1__.Mixin;
-    var computed = __dependency2__.computed;
-    var ActionHandler = __dependency3__["default"];
-    var ControllerContentModelAliasDeprecation = __dependency4__["default"];
+        delete props[hashName];
+      }
+    },
 
     /**
-      `Ember.ControllerMixin` provides a standard interface for all classes that
-      compose Ember's controller layer: `Ember.Controller`,
-      `Ember.ArrayController`, and `Ember.ObjectController`.
+      Triggers a named action on the `ActionHandler`. Any parameters
+      supplied after the `actionName` string will be passed as arguments
+      to the action target function.
 
-      @class ControllerMixin
-      @namespace Ember
-      @uses Ember.ActionHandler
-    */
-    __exports__["default"] = Mixin.create(ActionHandler, ControllerContentModelAliasDeprecation, {
-      /* ducktype as a controller */
-      isController: true,
-
-      /**
-        The object to which actions from the view should be sent.
-
-        For example, when a Handlebars template uses the `{{action}}` helper,
-        it will attempt to send the action to the view's controller's `target`.
-
-        By default, the value of the target property is set to the router, and
-        is injected when a controller is instantiated. This injection is defined
-        in Ember.Application#buildContainer, and is applied as part of the
-        applications initialization process. It can also be set after a controller
-        has been instantiated, for instance when using the render helper in a
-        template, or when a controller is used as an `itemController`. In most
-        cases the `target` property will automatically be set to the logical
-        consumer of actions for the controller.
-
-        @property target
-        @default null
-      */
-      target: null,
+      If the `ActionHandler` has its `target` property set, actions may
+      bubble to the `target`. Bubbling happens when an `actionName` can
+      not be found in the `ActionHandler`'s `actions` hash or if the
+      action target function returns `true`.
 
-      container: null,
-
-      parentController: null,
-
-      store: null,
+      Example
 
-      /**
-        The controller's current model. When retrieving or modifying a controller's
-        model, this property should be used instead of the `content` property.
+      ```js
+      App.WelcomeRoute = Ember.Route.extend({
+        actions: {
+          playTheme: function() {
+             this.send('playMusic', 'theme.mp3');
+          },
+          playMusic: function(track) {
+            // ...
+          }
+        }
+      });
+      ```
 
-        @property model
-        @public
-       */
-      model: null,
+      @method send
+      @param {String} actionName The action to trigger
+      @param {*} context a context to send with the action
+    */
+    send: function(actionName) {
+      var args = [].slice.call(arguments, 1);
+      var target;
 
-      /**
-        @private
-       */
-      content: computed.alias('model')
+      if (this._actions && this._actions[actionName]) {
+        var shouldBubble = this._actions[actionName].apply(this, args) === true;
+        if (!shouldBubble) { return; }
+      }
 
-    });
+      if (target = property_get.get(this, 'target')) {
+        Ember.assert("The `target` for " + this + " (" + target +
+                     ") does not have a `send` method", typeof target.send === 'function');
+        target.send.apply(target, arguments);
+      }
+    }
   });
-enifed("ember-runtime/mixins/controller_content_model_alias_deprecation",
-  ["ember-metal/core","ember-metal/mixin","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.deprecate
-    var Mixin = __dependency2__.Mixin;
 
-    /**
-      The ControllerContentModelAliasDeprecation mixin is used to provide a useful
-      deprecation warning when specifying `content` directly on a `Ember.Controller`
-      (without also specifying `model`).
-
-      Ember versions prior to 1.7 used `model` as an alias of `content`, but due to
-      much confusion this alias was reversed (so `content` is now an alias of `model).
+  exports['default'] = ActionHandler;
 
-      This change reduces many caveats with model/content, and also sets a
-      simple ground rule: Never set a controllers content, rather always set
-      its model and ember will do the right thing.
+});
+enifed('ember-runtime/mixins/array', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/computed', 'ember-metal/is_none', 'ember-runtime/mixins/enumerable', 'ember-metal/enumerable_utils', 'ember-metal/mixin', 'ember-metal/property_events', 'ember-metal/events', 'ember-metal/watching'], function (exports, Ember, property_get, computed, isNone, Enumerable, enumerable_utils, mixin, property_events, events, watching) {
 
+  'use strict';
 
-      `Ember.ControllerContentModelAliasDeprecation` is used internally by Ember in
-      `Ember.Controller`.
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-      @class ControllerContentModelAliasDeprecation
-      @namespace Ember
-      @private
-      @since 1.7.0
-    */
-    __exports__["default"] = Mixin.create({
-      /**
-        @private
+  // ..........................................................
+  // HELPERS
+  //
+  function arrayObserversHelper(obj, target, opts, operation, notify) {
+    var willChange = (opts && opts.willChange) || 'arrayWillChange';
+    var didChange  = (opts && opts.didChange) || 'arrayDidChange';
+    var hasObservers = property_get.get(obj, 'hasArrayObservers');
 
-        Moves `content` to `model`  at extend time if a `model` is not also specified.
+    if (hasObservers === notify) {
+      property_events.propertyWillChange(obj, 'hasArrayObservers');
+    }
 
-        Note that this currently modifies the mixin themselves, which is technically
-        dubious but is practically of little consequence. This may change in the
-        future.
+    operation(obj, '@array:before', target, willChange);
+    operation(obj, '@array:change', target, didChange);
 
-        @method willMergeMixin
-        @since 1.4.0
-      */
-      willMergeMixin: function(props) {
-        // Calling super is only OK here since we KNOW that
-        // there is another Mixin loaded first.
-        this._super.apply(this, arguments);
+    if (hasObservers === notify) {
+      property_events.propertyDidChange(obj, 'hasArrayObservers');
+    }
 
-        var modelSpecified = !!props.model;
+    return obj;
+  }
 
-        if (props.content && !modelSpecified) {
-          props.model = props.content;
-          delete props['content'];
+  // ..........................................................
+  // ARRAY
+  //
+  /**
+    This mixin implements Observer-friendly Array-like behavior. It is not a
+    concrete implementation, but it can be used up by other classes that want
+    to appear like arrays.
+
+    For example, ArrayProxy and ArrayController are both concrete classes that can
+    be instantiated to implement array-like behavior. Both of these classes use
+    the Array Mixin by way of the MutableArray mixin, which allows observable
+    changes to be made to the underlying array.
+
+    Unlike `Ember.Enumerable,` this mixin defines methods specifically for
+    collections that provide index-ordered access to their contents. When you
+    are designing code that needs to accept any kind of Array-like object, you
+    should use these methods instead of Array primitives because these will
+    properly notify observers of changes to the array.
+
+    Although these methods are efficient, they do add a layer of indirection to
+    your application so it is a good idea to use them only when you need the
+    flexibility of using both true JavaScript arrays and "virtual" arrays such
+    as controllers and collections.
+
+    You can use the methods defined in this module to access and modify array
+    contents in a KVO-friendly way. You can also be notified whenever the
+    membership of an array changes by using `.observes('myArray.[]')`.
+
+    To support `Ember.Array` in your own class, you must override two
+    primitives to use it: `replace()` and `objectAt()`.
+
+    Note that the Ember.Array mixin also incorporates the `Ember.Enumerable`
+    mixin. All `Ember.Array`-like objects are also enumerable.
+
+    @class Array
+    @namespace Ember
+    @uses Ember.Enumerable
+    @since Ember 0.9.0
+  */
+  exports['default'] = mixin.Mixin.create(Enumerable['default'], {
 
-          Ember.deprecate('Do not specify `content` on a Controller, use `model` instead.', false);
-        }
-      }
-    });
-  });
-enifed("ember-runtime/mixins/copyable",
-  ["ember-metal/property_get","ember-metal/mixin","ember-runtime/mixins/freezable","ember-runtime/system/string","ember-metal/error","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-runtime
-    */
-
-
-    var get = __dependency1__.get;
-    var required = __dependency2__.required;
-    var Freezable = __dependency3__.Freezable;
-    var Mixin = __dependency2__.Mixin;
-    var fmt = __dependency4__.fmt;
-    var EmberError = __dependency5__["default"];
+      Your array must support the `length` property. Your replace methods should
+      set this property whenever it changes.
 
+      @property {Number} length
+    */
+    length: mixin.required(),
 
     /**
-      Implements some standard methods for copying an object. Add this mixin to
-      any object you create that can create a copy of itself. This mixin is
-      added automatically to the built-in array.
+      Returns the object at the given `index`. If the given `index` is negative
+      or is greater or equal than the array length, returns `undefined`.
+
+      This is one of the primitives you must implement to support `Ember.Array`.
+      If your object supports retrieving the value of an array item using `get()`
+      (i.e. `myArray.get(0)`), then you do not need to implement this method
+      yourself.
 
-      You should generally implement the `copy()` method to return a copy of the
-      receiver.
+      ```javascript
+      var arr = ['a', 'b', 'c', 'd'];
 
-      Note that `frozenCopy()` will only work if you also implement
-      `Ember.Freezable`.
+      arr.objectAt(0);   // 'a'
+      arr.objectAt(3);   // 'd'
+      arr.objectAt(-1);  // undefined
+      arr.objectAt(4);   // undefined
+      arr.objectAt(5);   // undefined
+      ```
 
-      @class Copyable
-      @namespace Ember
-      @since Ember 0.9
+      @method objectAt
+      @param {Number} idx The index of the item to return.
+      @return {*} item at index or undefined
     */
-    __exports__["default"] = Mixin.create({
-      /**
-        Override to return a copy of the receiver. Default implementation raises
-        an exception.
+    objectAt: function(idx) {
+      if (idx < 0 || idx >= property_get.get(this, 'length')) {
+        return undefined;
+      }
 
-        @method copy
-        @param {Boolean} deep if `true`, a deep copy of the object should be made
-        @return {Object} copy of receiver
-      */
-      copy: required(Function),
+      return property_get.get(this, idx);
+    },
 
-      /**
-        If the object implements `Ember.Freezable`, then this will return a new
-        copy if the object is not frozen and the receiver if the object is frozen.
+    /**
+      This returns the objects at the specified indexes, using `objectAt`.
 
-        Raises an exception if you try to call this method on a object that does
-        not support freezing.
+      ```javascript
+      var arr = ['a', 'b', 'c', 'd'];
 
-        You should use this method whenever you want a copy of a freezable object
-        since a freezable object can simply return itself without actually
-        consuming more memory.
+      arr.objectsAt([0, 1, 2]);  // ['a', 'b', 'c']
+      arr.objectsAt([2, 3, 4]);  // ['c', 'd', undefined]
+      ```
 
-        @method frozenCopy
-        @return {Object} copy of receiver or receiver
-      */
-      frozenCopy: function() {
-        if (Freezable && Freezable.detect(this)) {
-          return get(this, 'isFrozen') ? this : this.copy().freeze();
-        } else {
-          throw new EmberError(fmt("%@ does not support freezing", [this]));
-        }
-      }
-    });
-  });
-enifed("ember-runtime/mixins/deferred",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/mixin","ember-metal/computed","ember-runtime/ext/rsvp","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.FEATURES, Ember.Test
-    var get = __dependency2__.get;
-    var Mixin = __dependency3__.Mixin;
-    var computed = __dependency4__.computed;
-    var RSVP = __dependency5__["default"];
+      @method objectsAt
+      @param {Array} indexes An array of indexes of items to return.
+      @return {Array}
+     */
+    objectsAt: function(indexes) {
+      var self = this;
 
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
+      return enumerable_utils.map(indexes, function(idx) {
+        return self.objectAt(idx);
+      });
+    },
 
+    // overrides Ember.Enumerable version
+    nextObject: function(idx) {
+      return this.objectAt(idx);
+    },
 
     /**
-      @class Deferred
-      @namespace Ember
-     */
-    __exports__["default"] = Mixin.create({
-      /**
-        Add handlers to be called when the Deferred object is resolved or rejected.
-
-        @method then
-        @param {Function} resolve a callback function to be called when done
-        @param {Function} reject  a callback function to be called when failed
-      */
-      then: function(resolve, reject, label) {
-        var deferred, promise, entity;
-
-        entity = this;
-        deferred = get(this, '_deferred');
-        promise = deferred.promise;
+      This is the handler for the special array content property. If you get
+      this property, it will return this. If you set this property to a new
+      array, it will replace the current content.
 
-        function fulfillmentHandler(fulfillment) {
-          if (fulfillment === promise) {
-            return resolve(entity);
-          } else {
-            return resolve(fulfillment);
-          }
-        }
+      This property overrides the default property defined in `Ember.Enumerable`.
 
-        return promise.then(resolve && fulfillmentHandler, reject, label);
-      },
+      @property []
+      @return this
+    */
+    '[]': computed.computed(function(key, value) {
+      if (value !== undefined) {
+        this.replace(0, property_get.get(this, 'length'), value);
+      }
 
-      /**
-        Resolve a Deferred object and call any `doneCallbacks` with the given args.
+      return this;
+    }),
 
-        @method resolve
-      */
-      resolve: function(value) {
-        var deferred, promise;
+    firstObject: computed.computed(function() {
+      return this.objectAt(0);
+    }),
 
-        deferred = get(this, '_deferred');
-        promise = deferred.promise;
+    lastObject: computed.computed(function() {
+      return this.objectAt(property_get.get(this, 'length') - 1);
+    }),
 
-        if (value === this) {
-          deferred.resolve(promise);
-        } else {
-          deferred.resolve(value);
-        }
-      },
+    // optimized version from Enumerable
+    contains: function(obj) {
+      return this.indexOf(obj) >= 0;
+    },
 
-      /**
-        Reject a Deferred object and call any `failCallbacks` with the given args.
+    // Add any extra methods to Ember.Array that are native to the built-in Array.
+    /**
+      Returns a new array that is a slice of the receiver. This implementation
+      uses the observable array methods to retrieve the objects for the new
+      slice.
 
-        @method reject
-      */
-      reject: function(value) {
-        get(this, '_deferred').reject(value);
-      },
+      ```javascript
+      var arr = ['red', 'green', 'blue'];
 
-      _deferred: computed(function() {
-        Ember.deprecate('Usage of Ember.DeferredMixin or Ember.Deferred is deprecated.', this._suppressDeferredDeprecation, { url: 'http://emberjs.com/guides/deprecations/#toc_deprecate-ember-deferredmixin-and-ember-deferred' });
+      arr.slice(0);       // ['red', 'green', 'blue']
+      arr.slice(0, 2);    // ['red', 'green']
+      arr.slice(1, 100);  // ['green', 'blue']
+      ```
 
-        return RSVP.defer('Ember: DeferredMixin - ' + this);
-      })
-    });
-  });
-enifed("ember-runtime/mixins/enumerable",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/mixin","ember-metal/enumerable_utils","ember-metal/computed","ember-metal/property_events","ember-metal/events","ember-runtime/compare","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-runtime
+      @method slice
+      @param {Integer} beginIndex (Optional) index to begin slicing from.
+      @param {Integer} endIndex (Optional) index to end the slice at (but not included).
+      @return {Array} New array with specified slice
     */
+    slice: function(beginIndex, endIndex) {
+      var ret = Ember['default'].A();
+      var length = property_get.get(this, 'length');
 
-    // ..........................................................
-    // HELPERS
-    //
+      if (isNone['default'](beginIndex)) {
+        beginIndex = 0;
+      }
 
-    var Ember = __dependency1__["default"];
-    var get = __dependency2__.get;
-    var set = __dependency3__.set;
-    var apply = __dependency4__.apply;
-    var Mixin = __dependency5__.Mixin;
-    var required = __dependency5__.required;
-    var aliasMethod = __dependency5__.aliasMethod;
-    var indexOf = __dependency6__.indexOf;
-    var computed = __dependency7__.computed;
-    var propertyWillChange = __dependency8__.propertyWillChange;
-    var propertyDidChange = __dependency8__.propertyDidChange;
-    var addListener = __dependency9__.addListener;
-    var removeListener = __dependency9__.removeListener;
-    var sendEvent = __dependency9__.sendEvent;
-    var hasListeners = __dependency9__.hasListeners;
-    var compare = __dependency10__["default"];
-
-    var a_slice = Array.prototype.slice;
-
-    var contexts = [];
-
-    function popCtx() {
-      return contexts.length === 0 ? {} : contexts.pop();
-    }
-
-    function pushCtx(ctx) {
-      contexts.push(ctx);
-      return null;
-    }
+      if (isNone['default'](endIndex) || (endIndex > length)) {
+        endIndex = length;
+      }
 
-    function iter(key, value) {
-      var valueProvided = arguments.length === 2;
+      if (beginIndex < 0) {
+        beginIndex = length + beginIndex;
+      }
 
-      function i(item) {
-        var cur = get(item, key);
-        return valueProvided ? value === cur : !!cur;
+      if (endIndex < 0) {
+        endIndex = length + endIndex;
       }
 
-      return i;
-    }
+      while (beginIndex < endIndex) {
+        ret[ret.length] = this.objectAt(beginIndex++);
+      }
 
-    /**
-      This mixin defines the common interface implemented by enumerable objects
-      in Ember. Most of these methods follow the standard Array iteration
-      API defined up to JavaScript 1.8 (excluding language-specific features that
-      cannot be emulated in older versions of JavaScript).
+      return ret;
+    },
 
-      This mixin is applied automatically to the Array class on page load, so you
-      can use any of these methods on simple arrays. If Array already implements
-      one of these methods, the mixin will not override them.
+    /**
+      Returns the index of the given object's first occurrence.
+      If no `startAt` argument is given, the starting location to
+      search is 0. If it's negative, will count backward from
+      the end of the array. Returns -1 if no match is found.
 
-      ## Writing Your Own Enumerable
+      ```javascript
+      var arr = ['a', 'b', 'c', 'd', 'a'];
 
-      To make your own custom class enumerable, you need two items:
+      arr.indexOf('a');       //  0
+      arr.indexOf('z');       // -1
+      arr.indexOf('a', 2);    //  4
+      arr.indexOf('a', -1);   //  4
+      arr.indexOf('b', 3);    // -1
+      arr.indexOf('a', 100);  // -1
+      ```
 
-      1. You must have a length property. This property should change whenever
-         the number of items in your enumerable object changes. If you use this
-         with an `Ember.Object` subclass, you should be sure to change the length
-         property using `set().`
+      @method indexOf
+      @param {Object} object the item to search for
+      @param {Number} startAt optional starting location to search, default 0
+      @return {Number} index or -1 if not found
+    */
+    indexOf: function(object, startAt) {
+      var len = property_get.get(this, 'length');
+      var idx;
 
-      2. You must implement `nextObject().` See documentation.
+      if (startAt === undefined) {
+        startAt = 0;
+      }
 
-      Once you have these two methods implemented, apply the `Ember.Enumerable` mixin
-      to your class and you will be able to enumerate the contents of your object
-      like any other collection.
+      if (startAt < 0) {
+        startAt += len;
+      }
 
-      ## Using Ember Enumeration with Other Libraries
+      for (idx = startAt; idx < len; idx++) {
+        if (this.objectAt(idx) === object) {
+          return idx;
+        }
+      }
 
-      Many other libraries provide some kind of iterator or enumeration like
-      facility. This is often where the most common API conflicts occur.
-      Ember's API is designed to be as friendly as possible with other
-      libraries by implementing only methods that mostly correspond to the
-      JavaScript 1.8 API.
+      return -1;
+    },
 
-      @class Enumerable
-      @namespace Ember
-      @since Ember 0.9
-    */
-    __exports__["default"] = Mixin.create({
+    /**
+      Returns the index of the given object's last occurrence.
+      If no `startAt` argument is given, the search starts from
+      the last position. If it's negative, will count backward
+      from the end of the array. Returns -1 if no match is found.
 
-      /**
-        Implement this method to make your class enumerable.
-
-        This method will be call repeatedly during enumeration. The index value
-        will always begin with 0 and increment monotonically. You don't have to
-        rely on the index value to determine what object to return, but you should
-        always check the value and start from the beginning when you see the
-        requested index is 0.
-
-        The `previousObject` is the object that was returned from the last call
-        to `nextObject` for the current iteration. This is a useful way to
-        manage iteration if you are tracing a linked list, for example.
-
-        Finally the context parameter will always contain a hash you can use as
-        a "scratchpad" to maintain any other state you need in order to iterate
-        properly. The context object is reused and is not reset between
-        iterations so make sure you setup the context with a fresh state whenever
-        the index parameter is 0.
-
-        Generally iterators will continue to call `nextObject` until the index
-        reaches the your current length-1. If you run out of data before this
-        time for some reason, you should simply return undefined.
-
-        The default implementation of this method simply looks up the index.
-        This works great on any Array-like objects.
-
-        @method nextObject
-        @param {Number} index the current index of the iteration
-        @param {Object} previousObject the value returned by the last call to
-          `nextObject`.
-        @param {Object} context a context object you can use to maintain state.
-        @return {Object} the next object in the iteration or undefined
-      */
-      nextObject: required(Function),
+      ```javascript
+      var arr = ['a', 'b', 'c', 'd', 'a'];
 
-      /**
-        Helper method returns the first object from a collection. This is usually
-        used by bindings and other parts of the framework to extract a single
-        object if the enumerable contains only one item.
+      arr.lastIndexOf('a');       //  4
+      arr.lastIndexOf('z');       // -1
+      arr.lastIndexOf('a', 2);    //  0
+      arr.lastIndexOf('a', -1);   //  4
+      arr.lastIndexOf('b', 3);    //  1
+      arr.lastIndexOf('a', 100);  //  4
+      ```
 
-        If you override this method, you should implement it so that it will
-        always return the same value each time it is called. If your enumerable
-        contains only one object, this method should always return that object.
-        If your enumerable is empty, this method should return `undefined`.
+      @method lastIndexOf
+      @param {Object} object the item to search for
+      @param {Number} startAt optional starting location to search, default 0
+      @return {Number} index or -1 if not found
+    */
+    lastIndexOf: function(object, startAt) {
+      var len = property_get.get(this, 'length');
+      var idx;
 
-        ```javascript
-        var arr = ['a', 'b', 'c'];
-        arr.get('firstObject');  // 'a'
+      if (startAt === undefined || startAt >= len) {
+        startAt = len-1;
+      }
 
-        var arr = [];
-        arr.get('firstObject');  // undefined
-        ```
+      if (startAt < 0) {
+        startAt += len;
+      }
 
-        @property firstObject
-        @return {Object} the object or undefined
-      */
-      firstObject: computed('[]', function() {
-        if (get(this, 'length') === 0) {
-          return undefined;
+      for (idx = startAt; idx >= 0; idx--) {
+        if (this.objectAt(idx) === object) {
+          return idx;
         }
+      }
 
-        // handle generic enumerables
-        var context = popCtx();
-        var ret = this.nextObject(0, null, context);
+      return -1;
+    },
 
-        pushCtx(context);
+    // ..........................................................
+    // ARRAY OBSERVERS
+    //
 
-        return ret;
-      }),
+    /**
+      Adds an array observer to the receiving array. The array observer object
+      normally must implement two methods:
 
-      /**
-        Helper method returns the last object from a collection. If your enumerable
-        contains only one object, this method should always return that object.
-        If your enumerable is empty, this method should return `undefined`.
+      * `arrayWillChange(observedObj, start, removeCount, addCount)` - This method will be
+        called just before the array is modified.
+      * `arrayDidChange(observedObj, start, removeCount, addCount)` - This method will be
+        called just after the array is modified.
 
-        ```javascript
-        var arr = ['a', 'b', 'c'];
-        arr.get('lastObject');  // 'c'
+      Both callbacks will be passed the observed object, starting index of the
+      change as well a a count of the items to be removed and added. You can use
+      these callbacks to optionally inspect the array during the change, clear
+      caches, or do any other bookkeeping necessary.
 
-        var arr = [];
-        arr.get('lastObject');  // undefined
-        ```
+      In addition to passing a target, you can also include an options hash
+      which you can use to override the method names that will be invoked on the
+      target.
 
-        @property lastObject
-        @return {Object} the last object or undefined
-      */
-      lastObject: computed('[]', function() {
-        var len = get(this, 'length');
+      @method addArrayObserver
+      @param {Object} target The observer object.
+      @param {Hash} opts Optional hash of configuration options including
+        `willChange` and `didChange` option.
+      @return {Ember.Array} receiver
+    */
 
-        if (len === 0) {
-          return undefined;
-        }
+    addArrayObserver: function(target, opts) {
+      return arrayObserversHelper(this, target, opts, events.addListener, false);
+    },
+
+    /**
+      Removes an array observer from the object if the observer is current
+      registered. Calling this method multiple times with the same object will
+      have no effect.
 
-        var context = popCtx();
-        var idx = 0;
-        var last = null;
-        var cur;
+      @method removeArrayObserver
+      @param {Object} target The object observing the array.
+      @param {Hash} opts Optional hash of configuration options including
+        `willChange` and `didChange` option.
+      @return {Ember.Array} receiver
+    */
+    removeArrayObserver: function(target, opts) {
+      return arrayObserversHelper(this, target, opts, events.removeListener, true);
+    },
 
-        do {
-          last = cur;
-          cur = this.nextObject(idx++, last, context);
-        } while (cur !== undefined);
+    /**
+      Becomes true whenever the array currently has observers watching changes
+      on the array.
 
-        pushCtx(context);
+      @property {Boolean} hasArrayObservers
+    */
+    hasArrayObservers: computed.computed(function() {
+      return events.hasListeners(this, '@array:change') || events.hasListeners(this, '@array:before');
+    }),
 
-        return last;
-      }),
+    /**
+      If you are implementing an object that supports `Ember.Array`, call this
+      method just before the array content changes to notify any observers and
+      invalidate any related properties. Pass the starting index of the change
+      as well as a delta of the amounts to change.
 
-      /**
-        Returns `true` if the passed object can be found in the receiver. The
-        default version will iterate through the enumerable until the object
-        is found. You may want to override this with a more efficient version.
+      @method arrayContentWillChange
+      @param {Number} startIdx The starting index in the array that will change.
+      @param {Number} removeAmt The number of items that will be removed. If you
+        pass `null` assumes 0
+      @param {Number} addAmt The number of items that will be added. If you
+        pass `null` assumes 0.
+      @return {Ember.Array} receiver
+    */
+    arrayContentWillChange: function(startIdx, removeAmt, addAmt) {
+      var removing, lim;
 
-        ```javascript
-        var arr = ['a', 'b', 'c'];
+      // if no args are passed assume everything changes
+      if (startIdx === undefined) {
+        startIdx = 0;
+        removeAmt = addAmt = -1;
+      } else {
+        if (removeAmt === undefined) {
+          removeAmt = -1;
+        }
 
-        arr.contains('a'); // true
-        arr.contains('z'); // false
-        ```
+        if (addAmt === undefined) {
+          addAmt = -1;
+        }
+      }
 
-        @method contains
-        @param {Object} obj The object to search for.
-        @return {Boolean} `true` if object is found in enumerable.
-      */
-      contains: function(obj) {
-        var found = this.find(function(item) {
-          return item === obj;
-        });
-        
-        return found !== undefined;
-      },
+      // Make sure the @each proxy is set up if anyone is observing @each
+      if (watching.isWatching(this, '@each')) {
+        property_get.get(this, '@each');
+      }
 
-      /**
-        Iterates through the enumerable, calling the passed function on each
-        item. This method corresponds to the `forEach()` method defined in
-        JavaScript 1.6.
+      events.sendEvent(this, '@array:before', [this, startIdx, removeAmt, addAmt]);
 
-        The callback method you provide should have the following signature (all
-        parameters are optional):
+      if (startIdx >= 0 && removeAmt >= 0 && property_get.get(this, 'hasEnumerableObservers')) {
+        removing = [];
+        lim = startIdx + removeAmt;
 
-        ```javascript
-        function(item, index, enumerable);
-        ```
+        for (var idx = startIdx; idx < lim; idx++) {
+          removing.push(this.objectAt(idx));
+        }
+      } else {
+        removing = removeAmt;
+      }
 
-        - `item` is the current item in the iteration.
-        - `index` is the current index in the iteration.
-        - `enumerable` is the enumerable object itself.
+      this.enumerableContentWillChange(removing, addAmt);
 
-        Note that in addition to a callback, you can also pass an optional target
-        object that will be set as `this` on the context. This is a good way
-        to give your iterator function access to the current object.
+      return this;
+    },
 
-        @method forEach
-        @param {Function} callback The callback to execute
-        @param {Object} [target] The target object to use
-        @return {Object} receiver
-      */
-      forEach: function(callback, target) {
-        if (typeof callback !== 'function') {
-          throw new TypeError();
-        }
+    /**
+      If you are implementing an object that supports `Ember.Array`, call this
+      method just after the array content changes to notify any observers and
+      invalidate any related properties. Pass the starting index of the change
+      as well as a delta of the amounts to change.
 
-        var context = popCtx();
-        var len = get(this, 'length');
-        var last = null;
+      @method arrayContentDidChange
+      @param {Number} startIdx The starting index in the array that did change.
+      @param {Number} removeAmt The number of items that were removed. If you
+        pass `null` assumes 0
+      @param {Number} addAmt The number of items that were added. If you
+        pass `null` assumes 0.
+      @return {Ember.Array} receiver
+    */
+    arrayContentDidChange: function(startIdx, removeAmt, addAmt) {
+      var adding, lim;
 
-        if (target === undefined) {
-          target = null;
+      // if no args are passed assume everything changes
+      if (startIdx === undefined) {
+        startIdx = 0;
+        removeAmt = addAmt = -1;
+      } else {
+        if (removeAmt === undefined) {
+          removeAmt = -1;
         }
 
-        for(var idx = 0; idx < len; idx++) {
-          var next = this.nextObject(idx, last, context) ;
-          callback.call(target, next, idx, this);
-          last = next ;
+        if (addAmt === undefined) {
+          addAmt = -1;
         }
+      }
 
-        last = null ;
-        context = pushCtx(context);
-
-        return this ;
-      },
+      if (startIdx >= 0 && addAmt >= 0 && property_get.get(this, 'hasEnumerableObservers')) {
+        adding = [];
+        lim = startIdx + addAmt;
 
-      /**
-        Alias for `mapBy`
+        for (var idx = startIdx; idx < lim; idx++) {
+          adding.push(this.objectAt(idx));
+        }
+      } else {
+        adding = addAmt;
+      }
 
-        @method getEach
-        @param {String} key name of the property
-        @return {Array} The mapped array.
-      */
-      getEach: function(key) {
-        return this.mapBy(key);
-      },
+      this.enumerableContentDidChange(removeAmt, adding);
+      events.sendEvent(this, '@array:change', [this, startIdx, removeAmt, addAmt]);
 
-      /**
-        Sets the value on the named property for each member. This is more
-        efficient than using other methods defined on this helper. If the object
-        implements Ember.Observable, the value will be changed to `set(),` otherwise
-        it will be set directly. `null` objects are skipped.
-
-        @method setEach
-        @param {String} key The key to set
-        @param {Object} value The object to set
-        @return {Object} receiver
-      */
-      setEach: function(key, value) {
-        return this.forEach(function(item) {
-          set(item, key, value);
-        });
-      },
+      var length = property_get.get(this, 'length');
+      var cachedFirst = computed.cacheFor(this, 'firstObject');
+      var cachedLast = computed.cacheFor(this, 'lastObject');
 
-      /**
-        Maps all of the items in the enumeration to another value, returning
-        a new array. This method corresponds to `map()` defined in JavaScript 1.6.
+      if (this.objectAt(0) !== cachedFirst) {
+        property_events.propertyWillChange(this, 'firstObject');
+        property_events.propertyDidChange(this, 'firstObject');
+      }
 
-        The callback method you provide should have the following signature (all
-        parameters are optional):
+      if (this.objectAt(length-1) !== cachedLast) {
+        property_events.propertyWillChange(this, 'lastObject');
+        property_events.propertyDidChange(this, 'lastObject');
+      }
 
-        ```javascript
-        function(item, index, enumerable);
-        ```
+      return this;
+    },
 
-        - `item` is the current item in the iteration.
-        - `index` is the current index in the iteration.
-        - `enumerable` is the enumerable object itself.
+    // ..........................................................
+    // ENUMERATED PROPERTIES
+    //
 
-        It should return the mapped value.
+    /**
+      Returns a special object that can be used to observe individual properties
+      on the array. Just get an equivalent property on this object and it will
+      return an enumerable that maps automatically to the named key on the
+      member objects.
 
-        Note that in addition to a callback, you can also pass an optional target
-        object that will be set as `this` on the context. This is a good way
-        to give your iterator function access to the current object.
+      If you merely want to watch for any items being added or removed to the array,
+      use the `[]` property instead of `@each`.
 
-        @method map
-        @param {Function} callback The callback to execute
-        @param {Object} [target] The target object to use
-        @return {Array} The mapped array.
-      */
-      map: function(callback, target) {
-        var ret = Ember.A();
+      @property @each
+    */
+    '@each': computed.computed(function() {
+      if (!this.__each) {
+        // ES6TODO: GRRRRR
+        var EachProxy = requireModule('ember-runtime/system/each_proxy')['EachProxy'];
 
-        this.forEach(function(x, idx, i) {
-          ret[idx] = callback.call(target, x, idx,i);
-        });
+        this.__each = new EachProxy(this);
+      }
 
-        return ret ;
-      },
+      return this.__each;
+    })
+  });
 
-      /**
-        Similar to map, this specialized function returns the value of the named
-        property on all items in the enumeration.
+});
+enifed('ember-runtime/mixins/comparable', ['exports', 'ember-metal/mixin'], function (exports, mixin) {
 
-        @method mapBy
-        @param {String} key name of the property
-        @return {Array} The mapped array.
-      */
-      mapBy: function(key) {
-        return this.map(function(next) {
-          return get(next, key);
-        });
-      },
+  'use strict';
 
-      /**
-        Similar to map, this specialized function returns the value of the named
-        property on all items in the enumeration.
+  exports['default'] = mixin.Mixin.create({
 
-        @method mapProperty
-        @param {String} key name of the property
-        @return {Array} The mapped array.
-        @deprecated Use `mapBy` instead
-      */
+    /**
+      Override to return the result of the comparison of the two parameters. The
+      compare method should return:
 
-      mapProperty: aliasMethod('mapBy'),
+      - `-1` if `a < b`
+      - `0` if `a == b`
+      - `1` if `a > b`
 
-      /**
-        Returns an array with all of the items in the enumeration that the passed
-        function returns true for. This method corresponds to `filter()` defined in
-        JavaScript 1.6.
+      Default implementation raises an exception.
 
-        The callback method you provide should have the following signature (all
-        parameters are optional):
+      @method compare
+      @param a {Object} the first object to compare
+      @param b {Object} the second object to compare
+      @return {Integer} the result of the comparison
+    */
+    compare: mixin.required(Function)
+  });
 
-        ```javascript
-        function(item, index, enumerable);
-        ```
+});
+enifed('ember-runtime/mixins/controller', ['exports', 'ember-metal/mixin', 'ember-metal/alias', 'ember-runtime/mixins/action_handler', 'ember-runtime/mixins/controller_content_model_alias_deprecation'], function (exports, mixin, alias, ActionHandler, ControllerContentModelAliasDeprecation) {
 
-        - `item` is the current item in the iteration.
-        - `index` is the current index in the iteration.
-        - `enumerable` is the enumerable object itself.
+  'use strict';
 
-        It should return `true` to include the item in the results, `false`
-        otherwise.
+  exports['default'] = mixin.Mixin.create(ActionHandler['default'], ControllerContentModelAliasDeprecation['default'], {
+    /* ducktype as a controller */
+    isController: true,
 
-        Note that in addition to a callback, you can also pass an optional target
-        object that will be set as `this` on the context. This is a good way
-        to give your iterator function access to the current object.
+    /**
+      The object to which actions from the view should be sent.
 
-        @method filter
-        @param {Function} callback The callback to execute
-        @param {Object} [target] The target object to use
-        @return {Array} A filtered array.
-      */
-      filter: function(callback, target) {
-        var ret = Ember.A();
+      For example, when a Handlebars template uses the `{{action}}` helper,
+      it will attempt to send the action to the view's controller's `target`.
 
-        this.forEach(function(x, idx, i) {
-          if (callback.call(target, x, idx, i)) {
-            ret.push(x);
-          }
-        });
+      By default, the value of the target property is set to the router, and
+      is injected when a controller is instantiated. This injection is defined
+      in Ember.Application#buildContainer, and is applied as part of the
+      applications initialization process. It can also be set after a controller
+      has been instantiated, for instance when using the render helper in a
+      template, or when a controller is used as an `itemController`. In most
+      cases the `target` property will automatically be set to the logical
+      consumer of actions for the controller.
 
-        return ret ;
-      },
+      @property target
+      @default null
+    */
+    target: null,
 
-      /**
-        Returns an array with all of the items in the enumeration where the passed
-        function returns false for. This method is the inverse of filter().
+    container: null,
 
-        The callback method you provide should have the following signature (all
-        parameters are optional):
+    parentController: null,
 
-        ```javascript
-        function(item, index, enumerable);
-        ```
+    store: null,
 
-        - *item* is the current item in the iteration.
-        - *index* is the current index in the iteration
-        - *enumerable* is the enumerable object itself.
+    /**
+      The controller's current model. When retrieving or modifying a controller's
+      model, this property should be used instead of the `content` property.
 
-        It should return the a falsey value to include the item in the results.
+      @property model
+      @public
+     */
+    model: null,
 
-        Note that in addition to a callback, you can also pass an optional target
-        object that will be set as "this" on the context. This is a good way
-        to give your iterator function access to the current object.
+    /**
+      @private
+     */
+    content: alias['default']('model')
 
-        @method reject
-        @param {Function} callback The callback to execute
-        @param {Object} [target] The target object to use
-        @return {Array} A rejected array.
-       */
-      reject: function(callback, target) {
-        return this.filter(function() {
-          return !(apply(target, callback, arguments));
-        });
-      },
+  });
 
-      /**
-        Returns an array with just the items with the matched property. You
-        can pass an optional second argument with the target value. Otherwise
-        this will match any property that evaluates to `true`.
-
-        @method filterBy
-        @param {String} key the property to test
-        @param {*} [value] optional value to test against.
-        @return {Array} filtered array
-      */
-      filterBy: function(key, value) {
-        return this.filter(apply(this, iter, arguments));
-      },
+});
+enifed('ember-runtime/mixins/controller_content_model_alias_deprecation', ['exports', 'ember-metal/core', 'ember-metal/mixin'], function (exports, Ember, mixin) {
 
-      /**
-        Returns an array with just the items with the matched property. You
-        can pass an optional second argument with the target value. Otherwise
-        this will match any property that evaluates to `true`.
-
-        @method filterProperty
-        @param {String} key the property to test
-        @param {String} [value] optional value to test against.
-        @return {Array} filtered array
-        @deprecated Use `filterBy` instead
-      */
-      filterProperty: aliasMethod('filterBy'),
+  'use strict';
 
-      /**
-        Returns an array with the items that do not have truthy values for
-        key.  You can pass an optional second argument with the target value.  Otherwise
-        this will match any property that evaluates to false.
-
-        @method rejectBy
-        @param {String} key the property to test
-        @param {String} [value] optional value to test against.
-        @return {Array} rejected array
-      */
-      rejectBy: function(key, value) {
-        var exactValue = function(item) {
-          return get(item, key) === value;
-        };
+  exports['default'] = mixin.Mixin.create({
+    /**
+      @private
 
-        var hasValue = function(item) {
-          return !!get(item, key);
-        };
+      Moves `content` to `model`  at extend time if a `model` is not also specified.
 
-        var use = (arguments.length === 2 ? exactValue : hasValue);
+      Note that this currently modifies the mixin themselves, which is technically
+      dubious but is practically of little consequence. This may change in the
+      future.
 
-        return this.reject(use);
-      },
+      @method willMergeMixin
+      @since 1.4.0
+    */
+    willMergeMixin: function(props) {
+      // Calling super is only OK here since we KNOW that
+      // there is another Mixin loaded first.
+      this._super.apply(this, arguments);
 
-      /**
-        Returns an array with the items that do not have truthy values for
-        key.  You can pass an optional second argument with the target value.  Otherwise
-        this will match any property that evaluates to false.
-
-        @method rejectProperty
-        @param {String} key the property to test
-        @param {String} [value] optional value to test against.
-        @return {Array} rejected array
-        @deprecated Use `rejectBy` instead
-      */
-      rejectProperty: aliasMethod('rejectBy'),
+      var modelSpecified = !!props.model;
 
-      /**
-        Returns the first item in the array for which the callback returns true.
-        This method works similar to the `filter()` method defined in JavaScript 1.6
-        except that it will stop working on the array once a match is found.
+      if (props.content && !modelSpecified) {
+        props.model = props.content;
+        delete props['content'];
 
-        The callback method you provide should have the following signature (all
-        parameters are optional):
+        Ember['default'].deprecate('Do not specify `content` on a Controller, use `model` instead.');
+      }
+    }
+  });
 
-        ```javascript
-        function(item, index, enumerable);
-        ```
+});
+enifed('ember-runtime/mixins/copyable', ['exports', 'ember-metal/property_get', 'ember-metal/mixin', 'ember-runtime/mixins/freezable', 'ember-runtime/system/string', 'ember-metal/error'], function (exports, property_get, mixin, freezable, string, EmberError) {
 
-        - `item` is the current item in the iteration.
-        - `index` is the current index in the iteration.
-        - `enumerable` is the enumerable object itself.
+  'use strict';
 
-        It should return the `true` to include the item in the results, `false`
-        otherwise.
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-        Note that in addition to a callback, you can also pass an optional target
-        object that will be set as `this` on the context. This is a good way
-        to give your iterator function access to the current object.
 
-        @method find
-        @param {Function} callback The callback to execute
-        @param {Object} [target] The target object to use
-        @return {Object} Found item or `undefined`.
-      */
-      find: function(callback, target) {
-        var len = get(this, 'length');
+  exports['default'] = mixin.Mixin.create({
+    /**
+      Override to return a copy of the receiver. Default implementation raises
+      an exception.
 
-        if (target === undefined) {
-          target = null;
-        }
+      @method copy
+      @param {Boolean} deep if `true`, a deep copy of the object should be made
+      @return {Object} copy of receiver
+    */
+    copy: mixin.required(Function),
 
-        var context = popCtx();
-        var found = false;
-        var last = null;
-        var next, ret;
+    /**
+      If the object implements `Ember.Freezable`, then this will return a new
+      copy if the object is not frozen and the receiver if the object is frozen.
 
-        for(var idx = 0; idx < len && !found; idx++) {
-          next = this.nextObject(idx, last, context);
+      Raises an exception if you try to call this method on a object that does
+      not support freezing.
 
-          if (found = callback.call(target, next, idx, this)) {
-            ret = next;
-          }
+      You should use this method whenever you want a copy of a freezable object
+      since a freezable object can simply return itself without actually
+      consuming more memory.
 
-          last = next;
-        }
+      @method frozenCopy
+      @return {Object} copy of receiver or receiver
+    */
+    frozenCopy: function() {
+      if (freezable.Freezable && freezable.Freezable.detect(this)) {
+        return property_get.get(this, 'isFrozen') ? this : this.copy().freeze();
+      } else {
+        throw new EmberError['default'](string.fmt("%@ does not support freezing", [this]));
+      }
+    }
+  });
 
-        next = last = null;
-        context = pushCtx(context);
+});
+enifed('ember-runtime/mixins/deferred', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/mixin', 'ember-metal/computed', 'ember-runtime/ext/rsvp'], function (exports, Ember, property_get, mixin, computed, RSVP) {
 
-        return ret;
-      },
+  'use strict';
 
-      /**
-        Returns the first item with a property matching the passed value. You
-        can pass an optional second argument with the target value. Otherwise
-        this will match any property that evaluates to `true`.
+  exports['default'] = mixin.Mixin.create({
+    /**
+      Add handlers to be called when the Deferred object is resolved or rejected.
 
-        This method works much like the more generic `find()` method.
+      @method then
+      @param {Function} resolve a callback function to be called when done
+      @param {Function} reject  a callback function to be called when failed
+    */
+    then: function(resolve, reject, label) {
+      var deferred, promise, entity;
 
-        @method findBy
-        @param {String} key the property to test
-        @param {String} [value] optional value to test against.
-        @return {Object} found item or `undefined`
-      */
-      findBy: function(key, value) {
-        return this.find(apply(this, iter, arguments));
-      },
+      entity = this;
+      deferred = property_get.get(this, '_deferred');
+      promise = deferred.promise;
 
-      /**
-        Returns the first item with a property matching the passed value. You
-        can pass an optional second argument with the target value. Otherwise
-        this will match any property that evaluates to `true`.
+      function fulfillmentHandler(fulfillment) {
+        if (fulfillment === promise) {
+          return resolve(entity);
+        } else {
+          return resolve(fulfillment);
+        }
+      }
 
-        This method works much like the more generic `find()` method.
+      return promise.then(resolve && fulfillmentHandler, reject, label);
+    },
 
-        @method findProperty
-        @param {String} key the property to test
-        @param {String} [value] optional value to test against.
-        @return {Object} found item or `undefined`
-        @deprecated Use `findBy` instead
-      */
-      findProperty: aliasMethod('findBy'),
+    /**
+      Resolve a Deferred object and call any `doneCallbacks` with the given args.
 
-      /**
-        Returns `true` if the passed function returns true for every item in the
-        enumeration. This corresponds with the `every()` method in JavaScript 1.6.
+      @method resolve
+    */
+    resolve: function(value) {
+      var deferred, promise;
 
-        The callback method you provide should have the following signature (all
-        parameters are optional):
+      deferred = property_get.get(this, '_deferred');
+      promise = deferred.promise;
 
-        ```javascript
-        function(item, index, enumerable);
-        ```
+      if (value === this) {
+        deferred.resolve(promise);
+      } else {
+        deferred.resolve(value);
+      }
+    },
 
-        - `item` is the current item in the iteration.
-        - `index` is the current index in the iteration.
-        - `enumerable` is the enumerable object itself.
+    /**
+      Reject a Deferred object and call any `failCallbacks` with the given args.
 
-        It should return the `true` or `false`.
+      @method reject
+    */
+    reject: function(value) {
+      property_get.get(this, '_deferred').reject(value);
+    },
 
-        Note that in addition to a callback, you can also pass an optional target
-        object that will be set as `this` on the context. This is a good way
-        to give your iterator function access to the current object.
+    _deferred: computed.computed(function() {
+      Ember['default'].deprecate(
+        'Usage of Ember.DeferredMixin or Ember.Deferred is deprecated.',
+        this._suppressDeferredDeprecation,
+        { url: 'http://emberjs.com/guides/deprecations/#toc_ember-deferredmixin-and-ember-deferred' }
+      );
 
-        Example Usage:
+      return RSVP['default'].defer('Ember: DeferredMixin - ' + this);
+    })
+  });
 
-        ```javascript
-        if (people.every(isEngineer)) {
-          Paychecks.addBigBonus();
-        }
-        ```
+});
+enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/utils', 'ember-metal/mixin', 'ember-metal/enumerable_utils', 'ember-metal/computed', 'ember-metal/property_events', 'ember-metal/events', 'ember-runtime/compare'], function (exports, Ember, property_get, property_set, utils, mixin, enumerable_utils, computed, property_events, events, compare) {
 
-        @method every
-        @param {Function} callback The callback to execute
-        @param {Object} [target] The target object to use
-        @return {Boolean}
-      */
-      every: function(callback, target) {
-        return !this.find(function(x, idx, i) {
-          return !callback.call(target, x, idx, i);
-        });
-      },
+  'use strict';
 
-      /**
-        @method everyBy
-        @param {String} key the property to test
-        @param {String} [value] optional value to test against.
-        @deprecated Use `isEvery` instead
-        @return {Boolean}
-      */
-      everyBy: aliasMethod('isEvery'),
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-      /**
-        @method everyProperty
-        @param {String} key the property to test
-        @param {String} [value] optional value to test against.
-        @deprecated Use `isEvery` instead
-        @return {Boolean}
-      */
-      everyProperty: aliasMethod('isEvery'),
+  // ..........................................................
+  // HELPERS
+  //
 
-      /**
-        Returns `true` if the passed property resolves to `true` for all items in
-        the enumerable. This method is often simpler/faster than using a callback.
-
-        @method isEvery
-        @param {String} key the property to test
-        @param {String} [value] optional value to test against.
-        @return {Boolean}
-        @since 1.3.0
-      */
-      isEvery: function(key, value) {
-        return this.every(apply(this, iter, arguments));
-      },
+  var a_slice = Array.prototype.slice;
 
-      /**
-        Returns `true` if the passed function returns true for any item in the
-        enumeration. This corresponds with the `some()` method in JavaScript 1.6.
+  var contexts = [];
 
-        The callback method you provide should have the following signature (all
-        parameters are optional):
+  function popCtx() {
+    return contexts.length === 0 ? {} : contexts.pop();
+  }
 
-        ```javascript
-        function(item, index, enumerable);
-        ```
+  function pushCtx(ctx) {
+    contexts.push(ctx);
+    return null;
+  }
 
-        - `item` is the current item in the iteration.
-        - `index` is the current index in the iteration.
-        - `enumerable` is the enumerable object itself.
+  function iter(key, value) {
+    var valueProvided = arguments.length === 2;
 
-        It should return the `true` to include the item in the results, `false`
-        otherwise.
+    function i(item) {
+      var cur = property_get.get(item, key);
+      return valueProvided ? value === cur : !!cur;
+    }
 
-        Note that in addition to a callback, you can also pass an optional target
-        object that will be set as `this` on the context. This is a good way
-        to give your iterator function access to the current object.
+    return i;
+  }
 
-        Usage Example:
+  /**
+    This mixin defines the common interface implemented by enumerable objects
+    in Ember. Most of these methods follow the standard Array iteration
+    API defined up to JavaScript 1.8 (excluding language-specific features that
+    cannot be emulated in older versions of JavaScript).
 
-        ```javascript
-        if (people.any(isManager)) {
-          Paychecks.addBiggerBonus();
-        }
-        ```
+    This mixin is applied automatically to the Array class on page load, so you
+    can use any of these methods on simple arrays. If Array already implements
+    one of these methods, the mixin will not override them.
 
-        @method any
-        @param {Function} callback The callback to execute
-        @param {Object} [target] The target object to use
-        @return {Boolean} `true` if the passed function returns `true` for any item
-      */
-      any: function(callback, target) {
-        var len = get(this, 'length');
-        var context = popCtx();
-        var found = false;
-        var last = null;
-        var next, idx;
-
-        if (target === undefined) {
-          target = null;
-        }
+    ## Writing Your Own Enumerable
 
-        for (idx = 0; idx < len && !found; idx++) {
-          next  = this.nextObject(idx, last, context);
-          found = callback.call(target, next, idx, this);
-          last  = next;
-        }
+    To make your own custom class enumerable, you need two items:
 
-        next = last = null;
-        context = pushCtx(context);
-        return found;
-      },
+    1. You must have a length property. This property should change whenever
+       the number of items in your enumerable object changes. If you use this
+       with an `Ember.Object` subclass, you should be sure to change the length
+       property using `set().`
 
-      /**
-        Returns `true` if the passed function returns true for any item in the
-        enumeration. This corresponds with the `some()` method in JavaScript 1.6.
+    2. You must implement `nextObject().` See documentation.
 
-        The callback method you provide should have the following signature (all
-        parameters are optional):
+    Once you have these two methods implemented, apply the `Ember.Enumerable` mixin
+    to your class and you will be able to enumerate the contents of your object
+    like any other collection.
 
-        ```javascript
-        function(item, index, enumerable);
-        ```
+    ## Using Ember Enumeration with Other Libraries
 
-        - `item` is the current item in the iteration.
-        - `index` is the current index in the iteration.
-        - `enumerable` is the enumerable object itself.
+    Many other libraries provide some kind of iterator or enumeration like
+    facility. This is often where the most common API conflicts occur.
+    Ember's API is designed to be as friendly as possible with other
+    libraries by implementing only methods that mostly correspond to the
+    JavaScript 1.8 API.
 
-        It should return the `true` to include the item in the results, `false`
-        otherwise.
+    @class Enumerable
+    @namespace Ember
+    @since Ember 0.9
+  */
+  exports['default'] = mixin.Mixin.create({
 
-        Note that in addition to a callback, you can also pass an optional target
-        object that will be set as `this` on the context. This is a good way
-        to give your iterator function access to the current object.
+    /**
+      Implement this method to make your class enumerable.
 
-        Usage Example:
+      This method will be called repeatedly during enumeration. The index value
+      will always begin with 0 and increment monotonically. You don't have to
+      rely on the index value to determine what object to return, but you should
+      always check the value and start from the beginning when you see the
+      requested index is 0.
 
-        ```javascript
-        if (people.some(isManager)) {
-          Paychecks.addBiggerBonus();
-        }
-        ```
+      The `previousObject` is the object that was returned from the last call
+      to `nextObject` for the current iteration. This is a useful way to
+      manage iteration if you are tracing a linked list, for example.
 
-        @method some
-        @param {Function} callback The callback to execute
-        @param {Object} [target] The target object to use
-        @return {Boolean} `true` if the passed function returns `true` for any item
-        @deprecated Use `any` instead
-      */
-      some: aliasMethod('any'),
+      Finally the context parameter will always contain a hash you can use as
+      a "scratchpad" to maintain any other state you need in order to iterate
+      properly. The context object is reused and is not reset between
+      iterations so make sure you setup the context with a fresh state whenever
+      the index parameter is 0.
 
-      /**
-        Returns `true` if the passed property resolves to `true` for any item in
-        the enumerable. This method is often simpler/faster than using a callback.
-
-        @method isAny
-        @param {String} key the property to test
-        @param {String} [value] optional value to test against.
-        @return {Boolean}
-        @since 1.3.0
-      */
-      isAny: function(key, value) {
-        return this.any(apply(this, iter, arguments));
-      },
+      Generally iterators will continue to call `nextObject` until the index
+      reaches the your current length-1. If you run out of data before this
+      time for some reason, you should simply return undefined.
 
-      /**
-        @method anyBy
-        @param {String} key the property to test
-        @param {String} [value] optional value to test against.
-        @return {Boolean}
-        @deprecated Use `isAny` instead
-      */
-      anyBy: aliasMethod('isAny'),
+      The default implementation of this method simply looks up the index.
+      This works great on any Array-like objects.
 
-      /**
-        @method someProperty
-        @param {String} key the property to test
-        @param {String} [value] optional value to test against.
-        @return {Boolean}
-        @deprecated Use `isAny` instead
-      */
-      someProperty: aliasMethod('isAny'),
+      @method nextObject
+      @param {Number} index the current index of the iteration
+      @param {Object} previousObject the value returned by the last call to
+        `nextObject`.
+      @param {Object} context a context object you can use to maintain state.
+      @return {Object} the next object in the iteration or undefined
+    */
+    nextObject: mixin.required(Function),
 
-      /**
-        This will combine the values of the enumerator into a single value. It
-        is a useful way to collect a summary value from an enumeration. This
-        corresponds to the `reduce()` method defined in JavaScript 1.8.
+    /**
+      Helper method returns the first object from a collection. This is usually
+      used by bindings and other parts of the framework to extract a single
+      object if the enumerable contains only one item.
 
-        The callback method you provide should have the following signature (all
-        parameters are optional):
+      If you override this method, you should implement it so that it will
+      always return the same value each time it is called. If your enumerable
+      contains only one object, this method should always return that object.
+      If your enumerable is empty, this method should return `undefined`.
 
-        ```javascript
-        function(previousValue, item, index, enumerable);
-        ```
+      ```javascript
+      var arr = ['a', 'b', 'c'];
+      arr.get('firstObject');  // 'a'
 
-        - `previousValue` is the value returned by the last call to the iterator.
-        - `item` is the current item in the iteration.
-        - `index` is the current index in the iteration.
-        - `enumerable` is the enumerable object itself.
+      var arr = [];
+      arr.get('firstObject');  // undefined
+      ```
 
-        Return the new cumulative value.
+      @property firstObject
+      @return {Object} the object or undefined
+    */
+    firstObject: computed.computed('[]', function() {
+      if (property_get.get(this, 'length') === 0) {
+        return undefined;
+      }
 
-        In addition to the callback you can also pass an `initialValue`. An error
-        will be raised if you do not pass an initial value and the enumerator is
-        empty.
+      // handle generic enumerables
+      var context = popCtx();
+      var ret = this.nextObject(0, null, context);
 
-        Note that unlike the other methods, this method does not allow you to
-        pass a target object to set as this for the callback. It's part of the
-        spec. Sorry.
+      pushCtx(context);
 
-        @method reduce
-        @param {Function} callback The callback to execute
-        @param {Object} initialValue Initial value for the reduce
-        @param {String} reducerProperty internal use only.
-        @return {Object} The reduced value.
-      */
-      reduce: function(callback, initialValue, reducerProperty) {
-        if (typeof callback !== 'function') {
-          throw new TypeError();
-        }
+      return ret;
+    }),
 
-        var ret = initialValue;
+    /**
+      Helper method returns the last object from a collection. If your enumerable
+      contains only one object, this method should always return that object.
+      If your enumerable is empty, this method should return `undefined`.
 
-        this.forEach(function(item, i) {
-          ret = callback(ret, item, i, this, reducerProperty);
-        }, this);
+      ```javascript
+      var arr = ['a', 'b', 'c'];
+      arr.get('lastObject');  // 'c'
 
-        return ret;
-      },
+      var arr = [];
+      arr.get('lastObject');  // undefined
+      ```
 
-      /**
-        Invokes the named method on every object in the receiver that
-        implements it. This method corresponds to the implementation in
-        Prototype 1.6.
-
-        @method invoke
-        @param {String} methodName the name of the method
-        @param {Object...} args optional arguments to pass as well.
-        @return {Array} return values from calling invoke.
-      */
-      invoke: function(methodName) {
-        var ret = Ember.A();
-        var args;
+      @property lastObject
+      @return {Object} the last object or undefined
+    */
+    lastObject: computed.computed('[]', function() {
+      var len = property_get.get(this, 'length');
 
-        if (arguments.length > 1) {
-          args = a_slice.call(arguments, 1);
-        }
+      if (len === 0) {
+        return undefined;
+      }
 
-        this.forEach(function(x, idx) {
-          var method = x && x[methodName];
+      var context = popCtx();
+      var idx = 0;
+      var last = null;
+      var cur;
 
-          if ('function' === typeof method) {
-            ret[idx] = args ? apply(x, method, args) : x[methodName]();
-          }
-        }, this);
+      do {
+        last = cur;
+        cur = this.nextObject(idx++, last, context);
+      } while (cur !== undefined);
 
-        return ret;
-      },
+      pushCtx(context);
 
-      /**
-        Simply converts the enumerable into a genuine array. The order is not
-        guaranteed. Corresponds to the method implemented by Prototype.
+      return last;
+    }),
 
-        @method toArray
-        @return {Array} the enumerable as an array.
-      */
-      toArray: function() {
-        var ret = Ember.A();
+    /**
+      Returns `true` if the passed object can be found in the receiver. The
+      default version will iterate through the enumerable until the object
+      is found. You may want to override this with a more efficient version.
 
-        this.forEach(function(o, idx) {
-          ret[idx] = o;
-        });
+      ```javascript
+      var arr = ['a', 'b', 'c'];
 
-        return ret;
-      },
+      arr.contains('a'); // true
+      arr.contains('z'); // false
+      ```
 
-      /**
-        Returns a copy of the array with all `null` and `undefined` elements removed.
+      @method contains
+      @param {Object} obj The object to search for.
+      @return {Boolean} `true` if object is found in enumerable.
+    */
+    contains: function(obj) {
+      var found = this.find(function(item) {
+        return item === obj;
+      });
 
-        ```javascript
-        var arr = ['a', null, 'c', undefined];
-        arr.compact();  // ['a', 'c']
-        ```
+      return found !== undefined;
+    },
 
-        @method compact
-        @return {Array} the array without null and undefined elements.
-      */
-      compact: function() {
-        return this.filter(function(value) {
-          return value != null;
-        });
-      },
+    /**
+      Iterates through the enumerable, calling the passed function on each
+      item. This method corresponds to the `forEach()` method defined in
+      JavaScript 1.6.
 
-      /**
-        Returns a new enumerable that excludes the passed value. The default
-        implementation returns an array regardless of the receiver type unless
-        the receiver does not contain the value.
+      The callback method you provide should have the following signature (all
+      parameters are optional):
 
-        ```javascript
-        var arr = ['a', 'b', 'a', 'c'];
-        arr.without('a');  // ['b', 'c']
-        ```
+      ```javascript
+      function(item, index, enumerable);
+      ```
 
-        @method without
-        @param {Object} value
-        @return {Ember.Enumerable}
-      */
-      without: function(value) {
-        if (!this.contains(value)) {
-          return this; // nothing to do
-        }
+      - `item` is the current item in the iteration.
+      - `index` is the current index in the iteration.
+      - `enumerable` is the enumerable object itself.
 
-        var ret = Ember.A();
+      Note that in addition to a callback, you can also pass an optional target
+      object that will be set as `this` on the context. This is a good way
+      to give your iterator function access to the current object.
 
-        this.forEach(function(k) {
-          if (k !== value) {
-            ret[ret.length] = k;
-          }
-        });
+      @method forEach
+      @param {Function} callback The callback to execute
+      @param {Object} [target] The target object to use
+      @return {Object} receiver
+    */
+    forEach: function(callback, target) {
+      if (typeof callback !== 'function') {
+        throw new TypeError();
+      }
 
-        return ret;
-      },
+      var context = popCtx();
+      var len = property_get.get(this, 'length');
+      var last = null;
 
-      /**
-        Returns a new enumerable that contains only unique values. The default
-        implementation returns an array regardless of the receiver type.
+      if (target === undefined) {
+        target = null;
+      }
 
-        ```javascript
-        var arr = ['a', 'a', 'b', 'b'];
-        arr.uniq();  // ['a', 'b']
-        ```
+      for (var idx = 0; idx < len; idx++) {
+        var next = this.nextObject(idx, last, context);
+        callback.call(target, next, idx, this);
+        last = next;
+      }
 
-        This only works on primitive data types, e.g. Strings, Numbers, etc.
+      last = null;
+      context = pushCtx(context);
 
-        @method uniq
-        @return {Ember.Enumerable}
-      */
-      uniq: function() {
-        var ret = Ember.A();
+      return this;
+    },
 
-        this.forEach(function(k) {
-          if (indexOf(ret, k) < 0) {
-            ret.push(k);
-          }
-        });
+    /**
+      Alias for `mapBy`
 
-        return ret;
-      },
+      @method getEach
+      @param {String} key name of the property
+      @return {Array} The mapped array.
+    */
+    getEach: mixin.aliasMethod('mapBy'),
 
-      /**
-        This property will trigger anytime the enumerable's content changes.
-        You can observe this property to be notified of changes to the enumerables
-        content.
+    /**
+      Sets the value on the named property for each member. This is more
+      efficient than using other methods defined on this helper. If the object
+      implements Ember.Observable, the value will be changed to `set(),` otherwise
+      it will be set directly. `null` objects are skipped.
 
-        For plain enumerables, this property is read only. `Array` overrides
-        this method.
+      @method setEach
+      @param {String} key The key to set
+      @param {Object} value The object to set
+      @return {Object} receiver
+    */
+    setEach: function(key, value) {
+      return this.forEach(function(item) {
+        property_set.set(item, key, value);
+      });
+    },
 
-        @property []
-        @type Array
-        @return this
-      */
-      '[]': computed(function(key, value) {
-        return this;
-      }),
+    /**
+      Maps all of the items in the enumeration to another value, returning
+      a new array. This method corresponds to `map()` defined in JavaScript 1.6.
 
-      // ..........................................................
-      // ENUMERABLE OBSERVERS
-      //
+      The callback method you provide should have the following signature (all
+      parameters are optional):
 
-      /**
-        Registers an enumerable observer. Must implement `Ember.EnumerableObserver`
-        mixin.
+      ```javascript
+      function(item, index, enumerable);
+      ```
 
-        @method addEnumerableObserver
-        @param {Object} target
-        @param {Hash} [opts]
-        @return this
-      */
-      addEnumerableObserver: function(target, opts) {
-        var willChange = (opts && opts.willChange) || 'enumerableWillChange';
-        var didChange  = (opts && opts.didChange) || 'enumerableDidChange';
-        var hasObservers = get(this, 'hasEnumerableObservers');
+      - `item` is the current item in the iteration.
+      - `index` is the current index in the iteration.
+      - `enumerable` is the enumerable object itself.
 
-        if (!hasObservers) { 
-          propertyWillChange(this, 'hasEnumerableObservers');
-        }
+      It should return the mapped value.
 
-        addListener(this, '@enumerable:before', target, willChange);
-        addListener(this, '@enumerable:change', target, didChange);
+      Note that in addition to a callback, you can also pass an optional target
+      object that will be set as `this` on the context. This is a good way
+      to give your iterator function access to the current object.
 
-        if (!hasObservers) {
-          propertyDidChange(this, 'hasEnumerableObservers');
-        }
+      @method map
+      @param {Function} callback The callback to execute
+      @param {Object} [target] The target object to use
+      @return {Array} The mapped array.
+    */
+    map: function(callback, target) {
+      var ret = Ember['default'].A();
 
-        return this;
-      },
+      this.forEach(function(x, idx, i) {
+        ret[idx] = callback.call(target, x, idx, i);
+      });
 
-      /**
-        Removes a registered enumerable observer.
+      return ret;
+    },
 
-        @method removeEnumerableObserver
-        @param {Object} target
-        @param {Hash} [opts]
-        @return this
-      */
-      removeEnumerableObserver: function(target, opts) {
-        var willChange = (opts && opts.willChange) || 'enumerableWillChange';
-        var didChange  = (opts && opts.didChange) || 'enumerableDidChange';
-        var hasObservers = get(this, 'hasEnumerableObservers');
+    /**
+      Similar to map, this specialized function returns the value of the named
+      property on all items in the enumeration.
 
-        if (hasObservers) {
-          propertyWillChange(this, 'hasEnumerableObservers');
-        }
+      @method mapBy
+      @param {String} key name of the property
+      @return {Array} The mapped array.
+    */
+    mapBy: function(key) {
+      return this.map(function(next) {
+        return property_get.get(next, key);
+      });
+    },
 
-        removeListener(this, '@enumerable:before', target, willChange);
-        removeListener(this, '@enumerable:change', target, didChange);
+    /**
+      Similar to map, this specialized function returns the value of the named
+      property on all items in the enumeration.
 
-        if (hasObservers) {
-          propertyDidChange(this, 'hasEnumerableObservers');
-        }
+      @method mapProperty
+      @param {String} key name of the property
+      @return {Array} The mapped array.
+      @deprecated Use `mapBy` instead
+    */
 
-        return this;
-      },
+    mapProperty: mixin.aliasMethod('mapBy'),
 
-      /**
-        Becomes true whenever the array currently has observers watching changes
-        on the array.
+    /**
+      Returns an array with all of the items in the enumeration that the passed
+      function returns true for. This method corresponds to `filter()` defined in
+      JavaScript 1.6.
 
-        @property hasEnumerableObservers
-        @type Boolean
-      */
-      hasEnumerableObservers: computed(function() {
-        return hasListeners(this, '@enumerable:change') || hasListeners(this, '@enumerable:before');
-      }),
+      The callback method you provide should have the following signature (all
+      parameters are optional):
 
+      ```javascript
+      function(item, index, enumerable);
+      ```
 
-      /**
-        Invoke this method just before the contents of your enumerable will
-        change. You can either omit the parameters completely or pass the objects
-        to be removed or added if available or just a count.
-
-        @method enumerableContentWillChange
-        @param {Ember.Enumerable|Number} removing An enumerable of the objects to
-          be removed or the number of items to be removed.
-        @param {Ember.Enumerable|Number} adding An enumerable of the objects to be
-          added or the number of items to be added.
-        @chainable
-      */
-      enumerableContentWillChange: function(removing, adding) {
-        var removeCnt, addCnt, hasDelta;
+      - `item` is the current item in the iteration.
+      - `index` is the current index in the iteration.
+      - `enumerable` is the enumerable object itself.
 
-        if ('number' === typeof removing) {
-          removeCnt = removing;
-        } else if (removing) {
-          removeCnt = get(removing, 'length');
-        } else {
-          removeCnt = removing = -1;
-        }
+      It should return `true` to include the item in the results, `false`
+      otherwise.
 
-        if ('number' === typeof adding) {
-          addCnt = adding;
-        } else if (adding) {
-          addCnt = get(adding,'length');
-        } else {
-          addCnt = adding = -1;
-        }
+      Note that in addition to a callback, you can also pass an optional target
+      object that will be set as `this` on the context. This is a good way
+      to give your iterator function access to the current object.
 
-        hasDelta = addCnt < 0 || removeCnt < 0 || addCnt - removeCnt !== 0;
+      @method filter
+      @param {Function} callback The callback to execute
+      @param {Object} [target] The target object to use
+      @return {Array} A filtered array.
+    */
+    filter: function(callback, target) {
+      var ret = Ember['default'].A();
 
-        if (removing === -1) {
-          removing = null;
+      this.forEach(function(x, idx, i) {
+        if (callback.call(target, x, idx, i)) {
+          ret.push(x);
         }
+      });
 
-        if (adding === -1) {
-          adding = null;
-        }
+      return ret;
+    },
 
-        propertyWillChange(this, '[]');
+    /**
+      Returns an array with all of the items in the enumeration where the passed
+      function returns true. This method is the inverse of filter().
 
-        if (hasDelta) {
-          propertyWillChange(this, 'length');
-        }
+      The callback method you provide should have the following signature (all
+      parameters are optional):
 
-        sendEvent(this, '@enumerable:before', [this, removing, adding]);
+      ```javascript
+      function(item, index, enumerable);
+      ```
 
-        return this;
-      },
+      - *item* is the current item in the iteration.
+      - *index* is the current index in the iteration
+      - *enumerable* is the enumerable object itself.
 
-      /**
-        Invoke this method when the contents of your enumerable has changed.
-        This will notify any observers watching for content changes. If you are
-        implementing an ordered enumerable (such as an array), also pass the
-        start and end values where the content changed so that it can be used to
-        notify range observers.
-
-        @method enumerableContentDidChange
-        @param {Ember.Enumerable|Number} removing An enumerable of the objects to
-          be removed or the number of items to be removed.
-        @param {Ember.Enumerable|Number} adding  An enumerable of the objects to
-          be added or the number of items to be added.
-        @chainable
-      */
-      enumerableContentDidChange: function(removing, adding) {
-        var removeCnt, addCnt, hasDelta;
+      It should return the a falsey value to include the item in the results.
 
-        if ('number' === typeof removing) {
-          removeCnt = removing;
-        } else if (removing) {
-          removeCnt = get(removing, 'length');
-        } else {
-          removeCnt = removing = -1;
-        }
+      Note that in addition to a callback, you can also pass an optional target
+      object that will be set as "this" on the context. This is a good way
+      to give your iterator function access to the current object.
 
-        if ('number' === typeof adding) {
-          addCnt = adding;
-        } else if (adding) {
-          addCnt = get(adding, 'length');
-        } else {
-          addCnt = adding = -1;
-        }
+      @method reject
+      @param {Function} callback The callback to execute
+      @param {Object} [target] The target object to use
+      @return {Array} A rejected array.
+     */
+    reject: function(callback, target) {
+      return this.filter(function() {
+        return !(utils.apply(target, callback, arguments));
+      });
+    },
 
-        hasDelta = addCnt < 0 || removeCnt < 0 || addCnt - removeCnt !== 0;
+    /**
+      Returns an array with just the items with the matched property. You
+      can pass an optional second argument with the target value. Otherwise
+      this will match any property that evaluates to `true`.
 
-        if (removing === -1) {
-          removing = null;
-        }
+      @method filterBy
+      @param {String} key the property to test
+      @param {*} [value] optional value to test against.
+      @return {Array} filtered array
+    */
+    filterBy: function(key, value) {
+      return this.filter(utils.apply(this, iter, arguments));
+    },
 
-        if (adding === -1) {
-          adding = null;
-        }
+    /**
+      Returns an array with just the items with the matched property. You
+      can pass an optional second argument with the target value. Otherwise
+      this will match any property that evaluates to `true`.
 
-        sendEvent(this, '@enumerable:change', [this, removing, adding]);
+      @method filterProperty
+      @param {String} key the property to test
+      @param {String} [value] optional value to test against.
+      @return {Array} filtered array
+      @deprecated Use `filterBy` instead
+    */
+    filterProperty: mixin.aliasMethod('filterBy'),
 
-        if (hasDelta) {
-          propertyDidChange(this, 'length');
-        }
+    /**
+      Returns an array with the items that do not have truthy values for
+      key.  You can pass an optional second argument with the target value.  Otherwise
+      this will match any property that evaluates to false.
 
-        propertyDidChange(this, '[]');
+      @method rejectBy
+      @param {String} key the property to test
+      @param {String} [value] optional value to test against.
+      @return {Array} rejected array
+    */
+    rejectBy: function(key, value) {
+      var exactValue = function(item) {
+        return property_get.get(item, key) === value;
+      };
 
-        return this ;
-      },
+      var hasValue = function(item) {
+        return !!property_get.get(item, key);
+      };
 
-      /**
-        Converts the enumerable into an array and sorts by the keys
-        specified in the argument.
-
-        You may provide multiple arguments to sort by multiple properties.
-
-        @method sortBy
-        @param {String} property name(s) to sort on
-        @return {Array} The sorted array.
-        @since 1.2.0
-        */
-      sortBy: function() {
-        var sortKeys = arguments;
-
-        return this.toArray().sort(function(a, b) {
-          for(var i = 0; i < sortKeys.length; i++) {
-            var key = sortKeys[i];
-            var propA = get(a, key);
-            var propB = get(b, key);
-            // return 1 or -1 else continue to the next sortKey
-            var compareValue = compare(propA, propB);
-
-            if (compareValue) {
-              return compareValue;
-            }
-          }
-          return 0;
-        });
-      }
-    });
-  });
-enifed("ember-runtime/mixins/evented",
-  ["ember-metal/mixin","ember-metal/events","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var Mixin = __dependency1__.Mixin;
-    var addListener = __dependency2__.addListener;
-    var removeListener = __dependency2__.removeListener;
-    var hasListeners = __dependency2__.hasListeners;
-    var sendEvent = __dependency2__.sendEvent;
+      var use = (arguments.length === 2 ? exactValue : hasValue);
+
+      return this.reject(use);
+    },
 
     /**
-    @module ember
-    @submodule ember-runtime
+      Returns an array with the items that do not have truthy values for
+      key.  You can pass an optional second argument with the target value.  Otherwise
+      this will match any property that evaluates to false.
+
+      @method rejectProperty
+      @param {String} key the property to test
+      @param {String} [value] optional value to test against.
+      @return {Array} rejected array
+      @deprecated Use `rejectBy` instead
     */
+    rejectProperty: mixin.aliasMethod('rejectBy'),
 
     /**
-      This mixin allows for Ember objects to subscribe to and emit events.
+      Returns the first item in the array for which the callback returns true.
+      This method works similar to the `filter()` method defined in JavaScript 1.6
+      except that it will stop working on the array once a match is found.
+
+      The callback method you provide should have the following signature (all
+      parameters are optional):
 
       ```javascript
-      App.Person = Ember.Object.extend(Ember.Evented, {
-        greet: function() {
-          // ...
-          this.trigger('greet');
-        }
-      });
+      function(item, index, enumerable);
+      ```
 
-      var person = App.Person.create();
+      - `item` is the current item in the iteration.
+      - `index` is the current index in the iteration.
+      - `enumerable` is the enumerable object itself.
 
-      person.on('greet', function() {
-        console.log('Our person has greeted');
-      });
+      It should return the `true` to include the item in the results, `false`
+      otherwise.
 
-      person.greet();
+      Note that in addition to a callback, you can also pass an optional target
+      object that will be set as `this` on the context. This is a good way
+      to give your iterator function access to the current object.
 
-      // outputs: 'Our person has greeted'
-      ```
+      @method find
+      @param {Function} callback The callback to execute
+      @param {Object} [target] The target object to use
+      @return {Object} Found item or `undefined`.
+    */
+    find: function(callback, target) {
+      var len = property_get.get(this, 'length');
 
-      You can also chain multiple event subscriptions:
+      if (target === undefined) {
+        target = null;
+      }
 
-      ```javascript
-      person.on('greet', function() {
-        console.log('Our person has greeted');
-      }).one('greet', function() {
-        console.log('Offer one-time special');
-      }).off('event', this, forgetThis);
-      ```
+      var context = popCtx();
+      var found = false;
+      var last = null;
+      var next, ret;
 
-      @class Evented
-      @namespace Ember
-     */
-    __exports__["default"] = Mixin.create({
+      for (var idx = 0; idx < len && !found; idx++) {
+        next = this.nextObject(idx, last, context);
 
-      /**
-       Subscribes to a named event with given function.
+        if (found = callback.call(target, next, idx, this)) {
+          ret = next;
+        }
 
-       ```javascript
-       person.on('didLoad', function() {
-         // fired once the person has loaded
-       });
-       ```
+        last = next;
+      }
 
-       An optional target can be passed in as the 2nd argument that will
-       be set as the "this" for the callback. This is a good way to give your
-       function access to the object triggering the event. When the target
-       parameter is used the callback becomes the third argument.
+      next = last = null;
+      context = pushCtx(context);
 
-       @method on
-       @param {String} name The name of the event
-       @param {Object} [target] The "this" binding for the callback
-       @param {Function} method The callback to execute
-       @return this
-      */
-      on: function(name, target, method) {
-        addListener(this, name, target, method);
-        return this;
-      },
+      return ret;
+    },
 
-      /**
-        Subscribes a function to a named event and then cancels the subscription
-        after the first time the event is triggered. It is good to use ``one`` when
-        you only care about the first time an event has taken place.
-
-        This function takes an optional 2nd argument that will become the "this"
-        value for the callback. If this argument is passed then the 3rd argument
-        becomes the function.
-
-        @method one
-        @param {String} name The name of the event
-        @param {Object} [target] The "this" binding for the callback
-        @param {Function} method The callback to execute
-        @return this
-      */
-      one: function(name, target, method) {
-        if (!method) {
-          method = target;
-          target = null;
-        }
+    /**
+      Returns the first item with a property matching the passed value. You
+      can pass an optional second argument with the target value. Otherwise
+      this will match any property that evaluates to `true`.
 
-        addListener(this, name, target, method, true);
-        return this;
-      },
+      This method works much like the more generic `find()` method.
 
-      /**
-        Triggers a named event for the object. Any additional arguments
-        will be passed as parameters to the functions that are subscribed to the
-        event.
+      @method findBy
+      @param {String} key the property to test
+      @param {String} [value] optional value to test against.
+      @return {Object} found item or `undefined`
+    */
+    findBy: function(key, value) {
+      return this.find(utils.apply(this, iter, arguments));
+    },
 
-        ```javascript
-        person.on('didEat', function(food) {
-          console.log('person ate some ' + food);
-        });
+    /**
+      Returns the first item with a property matching the passed value. You
+      can pass an optional second argument with the target value. Otherwise
+      this will match any property that evaluates to `true`.
 
-        person.trigger('didEat', 'broccoli');
+      This method works much like the more generic `find()` method.
 
-        // outputs: person ate some broccoli
-        ```
-        @method trigger
-        @param {String} name The name of the event
-        @param {Object...} args Optional arguments to pass on
-      */
-      trigger: function(name) {
-        var length = arguments.length;
-        var args = new Array(length - 1);
+      @method findProperty
+      @param {String} key the property to test
+      @param {String} [value] optional value to test against.
+      @return {Object} found item or `undefined`
+      @deprecated Use `findBy` instead
+    */
+    findProperty: mixin.aliasMethod('findBy'),
 
-        for (var i = 1; i < length; i++) {
-          args[i - 1] = arguments[i];
-        }
+    /**
+      Returns `true` if the passed function returns true for every item in the
+      enumeration. This corresponds with the `every()` method in JavaScript 1.6.
 
-        sendEvent(this, name, args);
-      },
+      The callback method you provide should have the following signature (all
+      parameters are optional):
 
-      /**
-        Cancels subscription for given name, target, and method.
+      ```javascript
+      function(item, index, enumerable);
+      ```
 
-        @method off
-        @param {String} name The name of the event
-        @param {Object} target The target of the subscription
-        @param {Function} method The function of the subscription
-        @return this
-      */
-      off: function(name, target, method) {
-        removeListener(this, name, target, method);
-        return this;
-      },
+      - `item` is the current item in the iteration.
+      - `index` is the current index in the iteration.
+      - `enumerable` is the enumerable object itself.
 
-      /**
-        Checks to see if object has any subscriptions for named event.
+      It should return the `true` or `false`.
 
-        @method has
-        @param {String} name The name of the event
-        @return {Boolean} does the object have a subscription for event
-       */
-      has: function(name) {
-        return hasListeners(this, name);
+      Note that in addition to a callback, you can also pass an optional target
+      object that will be set as `this` on the context. This is a good way
+      to give your iterator function access to the current object.
+
+      Example Usage:
+
+      ```javascript
+      if (people.every(isEngineer)) {
+        Paychecks.addBigBonus();
       }
-    });
-  });
-enifed("ember-runtime/mixins/freezable",
-  ["ember-metal/mixin","ember-metal/property_get","ember-metal/property_set","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
+      ```
+
+      @method every
+      @param {Function} callback The callback to execute
+      @param {Object} [target] The target object to use
+      @return {Boolean}
+    */
+    every: function(callback, target) {
+      return !this.find(function(x, idx, i) {
+        return !callback.call(target, x, idx, i);
+      });
+    },
+
     /**
-    @module ember
-    @submodule ember-runtime
+      @method everyBy
+      @param {String} key the property to test
+      @param {String} [value] optional value to test against.
+      @deprecated Use `isEvery` instead
+      @return {Boolean}
     */
+    everyBy: mixin.aliasMethod('isEvery'),
 
-    var Mixin = __dependency1__.Mixin;
-    var get = __dependency2__.get;
-    var set = __dependency3__.set;
+    /**
+      @method everyProperty
+      @param {String} key the property to test
+      @param {String} [value] optional value to test against.
+      @deprecated Use `isEvery` instead
+      @return {Boolean}
+    */
+    everyProperty: mixin.aliasMethod('isEvery'),
 
     /**
-      The `Ember.Freezable` mixin implements some basic methods for marking an
-      object as frozen. Once an object is frozen it should be read only. No changes
-      may be made the internal state of the object.
+      Returns `true` if the passed property resolves to `true` for all items in
+      the enumerable. This method is often simpler/faster than using a callback.
+
+      @method isEvery
+      @param {String} key the property to test
+      @param {String} [value] optional value to test against.
+      @return {Boolean}
+      @since 1.3.0
+    */
+    isEvery: function(key, value) {
+      return this.every(utils.apply(this, iter, arguments));
+    },
 
-      ## Enforcement
+    /**
+      Returns `true` if the passed function returns true for any item in the
+      enumeration. This corresponds with the `some()` method in JavaScript 1.6.
 
-      To fully support freezing in your subclass, you must include this mixin and
-      override any method that might alter any property on the object to instead
-      raise an exception. You can check the state of an object by checking the
-      `isFrozen` property.
+      The callback method you provide should have the following signature (all
+      parameters are optional):
 
-      Although future versions of JavaScript may support language-level freezing
-      object objects, that is not the case today. Even if an object is freezable,
-      it is still technically possible to modify the object, even though it could
-      break other parts of your application that do not expect a frozen object to
-      change. It is, therefore, very important that you always respect the
-      `isFrozen` property on all freezable objects.
+      ```javascript
+      function(item, index, enumerable);
+      ```
 
-      ## Example Usage
+      - `item` is the current item in the iteration.
+      - `index` is the current index in the iteration.
+      - `enumerable` is the enumerable object itself.
 
-      The example below shows a simple object that implement the `Ember.Freezable`
-      protocol.
+      It should return the `true` to include the item in the results, `false`
+      otherwise.
 
-      ```javascript
-      Contact = Ember.Object.extend(Ember.Freezable, {
-        firstName: null,
-        lastName: null,
-
-        // swaps the names
-        swapNames: function() {
-          if (this.get('isFrozen')) throw Ember.FROZEN_ERROR;
-          var tmp = this.get('firstName');
-          this.set('firstName', this.get('lastName'));
-          this.set('lastName', tmp);
-          return this;
-        }
+      Note that in addition to a callback, you can also pass an optional target
+      object that will be set as `this` on the context. This is a good way
+      to give your iterator function access to the current object.
 
-      });
+      Usage Example:
 
-      c = Contact.create({ firstName: "John", lastName: "Doe" });
-      c.swapNames();  // returns c
-      c.freeze();
-      c.swapNames();  // EXCEPTION
+      ```javascript
+      if (people.any(isManager)) {
+        Paychecks.addBiggerBonus();
+      }
       ```
 
-      ## Copying
+      @method any
+      @param {Function} callback The callback to execute
+      @param {Object} [target] The target object to use
+      @return {Boolean} `true` if the passed function returns `true` for any item
+    */
+    any: function(callback, target) {
+      var len = property_get.get(this, 'length');
+      var context = popCtx();
+      var found = false;
+      var last = null;
+      var next, idx;
 
-      Usually the `Ember.Freezable` protocol is implemented in cooperation with the
-      `Ember.Copyable` protocol, which defines a `frozenCopy()` method that will
-      return a frozen object, if the object implements this method as well.
+      if (target === undefined) {
+        target = null;
+      }
 
-      @class Freezable
-      @namespace Ember
-      @since Ember 0.9
-    */
-    var Freezable = Mixin.create({
+      for (idx = 0; idx < len && !found; idx++) {
+        next  = this.nextObject(idx, last, context);
+        found = callback.call(target, next, idx, this);
+        last  = next;
+      }
 
-      /**
-        Set to `true` when the object is frozen. Use this property to detect
-        whether your object is frozen or not.
+      next = last = null;
+      context = pushCtx(context);
+      return found;
+    },
 
-        @property isFrozen
-        @type Boolean
-      */
-      isFrozen: false,
+    /**
+      Returns `true` if the passed function returns true for any item in the
+      enumeration. This corresponds with the `some()` method in JavaScript 1.6.
 
-      /**
-        Freezes the object. Once this method has been called the object should
-        no longer allow any properties to be edited.
+      The callback method you provide should have the following signature (all
+      parameters are optional):
 
-        @method freeze
-        @return {Object} receiver
-      */
-      freeze: function() {
-        if (get(this, 'isFrozen')) return this;
-        set(this, 'isFrozen', true);
-        return this;
-      }
+      ```javascript
+      function(item, index, enumerable);
+      ```
 
-    });
-    __exports__.Freezable = Freezable;
-    var FROZEN_ERROR = "Frozen object cannot be modified.";
-    __exports__.FROZEN_ERROR = FROZEN_ERROR;
-  });
-enifed("ember-runtime/mixins/mutable_array",
-  ["ember-metal/property_get","ember-metal/utils","ember-metal/error","ember-metal/mixin","ember-runtime/mixins/array","ember-runtime/mixins/mutable_enumerable","ember-runtime/mixins/enumerable","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
+      - `item` is the current item in the iteration.
+      - `index` is the current index in the iteration.
+      - `enumerable` is the enumerable object itself.
 
+      It should return the `true` to include the item in the results, `false`
+      otherwise.
 
-    // require('ember-runtime/mixins/array');
-    // require('ember-runtime/mixins/mutable_enumerable');
+      Note that in addition to a callback, you can also pass an optional target
+      object that will be set as `this` on the context. This is a good way
+      to give your iterator function access to the current object.
 
-    // ..........................................................
-    // CONSTANTS
-    //
+      Usage Example:
 
-    var OUT_OF_RANGE_EXCEPTION = "Index out of range";
-    var EMPTY = [];
+      ```javascript
+      if (people.some(isManager)) {
+        Paychecks.addBiggerBonus();
+      }
+      ```
 
-    // ..........................................................
-    // HELPERS
-    //
+      @method some
+      @param {Function} callback The callback to execute
+      @param {Object} [target] The target object to use
+      @return {Boolean} `true` if the passed function returns `true` for any item
+      @deprecated Use `any` instead
+    */
+    some: mixin.aliasMethod('any'),
 
-    var get = __dependency1__.get;
-    var isArray = __dependency2__.isArray;
-    var EmberError = __dependency3__["default"];
-    var Mixin = __dependency4__.Mixin;
-    var required = __dependency4__.required;
-    var EmberArray = __dependency5__["default"];
-    var MutableEnumerable = __dependency6__["default"];
-    var Enumerable = __dependency7__["default"];
     /**
-      This mixin defines the API for modifying array-like objects. These methods
-      can be applied only to a collection that keeps its items in an ordered set.
-      It builds upon the Array mixin and adds methods to modify the array.
-      Concrete implementations of this class include ArrayProxy and ArrayController.
-
-      It is important to use the methods in this class to modify arrays so that
-      changes are observable. This allows the binding system in Ember to function
-      correctly.
+      Returns `true` if the passed property resolves to `true` for any item in
+      the enumerable. This method is often simpler/faster than using a callback.
 
+      @method isAny
+      @param {String} key the property to test
+      @param {String} [value] optional value to test against.
+      @return {Boolean}
+      @since 1.3.0
+    */
+    isAny: function(key, value) {
+      return this.any(utils.apply(this, iter, arguments));
+    },
 
-      Note that an Array can change even if it does not implement this mixin.
-      For example, one might implement a SparseArray that cannot be directly
-      modified, but if its underlying enumerable changes, it will change also.
+    /**
+      @method anyBy
+      @param {String} key the property to test
+      @param {String} [value] optional value to test against.
+      @return {Boolean}
+      @deprecated Use `isAny` instead
+    */
+    anyBy: mixin.aliasMethod('isAny'),
 
-      @class MutableArray
-      @namespace Ember
-      @uses Ember.Array
-      @uses Ember.MutableEnumerable
+    /**
+      @method someProperty
+      @param {String} key the property to test
+      @param {String} [value] optional value to test against.
+      @return {Boolean}
+      @deprecated Use `isAny` instead
     */
-    __exports__["default"] = Mixin.create(EmberArray, MutableEnumerable, {
+    someProperty: mixin.aliasMethod('isAny'),
 
-      /**
-        __Required.__ You must implement this method to apply this mixin.
-
-        This is one of the primitives you must implement to support `Ember.Array`.
-        You should replace amt objects started at idx with the objects in the
-        passed array. You should also call `this.enumerableContentDidChange()`
-
-        @method replace
-        @param {Number} idx Starting index in the array to replace. If
-          idx >= length, then append to the end of the array.
-        @param {Number} amt Number of elements that should be removed from
-          the array, starting at *idx*.
-        @param {Array} objects An array of zero or more objects that should be
-          inserted into the array at *idx*
-      */
-      replace: required(),
+    /**
+      This will combine the values of the enumerator into a single value. It
+      is a useful way to collect a summary value from an enumeration. This
+      corresponds to the `reduce()` method defined in JavaScript 1.8.
 
-      /**
-        Remove all elements from the array. This is useful if you
-        want to reuse an existing array without having to recreate it.
+      The callback method you provide should have the following signature (all
+      parameters are optional):
 
-        ```javascript
-        var colors = ["red", "green", "blue"];
-        color.length();   //  3
-        colors.clear();   //  []
-        colors.length();  //  0
-        ```
+      ```javascript
+      function(previousValue, item, index, enumerable);
+      ```
 
-        @method clear
-        @return {Ember.Array} An empty Array.
-      */
-      clear: function () {
-        var len = get(this, 'length');
-        if (len === 0) return this;
-        this.replace(0, len, EMPTY);
-        return this;
-      },
+      - `previousValue` is the value returned by the last call to the iterator.
+      - `item` is the current item in the iteration.
+      - `index` is the current index in the iteration.
+      - `enumerable` is the enumerable object itself.
 
-      /**
-        This will use the primitive `replace()` method to insert an object at the
-        specified index.
+      Return the new cumulative value.
 
-        ```javascript
-        var colors = ["red", "green", "blue"];
-        colors.insertAt(2, "yellow");  // ["red", "green", "yellow", "blue"]
-        colors.insertAt(5, "orange");  // Error: Index out of range
-        ```
+      In addition to the callback you can also pass an `initialValue`. An error
+      will be raised if you do not pass an initial value and the enumerator is
+      empty.
 
-        @method insertAt
-        @param {Number} idx index of insert the object at.
-        @param {Object} object object to insert
-        @return {Ember.Array} receiver
-      */
-      insertAt: function(idx, object) {
-        if (idx > get(this, 'length')) throw new EmberError(OUT_OF_RANGE_EXCEPTION);
-        this.replace(idx, 0, [object]);
-        return this;
-      },
+      Note that unlike the other methods, this method does not allow you to
+      pass a target object to set as this for the callback. It's part of the
+      spec. Sorry.
 
-      /**
-        Remove an object at the specified index using the `replace()` primitive
-        method. You can pass either a single index, or a start and a length.
+      @method reduce
+      @param {Function} callback The callback to execute
+      @param {Object} initialValue Initial value for the reduce
+      @param {String} reducerProperty internal use only.
+      @return {Object} The reduced value.
+    */
+    reduce: function(callback, initialValue, reducerProperty) {
+      if (typeof callback !== 'function') {
+        throw new TypeError();
+      }
 
-        If you pass a start and length that is beyond the
-        length this method will throw an `OUT_OF_RANGE_EXCEPTION`.
+      var ret = initialValue;
 
-        ```javascript
-        var colors = ["red", "green", "blue", "yellow", "orange"];
-        colors.removeAt(0);     // ["green", "blue", "yellow", "orange"]
-        colors.removeAt(2, 2);  // ["green", "blue"]
-        colors.removeAt(4, 2);  // Error: Index out of range
-        ```
+      this.forEach(function(item, i) {
+        ret = callback(ret, item, i, this, reducerProperty);
+      }, this);
 
-        @method removeAt
-        @param {Number} start index, start of range
-        @param {Number} len length of passing range
-        @return {Ember.Array} receiver
-      */
-      removeAt: function(start, len) {
-        if ('number' === typeof start) {
+      return ret;
+    },
 
-          if ((start < 0) || (start >= get(this, 'length'))) {
-            throw new EmberError(OUT_OF_RANGE_EXCEPTION);
-          }
+    /**
+      Invokes the named method on every object in the receiver that
+      implements it. This method corresponds to the implementation in
+      Prototype 1.6.
+
+      @method invoke
+      @param {String} methodName the name of the method
+      @param {Object...} args optional arguments to pass as well.
+      @return {Array} return values from calling invoke.
+    */
+    invoke: function(methodName) {
+      var ret = Ember['default'].A();
+      var args;
+
+      if (arguments.length > 1) {
+        args = a_slice.call(arguments, 1);
+      }
+
+      this.forEach(function(x, idx) {
+        var method = x && x[methodName];
 
-          // fast case
-          if (len === undefined) len = 1;
-          this.replace(start, len, EMPTY);
+        if ('function' === typeof method) {
+          ret[idx] = args ? utils.apply(x, method, args) : x[methodName]();
         }
+      }, this);
 
-        return this;
-      },
+      return ret;
+    },
+
+    /**
+      Simply converts the enumerable into a genuine array. The order is not
+      guaranteed. Corresponds to the method implemented by Prototype.
 
-      /**
-        Push the object onto the end of the array. Works just like `push()` but it
-        is KVO-compliant.
+      @method toArray
+      @return {Array} the enumerable as an array.
+    */
+    toArray: function() {
+      var ret = Ember['default'].A();
 
-        ```javascript
-        var colors = ["red", "green"];
-        colors.pushObject("black");     // ["red", "green", "black"]
-        colors.pushObject(["yellow"]);  // ["red", "green", ["yellow"]]
-        ```
+      this.forEach(function(o, idx) {
+        ret[idx] = o;
+      });
 
-        @method pushObject
-        @param {*} obj object to push
-        @return object same object passed as a param
-      */
-      pushObject: function(obj) {
-        this.insertAt(get(this, 'length'), obj);
-        return obj;
-      },
+      return ret;
+    },
 
-      /**
-        Add the objects in the passed numerable to the end of the array. Defers
-        notifying observers of the change until all objects are added.
+    /**
+      Returns a copy of the array with all `null` and `undefined` elements removed.
 
-        ```javascript
-        var colors = ["red"];
-        colors.pushObjects(["yellow", "orange"]);  // ["red", "yellow", "orange"]
-        ```
+      ```javascript
+      var arr = ['a', null, 'c', undefined];
+      arr.compact();  // ['a', 'c']
+      ```
 
-        @method pushObjects
-        @param {Ember.Enumerable} objects the objects to add
-        @return {Ember.Array} receiver
-      */
-      pushObjects: function(objects) {
-        if (!(Enumerable.detect(objects) || isArray(objects))) {
-          throw new TypeError("Must pass Ember.Enumerable to Ember.MutableArray#pushObjects");
-        }
-        this.replace(get(this, 'length'), 0, objects);
-        return this;
-      },
+      @method compact
+      @return {Array} the array without null and undefined elements.
+    */
+    compact: function() {
+      return this.filter(function(value) {
+        return value != null;
+      });
+    },
 
-      /**
-        Pop object from array or nil if none are left. Works just like `pop()` but
-        it is KVO-compliant.
+    /**
+      Returns a new enumerable that excludes the passed value. The default
+      implementation returns an array regardless of the receiver type unless
+      the receiver does not contain the value.
 
-        ```javascript
-        var colors = ["red", "green", "blue"];
-        colors.popObject();   // "blue"
-        console.log(colors);  // ["red", "green"]
-        ```
+      ```javascript
+      var arr = ['a', 'b', 'a', 'c'];
+      arr.without('a');  // ['b', 'c']
+      ```
 
-        @method popObject
-        @return object
-      */
-      popObject: function() {
-        var len = get(this, 'length');
-        if (len === 0) return null;
+      @method without
+      @param {Object} value
+      @return {Ember.Enumerable}
+    */
+    without: function(value) {
+      if (!this.contains(value)) {
+        return this; // nothing to do
+      }
 
-        var ret = this.objectAt(len-1);
-        this.removeAt(len-1, 1);
-        return ret;
-      },
+      var ret = Ember['default'].A();
 
-      /**
-        Shift an object from start of array or nil if none are left. Works just
-        like `shift()` but it is KVO-compliant.
+      this.forEach(function(k) {
+        if (k !== value) {
+          ret[ret.length] = k;
+        }
+      });
 
-        ```javascript
-        var colors = ["red", "green", "blue"];
-        colors.shiftObject();  // "red"
-        console.log(colors);   // ["green", "blue"]
-        ```
+      return ret;
+    },
 
-        @method shiftObject
-        @return object
-      */
-      shiftObject: function() {
-        if (get(this, 'length') === 0) return null;
-        var ret = this.objectAt(0);
-        this.removeAt(0);
-        return ret;
-      },
+    /**
+      Returns a new enumerable that contains only unique values. The default
+      implementation returns an array regardless of the receiver type.
 
-      /**
-        Unshift an object to start of array. Works just like `unshift()` but it is
-        KVO-compliant.
+      ```javascript
+      var arr = ['a', 'a', 'b', 'b'];
+      arr.uniq();  // ['a', 'b']
+      ```
 
-        ```javascript
-        var colors = ["red"];
-        colors.unshiftObject("yellow");    // ["yellow", "red"]
-        colors.unshiftObject(["black"]);   // [["black"], "yellow", "red"]
-        ```
+      This only works on primitive data types, e.g. Strings, Numbers, etc.
 
-        @method unshiftObject
-        @param {*} obj object to unshift
-        @return object same object passed as a param
-      */
-      unshiftObject: function(obj) {
-        this.insertAt(0, obj);
-        return obj;
-      },
+      @method uniq
+      @return {Ember.Enumerable}
+    */
+    uniq: function() {
+      var ret = Ember['default'].A();
 
-      /**
-        Adds the named objects to the beginning of the array. Defers notifying
-        observers until all objects have been added.
+      this.forEach(function(k) {
+        if (enumerable_utils.indexOf(ret, k) < 0) {
+          ret.push(k);
+        }
+      });
 
-        ```javascript
-        var colors = ["red"];
-        colors.unshiftObjects(["black", "white"]);   // ["black", "white", "red"]
-        colors.unshiftObjects("yellow"); // Type Error: 'undefined' is not a function
-        ```
+      return ret;
+    },
 
-        @method unshiftObjects
-        @param {Ember.Enumerable} objects the objects to add
-        @return {Ember.Array} receiver
-      */
-      unshiftObjects: function(objects) {
-        this.replace(0, 0, objects);
-        return this;
-      },
+    /**
+      This property will trigger anytime the enumerable's content changes.
+      You can observe this property to be notified of changes to the enumerable's
+      content.
 
-      /**
-        Reverse objects in the array. Works just like `reverse()` but it is
-        KVO-compliant.
+      For plain enumerables, this property is read only. `Array` overrides
+      this method.
 
-        @method reverseObjects
-        @return {Ember.Array} receiver
-       */
-      reverseObjects: function() {
-        var len = get(this, 'length');
-        if (len === 0) return this;
-        var objects = this.toArray().reverse();
-        this.replace(0, len, objects);
-        return this;
-      },
+      @property []
+      @type Array
+      @return this
+    */
+    '[]': computed.computed(function(key, value) {
+      return this;
+    }),
 
-      /**
-        Replace all the receiver's content with content of the argument.
-        If argument is an empty array receiver will be cleared.
+    // ..........................................................
+    // ENUMERABLE OBSERVERS
+    //
 
-        ```javascript
-        var colors = ["red", "green", "blue"];
-        colors.setObjects(["black", "white"]);  // ["black", "white"]
-        colors.setObjects([]);                  // []
-        ```
+    /**
+      Registers an enumerable observer. Must implement `Ember.EnumerableObserver`
+      mixin.
 
-        @method setObjects
-        @param {Ember.Array} objects array whose content will be used for replacing
-            the content of the receiver
-        @return {Ember.Array} receiver with the new content
-       */
-      setObjects: function(objects) {
-        if (objects.length === 0) return this.clear();
+      @method addEnumerableObserver
+      @param {Object} target
+      @param {Hash} [opts]
+      @return this
+    */
+    addEnumerableObserver: function(target, opts) {
+      var willChange = (opts && opts.willChange) || 'enumerableWillChange';
+      var didChange  = (opts && opts.didChange) || 'enumerableDidChange';
+      var hasObservers = property_get.get(this, 'hasEnumerableObservers');
 
-        var len = get(this, 'length');
-        this.replace(0, len, objects);
-        return this;
-      },
+      if (!hasObservers) {
+        property_events.propertyWillChange(this, 'hasEnumerableObservers');
+      }
 
-      // ..........................................................
-      // IMPLEMENT Ember.MutableEnumerable
-      //
+      events.addListener(this, '@enumerable:before', target, willChange);
+      events.addListener(this, '@enumerable:change', target, didChange);
 
-      /**
-        Remove all occurrences of an object in the array.
+      if (!hasObservers) {
+        property_events.propertyDidChange(this, 'hasEnumerableObservers');
+      }
 
-        ```javascript
-        var cities = ["Chicago", "Berlin", "Lima", "Chicago"];
-        cities.removeObject("Chicago");  // ["Berlin", "Lima"]
-        cities.removeObject("Lima");     // ["Berlin"]
-        cities.removeObject("Tokyo")     // ["Berlin"]
-        ```
+      return this;
+    },
 
-        @method removeObject
-        @param {*} obj object to remove
-        @return {Ember.Array} receiver
-      */
-      removeObject: function(obj) {
-        var loc = get(this, 'length') || 0;
-        while(--loc >= 0) {
-          var curObject = this.objectAt(loc);
-          if (curObject === obj) this.removeAt(loc);
-        }
-        return this;
-      },
+    /**
+      Removes a registered enumerable observer.
 
-      /**
-        Push the object onto the end of the array if it is not already
-        present in the array.
+      @method removeEnumerableObserver
+      @param {Object} target
+      @param {Hash} [opts]
+      @return this
+    */
+    removeEnumerableObserver: function(target, opts) {
+      var willChange = (opts && opts.willChange) || 'enumerableWillChange';
+      var didChange  = (opts && opts.didChange) || 'enumerableDidChange';
+      var hasObservers = property_get.get(this, 'hasEnumerableObservers');
 
-        ```javascript
-        var cities = ["Chicago", "Berlin"];
-        cities.addObject("Lima");    // ["Chicago", "Berlin", "Lima"]
-        cities.addObject("Berlin");  // ["Chicago", "Berlin", "Lima"]
-        ```
+      if (hasObservers) {
+        property_events.propertyWillChange(this, 'hasEnumerableObservers');
+      }
 
-        @method addObject
-        @param {*} obj object to add, if not already present
-        @return {Ember.Array} receiver
-      */
-      addObject: function(obj) {
-        if (!this.contains(obj)) this.pushObject(obj);
-        return this;
+      events.removeListener(this, '@enumerable:before', target, willChange);
+      events.removeListener(this, '@enumerable:change', target, didChange);
+
+      if (hasObservers) {
+        property_events.propertyDidChange(this, 'hasEnumerableObservers');
       }
 
-    });
-  });
-enifed("ember-runtime/mixins/mutable_enumerable",
-  ["ember-metal/enumerable_utils","ember-runtime/mixins/enumerable","ember-metal/mixin","ember-metal/property_events","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    var forEach = __dependency1__.forEach;
-    var Enumerable = __dependency2__["default"];
-    var Mixin = __dependency3__.Mixin;
-    var required = __dependency3__.required;
-    var beginPropertyChanges = __dependency4__.beginPropertyChanges;
-    var endPropertyChanges = __dependency4__.endPropertyChanges;
+      return this;
+    },
 
     /**
-    @module ember
-    @submodule ember-runtime
+      Becomes true whenever the array currently has observers watching changes
+      on the array.
+
+      @property hasEnumerableObservers
+      @type Boolean
     */
+    hasEnumerableObservers: computed.computed(function() {
+      return events.hasListeners(this, '@enumerable:change') || events.hasListeners(this, '@enumerable:before');
+    }),
+
 
     /**
-      This mixin defines the API for modifying generic enumerables. These methods
-      can be applied to an object regardless of whether it is ordered or
-      unordered.
+      Invoke this method just before the contents of your enumerable will
+      change. You can either omit the parameters completely or pass the objects
+      to be removed or added if available or just a count.
+
+      @method enumerableContentWillChange
+      @param {Ember.Enumerable|Number} removing An enumerable of the objects to
+        be removed or the number of items to be removed.
+      @param {Ember.Enumerable|Number} adding An enumerable of the objects to be
+        added or the number of items to be added.
+      @chainable
+    */
+    enumerableContentWillChange: function(removing, adding) {
+      var removeCnt, addCnt, hasDelta;
+
+      if ('number' === typeof removing) {
+        removeCnt = removing;
+      } else if (removing) {
+        removeCnt = property_get.get(removing, 'length');
+      } else {
+        removeCnt = removing = -1;
+      }
 
-      Note that an Enumerable can change even if it does not implement this mixin.
-      For example, a MappedEnumerable cannot be directly modified but if its
-      underlying enumerable changes, it will change also.
+      if ('number' === typeof adding) {
+        addCnt = adding;
+      } else if (adding) {
+        addCnt = property_get.get(adding, 'length');
+      } else {
+        addCnt = adding = -1;
+      }
 
-      ## Adding Objects
+      hasDelta = addCnt < 0 || removeCnt < 0 || addCnt - removeCnt !== 0;
 
-      To add an object to an enumerable, use the `addObject()` method. This
-      method will only add the object to the enumerable if the object is not
-      already present and is of a type supported by the enumerable.
+      if (removing === -1) {
+        removing = null;
+      }
 
-      ```javascript
-      set.addObject(contact);
-      ```
+      if (adding === -1) {
+        adding = null;
+      }
 
-      ## Removing Objects
+      property_events.propertyWillChange(this, '[]');
 
-      To remove an object from an enumerable, use the `removeObject()` method. This
-      will only remove the object if it is present in the enumerable, otherwise
-      this method has no effect.
+      if (hasDelta) {
+        property_events.propertyWillChange(this, 'length');
+      }
 
-      ```javascript
-      set.removeObject(contact);
-      ```
+      events.sendEvent(this, '@enumerable:before', [this, removing, adding]);
 
-      ## Implementing In Your Own Code
+      return this;
+    },
 
-      If you are implementing an object and want to support this API, just include
-      this mixin in your class and implement the required methods. In your unit
-      tests, be sure to apply the Ember.MutableEnumerableTests to your object.
+    /**
+      Invoke this method when the contents of your enumerable has changed.
+      This will notify any observers watching for content changes. If you are
+      implementing an ordered enumerable (such as an array), also pass the
+      start and end values where the content changed so that it can be used to
+      notify range observers.
 
-      @class MutableEnumerable
-      @namespace Ember
-      @uses Ember.Enumerable
+      @method enumerableContentDidChange
+      @param {Ember.Enumerable|Number} removing An enumerable of the objects to
+        be removed or the number of items to be removed.
+      @param {Ember.Enumerable|Number} adding  An enumerable of the objects to
+        be added or the number of items to be added.
+      @chainable
     */
-    __exports__["default"] = Mixin.create(Enumerable, {
-
-      /**
-        __Required.__ You must implement this method to apply this mixin.
+    enumerableContentDidChange: function(removing, adding) {
+      var removeCnt, addCnt, hasDelta;
 
-        Attempts to add the passed object to the receiver if the object is not
-        already present in the collection. If the object is present, this method
-        has no effect.
+      if ('number' === typeof removing) {
+        removeCnt = removing;
+      } else if (removing) {
+        removeCnt = property_get.get(removing, 'length');
+      } else {
+        removeCnt = removing = -1;
+      }
 
-        If the passed object is of a type not supported by the receiver,
-        then this method should raise an exception.
+      if ('number' === typeof adding) {
+        addCnt = adding;
+      } else if (adding) {
+        addCnt = property_get.get(adding, 'length');
+      } else {
+        addCnt = adding = -1;
+      }
 
-        @method addObject
-        @param {Object} object The object to add to the enumerable.
-        @return {Object} the passed object
-      */
-      addObject: required(Function),
+      hasDelta = addCnt < 0 || removeCnt < 0 || addCnt - removeCnt !== 0;
 
-      /**
-        Adds each object in the passed enumerable to the receiver.
+      if (removing === -1) {
+        removing = null;
+      }
 
-        @method addObjects
-        @param {Ember.Enumerable} objects the objects to add.
-        @return {Object} receiver
-      */
-      addObjects: function(objects) {
-        beginPropertyChanges(this);
-        forEach(objects, function(obj) { this.addObject(obj); }, this);
-        endPropertyChanges(this);
-        return this;
-      },
+      if (adding === -1) {
+        adding = null;
+      }
 
-      /**
-        __Required.__ You must implement this method to apply this mixin.
+      events.sendEvent(this, '@enumerable:change', [this, removing, adding]);
 
-        Attempts to remove the passed object from the receiver collection if the
-        object is present in the collection. If the object is not present,
-        this method has no effect.
+      if (hasDelta) {
+        property_events.propertyDidChange(this, 'length');
+      }
 
-        If the passed object is of a type not supported by the receiver,
-        then this method should raise an exception.
+      property_events.propertyDidChange(this, '[]');
 
-        @method removeObject
-        @param {Object} object The object to remove from the enumerable.
-        @return {Object} the passed object
-      */
-      removeObject: required(Function),
+      return this;
+    },
 
+    /**
+      Converts the enumerable into an array and sorts by the keys
+      specified in the argument.
 
-      /**
-        Removes each object in the passed enumerable from the receiver.
+      You may provide multiple arguments to sort by multiple properties.
 
-        @method removeObjects
-        @param {Ember.Enumerable} objects the objects to remove
-        @return {Object} receiver
+      @method sortBy
+      @param {String} property name(s) to sort on
+      @return {Array} The sorted array.
+      @since 1.2.0
       */
-      removeObjects: function(objects) {
-        beginPropertyChanges(this);
-        for (var i = objects.length - 1; i >= 0; i--) {
-          this.removeObject(objects[i]);
+    sortBy: function() {
+      var sortKeys = arguments;
+
+      return this.toArray().sort(function(a, b) {
+        for (var i = 0; i < sortKeys.length; i++) {
+          var key = sortKeys[i];
+          var propA = property_get.get(a, key);
+          var propB = property_get.get(b, key);
+          // return 1 or -1 else continue to the next sortKey
+          var compareValue = compare['default'](propA, propB);
+
+          if (compareValue) {
+            return compareValue;
+          }
         }
-        endPropertyChanges(this);
-        return this;
-      }
-    });
+        return 0;
+      });
+    }
   });
-enifed("ember-runtime/mixins/observable",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/get_properties","ember-metal/set_properties","ember-metal/mixin","ember-metal/events","ember-metal/property_events","ember-metal/observer","ember-metal/computed","ember-metal/is_none","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-
-    var get = __dependency2__.get;
-    var getWithDefault = __dependency2__.getWithDefault;
-    var set = __dependency3__.set;
-    var apply = __dependency4__.apply;
-    var getProperties = __dependency5__["default"];
-    var setProperties = __dependency6__["default"];
-    var Mixin = __dependency7__.Mixin;
-    var hasListeners = __dependency8__.hasListeners;
-    var beginPropertyChanges = __dependency9__.beginPropertyChanges;
-    var propertyWillChange = __dependency9__.propertyWillChange;
-    var propertyDidChange = __dependency9__.propertyDidChange;
-    var endPropertyChanges = __dependency9__.endPropertyChanges;
-    var addObserver = __dependency10__.addObserver;
-    var addBeforeObserver = __dependency10__.addBeforeObserver;
-    var removeObserver = __dependency10__.removeObserver;
-    var observersFor = __dependency10__.observersFor;
-    var cacheFor = __dependency11__.cacheFor;
-    var isNone = __dependency12__["default"];
 
+});
+enifed('ember-runtime/mixins/evented', ['exports', 'ember-metal/mixin', 'ember-metal/events'], function (exports, mixin, events) {
 
-    var slice = Array.prototype.slice;
-    /**
-      ## Overview
+  'use strict';
 
-      This mixin provides properties and property observing functionality, core
-      features of the Ember object model.
+  exports['default'] = mixin.Mixin.create({
 
-      Properties and observers allow one object to observe changes to a
-      property on another object. This is one of the fundamental ways that
-      models, controllers and views communicate with each other in an Ember
-      application.
+    /**
+     Subscribes to a named event with given function.
+
+     ```javascript
+     person.on('didLoad', function() {
+       // fired once the person has loaded
+     });
+     ```
 
-      Any object that has this mixin applied can be used in observer
-      operations. That includes `Ember.Object` and most objects you will
-      interact with as you write your Ember application.
+     An optional target can be passed in as the 2nd argument that will
+     be set as the "this" for the callback. This is a good way to give your
+     function access to the object triggering the event. When the target
+     parameter is used the callback becomes the third argument.
 
-      Note that you will not generally apply this mixin to classes yourself,
-      but you will use the features provided by this module frequently, so it
-      is important to understand how to use it.
+     @method on
+     @param {String} name The name of the event
+     @param {Object} [target] The "this" binding for the callback
+     @param {Function} method The callback to execute
+     @return this
+    */
+    on: function(name, target, method) {
+      events.addListener(this, name, target, method);
+      return this;
+    },
 
-      ## Using `get()` and `set()`
+    /**
+      Subscribes a function to a named event and then cancels the subscription
+      after the first time the event is triggered. It is good to use ``one`` when
+      you only care about the first time an event has taken place.
 
-      Because of Ember's support for bindings and observers, you will always
-      access properties using the get method, and set properties using the
-      set method. This allows the observing objects to be notified and
-      computed properties to be handled properly.
+      This function takes an optional 2nd argument that will become the "this"
+      value for the callback. If this argument is passed then the 3rd argument
+      becomes the function.
 
-      More documentation about `get` and `set` are below.
+      @method one
+      @param {String} name The name of the event
+      @param {Object} [target] The "this" binding for the callback
+      @param {Function} method The callback to execute
+      @return this
+    */
+    one: function(name, target, method) {
+      if (!method) {
+        method = target;
+        target = null;
+      }
 
-      ## Observing Property Changes
+      events.addListener(this, name, target, method, true);
+      return this;
+    },
 
-      You typically observe property changes simply by adding the `observes`
-      call to the end of your method declarations in classes that you write.
-      For example:
+    /**
+      Triggers a named event for the object. Any additional arguments
+      will be passed as parameters to the functions that are subscribed to the
+      event.
 
       ```javascript
-      Ember.Object.extend({
-        valueObserver: function() {
-          // Executes whenever the "value" property changes
-        }.observes('value')
+      person.on('didEat', function(food) {
+        console.log('person ate some ' + food);
       });
-      ```
 
-      Although this is the most common way to add an observer, this capability
-      is actually built into the `Ember.Object` class on top of two methods
-      defined in this mixin: `addObserver` and `removeObserver`. You can use
-      these two methods to add and remove observers yourself if you need to
-      do so at runtime.
+      person.trigger('didEat', 'broccoli');
 
-      To add an observer for a property, call:
-
-      ```javascript
-      object.addObserver('propertyKey', targetObject, targetAction)
+      // outputs: person ate some broccoli
       ```
-
-      This will call the `targetAction` method on the `targetObject` whenever
-      the value of the `propertyKey` changes.
-
-      Note that if `propertyKey` is a computed property, the observer will be
-      called when any of the property dependencies are changed, even if the
-      resulting value of the computed property is unchanged. This is necessary
-      because computed properties are not computed until `get` is called.
-
-      @class Observable
-      @namespace Ember
+      @method trigger
+      @param {String} name The name of the event
+      @param {Object...} args Optional arguments to pass on
     */
-    __exports__["default"] = Mixin.create({
-
-      /**
-        Retrieves the value of a property from the object.
-
-        This method is usually similar to using `object[keyName]` or `object.keyName`,
-        however it supports both computed properties and the unknownProperty
-        handler.
+    trigger: function(name) {
+      var length = arguments.length;
+      var args = new Array(length - 1);
 
-        Because `get` unifies the syntax for accessing all these kinds
-        of properties, it can make many refactorings easier, such as replacing a
-        simple property with a computed property, or vice versa.
+      for (var i = 1; i < length; i++) {
+        args[i - 1] = arguments[i];
+      }
 
-        ### Computed Properties
+      events.sendEvent(this, name, args);
+    },
 
-        Computed properties are methods defined with the `property` modifier
-        declared at the end, such as:
+    /**
+      Cancels subscription for given name, target, and method.
 
-        ```javascript
-        fullName: function() {
-          return this.get('firstName') + ' ' + this.get('lastName');
-        }.property('firstName', 'lastName')
-        ```
+      @method off
+      @param {String} name The name of the event
+      @param {Object} target The target of the subscription
+      @param {Function} method The function of the subscription
+      @return this
+    */
+    off: function(name, target, method) {
+      events.removeListener(this, name, target, method);
+      return this;
+    },
 
-        When you call `get` on a computed property, the function will be
-        called and the return value will be returned instead of the function
-        itself.
+    /**
+      Checks to see if object has any subscriptions for named event.
 
-        ### Unknown Properties
+      @method has
+      @param {String} name The name of the event
+      @return {Boolean} does the object have a subscription for event
+     */
+    has: function(name) {
+      return events.hasListeners(this, name);
+    }
+  });
 
-        Likewise, if you try to call `get` on a property whose value is
-        `undefined`, the `unknownProperty()` method will be called on the object.
-        If this method returns any value other than `undefined`, it will be returned
-        instead. This allows you to implement "virtual" properties that are
-        not defined upfront.
+});
+enifed('ember-runtime/mixins/freezable', ['exports', 'ember-metal/mixin', 'ember-metal/property_get', 'ember-metal/property_set'], function (exports, mixin, property_get, property_set) {
 
-        @method get
-        @param {String} keyName The property to retrieve
-        @return {Object} The property value or undefined.
-      */
-      get: function(keyName) {
-        return get(this, keyName);
-      },
+  'use strict';
 
-      /**
-        To get the values of multiple properties at once, call `getProperties`
-        with a list of strings or an array:
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-        ```javascript
-        record.getProperties('firstName', 'lastName', 'zipCode');
-        // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
-        ```
+  var Freezable = mixin.Mixin.create({
 
-        is equivalent to:
+    /**
+      Set to `true` when the object is frozen. Use this property to detect
+      whether your object is frozen or not.
 
-        ```javascript
-        record.getProperties(['firstName', 'lastName', 'zipCode']);
-        // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
-        ```
+      @property isFrozen
+      @type Boolean
+    */
+    isFrozen: false,
 
-        @method getProperties
-        @param {String...|Array} list of keys to get
-        @return {Hash}
-      */
-      getProperties: function() {
-        return apply(null, getProperties, [this].concat(slice.call(arguments)));
-      },
+    /**
+      Freezes the object. Once this method has been called the object should
+      no longer allow any properties to be edited.
 
-      /**
-        Sets the provided key or path to the value.
+      @method freeze
+      @return {Object} receiver
+    */
+    freeze: function() {
+      if (property_get.get(this, 'isFrozen')) {
+        return this;
+      }
 
-        This method is generally very similar to calling `object[key] = value` or
-        `object.key = value`, except that it provides support for computed
-        properties, the `setUnknownProperty()` method and property observers.
+      property_set.set(this, 'isFrozen', true);
+      return this;
+    }
 
-        ### Computed Properties
+  });
 
-        If you try to set a value on a key that has a computed property handler
-        defined (see the `get()` method for an example), then `set()` will call
-        that method, passing both the value and key instead of simply changing
-        the value itself. This is useful for those times when you need to
-        implement a property that is composed of one or more member
-        properties.
+  var FROZEN_ERROR = "Frozen object cannot be modified.";
 
-        ### Unknown Properties
+  exports.Freezable = Freezable;
+  exports.FROZEN_ERROR = FROZEN_ERROR;
 
-        If you try to set a value on a key that is undefined in the target
-        object, then the `setUnknownProperty()` handler will be called instead. This
-        gives you an opportunity to implement complex "virtual" properties that
-        are not predefined on the object. If `setUnknownProperty()` returns
-        undefined, then `set()` will simply set the value on the object.
+});
+enifed('ember-runtime/mixins/mutable_array', ['exports', 'ember-metal/property_get', 'ember-metal/utils', 'ember-metal/error', 'ember-metal/mixin', 'ember-runtime/mixins/array', 'ember-runtime/mixins/mutable_enumerable', 'ember-runtime/mixins/enumerable'], function (exports, property_get, utils, EmberError, mixin, EmberArray, MutableEnumerable, Enumerable) {
 
-        ### Property Observers
+  'use strict';
 
-        In addition to changing the property, `set()` will also register a property
-        change with the object. Unless you have placed this call inside of a
-        `beginPropertyChanges()` and `endPropertyChanges(),` any "local" observers
-        (i.e. observer methods declared on the same object), will be called
-        immediately. Any "remote" observers (i.e. observer methods declared on
-        another object) will be placed in a queue and called at a later time in a
-        coalesced manner.
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-        ### Chaining
 
-        In addition to property changes, `set()` returns the value of the object
-        itself so you can do chaining like this:
+  // require('ember-runtime/mixins/array');
+  // require('ember-runtime/mixins/mutable_enumerable');
 
-        ```javascript
-        record.set('firstName', 'Charles').set('lastName', 'Jolley');
-        ```
+  // ..........................................................
+  // CONSTANTS
+  //
 
-        @method set
-        @param {String} keyName The property to set
-        @param {Object} value The value to set or `null`.
-        @return {Ember.Observable}
-      */
-      set: function(keyName, value) {
-        set(this, keyName, value);
-        return this;
-      },
+  var OUT_OF_RANGE_EXCEPTION = "Index out of range";
+  var EMPTY = [];
 
+  // ..........................................................
+  // HELPERS
+  //
 
-      /**
-        Sets a list of properties at once. These properties are set inside
-        a single `beginPropertyChanges` and `endPropertyChanges` batch, so
-        observers will be buffered.
+  exports['default'] = mixin.Mixin.create(EmberArray['default'], MutableEnumerable['default'], {
 
-        ```javascript
-        record.setProperties({ firstName: 'Charles', lastName: 'Jolley' });
-        ```
+    /**
+      __Required.__ You must implement this method to apply this mixin.
 
-        @method setProperties
-        @param {Hash} hash the hash of keys and values to set
-        @return {Ember.Observable}
-      */
-      setProperties: function(hash) {
-        return setProperties(this, hash);
-      },
+      This is one of the primitives you must implement to support `Ember.Array`.
+      You should replace amt objects started at idx with the objects in the
+      passed array. You should also call `this.enumerableContentDidChange()`
 
-      /**
-        Begins a grouping of property changes.
-
-        You can use this method to group property changes so that notifications
-        will not be sent until the changes are finished. If you plan to make a
-        large number of changes to an object at one time, you should call this
-        method at the beginning of the changes to begin deferring change
-        notifications. When you are done making changes, call
-        `endPropertyChanges()` to deliver the deferred change notifications and end
-        deferring.
-
-        @method beginPropertyChanges
-        @return {Ember.Observable}
-      */
-      beginPropertyChanges: function() {
-        beginPropertyChanges();
-        return this;
-      },
+      @method replace
+      @param {Number} idx Starting index in the array to replace. If
+        idx >= length, then append to the end of the array.
+      @param {Number} amt Number of elements that should be removed from
+        the array, starting at *idx*.
+      @param {Array} objects An array of zero or more objects that should be
+        inserted into the array at *idx*
+    */
+    replace: mixin.required(),
 
-      /**
-        Ends a grouping of property changes.
+    /**
+      Remove all elements from the array. This is useful if you
+      want to reuse an existing array without having to recreate it.
 
-        You can use this method to group property changes so that notifications
-        will not be sent until the changes are finished. If you plan to make a
-        large number of changes to an object at one time, you should call
-        `beginPropertyChanges()` at the beginning of the changes to defer change
-        notifications. When you are done making changes, call this method to
-        deliver the deferred change notifications and end deferring.
+      ```javascript
+      var colors = ["red", "green", "blue"];
+      color.length();   //  3
+      colors.clear();   //  []
+      colors.length();  //  0
+      ```
 
-        @method endPropertyChanges
-        @return {Ember.Observable}
-      */
-      endPropertyChanges: function() {
-        endPropertyChanges();
+      @method clear
+      @return {Ember.Array} An empty Array.
+    */
+    clear: function () {
+      var len = property_get.get(this, 'length');
+      if (len === 0) {
         return this;
-      },
+      }
 
-      /**
-        Notify the observer system that a property is about to change.
-
-        Sometimes you need to change a value directly or indirectly without
-        actually calling `get()` or `set()` on it. In this case, you can use this
-        method and `propertyDidChange()` instead. Calling these two methods
-        together will notify all observers that the property has potentially
-        changed value.
-
-        Note that you must always call `propertyWillChange` and `propertyDidChange`
-        as a pair. If you do not, it may get the property change groups out of
-        order and cause notifications to be delivered more often than you would
-        like.
-
-        @method propertyWillChange
-        @param {String} keyName The property key that is about to change.
-        @return {Ember.Observable}
-      */
-      propertyWillChange: function(keyName) {
-        propertyWillChange(this, keyName);
-        return this;
-      },
+      this.replace(0, len, EMPTY);
+      return this;
+    },
+
+    /**
+      This will use the primitive `replace()` method to insert an object at the
+      specified index.
 
-      /**
-        Notify the observer system that a property has just changed.
-
-        Sometimes you need to change a value directly or indirectly without
-        actually calling `get()` or `set()` on it. In this case, you can use this
-        method and `propertyWillChange()` instead. Calling these two methods
-        together will notify all observers that the property has potentially
-        changed value.
-
-        Note that you must always call `propertyWillChange` and `propertyDidChange`
-        as a pair. If you do not, it may get the property change groups out of
-        order and cause notifications to be delivered more often than you would
-        like.
-
-        @method propertyDidChange
-        @param {String} keyName The property key that has just changed.
-        @return {Ember.Observable}
-      */
-      propertyDidChange: function(keyName) {
-        propertyDidChange(this, keyName);
-        return this;
-      },
+      ```javascript
+      var colors = ["red", "green", "blue"];
+      colors.insertAt(2, "yellow");  // ["red", "green", "yellow", "blue"]
+      colors.insertAt(5, "orange");  // Error: Index out of range
+      ```
 
-      /**
-        Convenience method to call `propertyWillChange` and `propertyDidChange` in
-        succession.
+      @method insertAt
+      @param {Number} idx index of insert the object at.
+      @param {Object} object object to insert
+      @return {Ember.Array} receiver
+    */
+    insertAt: function(idx, object) {
+      if (idx > property_get.get(this, 'length')) {
+        throw new EmberError['default'](OUT_OF_RANGE_EXCEPTION);
+      }
 
-        @method notifyPropertyChange
-        @param {String} keyName The property key to be notified about.
-        @return {Ember.Observable}
-      */
-      notifyPropertyChange: function(keyName) {
-        this.propertyWillChange(keyName);
-        this.propertyDidChange(keyName);
-        return this;
-      },
+      this.replace(idx, 0, [object]);
+      return this;
+    },
 
-      addBeforeObserver: function(key, target, method) {
-        Ember.deprecate('Before observers are deprecated and will be removed in a future release. If you want to keep track of previous values you have to implement it yourself.', false, { url: 'http://emberjs.com/guides/deprecations/#toc_deprecate-beforeobservers' });
-        addBeforeObserver(this, key, target, method);
-      },
+    /**
+      Remove an object at the specified index using the `replace()` primitive
+      method. You can pass either a single index, or a start and a length.
 
-      /**
-        Adds an observer on a property.
+      If you pass a start and length that is beyond the
+      length this method will throw an `OUT_OF_RANGE_EXCEPTION`.
 
-        This is the core method used to register an observer for a property.
+      ```javascript
+      var colors = ["red", "green", "blue", "yellow", "orange"];
+      colors.removeAt(0);     // ["green", "blue", "yellow", "orange"]
+      colors.removeAt(2, 2);  // ["green", "blue"]
+      colors.removeAt(4, 2);  // Error: Index out of range
+      ```
 
-        Once you call this method, any time the key's value is set, your observer
-        will be notified. Note that the observers are triggered any time the
-        value is set, regardless of whether it has actually changed. Your
-        observer should be prepared to handle that.
+      @method removeAt
+      @param {Number} start index, start of range
+      @param {Number} len length of passing range
+      @return {Ember.Array} receiver
+    */
+    removeAt: function(start, len) {
+      if ('number' === typeof start) {
 
-        You can also pass an optional context parameter to this method. The
-        context will be passed to your observer method whenever it is triggered.
-        Note that if you add the same target/method pair on a key multiple times
-        with different context parameters, your observer will only be called once
-        with the last context you passed.
+        if ((start < 0) || (start >= property_get.get(this, 'length'))) {
+          throw new EmberError['default'](OUT_OF_RANGE_EXCEPTION);
+        }
 
-        ### Observer Methods
+        // fast case
+        if (len === undefined) {
+          len = 1;
+        }
 
-        Observer methods you pass should generally have the following signature if
-        you do not pass a `context` parameter:
+        this.replace(start, len, EMPTY);
+      }
 
-        ```javascript
-        fooDidChange: function(sender, key, value, rev) { };
-        ```
+      return this;
+    },
 
-        The sender is the object that changed. The key is the property that
-        changes. The value property is currently reserved and unused. The rev
-        is the last property revision of the object when it changed, which you can
-        use to detect if the key value has really changed or not.
+    /**
+      Push the object onto the end of the array. Works just like `push()` but it
+      is KVO-compliant.
 
-        If you pass a `context` parameter, the context will be passed before the
-        revision like so:
+      ```javascript
+      var colors = ["red", "green"];
+      colors.pushObject("black");     // ["red", "green", "black"]
+      colors.pushObject(["yellow"]);  // ["red", "green", ["yellow"]]
+      ```
 
-        ```javascript
-        fooDidChange: function(sender, key, value, context, rev) { };
-        ```
+      @method pushObject
+      @param {*} obj object to push
+      @return object same object passed as a param
+    */
+    pushObject: function(obj) {
+      this.insertAt(property_get.get(this, 'length'), obj);
+      return obj;
+    },
 
-        Usually you will not need the value, context or revision parameters at
-        the end. In this case, it is common to write observer methods that take
-        only a sender and key value as parameters or, if you aren't interested in
-        any of these values, to write an observer that has no parameters at all.
+    /**
+      Add the objects in the passed numerable to the end of the array. Defers
+      notifying observers of the change until all objects are added.
 
-        @method addObserver
-        @param {String} key The key to observer
-        @param {Object} target The target object to invoke
-        @param {String|Function} method The method to invoke.
-      */
-      addObserver: function(key, target, method) {
-        addObserver(this, key, target, method);
-      },
+      ```javascript
+      var colors = ["red"];
+      colors.pushObjects(["yellow", "orange"]);  // ["red", "yellow", "orange"]
+      ```
 
-      /**
-        Remove an observer you have previously registered on this object. Pass
-        the same key, target, and method you passed to `addObserver()` and your
-        target will no longer receive notifications.
-
-        @method removeObserver
-        @param {String} key The key to observer
-        @param {Object} target The target object to invoke
-        @param {String|Function} method The method to invoke.
-      */
-      removeObserver: function(key, target, method) {
-        removeObserver(this, key, target, method);
-      },
+      @method pushObjects
+      @param {Ember.Enumerable} objects the objects to add
+      @return {Ember.Array} receiver
+    */
+    pushObjects: function(objects) {
+      if (!(Enumerable['default'].detect(objects) || utils.isArray(objects))) {
+        throw new TypeError("Must pass Ember.Enumerable to Ember.MutableArray#pushObjects");
+      }
+      this.replace(property_get.get(this, 'length'), 0, objects);
+      return this;
+    },
 
-      /**
-        Returns `true` if the object currently has observers registered for a
-        particular key. You can use this method to potentially defer performing
-        an expensive action until someone begins observing a particular property
-        on the object.
-
-        @method hasObserverFor
-        @param {String} key Key to check
-        @return {Boolean}
-      */
-      hasObserverFor: function(key) {
-        return hasListeners(this, key+':change');
-      },
+    /**
+      Pop object from array or nil if none are left. Works just like `pop()` but
+      it is KVO-compliant.
 
-      /**
-        Retrieves the value of a property, or a default value in the case that the
-        property returns `undefined`.
+      ```javascript
+      var colors = ["red", "green", "blue"];
+      colors.popObject();   // "blue"
+      console.log(colors);  // ["red", "green"]
+      ```
 
-        ```javascript
-        person.getWithDefault('lastName', 'Doe');
-        ```
+      @method popObject
+      @return object
+    */
+    popObject: function() {
+      var len = property_get.get(this, 'length');
+      if (len === 0) {
+        return null;
+      }
 
-        @method getWithDefault
-        @param {String} keyName The name of the property to retrieve
-        @param {Object} defaultValue The value to return if the property value is undefined
-        @return {Object} The property value or the defaultValue.
-      */
-      getWithDefault: function(keyName, defaultValue) {
-        return getWithDefault(this, keyName, defaultValue);
-      },
+      var ret = this.objectAt(len-1);
+      this.removeAt(len-1, 1);
+      return ret;
+    },
 
-      /**
-        Set the value of a property to the current value plus some amount.
+    /**
+      Shift an object from start of array or nil if none are left. Works just
+      like `shift()` but it is KVO-compliant.
 
-        ```javascript
-        person.incrementProperty('age');
-        team.incrementProperty('score', 2);
-        ```
+      ```javascript
+      var colors = ["red", "green", "blue"];
+      colors.shiftObject();  // "red"
+      console.log(colors);   // ["green", "blue"]
+      ```
 
-        @method incrementProperty
-        @param {String} keyName The name of the property to increment
-        @param {Number} increment The amount to increment by. Defaults to 1
-        @return {Number} The new property value
-      */
-      incrementProperty: function(keyName, increment) {
-        if (isNone(increment)) { increment = 1; }
-        Ember.assert("Must pass a numeric value to incrementProperty", (!isNaN(parseFloat(increment)) && isFinite(increment)));
-        set(this, keyName, (parseFloat(get(this, keyName)) || 0) + increment);
-        return get(this, keyName);
-      },
+      @method shiftObject
+      @return object
+    */
+    shiftObject: function() {
+      if (property_get.get(this, 'length') === 0) {
+        return null;
+      }
 
-      /**
-        Set the value of a property to the current value minus some amount.
+      var ret = this.objectAt(0);
+      this.removeAt(0);
+      return ret;
+    },
 
-        ```javascript
-        player.decrementProperty('lives');
-        orc.decrementProperty('health', 5);
-        ```
+    /**
+      Unshift an object to start of array. Works just like `unshift()` but it is
+      KVO-compliant.
 
-        @method decrementProperty
-        @param {String} keyName The name of the property to decrement
-        @param {Number} decrement The amount to decrement by. Defaults to 1
-        @return {Number} The new property value
-      */
-      decrementProperty: function(keyName, decrement) {
-        if (isNone(decrement)) { decrement = 1; }
-        Ember.assert("Must pass a numeric value to decrementProperty", (!isNaN(parseFloat(decrement)) && isFinite(decrement)));
-        set(this, keyName, (get(this, keyName) || 0) - decrement);
-        return get(this, keyName);
-      },
+      ```javascript
+      var colors = ["red"];
+      colors.unshiftObject("yellow");    // ["yellow", "red"]
+      colors.unshiftObject(["black"]);   // [["black"], "yellow", "red"]
+      ```
 
-      /**
-        Set the value of a boolean property to the opposite of its
-        current value.
+      @method unshiftObject
+      @param {*} obj object to unshift
+      @return object same object passed as a param
+    */
+    unshiftObject: function(obj) {
+      this.insertAt(0, obj);
+      return obj;
+    },
 
-        ```javascript
-        starship.toggleProperty('warpDriveEngaged');
-        ```
+    /**
+      Adds the named objects to the beginning of the array. Defers notifying
+      observers until all objects have been added.
 
-        @method toggleProperty
-        @param {String} keyName The name of the property to toggle
-        @return {Object} The new property value
-      */
-      toggleProperty: function(keyName) {
-        set(this, keyName, !get(this, keyName));
-        return get(this, keyName);
-      },
+      ```javascript
+      var colors = ["red"];
+      colors.unshiftObjects(["black", "white"]);   // ["black", "white", "red"]
+      colors.unshiftObjects("yellow"); // Type Error: 'undefined' is not a function
+      ```
 
-      /**
-        Returns the cached value of a computed property, if it exists.
-        This allows you to inspect the value of a computed property
-        without accidentally invoking it if it is intended to be
-        generated lazily.
-
-        @method cacheFor
-        @param {String} keyName
-        @return {Object} The cached value of the computed property, if any
-      */
-      cacheFor: function(keyName) {
-        return cacheFor(this, keyName);
-      },
+      @method unshiftObjects
+      @param {Ember.Enumerable} objects the objects to add
+      @return {Ember.Array} receiver
+    */
+    unshiftObjects: function(objects) {
+      this.replace(0, 0, objects);
+      return this;
+    },
+
+    /**
+      Reverse objects in the array. Works just like `reverse()` but it is
+      KVO-compliant.
 
-      // intended for debugging purposes
-      observersForKey: function(keyName) {
-        return observersFor(this, keyName);
+      @method reverseObjects
+      @return {Ember.Array} receiver
+     */
+    reverseObjects: function() {
+      var len = property_get.get(this, 'length');
+      if (len === 0) {
+        return this;
       }
-    });
-  });
-enifed("ember-runtime/mixins/promise_proxy",
-  ["ember-metal/property_get","ember-metal/set_properties","ember-metal/computed","ember-metal/mixin","ember-metal/error","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
-    var get = __dependency1__.get;
-    var setProperties = __dependency2__["default"];
-    var computed = __dependency3__.computed;
-    var Mixin = __dependency4__.Mixin;
-    var EmberError = __dependency5__["default"];
 
-    var not = computed.not;
-    var or = computed.or;
+      var objects = this.toArray().reverse();
+      this.replace(0, len, objects);
+      return this;
+    },
 
     /**
-      @module ember
-      @submodule ember-runtime
+      Replace all the receiver's content with content of the argument.
+      If argument is an empty array receiver will be cleared.
+
+      ```javascript
+      var colors = ["red", "green", "blue"];
+      colors.setObjects(["black", "white"]);  // ["black", "white"]
+      colors.setObjects([]);                  // []
+      ```
+
+      @method setObjects
+      @param {Ember.Array} objects array whose content will be used for replacing
+          the content of the receiver
+      @return {Ember.Array} receiver with the new content
      */
+    setObjects: function(objects) {
+      if (objects.length === 0) {
+        return this.clear();
+      }
 
-    function tap(proxy, promise) {
-      setProperties(proxy, {
-        isFulfilled: false,
-        isRejected: false
-      });
+      var len = property_get.get(this, 'length');
+      this.replace(0, len, objects);
+      return this;
+    },
 
-      return promise.then(function(value) {
-        setProperties(proxy, {
-          content: value,
-          isFulfilled: true
-        });
-        return value;
-      }, function(reason) {
-        setProperties(proxy, {
-          reason: reason,
-          isRejected: true
-        });
-        throw reason;
-      }, "Ember: PromiseProxy");
-    }
+    // ..........................................................
+    // IMPLEMENT Ember.MutableEnumerable
+    //
 
     /**
-      A low level mixin making ObjectProxy, ObjectController or ArrayController's promise aware.
+      Remove all occurrences of an object in the array.
 
       ```javascript
-      var ObjectPromiseController = Ember.ObjectController.extend(Ember.PromiseProxyMixin);
+      var cities = ["Chicago", "Berlin", "Lima", "Chicago"];
+      cities.removeObject("Chicago");  // ["Berlin", "Lima"]
+      cities.removeObject("Lima");     // ["Berlin"]
+      cities.removeObject("Tokyo")     // ["Berlin"]
+      ```
 
-      var controller = ObjectPromiseController.create({
-        promise: $.getJSON('/some/remote/data.json')
-      });
+      @method removeObject
+      @param {*} obj object to remove
+      @return {Ember.Array} receiver
+    */
+    removeObject: function(obj) {
+      var loc = property_get.get(this, 'length') || 0;
+      while (--loc >= 0) {
+        var curObject = this.objectAt(loc);
 
-      controller.then(function(json){
-         // the json
-      }, function(reason) {
-         // the reason why you have no json
-      });
-      ```
+        if (curObject === obj) {
+          this.removeAt(loc);
+        }
+      }
+      return this;
+    },
 
-      the controller has bindable attributes which
-      track the promises life cycle
+    /**
+      Push the object onto the end of the array if it is not already
+      present in the array.
 
       ```javascript
-      controller.get('isPending')   //=> true
-      controller.get('isSettled')  //=> false
-      controller.get('isRejected')  //=> false
-      controller.get('isFulfilled') //=> false
+      var cities = ["Chicago", "Berlin"];
+      cities.addObject("Lima");    // ["Chicago", "Berlin", "Lima"]
+      cities.addObject("Berlin");  // ["Chicago", "Berlin", "Lima"]
       ```
 
-      When the the $.getJSON completes, and the promise is fulfilled
-      with json, the life cycle attributes will update accordingly.
+      @method addObject
+      @param {*} obj object to add, if not already present
+      @return {Ember.Array} receiver
+    */
+    addObject: function(obj) {
+      if (!this.contains(obj)) {
+        this.pushObject(obj);
+      }
 
-      ```javascript
-      controller.get('isPending')   //=> false
-      controller.get('isSettled')   //=> true
-      controller.get('isRejected')  //=> false
-      controller.get('isFulfilled') //=> true
-      ```
+      return this;
+    }
 
-      As the controller is an ObjectController, and the json now its content,
-      all the json properties will be available directly from the controller.
+  });
 
-      ```javascript
-      // Assuming the following json:
-      {
-        firstName: 'Stefan',
-        lastName: 'Penner'
-      }
+});
+enifed('ember-runtime/mixins/mutable_enumerable', ['exports', 'ember-metal/enumerable_utils', 'ember-runtime/mixins/enumerable', 'ember-metal/mixin', 'ember-metal/property_events'], function (exports, enumerable_utils, Enumerable, mixin, property_events) {
 
-      // both properties will accessible on the controller
-      controller.get('firstName') //=> 'Stefan'
-      controller.get('lastName')  //=> 'Penner'
-      ```
+  'use strict';
 
-      If the controller is backing a template, the attributes are
-      bindable from within that template
+  exports['default'] = mixin.Mixin.create(Enumerable['default'], {
 
-      ```handlebars
-      {{#if isPending}}
-        loading...
-      {{else}}
-        firstName: {{firstName}}
-        lastName: {{lastName}}
-      {{/if}}
-      ```
-      @class Ember.PromiseProxyMixin
-    */
-    __exports__["default"] = Mixin.create({
-      /**
-        If the proxied promise is rejected this will contain the reason
-        provided.
+    /**
+      __Required.__ You must implement this method to apply this mixin.
 
-        @property reason
-        @default null
-      */
-      reason:  null,
+      Attempts to add the passed object to the receiver if the object is not
+      already present in the collection. If the object is present, this method
+      has no effect.
 
-      /**
-        Once the proxied promise has settled this will become `false`.
+      If the passed object is of a type not supported by the receiver,
+      then this method should raise an exception.
 
-        @property isPending
-        @default true
-      */
-      isPending:  not('isSettled').readOnly(),
+      @method addObject
+      @param {Object} object The object to add to the enumerable.
+      @return {Object} the passed object
+    */
+    addObject: mixin.required(Function),
 
-      /**
-        Once the proxied promise has settled this will become `true`.
+    /**
+      Adds each object in the passed enumerable to the receiver.
 
-        @property isSettled
-        @default false
-      */
-      isSettled:  or('isRejected', 'isFulfilled').readOnly(),
+      @method addObjects
+      @param {Ember.Enumerable} objects the objects to add.
+      @return {Object} receiver
+    */
+    addObjects: function(objects) {
+      property_events.beginPropertyChanges(this);
+      enumerable_utils.forEach(objects, function(obj) { this.addObject(obj); }, this);
+      property_events.endPropertyChanges(this);
+      return this;
+    },
 
-      /**
-        Will become `true` if the proxied promise is rejected.
+    /**
+      __Required.__ You must implement this method to apply this mixin.
 
-        @property isRejected
-        @default false
-      */
-      isRejected:  false,
+      Attempts to remove the passed object from the receiver collection if the
+      object is present in the collection. If the object is not present,
+      this method has no effect.
 
-      /**
-        Will become `true` if the proxied promise is fulfilled.
+      If the passed object is of a type not supported by the receiver,
+      then this method should raise an exception.
 
-        @property isFulfilled
-        @default false
-      */
-      isFulfilled: false,
+      @method removeObject
+      @param {Object} object The object to remove from the enumerable.
+      @return {Object} the passed object
+    */
+    removeObject: mixin.required(Function),
 
-      /**
-        The promise whose fulfillment value is being proxied by this object.
 
-        This property must be specified upon creation, and should not be
-        changed once created.
+    /**
+      Removes each object in the passed enumerable from the receiver.
 
-        Example:
+      @method removeObjects
+      @param {Ember.Enumerable} objects the objects to remove
+      @return {Object} receiver
+    */
+    removeObjects: function(objects) {
+      property_events.beginPropertyChanges(this);
+      for (var i = objects.length - 1; i >= 0; i--) {
+        this.removeObject(objects[i]);
+      }
+      property_events.endPropertyChanges(this);
+      return this;
+    }
+  });
 
-        ```javascript
-        Ember.ObjectController.extend(Ember.PromiseProxyMixin).create({
-          promise: <thenable>
-        });
-        ```
+});
+enifed('ember-runtime/mixins/observable', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/utils', 'ember-metal/get_properties', 'ember-metal/set_properties', 'ember-metal/mixin', 'ember-metal/events', 'ember-metal/property_events', 'ember-metal/observer', 'ember-metal/computed', 'ember-metal/is_none'], function (exports, Ember, property_get, property_set, utils, getProperties, setProperties, mixin, events, property_events, observer, computed, isNone) {
 
-        @property promise
-      */
-      promise: computed(function(key, promise) {
-        if (arguments.length === 2) {
-          return tap(this, promise);
-        } else {
-          throw new EmberError("PromiseProxy's promise must be set");
-        }
-      }),
+  'use strict';
 
-      /**
-        An alias to the proxied promise's `then`.
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
+  var slice = Array.prototype.slice;
+  /**
+    ## Overview
 
-        See RSVP.Promise.then.
+    This mixin provides properties and property observing functionality, core
+    features of the Ember object model.
 
-        @method then
-        @param {Function} callback
-        @return {RSVP.Promise}
-      */
-      then: promiseAlias('then'),
+    Properties and observers allow one object to observe changes to a
+    property on another object. This is one of the fundamental ways that
+    models, controllers and views communicate with each other in an Ember
+    application.
 
-      /**
-        An alias to the proxied promise's `catch`.
+    Any object that has this mixin applied can be used in observer
+    operations. That includes `Ember.Object` and most objects you will
+    interact with as you write your Ember application.
 
-        See RSVP.Promise.catch.
+    Note that you will not generally apply this mixin to classes yourself,
+    but you will use the features provided by this module frequently, so it
+    is important to understand how to use it.
 
-        @method catch
-        @param {Function} callback
-        @return {RSVP.Promise}
-        @since 1.3.0
-      */
-      'catch': promiseAlias('catch'),
+    ## Using `get()` and `set()`
 
-      /**
-        An alias to the proxied promise's `finally`.
+    Because of Ember's support for bindings and observers, you will always
+    access properties using the get method, and set properties using the
+    set method. This allows the observing objects to be notified and
+    computed properties to be handled properly.
 
-        See RSVP.Promise.finally.
+    More documentation about `get` and `set` are below.
 
-        @method finally
-        @param {Function} callback
-        @return {RSVP.Promise}
-        @since 1.3.0
-      */
-      'finally': promiseAlias('finally')
+    ## Observing Property Changes
+
+    You typically observe property changes simply by adding the `observes`
+    call to the end of your method declarations in classes that you write.
+    For example:
 
+    ```javascript
+    Ember.Object.extend({
+      valueObserver: function() {
+        // Executes whenever the "value" property changes
+      }.observes('value')
     });
+    ```
+
+    Although this is the most common way to add an observer, this capability
+    is actually built into the `Ember.Object` class on top of two methods
+    defined in this mixin: `addObserver` and `removeObserver`. You can use
+    these two methods to add and remove observers yourself if you need to
+    do so at runtime.
+
+    To add an observer for a property, call:
+
+    ```javascript
+    object.addObserver('propertyKey', targetObject, targetAction)
+    ```
+
+    This will call the `targetAction` method on the `targetObject` whenever
+    the value of the `propertyKey` changes.
+
+    Note that if `propertyKey` is a computed property, the observer will be
+    called when any of the property dependencies are changed, even if the
+    resulting value of the computed property is unchanged. This is necessary
+    because computed properties are not computed until `get` is called.
+
+    @class Observable
+    @namespace Ember
+  */
+  exports['default'] = mixin.Mixin.create({
 
-    function promiseAlias(name) {
-      return function () {
-        var promise = get(this, 'promise');
-        return promise[name].apply(promise, arguments);
-      };
-    }
-  });
-enifed("ember-runtime/mixins/sortable",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/enumerable_utils","ember-metal/mixin","ember-runtime/mixins/mutable_enumerable","ember-runtime/compare","ember-metal/observer","ember-metal/computed","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-runtime
-    */
+      Retrieves the value of a property from the object.
 
-    var Ember = __dependency1__["default"];
-    // Ember.assert, Ember.A
+      This method is usually similar to using `object[keyName]` or `object.keyName`,
+      however it supports both computed properties and the unknownProperty
+      handler.
 
-    var get = __dependency2__.get;
-    var forEach = __dependency3__.forEach;
-    var Mixin = __dependency4__.Mixin;
-    var MutableEnumerable = __dependency5__["default"];
-    var compare = __dependency6__["default"];
-    var addObserver = __dependency7__.addObserver;
-    var removeObserver = __dependency7__.removeObserver;
-    var computed = __dependency8__.computed;
-    var beforeObserver = __dependency4__.beforeObserver;
-    var observer = __dependency4__.observer;
-    //ES6TODO: should we access these directly from their package or from how their exposed in ember-metal?
-
-    /**
-      `Ember.SortableMixin` provides a standard interface for array proxies
-      to specify a sort order and maintain this sorting when objects are added,
-      removed, or updated without changing the implicit order of their underlying
-      model array:
+      Because `get` unifies the syntax for accessing all these kinds
+      of properties, it can make many refactorings easier, such as replacing a
+      simple property with a computed property, or vice versa.
+
+      ### Computed Properties
+
+      Computed properties are methods defined with the `property` modifier
+      declared at the end, such as:
 
       ```javascript
-      songs = [
-        {trackNumber: 4, title: 'Ob-La-Di, Ob-La-Da'},
-        {trackNumber: 2, title: 'Back in the U.S.S.R.'},
-        {trackNumber: 3, title: 'Glass Onion'},
-      ];
+      fullName: function() {
+        return this.get('firstName') + ' ' + this.get('lastName');
+      }.property('firstName', 'lastName')
+      ```
 
-      songsController = Ember.ArrayController.create({
-        model: songs,
-        sortProperties: ['trackNumber'],
-        sortAscending: true
-      });
+      When you call `get` on a computed property, the function will be
+      called and the return value will be returned instead of the function
+      itself.
 
-      songsController.get('firstObject');  // {trackNumber: 2, title: 'Back in the U.S.S.R.'}
+      ### Unknown Properties
 
-      songsController.addObject({trackNumber: 1, title: 'Dear Prudence'});
-      songsController.get('firstObject');  // {trackNumber: 1, title: 'Dear Prudence'}
-      ```
+      Likewise, if you try to call `get` on a property whose value is
+      `undefined`, the `unknownProperty()` method will be called on the object.
+      If this method returns any value other than `undefined`, it will be returned
+      instead. This allows you to implement "virtual" properties that are
+      not defined upfront.
+
+      @method get
+      @param {String} keyName The property to retrieve
+      @return {Object} The property value or undefined.
+    */
+    get: function(keyName) {
+      return property_get.get(this, keyName);
+    },
 
-      If you add or remove the properties to sort by or change the sort direction the model
-      sort order will be automatically updated.
+    /**
+      To get the values of multiple properties at once, call `getProperties`
+      with a list of strings or an array:
 
       ```javascript
-      songsController.set('sortProperties', ['title']);
-      songsController.get('firstObject'); // {trackNumber: 2, title: 'Back in the U.S.S.R.'}
-
-      songsController.toggleProperty('sortAscending');
-      songsController.get('firstObject'); // {trackNumber: 4, title: 'Ob-La-Di, Ob-La-Da'}
+      record.getProperties('firstName', 'lastName', 'zipCode');
+      // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
       ```
 
-      `SortableMixin` works by sorting the `arrangedContent` array, which is the array that
-      `ArrayProxy` displays. Due to the fact that the underlying 'content' array is not changed, that
-      array will not display the sorted list:
+      is equivalent to:
 
-       ```javascript
-      songsController.get('content').get('firstObject'); // Returns the unsorted original content
-      songsController.get('firstObject'); // Returns the sorted content.
+      ```javascript
+      record.getProperties(['firstName', 'lastName', 'zipCode']);
+      // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
       ```
 
-      Although the sorted content can also be accessed through the `arrangedContent` property,
-      it is preferable to use the proxied class and not the `arrangedContent` array directly.
-
-      @class SortableMixin
-      @namespace Ember
-      @uses Ember.MutableEnumerable
+      @method getProperties
+      @param {String...|Array} list of keys to get
+      @return {Hash}
     */
-    __exports__["default"] = Mixin.create(MutableEnumerable, {
+    getProperties: function() {
+      return utils.apply(null, getProperties['default'], [this].concat(slice.call(arguments)));
+    },
 
-      /**
-        Specifies which properties dictate the `arrangedContent`'s sort order.
+    /**
+      Sets the provided key or path to the value.
 
-        When specifying multiple properties the sorting will use properties
-        from the `sortProperties` array prioritized from first to last.
+      This method is generally very similar to calling `object[key] = value` or
+      `object.key = value`, except that it provides support for computed
+      properties, the `setUnknownProperty()` method and property observers.
 
-        @property {Array} sortProperties
-      */
-      sortProperties: null,
+      ### Computed Properties
 
-      /**
-        Specifies the `arrangedContent`'s sort direction.
-        Sorts the content in ascending order by default. Set to `false` to
-        use descending order.
+      If you try to set a value on a key that has a computed property handler
+      defined (see the `get()` method for an example), then `set()` will call
+      that method, passing both the value and key instead of simply changing
+      the value itself. This is useful for those times when you need to
+      implement a property that is composed of one or more member
+      properties.
 
-        @property {Boolean} sortAscending
-        @default true
-      */
-      sortAscending: true,
+      ### Unknown Properties
+
+      If you try to set a value on a key that is undefined in the target
+      object, then the `setUnknownProperty()` handler will be called instead. This
+      gives you an opportunity to implement complex "virtual" properties that
+      are not predefined on the object. If `setUnknownProperty()` returns
+      undefined, then `set()` will simply set the value on the object.
+
+      ### Property Observers
+
+      In addition to changing the property, `set()` will also register a property
+      change with the object. Unless you have placed this call inside of a
+      `beginPropertyChanges()` and `endPropertyChanges(),` any "local" observers
+      (i.e. observer methods declared on the same object), will be called
+      immediately. Any "remote" observers (i.e. observer methods declared on
+      another object) will be placed in a queue and called at a later time in a
+      coalesced manner.
+
+      ### Chaining
+
+      In addition to property changes, `set()` returns the value of the object
+      itself so you can do chaining like this:
+
+      ```javascript
+      record.set('firstName', 'Charles').set('lastName', 'Jolley');
+      ```
+
+      @method set
+      @param {String} keyName The property to set
+      @param {Object} value The value to set or `null`.
+      @return {Ember.Observable}
+    */
+    set: function(keyName, value) {
+      property_set.set(this, keyName, value);
+      return this;
+    },
+
+
+    /**
+      Sets a list of properties at once. These properties are set inside
+      a single `beginPropertyChanges` and `endPropertyChanges` batch, so
+      observers will be buffered.
+
+      ```javascript
+      record.setProperties({ firstName: 'Charles', lastName: 'Jolley' });
+      ```
 
-      /**
-        The function used to compare two values. You can override this if you
-        want to do custom comparisons. Functions must be of the type expected by
-        Array#sort, i.e.,
+      @method setProperties
+      @param {Hash} hash the hash of keys and values to set
+      @return {Ember.Observable}
+    */
+    setProperties: function(hash) {
+      return setProperties['default'](this, hash);
+    },
 
-        *  return 0 if the two parameters are equal,
-        *  return a negative value if the first parameter is smaller than the second or
-        *  return a positive value otherwise:
+    /**
+      Begins a grouping of property changes.
 
-        ```javascript
-        function(x, y) { // These are assumed to be integers
-          if (x === y)
-            return 0;
-          return x < y ? -1 : 1;
-        }
-        ```
+      You can use this method to group property changes so that notifications
+      will not be sent until the changes are finished. If you plan to make a
+      large number of changes to an object at one time, you should call this
+      method at the beginning of the changes to begin deferring change
+      notifications. When you are done making changes, call
+      `endPropertyChanges()` to deliver the deferred change notifications and end
+      deferring.
 
-        @property sortFunction
-        @type {Function}
-        @default Ember.compare
-      */
-      sortFunction: compare,
+      @method beginPropertyChanges
+      @return {Ember.Observable}
+    */
+    beginPropertyChanges: function() {
+      property_events.beginPropertyChanges();
+      return this;
+    },
 
-      orderBy: function(item1, item2) {
-        var result = 0;
-        var sortProperties = get(this, 'sortProperties');
-        var sortAscending = get(this, 'sortAscending');
-        var sortFunction = get(this, 'sortFunction');
+    /**
+      Ends a grouping of property changes.
 
-        Ember.assert("you need to define `sortProperties`", !!sortProperties);
+      You can use this method to group property changes so that notifications
+      will not be sent until the changes are finished. If you plan to make a
+      large number of changes to an object at one time, you should call
+      `beginPropertyChanges()` at the beginning of the changes to defer change
+      notifications. When you are done making changes, call this method to
+      deliver the deferred change notifications and end deferring.
 
-        forEach(sortProperties, function(propertyName) {
-          if (result === 0) {
-            result = sortFunction.call(this, get(item1, propertyName), get(item2, propertyName));
-            if ((result !== 0) && !sortAscending) {
-              result = (-1) * result;
-            }
-          }
-        }, this);
+      @method endPropertyChanges
+      @return {Ember.Observable}
+    */
+    endPropertyChanges: function() {
+      property_events.endPropertyChanges();
+      return this;
+    },
 
-        return result;
-      },
+    /**
+      Notify the observer system that a property is about to change.
 
-      destroy: function() {
-        var content = get(this, 'content');
-        var sortProperties = get(this, 'sortProperties');
+      Sometimes you need to change a value directly or indirectly without
+      actually calling `get()` or `set()` on it. In this case, you can use this
+      method and `propertyDidChange()` instead. Calling these two methods
+      together will notify all observers that the property has potentially
+      changed value.
 
-        if (content && sortProperties) {
-          forEach(content, function(item) {
-            forEach(sortProperties, function(sortProperty) {
-              removeObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
-            }, this);
-          }, this);
-        }
+      Note that you must always call `propertyWillChange` and `propertyDidChange`
+      as a pair. If you do not, it may get the property change groups out of
+      order and cause notifications to be delivered more often than you would
+      like.
 
-        return this._super();
-      },
+      @method propertyWillChange
+      @param {String} keyName The property key that is about to change.
+      @return {Ember.Observable}
+    */
+    propertyWillChange: function(keyName) {
+      property_events.propertyWillChange(this, keyName);
+      return this;
+    },
 
-      isSorted: computed.notEmpty('sortProperties'),
+    /**
+      Notify the observer system that a property has just changed.
 
-      /**
-        Overrides the default `arrangedContent` from `ArrayProxy` in order to sort by `sortFunction`.
-        Also sets up observers for each `sortProperty` on each item in the content Array.
+      Sometimes you need to change a value directly or indirectly without
+      actually calling `get()` or `set()` on it. In this case, you can use this
+      method and `propertyWillChange()` instead. Calling these two methods
+      together will notify all observers that the property has potentially
+      changed value.
 
-        @property arrangedContent
-      */
-      arrangedContent: computed('content', 'sortProperties.@each', function(key, value) {
-        var content = get(this, 'content');
-        var isSorted = get(this, 'isSorted');
-        var sortProperties = get(this, 'sortProperties');
-        var self = this;
+      Note that you must always call `propertyWillChange` and `propertyDidChange`
+      as a pair. If you do not, it may get the property change groups out of
+      order and cause notifications to be delivered more often than you would
+      like.
 
-        if (content && isSorted) {
-          content = content.slice();
-          content.sort(function(item1, item2) {
-            return self.orderBy(item1, item2);
-          });
-          forEach(content, function(item) {
-            forEach(sortProperties, function(sortProperty) {
-              addObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
-            }, this);
-          }, this);
-          return Ember.A(content);
-        }
+      @method propertyDidChange
+      @param {String} keyName The property key that has just changed.
+      @return {Ember.Observable}
+    */
+    propertyDidChange: function(keyName) {
+      property_events.propertyDidChange(this, keyName);
+      return this;
+    },
 
-        return content;
-      }),
+    /**
+      Convenience method to call `propertyWillChange` and `propertyDidChange` in
+      succession.
 
-      _contentWillChange: beforeObserver('content', function() {
-        var content = get(this, 'content');
-        var sortProperties = get(this, 'sortProperties');
+      @method notifyPropertyChange
+      @param {String} keyName The property key to be notified about.
+      @return {Ember.Observable}
+    */
+    notifyPropertyChange: function(keyName) {
+      this.propertyWillChange(keyName);
+      this.propertyDidChange(keyName);
+      return this;
+    },
 
-        if (content && sortProperties) {
-          forEach(content, function(item) {
-            forEach(sortProperties, function(sortProperty) {
-              removeObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
-            }, this);
-          }, this);
-        }
+    addBeforeObserver: function(key, target, method) {
+      Ember['default'].deprecate(
+        'Before observers are deprecated and will be removed in a future release. If you want to keep track of previous values you have to implement it yourself.',
+        false,
+        { url: 'http://emberjs.com/guides/deprecations/#toc_beforeobserver' }
+      );
+      observer.addBeforeObserver(this, key, target, method);
+    },
 
-        this._super();
-      }),
+    /**
+      Adds an observer on a property.
 
-      sortPropertiesWillChange: beforeObserver('sortProperties', function() {
-        this._lastSortAscending = undefined;
-      }),
+      This is the core method used to register an observer for a property.
 
-      sortPropertiesDidChange: observer('sortProperties', function() {
-        this._lastSortAscending = undefined;
-      }),
+      Once you call this method, any time the key's value is set, your observer
+      will be notified. Note that the observers are triggered any time the
+      value is set, regardless of whether it has actually changed. Your
+      observer should be prepared to handle that.
 
-      sortAscendingWillChange: beforeObserver('sortAscending', function() {
-        this._lastSortAscending = get(this, 'sortAscending');
-      }),
+      You can also pass an optional context parameter to this method. The
+      context will be passed to your observer method whenever it is triggered.
+      Note that if you add the same target/method pair on a key multiple times
+      with different context parameters, your observer will only be called once
+      with the last context you passed.
 
-      sortAscendingDidChange: observer('sortAscending', function() {
-        if (this._lastSortAscending !== undefined && get(this, 'sortAscending') !== this._lastSortAscending) {
-          var arrangedContent = get(this, 'arrangedContent');
-          arrangedContent.reverseObjects();
-        }
-      }),
+      ### Observer Methods
 
-      contentArrayWillChange: function(array, idx, removedCount, addedCount) {
-        var isSorted = get(this, 'isSorted');
+      Observer methods you pass should generally have the following signature if
+      you do not pass a `context` parameter:
 
-        if (isSorted) {
-          var arrangedContent = get(this, 'arrangedContent');
-          var removedObjects = array.slice(idx, idx+removedCount);
-          var sortProperties = get(this, 'sortProperties');
+      ```javascript
+      fooDidChange: function(sender, key, value, rev) { };
+      ```
 
-          forEach(removedObjects, function(item) {
-            arrangedContent.removeObject(item);
+      The sender is the object that changed. The key is the property that
+      changes. The value property is currently reserved and unused. The rev
+      is the last property revision of the object when it changed, which you can
+      use to detect if the key value has really changed or not.
 
-            forEach(sortProperties, function(sortProperty) {
-              removeObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
-            }, this);
-          }, this);
-        }
+      If you pass a `context` parameter, the context will be passed before the
+      revision like so:
 
-        return this._super(array, idx, removedCount, addedCount);
-      },
+      ```javascript
+      fooDidChange: function(sender, key, value, context, rev) { };
+      ```
 
-      contentArrayDidChange: function(array, idx, removedCount, addedCount) {
-        var isSorted = get(this, 'isSorted');
-        var sortProperties = get(this, 'sortProperties');
+      Usually you will not need the value, context or revision parameters at
+      the end. In this case, it is common to write observer methods that take
+      only a sender and key value as parameters or, if you aren't interested in
+      any of these values, to write an observer that has no parameters at all.
 
-        if (isSorted) {
-          var addedObjects = array.slice(idx, idx+addedCount);
+      @method addObserver
+      @param {String} key The key to observer
+      @param {Object} target The target object to invoke
+      @param {String|Function} method The method to invoke.
+    */
+    addObserver: function(key, target, method) {
+      observer.addObserver(this, key, target, method);
+    },
 
-          forEach(addedObjects, function(item) {
-            this.insertItemSorted(item);
+    /**
+      Remove an observer you have previously registered on this object. Pass
+      the same key, target, and method you passed to `addObserver()` and your
+      target will no longer receive notifications.
 
-            forEach(sortProperties, function(sortProperty) {
-              addObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
-            }, this);
-          }, this);
-        }
+      @method removeObserver
+      @param {String} key The key to observer
+      @param {Object} target The target object to invoke
+      @param {String|Function} method The method to invoke.
+    */
+    removeObserver: function(key, target, method) {
+      observer.removeObserver(this, key, target, method);
+    },
 
-        return this._super(array, idx, removedCount, addedCount);
-      },
+    /**
+      Returns `true` if the object currently has observers registered for a
+      particular key. You can use this method to potentially defer performing
+      an expensive action until someone begins observing a particular property
+      on the object.
 
-      insertItemSorted: function(item) {
-        var arrangedContent = get(this, 'arrangedContent');
-        var length = get(arrangedContent, 'length');
+      @method hasObserverFor
+      @param {String} key Key to check
+      @return {Boolean}
+    */
+    hasObserverFor: function(key) {
+      return events.hasListeners(this, key+':change');
+    },
 
-        var idx = this._binarySearch(item, 0, length);
-        arrangedContent.insertAt(idx, item);
-      },
+    /**
+      Retrieves the value of a property, or a default value in the case that the
+      property returns `undefined`.
 
-      contentItemSortPropertyDidChange: function(item) {
-        var arrangedContent = get(this, 'arrangedContent');
-        var oldIndex = arrangedContent.indexOf(item);
-        var leftItem = arrangedContent.objectAt(oldIndex - 1);
-        var rightItem = arrangedContent.objectAt(oldIndex + 1);
-        var leftResult = leftItem && this.orderBy(item, leftItem);
-        var rightResult = rightItem && this.orderBy(item, rightItem);
+      ```javascript
+      person.getWithDefault('lastName', 'Doe');
+      ```
 
-        if (leftResult < 0 || rightResult > 0) {
-          arrangedContent.removeObject(item);
-          this.insertItemSorted(item);
-        }
-      },
+      @method getWithDefault
+      @param {String} keyName The name of the property to retrieve
+      @param {Object} defaultValue The value to return if the property value is undefined
+      @return {Object} The property value or the defaultValue.
+    */
+    getWithDefault: function(keyName, defaultValue) {
+      return property_get.getWithDefault(this, keyName, defaultValue);
+    },
 
-      _binarySearch: function(item, low, high) {
-        var mid, midItem, res, arrangedContent;
+    /**
+      Set the value of a property to the current value plus some amount.
 
-        if (low === high) {
-          return low;
-        }
+      ```javascript
+      person.incrementProperty('age');
+      team.incrementProperty('score', 2);
+      ```
 
-        arrangedContent = get(this, 'arrangedContent');
+      @method incrementProperty
+      @param {String} keyName The name of the property to increment
+      @param {Number} increment The amount to increment by. Defaults to 1
+      @return {Number} The new property value
+    */
+    incrementProperty: function(keyName, increment) {
+      if (isNone['default'](increment)) { increment = 1; }
+      Ember['default'].assert("Must pass a numeric value to incrementProperty", (!isNaN(parseFloat(increment)) && isFinite(increment)));
+      property_set.set(this, keyName, (parseFloat(property_get.get(this, keyName)) || 0) + increment);
+      return property_get.get(this, keyName);
+    },
 
-        mid = low + Math.floor((high - low) / 2);
-        midItem = arrangedContent.objectAt(mid);
+    /**
+      Set the value of a property to the current value minus some amount.
 
-        res = this.orderBy(midItem, item);
+      ```javascript
+      player.decrementProperty('lives');
+      orc.decrementProperty('health', 5);
+      ```
 
-        if (res < 0) {
-          return this._binarySearch(item, mid+1, high);
-        } else if (res > 0) {
-          return this._binarySearch(item, low, mid);
-        }
+      @method decrementProperty
+      @param {String} keyName The name of the property to decrement
+      @param {Number} decrement The amount to decrement by. Defaults to 1
+      @return {Number} The new property value
+    */
+    decrementProperty: function(keyName, decrement) {
+      if (isNone['default'](decrement)) { decrement = 1; }
+      Ember['default'].assert("Must pass a numeric value to decrementProperty", (!isNaN(parseFloat(decrement)) && isFinite(decrement)));
+      property_set.set(this, keyName, (property_get.get(this, keyName) || 0) - decrement);
+      return property_get.get(this, keyName);
+    },
 
-        return mid;
-      }
-    });
-  });
-enifed("ember-runtime/mixins/target_action_support",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/mixin","ember-metal/computed","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-runtime
-    */
-    var Ember = __dependency1__["default"];
-    // Ember.lookup, Ember.assert
+      Set the value of a boolean property to the opposite of its
+      current value.
 
-    var get = __dependency2__.get;
-    var typeOf = __dependency3__.typeOf;
-    var Mixin = __dependency4__.Mixin;
-    var computed = __dependency5__.computed;
+      ```javascript
+      starship.toggleProperty('warpDriveEngaged');
+      ```
 
-    /**
-    `Ember.TargetActionSupport` is a mixin that can be included in a class
-    to add a `triggerAction` method with semantics similar to the Handlebars
-    `{{action}}` helper. In normal Ember usage, the `{{action}}` helper is
-    usually the best choice. This mixin is most often useful when you are
-    doing more complex event handling in View objects.
+      @method toggleProperty
+      @param {String} keyName The name of the property to toggle
+      @return {Object} The new property value
+    */
+    toggleProperty: function(keyName) {
+      property_set.set(this, keyName, !property_get.get(this, keyName));
+      return property_get.get(this, keyName);
+    },
 
-    See also `Ember.ViewTargetActionSupport`, which has
-    view-aware defaults for target and actionContext.
+    /**
+      Returns the cached value of a computed property, if it exists.
+      This allows you to inspect the value of a computed property
+      without accidentally invoking it if it is intended to be
+      generated lazily.
 
-    @class TargetActionSupport
-    @namespace Ember
-    @extends Ember.Mixin
+      @method cacheFor
+      @param {String} keyName
+      @return {Object} The cached value of the computed property, if any
     */
-    var TargetActionSupport = Mixin.create({
-      target: null,
-      action: null,
-      actionContext: null,
+    cacheFor: function(keyName) {
+      return computed.cacheFor(this, keyName);
+    },
 
-      targetObject: computed(function() {
-        var target = get(this, 'target');
+    // intended for debugging purposes
+    observersForKey: function(keyName) {
+      return observer.observersFor(this, keyName);
+    }
+  });
 
-        if (typeOf(target) === "string") {
-          var value = get(this, target);
-          if (value === undefined) { value = get(Ember.lookup, target); }
-          return value;
-        } else {
-          return target;
-        }
-      }).property('target'),
+});
+enifed('ember-runtime/mixins/promise_proxy', ['exports', 'ember-metal/property_get', 'ember-metal/set_properties', 'ember-metal/computed', 'ember-metal/mixin', 'ember-metal/error'], function (exports, property_get, setProperties, computed, mixin, EmberError) {
 
-      actionContextObject: computed(function() {
-        var actionContext = get(this, 'actionContext');
+  'use strict';
 
-        if (typeOf(actionContext) === "string") {
-          var value = get(this, actionContext);
-          if (value === undefined) { value = get(Ember.lookup, actionContext); }
-          return value;
-        } else {
-          return actionContext;
-        }
-      }).property('actionContext'),
+  var not = computed.computed.not;
+  var or = computed.computed.or;
 
-      /**
-      Send an `action` with an `actionContext` to a `target`. The action, actionContext
-      and target will be retrieved from properties of the object. For example:
+  /**
+    @module ember
+    @submodule ember-runtime
+   */
 
-      ```javascript
-      App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
-        target: Ember.computed.alias('controller'),
-        action: 'save',
-        actionContext: Ember.computed.alias('context'),
-        click: function() {
-          this.triggerAction(); // Sends the `save` action, along with the current context
-                                // to the current controller
-        }
+  function tap(proxy, promise) {
+    setProperties['default'](proxy, {
+      isFulfilled: false,
+      isRejected: false
+    });
+
+    return promise.then(function(value) {
+      setProperties['default'](proxy, {
+        content: value,
+        isFulfilled: true
       });
-      ```
+      return value;
+    }, function(reason) {
+      setProperties['default'](proxy, {
+        reason: reason,
+        isRejected: true
+      });
+      throw reason;
+    }, "Ember: PromiseProxy");
+  }
 
-      The `target`, `action`, and `actionContext` can be provided as properties of
-      an optional object argument to `triggerAction` as well.
+  /**
+    A low level mixin making ObjectProxy, ObjectController or ArrayController's promise aware.
 
-      ```javascript
-      App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
-        click: function() {
-          this.triggerAction({
-            action: 'save',
-            target: this.get('controller'),
-            actionContext: this.get('context')
-          }); // Sends the `save` action, along with the current context
-              // to the current controller
-        }
-      });
-      ```
+    ```javascript
+    var ObjectPromiseController = Ember.ObjectController.extend(Ember.PromiseProxyMixin);
 
-      The `actionContext` defaults to the object you are mixing `TargetActionSupport` into.
-      But `target` and `action` must be specified either as properties or with the argument
-      to `triggerAction`, or a combination:
+    var controller = ObjectPromiseController.create({
+      promise: $.getJSON('/some/remote/data.json')
+    });
 
-      ```javascript
-      App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
-        target: Ember.computed.alias('controller'),
-        click: function() {
-          this.triggerAction({
-            action: 'save'
-          }); // Sends the `save` action, along with a reference to `this`,
-              // to the current controller
-        }
-      });
-      ```
+    controller.then(function(json){
+       // the json
+    }, function(reason) {
+       // the reason why you have no json
+    });
+    ```
 
-      @method triggerAction
-      @param opts {Hash} (optional, with the optional keys action, target and/or actionContext)
-      @return {Boolean} true if the action was sent successfully and did not return false
-      */
-      triggerAction: function(opts) {
-        opts = opts || {};
-        var action = opts.action || get(this, 'action');
-        var target = opts.target || get(this, 'targetObject');
-        var actionContext = opts.actionContext;
+    the controller has bindable attributes which
+    track the promises life cycle
 
-        function args(options, actionName) {
-          var ret = [];
-          if (actionName) { ret.push(actionName); }
+    ```javascript
+    controller.get('isPending')   //=> true
+    controller.get('isSettled')  //=> false
+    controller.get('isRejected')  //=> false
+    controller.get('isFulfilled') //=> false
+    ```
 
-          return ret.concat(options);
-        }
+    When the the $.getJSON completes, and the promise is fulfilled
+    with json, the life cycle attributes will update accordingly.
 
-        if (typeof actionContext === 'undefined') {
-          actionContext = get(this, 'actionContextObject') || this;
-        }
+    ```javascript
+    controller.get('isPending')   //=> false
+    controller.get('isSettled')   //=> true
+    controller.get('isRejected')  //=> false
+    controller.get('isFulfilled') //=> true
+    ```
 
-        if (target && action) {
-          var ret;
+    As the controller is an ObjectController, and the json now its content,
+    all the json properties will be available directly from the controller.
 
-          if (target.send) {
-            ret = target.send.apply(target, args(actionContext, action));
-          } else {
-            Ember.assert("The action '" + action + "' did not exist on " + target, typeof target[action] === 'function');
-            ret = target[action].apply(target, args(actionContext));
-          }
+    ```javascript
+    // Assuming the following json:
+    {
+      firstName: 'Stefan',
+      lastName: 'Penner'
+    }
 
-          if (ret !== false) ret = true;
+    // both properties will accessible on the controller
+    controller.get('firstName') //=> 'Stefan'
+    controller.get('lastName')  //=> 'Penner'
+    ```
 
-          return ret;
-        } else {
-          return false;
-        }
-      }
-    });
+    If the controller is backing a template, the attributes are
+    bindable from within that template
 
-    __exports__["default"] = TargetActionSupport;
-  });
-enifed("ember-runtime/system/application",
-  ["ember-runtime/system/namespace","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Namespace = __dependency1__["default"];
+    ```handlebars
+    {{#if isPending}}
+      loading...
+    {{else}}
+      firstName: {{firstName}}
+      lastName: {{lastName}}
+    {{/if}}
+    ```
+    @class Ember.PromiseProxyMixin
+  */
+  exports['default'] = mixin.Mixin.create({
+    /**
+      If the proxied promise is rejected this will contain the reason
+      provided.
 
-    __exports__["default"] = Namespace.extend();
-  });
-enifed("ember-runtime/system/array_proxy",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/computed","ember-metal/mixin","ember-metal/property_events","ember-metal/error","ember-runtime/system/object","ember-runtime/mixins/mutable_array","ember-runtime/mixins/enumerable","ember-runtime/system/string","ember-metal/alias","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var get = __dependency2__.get;
-    var isArray = __dependency3__.isArray;
-    var apply = __dependency3__.apply;
-    var computed = __dependency4__.computed;
-    var beforeObserver = __dependency5__.beforeObserver;
-    var observer = __dependency5__.observer;
-    var beginPropertyChanges = __dependency6__.beginPropertyChanges;
-    var endPropertyChanges = __dependency6__.endPropertyChanges;
-    var EmberError = __dependency7__["default"];
-    var EmberObject = __dependency8__["default"];
-    var MutableArray = __dependency9__["default"];
-    var Enumerable = __dependency10__["default"];
-    var fmt = __dependency11__.fmt;
-    var alias = __dependency12__["default"];
+      @property reason
+      @default null
+    */
+    reason:  null,
 
     /**
-    @module ember
-    @submodule ember-runtime
+      Once the proxied promise has settled this will become `false`.
+
+      @property isPending
+      @default true
+    */
+    isPending:  not('isSettled').readOnly(),
+
+    /**
+      Once the proxied promise has settled this will become `true`.
+
+      @property isSettled
+      @default false
     */
+    isSettled:  or('isRejected', 'isFulfilled').readOnly(),
 
-    var OUT_OF_RANGE_EXCEPTION = "Index out of range";
-    var EMPTY = [];
+    /**
+      Will become `true` if the proxied promise is rejected.
 
-    function K() { return this; }
+      @property isRejected
+      @default false
+    */
+    isRejected:  false,
 
     /**
-      An ArrayProxy wraps any other object that implements `Ember.Array` and/or
-      `Ember.MutableArray,` forwarding all requests. This makes it very useful for
-      a number of binding use cases or other cases where being able to swap
-      out the underlying array is useful.
+      Will become `true` if the proxied promise is fulfilled.
 
-      A simple example of usage:
+      @property isFulfilled
+      @default false
+    */
+    isFulfilled: false,
 
-      ```javascript
-      var pets = ['dog', 'cat', 'fish'];
-      var ap = Ember.ArrayProxy.create({ content: Ember.A(pets) });
+    /**
+      The promise whose fulfillment value is being proxied by this object.
 
-      ap.get('firstObject');                        // 'dog'
-      ap.set('content', ['amoeba', 'paramecium']);
-      ap.get('firstObject');                        // 'amoeba'
-      ```
+      This property must be specified upon creation, and should not be
+      changed once created.
 
-      This class can also be useful as a layer to transform the contents of
-      an array, as they are accessed. This can be done by overriding
-      `objectAtContent`:
+      Example:
 
       ```javascript
-      var pets = ['dog', 'cat', 'fish'];
-      var ap = Ember.ArrayProxy.create({
-          content: Ember.A(pets),
-          objectAtContent: function(idx) {
-              return this.get('content').objectAt(idx).toUpperCase();
-          }
+      Ember.ObjectController.extend(Ember.PromiseProxyMixin).create({
+        promise: <thenable>
       });
-
-      ap.get('firstObject'); // . 'DOG'
       ```
 
-      @class ArrayProxy
-      @namespace Ember
-      @extends Ember.Object
-      @uses Ember.MutableArray
+      @property promise
     */
-    var ArrayProxy = EmberObject.extend(MutableArray, {
-
-      /**
-        The content array. Must be an object that implements `Ember.Array` and/or
-        `Ember.MutableArray.`
-
-        @property content
-        @type Ember.Array
-      */
-      content: null,
-
-      /**
-       The array that the proxy pretends to be. In the default `ArrayProxy`
-       implementation, this and `content` are the same. Subclasses of `ArrayProxy`
-       can override this property to provide things like sorting and filtering.
+    promise: computed.computed(function(key, promise) {
+      if (arguments.length === 2) {
+        return tap(this, promise);
+      } else {
+        throw new EmberError['default']("PromiseProxy's promise must be set");
+      }
+    }),
 
-       @property arrangedContent
-      */
-      arrangedContent: alias('content'),
+    /**
+      An alias to the proxied promise's `then`.
 
-      /**
-        Should actually retrieve the object at the specified index from the
-        content. You can override this method in subclasses to transform the
-        content item to something new.
+      See RSVP.Promise.then.
 
-        This method will only be called if content is non-`null`.
+      @method then
+      @param {Function} callback
+      @return {RSVP.Promise}
+    */
+    then: promiseAlias('then'),
 
-        @method objectAtContent
-        @param {Number} idx The index to retrieve.
-        @return {Object} the value or undefined if none found
-      */
-      objectAtContent: function(idx) {
-        return get(this, 'arrangedContent').objectAt(idx);
-      },
+    /**
+      An alias to the proxied promise's `catch`.
 
-      /**
-        Should actually replace the specified objects on the content array.
-        You can override this method in subclasses to transform the content item
-        into something new.
-
-        This method will only be called if content is non-`null`.
-
-        @method replaceContent
-        @param {Number} idx The starting index
-        @param {Number} amt The number of items to remove from the content.
-        @param {Array} objects Optional array of objects to insert or null if no
-          objects.
-        @return {void}
-      */
-      replaceContent: function(idx, amt, objects) {
-        get(this, 'content').replace(idx, amt, objects);
-      },
+      See RSVP.Promise.catch.
 
-      /**
-        Invoked when the content property is about to change. Notifies observers that the
-        entire array content will change.
+      @method catch
+      @param {Function} callback
+      @return {RSVP.Promise}
+      @since 1.3.0
+    */
+    'catch': promiseAlias('catch'),
 
-        @private
-        @method _contentWillChange
-      */
-      _contentWillChange: beforeObserver('content', function() {
-        this._teardownContent();
-      }),
+    /**
+      An alias to the proxied promise's `finally`.
 
-      _teardownContent: function() {
-        var content = get(this, 'content');
+      See RSVP.Promise.finally.
 
-        if (content) {
-          content.removeArrayObserver(this, {
-            willChange: 'contentArrayWillChange',
-            didChange: 'contentArrayDidChange'
-          });
-        }
-      },
+      @method finally
+      @param {Function} callback
+      @return {RSVP.Promise}
+      @since 1.3.0
+    */
+    'finally': promiseAlias('finally')
 
-      /**
-        Override to implement content array `willChange` observer.
+  });
 
-        @method contentArrayWillChange
+  function promiseAlias(name) {
+    return function () {
+      var promise = property_get.get(this, 'promise');
+      return promise[name].apply(promise, arguments);
+    };
+  }
 
-        @param {Ember.Array} contentArray the content array
-        @param {Number} start starting index of the change
-        @param {Number} removeCount count of items removed
-        @param {Number} addCount count of items added
+});
+enifed('ember-runtime/mixins/sortable', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/enumerable_utils', 'ember-runtime/mixins/mutable_enumerable', 'ember-runtime/compare', 'ember-metal/observer', 'ember-metal/computed', 'ember-metal/computed_macros', 'ember-metal/mixin'], function (exports, Ember, property_get, enumerable_utils, MutableEnumerable, compare, observer, computed, computed_macros, mixin) {
 
-      */
-      contentArrayWillChange: K,
-      /**
-        Override to implement content array `didChange` observer.
+  'use strict';
 
-        @method contentArrayDidChange
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-        @param {Ember.Array} contentArray the content array
-        @param {Number} start starting index of the change
-        @param {Number} removeCount count of items removed
-        @param {Number} addCount count of items added
-      */
-      contentArrayDidChange: K,
+  exports['default'] = mixin.Mixin.create(MutableEnumerable['default'], {
 
-      /**
-        Invoked when the content property changes. Notifies observers that the
-        entire array content has changed.
+    /**
+      Specifies which properties dictate the `arrangedContent`'s sort order.
 
-        @private
-        @method _contentDidChange
-      */
-      _contentDidChange: observer('content', function() {
-        var content = get(this, 'content');
+      When specifying multiple properties the sorting will use properties
+      from the `sortProperties` array prioritized from first to last.
 
-        Ember.assert("Can't set ArrayProxy's content to itself", content !== this);
+      @property {Array} sortProperties
+    */
+    sortProperties: null,
 
-        this._setupContent();
-      }),
+    /**
+      Specifies the `arrangedContent`'s sort direction.
+      Sorts the content in ascending order by default. Set to `false` to
+      use descending order.
 
-      _setupContent: function() {
-        var content = get(this, 'content');
+      @property {Boolean} sortAscending
+      @default true
+    */
+    sortAscending: true,
 
-        if (content) {
-          Ember.assert(fmt('ArrayProxy expects an Array or ' +
-            'Ember.ArrayProxy, but you passed %@', [typeof content]),
-            isArray(content) || content.isDestroyed);
+    /**
+      The function used to compare two values. You can override this if you
+      want to do custom comparisons. Functions must be of the type expected by
+      Array#sort, i.e.,
 
-          content.addArrayObserver(this, {
-            willChange: 'contentArrayWillChange',
-            didChange: 'contentArrayDidChange'
-          });
-        }
-      },
+      *  return 0 if the two parameters are equal,
+      *  return a negative value if the first parameter is smaller than the second or
+      *  return a positive value otherwise:
 
-      _arrangedContentWillChange: beforeObserver('arrangedContent', function() {
-        var arrangedContent = get(this, 'arrangedContent');
-        var len = arrangedContent ? get(arrangedContent, 'length') : 0;
+      ```javascript
+      function(x, y) { // These are assumed to be integers
+        if (x === y)
+          return 0;
+        return x < y ? -1 : 1;
+      }
+      ```
 
-        this.arrangedContentArrayWillChange(this, 0, len, undefined);
-        this.arrangedContentWillChange(this);
+      @property sortFunction
+      @type {Function}
+      @default Ember.compare
+    */
+    sortFunction: compare['default'],
 
-        this._teardownArrangedContent(arrangedContent);
-      }),
+    orderBy: function(item1, item2) {
+      var result = 0;
+      var sortProperties = property_get.get(this, 'sortProperties');
+      var sortAscending = property_get.get(this, 'sortAscending');
+      var sortFunction = property_get.get(this, 'sortFunction');
 
-      _arrangedContentDidChange: observer('arrangedContent', function() {
-        var arrangedContent = get(this, 'arrangedContent');
-        var len = arrangedContent ? get(arrangedContent, 'length') : 0;
+      Ember['default'].assert("you need to define `sortProperties`", !!sortProperties);
 
-        Ember.assert("Can't set ArrayProxy's content to itself", arrangedContent !== this);
+      enumerable_utils.forEach(sortProperties, function(propertyName) {
+        if (result === 0) {
+          result = sortFunction.call(this, property_get.get(item1, propertyName), property_get.get(item2, propertyName));
+          if ((result !== 0) && !sortAscending) {
+            result = (-1) * result;
+          }
+        }
+      }, this);
 
-        this._setupArrangedContent();
+      return result;
+    },
 
-        this.arrangedContentDidChange(this);
-        this.arrangedContentArrayDidChange(this, 0, undefined, len);
-      }),
+    destroy: function() {
+      var content = property_get.get(this, 'content');
+      var sortProperties = property_get.get(this, 'sortProperties');
 
-      _setupArrangedContent: function() {
-        var arrangedContent = get(this, 'arrangedContent');
+      if (content && sortProperties) {
+        enumerable_utils.forEach(content, function(item) {
+          enumerable_utils.forEach(sortProperties, function(sortProperty) {
+            observer.removeObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
+          }, this);
+        }, this);
+      }
 
-        if (arrangedContent) {
-          Ember.assert(fmt('ArrayProxy expects an Array or ' +
-            'Ember.ArrayProxy, but you passed %@', [typeof arrangedContent]),
-            isArray(arrangedContent) || arrangedContent.isDestroyed);
+      return this._super.apply(this, arguments);
+    },
 
-          arrangedContent.addArrayObserver(this, {
-            willChange: 'arrangedContentArrayWillChange',
-            didChange: 'arrangedContentArrayDidChange'
-          });
-        }
-      },
+    isSorted: computed_macros.notEmpty('sortProperties'),
 
-      _teardownArrangedContent: function() {
-        var arrangedContent = get(this, 'arrangedContent');
+    /**
+      Overrides the default `arrangedContent` from `ArrayProxy` in order to sort by `sortFunction`.
+      Also sets up observers for each `sortProperty` on each item in the content Array.
 
-        if (arrangedContent) {
-          arrangedContent.removeArrayObserver(this, {
-            willChange: 'arrangedContentArrayWillChange',
-            didChange: 'arrangedContentArrayDidChange'
-          });
-        }
-      },
+      @property arrangedContent
+    */
+    arrangedContent: computed.computed('content', 'sortProperties.@each', function(key, value) {
+      var content = property_get.get(this, 'content');
+      var isSorted = property_get.get(this, 'isSorted');
+      var sortProperties = property_get.get(this, 'sortProperties');
+      var self = this;
 
-      arrangedContentWillChange: K,
-      arrangedContentDidChange: K,
+      if (content && isSorted) {
+        content = content.slice();
+        content.sort(function(item1, item2) {
+          return self.orderBy(item1, item2);
+        });
+        enumerable_utils.forEach(content, function(item) {
+          enumerable_utils.forEach(sortProperties, function(sortProperty) {
+            observer.addObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
+          }, this);
+        }, this);
+        return Ember['default'].A(content);
+      }
 
-      objectAt: function(idx) {
-        return get(this, 'content') && this.objectAtContent(idx);
-      },
+      return content;
+    }),
 
-      length: computed(function() {
-        var arrangedContent = get(this, 'arrangedContent');
-        return arrangedContent ? get(arrangedContent, 'length') : 0;
-        // No dependencies since Enumerable notifies length of change
-      }),
+    _contentWillChange: mixin.beforeObserver('content', function() {
+      var content = property_get.get(this, 'content');
+      var sortProperties = property_get.get(this, 'sortProperties');
 
-      _replace: function(idx, amt, objects) {
-        var content = get(this, 'content');
-        Ember.assert('The content property of '+ this.constructor + ' should be set before modifying it', content);
-        if (content) this.replaceContent(idx, amt, objects);
-        return this;
-      },
+      if (content && sortProperties) {
+        enumerable_utils.forEach(content, function(item) {
+          enumerable_utils.forEach(sortProperties, function(sortProperty) {
+            observer.removeObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
+          }, this);
+        }, this);
+      }
 
-      replace: function() {
-        if (get(this, 'arrangedContent') === get(this, 'content')) {
-          apply(this, this._replace, arguments);
-        } else {
-          throw new EmberError("Using replace on an arranged ArrayProxy is not allowed.");
-        }
-      },
+      this._super.apply(this, arguments);
+    }),
 
-      _insertAt: function(idx, object) {
-        if (idx > get(this, 'content.length')) throw new EmberError(OUT_OF_RANGE_EXCEPTION);
-        this._replace(idx, 0, [object]);
-        return this;
-      },
+    sortPropertiesWillChange: mixin.beforeObserver('sortProperties', function() {
+      this._lastSortAscending = undefined;
+    }),
 
-      insertAt: function(idx, object) {
-        if (get(this, 'arrangedContent') === get(this, 'content')) {
-          return this._insertAt(idx, object);
-        } else {
-          throw new EmberError("Using insertAt on an arranged ArrayProxy is not allowed.");
-        }
-      },
+    sortPropertiesDidChange: mixin.observer('sortProperties', function() {
+      this._lastSortAscending = undefined;
+    }),
 
-      removeAt: function(start, len) {
-        if ('number' === typeof start) {
-          var content = get(this, 'content');
-          var arrangedContent = get(this, 'arrangedContent');
-          var indices = [];
-          var i;
+    sortAscendingWillChange: mixin.beforeObserver('sortAscending', function() {
+      this._lastSortAscending = property_get.get(this, 'sortAscending');
+    }),
 
-          if ((start < 0) || (start >= get(this, 'length'))) {
-            throw new EmberError(OUT_OF_RANGE_EXCEPTION);
-          }
+    sortAscendingDidChange: mixin.observer('sortAscending', function() {
+      if (this._lastSortAscending !== undefined && property_get.get(this, 'sortAscending') !== this._lastSortAscending) {
+        var arrangedContent = property_get.get(this, 'arrangedContent');
+        arrangedContent.reverseObjects();
+      }
+    }),
 
-          if (len === undefined) len = 1;
+    contentArrayWillChange: function(array, idx, removedCount, addedCount) {
+      var isSorted = property_get.get(this, 'isSorted');
 
-          // Get a list of indices in original content to remove
-          for (i=start; i<start+len; i++) {
-            // Use arrangedContent here so we avoid confusion with objects transformed by objectAtContent
-            indices.push(content.indexOf(arrangedContent.objectAt(i)));
-          }
+      if (isSorted) {
+        var arrangedContent = property_get.get(this, 'arrangedContent');
+        var removedObjects = array.slice(idx, idx+removedCount);
+        var sortProperties = property_get.get(this, 'sortProperties');
 
-          // Replace in reverse order since indices will change
-          indices.sort(function(a,b) { return b - a; });
+        enumerable_utils.forEach(removedObjects, function(item) {
+          arrangedContent.removeObject(item);
 
-          beginPropertyChanges();
-          for (i=0; i<indices.length; i++) {
-            this._replace(indices[i], 1, EMPTY);
-          }
-          endPropertyChanges();
-        }
+          enumerable_utils.forEach(sortProperties, function(sortProperty) {
+            observer.removeObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
+          }, this);
+        }, this);
+      }
 
-        return this ;
-      },
+      return this._super(array, idx, removedCount, addedCount);
+    },
 
-      pushObject: function(obj) {
-        this._insertAt(get(this, 'content.length'), obj) ;
-        return obj ;
-      },
+    contentArrayDidChange: function(array, idx, removedCount, addedCount) {
+      var isSorted = property_get.get(this, 'isSorted');
+      var sortProperties = property_get.get(this, 'sortProperties');
 
-      pushObjects: function(objects) {
-        if (!(Enumerable.detect(objects) || isArray(objects))) {
-          throw new TypeError("Must pass Ember.Enumerable to Ember.MutableArray#pushObjects");
-        }
-        this._replace(get(this, 'length'), 0, objects);
-        return this;
-      },
+      if (isSorted) {
+        var addedObjects = array.slice(idx, idx+addedCount);
 
-      setObjects: function(objects) {
-        if (objects.length === 0) return this.clear();
+        enumerable_utils.forEach(addedObjects, function(item) {
+          this.insertItemSorted(item);
 
-        var len = get(this, 'length');
-        this._replace(0, len, objects);
-        return this;
-      },
+          enumerable_utils.forEach(sortProperties, function(sortProperty) {
+            observer.addObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
+          }, this);
+        }, this);
+      }
 
-      unshiftObject: function(obj) {
-        this._insertAt(0, obj) ;
-        return obj ;
-      },
+      return this._super(array, idx, removedCount, addedCount);
+    },
 
-      unshiftObjects: function(objects) {
-        this._replace(0, 0, objects);
-        return this;
-      },
+    insertItemSorted: function(item) {
+      var arrangedContent = property_get.get(this, 'arrangedContent');
+      var length = property_get.get(arrangedContent, 'length');
 
-      slice: function() {
-        var arr = this.toArray();
-        return arr.slice.apply(arr, arguments);
-      },
+      var idx = this._binarySearch(item, 0, length);
+      arrangedContent.insertAt(idx, item);
+    },
 
-      arrangedContentArrayWillChange: function(item, idx, removedCnt, addedCnt) {
-        this.arrayContentWillChange(idx, removedCnt, addedCnt);
-      },
+    contentItemSortPropertyDidChange: function(item) {
+      var arrangedContent = property_get.get(this, 'arrangedContent');
+      var oldIndex = arrangedContent.indexOf(item);
+      var leftItem = arrangedContent.objectAt(oldIndex - 1);
+      var rightItem = arrangedContent.objectAt(oldIndex + 1);
+      var leftResult = leftItem && this.orderBy(item, leftItem);
+      var rightResult = rightItem && this.orderBy(item, rightItem);
 
-      arrangedContentArrayDidChange: function(item, idx, removedCnt, addedCnt) {
-        this.arrayContentDidChange(idx, removedCnt, addedCnt);
-      },
+      if (leftResult < 0 || rightResult > 0) {
+        arrangedContent.removeObject(item);
+        this.insertItemSorted(item);
+      }
+    },
 
-      init: function() {
-        this._super();
-        this._setupContent();
-        this._setupArrangedContent();
-      },
+    _binarySearch: function(item, low, high) {
+      var mid, midItem, res, arrangedContent;
 
-      willDestroy: function() {
-        this._teardownArrangedContent();
-        this._teardownContent();
+      if (low === high) {
+        return low;
       }
-    });
 
-    __exports__["default"] = ArrayProxy;
-  });
-enifed("ember-runtime/system/container",
-  ["ember-metal/property_set","container","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var set = __dependency1__.set;
-    var Container = __dependency2__["default"];
+      arrangedContent = property_get.get(this, 'arrangedContent');
+
+      mid = low + Math.floor((high - low) / 2);
+      midItem = arrangedContent.objectAt(mid);
 
-    Container.set = set;
+      res = this.orderBy(midItem, item);
 
-    __exports__["default"] = Container;
+      if (res < 0) {
+        return this._binarySearch(item, mid+1, high);
+      } else if (res > 0) {
+        return this._binarySearch(item, low, mid);
+      }
+
+      return mid;
+    }
   });
-enifed("ember-runtime/system/core_object",
-  ["ember-metal/core","ember-metal/merge","ember-metal/property_get","ember-metal/utils","ember-metal/platform","ember-metal/chains","ember-metal/events","ember-metal/mixin","ember-metal/enumerable_utils","ember-metal/error","ember-metal/keys","ember-runtime/mixins/action_handler","ember-metal/properties","ember-metal/binding","ember-metal/computed","ember-metal/injected_property","ember-metal/run_loop","ember-metal/watching","ember-runtime/inject","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __exports__) {
-        // Remove "use strict"; from transpiled module until
-    // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
-    //
-    // REMOVE_USE_STRICT: true
-
-    /**
-      @module ember
-      @submodule ember-runtime
-    */
-
-    var Ember = __dependency1__["default"];
-    var merge = __dependency2__["default"];
-    // Ember.assert, Ember.config
-
-    // NOTE: this object should never be included directly. Instead use `Ember.Object`.
-    // We only define this separately so that `Ember.Set` can depend on it.
-    var get = __dependency3__.get;
-    var guidFor = __dependency4__.guidFor;
-    var apply = __dependency4__.apply;
-    var o_create = __dependency5__.create;
-    var generateGuid = __dependency4__.generateGuid;
-    var GUID_KEY = __dependency4__.GUID_KEY;
-    var meta = __dependency4__.meta;
-    var makeArray = __dependency4__.makeArray;
-    var finishChains = __dependency6__.finishChains;
-    var sendEvent = __dependency7__.sendEvent;
-    var IS_BINDING = __dependency8__.IS_BINDING;
-    var Mixin = __dependency8__.Mixin;
-    var required = __dependency8__.required;
-    var indexOf = __dependency9__.indexOf;
-    var EmberError = __dependency10__["default"];
-    var o_defineProperty = __dependency5__.defineProperty;
-    var keys = __dependency11__["default"];
-    var ActionHandler = __dependency12__["default"];
-    var defineProperty = __dependency13__.defineProperty;
-    var Binding = __dependency14__.Binding;
-    var ComputedProperty = __dependency15__.ComputedProperty;
-    var computed = __dependency15__.computed;
-    var InjectedProperty = __dependency16__["default"];
-    var run = __dependency17__["default"];
-    var destroy = __dependency18__.destroy;
-    var K = __dependency1__.K;
-    var hasPropertyAccessors = __dependency5__.hasPropertyAccessors;
-    var validatePropertyInjections = __dependency19__.validatePropertyInjections;
-
-    var schedule = run.schedule;
-    var applyMixin = Mixin._apply;
-    var finishPartial = Mixin.finishPartial;
-    var reopen = Mixin.prototype.reopen;
-    var hasCachedComputedProperties = false;
-
-    var undefinedDescriptor = {
-      configurable: true,
-      writable: true,
-      enumerable: false,
-      value: undefined
-    };
 
-    var nullDescriptor = {
-      configurable: true,
-      writable: true,
-      enumerable: false,
-      value: null
-    };
+});
+enifed('ember-runtime/mixins/target_action_support', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/utils', 'ember-metal/mixin', 'ember-metal/computed'], function (exports, Ember, property_get, utils, mixin, computed) {
 
-    function makeCtor() {
+  'use strict';
 
-      // Note: avoid accessing any properties on the object since it makes the
-      // method a lot faster. This is glue code so we want it to be as fast as
-      // possible.
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
+  var TargetActionSupport = mixin.Mixin.create({
+    target: null,
+    action: null,
+    actionContext: null,
 
-      var wasApplied = false;
-      var initMixins, initProperties;
+    targetObject: computed.computed(function() {
+      var target = property_get.get(this, 'target');
 
-      var Class = function() {
-        if (!wasApplied) {
-          Class.proto(); // prepare prototype...
-        }
-        o_defineProperty(this, GUID_KEY, nullDescriptor);
-        o_defineProperty(this, '__nextSuper', undefinedDescriptor);
-        var m = meta(this);
-        var proto = m.proto;
-        m.proto = this;
-        if (initMixins) {
-          // capture locally so we can clear the closed over variable
-          var mixins = initMixins;
-          initMixins = null;
-          apply(this, this.reopen, mixins);
+      if (utils.typeOf(target) === "string") {
+        var value = property_get.get(this, target);
+        if (value === undefined) {
+          value = property_get.get(Ember['default'].lookup, target);
         }
-        if (initProperties) {
-          // capture locally so we can clear the closed over variable
-          var props = initProperties;
-          initProperties = null;
 
-          var concatenatedProperties = this.concatenatedProperties;
-          var mergedProperties = this.mergedProperties;
+        return value;
+      } else {
+        return target;
+      }
+    }).property('target'),
 
-          for (var i = 0, l = props.length; i < l; i++) {
-            var properties = props[i];
+    actionContextObject: computed.computed(function() {
+      var actionContext = property_get.get(this, 'actionContext');
 
-            Ember.assert("Ember.Object.create no longer supports mixing in other definitions, use createWithMixins instead.", !(properties instanceof Mixin));
+      if (utils.typeOf(actionContext) === "string") {
+        var value = property_get.get(this, actionContext);
+        if (value === undefined) { value = property_get.get(Ember['default'].lookup, actionContext); }
+        return value;
+      } else {
+        return actionContext;
+      }
+    }).property('actionContext'),
 
-            if (typeof properties !== 'object' && properties !== undefined) {
-              throw new EmberError("Ember.Object.create only accepts objects.");
-            }
+    /**
+    Send an `action` with an `actionContext` to a `target`. The action, actionContext
+    and target will be retrieved from properties of the object. For example:
 
-            if (!properties) { continue; }
+    ```javascript
+    App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+      target: Ember.computed.alias('controller'),
+      action: 'save',
+      actionContext: Ember.computed.alias('context'),
+      click: function() {
+        this.triggerAction(); // Sends the `save` action, along with the current context
+                              // to the current controller
+      }
+    });
+    ```
 
-            var keyNames = keys(properties);
+    The `target`, `action`, and `actionContext` can be provided as properties of
+    an optional object argument to `triggerAction` as well.
 
-            for (var j = 0, ll = keyNames.length; j < ll; j++) {
-              var keyName = keyNames[j];
-              var value = properties[keyName];
+    ```javascript
+    App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+      click: function() {
+        this.triggerAction({
+          action: 'save',
+          target: this.get('controller'),
+          actionContext: this.get('context')
+        }); // Sends the `save` action, along with the current context
+            // to the current controller
+      }
+    });
+    ```
 
-              if (IS_BINDING.test(keyName)) {
-                var bindings = m.bindings;
-                if (!bindings) {
-                  bindings = m.bindings = {};
-                } else if (!m.hasOwnProperty('bindings')) {
-                  bindings = m.bindings = o_create(m.bindings);
-                }
-                bindings[keyName] = value;
-              }
+    The `actionContext` defaults to the object you are mixing `TargetActionSupport` into.
+    But `target` and `action` must be specified either as properties or with the argument
+    to `triggerAction`, or a combination:
 
-              var desc = m.descs[keyName];
+    ```javascript
+    App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+      target: Ember.computed.alias('controller'),
+      click: function() {
+        this.triggerAction({
+          action: 'save'
+        }); // Sends the `save` action, along with a reference to `this`,
+            // to the current controller
+      }
+    });
+    ```
 
-              Ember.assert("Ember.Object.create no longer supports defining computed properties. Define computed properties using extend() or reopen() before calling create().", !(value instanceof ComputedProperty));
-              Ember.assert("Ember.Object.create no longer supports defining methods that call _super.", !(typeof value === 'function' && value.toString().indexOf('._super') !== -1));
-              Ember.assert("`actions` must be provided at extend time, not at create " +
-                           "time, when Ember.ActionHandler is used (i.e. views, " +
-                           "controllers & routes).", !((keyName === 'actions') && ActionHandler.detect(this)));
+    @method triggerAction
+    @param opts {Hash} (optional, with the optional keys action, target and/or actionContext)
+    @return {Boolean} true if the action was sent successfully and did not return false
+    */
+    triggerAction: function(opts) {
+      opts = opts || {};
+      var action = opts.action || property_get.get(this, 'action');
+      var target = opts.target || property_get.get(this, 'targetObject');
+      var actionContext = opts.actionContext;
 
-              if (concatenatedProperties &&
-                  concatenatedProperties.length > 0 &&
-                  indexOf(concatenatedProperties, keyName) >= 0) {
-                var baseValue = this[keyName];
+      function args(options, actionName) {
+        var ret = [];
+        if (actionName) { ret.push(actionName); }
 
-                if (baseValue) {
-                  if ('function' === typeof baseValue.concat) {
-                    value = baseValue.concat(value);
-                  } else {
-                    value = makeArray(baseValue).concat(value);
-                  }
-                } else {
-                  value = makeArray(value);
-                }
-              }
+        return ret.concat(options);
+      }
 
-              if (mergedProperties &&
-                  mergedProperties.length &&
-                  indexOf(mergedProperties, keyName) >= 0) {
-                var originalValue = this[keyName];
+      if (typeof actionContext === 'undefined') {
+        actionContext = property_get.get(this, 'actionContextObject') || this;
+      }
 
-                value = merge(originalValue, value);
-              }
+      if (target && action) {
+        var ret;
 
-              if (desc) {
-                desc.set(this, keyName, value);
-              } else {
-                if (typeof this.setUnknownProperty === 'function' && !(keyName in this)) {
-                  this.setUnknownProperty(keyName, value);
-                } else {
-                  
-                    if (hasPropertyAccessors) {
-                      defineProperty(this, keyName, null, value); // setup mandatory setter
-                    } else {
-                      this[keyName] = value;
-                    }
-                                  }
-              }
-            }
-          }
+        if (target.send) {
+          ret = target.send.apply(target, args(actionContext, action));
+        } else {
+          Ember['default'].assert("The action '" + action + "' did not exist on " + target, typeof target[action] === 'function');
+          ret = target[action].apply(target, args(actionContext));
         }
 
-        finishPartial(this, m);
+        if (ret !== false) {
+          ret = true;
+        }
 
-        var length = arguments.length;
+        return ret;
+      } else {
+        return false;
+      }
+    }
+  });
 
-        if (length === 0) {
-          this.init();
-        } else if (length === 1) {
-          this.init(arguments[0]);
-        } else {
-          // v8 bug potentially incorrectly deopts this function: https://code.google.com/p/v8/issues/detail?id=3709
-          // we may want to keep this around till this ages out on mobile
-          var args = new Array(length);
-          for (var x = 0; x < length; x++) {
-            args[x] = arguments[x];
-          }
-          this.init.apply(this, args);
-        }
+  exports['default'] = TargetActionSupport;
 
-        m.proto = proto;
-        finishChains(this);
-        sendEvent(this, 'init');
-      };
+});
+enifed('ember-runtime/system/application', ['exports', 'ember-runtime/system/namespace'], function (exports, Namespace) {
 
-      Class.toString = Mixin.prototype.toString;
-      Class.willReopen = function() {
-        if (wasApplied) {
-          Class.PrototypeMixin = Mixin.create(Class.PrototypeMixin);
-        }
+	'use strict';
 
-        wasApplied = false;
-      };
-      Class._initMixins = function(args) { initMixins = args; };
-      Class._initProperties = function(args) { initProperties = args; };
+	exports['default'] = Namespace['default'].extend();
 
-      Class.proto = function() {
-        var superclass = Class.superclass;
-        if (superclass) { superclass.proto(); }
+});
+enifed('ember-runtime/system/array_proxy', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/utils', 'ember-metal/computed', 'ember-metal/mixin', 'ember-metal/property_events', 'ember-metal/error', 'ember-runtime/system/object', 'ember-runtime/mixins/mutable_array', 'ember-runtime/mixins/enumerable', 'ember-runtime/system/string', 'ember-metal/alias'], function (exports, Ember, property_get, utils, computed, mixin, property_events, EmberError, EmberObject, MutableArray, Enumerable, string, alias) {
 
-        if (!wasApplied) {
-          wasApplied = true;
-          Class.PrototypeMixin.applyPartial(Class.prototype);
-        }
+  'use strict';
 
-        return this.prototype;
-      };
+  var OUT_OF_RANGE_EXCEPTION = "Index out of range";
+  var EMPTY = [];
 
-      return Class;
+  function K() { return this; }
 
-    }
+  /**
+    An ArrayProxy wraps any other object that implements `Ember.Array` and/or
+    `Ember.MutableArray,` forwarding all requests. This makes it very useful for
+    a number of binding use cases or other cases where being able to swap
+    out the underlying array is useful.
 
-    /**
-      @class CoreObject
-      @namespace Ember
-    */
-    var CoreObject = makeCtor();
-    CoreObject.toString = function() { return "Ember.CoreObject"; };
-    CoreObject.PrototypeMixin = Mixin.create({
-      reopen: function() {
-        var length = arguments.length;
-        var args = new Array(length);
-        for (var i = 0; i < length; i++) {
-          args[i] = arguments[i];
-        }
-        applyMixin(this, args, true);
-        return this;
-      },
+    A simple example of usage:
 
-      /**
-        An overridable method called when objects are instantiated. By default,
-        does nothing unless it is overridden during class definition.
+    ```javascript
+    var pets = ['dog', 'cat', 'fish'];
+    var ap = Ember.ArrayProxy.create({ content: Ember.A(pets) });
 
-        Example:
+    ap.get('firstObject');                        // 'dog'
+    ap.set('content', ['amoeba', 'paramecium']);
+    ap.get('firstObject');                        // 'amoeba'
+    ```
 
-        ```javascript
-        App.Person = Ember.Object.extend({
-          init: function() {
-            alert('Name is ' + this.get('name'));
-          }
-        });
+    This class can also be useful as a layer to transform the contents of
+    an array, as they are accessed. This can be done by overriding
+    `objectAtContent`:
 
-        var steve = App.Person.create({
-          name: "Steve"
-        });
+    ```javascript
+    var pets = ['dog', 'cat', 'fish'];
+    var ap = Ember.ArrayProxy.create({
+        content: Ember.A(pets),
+        objectAtContent: function(idx) {
+            return this.get('content').objectAt(idx).toUpperCase();
+        }
+    });
 
-        // alerts 'Name is Steve'.
-        ```
+    ap.get('firstObject'); // . 'DOG'
+    ```
 
-        NOTE: If you do override `init` for a framework class like `Ember.View` or
-        `Ember.ArrayController`, be sure to call `this._super()` in your
-        `init` declaration! If you don't, Ember may not have an opportunity to
-        do important setup work, and you'll see strange behavior in your
-        application.
+    @class ArrayProxy
+    @namespace Ember
+    @extends Ember.Object
+    @uses Ember.MutableArray
+  */
+  var ArrayProxy = EmberObject['default'].extend(MutableArray['default'], {
 
-        @method init
-      */
-      init: function() {},
+    /**
+      The content array. Must be an object that implements `Ember.Array` and/or
+      `Ember.MutableArray.`
 
-      /**
-        Defines the properties that will be concatenated from the superclass
-        (instead of overridden).
+      @property content
+      @type Ember.Array
+    */
+    content: null,
 
-        By default, when you extend an Ember class a property defined in
-        the subclass overrides a property with the same name that is defined
-        in the superclass. However, there are some cases where it is preferable
-        to build up a property's value by combining the superclass' property
-        value with the subclass' value. An example of this in use within Ember
-        is the `classNames` property of `Ember.View`.
+    /**
+     The array that the proxy pretends to be. In the default `ArrayProxy`
+     implementation, this and `content` are the same. Subclasses of `ArrayProxy`
+     can override this property to provide things like sorting and filtering.
 
-        Here is some sample code showing the difference between a concatenated
-        property and a normal one:
+     @property arrangedContent
+    */
+    arrangedContent: alias['default']('content'),
 
-        ```javascript
-        App.BarView = Ember.View.extend({
-          someNonConcatenatedProperty: ['bar'],
-          classNames: ['bar']
-        });
+    /**
+      Should actually retrieve the object at the specified index from the
+      content. You can override this method in subclasses to transform the
+      content item to something new.
 
-        App.FooBarView = App.BarView.extend({
-          someNonConcatenatedProperty: ['foo'],
-          classNames: ['foo']
-        });
+      This method will only be called if content is non-`null`.
 
-        var fooBarView = App.FooBarView.create();
-        fooBarView.get('someNonConcatenatedProperty'); // ['foo']
-        fooBarView.get('classNames'); // ['ember-view', 'bar', 'foo']
-        ```
+      @method objectAtContent
+      @param {Number} idx The index to retrieve.
+      @return {Object} the value or undefined if none found
+    */
+    objectAtContent: function(idx) {
+      return property_get.get(this, 'arrangedContent').objectAt(idx);
+    },
 
-        This behavior extends to object creation as well. Continuing the
-        above example:
+    /**
+      Should actually replace the specified objects on the content array.
+      You can override this method in subclasses to transform the content item
+      into something new.
 
-        ```javascript
-        var view = App.FooBarView.create({
-          someNonConcatenatedProperty: ['baz'],
-          classNames: ['baz']
-        })
-        view.get('someNonConcatenatedProperty'); // ['baz']
-        view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz']
-        ```
-        Adding a single property that is not an array will just add it in the array:
+      This method will only be called if content is non-`null`.
 
-        ```javascript
-        var view = App.FooBarView.create({
-          classNames: 'baz'
-        })
-        view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz']
-        ```
+      @method replaceContent
+      @param {Number} idx The starting index
+      @param {Number} amt The number of items to remove from the content.
+      @param {Array} objects Optional array of objects to insert or null if no
+        objects.
+      @return {void}
+    */
+    replaceContent: function(idx, amt, objects) {
+      property_get.get(this, 'content').replace(idx, amt, objects);
+    },
 
-        Using the `concatenatedProperties` property, we can tell Ember to mix the
-        content of the properties.
+    /**
+      Invoked when the content property is about to change. Notifies observers that the
+      entire array content will change.
 
-        In `Ember.View` the `classNameBindings` and `attributeBindings` properties
-        are also concatenated, in addition to `classNames`.
+      @private
+      @method _contentWillChange
+    */
+    _contentWillChange: mixin.beforeObserver('content', function() {
+      this._teardownContent();
+    }),
 
-        This feature is available for you to use throughout the Ember object model,
-        although typical app developers are likely to use it infrequently. Since
-        it changes expectations about behavior of properties, you should properly
-        document its usage in each individual concatenated property (to not
-        mislead your users to think they can override the property in a subclass).
+    _teardownContent: function() {
+      var content = property_get.get(this, 'content');
 
-        @property concatenatedProperties
-        @type Array
-        @default null
-      */
-      concatenatedProperties: null,
+      if (content) {
+        content.removeArrayObserver(this, {
+          willChange: 'contentArrayWillChange',
+          didChange: 'contentArrayDidChange'
+        });
+      }
+    },
 
-      /**
-        Destroyed object property flag.
+    /**
+      Override to implement content array `willChange` observer.
 
-        if this property is `true` the observers and bindings were already
-        removed by the effect of calling the `destroy()` method.
+      @method contentArrayWillChange
 
-        @property isDestroyed
-        @default false
-      */
-      isDestroyed: false,
+      @param {Ember.Array} contentArray the content array
+      @param {Number} start starting index of the change
+      @param {Number} removeCount count of items removed
+      @param {Number} addCount count of items added
 
-      /**
-        Destruction scheduled flag. The `destroy()` method has been called.
+    */
+    contentArrayWillChange: K,
+    /**
+      Override to implement content array `didChange` observer.
 
-        The object stays intact until the end of the run loop at which point
-        the `isDestroyed` flag is set.
+      @method contentArrayDidChange
 
-        @property isDestroying
-        @default false
-      */
-      isDestroying: false,
+      @param {Ember.Array} contentArray the content array
+      @param {Number} start starting index of the change
+      @param {Number} removeCount count of items removed
+      @param {Number} addCount count of items added
+    */
+    contentArrayDidChange: K,
 
-      /**
-        Destroys an object by setting the `isDestroyed` flag and removing its
-        metadata, which effectively destroys observers and bindings.
+    /**
+      Invoked when the content property changes. Notifies observers that the
+      entire array content has changed.
 
-        If you try to set a property on a destroyed object, an exception will be
-        raised.
+      @private
+      @method _contentDidChange
+    */
+    _contentDidChange: mixin.observer('content', function() {
+      var content = property_get.get(this, 'content');
 
-        Note that destruction is scheduled for the end of the run loop and does not
-        happen immediately.  It will set an isDestroying flag immediately.
+      Ember['default'].assert("Can't set ArrayProxy's content to itself", content !== this);
 
-        @method destroy
-        @return {Ember.Object} receiver
-      */
-      destroy: function() {
-        if (this.isDestroying) { return; }
-        this.isDestroying = true;
+      this._setupContent();
+    }),
 
-        schedule('actions', this, this.willDestroy);
-        schedule('destroy', this, this._scheduledDestroy);
-        return this;
-      },
+    _setupContent: function() {
+      var content = property_get.get(this, 'content');
 
-      /**
-        Override to implement teardown.
+      if (content) {
+        Ember['default'].assert(string.fmt('ArrayProxy expects an Array or ' +
+          'Ember.ArrayProxy, but you passed %@', [typeof content]),
+          utils.isArray(content) || content.isDestroyed);
 
-        @method willDestroy
-       */
-      willDestroy: K,
+        content.addArrayObserver(this, {
+          willChange: 'contentArrayWillChange',
+          didChange: 'contentArrayDidChange'
+        });
+      }
+    },
 
-      /**
-        Invoked by the run loop to actually destroy the object. This is
-        scheduled for execution by the `destroy` method.
+    _arrangedContentWillChange: mixin.beforeObserver('arrangedContent', function() {
+      var arrangedContent = property_get.get(this, 'arrangedContent');
+      var len = arrangedContent ? property_get.get(arrangedContent, 'length') : 0;
 
-        @private
-        @method _scheduledDestroy
-      */
-      _scheduledDestroy: function() {
-        if (this.isDestroyed) { return; }
-        destroy(this);
-        this.isDestroyed = true;
-      },
+      this.arrangedContentArrayWillChange(this, 0, len, undefined);
+      this.arrangedContentWillChange(this);
 
-      bind: function(to, from) {
-        if (!(from instanceof Binding)) { from = Binding.from(from); }
-        from.to(to).connect(this);
-        return from;
-      },
+      this._teardownArrangedContent(arrangedContent);
+    }),
 
-      /**
-        Returns a string representation which attempts to provide more information
-        than Javascript's `toString` typically does, in a generic way for all Ember
-        objects.
+    _arrangedContentDidChange: mixin.observer('arrangedContent', function() {
+      var arrangedContent = property_get.get(this, 'arrangedContent');
+      var len = arrangedContent ? property_get.get(arrangedContent, 'length') : 0;
 
-        ```javascript
-        App.Person = Em.Object.extend()
-        person = App.Person.create()
-        person.toString() //=> "<App.Person:ember1024>"
-        ```
+      Ember['default'].assert("Can't set ArrayProxy's content to itself", arrangedContent !== this);
 
-        If the object's class is not defined on an Ember namespace, it will
-        indicate it is a subclass of the registered superclass:
+      this._setupArrangedContent();
 
-       ```javascript
-        Student = App.Person.extend()
-        student = Student.create()
-        student.toString() //=> "<(subclass of App.Person):ember1025>"
-        ```
+      this.arrangedContentDidChange(this);
+      this.arrangedContentArrayDidChange(this, 0, undefined, len);
+    }),
 
-        If the method `toStringExtension` is defined, its return value will be
-        included in the output.
+    _setupArrangedContent: function() {
+      var arrangedContent = property_get.get(this, 'arrangedContent');
 
-        ```javascript
-        App.Teacher = App.Person.extend({
-          toStringExtension: function() {
-            return this.get('fullName');
-          }
+      if (arrangedContent) {
+        Ember['default'].assert(string.fmt('ArrayProxy expects an Array or ' +
+          'Ember.ArrayProxy, but you passed %@', [typeof arrangedContent]),
+          utils.isArray(arrangedContent) || arrangedContent.isDestroyed);
+
+        arrangedContent.addArrayObserver(this, {
+          willChange: 'arrangedContentArrayWillChange',
+          didChange: 'arrangedContentArrayDidChange'
         });
-        teacher = App.Teacher.create()
-        teacher.toString(); //=> "<App.Teacher:ember1026:Tom Dale>"
-        ```
+      }
+    },
 
-        @method toString
-        @return {String} string representation
-      */
-      toString: function toString() {
-        var hasToStringExtension = typeof this.toStringExtension === 'function';
-        var extension = hasToStringExtension ? ":" + this.toStringExtension() : '';
-        var ret = '<'+this.constructor.toString()+':'+guidFor(this)+extension+'>';
+    _teardownArrangedContent: function() {
+      var arrangedContent = property_get.get(this, 'arrangedContent');
 
-        this.toString = makeToString(ret);
-        return ret;
+      if (arrangedContent) {
+        arrangedContent.removeArrayObserver(this, {
+          willChange: 'arrangedContentArrayWillChange',
+          didChange: 'arrangedContentArrayDidChange'
+        });
       }
-    });
+    },
 
-    CoreObject.PrototypeMixin.ownerConstructor = CoreObject;
+    arrangedContentWillChange: K,
+    arrangedContentDidChange: K,
 
-    function makeToString(ret) {
-      return function() { return ret; };
-    }
+    objectAt: function(idx) {
+      return property_get.get(this, 'content') && this.objectAtContent(idx);
+    },
 
-    CoreObject.__super__ = null;
+    length: computed.computed(function() {
+      var arrangedContent = property_get.get(this, 'arrangedContent');
+      return arrangedContent ? property_get.get(arrangedContent, 'length') : 0;
+      // No dependencies since Enumerable notifies length of change
+    }),
 
-    var ClassMixinProps = {
+    _replace: function(idx, amt, objects) {
+      var content = property_get.get(this, 'content');
+      Ember['default'].assert('The content property of '+ this.constructor + ' should be set before modifying it', content);
+      if (content) {
+        this.replaceContent(idx, amt, objects);
+      }
 
-      ClassMixin: required(),
+      return this;
+    },
 
-      PrototypeMixin: required(),
+    replace: function() {
+      if (property_get.get(this, 'arrangedContent') === property_get.get(this, 'content')) {
+        utils.apply(this, this._replace, arguments);
+      } else {
+        throw new EmberError['default']("Using replace on an arranged ArrayProxy is not allowed.");
+      }
+    },
 
-      isClass: true,
+    _insertAt: function(idx, object) {
+      if (idx > property_get.get(this, 'content.length')) {
+        throw new EmberError['default'](OUT_OF_RANGE_EXCEPTION);
+      }
 
-      isMethod: false,
+      this._replace(idx, 0, [object]);
+      return this;
+    },
 
-      /**
-        Creates a new subclass.
+    insertAt: function(idx, object) {
+      if (property_get.get(this, 'arrangedContent') === property_get.get(this, 'content')) {
+        return this._insertAt(idx, object);
+      } else {
+        throw new EmberError['default']("Using insertAt on an arranged ArrayProxy is not allowed.");
+      }
+    },
 
-        ```javascript
-        App.Person = Ember.Object.extend({
-          say: function(thing) {
-            alert(thing);
-           }
-        });
-        ```
+    removeAt: function(start, len) {
+      if ('number' === typeof start) {
+        var content = property_get.get(this, 'content');
+        var arrangedContent = property_get.get(this, 'arrangedContent');
+        var indices = [];
+        var i;
 
-        This defines a new subclass of Ember.Object: `App.Person`. It contains one method: `say()`.
+        if ((start < 0) || (start >= property_get.get(this, 'length'))) {
+          throw new EmberError['default'](OUT_OF_RANGE_EXCEPTION);
+        }
 
-        You can also create a subclass from any existing class by calling its `extend()`  method. For example, you might want to create a subclass of Ember's built-in `Ember.View` class:
+        if (len === undefined) {
+          len = 1;
+        }
 
-        ```javascript
-        App.PersonView = Ember.View.extend({
-          tagName: 'li',
-          classNameBindings: ['isAdministrator']
-        });
-        ```
+        // Get a list of indices in original content to remove
+        for (i=start; i<start+len; i++) {
+          // Use arrangedContent here so we avoid confusion with objects transformed by objectAtContent
+          indices.push(content.indexOf(arrangedContent.objectAt(i)));
+        }
 
-        When defining a subclass, you can override methods but still access the implementation of your parent class by calling the special `_super()` method:
+        // Replace in reverse order since indices will change
+        indices.sort(function(a, b) { return b - a; });
 
-        ```javascript
-        App.Person = Ember.Object.extend({
-          say: function(thing) {
-            var name = this.get('name');
-            alert(name + ' says: ' + thing);
-          }
-        });
+        property_events.beginPropertyChanges();
+        for (i=0; i<indices.length; i++) {
+          this._replace(indices[i], 1, EMPTY);
+        }
+        property_events.endPropertyChanges();
+      }
 
-        App.Soldier = App.Person.extend({
-          say: function(thing) {
-            this._super(thing + ", sir!");
-          },
-          march: function(numberOfHours) {
-            alert(this.get('name') + ' marches for ' + numberOfHours + ' hours.')
-          }
-        });
+      return this;
+    },
 
-        var yehuda = App.Soldier.create({
-          name: "Yehuda Katz"
-        });
+    pushObject: function(obj) {
+      this._insertAt(property_get.get(this, 'content.length'), obj);
+      return obj;
+    },
 
-        yehuda.say("Yes");  // alerts "Yehuda Katz says: Yes, sir!"
-        ```
+    pushObjects: function(objects) {
+      if (!(Enumerable['default'].detect(objects) || utils.isArray(objects))) {
+        throw new TypeError("Must pass Ember.Enumerable to Ember.MutableArray#pushObjects");
+      }
+      this._replace(property_get.get(this, 'length'), 0, objects);
+      return this;
+    },
 
-        The `create()` on line #17 creates an *instance* of the `App.Soldier` class. The `extend()` on line #8 creates a *subclass* of `App.Person`. Any instance of the `App.Person` class will *not* have the `march()` method.
+    setObjects: function(objects) {
+      if (objects.length === 0) {
+        return this.clear();
+      }
 
-        You can also pass `Mixin` classes to add additional properties to the subclass.
+      var len = property_get.get(this, 'length');
+      this._replace(0, len, objects);
+      return this;
+    },
 
-        ```javascript
-        App.Person = Ember.Object.extend({
-          say: function(thing) {
-            alert(this.get('name') + ' says: ' + thing);
-          }
-        });
+    unshiftObject: function(obj) {
+      this._insertAt(0, obj);
+      return obj;
+    },
 
-        App.SingingMixin = Mixin.create({
-          sing: function(thing){
-            alert(this.get('name') + ' sings: la la la ' + thing);
-          }
-        });
+    unshiftObjects: function(objects) {
+      this._replace(0, 0, objects);
+      return this;
+    },
 
-        App.BroadwayStar = App.Person.extend(App.SingingMixin, {
-          dance: function() {
-            alert(this.get('name') + ' dances: tap tap tap tap ');
-          }
-        });
-        ```
+    slice: function() {
+      var arr = this.toArray();
+      return arr.slice.apply(arr, arguments);
+    },
 
-        The `App.BroadwayStar` class contains three methods: `say()`, `sing()`, and `dance()`.
+    arrangedContentArrayWillChange: function(item, idx, removedCnt, addedCnt) {
+      this.arrayContentWillChange(idx, removedCnt, addedCnt);
+    },
 
-        @method extend
-        @static
+    arrangedContentArrayDidChange: function(item, idx, removedCnt, addedCnt) {
+      this.arrayContentDidChange(idx, removedCnt, addedCnt);
+    },
 
-        @param {Mixin} [mixins]* One or more Mixin classes
-        @param {Object} [arguments]* Object containing values to use within the new class
-      */
-      extend: function extend() {
-        var Class = makeCtor();
-        var proto;
-        Class.ClassMixin = Mixin.create(this.ClassMixin);
-        Class.PrototypeMixin = Mixin.create(this.PrototypeMixin);
+    init: function() {
+      this._super.apply(this, arguments);
+      this._setupContent();
+      this._setupArrangedContent();
+    },
 
-        Class.ClassMixin.ownerConstructor = Class;
-        Class.PrototypeMixin.ownerConstructor = Class;
+    willDestroy: function() {
+      this._teardownArrangedContent();
+      this._teardownContent();
+    }
+  });
 
-        reopen.apply(Class.PrototypeMixin, arguments);
+  exports['default'] = ArrayProxy;
 
-        Class.superclass = this;
-        Class.__super__  = this.prototype;
+});
+enifed('ember-runtime/system/container', ['exports', 'ember-metal/property_set', 'container/registry', 'container/container'], function (exports, property_set, Registry, Container) {
 
-        proto = Class.prototype = o_create(this.prototype);
-        proto.constructor = Class;
-        generateGuid(proto);
-        meta(proto).proto = proto; // this will disable observers on prototype
+	'use strict';
 
-        Class.ClassMixin.apply(Class);
-        return Class;
-      },
+	Registry['default'].set = property_set.set;
+	Container['default'].set = property_set.set;
 
-      /**
-        Equivalent to doing `extend(arguments).create()`.
-        If possible use the normal `create` method instead.
+	exports.Registry = Registry['default'];
+	exports.Container = Container['default'];
 
-        @method createWithMixins
-        @static
-        @param [arguments]*
-      */
-      createWithMixins: function() {
-        var C = this;
-        var l= arguments.length;
-        if (l > 0) {
-          var args = new Array(l);
-          for (var i = 0; i < l; i++) {
-            args[i] = arguments[i];
-          }
-          this._initMixins(args);
-        }
-        return new C();
-      },
+});
+enifed('ember-runtime/system/core_object', ['exports', 'ember-metal', 'ember-metal/merge', 'ember-metal/property_get', 'ember-metal/utils', 'ember-metal/platform/create', 'ember-metal/chains', 'ember-metal/events', 'ember-metal/mixin', 'ember-metal/enumerable_utils', 'ember-metal/error', 'ember-metal/platform/define_property', 'ember-metal/keys', 'ember-runtime/mixins/action_handler', 'ember-metal/properties', 'ember-metal/binding', 'ember-metal/computed', 'ember-metal/injected_property', 'ember-metal/run_loop', 'ember-metal/watching', 'ember-metal/core', 'ember-runtime/inject'], function (exports, Ember, merge, property_get, utils, o_create, chains, events, mixin, enumerable_utils, EmberError, define_property, keys, ActionHandler, ember_metal__properties, binding, computed, InjectedProperty, run, watching, core, inject) {
 
-      /**
-        Creates an instance of a class. Accepts either no arguments, or an object
-        containing values to initialize the newly instantiated object with.
 
-        ```javascript
-        App.Person = Ember.Object.extend({
-          helloWorld: function() {
-            alert("Hi, my name is " + this.get('name'));
-          }
-        });
+  // Remove "use strict"; from transpiled module until
+  // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
+  //
+  "REMOVE_USE_STRICT: true";
 
-        var tom = App.Person.create({
-          name: 'Tom Dale'
-        });
+  /**
+    @module ember
+    @submodule ember-runtime
+  */
+
+  // using ember-metal/lib/main here to ensure that ember-debug is setup
+  // if present
+  var schedule = run['default'].schedule;
+  var applyMixin = mixin.Mixin._apply;
+  var finishPartial = mixin.Mixin.finishPartial;
+  var reopen = mixin.Mixin.prototype.reopen;
+  var hasCachedComputedProperties = false;
+
+  function makeCtor() {
+
+    // Note: avoid accessing any properties on the object since it makes the
+    // method a lot faster. This is glue code so we want it to be as fast as
+    // possible.
+
+    var wasApplied = false;
+    var initMixins, initProperties;
+
+    var Class = function() {
+      if (!wasApplied) {
+        Class.proto(); // prepare prototype...
+      }
+      this.__defineNonEnumerable(utils.GUID_KEY_PROPERTY);
+      this.__defineNonEnumerable(utils.NEXT_SUPER_PROPERTY);
+      var m = utils.meta(this);
+      var proto = m.proto;
+      m.proto = this;
+      if (initMixins) {
+        // capture locally so we can clear the closed over variable
+        var mixins = initMixins;
+        initMixins = null;
+        utils.apply(this, this.reopen, mixins);
+      }
+      if (initProperties) {
+        // capture locally so we can clear the closed over variable
+        var props = initProperties;
+        initProperties = null;
+
+        var concatenatedProperties = this.concatenatedProperties;
+        var mergedProperties = this.mergedProperties;
 
-        tom.helloWorld(); // alerts "Hi, my name is Tom Dale".
-        ```
+        for (var i = 0, l = props.length; i < l; i++) {
+          var properties = props[i];
 
-        `create` will call the `init` function if defined during
-        `Ember.AnyObject.extend`
+          Ember['default'].assert("Ember.Object.create no longer supports mixing in other definitions, use createWithMixins instead.", !(properties instanceof mixin.Mixin));
 
-        If no arguments are passed to `create`, it will not set values to the new
-        instance during initialization:
+          if (typeof properties !== 'object' && properties !== undefined) {
+            throw new EmberError['default']("Ember.Object.create only accepts objects.");
+          }
 
-        ```javascript
-        var noName = App.Person.create();
-        noName.helloWorld(); // alerts undefined
-        ```
+          if (!properties) { continue; }
 
-        NOTE: For performance reasons, you cannot declare methods or computed
-        properties during `create`. You should instead declare methods and computed
-        properties when using `extend` or use the `createWithMixins` shorthand.
+          var keyNames = keys['default'](properties);
 
-        @method create
-        @static
-        @param [arguments]*
-      */
-      create: function() {
-        var C = this;
-        var l = arguments.length;
-        if (l > 0) {
-          var args = new Array(l);
-          for (var i = 0; i < l; i++) {
-            args[i] = arguments[i];
-          }
-          this._initProperties(args);
-        }
-        return new C();
-      },
+          for (var j = 0, ll = keyNames.length; j < ll; j++) {
+            var keyName = keyNames[j];
+            var value = properties[keyName];
 
-      /**
-        Augments a constructor's prototype with additional
-        properties and functions:
+            if (mixin.IS_BINDING.test(keyName)) {
+              var bindings = m.bindings;
+              if (!bindings) {
+                bindings = m.bindings = {};
+              } else if (!m.hasOwnProperty('bindings')) {
+                bindings = m.bindings = o_create['default'](m.bindings);
+              }
+              bindings[keyName] = value;
+            }
 
-        ```javascript
-        MyObject = Ember.Object.extend({
-          name: 'an object'
-        });
+            var possibleDesc = this[keyName];
+            var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
 
-        o = MyObject.create();
-        o.get('name'); // 'an object'
+            Ember['default'].assert("Ember.Object.create no longer supports defining computed properties. Define computed properties using extend() or reopen() before calling create().", !(value instanceof computed.ComputedProperty));
+            Ember['default'].assert("Ember.Object.create no longer supports defining methods that call _super.", !(typeof value === 'function' && value.toString().indexOf('._super') !== -1));
+            Ember['default'].assert("`actions` must be provided at extend time, not at create " +
+                         "time, when Ember.ActionHandler is used (i.e. views, " +
+                         "controllers & routes).", !((keyName === 'actions') && ActionHandler['default'].detect(this)));
 
-        MyObject.reopen({
-          say: function(msg){
-            console.log(msg);
-          }
-        })
+            if (concatenatedProperties &&
+                concatenatedProperties.length > 0 &&
+                enumerable_utils.indexOf(concatenatedProperties, keyName) >= 0) {
+              var baseValue = this[keyName];
 
-        o2 = MyObject.create();
-        o2.say("hello"); // logs "hello"
+              if (baseValue) {
+                if ('function' === typeof baseValue.concat) {
+                  value = baseValue.concat(value);
+                } else {
+                  value = utils.makeArray(baseValue).concat(value);
+                }
+              } else {
+                value = utils.makeArray(value);
+              }
+            }
 
-        o.say("goodbye"); // logs "goodbye"
-        ```
+            if (mergedProperties &&
+                mergedProperties.length &&
+                enumerable_utils.indexOf(mergedProperties, keyName) >= 0) {
+              var originalValue = this[keyName];
 
-        To add functions and properties to the constructor itself,
-        see `reopenClass`
+              value = merge['default'](originalValue, value);
+            }
 
-        @method reopen
-      */
-      reopen: function() {
-        this.willReopen();
+            if (desc) {
+              desc.set(this, keyName, value);
+            } else {
+              if (typeof this.setUnknownProperty === 'function' && !(keyName in this)) {
+                this.setUnknownProperty(keyName, value);
+              } else {
 
-        var l = arguments.length;
-        var args = new Array(l);
-        if (l > 0) {
-          for (var i = 0; i < l; i++) {
-            args[i] = arguments[i];
+                  if (define_property.hasPropertyAccessors) {
+                    ember_metal__properties.defineProperty(this, keyName, null, value); // setup mandatory setter
+                  } else {
+                    this[keyName] = value;
+                  }
+                              }
+            }
           }
         }
+      }
 
-        apply(this.PrototypeMixin, reopen, args);
-        return this;
-      },
+      finishPartial(this, m);
 
-      /**
-        Augments a constructor's own properties and functions:
+      var length = arguments.length;
 
-        ```javascript
-        MyObject = Ember.Object.extend({
-          name: 'an object'
-        });
+      if (length === 0) {
+        this.init();
+      } else if (length === 1) {
+        this.init(arguments[0]);
+      } else {
+        // v8 bug potentially incorrectly deopts this function: https://code.google.com/p/v8/issues/detail?id=3709
+        // we may want to keep this around till this ages out on mobile
+        var args = new Array(length);
+        for (var x = 0; x < length; x++) {
+          args[x] = arguments[x];
+        }
+        this.init.apply(this, args);
+      }
 
-        MyObject.reopenClass({
-          canBuild: false
-        });
+      m.proto = proto;
+      chains.finishChains(this);
+      events.sendEvent(this, 'init');
+    };
 
-        MyObject.canBuild; // false
-        o = MyObject.create();
-        ```
+    Class.toString = mixin.Mixin.prototype.toString;
+    Class.willReopen = function() {
+      if (wasApplied) {
+        Class.PrototypeMixin = mixin.Mixin.create(Class.PrototypeMixin);
+      }
 
-        In other words, this creates static properties and functions for the class. These are only available on the class
-        and not on any instance of that class.
+      wasApplied = false;
+    };
+    Class._initMixins = function(args) { initMixins = args; };
+    Class._initProperties = function(args) { initProperties = args; };
 
-        ```javascript
-        App.Person = Ember.Object.extend({
-          name : "",
-          sayHello : function(){
-            alert("Hello. My name is " + this.get('name'));
-          }
-        });
+    Class.proto = function() {
+      var superclass = Class.superclass;
+      if (superclass) { superclass.proto(); }
 
-        App.Person.reopenClass({
-          species : "Homo sapiens",
-          createPerson: function(newPersonsName){
-            return App.Person.create({
-              name:newPersonsName
-            });
-          }
-        });
+      if (!wasApplied) {
+        wasApplied = true;
+        Class.PrototypeMixin.applyPartial(Class.prototype);
+      }
 
-        var tom = App.Person.create({
-          name : "Tom Dale"
-        });
-        var yehuda = App.Person.createPerson("Yehuda Katz");
+      return this.prototype;
+    };
 
-        tom.sayHello(); // "Hello. My name is Tom Dale"
-        yehuda.sayHello(); // "Hello. My name is Yehuda Katz"
-        alert(App.Person.species); // "Homo sapiens"
-        ```
+    return Class;
 
-        Note that `species` and `createPerson` are *not* valid on the `tom` and `yehuda`
-        variables. They are only valid on `App.Person`.
+  }
 
-        To add functions and properties to instances of
-        a constructor by extending the constructor's prototype
-        see `reopen`
+  /**
+    @class CoreObject
+    @namespace Ember
+  */
+  var CoreObject = makeCtor();
+  CoreObject.toString = function() { return "Ember.CoreObject"; };
+  CoreObject.PrototypeMixin = mixin.Mixin.create({
+    reopen: function() {
+      var length = arguments.length;
+      var args = new Array(length);
+      for (var i = 0; i < length; i++) {
+        args[i] = arguments[i];
+      }
+      applyMixin(this, args, true);
+      return this;
+    },
 
-        @method reopenClass
-      */
-      reopenClass: function() {
-        var l = arguments.length;
-        var args = new Array(l);
-        if (l > 0) {
-          for (var i = 0; i < l; i++) {
-            args[i] = arguments[i];
-          }
-        }
+    /**
+      An overridable method called when objects are instantiated. By default,
+      does nothing unless it is overridden during class definition.
 
-        apply(this.ClassMixin, reopen, args);
-        applyMixin(this, arguments, false);
-        return this;
-      },
+      Example:
 
-      detect: function(obj) {
-        if ('function' !== typeof obj) { return false; }
-        while(obj) {
-          if (obj===this) { return true; }
-          obj = obj.superclass;
+      ```javascript
+      App.Person = Ember.Object.extend({
+        init: function() {
+          alert('Name is ' + this.get('name'));
         }
-        return false;
-      },
+      });
 
-      detectInstance: function(obj) {
-        return obj instanceof this;
-      },
+      var steve = App.Person.create({
+        name: "Steve"
+      });
 
-      /**
-        In some cases, you may want to annotate computed properties with additional
-        metadata about how they function or what values they operate on. For
-        example, computed property functions may close over variables that are then
-        no longer available for introspection.
+      // alerts 'Name is Steve'.
+      ```
 
-        You can pass a hash of these values to a computed property like this:
+      NOTE: If you do override `init` for a framework class like `Ember.View` or
+      `Ember.ArrayController`, be sure to call `this._super.apply(this, arguments)` in your
+      `init` declaration! If you don't, Ember may not have an opportunity to
+      do important setup work, and you'll see strange behavior in your
+      application.
 
-        ```javascript
-        person: function() {
-          var personId = this.get('personId');
-          return App.Person.create({ id: personId });
-        }.property().meta({ type: App.Person })
-        ```
+      @method init
+    */
+    init: function() {},
+    __defineNonEnumerable: function(property) {
+      define_property.defineProperty(this, property.name, property.descriptor);
+      //this[property.name] = property.descriptor.value;
+    },
 
-        Once you've done this, you can retrieve the values saved to the computed
-        property from your class like this:
+    /**
+      Defines the properties that will be concatenated from the superclass
+      (instead of overridden).
 
-        ```javascript
-        MyClass.metaForProperty('person');
-        ```
+      By default, when you extend an Ember class a property defined in
+      the subclass overrides a property with the same name that is defined
+      in the superclass. However, there are some cases where it is preferable
+      to build up a property's value by combining the superclass' property
+      value with the subclass' value. An example of this in use within Ember
+      is the `classNames` property of `Ember.View`.
 
-        This will return the original hash that was passed to `meta()`.
-        
-        @static
-        @method metaForProperty
-        @param key {String} property name
-      */
-      metaForProperty: function(key) {
-        var meta = this.proto()['__ember_meta__'];
-        var desc = meta && meta.descs[key];
+      Here is some sample code showing the difference between a concatenated
+      property and a normal one:
 
-        Ember.assert("metaForProperty() could not find a computed property with key '"+key+"'.", !!desc && desc instanceof ComputedProperty);
-        return desc._meta || {};
-      },
+      ```javascript
+      App.BarView = Ember.View.extend({
+        someNonConcatenatedProperty: ['bar'],
+        classNames: ['bar']
+      });
 
-      _computedProperties: computed(function() {
-        hasCachedComputedProperties = true;
-        var proto = this.proto();
-        var descs = meta(proto).descs;
-        var property;
-        var properties = [];
+      App.FooBarView = App.BarView.extend({
+        someNonConcatenatedProperty: ['foo'],
+        classNames: ['foo']
+      });
 
-        for (var name in descs) {
-          property = descs[name];
+      var fooBarView = App.FooBarView.create();
+      fooBarView.get('someNonConcatenatedProperty'); // ['foo']
+      fooBarView.get('classNames'); // ['ember-view', 'bar', 'foo']
+      ```
 
-          if (property instanceof ComputedProperty) {
-            properties.push({
-              name: name,
-              meta: property._meta
-            });
-          }
-        }
-        return properties;
-      }).readOnly(),
+      This behavior extends to object creation as well. Continuing the
+      above example:
 
-      /**
-        Iterate over each computed property for the class, passing its name
-        and any associated metadata (see `metaForProperty`) to the callback.
-        
-        @static
-        @method eachComputedProperty
-        @param {Function} callback
-        @param {Object} binding
-      */
-      eachComputedProperty: function(callback, binding) {
-        var property, name;
-        var empty = {};
+      ```javascript
+      var view = App.FooBarView.create({
+        someNonConcatenatedProperty: ['baz'],
+        classNames: ['baz']
+      })
+      view.get('someNonConcatenatedProperty'); // ['baz']
+      view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz']
+      ```
+      Adding a single property that is not an array will just add it in the array:
 
-        var properties = get(this, '_computedProperties');
+      ```javascript
+      var view = App.FooBarView.create({
+        classNames: 'baz'
+      })
+      view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz']
+      ```
 
-        for (var i = 0, length = properties.length; i < length; i++) {
-          property = properties[i];
-          name = property.name;
-          callback.call(binding || this, property.name, property.meta || empty);
-        }
-      }
-    };
+      Using the `concatenatedProperties` property, we can tell Ember to mix the
+      content of the properties.
 
-    function injectedPropertyAssertion() {
-      Ember.assert("Injected properties are invalid", validatePropertyInjections(this));
-    }
+      In `Ember.View` the `classNameBindings` and `attributeBindings` properties
+      are also concatenated, in addition to `classNames`.
 
-    function addOnLookupHandler() {
-      Ember.runInDebug(function() {
-        /**
-          Provides lookup-time type validation for injected properties.
+      This feature is available for you to use throughout the Ember object model,
+      although typical app developers are likely to use it infrequently. Since
+      it changes expectations about behavior of properties, you should properly
+      document its usage in each individual concatenated property (to not
+      mislead your users to think they can override the property in a subclass).
 
-          @private
-          @method _onLookup
-          */
-        ClassMixinProps._onLookup = injectedPropertyAssertion;
-      });
-    }
+      @property concatenatedProperties
+      @type Array
+      @default null
+    */
+    concatenatedProperties: null,
 
-    
-      addOnLookupHandler();
+    /**
+      Destroyed object property flag.
 
-      /**
-        Returns a hash of property names and container names that injected
-        properties will lookup on the container lazily.
+      if this property is `true` the observers and bindings were already
+      removed by the effect of calling the `destroy()` method.
 
-        @method _lazyInjections
-        @return {Object} Hash of all lazy injected property keys to container names
-      */
-      ClassMixinProps._lazyInjections = function() {
-        var injections = {};
-        var proto = this.proto();
-        var descs = meta(proto).descs;
-        var key, desc;
-
-        for (key in descs) {
-          desc = descs[key];
-          if (desc instanceof InjectedProperty) {
-            injections[key] = desc.type + ':' + (desc.name || key);
-          }
-        }
+      @property isDestroyed
+      @default false
+    */
+    isDestroyed: false,
 
-        return injections;
-      };
-    
+    /**
+      Destruction scheduled flag. The `destroy()` method has been called.
 
-    var ClassMixin = Mixin.create(ClassMixinProps);
+      The object stays intact until the end of the run loop at which point
+      the `isDestroyed` flag is set.
 
-    ClassMixin.ownerConstructor = CoreObject;
+      @property isDestroying
+      @default false
+    */
+    isDestroying: false,
 
-    CoreObject.ClassMixin = ClassMixin;
+    /**
+      Destroys an object by setting the `isDestroyed` flag and removing its
+      metadata, which effectively destroys observers and bindings.
 
-    ClassMixin.apply(CoreObject);
+      If you try to set a property on a destroyed object, an exception will be
+      raised.
 
-    CoreObject.reopen({
-      didDefineProperty: function(proto, key, value) {
-        if (hasCachedComputedProperties === false) { return; }
-        if (value instanceof Ember.ComputedProperty) {
-          var cache = Ember.meta(this.constructor).cache;
+      Note that destruction is scheduled for the end of the run loop and does not
+      happen immediately.  It will set an isDestroying flag immediately.
 
-          if (cache._computedProperties !== undefined) {
-            cache._computedProperties = undefined;
-          }
-        }
-      }
-    });
+      @method destroy
+      @return {Ember.Object} receiver
+    */
+    destroy: function() {
+      if (this.isDestroying) { return; }
+      this.isDestroying = true;
 
-    __exports__["default"] = CoreObject;
-  });
-enifed("ember-runtime/system/deferred",
-  ["ember-metal/core","ember-runtime/mixins/deferred","ember-runtime/system/object","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var DeferredMixin = __dependency2__["default"];
-    var EmberObject = __dependency3__["default"];
+      schedule('actions', this, this.willDestroy);
+      schedule('destroy', this, this._scheduledDestroy);
+      return this;
+    },
 
-    var Deferred = EmberObject.extend(DeferredMixin, {
-      init: function() {
-        Ember.deprecate('Usage of Ember.Deferred is deprecated.', false, { url: 'http://emberjs.com/guides/deprecations/#toc_deprecate-ember-deferredmixin-and-ember-deferred' });
-        this._super();
-      }
-    });
+    /**
+      Override to implement teardown.
 
-    Deferred.reopenClass({
-      promise: function(callback, binding) {
-        var deferred = Deferred.create();
-        callback.call(binding, deferred);
-        return deferred;
-      }
-    });
+      @method willDestroy
+     */
+    willDestroy: core.K,
 
-    __exports__["default"] = Deferred;
-  });
-enifed("ember-runtime/system/each_proxy",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/enumerable_utils","ember-metal/array","ember-runtime/mixins/array","ember-runtime/system/object","ember-metal/computed","ember-metal/observer","ember-metal/events","ember-metal/properties","ember-metal/property_events","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-runtime
-    */
+      Invoked by the run loop to actually destroy the object. This is
+      scheduled for execution by the `destroy` method.
 
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-
-    var get = __dependency2__.get;
-    var guidFor = __dependency3__.guidFor;
-    var forEach = __dependency4__.forEach;
-    var indexOf = __dependency5__.indexOf;
-    var EmberArray = __dependency6__["default"];
-    // ES6TODO: WAT? Circular dep?
-    var EmberObject = __dependency7__["default"];
-    var computed = __dependency8__.computed;
-    var addObserver = __dependency9__.addObserver;
-    var addBeforeObserver = __dependency9__.addBeforeObserver;
-    var removeBeforeObserver = __dependency9__.removeBeforeObserver;
-    var removeObserver = __dependency9__.removeObserver;
-    var typeOf = __dependency3__.typeOf;
-    var watchedEvents = __dependency10__.watchedEvents;
-    var defineProperty = __dependency11__.defineProperty;
-    var beginPropertyChanges = __dependency12__.beginPropertyChanges;
-    var propertyDidChange = __dependency12__.propertyDidChange;
-    var propertyWillChange = __dependency12__.propertyWillChange;
-    var endPropertyChanges = __dependency12__.endPropertyChanges;
-    var changeProperties = __dependency12__.changeProperties;
-
-    var EachArray = EmberObject.extend(EmberArray, {
-
-      init: function(content, keyName, owner) {
-        this._super();
-        this._keyName = keyName;
-        this._owner   = owner;
-        this._content = content;
-      },
+      @private
+      @method _scheduledDestroy
+    */
+    _scheduledDestroy: function() {
+      if (this.isDestroyed) { return; }
+      watching.destroy(this);
+      this.isDestroyed = true;
+    },
 
-      objectAt: function(idx) {
-        var item = this._content.objectAt(idx);
-        return item && get(item, this._keyName);
-      },
+    bind: function(to, from) {
+      if (!(from instanceof binding.Binding)) { from = binding.Binding.from(from); }
+      from.to(to).connect(this);
+      return from;
+    },
 
-      length: computed(function() {
-        var content = this._content;
-        return content ? get(content, 'length') : 0;
-      })
+    /**
+      Returns a string representation which attempts to provide more information
+      than Javascript's `toString` typically does, in a generic way for all Ember
+      objects.
 
-    });
+      ```javascript
+      App.Person = Em.Object.extend()
+      person = App.Person.create()
+      person.toString() //=> "<App.Person:ember1024>"
+      ```
 
-    var IS_OBSERVER = /^.+:(before|change)$/;
+      If the object's class is not defined on an Ember namespace, it will
+      indicate it is a subclass of the registered superclass:
 
-    function addObserverForContentKey(content, keyName, proxy, idx, loc) {
-      var objects = proxy._objects;
-      var guid;
-      if (!objects) objects = proxy._objects = {};
+     ```javascript
+      Student = App.Person.extend()
+      student = Student.create()
+      student.toString() //=> "<(subclass of App.Person):ember1025>"
+      ```
 
-      while(--loc>=idx) {
-        var item = content.objectAt(loc);
-        if (item) {
-          Ember.assert('When using @each to observe the array ' + content + ', the array must return an object', typeOf(item) === 'instance' || typeOf(item) === 'object');
-          addBeforeObserver(item, keyName, proxy, 'contentKeyWillChange');
-          addObserver(item, keyName, proxy, 'contentKeyDidChange');
+      If the method `toStringExtension` is defined, its return value will be
+      included in the output.
 
-          // keep track of the index each item was found at so we can map
-          // it back when the obj changes.
-          guid = guidFor(item);
-          if (!objects[guid]) objects[guid] = [];
-          objects[guid].push(loc);
+      ```javascript
+      App.Teacher = App.Person.extend({
+        toStringExtension: function() {
+          return this.get('fullName');
         }
-      }
+      });
+      teacher = App.Teacher.create()
+      teacher.toString(); //=> "<App.Teacher:ember1026:Tom Dale>"
+      ```
+
+      @method toString
+      @return {String} string representation
+    */
+    toString: function toString() {
+      var hasToStringExtension = typeof this.toStringExtension === 'function';
+      var extension = hasToStringExtension ? ":" + this.toStringExtension() : '';
+      var ret = '<'+this.constructor.toString()+':'+utils.guidFor(this)+extension+'>';
+
+      this.toString = makeToString(ret);
+      return ret;
     }
+  });
 
-    function removeObserverForContentKey(content, keyName, proxy, idx, loc) {
-      var objects = proxy._objects;
-      if (!objects) objects = proxy._objects = {};
-      var indicies, guid;
+  CoreObject.PrototypeMixin.ownerConstructor = CoreObject;
 
-      while(--loc>=idx) {
-        var item = content.objectAt(loc);
-        if (item) {
-          removeBeforeObserver(item, keyName, proxy, 'contentKeyWillChange');
-          removeObserver(item, keyName, proxy, 'contentKeyDidChange');
+  function makeToString(ret) {
+    return function() { return ret; };
+  }
 
-          guid = guidFor(item);
-          indicies = objects[guid];
-          indicies[indexOf.call(indicies, loc)] = null;
-        }
-      }
-    }
+  CoreObject.__super__ = null;
+
+  var ClassMixinProps = {
+
+    ClassMixin: mixin.required(),
+
+    PrototypeMixin: mixin.required(),
+
+    isClass: true,
+
+    isMethod: false,
 
     /**
-      This is the object instance returned when you get the `@each` property on an
-      array. It uses the unknownProperty handler to automatically create
-      EachArray instances for property names.
+      Creates a new subclass.
 
-      @private
-      @class EachProxy
-      @namespace Ember
-      @extends Ember.Object
-    */
-    var EachProxy = EmberObject.extend({
+      ```javascript
+      App.Person = Ember.Object.extend({
+        say: function(thing) {
+          alert(thing);
+         }
+      });
+      ```
 
-      init: function(content) {
-        this._super();
-        this._content = content;
-        content.addArrayObserver(this);
+      This defines a new subclass of Ember.Object: `App.Person`. It contains one method: `say()`.
 
-        // in case someone is already observing some keys make sure they are
-        // added
-        forEach(watchedEvents(this), function(eventName) {
-          this.didAddListener(eventName);
-        }, this);
-      },
+      You can also create a subclass from any existing class by calling its `extend()`  method. For example, you might want to create a subclass of Ember's built-in `Ember.View` class:
 
-      /**
-        You can directly access mapped properties by simply requesting them.
-        The `unknownProperty` handler will generate an EachArray of each item.
+      ```javascript
+      App.PersonView = Ember.View.extend({
+        tagName: 'li',
+        classNameBindings: ['isAdministrator']
+      });
+      ```
 
-        @method unknownProperty
-        @param keyName {String}
-        @param value {*}
-      */
-      unknownProperty: function(keyName, value) {
-        var ret;
-        ret = new EachArray(this._content, keyName, this);
-        defineProperty(this, keyName, null, ret);
-        this.beginObservingContentKey(keyName);
-        return ret;
-      },
+      When defining a subclass, you can override methods but still access the implementation of your parent class by calling the special `_super()` method:
+
+      ```javascript
+      App.Person = Ember.Object.extend({
+        say: function(thing) {
+          var name = this.get('name');
+          alert(name + ' says: ' + thing);
+        }
+      });
 
-      // ..........................................................
-      // ARRAY CHANGES
-      // Invokes whenever the content array itself changes.
+      App.Soldier = App.Person.extend({
+        say: function(thing) {
+          this._super(thing + ", sir!");
+        },
+        march: function(numberOfHours) {
+          alert(this.get('name') + ' marches for ' + numberOfHours + ' hours.')
+        }
+      });
 
-      arrayWillChange: function(content, idx, removedCnt, addedCnt) {
-        var keys = this._keys;
-        var key, lim;
+      var yehuda = App.Soldier.create({
+        name: "Yehuda Katz"
+      });
 
-        lim = removedCnt>0 ? idx+removedCnt : -1;
-        beginPropertyChanges(this);
+      yehuda.say("Yes");  // alerts "Yehuda Katz says: Yes, sir!"
+      ```
 
-        for(key in keys) {
-          if (!keys.hasOwnProperty(key)) { continue; }
+      The `create()` on line #17 creates an *instance* of the `App.Soldier` class. The `extend()` on line #8 creates a *subclass* of `App.Person`. Any instance of the `App.Person` class will *not* have the `march()` method.
 
-          if (lim>0) { removeObserverForContentKey(content, key, this, idx, lim); }
+      You can also pass `Mixin` classes to add additional properties to the subclass.
 
-          propertyWillChange(this, key);
+      ```javascript
+      App.Person = Ember.Object.extend({
+        say: function(thing) {
+          alert(this.get('name') + ' says: ' + thing);
         }
+      });
 
-        propertyWillChange(this._content, '@each');
-        endPropertyChanges(this);
-      },
+      App.SingingMixin = Mixin.create({
+        sing: function(thing){
+          alert(this.get('name') + ' sings: la la la ' + thing);
+        }
+      });
 
-      arrayDidChange: function(content, idx, removedCnt, addedCnt) {
-        var keys = this._keys;
-        var lim;
+      App.BroadwayStar = App.Person.extend(App.SingingMixin, {
+        dance: function() {
+          alert(this.get('name') + ' dances: tap tap tap tap ');
+        }
+      });
+      ```
 
-        lim = addedCnt>0 ? idx+addedCnt : -1;
-        changeProperties(function() {
-          for(var key in keys) {
-            if (!keys.hasOwnProperty(key)) { continue; }
+      The `App.BroadwayStar` class contains three methods: `say()`, `sing()`, and `dance()`.
 
-            if (lim>0) { addObserverForContentKey(content, key, this, idx, lim); }
+      @method extend
+      @static
 
-            propertyDidChange(this, key);
-          }
+      @param {Mixin} [mixins]* One or more Mixin classes
+      @param {Object} [arguments]* Object containing values to use within the new class
+    */
+    extend: function extend() {
+      var Class = makeCtor();
+      var proto;
+      Class.ClassMixin = mixin.Mixin.create(this.ClassMixin);
+      Class.PrototypeMixin = mixin.Mixin.create(this.PrototypeMixin);
 
-          propertyDidChange(this._content, '@each');
-        }, this);
-      },
+      Class.ClassMixin.ownerConstructor = Class;
+      Class.PrototypeMixin.ownerConstructor = Class;
 
-      // ..........................................................
-      // LISTEN FOR NEW OBSERVERS AND OTHER EVENT LISTENERS
-      // Start monitoring keys based on who is listening...
+      reopen.apply(Class.PrototypeMixin, arguments);
 
-      didAddListener: function(eventName) {
-        if (IS_OBSERVER.test(eventName)) {
-          this.beginObservingContentKey(eventName.slice(0, -7));
-        }
-      },
+      Class.superclass = this;
+      Class.__super__  = this.prototype;
 
-      didRemoveListener: function(eventName) {
-        if (IS_OBSERVER.test(eventName)) {
-          this.stopObservingContentKey(eventName.slice(0, -7));
-        }
-      },
+      proto = Class.prototype = o_create['default'](this.prototype);
+      proto.constructor = Class;
+      utils.generateGuid(proto);
+      utils.meta(proto).proto = proto; // this will disable observers on prototype
 
-      // ..........................................................
-      // CONTENT KEY OBSERVING
-      // Actual watch keys on the source content.
+      Class.ClassMixin.apply(Class);
+      return Class;
+    },
 
-      beginObservingContentKey: function(keyName) {
-        var keys = this._keys;
-        if (!keys) keys = this._keys = {};
-        if (!keys[keyName]) {
-          keys[keyName] = 1;
-          var content = this._content;
-          var len = get(content, 'length');
+    /**
+      Equivalent to doing `extend(arguments).create()`.
+      If possible use the normal `create` method instead.
 
-          addObserverForContentKey(content, keyName, this, 0, len);
-        } else {
-          keys[keyName]++;
+      @method createWithMixins
+      @static
+      @param [arguments]*
+    */
+    createWithMixins: function() {
+      var C = this;
+      var l= arguments.length;
+      if (l > 0) {
+        var args = new Array(l);
+        for (var i = 0; i < l; i++) {
+          args[i] = arguments[i];
         }
-      },
+        this._initMixins(args);
+      }
+      return new C();
+    },
 
-      stopObservingContentKey: function(keyName) {
-        var keys = this._keys;
-        if (keys && (keys[keyName]>0) && (--keys[keyName]<=0)) {
-          var content = this._content;
-          var len     = get(content, 'length');
+    /**
+      Creates an instance of a class. Accepts either no arguments, or an object
+      containing values to initialize the newly instantiated object with.
 
-          removeObserverForContentKey(content, keyName, this, 0, len);
+      ```javascript
+      App.Person = Ember.Object.extend({
+        helloWorld: function() {
+          alert("Hi, my name is " + this.get('name'));
         }
-      },
+      });
 
-      contentKeyWillChange: function(obj, keyName) {
-        propertyWillChange(this, keyName);
-      },
+      var tom = App.Person.create({
+        name: 'Tom Dale'
+      });
 
-      contentKeyDidChange: function(obj, keyName) {
-        propertyDidChange(this, keyName);
-      }
-    });
+      tom.helloWorld(); // alerts "Hi, my name is Tom Dale".
+      ```
 
-    __exports__.EachArray = EachArray;
-    __exports__.EachProxy = EachProxy;
-  });
-enifed("ember-runtime/system/lazy_load",
-  ["ember-metal/core","ember-metal/array","ember-runtime/system/native_array","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    /*globals CustomEvent */
+      `create` will call the `init` function if defined during
+      `Ember.AnyObject.extend`
 
-    var Ember = __dependency1__["default"];
-    // Ember.ENV.EMBER_LOAD_HOOKS
-    var forEach = __dependency2__.forEach;
-    // make sure Ember.A is setup.
+      If no arguments are passed to `create`, it will not set values to the new
+      instance during initialization:
 
-    /**
-      @module ember
-      @submodule ember-runtime
-    */
+      ```javascript
+      var noName = App.Person.create();
+      noName.helloWorld(); // alerts undefined
+      ```
 
-    var loadHooks = Ember.ENV.EMBER_LOAD_HOOKS || {};
-    var loaded = {};
+      NOTE: For performance reasons, you cannot declare methods or computed
+      properties during `create`. You should instead declare methods and computed
+      properties when using `extend` or use the `createWithMixins` shorthand.
 
-    /**
-      Detects when a specific package of Ember (e.g. 'Ember.Handlebars')
-      has fully loaded and is available for extension.
+      @method create
+      @static
+      @param [arguments]*
+    */
+    create: function() {
+      var C = this;
+      var l = arguments.length;
+      if (l > 0) {
+        var args = new Array(l);
+        for (var i = 0; i < l; i++) {
+          args[i] = arguments[i];
+        }
+        this._initProperties(args);
+      }
+      return new C();
+    },
 
-      The provided `callback` will be called with the `name` passed
-      resolved from a string into the object:
+    /**
+      Augments a constructor's prototype with additional
+      properties and functions:
 
-      ``` javascript
-      Ember.onLoad('Ember.Handlebars' function(hbars) {
-        hbars.registerHelper(...);
+      ```javascript
+      MyObject = Ember.Object.extend({
+        name: 'an object'
       });
-      ```
 
-      @method onLoad
-      @for Ember
-      @param name {String} name of hook
-      @param callback {Function} callback to be called
-    */
-    function onLoad(name, callback) {
-      var object;
+      o = MyObject.create();
+      o.get('name'); // 'an object'
 
-      loadHooks[name] = loadHooks[name] || Ember.A();
-      loadHooks[name].pushObject(callback);
+      MyObject.reopen({
+        say: function(msg){
+          console.log(msg);
+        }
+      })
 
-      if (object = loaded[name]) {
-        callback(object);
-      }
-    }
+      o2 = MyObject.create();
+      o2.say("hello"); // logs "hello"
+
+      o.say("goodbye"); // logs "goodbye"
+      ```
 
-    __exports__.onLoad = onLoad;/**
-      Called when an Ember.js package (e.g Ember.Handlebars) has finished
-      loading. Triggers any callbacks registered for this event.
+      To add functions and properties to the constructor itself,
+      see `reopenClass`
 
-      @method runLoadHooks
-      @for Ember
-      @param name {String} name of hook
-      @param object {Object} object to pass to callbacks
+      @method reopen
     */
-    function runLoadHooks(name, object) {
-      loaded[name] = object;
+    reopen: function() {
+      this.willReopen();
 
-      if (typeof window === 'object' && typeof window.dispatchEvent === 'function' && typeof CustomEvent === "function") {
-        var event = new CustomEvent(name, {detail: object, name: name});
-        window.dispatchEvent(event);
+      var l = arguments.length;
+      var args = new Array(l);
+      if (l > 0) {
+        for (var i = 0; i < l; i++) {
+          args[i] = arguments[i];
+        }
       }
 
-      if (loadHooks[name]) {
-        forEach.call(loadHooks[name], function(callback) {
-          callback(object);
-        });
-      }
-    }
+      utils.apply(this.PrototypeMixin, reopen, args);
+      return this;
+    },
 
-    __exports__.runLoadHooks = runLoadHooks;
-  });
-enifed("ember-runtime/system/namespace",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/array","ember-metal/utils","ember-metal/mixin","ember-runtime/system/object","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-runtime
-    */
+      Augments a constructor's own properties and functions:
 
-    // Ember.lookup, Ember.BOOTED, Ember.deprecate, Ember.NAME_KEY, Ember.anyUnprocessedMixins
-    var Ember = __dependency1__["default"];
-    var get = __dependency2__.get;
-    var indexOf = __dependency3__.indexOf;
-    var GUID_KEY = __dependency4__.GUID_KEY;
-    var guidFor = __dependency4__.guidFor;
-    var Mixin = __dependency5__.Mixin;
+      ```javascript
+      MyObject = Ember.Object.extend({
+        name: 'an object'
+      });
 
-    var EmberObject = __dependency6__["default"];
+      MyObject.reopenClass({
+        canBuild: false
+      });
 
-    /**
-      A Namespace is an object usually used to contain other objects or methods
-      such as an application or framework. Create a namespace anytime you want
-      to define one of these new containers.
+      MyObject.canBuild; // false
+      o = MyObject.create();
+      ```
 
-      # Example Usage
+      In other words, this creates static properties and functions for the class. These are only available on the class
+      and not on any instance of that class.
 
       ```javascript
-      MyFramework = Ember.Namespace.create({
-        VERSION: '1.0.0'
+      App.Person = Ember.Object.extend({
+        name : "",
+        sayHello : function() {
+          alert("Hello. My name is " + this.get('name'));
+        }
       });
-      ```
 
-      @class Namespace
-      @namespace Ember
-      @extends Ember.Object
-    */
-    var Namespace = EmberObject.extend({
-      isNamespace: true,
-
-      init: function() {
-        Namespace.NAMESPACES.push(this);
-        Namespace.PROCESSED = false;
-      },
+      App.Person.reopenClass({
+        species : "Homo sapiens",
+        createPerson: function(newPersonsName){
+          return App.Person.create({
+            name:newPersonsName
+          });
+        }
+      });
 
-      toString: function() {
-        var name = get(this, 'name') || get(this, 'modulePrefix');
-        if (name) { return name; }
+      var tom = App.Person.create({
+        name : "Tom Dale"
+      });
+      var yehuda = App.Person.createPerson("Yehuda Katz");
 
-        findNamespaces();
-        return this[NAME_KEY];
-      },
+      tom.sayHello(); // "Hello. My name is Tom Dale"
+      yehuda.sayHello(); // "Hello. My name is Yehuda Katz"
+      alert(App.Person.species); // "Homo sapiens"
+      ```
 
-      nameClasses: function() {
-        processNamespace([this.toString()], this, {});
-      },
+      Note that `species` and `createPerson` are *not* valid on the `tom` and `yehuda`
+      variables. They are only valid on `App.Person`.
 
-      destroy: function() {
-        var namespaces = Namespace.NAMESPACES;
-        var toString = this.toString();
+      To add functions and properties to instances of
+      a constructor by extending the constructor's prototype
+      see `reopen`
 
-        if (toString) {
-          Ember.lookup[toString] = undefined;
-          delete Namespace.NAMESPACES_BY_ID[toString];
+      @method reopenClass
+    */
+    reopenClass: function() {
+      var l = arguments.length;
+      var args = new Array(l);
+      if (l > 0) {
+        for (var i = 0; i < l; i++) {
+          args[i] = arguments[i];
         }
-        namespaces.splice(indexOf.call(namespaces, this), 1);
-        this._super();
       }
-    });
 
-    Namespace.reopenClass({
-      NAMESPACES: [Ember],
-      NAMESPACES_BY_ID: {},
-      PROCESSED: false,
-      processAll: processAllNamespaces,
-      byName: function(name) {
-        if (!Ember.BOOTED) {
-          processAllNamespaces();
-        }
+      utils.apply(this.ClassMixin, reopen, args);
+      applyMixin(this, arguments, false);
+      return this;
+    },
 
-        return NAMESPACES_BY_ID[name];
+    detect: function(obj) {
+      if ('function' !== typeof obj) { return false; }
+      while (obj) {
+        if (obj===this) { return true; }
+        obj = obj.superclass;
       }
-    });
+      return false;
+    },
+
+    detectInstance: function(obj) {
+      return obj instanceof this;
+    },
 
-    var NAMESPACES_BY_ID = Namespace.NAMESPACES_BY_ID;
+    /**
+      In some cases, you may want to annotate computed properties with additional
+      metadata about how they function or what values they operate on. For
+      example, computed property functions may close over variables that are then
+      no longer available for introspection.
 
-    var hasOwnProp = ({}).hasOwnProperty;
+      You can pass a hash of these values to a computed property like this:
 
-    function processNamespace(paths, root, seen) {
-      var idx = paths.length;
+      ```javascript
+      person: function() {
+        var personId = this.get('personId');
+        return App.Person.create({ id: personId });
+      }.property().meta({ type: App.Person })
+      ```
 
-      NAMESPACES_BY_ID[paths.join('.')] = root;
+      Once you've done this, you can retrieve the values saved to the computed
+      property from your class like this:
 
-      // Loop over all of the keys in the namespace, looking for classes
-      for(var key in root) {
-        if (!hasOwnProp.call(root, key)) { continue; }
-        var obj = root[key];
+      ```javascript
+      MyClass.metaForProperty('person');
+      ```
 
-        // If we are processing the `Ember` namespace, for example, the
-        // `paths` will start with `["Ember"]`. Every iteration through
-        // the loop will update the **second** element of this list with
-        // the key, so processing `Ember.View` will make the Array
-        // `['Ember', 'View']`.
-        paths[idx] = key;
+      This will return the original hash that was passed to `meta()`.
 
-        // If we have found an unprocessed class
-        if (obj && obj.toString === classToString) {
-          // Replace the class' `toString` with the dot-separated path
-          // and set its `NAME_KEY`
-          obj.toString = makeToString(paths.join('.'));
-          obj[NAME_KEY] = paths.join('.');
+      @static
+      @method metaForProperty
+      @param key {String} property name
+    */
+    metaForProperty: function(key) {
+      var proto = this.proto();
+      var possibleDesc = proto[key];
+      var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
+
+      Ember['default'].assert("metaForProperty() could not find a computed property with key '"+key+"'.", !!desc && desc instanceof computed.ComputedProperty);
+      return desc._meta || {};
+    },
+
+    _computedProperties: computed.computed(function() {
+      hasCachedComputedProperties = true;
+      var proto = this.proto();
+      var property;
+      var properties = [];
 
-        // Support nested namespaces
-        } else if (obj && obj.isNamespace) {
-          // Skip aliased namespaces
-          if (seen[guidFor(obj)]) { continue; }
-          seen[guidFor(obj)] = true;
+      for (var name in proto) {
+        property = proto[name];
 
-          // Process the child namespace
-          processNamespace(paths, obj, seen);
+        if (property instanceof computed.ComputedProperty) {
+          properties.push({
+            name: name,
+            meta: property._meta
+          });
         }
       }
+      return properties;
+    }).readOnly(),
 
-      paths.length = idx; // cut out last item
-    }
+    /**
+      Iterate over each computed property for the class, passing its name
+      and any associated metadata (see `metaForProperty`) to the callback.
+
+      @static
+      @method eachComputedProperty
+      @param {Function} callback
+      @param {Object} binding
+    */
+    eachComputedProperty: function(callback, binding) {
+      var property, name;
+      var empty = {};
 
-    var STARTS_WITH_UPPERCASE = /^[A-Z]/;
+      var properties = property_get.get(this, '_computedProperties');
 
-    function tryIsNamespace(lookup, prop) {
-      try {
-        var obj = lookup[prop];
-        return obj && obj.isNamespace && obj;
-      } catch (e) {
-        // continue
+      for (var i = 0, length = properties.length; i < length; i++) {
+        property = properties[i];
+        name = property.name;
+        callback.call(binding || this, property.name, property.meta || empty);
       }
     }
+  };
 
-    function findNamespaces() {
-      var lookup = Ember.lookup;
-      var obj;
+  function injectedPropertyAssertion() {
+    Ember['default'].assert("Injected properties are invalid", inject.validatePropertyInjections(this));
+  }
+
+  Ember['default'].runInDebug(function() {
+    /**
+      Provides lookup-time type validation for injected properties.
 
-      if (Namespace.PROCESSED) { return; }
+      @private
+      @method _onLookup
+      */
+    ClassMixinProps._onLookup = injectedPropertyAssertion;
+  });
 
-      for (var prop in lookup) {
-        // Only process entities that start with uppercase A-Z
-        if (!STARTS_WITH_UPPERCASE.test(prop)) { continue; }
+  /**
+    Returns a hash of property names and container names that injected
+    properties will lookup on the container lazily.
 
-        // Unfortunately, some versions of IE don't support window.hasOwnProperty
-        if (lookup.hasOwnProperty && !lookup.hasOwnProperty(prop)) { continue; }
+    @method _lazyInjections
+    @return {Object} Hash of all lazy injected property keys to container names
+  */
+  ClassMixinProps._lazyInjections = function() {
+    var injections = {};
+    var proto = this.proto();
+    var key, desc;
 
-        // At times we are not allowed to access certain properties for security reasons.
-        // There are also times where even if we can access them, we are not allowed to access their properties.
-        obj = tryIsNamespace(lookup, prop);
-        if (obj) {
-          obj[NAME_KEY] = prop;
-        }
+    for (key in proto) {
+      desc = proto[key];
+      if (desc instanceof InjectedProperty['default']) {
+        injections[key] = desc.type + ':' + (desc.name || key);
       }
     }
 
-    var NAME_KEY = Ember.NAME_KEY = GUID_KEY + '_name';
+    return injections;
+  };
 
-    function superClassString(mixin) {
-      var superclass = mixin.superclass;
-      if (superclass) {
-        if (superclass[NAME_KEY]) { return superclass[NAME_KEY]; }
-        else { return superClassString(superclass); }
-      } else {
-        return;
-      }
-    }
+  var ClassMixin = mixin.Mixin.create(ClassMixinProps);
 
-    function classToString() {
-      if (!Ember.BOOTED && !this[NAME_KEY]) {
-        processAllNamespaces();
-      }
+  ClassMixin.ownerConstructor = CoreObject;
 
-      var ret;
+  CoreObject.ClassMixin = ClassMixin;
 
-      if (this[NAME_KEY]) {
-        ret = this[NAME_KEY];
-      } else if (this._toString) {
-        ret = this._toString;
-      } else {
-        var str = superClassString(this);
-        if (str) {
-          ret = "(subclass of " + str + ")";
-        } else {
-          ret = "(unknown mixin)";
+  ClassMixin.apply(CoreObject);
+
+  CoreObject.reopen({
+    didDefineProperty: function(proto, key, value) {
+      if (hasCachedComputedProperties === false) { return; }
+      if (value instanceof Ember['default'].ComputedProperty) {
+        var cache = Ember['default'].meta(this.constructor).cache;
+
+        if (cache && cache._computedProperties !== undefined) {
+          cache._computedProperties = undefined;
         }
-        this.toString = makeToString(ret);
       }
-
-      return ret;
     }
+  });
 
-    function processAllNamespaces() {
-      var unprocessedNamespaces = !Namespace.PROCESSED;
-      var unprocessedMixins = Ember.anyUnprocessedMixins;
-
-      if (unprocessedNamespaces) {
-        findNamespaces();
-        Namespace.PROCESSED = true;
-      }
+  exports['default'] = CoreObject;
 
-      if (unprocessedNamespaces || unprocessedMixins) {
-        var namespaces = Namespace.NAMESPACES;
-        var namespace;
+});
+enifed('ember-runtime/system/deferred', ['exports', 'ember-metal/core', 'ember-runtime/mixins/deferred', 'ember-runtime/system/object'], function (exports, Ember, DeferredMixin, EmberObject) {
 
-        for (var i=0, l=namespaces.length; i<l; i++) {
-          namespace = namespaces[i];
-          processNamespace([namespace.toString()], namespace, {});
-        }
+  'use strict';
 
-        Ember.anyUnprocessedMixins = false;
-      }
+  var Deferred = EmberObject['default'].extend(DeferredMixin['default'], {
+    init: function() {
+      Ember['default'].deprecate(
+        'Usage of Ember.Deferred is deprecated.',
+        false,
+        { url: 'http://emberjs.com/guides/deprecations/#toc_deferredmixin-and-ember-deferred' }
+      );
+      this._super.apply(this, arguments);
     }
+  });
 
-    function makeToString(ret) {
-      return function() { return ret; };
+  Deferred.reopenClass({
+    promise: function(callback, binding) {
+      var deferred = Deferred.create();
+      callback.call(binding, deferred);
+      return deferred;
     }
-
-    Mixin.prototype.toString = classToString; // ES6TODO: altering imported objects. SBB.
-
-    __exports__["default"] = Namespace;
   });
-enifed("ember-runtime/system/native_array",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/enumerable_utils","ember-metal/mixin","ember-metal/array","ember-runtime/mixins/array","ember-runtime/mixins/mutable_array","ember-runtime/mixins/observable","ember-runtime/mixins/copyable","ember-runtime/mixins/freezable","ember-runtime/copy","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
 
-    var Ember = __dependency1__["default"];
-    // Ember.EXTEND_PROTOTYPES
+  exports['default'] = Deferred;
 
-    var get = __dependency2__.get;
-    var replace = __dependency3__._replace;
-    var forEach = __dependency3__.forEach;
-    var Mixin = __dependency4__.Mixin;
-    var indexOf = __dependency5__.indexOf;
-    var lastIndexOf = __dependency5__.lastIndexOf;
-    var EmberArray = __dependency6__["default"];
-    var MutableArray = __dependency7__["default"];
-    var Observable = __dependency8__["default"];
-    var Copyable = __dependency9__["default"];
-    var FROZEN_ERROR = __dependency10__.FROZEN_ERROR;
-    var copy = __dependency11__["default"];
-
-    // Add Ember.Array to Array.prototype. Remove methods with native
-    // implementations and supply some more optimized versions of generic methods
-    // because they are so common.
-
-    /**
-      The NativeArray mixin contains the properties needed to make the native
-      Array support Ember.MutableArray and all of its dependent APIs. Unless you
-      have `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Array` set to
-      false, this will be applied automatically. Otherwise you can apply the mixin
-      at anytime by calling `Ember.NativeArray.activate`.
-
-      @class NativeArray
-      @namespace Ember
-      @uses Ember.MutableArray
-      @uses Ember.Observable
-      @uses Ember.Copyable
-    */
-    var NativeArray = Mixin.create(MutableArray, Observable, Copyable, {
-
-      // because length is a built-in property we need to know to just get the
-      // original property.
-      get: function(key) {
-        if (key==='length') return this.length;
-        else if ('number' === typeof key) return this[key];
-        else return this._super(key);
-      },
+});
+enifed('ember-runtime/system/each_proxy', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/utils', 'ember-metal/enumerable_utils', 'ember-metal/array', 'ember-runtime/mixins/array', 'ember-runtime/system/object', 'ember-metal/computed', 'ember-metal/observer', 'ember-metal/events', 'ember-metal/properties', 'ember-metal/property_events'], function (exports, Ember, property_get, utils, enumerable_utils, array, EmberArray, EmberObject, computed, observer, events, properties, property_events) {
 
-      objectAt: function(idx) {
-        return this[idx];
-      },
+  'use strict';
 
-      // primitive for array support.
-      replace: function(idx, amt, objects) {
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-        if (this.isFrozen) throw FROZEN_ERROR;
+  var EachArray = EmberObject['default'].extend(EmberArray['default'], {
 
-        // if we replaced exactly the same number of items, then pass only the
-        // replaced range. Otherwise, pass the full remaining array length
-        // since everything has shifted
-        var len = objects ? get(objects, 'length') : 0;
-        this.arrayContentWillChange(idx, amt, len);
+    init: function(content, keyName, owner) {
+      this._super.apply(this, arguments);
+      this._keyName = keyName;
+      this._owner   = owner;
+      this._content = content;
+    },
 
-        if (len === 0) {
-          this.splice(idx, amt);
-        } else {
-          replace(this, idx, amt, objects);
-        }
+    objectAt: function(idx) {
+      var item = this._content.objectAt(idx);
+      return item && property_get.get(item, this._keyName);
+    },
 
-        this.arrayContentDidChange(idx, amt, len);
-        return this;
-      },
+    length: computed.computed(function() {
+      var content = this._content;
+      return content ? property_get.get(content, 'length') : 0;
+    })
 
-      // If you ask for an unknown property, then try to collect the value
-      // from member items.
-      unknownProperty: function(key, value) {
-        var ret;// = this.reducedProperty(key, value) ;
-        if (value !== undefined && ret === undefined) {
-          ret = this[key] = value;
-        }
-        return ret;
-      },
+  });
 
-      indexOf: indexOf,
+  var IS_OBSERVER = /^.+:(before|change)$/;
+
+  function addObserverForContentKey(content, keyName, proxy, idx, loc) {
+    var objects = proxy._objects;
+    var guid;
+    if (!objects) {
+      objects = proxy._objects = {};
+    }
 
-      lastIndexOf: lastIndexOf,
+    while (--loc >= idx) {
+      var item = content.objectAt(loc);
+      if (item) {
+        Ember['default'].assert('When using @each to observe the array ' + content + ', the array must return an object', utils.typeOf(item) === 'instance' || utils.typeOf(item) === 'object');
+        observer.addBeforeObserver(item, keyName, proxy, 'contentKeyWillChange');
+        observer.addObserver(item, keyName, proxy, 'contentKeyDidChange');
 
-      copy: function(deep) {
-        if (deep) {
-          return this.map(function(item) { return copy(item, true); });
+        // keep track of the index each item was found at so we can map
+        // it back when the obj changes.
+        guid = utils.guidFor(item);
+        if (!objects[guid]) {
+          objects[guid] = [];
         }
 
-        return this.slice();
+        objects[guid].push(loc);
       }
-    });
+    }
+  }
 
-    // Remove any methods implemented natively so we don't override them
-    var ignore = ['length'];
-    forEach(NativeArray.keys(), function(methodName) {
-      if (Array.prototype[methodName]) ignore.push(methodName);
-    });
+  function removeObserverForContentKey(content, keyName, proxy, idx, loc) {
+    var objects = proxy._objects;
+    if (!objects) {
+      objects = proxy._objects = {};
+    }
+
+    var indices, guid;
 
-    if (ignore.length > 0) {
-      NativeArray = NativeArray.without.apply(NativeArray, ignore);
+    while (--loc >= idx) {
+      var item = content.objectAt(loc);
+      if (item) {
+        observer.removeBeforeObserver(item, keyName, proxy, 'contentKeyWillChange');
+        observer.removeObserver(item, keyName, proxy, 'contentKeyDidChange');
+
+        guid = utils.guidFor(item);
+        indices = objects[guid];
+        indices[array.indexOf.call(indices, loc)] = null;
+      }
     }
+  }
+
+  /**
+    This is the object instance returned when you get the `@each` property on an
+    array. It uses the unknownProperty handler to automatically create
+    EachArray instances for property names.
+
+    @private
+    @class EachProxy
+    @namespace Ember
+    @extends Ember.Object
+  */
+  var EachProxy = EmberObject['default'].extend({
+
+    init: function(content) {
+      this._super.apply(this, arguments);
+      this._content = content;
+      content.addArrayObserver(this);
+
+      // in case someone is already observing some keys make sure they are
+      // added
+      enumerable_utils.forEach(events.watchedEvents(this), function(eventName) {
+        this.didAddListener(eventName);
+      }, this);
+    },
 
     /**
-      Creates an `Ember.NativeArray` from an Array like object.
-      Does not modify the original object. Ember.A is not needed if
-      `Ember.EXTEND_PROTOTYPES` is `true` (the default value). However,
-      it is recommended that you use Ember.A when creating addons for
-      ember or when you can not guarantee that `Ember.EXTEND_PROTOTYPES`
-      will be `true`.
+      You can directly access mapped properties by simply requesting them.
+      The `unknownProperty` handler will generate an EachArray of each item.
 
-      Example
+      @method unknownProperty
+      @param keyName {String}
+      @param value {*}
+    */
+    unknownProperty: function(keyName, value) {
+      var ret;
+      ret = new EachArray(this._content, keyName, this);
+      properties.defineProperty(this, keyName, null, ret);
+      this.beginObservingContentKey(keyName);
+      return ret;
+    },
 
-      ```js
-      var Pagination = Ember.CollectionView.extend({
-        tagName: 'ul',
-        classNames: ['pagination'],
+    // ..........................................................
+    // ARRAY CHANGES
+    // Invokes whenever the content array itself changes.
 
-        init: function() {
-          this._super();
-          if (!this.get('content')) {
-            this.set('content', Ember.A());
-          }
+    arrayWillChange: function(content, idx, removedCnt, addedCnt) {
+      var keys = this._keys;
+      var key, lim;
+
+      lim = removedCnt>0 ? idx+removedCnt : -1;
+      property_events.beginPropertyChanges(this);
+
+      for (key in keys) {
+        if (!keys.hasOwnProperty(key)) { continue; }
+
+        if (lim>0) { removeObserverForContentKey(content, key, this, idx, lim); }
+
+        property_events.propertyWillChange(this, key);
+      }
+
+      property_events.propertyWillChange(this._content, '@each');
+      property_events.endPropertyChanges(this);
+    },
+
+    arrayDidChange: function(content, idx, removedCnt, addedCnt) {
+      var keys = this._keys;
+      var lim;
+
+      lim = addedCnt>0 ? idx+addedCnt : -1;
+      property_events.changeProperties(function() {
+        for (var key in keys) {
+          if (!keys.hasOwnProperty(key)) { continue; }
+
+          if (lim>0) { addObserverForContentKey(content, key, this, idx, lim); }
+
+          property_events.propertyDidChange(this, key);
         }
-      });
-      ```
 
-      @method A
-      @for Ember
-      @return {Ember.NativeArray}
-    */
-    var A = function(arr) {
-      if (arr === undefined) { arr = []; }
-      return EmberArray.detect(arr) ? arr : NativeArray.apply(arr);
-    };
+        property_events.propertyDidChange(this._content, '@each');
+      }, this);
+    },
 
-    /**
-      Activates the mixin on the Array.prototype if not already applied. Calling
-      this method more than once is safe. This will be called when ember is loaded
-      unless you have `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Array`
-      set to `false`.
+    // ..........................................................
+    // LISTEN FOR NEW OBSERVERS AND OTHER EVENT LISTENERS
+    // Start monitoring keys based on who is listening...
 
-      Example
+    didAddListener: function(eventName) {
+      if (IS_OBSERVER.test(eventName)) {
+        this.beginObservingContentKey(eventName.slice(0, -7));
+      }
+    },
 
-      ```js
-      if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Array) {
-        Ember.NativeArray.activate();
+    didRemoveListener: function(eventName) {
+      if (IS_OBSERVER.test(eventName)) {
+        this.stopObservingContentKey(eventName.slice(0, -7));
       }
-      ```
+    },
 
-      @method activate
-      @for Ember.NativeArray
-      @static
-      @return {void}
-    */
-    NativeArray.activate = function() {
-      NativeArray.apply(Array.prototype);
+    // ..........................................................
+    // CONTENT KEY OBSERVING
+    // Actual watch keys on the source content.
 
-      A = function(arr) { return arr || []; };
-    };
+    beginObservingContentKey: function(keyName) {
+      var keys = this._keys;
+      if (!keys) {
+        keys = this._keys = {};
+      }
 
-    if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Array) {
-      NativeArray.activate();
-    }
+      if (!keys[keyName]) {
+        keys[keyName] = 1;
+        var content = this._content;
+        var len = property_get.get(content, 'length');
 
-    Ember.A = A; // ES6TODO: Setting A onto the object returned by ember-metal/core to avoid circles
-    __exports__.A = A;
-    __exports__.NativeArray = NativeArray;
-    __exports__["default"] = NativeArray;
-  });
-enifed("ember-runtime/system/object",
-  ["ember-runtime/system/core_object","ember-runtime/mixins/observable","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
+        addObserverForContentKey(content, keyName, this, 0, len);
+      } else {
+        keys[keyName]++;
+      }
+    },
 
-    var CoreObject = __dependency1__["default"];
-    var Observable = __dependency2__["default"];
+    stopObservingContentKey: function(keyName) {
+      var keys = this._keys;
+      if (keys && (keys[keyName]>0) && (--keys[keyName]<=0)) {
+        var content = this._content;
+        var len     = property_get.get(content, 'length');
 
-    /**
-      `Ember.Object` is the main base class for all Ember objects. It is a subclass
-      of `Ember.CoreObject` with the `Ember.Observable` mixin applied. For details,
-      see the documentation for each of these.
+        removeObserverForContentKey(content, keyName, this, 0, len);
+      }
+    },
 
-      @class Object
-      @namespace Ember
-      @extends Ember.CoreObject
-      @uses Ember.Observable
-    */
-    var EmberObject = CoreObject.extend(Observable);
-    EmberObject.toString = function() {
-      return "Ember.Object";
-    };
+    contentKeyWillChange: function(obj, keyName) {
+      property_events.propertyWillChange(this, keyName);
+    },
 
-    __exports__["default"] = EmberObject;
-  });
-enifed("ember-runtime/system/object_proxy",
-  ["ember-runtime/system/object","ember-runtime/mixins/-proxy","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var EmberObject = __dependency1__["default"];
-    var _ProxyMixin = __dependency2__["default"];
+    contentKeyDidChange: function(obj, keyName) {
+      property_events.propertyDidChange(this, keyName);
+    }
+  });
 
-    /**
-      `Ember.ObjectProxy` forwards all properties not defined by the proxy itself
-      to a proxied `content` object.
+  exports.EachArray = EachArray;
+  exports.EachProxy = EachProxy;
 
-      ```javascript
-      object = Ember.Object.create({
-        name: 'Foo'
-      });
+});
+enifed('ember-runtime/system/lazy_load', ['exports', 'ember-metal/core', 'ember-metal/array', 'ember-runtime/system/native_array'], function (exports, Ember, array) {
 
-      proxy = Ember.ObjectProxy.create({
-        content: object
-      });
+  'use strict';
 
-      // Access and change existing properties
-      proxy.get('name')          // 'Foo'
-      proxy.set('name', 'Bar');
-      object.get('name')         // 'Bar'
+  exports.onLoad = onLoad;
+  exports.runLoadHooks = runLoadHooks;
 
-      // Create new 'description' property on `object`
-      proxy.set('description', 'Foo is a whizboo baz');
-      object.get('description')  // 'Foo is a whizboo baz'
-      ```
+  /*globals CustomEvent */
 
-      While `content` is unset, setting a property to be delegated will throw an
-      Error.
+  var loadHooks = Ember['default'].ENV.EMBER_LOAD_HOOKS || {};
+  var loaded = {};
 
-      ```javascript
-      proxy = Ember.ObjectProxy.create({
-        content: null,
-        flag: null
-      });
-      proxy.set('flag', true);
-      proxy.get('flag');         // true
-      proxy.get('foo');          // undefined
-      proxy.set('foo', 'data');  // throws Error
-      ```
+  /**
+    Detects when a specific package of Ember (e.g. 'Ember.Handlebars')
+    has fully loaded and is available for extension.
 
-      Delegated properties can be bound to and will change when content is updated.
+    The provided `callback` will be called with the `name` passed
+    resolved from a string into the object:
 
-      Computed properties on the proxy itself can depend on delegated properties.
+    ``` javascript
+    Ember.onLoad('Ember.Handlebars' function(hbars) {
+      hbars.registerHelper(...);
+    });
+    ```
 
-      ```javascript
-      ProxyWithComputedProperty = Ember.ObjectProxy.extend({
-        fullName: function () {
-          var firstName = this.get('firstName'),
-              lastName = this.get('lastName');
-          if (firstName && lastName) {
-            return firstName + ' ' + lastName;
-          }
-          return firstName || lastName;
-        }.property('firstName', 'lastName')
-      });
+    @method onLoad
+    @for Ember
+    @param name {String} name of hook
+    @param callback {Function} callback to be called
+  */
+  function onLoad(name, callback) {
+    var object;
 
-      proxy = ProxyWithComputedProperty.create();
+    loadHooks[name] = loadHooks[name] || Ember['default'].A();
+    loadHooks[name].pushObject(callback);
 
-      proxy.get('fullName');  // undefined
-      proxy.set('content', {
-        firstName: 'Tom', lastName: 'Dale'
-      }); // triggers property change for fullName on proxy
+    if (object = loaded[name]) {
+      callback(object);
+    }
+  }
 
-      proxy.get('fullName');  // 'Tom Dale'
-      ```
+  /**
+    Called when an Ember.js package (e.g Ember.Handlebars) has finished
+    loading. Triggers any callbacks registered for this event.
 
-      @class ObjectProxy
-      @namespace Ember
-      @extends Ember.Object
-      @extends Ember._ProxyMixin
-    */
+    @method runLoadHooks
+    @for Ember
+    @param name {String} name of hook
+    @param object {Object} object to pass to callbacks
+  */
+  function runLoadHooks(name, object) {
+    loaded[name] = object;
 
-    __exports__["default"] = EmberObject.extend(_ProxyMixin);
-  });
-enifed("ember-runtime/system/service",
-  ["ember-runtime/system/object","ember-runtime/inject","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var Object = __dependency1__["default"];
-    var createInjectionHelper = __dependency2__.createInjectionHelper;
+    if (typeof window === 'object' && typeof window.dispatchEvent === 'function' && typeof CustomEvent === "function") {
+      var event = new CustomEvent(name, { detail: object, name: name });
+      window.dispatchEvent(event);
+    }
 
-    var Service;
+    if (loadHooks[name]) {
+      array.forEach.call(loadHooks[name], function(callback) {
+        callback(object);
+      });
+    }
+  }
 
-    
-      /**
-        @class Service
-        @namespace Ember
-        @extends Ember.Object
-      */
-      Service = Object.extend();
+});
+enifed('ember-runtime/system/namespace', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/array', 'ember-metal/utils', 'ember-metal/mixin', 'ember-runtime/system/object'], function (exports, Ember, property_get, array, utils, mixin, EmberObject) {
 
-      /**
-        Creates a property that lazily looks up a service in the container. There
-        are no restrictions as to what objects a service can be injected into.
+  'use strict';
 
-        Example:
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-        ```javascript
-        App.ApplicationRoute = Ember.Route.extend({
-          authManager: Ember.inject.service('auth'),
+  // Ember.lookup, Ember.BOOTED, Ember.deprecate, Ember.NAME_KEY, Ember.anyUnprocessedMixins
+  var Namespace = EmberObject['default'].extend({
+    isNamespace: true,
 
-          model: function() {
-            return this.get('authManager').findCurrentUser();
-          }
-        });
-        ```
+    init: function() {
+      Namespace.NAMESPACES.push(this);
+      Namespace.PROCESSED = false;
+    },
 
-        This example will create an `authManager` property on the application route
-        that looks up the `auth` service in the container, making it easily
-        accessible in the `model` hook.
+    toString: function() {
+      var name = property_get.get(this, 'name') || property_get.get(this, 'modulePrefix');
+      if (name) { return name; }
 
-        @method inject.service
-        @for Ember
-        @param {String} name (optional) name of the service to inject, defaults to
-               the property's name
-        @return {Ember.InjectedProperty} injection descriptor instance
-      */
-      createInjectionHelper('service');
-    
+      findNamespaces();
+      return this[NAME_KEY];
+    },
 
-    __exports__["default"] = Service;
-  });
-enifed("ember-runtime/system/set",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/is_none","ember-runtime/system/string","ember-runtime/system/core_object","ember-runtime/mixins/mutable_enumerable","ember-runtime/mixins/enumerable","ember-runtime/mixins/copyable","ember-runtime/mixins/freezable","ember-metal/error","ember-metal/property_events","ember-metal/mixin","ember-metal/computed","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-runtime
-    */
-    var Ember = __dependency1__["default"];
-    // Ember.isNone, Ember.A
+    nameClasses: function() {
+      processNamespace([this.toString()], this, {});
+    },
 
-    var get = __dependency2__.get;
-    var set = __dependency3__.set;
-    var guidFor = __dependency4__.guidFor;
-    var isNone = __dependency5__["default"];
-    var fmt = __dependency6__.fmt;
-    var CoreObject = __dependency7__["default"];
-    var MutableEnumerable = __dependency8__["default"];
-    var Enumerable = __dependency9__["default"];
-    var Copyable = __dependency10__["default"];
-    var Freezable = __dependency11__.Freezable;
-    var FROZEN_ERROR = __dependency11__.FROZEN_ERROR;
-    var EmberError = __dependency12__["default"];
-    var propertyWillChange = __dependency13__.propertyWillChange;
-    var propertyDidChange = __dependency13__.propertyDidChange;
-    var aliasMethod = __dependency14__.aliasMethod;
-    var computed = __dependency15__.computed;
+    destroy: function() {
+      var namespaces = Namespace.NAMESPACES;
+      var toString = this.toString();
 
-    /**
-      An unordered collection of objects.
+      if (toString) {
+        Ember['default'].lookup[toString] = undefined;
+        delete Namespace.NAMESPACES_BY_ID[toString];
+      }
+      namespaces.splice(array.indexOf.call(namespaces, this), 1);
+      this._super.apply(this, arguments);
+    }
+  });
 
-      A Set works a bit like an array except that its items are not ordered. You
-      can create a set to efficiently test for membership for an object. You can
-      also iterate through a set just like an array, even accessing objects by
-      index, however there is no guarantee as to their order.
+  Namespace.reopenClass({
+    NAMESPACES: [Ember['default']],
+    NAMESPACES_BY_ID: {},
+    PROCESSED: false,
+    processAll: processAllNamespaces,
+    byName: function(name) {
+      if (!Ember['default'].BOOTED) {
+        processAllNamespaces();
+      }
 
-      All Sets are observable via the Enumerable Observer API - which works
-      on any enumerable object including both Sets and Arrays.
+      return NAMESPACES_BY_ID[name];
+    }
+  });
 
-      ## Creating a Set
+  var NAMESPACES_BY_ID = Namespace.NAMESPACES_BY_ID;
 
-      You can create a set like you would most objects using
-      `new Ember.Set()`. Most new sets you create will be empty, but you can
-      also initialize the set with some content by passing an array or other
-      enumerable of objects to the constructor.
+  var hasOwnProp = ({}).hasOwnProperty;
 
-      Finally, you can pass in an existing set and the set will be copied. You
-      can also create a copy of a set by calling `Ember.Set#copy()`.
+  function processNamespace(paths, root, seen) {
+    var idx = paths.length;
 
-      ```javascript
-      // creates a new empty set
-      var foundNames = new Ember.Set();
+    NAMESPACES_BY_ID[paths.join('.')] = root;
 
-      // creates a set with four names in it.
-      var names = new Ember.Set(["Charles", "Tom", "Juan", "Alex"]); // :P
+    // Loop over all of the keys in the namespace, looking for classes
+    for (var key in root) {
+      if (!hasOwnProp.call(root, key)) { continue; }
+      var obj = root[key];
 
-      // creates a copy of the names set.
-      var namesCopy = new Ember.Set(names);
+      // If we are processing the `Ember` namespace, for example, the
+      // `paths` will start with `["Ember"]`. Every iteration through
+      // the loop will update the **second** element of this list with
+      // the key, so processing `Ember.View` will make the Array
+      // `['Ember', 'View']`.
+      paths[idx] = key;
 
-      // same as above.
-      var anotherNamesCopy = names.copy();
-      ```
+      // If we have found an unprocessed class
+      if (obj && obj.toString === classToString) {
+        // Replace the class' `toString` with the dot-separated path
+        // and set its `NAME_KEY`
+        obj.toString = makeToString(paths.join('.'));
+        obj[NAME_KEY] = paths.join('.');
 
-      ## Adding/Removing Objects
+      // Support nested namespaces
+      } else if (obj && obj.isNamespace) {
+        // Skip aliased namespaces
+        if (seen[utils.guidFor(obj)]) { continue; }
+        seen[utils.guidFor(obj)] = true;
 
-      You generally add or remove objects from a set using `add()` or
-      `remove()`. You can add any type of object including primitives such as
-      numbers, strings, and booleans.
+        // Process the child namespace
+        processNamespace(paths, obj, seen);
+      }
+    }
 
-      Unlike arrays, objects can only exist one time in a set. If you call `add()`
-      on a set with the same object multiple times, the object will only be added
-      once. Likewise, calling `remove()` with the same object multiple times will
-      remove the object the first time and have no effect on future calls until
-      you add the object to the set again.
+    paths.length = idx; // cut out last item
+  }
 
-      NOTE: You cannot add/remove `null` or `undefined` to a set. Any attempt to do
-      so will be ignored.
+  var STARTS_WITH_UPPERCASE = /^[A-Z]/;
 
-      In addition to add/remove you can also call `push()`/`pop()`. Push behaves
-      just like `add()` but `pop()`, unlike `remove()` will pick an arbitrary
-      object, remove it and return it. This is a good way to use a set as a job
-      queue when you don't care which order the jobs are executed in.
+  function tryIsNamespace(lookup, prop) {
+    try {
+      var obj = lookup[prop];
+      return obj && obj.isNamespace && obj;
+    } catch (e) {
+      // continue
+    }
+  }
 
-      ## Testing for an Object
+  function findNamespaces() {
+    var lookup = Ember['default'].lookup;
+    var obj;
 
-      To test for an object's presence in a set you simply call
-      `Ember.Set#contains()`.
+    if (Namespace.PROCESSED) { return; }
 
-      ## Observing changes
+    for (var prop in lookup) {
+      // Only process entities that start with uppercase A-Z
+      if (!STARTS_WITH_UPPERCASE.test(prop)) { continue; }
 
-      When using `Ember.Set`, you can observe the `"[]"` property to be
-      alerted whenever the content changes. You can also add an enumerable
-      observer to the set to be notified of specific objects that are added and
-      removed from the set. See [Ember.Enumerable](/api/classes/Ember.Enumerable.html)
-      for more information on enumerables.
+      // Unfortunately, some versions of IE don't support window.hasOwnProperty
+      if (lookup.hasOwnProperty && !lookup.hasOwnProperty(prop)) { continue; }
 
-      This is often unhelpful. If you are filtering sets of objects, for instance,
-      it is very inefficient to re-filter all of the items each time the set
-      changes. It would be better if you could just adjust the filtered set based
-      on what was changed on the original set. The same issue applies to merging
-      sets, as well.
+      // At times we are not allowed to access certain properties for security reasons.
+      // There are also times where even if we can access them, we are not allowed to access their properties.
+      obj = tryIsNamespace(lookup, prop);
+      if (obj) {
+        obj[NAME_KEY] = prop;
+      }
+    }
+  }
 
-      ## Other Methods
+  var NAME_KEY = Ember['default'].NAME_KEY = utils.GUID_KEY + '_name';
 
-      `Ember.Set` primary implements other mixin APIs. For a complete reference
-      on the methods you will use with `Ember.Set`, please consult these mixins.
-      The most useful ones will be `Ember.Enumerable` and
-      `Ember.MutableEnumerable` which implement most of the common iterator
-      methods you are used to on Array.
+  function superClassString(mixin) {
+    var superclass = mixin.superclass;
+    if (superclass) {
+      if (superclass[NAME_KEY]) {
+        return superclass[NAME_KEY];
+      } else {
+        return superClassString(superclass);
+      }
+    } else {
+      return;
+    }
+  }
 
-      Note that you can also use the `Ember.Copyable` and `Ember.Freezable`
-      APIs on `Ember.Set` as well. Once a set is frozen it can no longer be
-      modified. The benefit of this is that when you call `frozenCopy()` on it,
-      Ember will avoid making copies of the set. This allows you to write
-      code that can know with certainty when the underlying set data will or
-      will not be modified.
+  function classToString() {
+    if (!Ember['default'].BOOTED && !this[NAME_KEY]) {
+      processAllNamespaces();
+    }
 
-      @class Set
-      @namespace Ember
-      @extends Ember.CoreObject
-      @uses Ember.MutableEnumerable
-      @uses Ember.Copyable
-      @uses Ember.Freezable
-      @since Ember 0.9
-      @deprecated
-    */
-    __exports__["default"] = CoreObject.extend(MutableEnumerable, Copyable, Freezable, {
+    var ret;
 
-      // ..........................................................
-      // IMPLEMENT ENUMERABLE APIS
-      //
+    if (this[NAME_KEY]) {
+      ret = this[NAME_KEY];
+    } else if (this._toString) {
+      ret = this._toString;
+    } else {
+      var str = superClassString(this);
+      if (str) {
+        ret = "(subclass of " + str + ")";
+      } else {
+        ret = "(unknown mixin)";
+      }
+      this.toString = makeToString(ret);
+    }
 
-      /**
-        This property will change as the number of objects in the set changes.
+    return ret;
+  }
 
-        @property length
-        @type number
-        @default 0
-      */
-      length: 0,
+  function processAllNamespaces() {
+    var unprocessedNamespaces = !Namespace.PROCESSED;
+    var unprocessedMixins = Ember['default'].anyUnprocessedMixins;
 
-      /**
-        Clears the set. This is useful if you want to reuse an existing set
-        without having to recreate it.
+    if (unprocessedNamespaces) {
+      findNamespaces();
+      Namespace.PROCESSED = true;
+    }
 
-        ```javascript
-        var colors = new Ember.Set(["red", "green", "blue"]);
-        colors.length;  // 3
-        colors.clear();
-        colors.length;  // 0
-        ```
+    if (unprocessedNamespaces || unprocessedMixins) {
+      var namespaces = Namespace.NAMESPACES;
+      var namespace;
 
-        @method clear
-        @return {Ember.Set} An empty Set
-      */
-      clear: function() {
-        if (this.isFrozen) { throw new EmberError(FROZEN_ERROR); }
+      for (var i=0, l=namespaces.length; i<l; i++) {
+        namespace = namespaces[i];
+        processNamespace([namespace.toString()], namespace, {});
+      }
 
-        var len = get(this, 'length');
-        if (len === 0) { return this; }
+      Ember['default'].anyUnprocessedMixins = false;
+    }
+  }
 
-        var guid;
+  function makeToString(ret) {
+    return function() { return ret; };
+  }
 
-        this.enumerableContentWillChange(len, 0);
-        propertyWillChange(this, 'firstObject');
-        propertyWillChange(this, 'lastObject');
+  mixin.Mixin.prototype.toString = classToString; // ES6TODO: altering imported objects. SBB.
 
-        for (var i=0; i < len; i++) {
-          guid = guidFor(this[i]);
-          delete this[guid];
-          delete this[i];
-        }
+  exports['default'] = Namespace;
 
-        set(this, 'length', 0);
+});
+enifed('ember-runtime/system/native_array', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/enumerable_utils', 'ember-metal/mixin', 'ember-metal/array', 'ember-runtime/mixins/array', 'ember-runtime/mixins/mutable_array', 'ember-runtime/mixins/observable', 'ember-runtime/mixins/copyable', 'ember-runtime/mixins/freezable', 'ember-runtime/copy'], function (exports, Ember, property_get, enumerable_utils, mixin, array, EmberArray, MutableArray, Observable, Copyable, freezable, copy) {
 
-        propertyDidChange(this, 'firstObject');
-        propertyDidChange(this, 'lastObject');
-        this.enumerableContentDidChange(len, 0);
+  'use strict';
 
-        return this;
-      },
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-      /**
-        Returns true if the passed object is also an enumerable that contains the
-        same objects as the receiver.
+  var NativeArray = mixin.Mixin.create(MutableArray['default'], Observable['default'], Copyable['default'], {
 
-        ```javascript
-        var colors = ["red", "green", "blue"],
-            same_colors = new Ember.Set(colors);
+    // because length is a built-in property we need to know to just get the
+    // original property.
+    get: function(key) {
+      if (key==='length') {
+        return this.length;
+      } else if ('number' === typeof key) {
+        return this[key];
+      } else {
+        return this._super(key);
+      }
+    },
 
-        same_colors.isEqual(colors);               // true
-        same_colors.isEqual(["purple", "brown"]);  // false
-        ```
+    objectAt: function(idx) {
+      return this[idx];
+    },
 
-        @method isEqual
-        @param {Ember.Set} obj the other object.
-        @return {Boolean}
-      */
-      isEqual: function(obj) {
-        // fail fast
-        if (!Enumerable.detect(obj)) return false;
+    // primitive for array support.
+    replace: function(idx, amt, objects) {
 
-        var loc = get(this, 'length');
-        if (get(obj, 'length') !== loc) return false;
+      if (this.isFrozen) {
+        throw freezable.FROZEN_ERROR;
+      }
 
-        while(--loc >= 0) {
-          if (!obj.contains(this[loc])) return false;
-        }
+      // if we replaced exactly the same number of items, then pass only the
+      // replaced range. Otherwise, pass the full remaining array length
+      // since everything has shifted
+      var len = objects ? property_get.get(objects, 'length') : 0;
+      this.arrayContentWillChange(idx, amt, len);
 
-        return true;
-      },
+      if (len === 0) {
+        this.splice(idx, amt);
+      } else {
+        enumerable_utils._replace(this, idx, amt, objects);
+      }
 
-      /**
-        Adds an object to the set. Only non-`null` objects can be added to a set
-        and those can only be added once. If the object is already in the set or
-        the passed value is null this method will have no effect.
+      this.arrayContentDidChange(idx, amt, len);
+      return this;
+    },
 
-        This is an alias for `Ember.MutableEnumerable.addObject()`.
+    // If you ask for an unknown property, then try to collect the value
+    // from member items.
+    unknownProperty: function(key, value) {
+      var ret;// = this.reducedProperty(key, value);
+      if (value !== undefined && ret === undefined) {
+        ret = this[key] = value;
+      }
+      return ret;
+    },
 
-        ```javascript
-        var colors = new Ember.Set();
-        colors.add("blue");     // ["blue"]
-        colors.add("blue");     // ["blue"]
-        colors.add("red");      // ["blue", "red"]
-        colors.add(null);       // ["blue", "red"]
-        colors.add(undefined);  // ["blue", "red"]
-        ```
+    indexOf: array.indexOf,
 
-        @method add
-        @param {Object} obj The object to add.
-        @return {Ember.Set} The set itself.
-      */
-      add: aliasMethod('addObject'),
+    lastIndexOf: array.lastIndexOf,
 
-      /**
-        Removes the object from the set if it is found. If you pass a `null` value
-        or an object that is already not in the set, this method will have no
-        effect. This is an alias for `Ember.MutableEnumerable.removeObject()`.
+    copy: function(deep) {
+      if (deep) {
+        return this.map(function(item) { return copy['default'](item, true); });
+      }
 
-        ```javascript
-        var colors = new Ember.Set(["red", "green", "blue"]);
-        colors.remove("red");     // ["blue", "green"]
-        colors.remove("purple");  // ["blue", "green"]
-        colors.remove(null);      // ["blue", "green"]
-        ```
+      return this.slice();
+    }
+  });
 
-        @method remove
-        @param {Object} obj The object to remove
-        @return {Ember.Set} The set itself.
-      */
-      remove: aliasMethod('removeObject'),
+  // Remove any methods implemented natively so we don't override them
+  var ignore = ['length'];
+  enumerable_utils.forEach(NativeArray.keys(), function(methodName) {
+    if (Array.prototype[methodName]) {
+      ignore.push(methodName);
+    }
+  });
 
-      /**
-        Removes the last element from the set and returns it, or `null` if it's empty.
+  NativeArray = NativeArray.without.apply(NativeArray, ignore);
 
-        ```javascript
-        var colors = new Ember.Set(["green", "blue"]);
-        colors.pop();  // "blue"
-        colors.pop();  // "green"
-        colors.pop();  // null
-        ```
+  /**
+    Creates an `Ember.NativeArray` from an Array like object.
+    Does not modify the original object. Ember.A is not needed if
+    `Ember.EXTEND_PROTOTYPES` is `true` (the default value). However,
+    it is recommended that you use Ember.A when creating addons for
+    ember or when you can not guarantee that `Ember.EXTEND_PROTOTYPES`
+    will be `true`.
 
-        @method pop
-        @return {Object} The removed object from the set or null.
-      */
-      pop: function() {
-        if (get(this, 'isFrozen')) throw new EmberError(FROZEN_ERROR);
-        var obj = this.length > 0 ? this[this.length-1] : null;
-        this.remove(obj);
-        return obj;
-      },
+    Example
 
-      /**
-        Inserts the given object on to the end of the set. It returns
-        the set itself.
+    ```js
+    var Pagination = Ember.CollectionView.extend({
+      tagName: 'ul',
+      classNames: ['pagination'],
 
-        This is an alias for `Ember.MutableEnumerable.addObject()`.
+      init: function() {
+        this._super.apply(this, arguments);
+        if (!this.get('content')) {
+          this.set('content', Ember.A());
+        }
+      }
+    });
+    ```
 
-        ```javascript
-        var colors = new Ember.Set();
-        colors.push("red");   // ["red"]
-        colors.push("green"); // ["red", "green"]
-        colors.push("blue");  // ["red", "green", "blue"]
-        ```
+    @method A
+    @for Ember
+    @return {Ember.NativeArray}
+  */
+  var A = function(arr) {
+    if (arr === undefined) { arr = []; }
+    return EmberArray['default'].detect(arr) ? arr : NativeArray.apply(arr);
+  };
 
-        @method push
-        @return {Ember.Set} The set itself.
-      */
-      push: aliasMethod('addObject'),
+  /**
+    Activates the mixin on the Array.prototype if not already applied. Calling
+    this method more than once is safe. This will be called when ember is loaded
+    unless you have `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Array`
+    set to `false`.
 
-      /**
-        Removes the last element from the set and returns it, or `null` if it's empty.
+    Example
 
-        This is an alias for `Ember.Set.pop()`.
+    ```js
+    if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Array) {
+      Ember.NativeArray.activate();
+    }
+    ```
 
-        ```javascript
-        var colors = new Ember.Set(["green", "blue"]);
-        colors.shift();  // "blue"
-        colors.shift();  // "green"
-        colors.shift();  // null
-        ```
+    @method activate
+    @for Ember.NativeArray
+    @static
+    @return {void}
+  */
+  NativeArray.activate = function() {
+    NativeArray.apply(Array.prototype);
 
-        @method shift
-        @return {Object} The removed object from the set or null.
-      */
-      shift: aliasMethod('pop'),
+    A = function(arr) { return arr || []; };
+  };
 
-      /**
-        Inserts the given object on to the end of the set. It returns
-        the set itself.
+  if (Ember['default'].EXTEND_PROTOTYPES === true || Ember['default'].EXTEND_PROTOTYPES.Array) {
+    NativeArray.activate();
+  }
 
-        This is an alias of `Ember.Set.push()`
+  Ember['default'].A = A; // ES6TODO: Setting A onto the object returned by ember-metal/core to avoid circles
+  exports['default'] = NativeArray;
 
-        ```javascript
-        var colors = new Ember.Set();
-        colors.unshift("red");    // ["red"]
-        colors.unshift("green");  // ["red", "green"]
-        colors.unshift("blue");   // ["red", "green", "blue"]
-        ```
+  exports.A = A;
+  exports.NativeArray = NativeArray;
 
-        @method unshift
-        @return {Ember.Set} The set itself.
-      */
-      unshift: aliasMethod('push'),
+});
+enifed('ember-runtime/system/object', ['exports', 'ember-runtime/system/core_object', 'ember-runtime/mixins/observable'], function (exports, CoreObject, Observable) {
 
-      /**
-        Adds each object in the passed enumerable to the set.
+  'use strict';
 
-        This is an alias of `Ember.MutableEnumerable.addObjects()`
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
 
-        ```javascript
-        var colors = new Ember.Set();
-        colors.addEach(["red", "green", "blue"]);  // ["red", "green", "blue"]
-        ```
+  var EmberObject = CoreObject['default'].extend(Observable['default']);
+  EmberObject.toString = function() {
+    return "Ember.Object";
+  };
 
-        @method addEach
-        @param {Ember.Enumerable} objects the objects to add.
-        @return {Ember.Set} The set itself.
-      */
-      addEach: aliasMethod('addObjects'),
+  exports['default'] = EmberObject;
 
-      /**
-        Removes each object in the passed enumerable to the set.
+});
+enifed('ember-runtime/system/object_proxy', ['exports', 'ember-runtime/system/object', 'ember-runtime/mixins/-proxy'], function (exports, EmberObject, _ProxyMixin) {
 
-        This is an alias of `Ember.MutableEnumerable.removeObjects()`
+  'use strict';
 
-        ```javascript
-        var colors = new Ember.Set(["red", "green", "blue"]);
-        colors.removeEach(["red", "blue"]);  //  ["green"]
-        ```
+  exports['default'] = EmberObject['default'].extend(_ProxyMixin['default']);
 
-        @method removeEach
-        @param {Ember.Enumerable} objects the objects to remove.
-        @return {Ember.Set} The set itself.
-      */
-      removeEach: aliasMethod('removeObjects'),
+});
+enifed('ember-runtime/system/service', ['exports', 'ember-runtime/system/object', 'ember-runtime/inject'], function (exports, Object, inject) {
 
-      // ..........................................................
-      // PRIVATE ENUMERABLE SUPPORT
-      //
+  'use strict';
 
-      init: function(items) {
-        Ember.deprecate('Ember.Set is deprecated and will be removed in a future release.');
-        this._super();
-        if (items) this.addObjects(items);
-      },
+  inject.createInjectionHelper('service');
 
-      // implement Ember.Enumerable
-      nextObject: function(idx) {
-        return this[idx];
-      },
+  /**
+    @class Service
+    @namespace Ember
+    @extends Ember.Object
+    @since 1.10.0
+  */
+  exports['default'] = Object['default'].extend();
 
-      // more optimized version
-      firstObject: computed(function() {
-        return this.length > 0 ? this[0] : undefined;
-      }),
+});
+enifed('ember-runtime/system/set', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/utils', 'ember-metal/is_none', 'ember-runtime/system/string', 'ember-runtime/system/core_object', 'ember-runtime/mixins/mutable_enumerable', 'ember-runtime/mixins/enumerable', 'ember-runtime/mixins/copyable', 'ember-runtime/mixins/freezable', 'ember-metal/error', 'ember-metal/property_events', 'ember-metal/mixin', 'ember-metal/computed'], function (exports, Ember, property_get, property_set, utils, isNone, string, CoreObject, MutableEnumerable, Enumerable, Copyable, freezable, EmberError, property_events, mixin, computed) {
 
-      // more optimized version
-      lastObject: computed(function() {
-        return this.length > 0 ? this[this.length-1] : undefined;
-      }),
+  'use strict';
 
-      // implements Ember.MutableEnumerable
-      addObject: function(obj) {
-        if (get(this, 'isFrozen')) throw new EmberError(FROZEN_ERROR);
-        if (isNone(obj)) return this; // nothing to do
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
+  exports['default'] = CoreObject['default'].extend(MutableEnumerable['default'], Copyable['default'], freezable.Freezable, {
 
-        var guid = guidFor(obj);
-        var idx  = this[guid];
-        var len  = get(this, 'length');
-        var added;
+    // ..........................................................
+    // IMPLEMENT ENUMERABLE APIS
+    //
 
-        if (idx>=0 && idx<len && (this[idx] === obj)) return this; // added
+    /**
+      This property will change as the number of objects in the set changes.
 
-        added = [obj];
+      @property length
+      @type number
+      @default 0
+    */
+    length: 0,
 
-        this.enumerableContentWillChange(null, added);
-        propertyWillChange(this, 'lastObject');
+    /**
+      Clears the set. This is useful if you want to reuse an existing set
+      without having to recreate it.
 
-        len = get(this, 'length');
-        this[guid] = len;
-        this[len] = obj;
-        set(this, 'length', len+1);
+      ```javascript
+      var colors = new Ember.Set(["red", "green", "blue"]);
+      colors.length;  // 3
+      colors.clear();
+      colors.length;  // 0
+      ```
 
-        propertyDidChange(this, 'lastObject');
-        this.enumerableContentDidChange(null, added);
+      @method clear
+      @return {Ember.Set} An empty Set
+    */
+    clear: function() {
+      if (this.isFrozen) { throw new EmberError['default'](freezable.FROZEN_ERROR); }
 
-        return this;
-      },
+      var len = property_get.get(this, 'length');
+      if (len === 0) { return this; }
 
-      // implements Ember.MutableEnumerable
-      removeObject: function(obj) {
-        if (get(this, 'isFrozen')) throw new EmberError(FROZEN_ERROR);
-        if (isNone(obj)) return this; // nothing to do
+      var guid;
 
-        var guid = guidFor(obj);
-        var idx  = this[guid];
-        var len = get(this, 'length');
-        var isFirst = idx === 0;
-        var isLast = idx === len-1;
-        var last, removed;
+      this.enumerableContentWillChange(len, 0);
+      property_events.propertyWillChange(this, 'firstObject');
+      property_events.propertyWillChange(this, 'lastObject');
 
+      for (var i=0; i < len; i++) {
+        guid = utils.guidFor(this[i]);
+        delete this[guid];
+        delete this[i];
+      }
 
-        if (idx>=0 && idx<len && (this[idx] === obj)) {
-          removed = [obj];
+      property_set.set(this, 'length', 0);
 
-          this.enumerableContentWillChange(removed, null);
-          if (isFirst) { propertyWillChange(this, 'firstObject'); }
-          if (isLast)  { propertyWillChange(this, 'lastObject'); }
+      property_events.propertyDidChange(this, 'firstObject');
+      property_events.propertyDidChange(this, 'lastObject');
+      this.enumerableContentDidChange(len, 0);
 
-          // swap items - basically move the item to the end so it can be removed
-          if (idx < len-1) {
-            last = this[len-1];
-            this[idx] = last;
-            this[guidFor(last)] = idx;
-          }
+      return this;
+    },
 
-          delete this[guid];
-          delete this[len-1];
-          set(this, 'length', len-1);
+    /**
+      Returns true if the passed object is also an enumerable that contains the
+      same objects as the receiver.
 
-          if (isFirst) { propertyDidChange(this, 'firstObject'); }
-          if (isLast)  { propertyDidChange(this, 'lastObject'); }
-          this.enumerableContentDidChange(removed, null);
-        }
+      ```javascript
+      var colors = ["red", "green", "blue"],
+          same_colors = new Ember.Set(colors);
 
-        return this;
-      },
+      same_colors.isEqual(colors);               // true
+      same_colors.isEqual(["purple", "brown"]);  // false
+      ```
 
-      // optimized version
-      contains: function(obj) {
-        return this[guidFor(obj)]>=0;
-      },
+      @method isEqual
+      @param {Ember.Set} obj the other object.
+      @return {Boolean}
+    */
+    isEqual: function(obj) {
+      // fail fast
+      if (!Enumerable['default'].detect(obj)) {
+        return false;
+      }
 
-      copy: function() {
-        var C = this.constructor, ret = new C(), loc = get(this, 'length');
-        set(ret, 'length', loc);
-        while(--loc>=0) {
-          ret[loc] = this[loc];
-          ret[guidFor(this[loc])] = loc;
-        }
-        return ret;
-      },
+      var loc = property_get.get(this, 'length');
+      if (property_get.get(obj, 'length') !== loc) {
+        return false;
+      }
 
-      toString: function() {
-        var len = this.length, idx, array = [];
-        for(idx = 0; idx < len; idx++) {
-          array[idx] = this[idx];
+      while (--loc >= 0) {
+        if (!obj.contains(this[loc])) {
+          return false;
         }
-        return fmt("Ember.Set<%@>", [array.join(',')]);
       }
-    });
-  });
-enifed("ember-runtime/system/string",
-  ["ember-metal/core","ember-metal/utils","ember-metal/cache","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
+
+      return true;
+    },
+
     /**
-    @module ember
-    @submodule ember-runtime
+      Adds an object to the set. Only non-`null` objects can be added to a set
+      and those can only be added once. If the object is already in the set or
+      the passed value is null this method will have no effect.
+
+      This is an alias for `Ember.MutableEnumerable.addObject()`.
+
+      ```javascript
+      var colors = new Ember.Set();
+      colors.add("blue");     // ["blue"]
+      colors.add("blue");     // ["blue"]
+      colors.add("red");      // ["blue", "red"]
+      colors.add(null);       // ["blue", "red"]
+      colors.add(undefined);  // ["blue", "red"]
+      ```
+
+      @method add
+      @param {Object} obj The object to add.
+      @return {Ember.Set} The set itself.
     */
-    var Ember = __dependency1__["default"];
-    // Ember.STRINGS, Ember.FEATURES
-    var isArray = __dependency2__.isArray;
-    var emberInspect = __dependency2__.inspect;
+    add: mixin.aliasMethod('addObject'),
 
-    var Cache = __dependency3__["default"];
+    /**
+      Removes the object from the set if it is found. If you pass a `null` value
+      or an object that is already not in the set, this method will have no
+      effect. This is an alias for `Ember.MutableEnumerable.removeObject()`.
 
-    var STRING_DASHERIZE_REGEXP = (/[ _]/g);
+      ```javascript
+      var colors = new Ember.Set(["red", "green", "blue"]);
+      colors.remove("red");     // ["blue", "green"]
+      colors.remove("purple");  // ["blue", "green"]
+      colors.remove(null);      // ["blue", "green"]
+      ```
 
-    var STRING_DASHERIZE_CACHE = new Cache(1000, function(key) {
-      return decamelize(key).replace(STRING_DASHERIZE_REGEXP, '-');
-    });
+      @method remove
+      @param {Object} obj The object to remove
+      @return {Ember.Set} The set itself.
+    */
+    remove: mixin.aliasMethod('removeObject'),
 
-    var CAMELIZE_CACHE = new Cache(1000, function(key) {
-      return key.replace(STRING_CAMELIZE_REGEXP, function(match, separator, chr) {
-        return chr ? chr.toUpperCase() : '';
-      }).replace(/^([A-Z])/, function(match, separator, chr) {
-        return match.toLowerCase();
-      });
-    });
+    /**
+      Removes the last element from the set and returns it, or `null` if it's empty.
 
-    var CLASSIFY_CACHE = new Cache(1000, function(str) {
-      var parts = str.split(".");
-      var out = [];
+      ```javascript
+      var colors = new Ember.Set(["green", "blue"]);
+      colors.pop();  // "blue"
+      colors.pop();  // "green"
+      colors.pop();  // null
+      ```
 
-      for (var i=0, l=parts.length; i<l; i++) {
-        var camelized = camelize(parts[i]);
-        out.push(camelized.charAt(0).toUpperCase() + camelized.substr(1));
+      @method pop
+      @return {Object} The removed object from the set or null.
+    */
+    pop: function() {
+      if (property_get.get(this, 'isFrozen')) {
+        throw new EmberError['default'](freezable.FROZEN_ERROR);
       }
 
-      return out.join(".");
-    });
-
-    var UNDERSCORE_CACHE = new Cache(1000, function(str) {
-      return str.replace(STRING_UNDERSCORE_REGEXP_1, '$1_$2').
-        replace(STRING_UNDERSCORE_REGEXP_2, '_').toLowerCase();
-    });
+      var obj = this.length > 0 ? this[this.length-1] : null;
+      this.remove(obj);
+      return obj;
+    },
 
-    var CAPITALIZE_CACHE = new Cache(1000, function(str) {
-      return str.charAt(0).toUpperCase() + str.substr(1);
-    });
+    /**
+      Inserts the given object on to the end of the set. It returns
+      the set itself.
 
-    var DECAMELIZE_CACHE = new Cache(1000, function(str) {
-      return str.replace(STRING_DECAMELIZE_REGEXP, '$1_$2').toLowerCase();
-    });
+      This is an alias for `Ember.MutableEnumerable.addObject()`.
 
-    var STRING_DECAMELIZE_REGEXP = (/([a-z\d])([A-Z])/g);
-    var STRING_CAMELIZE_REGEXP = (/(\-|_|\.|\s)+(.)?/g);
-    var STRING_UNDERSCORE_REGEXP_1 = (/([a-z\d])([A-Z]+)/g);
-    var STRING_UNDERSCORE_REGEXP_2 = (/\-|\s+/g);
+      ```javascript
+      var colors = new Ember.Set();
+      colors.push("red");   // ["red"]
+      colors.push("green"); // ["red", "green"]
+      colors.push("blue");  // ["red", "green", "blue"]
+      ```
 
-    function fmt(str, formats) {
-      var cachedFormats = formats;
+      @method push
+      @return {Ember.Set} The set itself.
+    */
+    push: mixin.aliasMethod('addObject'),
 
-      if (!isArray(cachedFormats) || arguments.length > 2) {
-        cachedFormats = new Array(arguments.length - 1);
+    /**
+      Removes the last element from the set and returns it, or `null` if it's empty.
 
-        for (var i = 1, l = arguments.length; i < l; i++) {
-          cachedFormats[i - 1] = arguments[i];
-        }
-      }
+      This is an alias for `Ember.Set.pop()`.
 
-      // first, replace any ORDERED replacements.
-      var idx  = 0; // the current index for non-numerical replacements
-      return str.replace(/%@([0-9]+)?/g, function(s, argIndex) {
-        argIndex = (argIndex) ? parseInt(argIndex, 10) - 1 : idx++;
-        s = cachedFormats[argIndex];
-        return (s === null) ? '(null)' : (s === undefined) ? '' : emberInspect(s);
-      });
-    }
+      ```javascript
+      var colors = new Ember.Set(["green", "blue"]);
+      colors.shift();  // "blue"
+      colors.shift();  // "green"
+      colors.shift();  // null
+      ```
 
-    function loc(str, formats) {
-      if (!isArray(formats) || arguments.length > 2) {
-        formats = Array.prototype.slice.call(arguments, 1);
-      }
+      @method shift
+      @return {Object} The removed object from the set or null.
+    */
+    shift: mixin.aliasMethod('pop'),
 
-      str = Ember.STRINGS[str] || str;
-      return fmt(str, formats);
-    }
+    /**
+      Inserts the given object on to the end of the set. It returns
+      the set itself.
 
-    function w(str) {
-      return str.split(/\s+/);
-    }
+      This is an alias of `Ember.Set.push()`
 
-    function decamelize(str) {
-      return DECAMELIZE_CACHE.get(str);
-    }
+      ```javascript
+      var colors = new Ember.Set();
+      colors.unshift("red");    // ["red"]
+      colors.unshift("green");  // ["red", "green"]
+      colors.unshift("blue");   // ["red", "green", "blue"]
+      ```
 
-    function dasherize(str) {
-      return STRING_DASHERIZE_CACHE.get(str);
-    }
+      @method unshift
+      @return {Ember.Set} The set itself.
+    */
+    unshift: mixin.aliasMethod('push'),
 
-    function camelize(str) {
-      return CAMELIZE_CACHE.get(str);
-    }
+    /**
+      Adds each object in the passed enumerable to the set.
 
-    function classify(str) {
-      return CLASSIFY_CACHE.get(str);
-    }
+      This is an alias of `Ember.MutableEnumerable.addObjects()`
 
-    function underscore(str) {
-      return UNDERSCORE_CACHE.get(str);
-    }
+      ```javascript
+      var colors = new Ember.Set();
+      colors.addEach(["red", "green", "blue"]);  // ["red", "green", "blue"]
+      ```
 
-    function capitalize(str) {
-      return CAPITALIZE_CACHE.get(str);
-    }
+      @method addEach
+      @param {Ember.Enumerable} objects the objects to add.
+      @return {Ember.Set} The set itself.
+    */
+    addEach: mixin.aliasMethod('addObjects'),
 
     /**
-      Defines the hash of localized strings for the current language. Used by
-      the `Ember.String.loc()` helper. To localize, add string values to this
-      hash.
+      Removes each object in the passed enumerable to the set.
 
-      @property STRINGS
-      @for Ember
-      @type Hash
-    */
-    Ember.STRINGS = {};
+      This is an alias of `Ember.MutableEnumerable.removeObjects()`
 
-    /**
-      Defines string helper methods including string formatting and localization.
-      Unless `Ember.EXTEND_PROTOTYPES.String` is `false` these methods will also be
-      added to the `String.prototype` as well.
+      ```javascript
+      var colors = new Ember.Set(["red", "green", "blue"]);
+      colors.removeEach(["red", "blue"]);  //  ["green"]
+      ```
 
-      @class String
-      @namespace Ember
-      @static
+      @method removeEach
+      @param {Ember.Enumerable} objects the objects to remove.
+      @return {Ember.Set} The set itself.
     */
-    __exports__["default"] = {
-      /**
-        Apply formatting options to the string. This will look for occurrences
-        of "%@" in your string and substitute them with the arguments you pass into
-        this method. If you want to control the specific order of replacement,
-        you can add a number after the key as well to indicate which argument
-        you want to insert.
+    removeEach: mixin.aliasMethod('removeObjects'),
 
-        Ordered insertions are most useful when building loc strings where values
-        you need to insert may appear in different orders.
-
-        ```javascript
-        "Hello %@ %@".fmt('John', 'Doe');     // "Hello John Doe"
-        "Hello %@2, %@1".fmt('John', 'Doe');  // "Hello Doe, John"
-        ```
+    // ..........................................................
+    // PRIVATE ENUMERABLE SUPPORT
+    //
 
-        @method fmt
-        @param {String} str The string to format
-        @param {Array} formats An array of parameters to interpolate into string.
-        @return {String} formatted string
-      */
-      fmt: fmt,
+    init: function(items) {
+      Ember['default'].deprecate('Ember.Set is deprecated and will be removed in a future release.');
+      this._super.apply(this, arguments);
 
-      /**
-        Formats the passed string, but first looks up the string in the localized
-        strings hash. This is a convenient way to localize text. See
-        `Ember.String.fmt()` for more information on formatting.
+      if (items) {
+        this.addObjects(items);
+      }
+    },
 
-        Note that it is traditional but not required to prefix localized string
-        keys with an underscore or other character so you can easily identify
-        localized strings.
+    // implement Ember.Enumerable
+    nextObject: function(idx) {
+      return this[idx];
+    },
 
-        ```javascript
-        Ember.STRINGS = {
-          '_Hello World': 'Bonjour le monde',
-          '_Hello %@ %@': 'Bonjour %@ %@'
-        };
+    // more optimized version
+    firstObject: computed.computed(function() {
+      return this.length > 0 ? this[0] : undefined;
+    }),
 
-        Ember.String.loc("_Hello World");  // 'Bonjour le monde';
-        Ember.String.loc("_Hello %@ %@", ["John", "Smith"]);  // "Bonjour John Smith";
-        ```
+    // more optimized version
+    lastObject: computed.computed(function() {
+      return this.length > 0 ? this[this.length-1] : undefined;
+    }),
 
-        @method loc
-        @param {String} str The string to format
-        @param {Array} formats Optional array of parameters to interpolate into string.
-        @return {String} formatted string
-      */
-      loc: loc,
+    // implements Ember.MutableEnumerable
+    addObject: function(obj) {
+      if (property_get.get(this, 'isFrozen')) {
+        throw new EmberError['default'](freezable.FROZEN_ERROR);
+      }
 
-      /**
-        Splits a string into separate units separated by spaces, eliminating any
-        empty strings in the process. This is a convenience method for split that
-        is mostly useful when applied to the `String.prototype`.
+      if (isNone['default'](obj)) {
+        return this; // nothing to do
+      }
 
-        ```javascript
-        Ember.String.w("alpha beta gamma").forEach(function(key) {
-          console.log(key);
-        });
+      var guid = utils.guidFor(obj);
+      var idx  = this[guid];
+      var len  = property_get.get(this, 'length');
+      var added;
 
-        // > alpha
-        // > beta
-        // > gamma
-        ```
+      if (idx>=0 && idx<len && (this[idx] === obj)) {
+        return this; // added
+      }
 
-        @method w
-        @param {String} str The string to split
-        @return {Array} array containing the split strings
-      */
-      w: w,
+      added = [obj];
 
-      /**
-        Converts a camelized string into all lower case separated by underscores.
+      this.enumerableContentWillChange(null, added);
+      property_events.propertyWillChange(this, 'lastObject');
 
-        ```javascript
-        'innerHTML'.decamelize();           // 'inner_html'
-        'action_name'.decamelize();        // 'action_name'
-        'css-class-name'.decamelize();     // 'css-class-name'
-        'my favorite items'.decamelize();  // 'my favorite items'
-        ```
+      len = property_get.get(this, 'length');
+      this[guid] = len;
+      this[len] = obj;
+      property_set.set(this, 'length', len+1);
 
-        @method decamelize
-        @param {String} str The string to decamelize.
-        @return {String} the decamelized string.
-      */
-      decamelize: decamelize,
+      property_events.propertyDidChange(this, 'lastObject');
+      this.enumerableContentDidChange(null, added);
 
-      /**
-        Replaces underscores, spaces, or camelCase with dashes.
+      return this;
+    },
 
-        ```javascript
-        'innerHTML'.dasherize();          // 'inner-html'
-        'action_name'.dasherize();        // 'action-name'
-        'css-class-name'.dasherize();     // 'css-class-name'
-        'my favorite items'.dasherize();  // 'my-favorite-items'
-        ```
+    // implements Ember.MutableEnumerable
+    removeObject: function(obj) {
+      if (property_get.get(this, 'isFrozen')) {
+        throw new EmberError['default'](freezable.FROZEN_ERROR);
+      }
 
-        @method dasherize
-        @param {String} str The string to dasherize.
-        @return {String} the dasherized string.
-      */
-      dasherize: dasherize,
+      if (isNone['default'](obj)) {
+        return this; // nothing to do
+      }
 
-      /**
-        Returns the lowerCamelCase form of a string.
+      var guid = utils.guidFor(obj);
+      var idx  = this[guid];
+      var len = property_get.get(this, 'length');
+      var isFirst = idx === 0;
+      var isLast = idx === len-1;
+      var last, removed;
 
-        ```javascript
-        'innerHTML'.camelize();          // 'innerHTML'
-        'action_name'.camelize();        // 'actionName'
-        'css-class-name'.camelize();     // 'cssClassName'
-        'my favorite items'.camelize();  // 'myFavoriteItems'
-        'My Favorite Items'.camelize();  // 'myFavoriteItems'
-        ```
 
-        @method camelize
-        @param {String} str The string to camelize.
-        @return {String} the camelized string.
-      */
-      camelize: camelize,
+      if (idx>=0 && idx<len && (this[idx] === obj)) {
+        removed = [obj];
 
-      /**
-        Returns the UpperCamelCase form of a string.
+        this.enumerableContentWillChange(removed, null);
+        if (isFirst) { property_events.propertyWillChange(this, 'firstObject'); }
+        if (isLast) { property_events.propertyWillChange(this, 'lastObject'); }
 
-        ```javascript
-        'innerHTML'.classify();          // 'InnerHTML'
-        'action_name'.classify();        // 'ActionName'
-        'css-class-name'.classify();     // 'CssClassName'
-        'my favorite items'.classify();  // 'MyFavoriteItems'
-        ```
+        // swap items - basically move the item to the end so it can be removed
+        if (idx < len-1) {
+          last = this[len-1];
+          this[idx] = last;
+          this[utils.guidFor(last)] = idx;
+        }
 
-        @method classify
-        @param {String} str the string to classify
-        @return {String} the classified string
-      */
-      classify: classify,
+        delete this[guid];
+        delete this[len-1];
+        property_set.set(this, 'length', len-1);
 
-      /**
-        More general than decamelize. Returns the lower\_case\_and\_underscored
-        form of a string.
+        if (isFirst) { property_events.propertyDidChange(this, 'firstObject'); }
+        if (isLast) { property_events.propertyDidChange(this, 'lastObject'); }
+        this.enumerableContentDidChange(removed, null);
+      }
 
-        ```javascript
-        'innerHTML'.underscore();          // 'inner_html'
-        'action_name'.underscore();        // 'action_name'
-        'css-class-name'.underscore();     // 'css_class_name'
-        'my favorite items'.underscore();  // 'my_favorite_items'
-        ```
+      return this;
+    },
 
-        @method underscore
-        @param {String} str The string to underscore.
-        @return {String} the underscored string.
-      */
-      underscore: underscore,
+    // optimized version
+    contains: function(obj) {
+      return this[utils.guidFor(obj)]>=0;
+    },
 
-      /**
-        Returns the Capitalized form of a string
+    copy: function() {
+      var C = this.constructor;
+      var ret = new C();
+      var loc = property_get.get(this, 'length');
 
-        ```javascript
-        'innerHTML'.capitalize()         // 'InnerHTML'
-        'action_name'.capitalize()       // 'Action_name'
-        'css-class-name'.capitalize()    // 'Css-class-name'
-        'my favorite items'.capitalize() // 'My favorite items'
-        ```
+      property_set.set(ret, 'length', loc);
+      while (--loc >= 0) {
+        ret[loc] = this[loc];
+        ret[utils.guidFor(this[loc])] = loc;
+      }
+      return ret;
+    },
 
-        @method capitalize
-        @param {String} str The string to capitalize.
-        @return {String} The capitalized string.
-      */
-      capitalize: capitalize
-    };
+    toString: function() {
+      var len = this.length;
+      var array = [];
+      var idx;
 
-    __exports__.fmt = fmt;
-    __exports__.loc = loc;
-    __exports__.w = w;
-    __exports__.decamelize = decamelize;
-    __exports__.dasherize = dasherize;
-    __exports__.camelize = camelize;
-    __exports__.classify = classify;
-    __exports__.underscore = underscore;
-    __exports__.capitalize = capitalize;
+      for (idx = 0; idx < len; idx++) {
+        array[idx] = this[idx];
+      }
+      return string.fmt("Ember.Set<%@>", [array.join(',')]);
+    }
   });
-enifed("ember-runtime/system/subarray",
-  ["ember-metal/error","ember-metal/enumerable_utils","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var EmberError = __dependency1__["default"];
-    var EnumerableUtils = __dependency2__["default"];
 
-    var RETAIN = 'r';
-    var FILTER = 'f';
+});
+enifed('ember-runtime/system/string', ['exports', 'ember-metal/core', 'ember-metal/utils', 'ember-metal/cache'], function (exports, Ember, utils, Cache) {
 
-    function Operation(type, count) {
-      this.type = type;
-      this.count = count;
-    }
+  'use strict';
 
-    __exports__["default"] = SubArray;
+  exports.fmt = fmt;
+  exports.loc = loc;
+  exports.w = w;
+  exports.decamelize = decamelize;
+  exports.dasherize = dasherize;
+  exports.camelize = camelize;
+  exports.classify = classify;
+  exports.underscore = underscore;
+  exports.capitalize = capitalize;
 
-    /**
-      An `Ember.SubArray` tracks an array in a way similar to, but more specialized
-      than, `Ember.TrackedArray`.  It is useful for keeping track of the indexes of
-      items within a filtered array.
+  /**
+  @module ember
+  @submodule ember-runtime
+  */
+  var STRING_DASHERIZE_REGEXP = (/[ _]/g);
 
-      @class SubArray
-      @namespace Ember
-    */
-    function SubArray (length) {
-      if (arguments.length < 1) { length = 0; }
+  var STRING_DASHERIZE_CACHE = new Cache['default'](1000, function(key) {
+    return decamelize(key).replace(STRING_DASHERIZE_REGEXP, '-');
+  });
 
-      if (length > 0) {
-        this._operations = [new Operation(RETAIN, length)];
-      } else {
-        this._operations = [];
-      }
-    }
+  var CAMELIZE_CACHE = new Cache['default'](1000, function(key) {
+    return key.replace(STRING_CAMELIZE_REGEXP, function(match, separator, chr) {
+      return chr ? chr.toUpperCase() : '';
+    }).replace(/^([A-Z])/, function(match, separator, chr) {
+      return match.toLowerCase();
+    });
+  });
 
+  var CLASSIFY_CACHE = new Cache['default'](1000, function(str) {
+    var parts = str.split(".");
+    var out = [];
 
-    SubArray.prototype = {
-      /**
-        Track that an item was added to the tracked array.
+    for (var i=0, l=parts.length; i<l; i++) {
+      var camelized = camelize(parts[i]);
+      out.push(camelized.charAt(0).toUpperCase() + camelized.substr(1));
+    }
 
-        @method addItem
+    return out.join(".");
+  });
 
-        @param {Number} index The index of the item in the tracked array.
-        @param {Boolean} match `true` iff the item is included in the subarray.
+  var UNDERSCORE_CACHE = new Cache['default'](1000, function(str) {
+    return str.replace(STRING_UNDERSCORE_REGEXP_1, '$1_$2').
+      replace(STRING_UNDERSCORE_REGEXP_2, '_').toLowerCase();
+  });
 
-        @return {number} The index of the item in the subarray.
-      */
-      addItem: function(index, match) {
-        var returnValue = -1;
-        var itemType = match ? RETAIN : FILTER;
-        var self = this;
+  var CAPITALIZE_CACHE = new Cache['default'](1000, function(str) {
+    return str.charAt(0).toUpperCase() + str.substr(1);
+  });
 
-        this._findOperation(index, function(operation, operationIndex, rangeStart, rangeEnd, seenInSubArray) {
-          var newOperation, splitOperation;
+  var DECAMELIZE_CACHE = new Cache['default'](1000, function(str) {
+    return str.replace(STRING_DECAMELIZE_REGEXP, '$1_$2').toLowerCase();
+  });
 
-          if (itemType === operation.type) {
-            ++operation.count;
-          } else if (index === rangeStart) {
-            // insert to the left of `operation`
-            self._operations.splice(operationIndex, 0, new Operation(itemType, 1));
-          } else {
-            newOperation = new Operation(itemType, 1);
-            splitOperation = new Operation(operation.type, rangeEnd - index + 1);
-            operation.count = index - rangeStart;
+  var STRING_DECAMELIZE_REGEXP = (/([a-z\d])([A-Z])/g);
+  var STRING_CAMELIZE_REGEXP = (/(\-|_|\.|\s)+(.)?/g);
+  var STRING_UNDERSCORE_REGEXP_1 = (/([a-z\d])([A-Z]+)/g);
+  var STRING_UNDERSCORE_REGEXP_2 = (/\-|\s+/g);
 
-            self._operations.splice(operationIndex + 1, 0, newOperation, splitOperation);
-          }
+  function fmt(str, formats) {
+    var cachedFormats = formats;
 
-          if (match) {
-            if (operation.type === RETAIN) {
-              returnValue = seenInSubArray + (index - rangeStart);
-            } else {
-              returnValue = seenInSubArray;
-            }
-          }
+    if (!utils.isArray(cachedFormats) || arguments.length > 2) {
+      cachedFormats = new Array(arguments.length - 1);
 
-          self._composeAt(operationIndex);
-        }, function(seenInSubArray) {
-          self._operations.push(new Operation(itemType, 1));
+      for (var i = 1, l = arguments.length; i < l; i++) {
+        cachedFormats[i - 1] = arguments[i];
+      }
+    }
 
-          if (match) {
-            returnValue = seenInSubArray;
-          }
+    // first, replace any ORDERED replacements.
+    var idx  = 0; // the current index for non-numerical replacements
+    return str.replace(/%@([0-9]+)?/g, function(s, argIndex) {
+      argIndex = (argIndex) ? parseInt(argIndex, 10) - 1 : idx++;
+      s = cachedFormats[argIndex];
+      return (s === null) ? '(null)' : (s === undefined) ? '' : utils.inspect(s);
+    });
+  }
 
-          self._composeAt(self._operations.length-1);
-        });
+  function loc(str, formats) {
+    if (!utils.isArray(formats) || arguments.length > 2) {
+      formats = Array.prototype.slice.call(arguments, 1);
+    }
 
-        return returnValue;
-      },
+    str = Ember['default'].STRINGS[str] || str;
+    return fmt(str, formats);
+  }
 
-      /**
-        Track that an item was removed from the tracked array.
+  function w(str) {
+    return str.split(/\s+/);
+  }
 
-        @method removeItem
+  function decamelize(str) {
+    return DECAMELIZE_CACHE.get(str);
+  }
 
-        @param {Number} index The index of the item in the tracked array.
+  function dasherize(str) {
+    return STRING_DASHERIZE_CACHE.get(str);
+  }
 
-        @return {number} The index of the item in the subarray, or `-1` if the item
-        was not in the subarray.
-      */
-      removeItem: function(index) {
-        var returnValue = -1;
-        var self = this;
+  function camelize(str) {
+    return CAMELIZE_CACHE.get(str);
+  }
 
-        this._findOperation(index, function (operation, operationIndex, rangeStart, rangeEnd, seenInSubArray) {
-          if (operation.type === RETAIN) {
-            returnValue = seenInSubArray + (index - rangeStart);
-          }
+  function classify(str) {
+    return CLASSIFY_CACHE.get(str);
+  }
 
-          if (operation.count > 1) {
-            --operation.count;
-          } else {
-            self._operations.splice(operationIndex, 1);
-            self._composeAt(operationIndex);
-          }
-        }, function() {
-          throw new EmberError("Can't remove an item that has never been added.");
-        });
+  function underscore(str) {
+    return UNDERSCORE_CACHE.get(str);
+  }
 
-        return returnValue;
-      },
+  function capitalize(str) {
+    return CAPITALIZE_CACHE.get(str);
+  }
 
+  /**
+    Defines the hash of localized strings for the current language. Used by
+    the `Ember.String.loc()` helper. To localize, add string values to this
+    hash.
 
-      _findOperation: function (index, foundCallback, notFoundCallback) {
-        var seenInSubArray = 0;
-        var operationIndex, len, operation, rangeStart, rangeEnd;
+    @property STRINGS
+    @for Ember
+    @type Hash
+  */
+  Ember['default'].STRINGS = {};
 
-        // OPTIMIZE: change to balanced tree
-        // find leftmost operation to the right of `index`
-        for (operationIndex = rangeStart = 0, len = this._operations.length; operationIndex < len; rangeStart = rangeEnd + 1, ++operationIndex) {
-          operation = this._operations[operationIndex];
-          rangeEnd = rangeStart + operation.count - 1;
+  /**
+    Defines string helper methods including string formatting and localization.
+    Unless `Ember.EXTEND_PROTOTYPES.String` is `false` these methods will also be
+    added to the `String.prototype` as well.
 
-          if (index >= rangeStart && index <= rangeEnd) {
-            foundCallback(operation, operationIndex, rangeStart, rangeEnd, seenInSubArray);
-            return;
-          } else if (operation.type === RETAIN) {
-            seenInSubArray += operation.count;
-          }
-        }
+    @class String
+    @namespace Ember
+    @static
+  */
+  exports['default'] = {
+    /**
+      Apply formatting options to the string. This will look for occurrences
+      of "%@" in your string and substitute them with the arguments you pass into
+      this method. If you want to control the specific order of replacement,
+      you can add a number after the key as well to indicate which argument
+      you want to insert.
 
-        notFoundCallback(seenInSubArray);
-      },
+      Ordered insertions are most useful when building loc strings where values
+      you need to insert may appear in different orders.
 
-      _composeAt: function(index) {
-        var op = this._operations[index];
-        var otherOp;
+      ```javascript
+      "Hello %@ %@".fmt('John', 'Doe');     // "Hello John Doe"
+      "Hello %@2, %@1".fmt('John', 'Doe');  // "Hello Doe, John"
+      ```
 
-        if (!op) {
-          // Composing out of bounds is a no-op, as when removing the last operation
-          // in the list.
-          return;
-        }
+      @method fmt
+      @param {String} str The string to format
+      @param {Array} formats An array of parameters to interpolate into string.
+      @return {String} formatted string
+    */
+    fmt: fmt,
 
-        if (index > 0) {
-          otherOp = this._operations[index-1];
-          if (otherOp.type === op.type) {
-            op.count += otherOp.count;
-            this._operations.splice(index-1, 1);
-            --index;
-          }
-        }
+    /**
+      Formats the passed string, but first looks up the string in the localized
+      strings hash. This is a convenient way to localize text. See
+      `Ember.String.fmt()` for more information on formatting.
 
-        if (index < this._operations.length-1) {
-          otherOp = this._operations[index+1];
-          if (otherOp.type === op.type) {
-            op.count += otherOp.count;
-            this._operations.splice(index+1, 1);
-          }
-        }
-      },
+      Note that it is traditional but not required to prefix localized string
+      keys with an underscore or other character so you can easily identify
+      localized strings.
 
-      toString: function () {
-        var str = "";
-        EnumerableUtils.forEach(this._operations, function (operation) {
-          str += " " + operation.type + ":" + operation.count;
-        });
-        return str.substring(1);
-      }
-    };
-  });
-enifed("ember-runtime/system/tracked_array",
-  ["ember-metal/property_get","ember-metal/enumerable_utils","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var get = __dependency1__.get;
-    var forEach = __dependency2__.forEach;
+      ```javascript
+      Ember.STRINGS = {
+        '_Hello World': 'Bonjour le monde',
+        '_Hello %@ %@': 'Bonjour %@ %@'
+      };
 
-    var RETAIN = 'r';
-    var INSERT = 'i';
-    var DELETE = 'd';
+      Ember.String.loc("_Hello World");  // 'Bonjour le monde';
+      Ember.String.loc("_Hello %@ %@", ["John", "Smith"]);  // "Bonjour John Smith";
+      ```
 
-    __exports__["default"] = TrackedArray;
+      @method loc
+      @param {String} str The string to format
+      @param {Array} formats Optional array of parameters to interpolate into string.
+      @return {String} formatted string
+    */
+    loc: loc,
 
     /**
-      An `Ember.TrackedArray` tracks array operations.  It's useful when you want to
-      lazily compute the indexes of items in an array after they've been shifted by
-      subsequent operations.
+      Splits a string into separate units separated by spaces, eliminating any
+      empty strings in the process. This is a convenience method for split that
+      is mostly useful when applied to the `String.prototype`.
 
-      @class TrackedArray
-      @namespace Ember
-      @param {Array} [items=[]] The array to be tracked.  This is used just to get
-      the initial items for the starting state of retain:n.
-    */
-    function TrackedArray(items) {
-      if (arguments.length < 1) { items = []; }
+      ```javascript
+      Ember.String.w("alpha beta gamma").forEach(function(key) {
+        console.log(key);
+      });
 
-      var length = get(items, 'length');
+      // > alpha
+      // > beta
+      // > gamma
+      ```
 
-      if (length) {
-        this._operations = [new ArrayOperation(RETAIN, length, items)];
-      } else {
-        this._operations = [];
-      }
-    }
+      @method w
+      @param {String} str The string to split
+      @return {Array} array containing the split strings
+    */
+    w: w,
 
-    TrackedArray.RETAIN = RETAIN;
-    TrackedArray.INSERT = INSERT;
-    TrackedArray.DELETE = DELETE;
+    /**
+      Converts a camelized string into all lower case separated by underscores.
 
-    TrackedArray.prototype = {
+      ```javascript
+      'innerHTML'.decamelize();           // 'inner_html'
+      'action_name'.decamelize();        // 'action_name'
+      'css-class-name'.decamelize();     // 'css-class-name'
+      'my favorite items'.decamelize();  // 'my favorite items'
+      ```
 
-      /**
-        Track that `newItems` were added to the tracked array at `index`.
+      @method decamelize
+      @param {String} str The string to decamelize.
+      @return {String} the decamelized string.
+    */
+    decamelize: decamelize,
 
-        @method addItems
-        @param index
-        @param newItems
-      */
-      addItems: function (index, newItems) {
-        var count = get(newItems, 'length');
-        if (count < 1) { return; }
-
-        var match = this._findArrayOperation(index);
-        var arrayOperation = match.operation;
-        var arrayOperationIndex = match.index;
-        var arrayOperationRangeStart = match.rangeStart;
-        var composeIndex, newArrayOperation;
-
-        newArrayOperation = new ArrayOperation(INSERT, count, newItems);
-
-        if (arrayOperation) {
-          if (!match.split) {
-            // insert left of arrayOperation
-            this._operations.splice(arrayOperationIndex, 0, newArrayOperation);
-            composeIndex = arrayOperationIndex;
-          } else {
-            this._split(arrayOperationIndex, index - arrayOperationRangeStart, newArrayOperation);
-            composeIndex = arrayOperationIndex + 1;
-          }
-        } else {
-          // insert at end
-          this._operations.push(newArrayOperation);
-          composeIndex = arrayOperationIndex;
-        }
+    /**
+      Replaces underscores, spaces, or camelCase with dashes.
 
-        this._composeInsert(composeIndex);
-      },
+      ```javascript
+      'innerHTML'.dasherize();          // 'inner-html'
+      'action_name'.dasherize();        // 'action-name'
+      'css-class-name'.dasherize();     // 'css-class-name'
+      'my favorite items'.dasherize();  // 'my-favorite-items'
+      ```
 
-      /**
-        Track that `count` items were removed at `index`.
+      @method dasherize
+      @param {String} str The string to dasherize.
+      @return {String} the dasherized string.
+    */
+    dasherize: dasherize,
 
-        @method removeItems
-        @param index
-        @param count
-      */
-      removeItems: function (index, count) {
-        if (count < 1) { return; }
+    /**
+      Returns the lowerCamelCase form of a string.
 
-        var match = this._findArrayOperation(index);
-        var arrayOperationIndex = match.index;
-        var arrayOperationRangeStart = match.rangeStart;
-        var newArrayOperation, composeIndex;
+      ```javascript
+      'innerHTML'.camelize();          // 'innerHTML'
+      'action_name'.camelize();        // 'actionName'
+      'css-class-name'.camelize();     // 'cssClassName'
+      'my favorite items'.camelize();  // 'myFavoriteItems'
+      'My Favorite Items'.camelize();  // 'myFavoriteItems'
+      ```
 
-        newArrayOperation = new ArrayOperation(DELETE, count);
-        if (!match.split) {
-          // insert left of arrayOperation
-          this._operations.splice(arrayOperationIndex, 0, newArrayOperation);
-          composeIndex = arrayOperationIndex;
-        } else {
-          this._split(arrayOperationIndex, index - arrayOperationRangeStart, newArrayOperation);
-          composeIndex = arrayOperationIndex + 1;
-        }
+      @method camelize
+      @param {String} str The string to camelize.
+      @return {String} the camelized string.
+    */
+    camelize: camelize,
 
-        return this._composeDelete(composeIndex);
-      },
+    /**
+      Returns the UpperCamelCase form of a string.
 
-      /**
-        Apply all operations, reducing them to retain:n, for `n`, the number of
-        items in the array.
+      ```javascript
+      'innerHTML'.classify();          // 'InnerHTML'
+      'action_name'.classify();        // 'ActionName'
+      'css-class-name'.classify();     // 'CssClassName'
+      'my favorite items'.classify();  // 'MyFavoriteItems'
+      ```
 
-        `callback` will be called for each operation and will be passed the following arguments:
+      @method classify
+      @param {String} str the string to classify
+      @return {String} the classified string
+    */
+    classify: classify,
 
-        * {array} items The items for the given operation
-        * {number} offset The computed offset of the items, ie the index in the
-        array of the first item for this operation.
-        * {string} operation The type of the operation.  One of
-        `Ember.TrackedArray.{RETAIN, DELETE, INSERT}`
+    /**
+      More general than decamelize. Returns the lower\_case\_and\_underscored
+      form of a string.
 
-        @method apply
-        @param {Function} callback
-      */
-      apply: function (callback) {
-        var items = [];
-        var offset = 0;
+      ```javascript
+      'innerHTML'.underscore();          // 'inner_html'
+      'action_name'.underscore();        // 'action_name'
+      'css-class-name'.underscore();     // 'css_class_name'
+      'my favorite items'.underscore();  // 'my_favorite_items'
+      ```
 
-        forEach(this._operations, function (arrayOperation, operationIndex) {
-          callback(arrayOperation.items, offset, arrayOperation.type, operationIndex);
+      @method underscore
+      @param {String} str The string to underscore.
+      @return {String} the underscored string.
+    */
+    underscore: underscore,
 
-          if (arrayOperation.type !== DELETE) {
-            offset += arrayOperation.count;
-            items = items.concat(arrayOperation.items);
-          }
-        });
+    /**
+      Returns the Capitalized form of a string
 
-        this._operations = [new ArrayOperation(RETAIN, items.length, items)];
-      },
+      ```javascript
+      'innerHTML'.capitalize()         // 'InnerHTML'
+      'action_name'.capitalize()       // 'Action_name'
+      'css-class-name'.capitalize()    // 'Css-class-name'
+      'my favorite items'.capitalize() // 'My favorite items'
+      ```
 
-      /**
-        Return an `ArrayOperationMatch` for the operation that contains the item at `index`.
+      @method capitalize
+      @param {String} str The string to capitalize.
+      @return {String} The capitalized string.
+    */
+    capitalize: capitalize
+  };
 
-        @method _findArrayOperation
+});
+enifed('ember-runtime/system/subarray', ['exports', 'ember-metal/error', 'ember-metal/enumerable_utils'], function (exports, EmberError, EnumerableUtils) {
 
-        @param {Number} index the index of the item whose operation information
-        should be returned.
-        @private
-      */
-      _findArrayOperation: function (index) {
-        var split = false;
-        var arrayOperationIndex, arrayOperation,
-            arrayOperationRangeStart, arrayOperationRangeEnd,
-            len;
+  'use strict';
 
-        // OPTIMIZE: we could search these faster if we kept a balanced tree.
-        // find leftmost arrayOperation to the right of `index`
-        for (arrayOperationIndex = arrayOperationRangeStart = 0, len = this._operations.length; arrayOperationIndex < len; ++arrayOperationIndex) {
-          arrayOperation = this._operations[arrayOperationIndex];
+  var RETAIN = 'r';
+  var FILTER = 'f';
 
-          if (arrayOperation.type === DELETE) { continue; }
+  function Operation(type, count) {
+    this.type = type;
+    this.count = count;
+  }
 
-          arrayOperationRangeEnd = arrayOperationRangeStart + arrayOperation.count - 1;
+  exports['default'] = SubArray;
 
-          if (index === arrayOperationRangeStart) {
-            break;
-          } else if (index > arrayOperationRangeStart && index <= arrayOperationRangeEnd) {
-            split = true;
-            break;
-          } else {
-            arrayOperationRangeStart = arrayOperationRangeEnd + 1;
-          }
-        }
+  /**
+    An `Ember.SubArray` tracks an array in a way similar to, but more specialized
+    than, `Ember.TrackedArray`.  It is useful for keeping track of the indexes of
+    items within a filtered array.
 
-        return new ArrayOperationMatch(arrayOperation, arrayOperationIndex, split, arrayOperationRangeStart);
-      },
+    @class SubArray
+    @namespace Ember
+  */
+  function SubArray(length) {
+    if (arguments.length < 1) { length = 0; }
 
-      _split: function (arrayOperationIndex, splitIndex, newArrayOperation) {
-        var arrayOperation = this._operations[arrayOperationIndex];
-        var splitItems = arrayOperation.items.slice(splitIndex);
-        var splitArrayOperation = new ArrayOperation(arrayOperation.type, splitItems.length, splitItems);
+    if (length > 0) {
+      this._operations = [new Operation(RETAIN, length)];
+    } else {
+      this._operations = [];
+    }
+  }
 
-        // truncate LHS
-        arrayOperation.count = splitIndex;
-        arrayOperation.items = arrayOperation.items.slice(0, splitIndex);
 
-        this._operations.splice(arrayOperationIndex + 1, 0, newArrayOperation, splitArrayOperation);
-      },
+  SubArray.prototype = {
+    /**
+      Track that an item was added to the tracked array.
 
-      // see SubArray for a better implementation.
-      _composeInsert: function (index) {
-        var newArrayOperation = this._operations[index];
-        var leftArrayOperation = this._operations[index-1]; // may be undefined
-        var rightArrayOperation = this._operations[index+1]; // may be undefined
-        var leftOp = leftArrayOperation && leftArrayOperation.type;
-        var rightOp = rightArrayOperation && rightArrayOperation.type;
-
-        if (leftOp === INSERT) {
-            // merge left
-            leftArrayOperation.count += newArrayOperation.count;
-            leftArrayOperation.items = leftArrayOperation.items.concat(newArrayOperation.items);
-
-          if (rightOp === INSERT) {
-            // also merge right (we have split an insert with an insert)
-            leftArrayOperation.count += rightArrayOperation.count;
-            leftArrayOperation.items = leftArrayOperation.items.concat(rightArrayOperation.items);
-            this._operations.splice(index, 2);
-          } else {
-            // only merge left
-            this._operations.splice(index, 1);
-          }
-        } else if (rightOp === INSERT) {
-          // merge right
-          newArrayOperation.count += rightArrayOperation.count;
-          newArrayOperation.items = newArrayOperation.items.concat(rightArrayOperation.items);
-          this._operations.splice(index + 1, 1);
-        }
-      },
+      @method addItem
 
-      _composeDelete: function (index) {
-        var arrayOperation = this._operations[index];
-        var deletesToGo = arrayOperation.count;
-        var leftArrayOperation = this._operations[index-1]; // may be undefined
-        var leftOp = leftArrayOperation && leftArrayOperation.type;
-        var nextArrayOperation;
-        var nextOp;
-        var nextCount;
-        var removeNewAndNextOp = false;
-        var removedItems = [];
-
-        if (leftOp === DELETE) {
-          arrayOperation = leftArrayOperation;
-          index -= 1;
-        }
-
-        for (var i = index + 1; deletesToGo > 0; ++i) {
-          nextArrayOperation = this._operations[i];
-          nextOp = nextArrayOperation.type;
-          nextCount = nextArrayOperation.count;
-
-          if (nextOp === DELETE) {
-            arrayOperation.count += nextCount;
-            continue;
-          }
+      @param {Number} index The index of the item in the tracked array.
+      @param {Boolean} match `true` iff the item is included in the subarray.
 
-          if (nextCount > deletesToGo) {
-            // d:2 {r,i}:5  we reduce the retain or insert, but it stays
-            removedItems = removedItems.concat(nextArrayOperation.items.splice(0, deletesToGo));
-            nextArrayOperation.count -= deletesToGo;
+      @return {number} The index of the item in the subarray.
+    */
+    addItem: function(index, match) {
+      var returnValue = -1;
+      var itemType = match ? RETAIN : FILTER;
+      var self = this;
 
-            // In the case where we truncate the last arrayOperation, we don't need to
-            // remove it; also the deletesToGo reduction is not the entirety of
-            // nextCount
-            i -= 1;
-            nextCount = deletesToGo;
+      this._findOperation(index, function(operation, operationIndex, rangeStart, rangeEnd, seenInSubArray) {
+        var newOperation, splitOperation;
 
-            deletesToGo = 0;
-          } else {
-            if (nextCount === deletesToGo) {
-              // Handle edge case of d:2 i:2 in which case both operations go away
-              // during composition.
-              removeNewAndNextOp = true;
-            }
-            removedItems = removedItems.concat(nextArrayOperation.items);
-            deletesToGo -= nextCount;
-          }
+        if (itemType === operation.type) {
+          ++operation.count;
+        } else if (index === rangeStart) {
+          // insert to the left of `operation`
+          self._operations.splice(operationIndex, 0, new Operation(itemType, 1));
+        } else {
+          newOperation = new Operation(itemType, 1);
+          splitOperation = new Operation(operation.type, rangeEnd - index + 1);
+          operation.count = index - rangeStart;
 
-          if (nextOp === INSERT) {
-            // d:2 i:3 will result in delete going away
-            arrayOperation.count -= nextCount;
-          }
+          self._operations.splice(operationIndex + 1, 0, newOperation, splitOperation);
         }
 
-        if (arrayOperation.count > 0) {
-          // compose our new delete with possibly several operations to the right of
-          // disparate types
-          this._operations.splice(index+1, i-1-index);
-        } else {
-          // The delete operation can go away; it has merely reduced some other
-          // operation, as in d:3 i:4; it may also have eliminated that operation,
-          // as in d:3 i:3.
-          this._operations.splice(index, removeNewAndNextOp ? 2 : 1);
+        if (match) {
+          if (operation.type === RETAIN) {
+            returnValue = seenInSubArray + (index - rangeStart);
+          } else {
+            returnValue = seenInSubArray;
+          }
         }
 
-        return removedItems;
-      },
-
-      toString: function () {
-        var str = "";
-        forEach(this._operations, function (operation) {
-          str += " " + operation.type + ":" + operation.count;
-        });
-        return str.substring(1);
-      }
-    };
-
-    /**
-      Internal data structure to represent an array operation.
-
-      @method ArrayOperation
-      @private
-      @param {String} type The type of the operation.  One of
-      `Ember.TrackedArray.{RETAIN, INSERT, DELETE}`
-      @param {Number} count The number of items in this operation.
-      @param {Array} items The items of the operation, if included.  RETAIN and
-      INSERT include their items, DELETE does not.
-    */
-    function ArrayOperation (operation, count, items) {
-      this.type = operation; // RETAIN | INSERT | DELETE
-      this.count = count;
-      this.items = items;
-    }
-
-    /**
-      Internal data structure used to include information when looking up operations
-      by item index.
+        self._composeAt(operationIndex);
+      }, function(seenInSubArray) {
+        self._operations.push(new Operation(itemType, 1));
 
-      @method ArrayOperationMatch
-      @private
-      @param {ArrayOperation} operation
-      @param {Number} index The index of `operation` in the array of operations.
-      @param {Boolean} split Whether or not the item index searched for would
-      require a split for a new operation type.
-      @param {Number} rangeStart The index of the first item in the operation,
-      with respect to the tracked array.  The index of the last item can be computed
-      from `rangeStart` and `operation.count`.
-    */
-    function ArrayOperationMatch(operation, index, split, rangeStart) {
-      this.operation = operation;
-      this.index = index;
-      this.split = split;
-      this.rangeStart = rangeStart;
-    }
-  });
-enifed("ember-template-compiler",
-  ["ember-metal/core","ember-template-compiler/system/precompile","ember-template-compiler/system/compile","ember-template-compiler/system/template","ember-template-compiler/plugins","ember-template-compiler/plugins/transform-each-in-to-hash","ember-template-compiler/plugins/transform-with-as-to-hash","ember-template-compiler/compat","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
-    "use strict";
-    var _Ember = __dependency1__["default"];
-    var precompile = __dependency2__["default"];
-    var compile = __dependency3__["default"];
-    var template = __dependency4__["default"];
-    var registerPlugin = __dependency5__.registerPlugin;
+        if (match) {
+          returnValue = seenInSubArray;
+        }
 
-    var TransformEachInToHash = __dependency6__["default"];
-    var TransformWithAsToHash = __dependency7__["default"];
+        self._composeAt(self._operations.length-1);
+      });
 
-    // used for adding Ember.Handlebars.compile for backwards compat
+      return returnValue;
+    },
 
-    registerPlugin('ast', TransformWithAsToHash);
-    registerPlugin('ast', TransformEachInToHash);
+    /**
+      Track that an item was removed from the tracked array.
 
-    __exports__._Ember = _Ember;
-    __exports__.precompile = precompile;
-    __exports__.compile = compile;
-    __exports__.template = template;
-    __exports__.registerPlugin = registerPlugin;
-  });
-enifed("ember-template-compiler/compat",
-  ["ember-metal/core","ember-template-compiler/compat/precompile","ember-template-compiler/system/compile","ember-template-compiler/system/template"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var precompile = __dependency2__["default"];
-    var compile = __dependency3__["default"];
-    var template = __dependency4__["default"];
+      @method removeItem
 
-    var EmberHandlebars = Ember.Handlebars = Ember.Handlebars || {};
+      @param {Number} index The index of the item in the tracked array.
 
-    EmberHandlebars.precompile = precompile;
-    EmberHandlebars.compile = compile;
-    EmberHandlebars.template = template;
-  });
-enifed("ember-template-compiler/compat/precompile",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-template-compiler
+      @return {number} The index of the item in the subarray, or `-1` if the item
+      was not in the subarray.
     */
+    removeItem: function(index) {
+      var returnValue = -1;
+      var self = this;
+
+      this._findOperation(index, function (operation, operationIndex, rangeStart, rangeEnd, seenInSubArray) {
+        if (operation.type === RETAIN) {
+          returnValue = seenInSubArray + (index - rangeStart);
+        }
 
-    var compile, compileSpec;
+        if (operation.count > 1) {
+          --operation.count;
+        } else {
+          self._operations.splice(operationIndex, 1);
+          self._composeAt(operationIndex);
+        }
+      }, function() {
+        throw new EmberError['default']("Can't remove an item that has never been added.");
+      });
 
-    __exports__["default"] = function(string) {
-      if ((!compile || !compileSpec) && Ember.__loader.registry['htmlbars-compiler/compiler']) {
-        var Compiler = requireModule('htmlbars-compiler/compiler');
+      return returnValue;
+    },
 
-        compile = Compiler.compile;
-        compileSpec = Compiler.compileSpec;
-      }
 
-      if (!compile || !compileSpec) {
-        throw new Error('Cannot call `precompile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `precompile`.');
+    _findOperation: function (index, foundCallback, notFoundCallback) {
+      var seenInSubArray = 0;
+      var operationIndex, len, operation, rangeStart, rangeEnd;
+
+      // OPTIMIZE: change to balanced tree
+      // find leftmost operation to the right of `index`
+      for (operationIndex = rangeStart = 0, len = this._operations.length; operationIndex < len; rangeStart = rangeEnd + 1, ++operationIndex) {
+        operation = this._operations[operationIndex];
+        rangeEnd = rangeStart + operation.count - 1;
+
+        if (index >= rangeStart && index <= rangeEnd) {
+          foundCallback(operation, operationIndex, rangeStart, rangeEnd, seenInSubArray);
+          return;
+        } else if (operation.type === RETAIN) {
+          seenInSubArray += operation.count;
+        }
       }
 
-      var asObject = arguments[1] === undefined ? true : arguments[1];
-      var compileFunc = asObject ? compile : compileSpec;
+      notFoundCallback(seenInSubArray);
+    },
 
-      return compileFunc(string);
-    }
-  });
-enifed("ember-template-compiler/plugins",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-template-compiler
-    */
+    _composeAt: function(index) {
+      var op = this._operations[index];
+      var otherOp;
 
-    /**
-     @private
-     @property helpers
-    */
-    var plugins = {
-      ast: [ ]
-    };
+      if (!op) {
+        // Composing out of bounds is a no-op, as when removing the last operation
+        // in the list.
+        return;
+      }
 
-    /**
-      Adds an AST plugin to be used by Ember.HTMLBars.compile.
+      if (index > 0) {
+        otherOp = this._operations[index-1];
+        if (otherOp.type === op.type) {
+          op.count += otherOp.count;
+          this._operations.splice(index-1, 1);
+          --index;
+        }
+      }
 
-      @private
-      @method registerASTPlugin
-    */
-    function registerPlugin(type, Plugin) {
-      if (!plugins[type]) {
-        throw new Error('Attempting to register "' + Plugin + '" as "' + type + '" which is not a valid HTMLBars plugin type.');
+      if (index < this._operations.length-1) {
+        otherOp = this._operations[index+1];
+        if (otherOp.type === op.type) {
+          op.count += otherOp.count;
+          this._operations.splice(index+1, 1);
+        }
       }
+    },
 
-      plugins[type].push(Plugin);
+    toString: function () {
+      var str = "";
+      EnumerableUtils['default'].forEach(this._operations, function (operation) {
+        str += " " + operation.type + ":" + operation.count;
+      });
+      return str.substring(1);
     }
+  };
 
-    __exports__.registerPlugin = registerPlugin;__exports__["default"] = plugins;
-  });
-enifed("ember-template-compiler/plugins/transform-each-in-to-hash",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+});
+enifed('ember-runtime/system/tracked_array', ['exports', 'ember-metal/property_get', 'ember-metal/enumerable_utils'], function (exports, property_get, enumerable_utils) {
 
+  'use strict';
 
-    /**
-      An HTMLBars AST transformation that replaces all instances of
+  var RETAIN = 'r';
+  var INSERT = 'i';
+  var DELETE = 'd';
 
-      ```handlebars
-      {{#each item in items}}
-      {{/each}}
-      ```
+  exports['default'] = TrackedArray;
 
-      with
+  /**
+    An `Ember.TrackedArray` tracks array operations.  It's useful when you want to
+    lazily compute the indexes of items in an array after they've been shifted by
+    subsequent operations.
 
-      ```handlebars
-      {{#each items keyword="item"}}
-      {{/each}}
-      ```
+    @class TrackedArray
+    @namespace Ember
+    @param {Array} [items=[]] The array to be tracked.  This is used just to get
+    the initial items for the starting state of retain:n.
+  */
+  function TrackedArray(items) {
+    if (arguments.length < 1) { items = []; }
 
-      @class TransformEachInToHash
-      @private
-    */
-    function TransformEachInToHash() {
-      // set later within HTMLBars to the syntax package
-      this.syntax = null;
+    var length = property_get.get(items, 'length');
+
+    if (length) {
+      this._operations = [new ArrayOperation(RETAIN, length, items)];
+    } else {
+      this._operations = [];
     }
+  }
 
-    /**
-      @private
-      @method transform
-      @param {AST} The AST to be transformed.
-    */
-    TransformEachInToHash.prototype.transform = function TransformEachInToHash_transform(ast) {
-      var pluginContext = this;
-      var walker = new pluginContext.syntax.Walker();
-      var b = pluginContext.syntax.builders;
+  TrackedArray.RETAIN = RETAIN;
+  TrackedArray.INSERT = INSERT;
+  TrackedArray.DELETE = DELETE;
 
-      walker.visit(ast, function(node) {
-        if (pluginContext.validate(node)) {
+  TrackedArray.prototype = {
 
-          if (node.program && node.program.blockParams.length) {
-            throw new Error('You cannot use keyword (`{{each foo in bar}}`) and block params (`{{each bar as |foo|}}`) at the same time.');
-          }
+    /**
+      Track that `newItems` were added to the tracked array at `index`.
 
-          var removedParams = node.sexpr.params.splice(0, 2);
-          var keyword = removedParams[0].original;
+      @method addItems
+      @param index
+      @param newItems
+    */
+    addItems: function (index, newItems) {
+      var count = property_get.get(newItems, 'length');
+      if (count < 1) { return; }
 
-          // TODO: This may not be necessary.
-          if (!node.sexpr.hash) {
-            node.sexpr.hash = b.hash();
-          }
+      var match = this._findArrayOperation(index);
+      var arrayOperation = match.operation;
+      var arrayOperationIndex = match.index;
+      var arrayOperationRangeStart = match.rangeStart;
+      var composeIndex, newArrayOperation;
 
-          node.sexpr.hash.pairs.push(b.pair(
-            'keyword',
-            b.string(keyword)
-          ));
-        }
-      });
+      newArrayOperation = new ArrayOperation(INSERT, count, newItems);
 
-      return ast;
-    };
+      if (arrayOperation) {
+        if (!match.split) {
+          // insert left of arrayOperation
+          this._operations.splice(arrayOperationIndex, 0, newArrayOperation);
+          composeIndex = arrayOperationIndex;
+        } else {
+          this._split(arrayOperationIndex, index - arrayOperationRangeStart, newArrayOperation);
+          composeIndex = arrayOperationIndex + 1;
+        }
+      } else {
+        // insert at end
+        this._operations.push(newArrayOperation);
+        composeIndex = arrayOperationIndex;
+      }
 
-    TransformEachInToHash.prototype.validate = function TransformEachInToHash_validate(node) {
-      return (node.type === 'BlockStatement' || node.type === 'MustacheStatement') &&
-        node.sexpr.path.original === 'each' &&
-        node.sexpr.params.length === 3 &&
-        node.sexpr.params[1].type === 'PathExpression' &&
-        node.sexpr.params[1].original === 'in';
-    };
+      this._composeInsert(composeIndex);
+    },
 
-    __exports__["default"] = TransformEachInToHash;
-  });
-enifed("ember-template-compiler/plugins/transform-with-as-to-hash",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-htmlbars
+      Track that `count` items were removed at `index`.
+
+      @method removeItems
+      @param index
+      @param count
     */
+    removeItems: function (index, count) {
+      if (count < 1) { return; }
 
-    /**
-      An HTMLBars AST transformation that replaces all instances of
+      var match = this._findArrayOperation(index);
+      var arrayOperationIndex = match.index;
+      var arrayOperationRangeStart = match.rangeStart;
+      var newArrayOperation, composeIndex;
 
-      ```handlebars
-      {{#with foo.bar as bar}}
-      {{/with}}
-      ```
+      newArrayOperation = new ArrayOperation(DELETE, count);
+      if (!match.split) {
+        // insert left of arrayOperation
+        this._operations.splice(arrayOperationIndex, 0, newArrayOperation);
+        composeIndex = arrayOperationIndex;
+      } else {
+        this._split(arrayOperationIndex, index - arrayOperationRangeStart, newArrayOperation);
+        composeIndex = arrayOperationIndex + 1;
+      }
 
-      with
+      return this._composeDelete(composeIndex);
+    },
 
-      ```handlebars
-      {{#with foo.bar as |bar|}}
-      {{/with}}
-      ```
+    /**
+      Apply all operations, reducing them to retain:n, for `n`, the number of
+      items in the array.
 
-      @private
-      @class TransformWithAsToHash
-    */
-    function TransformWithAsToHash() {
-      // set later within HTMLBars to the syntax package
-      this.syntax = null;
-    }
+      `callback` will be called for each operation and will be passed the following arguments:
 
-    /**
-      @private
-      @method transform
-      @param {AST} The AST to be transformed.
-    */
-    TransformWithAsToHash.prototype.transform = function TransformWithAsToHash_transform(ast) {
-      var pluginContext = this;
-      var walker = new pluginContext.syntax.Walker();
+      * {array} items The items for the given operation
+      * {number} offset The computed offset of the items, ie the index in the
+      array of the first item for this operation.
+      * {string} operation The type of the operation.  One of
+      `Ember.TrackedArray.{RETAIN, DELETE, INSERT}`
 
-      walker.visit(ast, function(node) {
-        if (pluginContext.validate(node)) {
+      @method apply
+      @param {Function} callback
+    */
+    apply: function (callback) {
+      var items = [];
+      var offset = 0;
 
-          if (node.program && node.program.blockParams.length) {
-            throw new Error('You cannot use keyword (`{{with foo as bar}}`) and block params (`{{with foo as |bar|}}`) at the same time.');
-          }
+      enumerable_utils.forEach(this._operations, function (arrayOperation, operationIndex) {
+        callback(arrayOperation.items, offset, arrayOperation.type, operationIndex);
 
-          var removedParams = node.sexpr.params.splice(1, 2);
-          var keyword = removedParams[1].original;
-          node.program.blockParams = [ keyword ];
+        if (arrayOperation.type !== DELETE) {
+          offset += arrayOperation.count;
+          items = items.concat(arrayOperation.items);
         }
       });
 
-      return ast;
-    };
-
-    TransformWithAsToHash.prototype.validate = function TransformWithAsToHash_validate(node) {
-      return node.type === 'BlockStatement' &&
-        node.sexpr.path.original === 'with' &&
-        node.sexpr.params.length === 3 &&
-        node.sexpr.params[1].type === 'PathExpression' &&
-        node.sexpr.params[1].original === 'as';
-    };
+      this._operations = [new ArrayOperation(RETAIN, items.length, items)];
+    },
 
-    __exports__["default"] = TransformWithAsToHash;
-  });
-enifed("ember-template-compiler/system/compile",
-  ["ember-template-compiler/system/compile_options","ember-template-compiler/system/template","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-template-compiler
+      Return an `ArrayOperationMatch` for the operation that contains the item at `index`.
+
+      @method _findArrayOperation
+
+      @param {Number} index the index of the item whose operation information
+      should be returned.
+      @private
     */
+    _findArrayOperation: function (index) {
+      var split = false;
+      var arrayOperationIndex, arrayOperation,
+          arrayOperationRangeStart, arrayOperationRangeEnd,
+          len;
 
-    var compile;
-    var compileOptions = __dependency1__["default"];
-    var template = __dependency2__["default"];
+      // OPTIMIZE: we could search these faster if we kept a balanced tree.
+      // find leftmost arrayOperation to the right of `index`
+      for (arrayOperationIndex = arrayOperationRangeStart = 0, len = this._operations.length; arrayOperationIndex < len; ++arrayOperationIndex) {
+        arrayOperation = this._operations[arrayOperationIndex];
 
-    /**
-      Uses HTMLBars `compile` function to process a string into a compiled template.
+        if (arrayOperation.type === DELETE) { continue; }
 
-      This is not present in production builds.
+        arrayOperationRangeEnd = arrayOperationRangeStart + arrayOperation.count - 1;
 
-      @private
-      @method compile
-      @param {String} templateString This is the string to be compiled by HTMLBars.
-    */
-    __exports__["default"] = function(templateString) {
-      if (!compile && Ember.__loader.registry['htmlbars-compiler/compiler']) {
-        compile = requireModule('htmlbars-compiler/compiler').compile;
+        if (index === arrayOperationRangeStart) {
+          break;
+        } else if (index > arrayOperationRangeStart && index <= arrayOperationRangeEnd) {
+          split = true;
+          break;
+        } else {
+          arrayOperationRangeStart = arrayOperationRangeEnd + 1;
+        }
       }
 
-      if (!compile) {
-        throw new Error('Cannot call `compile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compile`.');
-      }
+      return new ArrayOperationMatch(arrayOperation, arrayOperationIndex, split, arrayOperationRangeStart);
+    },
 
-      var templateSpec = compile(templateString, compileOptions());
+    _split: function (arrayOperationIndex, splitIndex, newArrayOperation) {
+      var arrayOperation = this._operations[arrayOperationIndex];
+      var splitItems = arrayOperation.items.slice(splitIndex);
+      var splitArrayOperation = new ArrayOperation(arrayOperation.type, splitItems.length, splitItems);
 
-      return template(templateSpec);
-    }
-  });
-enifed("ember-template-compiler/system/compile_options",
-  ["ember-metal/core","ember-template-compiler/plugins","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-template-compiler
-    */
+      // truncate LHS
+      arrayOperation.count = splitIndex;
+      arrayOperation.items = arrayOperation.items.slice(0, splitIndex);
 
-    var Ember = __dependency1__["default"];
-    var plugins = __dependency2__["default"];
+      this._operations.splice(arrayOperationIndex + 1, 0, newArrayOperation, splitArrayOperation);
+    },
 
-    /**
-      @private
-      @property compileOptions
-    */
-    __exports__["default"] = function() {
-      var disableComponentGeneration = true;
-      
-      return {
-        disableComponentGeneration: disableComponentGeneration,
+    // see SubArray for a better implementation.
+    _composeInsert: function (index) {
+      var newArrayOperation = this._operations[index];
+      var leftArrayOperation = this._operations[index-1]; // may be undefined
+      var rightArrayOperation = this._operations[index+1]; // may be undefined
+      var leftOp = leftArrayOperation && leftArrayOperation.type;
+      var rightOp = rightArrayOperation && rightArrayOperation.type;
 
-        plugins: plugins
-      };
-    }
-  });
-enifed("ember-template-compiler/system/precompile",
-  ["ember-template-compiler/system/compile_options","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-template-compiler
-    */
+      if (leftOp === INSERT) {
+        // merge left
+        leftArrayOperation.count += newArrayOperation.count;
+        leftArrayOperation.items = leftArrayOperation.items.concat(newArrayOperation.items);
+
+        if (rightOp === INSERT) {
+          // also merge right (we have split an insert with an insert)
+          leftArrayOperation.count += rightArrayOperation.count;
+          leftArrayOperation.items = leftArrayOperation.items.concat(rightArrayOperation.items);
+          this._operations.splice(index, 2);
+        } else {
+          // only merge left
+          this._operations.splice(index, 1);
+        }
+      } else if (rightOp === INSERT) {
+        // merge right
+        newArrayOperation.count += rightArrayOperation.count;
+        newArrayOperation.items = newArrayOperation.items.concat(rightArrayOperation.items);
+        this._operations.splice(index + 1, 1);
+      }
+    },
+
+    _composeDelete: function (index) {
+      var arrayOperation = this._operations[index];
+      var deletesToGo = arrayOperation.count;
+      var leftArrayOperation = this._operations[index-1]; // may be undefined
+      var leftOp = leftArrayOperation && leftArrayOperation.type;
+      var nextArrayOperation;
+      var nextOp;
+      var nextCount;
+      var removeNewAndNextOp = false;
+      var removedItems = [];
+
+      if (leftOp === DELETE) {
+        arrayOperation = leftArrayOperation;
+        index -= 1;
+      }
+
+      for (var i = index + 1; deletesToGo > 0; ++i) {
+        nextArrayOperation = this._operations[i];
+        nextOp = nextArrayOperation.type;
+        nextCount = nextArrayOperation.count;
+
+        if (nextOp === DELETE) {
+          arrayOperation.count += nextCount;
+          continue;
+        }
 
-    var compileOptions = __dependency1__["default"];
-    var compileSpec;
+        if (nextCount > deletesToGo) {
+          // d:2 {r,i}:5  we reduce the retain or insert, but it stays
+          removedItems = removedItems.concat(nextArrayOperation.items.splice(0, deletesToGo));
+          nextArrayOperation.count -= deletesToGo;
 
-    /**
-      Uses HTMLBars `compile` function to process a string into a compiled template string.
-      The returned string must be passed through `Ember.HTMLBars.template`.
+          // In the case where we truncate the last arrayOperation, we don't need to
+          // remove it; also the deletesToGo reduction is not the entirety of
+          // nextCount
+          i -= 1;
+          nextCount = deletesToGo;
 
-      This is not present in production builds.
+          deletesToGo = 0;
+        } else {
+          if (nextCount === deletesToGo) {
+            // Handle edge case of d:2 i:2 in which case both operations go away
+            // during composition.
+            removeNewAndNextOp = true;
+          }
+          removedItems = removedItems.concat(nextArrayOperation.items);
+          deletesToGo -= nextCount;
+        }
 
-      @private
-      @method precompile
-      @param {String} templateString This is the string to be compiled by HTMLBars.
-    */
-    __exports__["default"] = function(templateString) {
-      if (!compileSpec && Ember.__loader.registry['htmlbars-compiler/compiler']) {
-        compileSpec = requireModule('htmlbars-compiler/compiler').compileSpec;
+        if (nextOp === INSERT) {
+          // d:2 i:3 will result in delete going away
+          arrayOperation.count -= nextCount;
+        }
       }
 
-      if (!compileSpec) {
-        throw new Error('Cannot call `compileSpec` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compileSpec`.');
+      if (arrayOperation.count > 0) {
+        // compose our new delete with possibly several operations to the right of
+        // disparate types
+        this._operations.splice(index+1, i-1-index);
+      } else {
+        // The delete operation can go away; it has merely reduced some other
+        // operation, as in d:3 i:4; it may also have eliminated that operation,
+        // as in d:3 i:3.
+        this._operations.splice(index, removeNewAndNextOp ? 2 : 1);
       }
 
-      return compileSpec(templateString, compileOptions());
-    }
-  });
-enifed("ember-template-compiler/system/template",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-template-compiler
-    */
+      return removedItems;
+    },
 
-    /**
-      Augments the detault precompiled output of an HTMLBars template with
-      additional information needed by Ember.
+    toString: function () {
+      var str = "";
+      enumerable_utils.forEach(this._operations, function (operation) {
+        str += " " + operation.type + ":" + operation.count;
+      });
+      return str.substring(1);
+    }
+  };
+
+  /**
+    Internal data structure to represent an array operation.
+
+    @method ArrayOperation
+    @private
+    @param {String} type The type of the operation.  One of
+    `Ember.TrackedArray.{RETAIN, INSERT, DELETE}`
+    @param {Number} count The number of items in this operation.
+    @param {Array} items The items of the operation, if included.  RETAIN and
+    INSERT include their items, DELETE does not.
+  */
+  function ArrayOperation(operation, count, items) {
+    this.type = operation; // RETAIN | INSERT | DELETE
+    this.count = count;
+    this.items = items;
+  }
 
-      @private
-      @method template
-      @param {Function} templateSpec This is the compiled HTMLBars template spec.
-    */
+  /**
+    Internal data structure used to include information when looking up operations
+    by item index.
+
+    @method ArrayOperationMatch
+    @private
+    @param {ArrayOperation} operation
+    @param {Number} index The index of `operation` in the array of operations.
+    @param {Boolean} split Whether or not the item index searched for would
+    require a split for a new operation type.
+    @param {Number} rangeStart The index of the first item in the operation,
+    with respect to the tracked array.  The index of the last item can be computed
+    from `rangeStart` and `operation.count`.
+  */
+  function ArrayOperationMatch(operation, index, split, rangeStart) {
+    this.operation = operation;
+    this.index = index;
+    this.split = split;
+    this.rangeStart = rangeStart;
+  }
 
-    __exports__["default"] = function(templateSpec) {
-      templateSpec.isTop = true;
-      templateSpec.isMethod = false;
+});
+enifed('ember-template-compiler', ['exports', 'ember-metal/core', 'ember-template-compiler/system/precompile', 'ember-template-compiler/system/compile', 'ember-template-compiler/system/template', 'ember-template-compiler/plugins', 'ember-template-compiler/plugins/transform-each-in-to-hash', 'ember-template-compiler/plugins/transform-with-as-to-hash', 'ember-template-compiler/compat'], function (exports, _Ember, precompile, compile, template, plugins, TransformEachInToHash, TransformWithAsToHash) {
 
-      return templateSpec;
-    }
-  });
-enifed("ember-testing",
-  ["ember-metal/core","ember-testing/initializers","ember-testing/support","ember-testing/setup_for_testing","ember-testing/test","ember-testing/adapters/adapter","ember-testing/adapters/qunit","ember-testing/helpers"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
+  'use strict';
 
-    // to setup initializer
-         // to handle various edge cases
+  plugins.registerPlugin('ast', TransformWithAsToHash['default']);
+  plugins.registerPlugin('ast', TransformEachInToHash['default']);
 
-    var setupForTesting = __dependency4__["default"];
-    var Test = __dependency5__["default"];
-    var Adapter = __dependency6__["default"];
-    var QUnitAdapter = __dependency7__["default"];
-         // adds helpers to helpers object in Test
+  exports._Ember = _Ember['default'];
+  exports.precompile = precompile['default'];
+  exports.compile = compile['default'];
+  exports.template = template['default'];
+  exports.registerPlugin = plugins.registerPlugin;
 
-    /**
-      Ember Testing
+});
+enifed('ember-template-compiler/compat', ['ember-metal/core', 'ember-template-compiler/compat/precompile', 'ember-template-compiler/system/compile', 'ember-template-compiler/system/template'], function (Ember, precompile, compile, template) {
 
-      @module ember
-      @submodule ember-testing
-      @requires ember-application
-    */
+	'use strict';
 
-    Ember.Test = Test;
-    Ember.Test.Adapter = Adapter;
-    Ember.Test.QUnitAdapter = QUnitAdapter;
-    Ember.setupForTesting = setupForTesting;
-  });
-enifed("ember-testing/adapters/adapter",
-  ["ember-runtime/system/object","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var EmberObject = __dependency1__["default"];
+	var EmberHandlebars = Ember['default'].Handlebars = Ember['default'].Handlebars || {};
 
-    function K() { return this; }
+	EmberHandlebars.precompile = precompile['default'];
+	EmberHandlebars.compile = compile['default'];
+	EmberHandlebars.template = template['default'];
 
-    /**
-     @module ember
-     @submodule ember-testing
-    */
+});
+enifed('ember-template-compiler/compat/precompile', ['exports', 'ember-template-compiler/system/compile_options'], function (exports, compileOptions) {
 
-    /**
-      The primary purpose of this class is to create hooks that can be implemented
-      by an adapter for various test frameworks.
+  'use strict';
 
-      @class Adapter
-      @namespace Ember.Test
-    */
-    var Adapter = EmberObject.extend({
-      /**
-        This callback will be called whenever an async operation is about to start.
+  /**
+  @module ember
+  @submodule ember-template-compiler
+  */
+  var compile, compileSpec;
 
-        Override this to call your framework's methods that handle async
-        operations.
+  exports['default'] = function(string) {
+    if ((!compile || !compileSpec) && Ember.__loader.registry['htmlbars-compiler/compiler']) {
+      var Compiler = requireModule('htmlbars-compiler/compiler');
 
-        @public
-        @method asyncStart
-      */
-      asyncStart: K,
+      compile = Compiler.compile;
+      compileSpec = Compiler.compileSpec;
+    }
 
-      /**
-        This callback will be called whenever an async operation has completed.
+    if (!compile || !compileSpec) {
+      throw new Error('Cannot call `precompile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `precompile`.');
+    }
 
-        @public
-        @method asyncEnd
-      */
-      asyncEnd: K,
+    var asObject = arguments[1] === undefined ? true : arguments[1];
+    var compileFunc = asObject ? compile : compileSpec;
 
-      /**
-        Override this method with your testing framework's false assertion.
-        This function is called whenever an exception occurs causing the testing
-        promise to fail.
+    return compileFunc(string, compileOptions['default']());
+  }
 
-        QUnit example:
+});
+enifed('ember-template-compiler/plugins', ['exports'], function (exports) {
 
-        ```javascript
-          exception: function(error) {
-            ok(false, error);
-          };
-        ```
+  'use strict';
 
-        @public
-        @method exception
-        @param {String} error The exception to be raised.
-      */
-      exception: function(error) {
-        throw error;
-      }
-    });
+  exports.registerPlugin = registerPlugin;
 
-    __exports__["default"] = Adapter;
-  });
-enifed("ember-testing/adapters/qunit",
-  ["ember-testing/adapters/adapter","ember-metal/utils","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var Adapter = __dependency1__["default"];
-    var inspect = __dependency2__.inspect;
+  /**
+  @module ember
+  @submodule ember-template-compiler
+  */
 
-    /**
-      This class implements the methods defined by Ember.Test.Adapter for the
-      QUnit testing framework.
+  /**
+   @private
+   @property helpers
+  */
+  var plugins = {
+    ast: []
+  };
 
-      @class QUnitAdapter
-      @namespace Ember.Test
-      @extends Ember.Test.Adapter
-    */
-    __exports__["default"] = Adapter.extend({
-      asyncStart: function() {
-        QUnit.stop();
-      },
-      asyncEnd: function() {
-        QUnit.start();
-      },
-      exception: function(error) {
-        ok(false, inspect(error));
-      }
-    });
-  });
-enifed("ember-testing/helpers",
-  ["ember-metal/property_get","ember-metal/error","ember-metal/run_loop","ember-views/system/jquery","ember-testing/test"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) {
-    "use strict";
-    var get = __dependency1__.get;
-    var EmberError = __dependency2__["default"];
-    var run = __dependency3__["default"];
-    var jQuery = __dependency4__["default"];
-    var Test = __dependency5__["default"];
+  /**
+    Adds an AST plugin to be used by Ember.HTMLBars.compile.
 
-    /**
-    * @module ember
-    * @submodule ember-testing
-    */
+    @private
+    @method registerASTPlugin
+  */
+  function registerPlugin(type, Plugin) {
+    if (!plugins[type]) {
+      throw new Error('Attempting to register "' + Plugin + '" as "' + type + '" which is not a valid HTMLBars plugin type.');
+    }
 
-    var helper = Test.registerHelper;
-    var asyncHelper = Test.registerAsyncHelper;
-    var countAsync = 0;
+    plugins[type].push(Plugin);
+  }
 
-    function currentRouteName(app){
-      var appController = app.__container__.lookup('controller:application');
+  exports['default'] = plugins;
 
-      return get(appController, 'currentRouteName');
-    }
+});
+enifed('ember-template-compiler/plugins/transform-each-in-to-hash', ['exports'], function (exports) {
 
-    function currentPath(app){
-      var appController = app.__container__.lookup('controller:application');
+  'use strict';
 
-      return get(appController, 'currentPath');
-    }
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-    function currentURL(app){
-      var router = app.__container__.lookup('router:main');
 
-      return get(router, 'location').getURL();
-    }
+  /**
+    An HTMLBars AST transformation that replaces all instances of
 
-    function pauseTest(){
-      Test.adapter.asyncStart();
-      return new Ember.RSVP.Promise(function(){ }, 'TestAdapter paused promise');
-    }
+    ```handlebars
+    {{#each item in items}}
+    {{/each}}
+    ```
 
-    function visit(app, url) {
-      var router = app.__container__.lookup('router:main');
-      router.location.setURL(url);
+    with
 
-      if (app._readinessDeferrals > 0) {
-        router['initialURL'] = url;
-        run(app, 'advanceReadiness');
-        delete router['initialURL'];
-      } else {
-        run(app, app.handleURL, url);
-      }
+    ```handlebars
+    {{#each items keyword="item"}}
+    {{/each}}
+    ```
 
-      return app.testHelpers.wait();
-    }
+    @class TransformEachInToHash
+    @private
+  */
+  function TransformEachInToHash() {
+    // set later within HTMLBars to the syntax package
+    this.syntax = null;
+  }
 
-    function click(app, selector, context) {
-      var $el = app.testHelpers.findWithAssert(selector, context);
-      run($el, 'mousedown');
+  /**
+    @private
+    @method transform
+    @param {AST} The AST to be transformed.
+  */
+  TransformEachInToHash.prototype.transform = function TransformEachInToHash_transform(ast) {
+    var pluginContext = this;
+    var walker = new pluginContext.syntax.Walker();
+    var b = pluginContext.syntax.builders;
 
-      if ($el.is(':input, [contenteditable=true]')) {
-        var type = $el.prop('type');
-        if (type !== 'checkbox' && type !== 'radio' && type !== 'hidden') {
-          run($el, function(){
-            // Firefox does not trigger the `focusin` event if the window
-            // does not have focus. If the document doesn't have focus just
-            // use trigger('focusin') instead.
-            if (!document.hasFocus || document.hasFocus()) {
-              this.focus();
-            } else {
-              this.trigger('focusin');
-            }
-          });
+    walker.visit(ast, function(node) {
+      if (pluginContext.validate(node)) {
+
+        if (node.program && node.program.blockParams.length) {
+          throw new Error('You cannot use keyword (`{{each foo in bar}}`) and block params (`{{each bar as |foo|}}`) at the same time.');
+        }
+
+        var removedParams = node.sexpr.params.splice(0, 2);
+        var keyword = removedParams[0].original;
+
+        // TODO: This may not be necessary.
+        if (!node.sexpr.hash) {
+          node.sexpr.hash = b.hash();
         }
+
+        node.sexpr.hash.pairs.push(b.pair(
+          'keyword',
+          b.string(keyword)
+        ));
       }
+    });
 
-      run($el, 'mouseup');
-      run($el, 'click');
+    return ast;
+  };
 
-      return app.testHelpers.wait();
-    }
+  TransformEachInToHash.prototype.validate = function TransformEachInToHash_validate(node) {
+    return (node.type === 'BlockStatement' || node.type === 'MustacheStatement') &&
+      node.sexpr.path.original === 'each' &&
+      node.sexpr.params.length === 3 &&
+      node.sexpr.params[1].type === 'PathExpression' &&
+      node.sexpr.params[1].original === 'in';
+  };
 
-    function triggerEvent(app, selector, contextOrType, typeOrOptions, possibleOptions){
-      var arity = arguments.length;
-      var context, type, options;
+  exports['default'] = TransformEachInToHash;
 
-      if (arity === 3) {
-        // context and options are optional, so this is
-        // app, selector, type
-        context = null;
-        type = contextOrType;
-        options = {};
-      } else if (arity === 4) {
-        // context and options are optional, so this is
-        if (typeof typeOrOptions === "object") {  // either
-          // app, selector, type, options
-          context = null;
-          type = contextOrType;
-          options = typeOrOptions;
-        } else { // or
-          // app, selector, context, type
-          context = contextOrType;
-          type = typeOrOptions;
-          options = {};
-        }
-      } else {
-        context = contextOrType;
-        type = typeOrOptions;
-        options = possibleOptions;
-      }
+});
+enifed('ember-template-compiler/plugins/transform-with-as-to-hash', ['exports'], function (exports) {
+
+  'use strict';
+
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
+
+  /**
+    An HTMLBars AST transformation that replaces all instances of
 
-      var $el = app.testHelpers.findWithAssert(selector, context);
+    ```handlebars
+    {{#with foo.bar as bar}}
+    {{/with}}
+    ```
 
-      var event = jQuery.Event(type, options);
+    with
 
-      run($el, 'trigger', event);
+    ```handlebars
+    {{#with foo.bar as |bar|}}
+    {{/with}}
+    ```
 
-      return app.testHelpers.wait();
-    }
+    @private
+    @class TransformWithAsToHash
+  */
+  function TransformWithAsToHash() {
+    // set later within HTMLBars to the syntax package
+    this.syntax = null;
+  }
 
-    function keyEvent(app, selector, contextOrType, typeOrKeyCode, keyCode) {
-      var context, type;
+  /**
+    @private
+    @method transform
+    @param {AST} The AST to be transformed.
+  */
+  TransformWithAsToHash.prototype.transform = function TransformWithAsToHash_transform(ast) {
+    var pluginContext = this;
+    var walker = new pluginContext.syntax.Walker();
 
-      if (typeof keyCode === 'undefined') {
-        context = null;
-        keyCode = typeOrKeyCode;
-        type = contextOrType;
-      } else {
-        context = contextOrType;
-        type = typeOrKeyCode;
-      }
+    walker.visit(ast, function(node) {
+      if (pluginContext.validate(node)) {
 
-      return app.testHelpers.triggerEvent(selector, context, type, { keyCode: keyCode, which: keyCode });
-    }
+        if (node.program && node.program.blockParams.length) {
+          throw new Error('You cannot use keyword (`{{with foo as bar}}`) and block params (`{{with foo as |bar|}}`) at the same time.');
+        }
 
-    function fillIn(app, selector, contextOrText, text) {
-      var $el, context;
-      if (typeof text === 'undefined') {
-        text = contextOrText;
-      } else {
-        context = contextOrText;
+        var removedParams = node.sexpr.params.splice(1, 2);
+        var keyword = removedParams[1].original;
+        node.program.blockParams = [keyword];
       }
-      $el = app.testHelpers.findWithAssert(selector, context);
-      run(function() {
-        $el.val(text).change();
-      });
-      return app.testHelpers.wait();
-    }
+    });
 
-    function findWithAssert(app, selector, context) {
-      var $el = app.testHelpers.find(selector, context);
-      if ($el.length === 0) {
-        throw new EmberError("Element " + selector + " not found.");
-      }
-      return $el;
-    }
+    return ast;
+  };
 
-    function find(app, selector, context) {
-      var $el;
-      context = context || get(app, 'rootElement');
-      $el = app.$(selector, context);
+  TransformWithAsToHash.prototype.validate = function TransformWithAsToHash_validate(node) {
+    return node.type === 'BlockStatement' &&
+      node.sexpr.path.original === 'with' &&
+      node.sexpr.params.length === 3 &&
+      node.sexpr.params[1].type === 'PathExpression' &&
+      node.sexpr.params[1].original === 'as';
+  };
 
-      return $el;
-    }
+  exports['default'] = TransformWithAsToHash;
 
-    function andThen(app, callback) {
-      return app.testHelpers.wait(callback(app));
-    }
+});
+enifed('ember-template-compiler/system/compile', ['exports', 'ember-template-compiler/system/compile_options', 'ember-template-compiler/system/template'], function (exports, compileOptions, template) {
 
-    function wait(app, value) {
-      return Test.promise(function(resolve) {
-        // If this is the first async promise, kick off the async test
-        if (++countAsync === 1) {
-          Test.adapter.asyncStart();
-        }
-
-        // Every 10ms, poll for the async thing to have finished
-        var watcher = setInterval(function() {
-          var router = app.__container__.lookup('router:main');
-
-          // 1. If the router is loading, keep polling
-          var routerIsLoading = router.router && !!router.router.activeTransition;
-          if (routerIsLoading) { return; }
-
-          // 2. If there are pending Ajax requests, keep polling
-          if (Test.pendingAjaxRequests) { return; }
-
-          // 3. If there are scheduled timers or we are inside of a run loop, keep polling
-          if (run.hasScheduledTimers() || run.currentRunLoop) { return; }
-          if (Test.waiters && Test.waiters.any(function(waiter) {
-            var context = waiter[0];
-            var callback = waiter[1];
-            return !callback.call(context);
-          })) { return; }
-          // Stop polling
-          clearInterval(watcher);
-
-          // If this is the last async promise, end the async test
-          if (--countAsync === 0) {
-            Test.adapter.asyncEnd();
-          }
+  'use strict';
 
-          // Synchronously resolve the promise
-          run(null, resolve, value);
-        }, 10);
-      });
-
-    }
-
-
-    /**
-    * Loads a route, sets up any controllers, and renders any templates associated
-    * with the route as though a real user had triggered the route change while
-    * using your app.
-    *
-    * Example:
-    *
-    * ```javascript
-    * visit('posts/index').then(function() {
-    *   // assert something
-    * });
-    * ```
-    *
-    * @method visit
-    * @param {String} url the name of the route
-    * @return {RSVP.Promise}
-    */
-    asyncHelper('visit', visit);
-
-    /**
-    * Clicks an element and triggers any actions triggered by the element's `click`
-    * event.
-    *
-    * Example:
-    *
-    * ```javascript
-    * click('.some-jQuery-selector').then(function() {
-    *   // assert something
-    * });
-    * ```
-    *
-    * @method click
-    * @param {String} selector jQuery selector for finding element on the DOM
-    * @return {RSVP.Promise}
-    */
-    asyncHelper('click', click);
-
-    /**
-    * Simulates a key event, e.g. `keypress`, `keydown`, `keyup` with the desired keyCode
-    *
-    * Example:
-    *
-    * ```javascript
-    * keyEvent('.some-jQuery-selector', 'keypress', 13).then(function() {
-    *  // assert something
-    * });
-    * ```
-    *
-    * @method keyEvent
-    * @param {String} selector jQuery selector for finding element on the DOM
-    * @param {String} type the type of key event, e.g. `keypress`, `keydown`, `keyup`
-    * @param {Number} keyCode the keyCode of the simulated key event
-    * @return {RSVP.Promise}
-    * @since 1.5.0
-    */
-    asyncHelper('keyEvent', keyEvent);
-
-    /**
-    * Fills in an input element with some text.
-    *
-    * Example:
-    *
-    * ```javascript
-    * fillIn('#email', 'you@example.com').then(function() {
-    *   // assert something
-    * });
-    * ```
-    *
-    * @method fillIn
-    * @param {String} selector jQuery selector finding an input element on the DOM
-    * to fill text with
-    * @param {String} text text to place inside the input element
-    * @return {RSVP.Promise}
-    */
-    asyncHelper('fillIn', fillIn);
-
-    /**
-    * Finds an element in the context of the app's container element. A simple alias
-    * for `app.$(selector)`.
-    *
-    * Example:
-    *
-    * ```javascript
-    * var $el = find('.my-selector');
-    * ```
-    *
-    * @method find
-    * @param {String} selector jQuery string selector for element lookup
-    * @return {Object} jQuery object representing the results of the query
-    */
-    helper('find', find);
-
-    /**
-    * Like `find`, but throws an error if the element selector returns no results.
-    *
-    * Example:
-    *
-    * ```javascript
-    * var $el = findWithAssert('.doesnt-exist'); // throws error
-    * ```
-    *
-    * @method findWithAssert
-    * @param {String} selector jQuery selector string for finding an element within
-    * the DOM
-    * @return {Object} jQuery object representing the results of the query
-    * @throws {Error} throws error if jQuery object returned has a length of 0
-    */
-    helper('findWithAssert', findWithAssert);
-
-    /**
-      Causes the run loop to process any pending events. This is used to ensure that
-      any async operations from other helpers (or your assertions) have been processed.
-
-      This is most often used as the return value for the helper functions (see 'click',
-      'fillIn','visit',etc).
+  /**
+  @module ember
+  @submodule ember-template-compiler
+  */
 
-      Example:
+  var compile;
+  exports['default'] = function(templateString) {
+    if (!compile && Ember.__loader.registry['htmlbars-compiler/compiler']) {
+      compile = requireModule('htmlbars-compiler/compiler').compile;
+    }
 
-      ```javascript
-      Ember.Test.registerAsyncHelper('loginUser', function(app, username, password) {
-        visit('secured/path/here')
-        .fillIn('#username', username)
-        .fillIn('#password', password)
-        .click('.submit')
+    if (!compile) {
+      throw new Error('Cannot call `compile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compile`.');
+    }
 
-        return app.testHelpers.wait();
-      });
+    var templateSpec = compile(templateString, compileOptions['default']());
 
-      @method wait
-      @param {Object} value The value to be returned.
-      @return {RSVP.Promise}
-    */
-    asyncHelper('wait', wait);
-    asyncHelper('andThen', andThen);
+    return template['default'](templateSpec);
+  }
 
+});
+enifed('ember-template-compiler/system/compile_options', ['exports', 'ember-metal/core', 'ember-template-compiler/plugins'], function (exports, Ember, plugins) {
 
-    /**
-      Returns the currently active route name.
+  'use strict';
 
-    Example:
+  /**
+  @module ember
+  @submodule ember-template-compiler
+  */
 
-    ```javascript
-    function validateRouteName(){
-    equal(currentRouteName(), 'some.path', "correct route was transitioned into.");
-    }
+  exports['default'] = function() {
+    var disableComponentGeneration = true;
 
-    visit('/some/path').then(validateRouteName)
-    ```
+    return {
+      revision: 'Ember@1.11.0',
 
-    @method currentRouteName
-    @return {Object} The name of the currently active route.
-    @since 1.5.0
-    */
-    helper('currentRouteName', currentRouteName);
+      disableComponentGeneration: disableComponentGeneration,
 
-    /**
-      Returns the current path.
+      plugins: plugins['default']
+    };
+  }
 
-    Example:
+});
+enifed('ember-template-compiler/system/precompile', ['exports', 'ember-template-compiler/system/compile_options'], function (exports, compileOptions) {
 
-    ```javascript
-    function validateURL(){
-    equal(currentPath(), 'some.path.index', "correct path was transitioned into.");
-    }
+  'use strict';
 
-    click('#some-link-id').then(validateURL);
-    ```
+  /**
+  @module ember
+  @submodule ember-template-compiler
+  */
 
-    @method currentPath
-    @return {Object} The currently active path.
-    @since 1.5.0
-    */
-    helper('currentPath', currentPath);
+  var compileSpec;
 
-    /**
-      Returns the current URL.
+  /**
+    Uses HTMLBars `compile` function to process a string into a compiled template string.
+    The returned string must be passed through `Ember.HTMLBars.template`.
 
-    Example:
+    This is not present in production builds.
 
-    ```javascript
-    function validateURL(){
-    equal(currentURL(), '/some/path', "correct URL was transitioned into.");
+    @private
+    @method precompile
+    @param {String} templateString This is the string to be compiled by HTMLBars.
+  */
+  exports['default'] = function(templateString) {
+    if (!compileSpec && Ember.__loader.registry['htmlbars-compiler/compiler']) {
+      compileSpec = requireModule('htmlbars-compiler/compiler').compileSpec;
     }
 
-    click('#some-link-id').then(validateURL);
-    ```
+    if (!compileSpec) {
+      throw new Error('Cannot call `compileSpec` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compileSpec`.');
+    }
 
-    @method currentURL
-    @return {Object} The currently active URL.
-    @since 1.5.0
-    */
-    helper('currentURL', currentURL);
+    return compileSpec(templateString, compileOptions['default']());
+  }
 
-    
-      /**
-       Pauses the current test - this is useful for debugging while testing or for test-driving.
-       It allows you to inspect the state of your application at any point.
+});
+enifed('ember-template-compiler/system/template', ['exports'], function (exports) {
 
-       Example (The test will pause before clicking the button):
+  'use strict';
 
-       ```javascript
-       visit('/')
-       return pauseTest();
+  /**
+  @module ember
+  @submodule ember-template-compiler
+  */
 
-       click('.btn');
-       ```
+  /**
+    Augments the default precompiled output of an HTMLBars template with
+    additional information needed by Ember.
 
-       @since 1.9.0
-       @method pauseTest
-       @return {Object} A promise that will never resolve
-       */
-      helper('pauseTest', pauseTest);
-    
+    @private
+    @method template
+    @param {Function} templateSpec This is the compiled HTMLBars template spec.
+  */
 
-    /**
-      Triggers the given DOM event on the element identified by the provided selector.
+  exports['default'] = function(templateSpec) {
+    templateSpec.isTop = true;
+    templateSpec.isMethod = false;
 
-      Example:
+    return templateSpec;
+  }
 
-      ```javascript
-      triggerEvent('#some-elem-id', 'blur');
-      ```
+});
+enifed('ember-testing', ['ember-metal/core', 'ember-testing/initializers', 'ember-testing/support', 'ember-testing/setup_for_testing', 'ember-testing/test', 'ember-testing/adapters/adapter', 'ember-testing/adapters/qunit', 'ember-testing/helpers'], function (Ember, __dep1__, __dep2__, setupForTesting, Test, Adapter, QUnitAdapter) {
 
-      This is actually used internally by the `keyEvent` helper like so:
+  'use strict';
 
-      ```javascript
-      triggerEvent('#some-elem-id', 'keypress', { keyCode: 13 });
-      ```
+  Ember['default'].Test = Test['default'];
+  Ember['default'].Test.Adapter = Adapter['default'];
+  Ember['default'].Test.QUnitAdapter = QUnitAdapter['default'];
+  Ember['default'].setupForTesting = setupForTesting['default'];
 
-     @method triggerEvent
-     @param {String} selector jQuery selector for finding element on the DOM
-     @param {String} [context] jQuery selector that will limit the selector
-                               argument to find only within the context's children
-     @param {String} type The event type to be triggered.
-     @param {Object} [options] The options to be passed to jQuery.Event.
-     @return {RSVP.Promise}
-     @since 1.5.0
-    */
-    asyncHelper('triggerEvent', triggerEvent);
-  });
-enifed("ember-testing/initializers",
-  ["ember-runtime/system/lazy_load"],
-  function(__dependency1__) {
-    "use strict";
-    var onLoad = __dependency1__.onLoad;
+});
+enifed('ember-testing/adapters/adapter', ['exports', 'ember-runtime/system/object'], function (exports, EmberObject) {
 
-    var name = 'deferReadiness in `testing` mode';
+  'use strict';
 
-    onLoad('Ember.Application', function(Application) {
-      if (!Application.initializers[name]) {
-        Application.initializer({
-          name: name,
+  function K() { return this; }
 
-          initialize: function(container, application){
-            if (application.testing) {
-              application.deferReadiness();
-            }
-          }
-        });
-      }
-    });
-  });
-enifed("ember-testing/setup_for_testing",
-  ["ember-metal/core","ember-testing/adapters/qunit","ember-views/system/jquery","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // import Test from "ember-testing/test";  // ES6TODO: fix when cycles are supported
-    var QUnitAdapter = __dependency2__["default"];
-    var jQuery = __dependency3__["default"];
+  /**
+   @module ember
+   @submodule ember-testing
+  */
 
-    var Test, requests;
+  /**
+    The primary purpose of this class is to create hooks that can be implemented
+    by an adapter for various test frameworks.
 
-    function incrementAjaxPendingRequests(_, xhr){
-      requests.push(xhr);
-      Test.pendingAjaxRequests = requests.length;
-    }
+    @class Adapter
+    @namespace Ember.Test
+  */
+  var Adapter = EmberObject['default'].extend({
+    /**
+      This callback will be called whenever an async operation is about to start.
 
-    function decrementAjaxPendingRequests(_, xhr){
-      for (var i=0;i<requests.length;i++) {
-        if (xhr === requests[i]) {
-          requests.splice(i, 1);
-        }
-      }
-      Test.pendingAjaxRequests = requests.length;
-    }
+      Override this to call your framework's methods that handle async
+      operations.
 
-    /**
-      Sets Ember up for testing. This is useful to perform
-      basic setup steps in order to unit test.
+      @public
+      @method asyncStart
+    */
+    asyncStart: K,
 
-      Use `App.setupForTesting` to perform integration tests (full
-      application testing).
+    /**
+      This callback will be called whenever an async operation has completed.
 
-      @method setupForTesting
-      @namespace Ember
-      @since 1.5.0
+      @public
+      @method asyncEnd
     */
-    __exports__["default"] = function setupForTesting() {
-      if (!Test) { Test = requireModule('ember-testing/test')['default']; }
+    asyncEnd: K,
 
-      Ember.testing = true;
+    /**
+      Override this method with your testing framework's false assertion.
+      This function is called whenever an exception occurs causing the testing
+      promise to fail.
 
-      // if adapter is not manually set default to QUnit
-      if (!Test.adapter) {
-        Test.adapter = QUnitAdapter.create();
-      }
+      QUnit example:
 
-      requests = [];
-      Test.pendingAjaxRequests = requests.length;
+      ```javascript
+        exception: function(error) {
+          ok(false, error);
+        };
+      ```
 
-      jQuery(document).off('ajaxSend', incrementAjaxPendingRequests);
-      jQuery(document).off('ajaxComplete', decrementAjaxPendingRequests);
-      jQuery(document).on('ajaxSend', incrementAjaxPendingRequests);
-      jQuery(document).on('ajaxComplete', decrementAjaxPendingRequests);
+      @public
+      @method exception
+      @param {String} error The exception to be raised.
+    */
+    exception: function(error) {
+      throw error;
     }
   });
-enifed("ember-testing/support",
-  ["ember-metal/core","ember-views/system/jquery"],
-  function(__dependency1__, __dependency2__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var jQuery = __dependency2__["default"];
 
-    /**
-      @module ember
-      @submodule ember-testing
-     */
+  exports['default'] = Adapter;
 
-    var $ = jQuery;
+});
+enifed('ember-testing/adapters/qunit', ['exports', 'ember-testing/adapters/adapter', 'ember-metal/utils'], function (exports, Adapter, utils) {
 
-    /**
-      This method creates a checkbox and triggers the click event to fire the
-      passed in handler. It is used to correct for a bug in older versions
-      of jQuery (e.g 1.8.3).
+  'use strict';
 
-      @private
-      @method testCheckboxClick
-    */
-    function testCheckboxClick(handler) {
-      $('<input type="checkbox">')
-        .css({ position: 'absolute', left: '-1000px', top: '-1000px' })
-        .appendTo('body')
-        .on('click', handler)
-        .trigger('click')
-        .remove();
+  exports['default'] = Adapter['default'].extend({
+    asyncStart: function() {
+      QUnit.stop();
+    },
+    asyncEnd: function() {
+      QUnit.start();
+    },
+    exception: function(error) {
+      ok(false, utils.inspect(error));
     }
+  });
 
-    $(function() {
-      /*
-        Determine whether a checkbox checked using jQuery's "click" method will have
-        the correct value for its checked property.
-
-        If we determine that the current jQuery version exhibits this behavior,
-        patch it to work correctly as in the commit for the actual fix:
-        https://github.com/jquery/jquery/commit/1fb2f92.
-      */
-      testCheckboxClick(function() {
-        if (!this.checked && !$.event.special.click) {
-          $.event.special.click = {
-            // For checkbox, fire native event so checked state will be right
-            trigger: function() {
-              if ($.nodeName( this, "input" ) && this.type === "checkbox" && this.click) {
-                this.click();
-                return false;
-              }
-            }
-          };
-        }
-      });
+});
+enifed('ember-testing/helpers', ['ember-metal/core', 'ember-metal/property_get', 'ember-metal/error', 'ember-metal/run_loop', 'ember-views/system/jquery', 'ember-testing/test', 'ember-runtime/ext/rsvp'], function (Ember, property_get, EmberError, run, jQuery, Test, RSVP) {
 
-      // Try again to verify that the patch took effect or blow up.
-      testCheckboxClick(function() {
-        Ember.warn("clicked checkboxes should be checked! the jQuery patch didn't work", this.checked);
-      });
-    });
-  });
-enifed("ember-testing/test",
-  ["ember-metal/core","ember-metal/run_loop","ember-metal/platform","ember-runtime/ext/rsvp","ember-testing/setup_for_testing","ember-application/system/application","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var emberRun = __dependency2__["default"];
-    var create = __dependency3__.create;
-    var RSVP = __dependency4__["default"];
-    var setupForTesting = __dependency5__["default"];
-    var EmberApplication = __dependency6__["default"];
+  'use strict';
 
-    /**
-      @module ember
-      @submodule ember-testing
-     */
-    var slice = [].slice;
-    var helpers = {};
-    var injectHelpersCallbacks = [];
+  var helper = Test['default'].registerHelper;
+  var asyncHelper = Test['default'].registerAsyncHelper;
 
-    /**
-      This is a container for an assortment of testing related functionality:
+  function currentRouteName(app) {
+    var appController = app.__container__.lookup('controller:application');
 
-      * Choose your default test adapter (for your framework of choice).
-      * Register/Unregister additional test helpers.
-      * Setup callbacks to be fired when the test helpers are injected into
-        your application.
+    return property_get.get(appController, 'currentRouteName');
+  }
 
-      @class Test
-      @namespace Ember
-    */
-    var Test = {
-      /**
-        Hash containing all known test helpers.
+  function currentPath(app) {
+    var appController = app.__container__.lookup('controller:application');
 
-        @property _helpers
-        @private
-        @since 1.7.0
-      */
-      _helpers: helpers,
+    return property_get.get(appController, 'currentPath');
+  }
 
-      /**
-        `registerHelper` is used to register a test helper that will be injected
-        when `App.injectTestHelpers` is called.
+  function currentURL(app) {
+    var router = app.__container__.lookup('router:main');
 
-        The helper method will always be called with the current Application as
-        the first parameter.
+    return property_get.get(router, 'location').getURL();
+  }
 
-        For example:
+  function pauseTest() {
+    Test['default'].adapter.asyncStart();
+    return new Ember['default'].RSVP.Promise(function() { }, 'TestAdapter paused promise');
+  }
 
-        ```javascript
-        Ember.Test.registerHelper('boot', function(app) {
-          Ember.run(app, app.advanceReadiness);
+  function focus(el) {
+    if (el && el.is(':input, [contenteditable=true]')) {
+      var type = el.prop('type');
+      if (type !== 'checkbox' && type !== 'radio' && type !== 'hidden') {
+        run['default'](el, function() {
+          // Firefox does not trigger the `focusin` event if the window
+          // does not have focus. If the document doesn't have focus just
+          // use trigger('focusin') instead.
+          if (!document.hasFocus || document.hasFocus()) {
+            this.focus();
+          } else {
+            this.trigger('focusin');
+          }
         });
-        ```
+      }
+    }
+  }
 
-        This helper can later be called without arguments because it will be
-        called with `app` as the first parameter.
+  function visit(app, url) {
+    var router = app.__container__.lookup('router:main');
+    router.location.setURL(url);
 
-        ```javascript
-        App = Ember.Application.create();
-        App.injectTestHelpers();
-        boot();
-        ```
+    if (app._readinessDeferrals > 0) {
+      router['initialURL'] = url;
+      run['default'](app, 'advanceReadiness');
+      delete router['initialURL'];
+    } else {
+      run['default'](app.__deprecatedInstance__, 'handleURL', url);
+    }
 
-        @public
-        @method registerHelper
-        @param {String} name The name of the helper method to add.
-        @param {Function} helperMethod
-        @param options {Object}
-      */
-      registerHelper: function(name, helperMethod) {
-        helpers[name] = {
-          method: helperMethod,
-          meta: { wait: false }
-        };
-      },
+    return app.testHelpers.wait();
+  }
 
-      /**
-        `registerAsyncHelper` is used to register an async test helper that will be injected
-        when `App.injectTestHelpers` is called.
+  function click(app, selector, context) {
+    var $el = app.testHelpers.findWithAssert(selector, context);
+    run['default']($el, 'mousedown');
 
-        The helper method will always be called with the current Application as
-        the first parameter.
+    focus($el);
 
-        For example:
+    run['default']($el, 'mouseup');
+    run['default']($el, 'click');
 
-        ```javascript
-        Ember.Test.registerAsyncHelper('boot', function(app) {
-          Ember.run(app, app.advanceReadiness);
-        });
-        ```
+    return app.testHelpers.wait();
+  }
 
-        The advantage of an async helper is that it will not run
-        until the last async helper has completed.  All async helpers
-        after it will wait for it complete before running.
+  function check(app, selector, context) {
+    var $el = app.testHelpers.findWithAssert(selector, context);
+    var type = $el.prop('type');
 
+    Ember['default'].assert('To check \'' + selector +
+        '\', the input must be a checkbox', type === 'checkbox');
 
-        For example:
+    if (!$el.prop('checked')) {
+      app.testHelpers.click(selector, context);
+    }
 
-        ```javascript
-        Ember.Test.registerAsyncHelper('deletePost', function(app, postId) {
-          click('.delete-' + postId);
-        });
+    return app.testHelpers.wait();
+  }
 
-        // ... in your test
-        visit('/post/2');
-        deletePost(2);
-        visit('/post/3');
-        deletePost(3);
-        ```
+  function uncheck(app, selector, context) {
+    var $el = app.testHelpers.findWithAssert(selector, context);
+    var type = $el.prop('type');
 
-        @public
-        @method registerAsyncHelper
-        @param {String} name The name of the helper method to add.
-        @param {Function} helperMethod
-        @since 1.2.0
-      */
-      registerAsyncHelper: function(name, helperMethod) {
-        helpers[name] = {
-          method: helperMethod,
-          meta: { wait: true }
-        };
-      },
+    Ember['default'].assert('To uncheck \'' + selector +
+        '\', the input must be a checkbox', type === 'checkbox');
 
-      /**
-        Remove a previously added helper method.
+    if ($el.prop('checked')) {
+      app.testHelpers.click(selector, context);
+    }
 
-        Example:
+    return app.testHelpers.wait();
+  }
 
-        ```javascript
-        Ember.Test.unregisterHelper('wait');
-        ```
+  function triggerEvent(app, selector, contextOrType, typeOrOptions, possibleOptions) {
+    var arity = arguments.length;
+    var context, type, options;
+
+    if (arity === 3) {
+      // context and options are optional, so this is
+      // app, selector, type
+      context = null;
+      type = contextOrType;
+      options = {};
+    } else if (arity === 4) {
+      // context and options are optional, so this is
+      if (typeof typeOrOptions === "object") {  // either
+        // app, selector, type, options
+        context = null;
+        type = contextOrType;
+        options = typeOrOptions;
+      } else { // or
+        // app, selector, context, type
+        context = contextOrType;
+        type = typeOrOptions;
+        options = {};
+      }
+    } else {
+      context = contextOrType;
+      type = typeOrOptions;
+      options = possibleOptions;
+    }
 
-        @public
-        @method unregisterHelper
-        @param {String} name The helper to remove.
-      */
-      unregisterHelper: function(name) {
-        delete helpers[name];
-        delete Test.Promise.prototype[name];
-      },
+    var $el = app.testHelpers.findWithAssert(selector, context);
 
-      /**
-        Used to register callbacks to be fired whenever `App.injectTestHelpers`
-        is called.
+    var event = jQuery['default'].Event(type, options);
 
-        The callback will receive the current application as an argument.
+    run['default']($el, 'trigger', event);
 
-        Example:
+    return app.testHelpers.wait();
+  }
 
-        ```javascript
-        Ember.Test.onInjectHelpers(function() {
-          Ember.$(document).ajaxSend(function() {
-            Test.pendingAjaxRequests++;
-          });
+  function keyEvent(app, selector, contextOrType, typeOrKeyCode, keyCode) {
+    var context, type;
 
-          Ember.$(document).ajaxComplete(function() {
-            Test.pendingAjaxRequests--;
-          });
-        });
-        ```
+    if (typeof keyCode === 'undefined') {
+      context = null;
+      keyCode = typeOrKeyCode;
+      type = contextOrType;
+    } else {
+      context = contextOrType;
+      type = typeOrKeyCode;
+    }
 
-        @public
-        @method onInjectHelpers
-        @param {Function} callback The function to be called.
-      */
-      onInjectHelpers: function(callback) {
-        injectHelpersCallbacks.push(callback);
-      },
+    return app.testHelpers.triggerEvent(selector, context, type, { keyCode: keyCode, which: keyCode });
+  }
 
-      /**
-        This returns a thenable tailored for testing.  It catches failed
-        `onSuccess` callbacks and invokes the `Ember.Test.adapter.exception`
-        callback in the last chained then.
+  function fillIn(app, selector, contextOrText, text) {
+    var $el, context;
+    if (typeof text === 'undefined') {
+      text = contextOrText;
+    } else {
+      context = contextOrText;
+    }
+    $el = app.testHelpers.findWithAssert(selector, context);
+    focus($el);
+    run['default'](function() {
+      $el.val(text).change();
+    });
+    return app.testHelpers.wait();
+  }
 
-        This method should be returned by async helpers such as `wait`.
+  function findWithAssert(app, selector, context) {
+    var $el = app.testHelpers.find(selector, context);
+    if ($el.length === 0) {
+      throw new EmberError['default']("Element " + selector + " not found.");
+    }
+    return $el;
+  }
 
-        @public
-        @method promise
-        @param {Function} resolver The function used to resolve the promise.
-      */
-      promise: function(resolver) {
-        return new Test.Promise(resolver);
-      },
+  function find(app, selector, context) {
+    var $el;
+    context = context || property_get.get(app, 'rootElement');
+    $el = app.$(selector, context);
 
-      /**
-       Used to allow ember-testing to communicate with a specific testing
-       framework.
+    return $el;
+  }
 
-       You can manually set it before calling `App.setupForTesting()`.
+  function andThen(app, callback) {
+    return app.testHelpers.wait(callback(app));
+  }
 
-       Example:
+  function wait(app, value) {
+    return new RSVP['default'].Promise(function(resolve) {
+      // Every 10ms, poll for the async thing to have finished
+      var watcher = setInterval(function() {
+        var router = app.__container__.lookup('router:main');
+
+        // 1. If the router is loading, keep polling
+        var routerIsLoading = router.router && !!router.router.activeTransition;
+        if (routerIsLoading) { return; }
+
+        // 2. If there are pending Ajax requests, keep polling
+        if (Test['default'].pendingAjaxRequests) { return; }
+
+        // 3. If there are scheduled timers or we are inside of a run loop, keep polling
+        if (run['default'].hasScheduledTimers() || run['default'].currentRunLoop) { return; }
+        if (Test['default'].waiters && Test['default'].waiters.any(function(waiter) {
+          var context = waiter[0];
+          var callback = waiter[1];
+          return !callback.call(context);
+        })) {
+          return;
+        }
+        // Stop polling
+        clearInterval(watcher);
 
-       ```javascript
-       Ember.Test.adapter = MyCustomAdapter.create()
-       ```
+        // Synchronously resolve the promise
+        run['default'](null, resolve, value);
+      }, 10);
+    });
 
-       If you do not set it, ember-testing will default to `Ember.Test.QUnitAdapter`.
+  }
 
-       @public
-       @property adapter
-       @type {Class} The adapter to be used.
-       @default Ember.Test.QUnitAdapter
-      */
-      adapter: null,
 
-      /**
-        Replacement for `Ember.RSVP.resolve`
-        The only difference is this uses
-        an instance of `Ember.Test.Promise`
+  /**
+  * Loads a route, sets up any controllers, and renders any templates associated
+  * with the route as though a real user had triggered the route change while
+  * using your app.
+  *
+  * Example:
+  *
+  * ```javascript
+  * visit('posts/index').then(function() {
+  *   // assert something
+  * });
+  * ```
+  *
+  * @method visit
+  * @param {String} url the name of the route
+  * @return {RSVP.Promise}
+  */
+  asyncHelper('visit', visit);
+
+  /**
+  * Clicks an element and triggers any actions triggered by the element's `click`
+  * event.
+  *
+  * Example:
+  *
+  * ```javascript
+  * click('.some-jQuery-selector').then(function() {
+  *   // assert something
+  * });
+  * ```
+  *
+  * @method click
+  * @param {String} selector jQuery selector for finding element on the DOM
+  * @return {RSVP.Promise}
+  */
+  asyncHelper('click', click);
+
+    /**
+  * Simulates a key event, e.g. `keypress`, `keydown`, `keyup` with the desired keyCode
+  *
+  * Example:
+  *
+  * ```javascript
+  * keyEvent('.some-jQuery-selector', 'keypress', 13).then(function() {
+  *  // assert something
+  * });
+  * ```
+  *
+  * @method keyEvent
+  * @param {String} selector jQuery selector for finding element on the DOM
+  * @param {String} type the type of key event, e.g. `keypress`, `keydown`, `keyup`
+  * @param {Number} keyCode the keyCode of the simulated key event
+  * @return {RSVP.Promise}
+  * @since 1.5.0
+  */
+  asyncHelper('keyEvent', keyEvent);
+
+  /**
+  * Fills in an input element with some text.
+  *
+  * Example:
+  *
+  * ```javascript
+  * fillIn('#email', 'you@example.com').then(function() {
+  *   // assert something
+  * });
+  * ```
+  *
+  * @method fillIn
+  * @param {String} selector jQuery selector finding an input element on the DOM
+  * to fill text with
+  * @param {String} text text to place inside the input element
+  * @return {RSVP.Promise}
+  */
+  asyncHelper('fillIn', fillIn);
+
+  /**
+  * Finds an element in the context of the app's container element. A simple alias
+  * for `app.$(selector)`.
+  *
+  * Example:
+  *
+  * ```javascript
+  * var $el = find('.my-selector');
+  * ```
+  *
+  * @method find
+  * @param {String} selector jQuery string selector for element lookup
+  * @return {Object} jQuery object representing the results of the query
+  */
+  helper('find', find);
+
+  /**
+  * Like `find`, but throws an error if the element selector returns no results.
+  *
+  * Example:
+  *
+  * ```javascript
+  * var $el = findWithAssert('.doesnt-exist'); // throws error
+  * ```
+  *
+  * @method findWithAssert
+  * @param {String} selector jQuery selector string for finding an element within
+  * the DOM
+  * @return {Object} jQuery object representing the results of the query
+  * @throws {Error} throws error if jQuery object returned has a length of 0
+  */
+  helper('findWithAssert', findWithAssert);
+
+  /**
+    Causes the run loop to process any pending events. This is used to ensure that
+    any async operations from other helpers (or your assertions) have been processed.
+
+    This is most often used as the return value for the helper functions (see 'click',
+    'fillIn','visit',etc).
 
-        @public
-        @method resolve
-        @param {Mixed} The value to resolve
-        @since 1.2.0
-      */
-      resolve: function(val) {
-        return Test.promise(function(resolve) {
-          return resolve(val);
-        });
-      },
+    Example:
 
-      /**
-         This allows ember-testing to play nicely with other asynchronous
-         events, such as an application that is waiting for a CSS3
-         transition or an IndexDB transaction.
-
-         For example:
-
-         ```javascript
-         Ember.Test.registerWaiter(function() {
-           return myPendingTransactions() == 0;
-         });
-         ```
-         The `context` argument allows you to optionally specify the `this`
-         with which your callback will be invoked.
-
-         For example:
-
-         ```javascript
-         Ember.Test.registerWaiter(MyDB, MyDB.hasPendingTransactions);
-         ```
-
-         @public
-         @method registerWaiter
-         @param {Object} context (optional)
-         @param {Function} callback
-         @since 1.2.0
-      */
-      registerWaiter: function(context, callback) {
-        if (arguments.length === 1) {
-          callback = context;
-          context = null;
-        }
-        if (!this.waiters) {
-          this.waiters = Ember.A();
-        }
-        this.waiters.push([context, callback]);
-      },
-      /**
-         `unregisterWaiter` is used to unregister a callback that was
-         registered with `registerWaiter`.
-
-         @public
-         @method unregisterWaiter
-         @param {Object} context (optional)
-         @param {Function} callback
-         @since 1.2.0
-      */
-      unregisterWaiter: function(context, callback) {
-        if (!this.waiters) { return; }
-        if (arguments.length === 1) {
-          callback = context;
-          context = null;
-        }
-        this.waiters = Ember.A(this.waiters.filter(function(elt) {
-          return !(elt[0] === context && elt[1] === callback);
-        }));
-      }
-    };
+    ```javascript
+    Ember.Test.registerAsyncHelper('loginUser', function(app, username, password) {
+      visit('secured/path/here')
+      .fillIn('#username', username)
+      .fillIn('#password', password)
+      .click('.submit')
+
+      return app.testHelpers.wait();
+    });
 
-    function helper(app, name) {
-      var fn = helpers[name].method;
-      var meta = helpers[name].meta;
+    @method wait
+    @param {Object} value The value to be returned.
+    @return {RSVP.Promise}
+  */
+  asyncHelper('wait', wait);
+  asyncHelper('andThen', andThen);
 
-      return function() {
-        var args = slice.call(arguments);
-        var lastPromise = Test.lastPromise;
 
-        args.unshift(app);
+  /**
+    Returns the currently active route name.
 
-        // some helpers are not async and
-        // need to return a value immediately.
-        // example: `find`
-        if (!meta.wait) {
-          return fn.apply(app, args);
-        }
+  Example:
 
-        if (!lastPromise) {
-          // It's the first async helper in current context
-          lastPromise = fn.apply(app, args);
-        } else {
-          // wait for last helper's promise to resolve
-          // and then execute
-          run(function() {
-            lastPromise = Test.resolve(lastPromise).then(function() {
-              return fn.apply(app, args);
-            });
-          });
-        }
+  ```javascript
+  function validateRouteName() {
+    equal(currentRouteName(), 'some.path', "correct route was transitioned into.");
+  }
 
-        return lastPromise;
-      };
-    }
+  visit('/some/path').then(validateRouteName)
+  ```
 
-    function run(fn) {
-      if (!emberRun.currentRunLoop) {
-        emberRun(fn);
-      } else {
-        fn();
-      }
-    }
+  @method currentRouteName
+  @return {Object} The name of the currently active route.
+  @since 1.5.0
+  */
+  helper('currentRouteName', currentRouteName);
 
-    EmberApplication.reopen({
-      /**
-       This property contains the testing helpers for the current application. These
-       are created once you call `injectTestHelpers` on your `Ember.Application`
-       instance. The included helpers are also available on the `window` object by
-       default, but can be used from this object on the individual application also.
-
-        @property testHelpers
-        @type {Object}
-        @default {}
-      */
-      testHelpers: {},
+  /**
+    Returns the current path.
 
-      /**
-       This property will contain the original methods that were registered
-       on the `helperContainer` before `injectTestHelpers` is called.
+  Example:
 
-       When `removeTestHelpers` is called, these methods are restored to the
-       `helperContainer`.
+  ```javascript
+  function validateURL() {
+    equal(currentPath(), 'some.path.index', "correct path was transitioned into.");
+  }
 
-        @property originalMethods
-        @type {Object}
-        @default {}
-        @private
-        @since 1.3.0
-      */
-      originalMethods: {},
+  click('#some-link-id').then(validateURL);
+  ```
 
+  @method currentPath
+  @return {Object} The currently active path.
+  @since 1.5.0
+  */
+  helper('currentPath', currentPath);
 
-      /**
-      This property indicates whether or not this application is currently in
-      testing mode. This is set when `setupForTesting` is called on the current
-      application.
+  /**
+    Returns the current URL.
 
-      @property testing
-      @type {Boolean}
-      @default false
-      @since 1.3.0
-      */
-      testing: false,
+  Example:
 
-      /**
-       This hook defers the readiness of the application, so that you can start
-       the app when your tests are ready to run. It also sets the router's
-       location to 'none', so that the window's location will not be modified
-       (preventing both accidental leaking of state between tests and interference
-       with your testing framework).
+  ```javascript
+  function validateURL() {
+    equal(currentURL(), '/some/path', "correct URL was transitioned into.");
+  }
 
-       Example:
+  click('#some-link-id').then(validateURL);
+  ```
 
-      ```
-      App.setupForTesting();
-      ```
+  @method currentURL
+  @return {Object} The currently active URL.
+  @since 1.5.0
+  */
+  helper('currentURL', currentURL);
 
-        @method setupForTesting
-      */
-      setupForTesting: function() {
-        setupForTesting();
+  /**
+   Pauses the current test - this is useful for debugging while testing or for test-driving.
+   It allows you to inspect the state of your application at any point.
 
-        this.testing = true;
+   Example (The test will pause before clicking the button):
 
-        this.Router.reopen({
-          location: 'none'
-        });
-      },
+   ```javascript
+   visit('/')
+   return pauseTest();
 
-      /**
-        This will be used as the container to inject the test helpers into. By
-        default the helpers are injected into `window`.
+   click('.btn');
+   ```
 
-        @property helperContainer
-        @type {Object} The object to be used for test helpers.
-        @default window
-        @since 1.2.0
-      */
-      helperContainer: window,
+   @since 1.9.0
+   @method pauseTest
+   @return {Object} A promise that will never resolve
+   */
+  helper('pauseTest', pauseTest);
 
-      /**
-        This injects the test helpers into the `helperContainer` object. If an object is provided
-        it will be used as the helperContainer. If `helperContainer` is not set it will default
-        to `window`. If a function of the same name has already been defined it will be cached
-        (so that it can be reset if the helper is removed with `unregisterHelper` or
-        `removeTestHelpers`).
+  /**
+    Triggers the given DOM event on the element identified by the provided selector.
 
-       Any callbacks registered with `onInjectHelpers` will be called once the
-       helpers have been injected.
+    Example:
 
-      Example:
-      ```
-      App.injectTestHelpers();
-      ```
+    ```javascript
+    triggerEvent('#some-elem-id', 'blur');
+    ```
 
-        @method injectTestHelpers
-      */
-      injectTestHelpers: function(helperContainer) {
-        if (helperContainer) { this.helperContainer = helperContainer; }
+    This is actually used internally by the `keyEvent` helper like so:
 
-        this.testHelpers = {};
-        for (var name in helpers) {
-          this.originalMethods[name] = this.helperContainer[name];
-          this.testHelpers[name] = this.helperContainer[name] = helper(this, name);
-          protoWrap(Test.Promise.prototype, name, helper(this, name), helpers[name].meta.wait);
-        }
+    ```javascript
+    triggerEvent('#some-elem-id', 'keypress', { keyCode: 13 });
+    ```
 
-        for(var i = 0, l = injectHelpersCallbacks.length; i < l; i++) {
-          injectHelpersCallbacks[i](this);
-        }
-      },
+   @method triggerEvent
+   @param {String} selector jQuery selector for finding element on the DOM
+   @param {String} [context] jQuery selector that will limit the selector
+                             argument to find only within the context's children
+   @param {String} type The event type to be triggered.
+   @param {Object} [options] The options to be passed to jQuery.Event.
+   @return {RSVP.Promise}
+   @since 1.5.0
+  */
+  asyncHelper('triggerEvent', triggerEvent);
 
-      /**
-        This removes all helpers that have been registered, and resets and functions
-        that were overridden by the helpers.
+});
+enifed('ember-testing/initializers', ['ember-runtime/system/lazy_load'], function (lazy_load) {
 
-        Example:
+  'use strict';
 
-        ```javascript
-        App.removeTestHelpers();
-        ```
+  var name = 'deferReadiness in `testing` mode';
 
-        @public
-        @method removeTestHelpers
-      */
-      removeTestHelpers: function() {
-        for (var name in helpers) {
-          this.helperContainer[name] = this.originalMethods[name];
-          delete this.testHelpers[name];
-          delete this.originalMethods[name];
-        }
-      }
-    });
+  lazy_load.onLoad('Ember.Application', function(Application) {
+    if (!Application.initializers[name]) {
+      Application.initializer({
+        name: name,
 
-    // This method is no longer needed
-    // But still here for backwards compatibility
-    // of helper chaining
-    function protoWrap(proto, name, callback, isAsync) {
-      proto[name] = function() {
-        var args = arguments;
-        if (isAsync) {
-          return callback.apply(this, args);
-        } else {
-          return this.then(function() {
-            return callback.apply(this, args);
-          });
+        initialize: function(registry, application) {
+          if (application.testing) {
+            application.deferReadiness();
+          }
         }
-      };
+      });
     }
+  });
 
-    Test.Promise = function() {
-      RSVP.Promise.apply(this, arguments);
-      Test.lastPromise = this;
-    };
-
-    Test.Promise.prototype = create(RSVP.Promise.prototype);
-    Test.Promise.prototype.constructor = Test.Promise;
-
-    // Patch `then` to isolate async methods
-    // specifically `Ember.Test.lastPromise`
-    var originalThen = RSVP.Promise.prototype.then;
-    Test.Promise.prototype.then = function(onSuccess, onFailure) {
-      return originalThen.call(this, function(val) {
-        return isolate(onSuccess, val);
-      }, onFailure);
-    };
-
-    // This method isolates nested async methods
-    // so that they don't conflict with other last promises.
-    //
-    // 1. Set `Ember.Test.lastPromise` to null
-    // 2. Invoke method
-    // 3. Return the last promise created during method
-    // 4. Restore `Ember.Test.lastPromise` to original value
-    function isolate(fn, val) {
-      var value, lastPromise;
+});
+enifed('ember-testing/setup_for_testing', ['exports', 'ember-metal/core', 'ember-testing/adapters/qunit', 'ember-views/system/jquery'], function (exports, Ember, QUnitAdapter, jQuery) {
 
-      // Reset lastPromise for nested helpers
-      Test.lastPromise = null;
+  'use strict';
 
-      value = fn(val);
+  var Test, requests;
 
-      lastPromise = Test.lastPromise;
+  function incrementAjaxPendingRequests(_, xhr) {
+    requests.push(xhr);
+    Test.pendingAjaxRequests = requests.length;
+  }
 
-      // If the method returned a promise
-      // return that promise. If not,
-      // return the last async helper's promise
-      if ((value && (value instanceof Test.Promise)) || !lastPromise) {
-        return value;
-      } else {
-        run(function() {
-          lastPromise = Test.resolve(lastPromise).then(function() {
-            return value;
-          });
-        });
-        return lastPromise;
+  function decrementAjaxPendingRequests(_, xhr) {
+    for (var i=0;i<requests.length;i++) {
+      if (xhr === requests[i]) {
+        requests.splice(i, 1);
       }
     }
+    Test.pendingAjaxRequests = requests.length;
+  }
 
-    __exports__["default"] = Test;
-  });
-enifed("ember-views",
-  ["ember-runtime","ember-views/system/jquery","ember-views/system/utils","ember-views/system/render_buffer","ember-views/system/ext","ember-views/views/states","ember-views/views/core_view","ember-views/views/view","ember-views/views/container_view","ember-views/views/collection_view","ember-views/views/component","ember-views/system/event_dispatcher","ember-views/mixins/view_target_action_support","ember-views/component_lookup","ember-views/views/checkbox","ember-views/mixins/text_support","ember-views/views/text_field","ember-views/views/text_area","ember-views/views/bound_view","ember-views/views/simple_bound_view","ember-views/views/metamorph_view","ember-views/views/select","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __dependency21__, __dependency22__, __exports__) {
-    "use strict";
-    /**
-    Ember Views
+  /**
+    Sets Ember up for testing. This is useful to perform
+    basic setup steps in order to unit test.
 
-    @module ember
-    @submodule ember-views
-    @requires ember-runtime
-    @main ember-views
-    */
-
-    // BEGIN IMPORTS
-    var Ember = __dependency1__["default"];
-    var jQuery = __dependency2__["default"];
-    var isSimpleClick = __dependency3__.isSimpleClick;
-    var getViewClientRects = __dependency3__.getViewClientRects;
-    var getViewBoundingClientRect = __dependency3__.getViewBoundingClientRect;
-    var RenderBuffer = __dependency4__["default"];
-     // for the side effect of extending Ember.run.queues
-    var cloneStates = __dependency6__.cloneStates;
-    var states = __dependency6__.states;
-
-    var CoreView = __dependency7__["default"];
-    var View = __dependency8__["default"];
-    var ContainerView = __dependency9__["default"];
-    var CollectionView = __dependency10__["default"];
-    var Component = __dependency11__["default"];
-
-    var EventDispatcher = __dependency12__["default"];
-    var ViewTargetActionSupport = __dependency13__["default"];
-    var ComponentLookup = __dependency14__["default"];
-    var Checkbox = __dependency15__["default"];
-    var TextSupport = __dependency16__["default"];
-    var TextField = __dependency17__["default"];
-    var TextArea = __dependency18__["default"];
-
-    var BoundView = __dependency19__["default"];
-    var SimpleBoundView = __dependency20__["default"];
-    var _MetamorphView = __dependency21__["default"];
-    var _SimpleMetamorphView = __dependency21__._SimpleMetamorphView;
-    var _Metamorph = __dependency21__._Metamorph;
-    var Select = __dependency22__.Select;
-    var SelectOption = __dependency22__.SelectOption;
-    var SelectOptgroup = __dependency22__.SelectOptgroup;
-    // END IMPORTS
-
-    /**
-      Alias for jQuery
+    Use `App.setupForTesting` to perform integration tests (full
+    application testing).
 
-      @method $
-      @for Ember
-    */
-
-    // BEGIN EXPORTS
-    Ember.$ = jQuery;
-
-    Ember.ViewTargetActionSupport = ViewTargetActionSupport;
-    Ember.RenderBuffer = RenderBuffer;
-
-    var ViewUtils = Ember.ViewUtils = {};
-    ViewUtils.isSimpleClick = isSimpleClick;
-    ViewUtils.getViewClientRects = getViewClientRects;
-    ViewUtils.getViewBoundingClientRect = getViewBoundingClientRect;
-
-    Ember.CoreView = CoreView;
-    Ember.View = View;
-    Ember.View.states = states;
-    Ember.View.cloneStates = cloneStates;
-    Ember.Checkbox = Checkbox;
-    Ember.TextField = TextField;
-    Ember.TextArea = TextArea;
-
-    Ember._SimpleBoundView = SimpleBoundView;
-    Ember._BoundView = BoundView;
-    Ember._SimpleMetamorphView = _SimpleMetamorphView;
-    Ember._MetamorphView = _MetamorphView;
-    Ember._Metamorph = _Metamorph;
-    Ember.Select = Select;
-    Ember.SelectOption = SelectOption;
-    Ember.SelectOptgroup = SelectOptgroup;
-
-    Ember.TextSupport = TextSupport;
-    Ember.ComponentLookup = ComponentLookup;
-    Ember.ContainerView = ContainerView;
-    Ember.CollectionView = CollectionView;
-    Ember.Component = Component;
-    Ember.EventDispatcher = EventDispatcher;
-    // END EXPORTS
-
-    __exports__["default"] = Ember;
-  });
-enifed("ember-views/attr_nodes/attr_node",
-  ["ember-metal/streams/utils","ember-metal/run_loop","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-htmlbars
-    */
+    @method setupForTesting
+    @namespace Ember
+    @since 1.5.0
+  */
+  function setupForTesting() {
+    if (!Test) { Test = requireModule('ember-testing/test')['default']; }
 
-    var read = __dependency1__.read;
-    var subscribe = __dependency1__.subscribe;
-    var unsubscribe = __dependency1__.unsubscribe;
-    var run = __dependency2__["default"];
+    Ember['default'].testing = true;
 
-    function AttrNode(attrName, attrValue) {
-      this.init(attrName, attrValue);
+    // if adapter is not manually set default to QUnit
+    if (!Test.adapter) {
+      Test.adapter = QUnitAdapter['default'].create();
     }
 
-    AttrNode.prototype.init = function init(attrName, simpleAttrValue){
-      this.isView = true;
+    requests = [];
+    Test.pendingAjaxRequests = requests.length;
 
-      // That these semantics are used is very unfortunate.
-      this.tagName = '';
-      this.classNameBindings = [];
-
-      this.attrName = attrName;
-      this.attrValue = simpleAttrValue;
-      this.isDirty = true;
-      this.lastValue = null;
+    jQuery['default'](document).off('ajaxSend', incrementAjaxPendingRequests);
+    jQuery['default'](document).off('ajaxComplete', decrementAjaxPendingRequests);
+    jQuery['default'](document).on('ajaxSend', incrementAjaxPendingRequests);
+    jQuery['default'](document).on('ajaxComplete', decrementAjaxPendingRequests);
+  }
+  exports['default'] = setupForTesting;
+
+});
+enifed('ember-testing/support', ['ember-metal/core', 'ember-views/system/jquery', 'ember-metal/environment'], function (Ember, jQuery, environment) {
+
+  'use strict';
+
+  var $ = jQuery['default'];
+
+  /**
+    This method creates a checkbox and triggers the click event to fire the
+    passed in handler. It is used to correct for a bug in older versions
+    of jQuery (e.g 1.8.3).
+
+    @private
+    @method testCheckboxClick
+  */
+  function testCheckboxClick(handler) {
+    $('<input type="checkbox">')
+      .css({ position: 'absolute', left: '-1000px', top: '-1000px' })
+      .appendTo('body')
+      .on('click', handler)
+      .trigger('click')
+      .remove();
+  }
 
-      subscribe(this.attrValue, this.rerender, this);
-    };
+  if (environment['default'].hasDOM) {
+    $(function() {
+      /*
+        Determine whether a checkbox checked using jQuery's "click" method will have
+        the correct value for its checked property.
 
-    AttrNode.prototype.renderIfDirty = function renderIfDirty(){
-      if (this.isDirty) {
-        var value = read(this.attrValue);
-        if (value !== this.lastValue) {
-          this._renderer.renderTree(this, this._parentView);
-        } else {
-          this.isDirty = false;
+        If we determine that the current jQuery version exhibits this behavior,
+        patch it to work correctly as in the commit for the actual fix:
+        https://github.com/jquery/jquery/commit/1fb2f92.
+      */
+      testCheckboxClick(function() {
+        if (!this.checked && !$.event.special.click) {
+          $.event.special.click = {
+            // For checkbox, fire native event so checked state will be right
+            trigger: function() {
+              if ($.nodeName(this, "input") && this.type === "checkbox" && this.click) {
+                this.click();
+                return false;
+              }
+            }
+          };
         }
-      }
-    };
+      });
 
-    AttrNode.prototype.render = function render(buffer) {
-      this.isDirty = false;
-      var value = read(this.attrValue);
+      // Try again to verify that the patch took effect or blow up.
+      testCheckboxClick(function() {
+        Ember['default'].warn("clicked checkboxes should be checked! the jQuery patch didn't work", this.checked);
+      });
+    });
+  }
 
-      this._morph.setContent(value);
+});
+enifed('ember-testing/test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-metal/platform/create', 'ember-runtime/ext/rsvp', 'ember-testing/setup_for_testing', 'ember-application/system/application'], function (exports, Ember, emberRun, create, RSVP, setupForTesting, EmberApplication) {
 
-      this.lastValue = value;
-    };
+  'use strict';
 
-    AttrNode.prototype.rerender = function render() {
-      this.isDirty = true;
-      run.schedule('render', this, this.renderIfDirty);
-    };
+  var slice = [].slice;
+  var helpers = {};
+  var injectHelpersCallbacks = [];
 
-    AttrNode.prototype.destroy = function render() {
-      this.isDirty = false;
-      unsubscribe(this.attrValue, this.rerender, this);
+  /**
+    This is a container for an assortment of testing related functionality:
 
-      var parent = this._parentView;
-      if (parent) { parent.removeChild(this); }
-    };
+    * Choose your default test adapter (for your framework of choice).
+    * Register/Unregister additional test helpers.
+    * Setup callbacks to be fired when the test helpers are injected into
+      your application.
 
-    __exports__["default"] = AttrNode;
-  });
-enifed("ember-views/attr_nodes/legacy_bind",
-  ["./attr_node","ember-runtime/system/string","ember-metal/utils","ember-metal/streams/utils","ember-metal/platform/create","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
+    @class Test
+    @namespace Ember
+  */
+  var Test = {
     /**
-    @module ember
-    @submodule ember-htmlbars
+      Hash containing all known test helpers.
+
+      @property _helpers
+      @private
+      @since 1.7.0
     */
+    _helpers: helpers,
 
-    var AttrNode = __dependency1__["default"];
-    var fmt = __dependency2__.fmt;
-    var typeOf = __dependency3__.typeOf;
-    var read = __dependency4__.read;
-    var create = __dependency5__["default"];
+    /**
+      `registerHelper` is used to register a test helper that will be injected
+      when `App.injectTestHelpers` is called.
 
-    function LegacyBindAttrNode(attrName, attrValue) {
-      this.init(attrName, attrValue);
-    }
+      The helper method will always be called with the current Application as
+      the first parameter.
 
-    LegacyBindAttrNode.prototype = create(AttrNode.prototype);
+      For example:
 
-    LegacyBindAttrNode.prototype.render = function render(buffer) {
-      this.isDirty = false;
-      var value = read(this.attrValue);
-      var type = typeOf(value);
+      ```javascript
+      Ember.Test.registerHelper('boot', function(app) {
+        Ember.run(app, app.advanceReadiness);
+      });
+      ```
 
-      Ember.assert(fmt("Attributes must be numbers, strings or booleans, not %@", [value]),
-                   value === null || value === undefined || type === 'number' || type === 'string' || type === 'boolean');
+      This helper can later be called without arguments because it will be
+      called with `app` as the first parameter.
 
-      this._morph.setContent(value);
+      ```javascript
+      App = Ember.Application.create();
+      App.injectTestHelpers();
+      boot();
+      ```
 
-      this.lastValue = value;
-    };
+      @public
+      @method registerHelper
+      @param {String} name The name of the helper method to add.
+      @param {Function} helperMethod
+      @param options {Object}
+    */
+    registerHelper: function(name, helperMethod) {
+      helpers[name] = {
+        method: helperMethod,
+        meta: { wait: false }
+      };
+    },
 
-    __exports__["default"] = LegacyBindAttrNode;
-  });
-enifed("ember-views/component_lookup",
-  ["ember-runtime/system/object","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var EmberObject = __dependency1__["default"];
+    /**
+      `registerAsyncHelper` is used to register an async test helper that will be injected
+      when `App.injectTestHelpers` is called.
 
-    __exports__["default"] = EmberObject.extend({
-      lookupFactory: function(name, container) {
+      The helper method will always be called with the current Application as
+      the first parameter.
 
-        container = container || this.container;
+      For example:
 
-        var fullName = 'component:' + name;
-        var templateFullName = 'template:components/' + name;
-        var templateRegistered = container && container.has(templateFullName);
+      ```javascript
+      Ember.Test.registerAsyncHelper('boot', function(app) {
+        Ember.run(app, app.advanceReadiness);
+      });
+      ```
 
-        if (templateRegistered) {
-          container.injection(fullName, 'layout', templateFullName);
-        }
+      The advantage of an async helper is that it will not run
+      until the last async helper has completed.  All async helpers
+      after it will wait for it complete before running.
 
-        var Component = container.lookupFactory(fullName);
 
-        // Only treat as a component if either the component
-        // or a template has been registered.
-        if (templateRegistered || Component) {
-          if (!Component) {
-            container.register(fullName, Ember.Component);
-            Component = container.lookupFactory(fullName);
-          }
-          return Component;
-        }
-      }
-    });
-  });
-enifed("ember-views/mixins/component_template_deprecation",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/mixin","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.deprecate
-    var get = __dependency2__.get;
-    var Mixin = __dependency3__.Mixin;
+      For example:
 
-    /**
-      The ComponentTemplateDeprecation mixin is used to provide a useful
-      deprecation warning when using either `template` or `templateName` with
-      a component. The `template` and `templateName` properties specified at
-      extend time are moved to `layout` and `layoutName` respectively.
+      ```javascript
+      Ember.Test.registerAsyncHelper('deletePost', function(app, postId) {
+        click('.delete-' + postId);
+      });
 
-      `Ember.ComponentTemplateDeprecation` is used internally by Ember in
-      `Ember.Component`.
+      // ... in your test
+      visit('/post/2');
+      deletePost(2);
+      visit('/post/3');
+      deletePost(3);
+      ```
 
-      @class ComponentTemplateDeprecation
-      @namespace Ember
+      @public
+      @method registerAsyncHelper
+      @param {String} name The name of the helper method to add.
+      @param {Function} helperMethod
+      @since 1.2.0
     */
-    __exports__["default"] = Mixin.create({
-      /**
-        @private
+    registerAsyncHelper: function(name, helperMethod) {
+      helpers[name] = {
+        method: helperMethod,
+        meta: { wait: true }
+      };
+    },
 
-        Moves `templateName` to `layoutName` and `template` to `layout` at extend
-        time if a layout is not also specified.
+    /**
+      Remove a previously added helper method.
 
-        Note that this currently modifies the mixin themselves, which is technically
-        dubious but is practically of little consequence. This may change in the
-        future.
+      Example:
 
-        @method willMergeMixin
-        @since 1.4.0
-      */
-      willMergeMixin: function(props) {
-        // must call _super here to ensure that the ActionHandler
-        // mixin is setup properly (moves actions -> _actions)
-        //
-        // Calling super is only OK here since we KNOW that
-        // there is another Mixin loaded first.
-        this._super.apply(this, arguments);
+      ```javascript
+      Ember.Test.unregisterHelper('wait');
+      ```
 
-        var deprecatedProperty, replacementProperty;
-        var layoutSpecified = (props.layoutName || props.layout || get(this, 'layoutName'));
+      @public
+      @method unregisterHelper
+      @param {String} name The helper to remove.
+    */
+    unregisterHelper: function(name) {
+      delete helpers[name];
+      delete Test.Promise.prototype[name];
+    },
 
-        if (props.templateName && !layoutSpecified) {
-          deprecatedProperty = 'templateName';
-          replacementProperty = 'layoutName';
+    /**
+      Used to register callbacks to be fired whenever `App.injectTestHelpers`
+      is called.
 
-          props.layoutName = props.templateName;
-          delete props['templateName'];
-        }
+      The callback will receive the current application as an argument.
 
-        if (props.template && !layoutSpecified) {
-          deprecatedProperty = 'template';
-          replacementProperty = 'layout';
+      Example:
 
-          props.layout = props.template;
-          delete props['template'];
-        }
+      ```javascript
+      Ember.Test.onInjectHelpers(function() {
+        Ember.$(document).ajaxSend(function() {
+          Test.pendingAjaxRequests++;
+        });
 
-        Ember.deprecate('Do not specify ' + deprecatedProperty + ' on a Component, use ' + replacementProperty + ' instead.', !deprecatedProperty);
-      }
-    });
-  });
-enifed("ember-views/mixins/text_support",
-  ["ember-metal/property_get","ember-metal/property_set","ember-metal/mixin","ember-runtime/mixins/target_action_support","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-views
-    */
+        Ember.$(document).ajaxComplete(function() {
+          Test.pendingAjaxRequests--;
+        });
+      });
+      ```
 
-    var get = __dependency1__.get;
-    var set = __dependency2__.set;
-    var Mixin = __dependency3__.Mixin;
-    var TargetActionSupport = __dependency4__["default"];
+      @public
+      @method onInjectHelpers
+      @param {Function} callback The function to be called.
+    */
+    onInjectHelpers: function(callback) {
+      injectHelpersCallbacks.push(callback);
+    },
 
     /**
-      `TextSupport` is a shared mixin used by both `Ember.TextField` and
-      `Ember.TextArea`. `TextSupport` adds a number of methods that allow you to
-      specify a controller action to invoke when a certain event is fired on your
-      text field or textarea. The specifed controller action would get the current
-      value of the field passed in as the only argument unless the value of
-      the field is empty. In that case, the instance of the field itself is passed
-      in as the only argument.
+      This returns a thenable tailored for testing.  It catches failed
+      `onSuccess` callbacks and invokes the `Ember.Test.adapter.exception`
+      callback in the last chained then.
 
-      Let's use the pressing of the escape key as an example. If you wanted to
-      invoke a controller action when a user presses the escape key while on your
-      field, you would use the `escape-press` attribute on your field like so:
+      This method should be returned by async helpers such as `wait`.
 
-      ```handlebars
-        {{! application.hbs}}
+      @public
+      @method promise
+      @param {Function} resolver The function used to resolve the promise.
+    */
+    promise: function(resolver) {
+      return new Test.Promise(resolver);
+    },
 
-        {{input escape-press='alertUser'}}
-      ```
+    /**
+     Used to allow ember-testing to communicate with a specific testing
+     framework.
 
-      ```javascript
-          App = Ember.Application.create();
+     You can manually set it before calling `App.setupForTesting()`.
 
-          App.ApplicationController = Ember.Controller.extend({
-            actions: {
-              alertUser: function ( currentValue ) {
-                alert( 'escape pressed, current value: ' + currentValue );
-              }
-            }
-          });
-      ```
+     Example:
+
+     ```javascript
+     Ember.Test.adapter = MyCustomAdapter.create()
+     ```
 
-      The following chart is a visual representation of what takes place when the
-      escape key is pressed in this scenario:
-
-      The Template
-      +---------------------------+
-      |                           |
-      | escape-press='alertUser'  |
-      |                           |          TextSupport Mixin
-      +----+----------------------+          +-------------------------------+
-           |                                 | cancel method                 |
-           |      escape button pressed      |                               |
-           +-------------------------------> | checks for the `escape-press` |
-                                             | attribute and pulls out the   |
-           +-------------------------------+ | `alertUser` value             |
-           |     action name 'alertUser'     +-------------------------------+
-           |     sent to controller
-           v
-      Controller
-      +------------------------------------------ +
-      |                                           |
-      |  actions: {                               |
-      |     alertUser: function( currentValue ){  |
-      |       alert( 'the esc key was pressed!' ) |
-      |     }                                     |
-      |  }                                        |
-      |                                           |
-      +-------------------------------------------+
-
-      Here are the events that we currently support along with the name of the
-      attribute you would need to use on your field. To reiterate, you would use the
-      attribute name like so:
+     If you do not set it, ember-testing will default to `Ember.Test.QUnitAdapter`.
 
-      ```handlebars
-        {{input attribute-name='controllerAction'}}
-      ```
-
-      +--------------------+----------------+
-      |                    |                |
-      | event              | attribute name |
-      +--------------------+----------------+
-      | new line inserted  | insert-newline |
-      |                    |                |
-      | enter key pressed  | insert-newline |
-      |                    |                |
-      | cancel key pressed | escape-press   |
-      |                    |                |
-      | focusin            | focus-in       |
-      |                    |                |
-      | focusout           | focus-out      |
-      |                    |                |
-      | keypress           | key-press      |
-      |                    |                |
-      | keyup              | key-up         |
-      |                    |                |
-      | keydown            | key-down       |
-      +--------------------+----------------+
-
-      @class TextSupport
-      @namespace Ember
-      @uses Ember.TargetActionSupport
-      @extends Ember.Mixin
-      @private
+     @public
+     @property adapter
+     @type {Class} The adapter to be used.
+     @default Ember.Test.QUnitAdapter
     */
-    var TextSupport = Mixin.create(TargetActionSupport, {
-      value: "",
-
-      attributeBindings: [
-        'autocapitalize',
-        'autocorrect',
-        'autofocus',
-        'disabled',
-        'form',
-        'maxlength',
-        'placeholder',
-        'readonly',
-        'required',
-        'selectionDirection',
-        'spellcheck',
-        'tabindex',
-        'title'
-      ],
-      placeholder: null,
-      disabled: false,
-      maxlength: null,
+    adapter: null,
 
-      init: function() {
-        this._super();
-        this.on("paste", this, this._elementValueDidChange);
-        this.on("cut", this, this._elementValueDidChange);
-        this.on("input", this, this._elementValueDidChange);
-      },
+    /**
+      Replacement for `Ember.RSVP.resolve`
+      The only difference is this uses
+      an instance of `Ember.Test.Promise`
 
-      /**
-        The action to be sent when the user presses the return key.
+      @public
+      @method resolve
+      @param {Mixed} The value to resolve
+      @since 1.2.0
+    */
+    resolve: function(val) {
+      return Test.promise(function(resolve) {
+        return resolve(val);
+      });
+    },
 
-        This is similar to the `{{action}}` helper, but is fired when
-        the user presses the return key when editing a text field, and sends
-        the value of the field as the context.
+    /**
+       This allows ember-testing to play nicely with other asynchronous
+       events, such as an application that is waiting for a CSS3
+       transition or an IndexDB transaction.
 
-        @property action
-        @type String
-        @default null
-      */
-      action: null,
+       For example:
 
-      /**
-        The event that should send the action.
+       ```javascript
+       Ember.Test.registerWaiter(function() {
+         return myPendingTransactions() == 0;
+       });
+       ```
+       The `context` argument allows you to optionally specify the `this`
+       with which your callback will be invoked.
 
-        Options are:
+       For example:
 
-        * `enter`: the user pressed enter
-        * `keyPress`: the user pressed a key
+       ```javascript
+       Ember.Test.registerWaiter(MyDB, MyDB.hasPendingTransactions);
+       ```
 
-        @property onEvent
-        @type String
-        @default enter
-      */
-      onEvent: 'enter',
+       @public
+       @method registerWaiter
+       @param {Object} context (optional)
+       @param {Function} callback
+       @since 1.2.0
+    */
+    registerWaiter: function(context, callback) {
+      if (arguments.length === 1) {
+        callback = context;
+        context = null;
+      }
+      if (!this.waiters) {
+        this.waiters = Ember['default'].A();
+      }
+      this.waiters.push([context, callback]);
+    },
+    /**
+       `unregisterWaiter` is used to unregister a callback that was
+       registered with `registerWaiter`.
 
-      /**
-        Whether the `keyUp` event that triggers an `action` to be sent continues
-        propagating to other views.
+       @public
+       @method unregisterWaiter
+       @param {Object} context (optional)
+       @param {Function} callback
+       @since 1.2.0
+    */
+    unregisterWaiter: function(context, callback) {
+      if (!this.waiters) { return; }
+      if (arguments.length === 1) {
+        callback = context;
+        context = null;
+      }
+      this.waiters = Ember['default'].A(this.waiters.filter(function(elt) {
+        return !(elt[0] === context && elt[1] === callback);
+      }));
+    }
+  };
 
-        By default, when the user presses the return key on their keyboard and
-        the text field has an `action` set, the action will be sent to the view's
-        controller and the key event will stop propagating.
+  function helper(app, name) {
+    var fn = helpers[name].method;
+    var meta = helpers[name].meta;
 
-        If you would like parent views to receive the `keyUp` event even after an
-        action has been dispatched, set `bubbles` to true.
+    return function() {
+      var args = slice.call(arguments);
+      var lastPromise;
 
-        @property bubbles
-        @type Boolean
-        @default false
-      */
-      bubbles: false,
+      args.unshift(app);
 
-      interpretKeyEvents: function(event) {
-        var map = TextSupport.KEY_EVENTS;
-        var method = map[event.keyCode];
+      // some helpers are not async and
+      // need to return a value immediately.
+      // example: `find`
+      if (!meta.wait) {
+        return fn.apply(app, args);
+      }
 
-        this._elementValueDidChange();
-        if (method) { return this[method](event); }
-      },
+      lastPromise = run(function() {
+        return Test.resolve(Test.lastPromise);
+      });
 
-      _elementValueDidChange: function() {
-        set(this, 'value', this.$().val());
-      },
+      // wait for last helper's promise to resolve and then
+      // execute. To be safe, we need to tell the adapter we're going
+      // asynchronous here, because fn may not be invoked before we
+      // return.
+      Test.adapter.asyncStart();
+      return lastPromise.then(function() {
+        return fn.apply(app, args);
+      })["finally"](function() {
+        Test.adapter.asyncEnd();
+      });
+    };
+  }
 
-      change: function(event) {
-        this._elementValueDidChange(event);
-      },
+  function run(fn) {
+    if (!emberRun['default'].currentRunLoop) {
+      return emberRun['default'](fn);
+    } else {
+      return fn();
+    }
+  }
 
-      /**
-        Allows you to specify a controller action to invoke when either the `enter`
-        key is pressed or, in the case of the field being a textarea, when a newline
-        is inserted. To use this method, give your field an `insert-newline`
-        attribute. The value of that attribute should be the name of the action
-        in your controller that you wish to invoke.
+  EmberApplication['default'].reopen({
+    /**
+     This property contains the testing helpers for the current application. These
+     are created once you call `injectTestHelpers` on your `Ember.Application`
+     instance. The included helpers are also available on the `window` object by
+     default, but can be used from this object on the individual application also.
 
-        For an example on how to use the `insert-newline` attribute, please
-        reference the example near the top of this file.
+      @property testHelpers
+      @type {Object}
+      @default {}
+    */
+    testHelpers: {},
 
-        @method insertNewline
-        @param {Event} event
-      */
-      insertNewline: function(event) {
-        sendAction('enter', this, event);
-        sendAction('insert-newline', this, event);
-      },
+    /**
+     This property will contain the original methods that were registered
+     on the `helperContainer` before `injectTestHelpers` is called.
 
-      /**
-        Allows you to specify a controller action to invoke when the escape button
-        is pressed. To use this method, give your field an `escape-press`
-        attribute. The value of that attribute should be the name of the action
-        in your controller that you wish to invoke.
+     When `removeTestHelpers` is called, these methods are restored to the
+     `helperContainer`.
 
-        For an example on how to use the `escape-press` attribute, please reference
-        the example near the top of this file.
+      @property originalMethods
+      @type {Object}
+      @default {}
+      @private
+      @since 1.3.0
+    */
+    originalMethods: {},
 
-        @method cancel
-        @param {Event} event
-      */
-      cancel: function(event) {
-        sendAction('escape-press', this, event);
-      },
 
-      /**
-        Allows you to specify a controller action to invoke when a field receives
-        focus. To use this method, give your field a `focus-in` attribute. The value
-        of that attribute should be the name of the action in your controller
-        that you wish to invoke.
+    /**
+    This property indicates whether or not this application is currently in
+    testing mode. This is set when `setupForTesting` is called on the current
+    application.
 
-        For an example on how to use the `focus-in` attribute, please reference the
-        example near the top of this file.
+    @property testing
+    @type {Boolean}
+    @default false
+    @since 1.3.0
+    */
+    testing: false,
 
-        @method focusIn
-        @param {Event} event
-      */
-      focusIn: function(event) {
-        sendAction('focus-in', this, event);
-      },
+    /**
+     This hook defers the readiness of the application, so that you can start
+     the app when your tests are ready to run. It also sets the router's
+     location to 'none', so that the window's location will not be modified
+     (preventing both accidental leaking of state between tests and interference
+     with your testing framework).
 
-      /**
-        Allows you to specify a controller action to invoke when a field loses
-        focus. To use this method, give your field a `focus-out` attribute. The value
-        of that attribute should be the name of the action in your controller
-        that you wish to invoke.
+     Example:
 
-        For an example on how to use the `focus-out` attribute, please reference the
-        example near the top of this file.
+    ```
+    App.setupForTesting();
+    ```
 
-        @method focusOut
-        @param {Event} event
-      */
-      focusOut: function(event) {
-        this._elementValueDidChange(event);
-        sendAction('focus-out', this, event);
-      },
+      @method setupForTesting
+    */
+    setupForTesting: function() {
+      setupForTesting['default']();
 
-      /**
-        Allows you to specify a controller action to invoke when a key is pressed.
-        To use this method, give your field a `key-press` attribute. The value of
-        that attribute should be the name of the action in your controller you
-        that wish to invoke.
+      this.testing = true;
 
-        For an example on how to use the `key-press` attribute, please reference the
-        example near the top of this file.
+      this.Router.reopen({
+        location: 'none'
+      });
+    },
 
-        @method keyPress
-        @param {Event} event
-      */
-      keyPress: function(event) {
-        sendAction('key-press', this, event);
-      },
+    /**
+      This will be used as the container to inject the test helpers into. By
+      default the helpers are injected into `window`.
 
-      /**
-        Allows you to specify a controller action to invoke when a key-up event is
-        fired. To use this method, give your field a `key-up` attribute. The value
-        of that attribute should be the name of the action in your controller
-        that you wish to invoke.
+      @property helperContainer
+      @type {Object} The object to be used for test helpers.
+      @default window
+      @since 1.2.0
+    */
+    helperContainer: null,
 
-        For an example on how to use the `key-up` attribute, please reference the
-        example near the top of this file.
+    /**
+      This injects the test helpers into the `helperContainer` object. If an object is provided
+      it will be used as the helperContainer. If `helperContainer` is not set it will default
+      to `window`. If a function of the same name has already been defined it will be cached
+      (so that it can be reset if the helper is removed with `unregisterHelper` or
+      `removeTestHelpers`).
 
-        @method keyUp
-        @param {Event} event
-      */
-      keyUp: function(event) {
-        this.interpretKeyEvents(event);
+     Any callbacks registered with `onInjectHelpers` will be called once the
+     helpers have been injected.
 
-        this.sendAction('key-up', get(this, 'value'), event);
-      },
+    Example:
+    ```
+    App.injectTestHelpers();
+    ```
 
-      /**
-        Allows you to specify a controller action to invoke when a key-down event is
-        fired. To use this method, give your field a `key-down` attribute. The value
-        of that attribute should be the name of the action in your controller that
-        you wish to invoke.
+      @method injectTestHelpers
+    */
+    injectTestHelpers: function(helperContainer) {
+      if (helperContainer) {
+        this.helperContainer = helperContainer;
+      } else {
+        this.helperContainer = window;
+      }
 
-        For an example on how to use the `key-down` attribute, please reference the
-        example near the top of this file.
+      this.testHelpers = {};
+      for (var name in helpers) {
+        this.originalMethods[name] = this.helperContainer[name];
+        this.testHelpers[name] = this.helperContainer[name] = helper(this, name);
+        protoWrap(Test.Promise.prototype, name, helper(this, name), helpers[name].meta.wait);
+      }
 
-        @method keyDown
-        @param {Event} event
-      */
-      keyDown: function(event) {
-        this.sendAction('key-down', get(this, 'value'), event);
+      for (var i = 0, l = injectHelpersCallbacks.length; i < l; i++) {
+        injectHelpersCallbacks[i](this);
       }
-    });
+    },
 
-    TextSupport.KEY_EVENTS = {
-      13: 'insertNewline',
-      27: 'cancel'
-    };
+    /**
+      This removes all helpers that have been registered, and resets and functions
+      that were overridden by the helpers.
 
-    // In principle, this shouldn't be necessary, but the legacy
-    // sendAction semantics for TextField are different from
-    // the component semantics so this method normalizes them.
-    function sendAction(eventName, view, event) {
-      var action = get(view, eventName);
-      var on = get(view, 'onEvent');
-      var value = get(view, 'value');
+      Example:
 
-      // back-compat support for keyPress as an event name even though
-      // it's also a method name that consumes the event (and therefore
-      // incompatible with sendAction semantics).
-      if (on === eventName || (on === 'keyPress' && eventName === 'key-press')) {
-        view.sendAction('action', value);
-      }
+      ```javascript
+      App.removeTestHelpers();
+      ```
 
-      view.sendAction(eventName, value);
+      @public
+      @method removeTestHelpers
+    */
+    removeTestHelpers: function() {
+      if (!this.helperContainer) { return; }
 
-      if (action || on === eventName) {
-        if(!get(view, 'bubbles')) {
-          event.stopPropagation();
-        }
+      for (var name in helpers) {
+        this.helperContainer[name] = this.originalMethods[name];
+        delete this.testHelpers[name];
+        delete this.originalMethods[name];
       }
     }
-
-    __exports__["default"] = TextSupport;
   });
-enifed("ember-views/mixins/view_target_action_support",
-  ["ember-metal/mixin","ember-runtime/mixins/target_action_support","ember-metal/alias","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var Mixin = __dependency1__.Mixin;
-    var TargetActionSupport = __dependency2__["default"];
-    var alias = __dependency3__["default"];
-
-    /**
-    `Ember.ViewTargetActionSupport` is a mixin that can be included in a
-    view class to add a `triggerAction` method with semantics similar to
-    the Handlebars `{{action}}` helper. It provides intelligent defaults
-    for the action's target: the view's controller; and the context that is
-    sent with the action: the view's context.
-
-    Note: In normal Ember usage, the `{{action}}` helper is usually the best
-    choice. This mixin is most often useful when you are doing more complex
-    event handling in custom View subclasses.
 
-    For example:
-
-    ```javascript
-    App.SaveButtonView = Ember.View.extend(Ember.ViewTargetActionSupport, {
-      action: 'save',
-      click: function() {
-        this.triggerAction(); // Sends the `save` action, along with the current context
-                              // to the current controller
+  // This method is no longer needed
+  // But still here for backwards compatibility
+  // of helper chaining
+  function protoWrap(proto, name, callback, isAsync) {
+    proto[name] = function() {
+      var args = arguments;
+      if (isAsync) {
+        return callback.apply(this, args);
+      } else {
+        return this.then(function() {
+          return callback.apply(this, args);
+        });
       }
-    });
-    ```
+    };
+  }
 
-    The `action` can be provided as properties of an optional object argument
-    to `triggerAction` as well.
+  Test.Promise = function() {
+    RSVP['default'].Promise.apply(this, arguments);
+    Test.lastPromise = this;
+  };
+
+  Test.Promise.prototype = create['default'](RSVP['default'].Promise.prototype);
+  Test.Promise.prototype.constructor = Test.Promise;
+  Test.Promise.resolve = Test.resolve;
+
+  // Patch `then` to isolate async methods
+  // specifically `Ember.Test.lastPromise`
+  var originalThen = RSVP['default'].Promise.prototype.then;
+  Test.Promise.prototype.then = function(onSuccess, onFailure) {
+    return originalThen.call(this, function(val) {
+      return isolate(onSuccess, val);
+    }, onFailure);
+  };
+
+  // This method isolates nested async methods
+  // so that they don't conflict with other last promises.
+  //
+  // 1. Set `Ember.Test.lastPromise` to null
+  // 2. Invoke method
+  // 3. Return the last promise created during method
+  function isolate(fn, val) {
+    var value, lastPromise;
+
+    // Reset lastPromise for nested helpers
+    Test.lastPromise = null;
+
+    value = fn(val);
+
+    lastPromise = Test.lastPromise;
+    Test.lastPromise = null;
+
+    // If the method returned a promise
+    // return that promise. If not,
+    // return the last async helper's promise
+    if ((value && (value instanceof Test.Promise)) || !lastPromise) {
+      return value;
+    } else {
+      return run(function() {
+        return Test.resolve(lastPromise).then(function() {
+          return value;
+        });
+      });
+    }
+  }
 
-    ```javascript
-    App.SaveButtonView = Ember.View.extend(Ember.ViewTargetActionSupport, {
-      click: function() {
-        this.triggerAction({
-          action: 'save'
-        }); // Sends the `save` action, along with the current context
-            // to the current controller
-      }
-    });
-    ```
+  exports['default'] = Test;
 
-    @class ViewTargetActionSupport
-    @namespace Ember
-    @extends Ember.TargetActionSupport
-    */
-    __exports__["default"] = Mixin.create(TargetActionSupport, {
-      /**
-      @property target
-      */
-      target: alias('controller'),
-      /**
-      @property actionContext
-      */
-      actionContext: alias('context')
-    });
-  });
-enifed("ember-views/streams/class_name_binding",
-  ["ember-metal/streams/utils","ember-metal/property_get","ember-runtime/system/string","ember-metal/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    var chain = __dependency1__.chain;
-    var read = __dependency1__.read;
-    var get = __dependency2__.get;
-    var dasherize = __dependency3__.dasherize;
-    var isArray = __dependency4__.isArray;
+});
+enifed('ember-views', ['exports', 'ember-runtime', 'ember-views/system/jquery', 'ember-views/system/utils', 'ember-views/system/render_buffer', 'ember-views/system/renderer', 'dom-helper', 'ember-views/system/ext', 'ember-views/views/states', 'ember-views/views/core_view', 'ember-views/views/view', 'ember-views/views/container_view', 'ember-views/views/collection_view', 'ember-views/views/component', 'ember-views/system/event_dispatcher', 'ember-views/mixins/view_target_action_support', 'ember-views/component_lookup', 'ember-views/views/checkbox', 'ember-views/mixins/text_support', 'ember-views/views/text_field', 'ember-views/views/text_area', 'ember-views/views/simple_bound_view', 'ember-views/views/metamorph_view', 'ember-views/views/select'], function (exports, Ember, jQuery, utils, RenderBuffer, Renderer, DOMHelper, __dep6__, states, CoreView, View, ContainerView, CollectionView, Component, EventDispatcher, ViewTargetActionSupport, ComponentLookup, Checkbox, TextSupport, TextField, TextArea, SimpleBoundView, metamorph_view, select) {
 
-    /**
-      Parse a path and return an object which holds the parsed properties.
+  'use strict';
 
-      For example a path like "content.isEnabled:enabled:disabled" will return the
-      following object:
+  /**
+  Ember Views
 
-      ```javascript
-      {
-        path: "content.isEnabled",
-        className: "enabled",
-        falsyClassName: "disabled",
-        classNames: ":enabled:disabled"
-      }
-      ```
+  @module ember
+  @submodule ember-views
+  @requires ember-runtime
+  @main ember-views
+  */
 
-      @method parsePropertyPath
-      @static
-      @private
-    */
-    function parsePropertyPath(path) {
-      var split = path.split(':');
-      var propertyPath = split[0];
-      var classNames = "";
-      var className, falsyClassName;
+  // BEGIN IMPORTS
+  Ember['default'].$ = jQuery['default'];
 
-      // check if the property is defined as prop:class or prop:trueClass:falseClass
-      if (split.length > 1) {
-        className = split[1];
-        if (split.length === 3) {
-          falsyClassName = split[2];
-        }
+  Ember['default'].ViewTargetActionSupport = ViewTargetActionSupport['default'];
+  Ember['default'].RenderBuffer = RenderBuffer['default'];
 
-        classNames = ':' + className;
-        if (falsyClassName) {
-          classNames += ":" + falsyClassName;
-        }
-      }
+  var ViewUtils = Ember['default'].ViewUtils = {};
+  ViewUtils.isSimpleClick = utils.isSimpleClick;
+  ViewUtils.getViewClientRects = utils.getViewClientRects;
+  ViewUtils.getViewBoundingClientRect = utils.getViewBoundingClientRect;
 
-      return {
-        path: propertyPath,
-        classNames: classNames,
-        className: (className === '') ? undefined : className,
-        falsyClassName: falsyClassName
-      };
-    }
+  Ember['default'].CoreView = CoreView['default'];
+  Ember['default'].View = View['default'];
+  Ember['default'].View.states = states.states;
+  Ember['default'].View.cloneStates = states.cloneStates;
+  Ember['default'].View.DOMHelper = DOMHelper['default'];
+  Ember['default'].View._Renderer = Renderer['default'];
+  Ember['default'].Checkbox = Checkbox['default'];
+  Ember['default'].TextField = TextField['default'];
+  Ember['default'].TextArea = TextArea['default'];
 
-    __exports__.parsePropertyPath = parsePropertyPath;/**
-      Get the class name for a given value, based on the path, optional
-      `className` and optional `falsyClassName`.
-
-      - if a `className` or `falsyClassName` has been specified:
-        - if the value is truthy and `className` has been specified,
-          `className` is returned
-        - if the value is falsy and `falsyClassName` has been specified,
-          `falsyClassName` is returned
-        - otherwise `null` is returned
-      - if the value is `true`, the dasherized last part of the supplied path
-        is returned
-      - if the value is not `false`, `undefined` or `null`, the `value`
-        is returned
-      - if none of the above rules apply, `null` is returned
-
-      @method classStringForValue
-      @param path
-      @param val
-      @param className
-      @param falsyClassName
-      @static
-      @private
-    */
-    function classStringForValue(path, val, className, falsyClassName) {
-      if(isArray(val)) {
-        val = get(val, 'length') !== 0;
-      }
+  Ember['default']._SimpleBoundView = SimpleBoundView['default'];
+  Ember['default']._MetamorphView = metamorph_view["default"];
+  Ember['default']._Metamorph = metamorph_view._Metamorph;
+  Ember['default'].Select = select.Select;
+  Ember['default'].SelectOption = select.SelectOption;
+  Ember['default'].SelectOptgroup = select.SelectOptgroup;
 
-      // When using the colon syntax, evaluate the truthiness or falsiness
-      // of the value to determine which className to return
-      if (className || falsyClassName) {
-        if (className && !!val) {
-          return className;
+  Ember['default'].TextSupport = TextSupport['default'];
+  Ember['default'].ComponentLookup = ComponentLookup['default'];
+  Ember['default'].ContainerView = ContainerView['default'];
+  Ember['default'].CollectionView = CollectionView['default'];
+  Ember['default'].Component = Component['default'];
+  Ember['default'].EventDispatcher = EventDispatcher['default'];
+  // END EXPORTS
 
-        } else if (falsyClassName && !val) {
-          return falsyClassName;
+  exports['default'] = Ember['default'];
 
-        } else {
-          return null;
-        }
+});
+enifed('ember-views/attr_nodes/attr_node', ['exports', 'ember-metal/core', 'ember-metal/streams/utils', 'ember-metal/run_loop'], function (exports, Ember, utils, run) {
 
-      // If value is a Boolean and true, return the dasherized property
-      // name.
-      } else if (val === true) {
-        // Normalize property path to be suitable for use
-        // as a class name. For exaple, content.foo.barBaz
-        // becomes bar-baz.
-        var parts = path.split('.');
-        return dasherize(parts[parts.length-1]);
+  'use strict';
 
-      // If the value is not false, undefined, or null, return the current
-      // value of the property.
-      } else if (val !== false && val != null) {
-        return val;
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-      // Nothing to display. Return null so that the old class is removed
-      // but no new class is added.
+  function AttrNode(attrName, attrValue) {
+    this.init(attrName, attrValue);
+  }
+
+  var styleWarning = 'Binding style attributes may introduce cross-site scripting vulnerabilities; ' +
+                            'please ensure that values being bound are properly escaped. For more information, ' +
+                            'including how to disable this warning, see ' +
+                            'http://emberjs.com/deprecations/v1.x/#toc_warning-when-binding-style-attributes.';
+
+  AttrNode.prototype.init = function init(attrName, simpleAttrValue) {
+    this.isAttrNode = true;
+    this.isView = true;
+
+    this.tagName = '';
+    this.isVirtual = true;
+
+    this.attrName = attrName;
+    this.attrValue = simpleAttrValue;
+    this.isDirty = true;
+    this.isDestroying = false;
+    this.lastValue = null;
+    this.hasRenderedInitially = false;
+
+    utils.subscribe(this.attrValue, this.rerender, this);
+  };
+
+  AttrNode.prototype.renderIfDirty = function renderIfDirty() {
+    if (this.isDirty && !this.isDestroying) {
+      var value = utils.read(this.attrValue);
+      if (value !== this.lastValue) {
+        this._renderer.renderTree(this, this._parentView);
       } else {
-        return null;
+        this.isDirty = false;
       }
     }
+  };
 
-    __exports__.classStringForValue = classStringForValue;function streamifyClassNameBinding(view, classNameBinding, prefix){
-      prefix = prefix || '';
-      Ember.assert("classNameBindings must not have spaces in them. Multiple class name bindings can be provided as elements of an array, e.g. ['foo', ':bar']", classNameBinding.indexOf(' ') === -1);
-      var parsedPath = parsePropertyPath(classNameBinding);
-      if (parsedPath.path === '') {
-        return classStringForValue(
-          parsedPath.path,
-          true,
-          parsedPath.className,
-          parsedPath.falsyClassName
-        );
-      } else {
-        var pathValue = view.getStream(prefix+parsedPath.path);
-        return chain(pathValue, function() {
-          return classStringForValue(
-            parsedPath.path,
-            read(pathValue),
-            parsedPath.className,
-            parsedPath.falsyClassName
-          );
-        });
-      }
+  AttrNode.prototype.render = function render(buffer) {
+    this.isDirty = false;
+    if (this.isDestroying) {
+      return;
     }
 
-    __exports__.streamifyClassNameBinding = streamifyClassNameBinding;
-  });
-enifed("ember-views/streams/conditional_stream",
-  ["ember-metal/streams/stream","ember-metal/streams/utils","ember-metal/platform","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var Stream = __dependency1__["default"];
-    var read = __dependency2__.read;
-    var subscribe = __dependency2__.subscribe;
-    var unsubscribe = __dependency2__.unsubscribe;
-    var create = __dependency3__.create;
+    var value = utils.read(this.attrValue);
 
-    function ConditionalStream(test, consequent, alternate) {
-      this.init();
+    if (this.attrName === 'value' && (value === null || value === undefined)) {
+      value = '';
+    }
 
-      this.oldTestResult = undefined;
-      this.test = test;
-      this.consequent = consequent;
-      this.alternate = alternate;
+    if (value === undefined) {
+      value = null;
     }
 
-    ConditionalStream.prototype = create(Stream.prototype);
 
-    ConditionalStream.prototype.valueFn = function() {
-      var oldTestResult = this.oldTestResult;
-      var newTestResult = !!read(this.test);
+    // If user is typing in a value we don't want to rerender and loose cursor position.
+    if (this.hasRenderedInitially && this.attrName === 'value' && this._morph.element.value === value) {
+      this.lastValue = value;
+      return;
+    }
 
-      if (newTestResult !== oldTestResult) {
-        switch (oldTestResult) {
-          case true: unsubscribe(this.consequent, this.notify, this); break;
-          case false: unsubscribe(this.alternate, this.notify, this); break;
-          case undefined: subscribe(this.test, this.notify, this);
-        }
+    if (this.lastValue !== null || value !== null) {
+      this._deprecateEscapedStyle(value);
+      this._morph.setContent(value);
+      this.lastValue = value;
+      this.hasRenderedInitially = true;
+    }
+  };
 
-        switch (newTestResult) {
-          case true: subscribe(this.consequent, this.notify, this); break;
-          case false: subscribe(this.alternate, this.notify, this);
+  AttrNode.prototype._deprecateEscapedStyle = function AttrNode_deprecateEscapedStyle(value) {
+    Ember['default'].warn(
+      styleWarning,
+      (function(name, value, escaped) {
+        // SafeString
+        if (value && value.toHTML) {
+          return true;
         }
 
-        this.oldTestResult = newTestResult;
-      }
+        if (name !== 'style') {
+          return true;
+        }
 
-      return newTestResult ? read(this.consequent) : read(this.alternate);
-    };
+        return !escaped;
+      }(this.attrName, value, this._morph.escaped))
+    );
+  };
 
-    __exports__["default"] = ConditionalStream;
-  });
-enifed("ember-views/streams/context_stream",
-  ["ember-metal/core","ember-metal/merge","ember-metal/platform","ember-metal/path_cache","ember-metal/streams/stream","ember-metal/streams/simple","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
+  AttrNode.prototype.rerender = function render() {
+    this.isDirty = true;
+    run['default'].schedule('render', this, this.renderIfDirty);
+  };
 
-    var merge = __dependency2__["default"];
-    var create = __dependency3__.create;
-    var isGlobal = __dependency4__.isGlobal;
-    var Stream = __dependency5__["default"];
-    var SimpleStream = __dependency6__["default"];
+  AttrNode.prototype.destroy = function render() {
+    this.isDestroying = true;
+    this.isDirty = false;
 
-    function ContextStream(view) {
-      Ember.assert("ContextStream error: the argument is not a view", view && view.isView);
+    utils.unsubscribe(this.attrValue, this.rerender, this);
 
-      this.init();
-      this.view = view;
+    if (!this.removedFromDOM && this._renderer) {
+      this._renderer.remove(this, true);
     }
+  };
 
-    ContextStream.prototype = create(Stream.prototype);
+  AttrNode.prototype.propertyDidChange = function render() {
+  };
 
-    merge(ContextStream.prototype, {
-      value: function() {},
+  AttrNode.prototype._notifyBecameHidden = function render() {
+  };
 
-      _makeChildStream: function(key, _fullPath) {
-        var stream;
+  AttrNode.prototype._notifyBecameVisible = function render() {
+  };
 
-        if (key === '' || key === 'this') {
-          stream = this.view._baseContext;
-        } else if (isGlobal(key) && Ember.lookup[key]) {
-          Ember.deprecate("Global lookup of " + _fullPath + " from a Handlebars template is deprecated.");
-          stream = new SimpleStream(Ember.lookup[key]);
-          stream._isGlobal = true;
-        } else if (key in this.view._keywords) {
-          stream = new SimpleStream(this.view._keywords[key]);
-        } else {
-          stream = new SimpleStream(this.view._baseContext.get(key));
-        }
+  exports['default'] = AttrNode;
 
-        stream._isRoot = true;
-
-        if (key === 'controller') {
-          stream._isController = true;
-        }
+  exports.styleWarning = styleWarning;
 
-        return stream;
-      }
-    });
+});
+enifed('ember-views/attr_nodes/legacy_bind', ['exports', './attr_node', 'ember-runtime/system/string', 'ember-metal/utils', 'ember-metal/streams/utils', 'ember-metal/platform/create'], function (exports, AttrNode, string, utils, streams__utils, o_create) {
 
-    __exports__["default"] = ContextStream;
-  });
-enifed("ember-views/streams/key_stream",
-  ["ember-metal/core","ember-metal/merge","ember-metal/platform","ember-metal/property_get","ember-metal/property_set","ember-metal/observer","ember-metal/streams/stream","ember-metal/streams/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
+  'use strict';
 
-    var merge = __dependency2__["default"];
-    var create = __dependency3__.create;
-    var get = __dependency4__.get;
-    var set = __dependency5__.set;
-    var addObserver = __dependency6__.addObserver;
-    var removeObserver = __dependency6__.removeObserver;
-    var Stream = __dependency7__["default"];
-    var read = __dependency8__.read;
-    var isStream = __dependency8__.isStream;
+  /**
+  @module ember
+  @submodule ember-htmlbars
+  */
 
-    function KeyStream(source, key) {
-      Ember.assert("KeyStream error: key must be a non-empty string", typeof key === 'string' && key.length > 0);
-      Ember.assert("KeyStream error: key must not have a '.'", key.indexOf('.') === -1);
+  function LegacyBindAttrNode(attrName, attrValue) {
+    this.init(attrName, attrValue);
+  }
 
-      this.init();
-      this.source = source;
-      this.obj = undefined;
-      this.key = key;
+  LegacyBindAttrNode.prototype = o_create['default'](AttrNode['default'].prototype);
 
-      if (isStream(source)) {
-        source.subscribe(this._didChange, this);
-      }
+  LegacyBindAttrNode.prototype.render = function render(buffer) {
+    this.isDirty = false;
+    if (this.isDestroying) {
+      return;
     }
+    var value = streams__utils.read(this.attrValue);
 
-    KeyStream.prototype = create(Stream.prototype);
-
-    merge(KeyStream.prototype, {
-      valueFn: function() {
-        var prevObj = this.obj;
-        var nextObj = read(this.source);
-
-        if (nextObj !== prevObj) {
-          if (prevObj && typeof prevObj === 'object') {
-            removeObserver(prevObj, this.key, this, this._didChange);
-          }
-
-          if (nextObj && typeof nextObj === 'object') {
-            addObserver(nextObj, this.key, this, this._didChange);
-          }
-
-          this.obj = nextObj;
-        }
+    if (value === undefined) {
+      value = null;
+    }
 
-        if (nextObj) {
-          return get(nextObj, this.key);
-        }
-      },
+    if ((this.attrName === 'value' || this.attrName === 'src') && value === null) {
+      value = '';
+    }
 
-      setValue: function(value) {
-        if (this.obj) {
-          set(this.obj, this.key, value);
-        }
-      },
+    Ember.assert(string.fmt("Attributes must be numbers, strings or booleans, not %@", [value]),
+                 value === null || value === undefined || utils.typeOf(value) === 'number' || utils.typeOf(value) === 'string' || utils.typeOf(value) === 'boolean' || !!(value && value.toHTML));
 
-      setSource: function(nextSource) {
-        Ember.assert("KeyStream error: source must be an object", typeof nextSource === 'object');
+    if (this.lastValue !== null || value !== null) {
+      this._deprecateEscapedStyle(value);
+      this._morph.setContent(value);
+      this.lastValue = value;
+    }
+  };
 
-        var prevSource = this.source;
+  exports['default'] = LegacyBindAttrNode;
 
-        if (nextSource !== prevSource) {
-          if (isStream(prevSource)) {
-            prevSource.unsubscribe(this._didChange, this);
-          }
+});
+enifed('ember-views/component_lookup', ['exports', 'ember-runtime/system/object'], function (exports, EmberObject) {
 
-          if (isStream(nextSource)) {
-            nextSource.subscribe(this._didChange, this);
-          }
+  'use strict';
 
-          this.source = nextSource;
-          this.notify();
-        }
-      },
+  exports['default'] = EmberObject['default'].extend({
+    lookupFactory: function(name, container) {
 
-      _didChange: function() {
-        this.notify();
-      },
+      container = container || this.container;
 
-      _super$destroy: Stream.prototype.destroy,
+      var fullName = 'component:' + name;
+      var templateFullName = 'template:components/' + name;
+      var templateRegistered = container && container._registry.has(templateFullName);
 
-      destroy: function() {
-        if (this._super$destroy()) {
-          if (isStream(this.source)) {
-            this.source.unsubscribe(this._didChange, this);
-          }
+      if (templateRegistered) {
+        container._registry.injection(fullName, 'layout', templateFullName);
+      }
 
-          if (this.obj && typeof this.obj === 'object') {
-            removeObserver(this.obj, this.key, this, this._didChange);
-          }
+      var Component = container.lookupFactory(fullName);
 
-          this.source = undefined;
-          this.obj = undefined;
-          return true;
+      // Only treat as a component if either the component
+      // or a template has been registered.
+      if (templateRegistered || Component) {
+        if (!Component) {
+          container._registry.register(fullName, Ember.Component);
+          Component = container.lookupFactory(fullName);
         }
+        return Component;
       }
-    });
+    }
+  });
 
-    __exports__["default"] = KeyStream;
+});
+enifed('ember-views/mixins/attribute_bindings_support', ['exports', 'ember-metal/mixin', 'ember-views/attr_nodes/attr_node', 'ember-metal/properties', 'ember-views/system/platform', 'ember-metal/streams/utils', 'ember-metal/property_set'], function (exports, mixin, AttrNode, properties, platform, utils, property_set) {
 
-    // The transpiler does not resolve cycles, so we export
-    // the `_makeChildStream` method onto `Stream` here.
+  'use strict';
 
-    Stream.prototype._makeChildStream = function(key) {
-      return new KeyStream(this, key);
-    };
-  });
-enifed("ember-views/streams/utils",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/path_cache","ember-runtime/system/string","ember-metal/streams/utils","ember-views/views/view","ember-runtime/mixins/controller","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var get = __dependency2__.get;
-    var isGlobal = __dependency3__.isGlobal;
-    var fmt = __dependency4__.fmt;
-    var read = __dependency5__.read;
-    var isStream = __dependency5__.isStream;
-    var View = __dependency6__["default"];
-    var ControllerMixin = __dependency7__["default"];
-
-    function readViewFactory(object, container) {
-      var value = read(object);
-      var viewClass;
-
-      if (typeof value === 'string') {
-        if (isGlobal(value)) {
-          viewClass = get(null, value);
-          Ember.deprecate('Resolved the view "'+value+'" on the global context. Pass a view name to be looked up on the container instead, such as {{view "select"}}.', !viewClass, { url: 'http://emberjs.com/guides/deprecations/#toc_global-lookup-of-views' });
-        } else {
-          Ember.assert("View requires a container to resolve views not passed in through the context", !!container);
-          viewClass = container.lookupFactory('view:'+value);
-        }
-      } else {
-        viewClass = value;
-      }
+  var EMPTY_ARRAY = [];
 
-      Ember.assert(fmt(value+" must be a subclass or an instance of Ember.View, not %@", [viewClass]), View.detect(viewClass) || View.detectInstance(viewClass));
+  var AttributeBindingsSupport = mixin.Mixin.create({
+    concatenatedProperties: ['attributeBindings'],
 
-      return viewClass;
-    }
+    /**
+      A list of properties of the view to apply as attributes. If the property is
+      a string value, the value of that string will be applied as the attribute.
 
-    __exports__.readViewFactory = readViewFactory;function readUnwrappedModel(object) {
-      if (isStream(object)) {
-        var result = object.value();
+      ```javascript
+      // Applies the type attribute to the element
+      // with the value "button", like <div type="button">
+      Ember.View.extend({
+        attributeBindings: ['type'],
+        type: 'button'
+      });
+      ```
 
-        // If the path is exactly `controller` then we don't unwrap it.
-        if (!object._isController) {
-          while (ControllerMixin.detect(result)) {
-            result = get(result, 'model');
-          }
-        }
+      If the value of the property is a Boolean, the name of that property is
+      added as an attribute.
 
-        return result;
-      } else {
-        return object;
-      }
-    }
+      ```javascript
+      // Renders something like <div enabled="enabled">
+      Ember.View.extend({
+        attributeBindings: ['enabled'],
+        enabled: true
+      });
+      ```
 
-    __exports__.readUnwrappedModel = readUnwrappedModel;
-  });
-enifed("ember-views/system/action_manager",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-views
+      @property attributeBindings
     */
+    attributeBindings: EMPTY_ARRAY,
 
-    function ActionManager() {}
+    _unspecifiedAttributeBindings: null,
 
     /**
-      Global action id hash.
+      Iterates through the view's attribute bindings, sets up observers for each,
+      then applies the current value of the attributes to the passed render buffer.
 
+      @method _applyAttributeBindings
+      @param {Ember.RenderBuffer} buffer
+      @param {Array} attributeBindings
       @private
-      @property registeredActions
-      @type Object
     */
-    ActionManager.registeredActions = {};
+    _applyAttributeBindings: function(buffer) {
+      var attributeBindings = this.attributeBindings;
 
-    __exports__["default"] = ActionManager;
-  });
-enifed("ember-views/system/event_dispatcher",
-  ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/is_none","ember-metal/run_loop","ember-metal/utils","ember-runtime/system/string","ember-runtime/system/object","ember-views/system/jquery","ember-views/system/action_manager","ember-views/views/view","ember-metal/merge","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-views
-    */
-    var Ember = __dependency1__["default"];
-    // Ember.assert
+      if (!attributeBindings || !attributeBindings.length) { return; }
+
+      var unspecifiedAttributeBindings = this._unspecifiedAttributeBindings = this._unspecifiedAttributeBindings || {};
 
-    var get = __dependency2__.get;
-    var set = __dependency3__.set;
-    var isNone = __dependency4__["default"];
-    var run = __dependency5__["default"];
-    var typeOf = __dependency6__.typeOf;
-    var fmt = __dependency7__.fmt;
-    var EmberObject = __dependency8__["default"];
-    var jQuery = __dependency9__["default"];
-    var ActionManager = __dependency10__["default"];
-    var View = __dependency11__["default"];
-    var merge = __dependency12__["default"];
+      var binding, colonIndex, property, attrName, attrNode, attrValue;
+      var i, l;
+      for (i=0, l=attributeBindings.length; i<l; i++) {
+        binding = attributeBindings[i];
+        colonIndex = binding.indexOf(':');
+        if (colonIndex === -1) {
+          property = binding;
+          attrName = binding;
+        } else {
+          property = binding.substring(0, colonIndex);
+          attrName = binding.substring(colonIndex + 1);
+        }
+
+        Ember.assert('You cannot use class as an attributeBinding, use classNameBindings instead.', attrName !== 'class');
+
+        if (property in this) {
+          attrValue = this.getStream('view.'+property);
+          attrNode = new AttrNode['default'](attrName, attrValue);
+          this.appendAttr(attrNode);
+          if (!platform.canSetNameOnInputs && attrName === 'name') {
+            buffer.attr('name', utils.read(attrValue));
+          }
+        } else {
+          unspecifiedAttributeBindings[property] = attrName;
+        }
+      }
 
-    //ES6TODO:
-    // find a better way to do Ember.View.views without global state
+      // Lazily setup setUnknownProperty after attributeBindings are initially applied
+      this.setUnknownProperty = this._setUnknownProperty;
+    },
 
     /**
-      `Ember.EventDispatcher` handles delegating browser events to their
-      corresponding `Ember.Views.` For example, when you click on a view,
-      `Ember.EventDispatcher` ensures that that view's `mouseDown` method gets
-      called.
+      We're using setUnknownProperty as a hook to setup attributeBinding observers for
+      properties that aren't defined on a view at initialization time.
+
+      Note: setUnknownProperty will only be called once for each property.
 
-      @class EventDispatcher
-      @namespace Ember
+      @method setUnknownProperty
+      @param key
+      @param value
       @private
-      @extends Ember.Object
     */
-    __exports__["default"] = EmberObject.extend({
+    setUnknownProperty: null, // Gets defined after initialization by _applyAttributeBindings
 
-      /**
-        The set of events names (and associated handler function names) to be setup
-        and dispatched by the `EventDispatcher`. Custom events can added to this list at setup
-        time, generally via the `Ember.Application.customEvents` hash. Only override this
-        default set to prevent the EventDispatcher from listening on some events all together.
+    _setUnknownProperty: function(key, value) {
+      var attrName = this._unspecifiedAttributeBindings && this._unspecifiedAttributeBindings[key];
 
-        This set will be modified by `setup` to also include any events added at that time.
+      properties.defineProperty(this, key);
 
-        @property events
-        @type Object
-      */
-      events: {
-        touchstart  : 'touchStart',
-        touchmove   : 'touchMove',
-        touchend    : 'touchEnd',
-        touchcancel : 'touchCancel',
-        keydown     : 'keyDown',
-        keyup       : 'keyUp',
-        keypress    : 'keyPress',
-        mousedown   : 'mouseDown',
-        mouseup     : 'mouseUp',
-        contextmenu : 'contextMenu',
-        click       : 'click',
-        dblclick    : 'doubleClick',
-        mousemove   : 'mouseMove',
-        focusin     : 'focusIn',
-        focusout    : 'focusOut',
-        mouseenter  : 'mouseEnter',
-        mouseleave  : 'mouseLeave',
-        submit      : 'submit',
-        input       : 'input',
-        change      : 'change',
-        dragstart   : 'dragStart',
-        drag        : 'drag',
-        dragenter   : 'dragEnter',
-        dragleave   : 'dragLeave',
-        dragover    : 'dragOver',
-        drop        : 'drop',
-        dragend     : 'dragEnd'
-      },
+      if (attrName) {
+        var attrValue = this.getStream('view.'+key);
+        var attrNode = new AttrNode['default'](attrName, attrValue);
+        this.appendAttr(attrNode);
+      }
+      return property_set.set(this, key, value);
+    }
+  });
 
-      /**
-        The root DOM element to which event listeners should be attached. Event
-        listeners will be attached to the document unless this is overridden.
+  exports['default'] = AttributeBindingsSupport;
 
-        Can be specified as a DOMElement or a selector string.
+});
+enifed('ember-views/mixins/class_names_support', ['exports', 'ember-metal/core', 'ember-metal/mixin', 'ember-runtime/system/native_array', 'ember-metal/enumerable_utils', 'ember-metal/streams/utils', 'ember-views/streams/class_name_binding', 'ember-metal/utils'], function (exports, Ember, mixin, native_array, enumerable_utils, utils, class_name_binding, ember_metal__utils) {
 
-        The default body is a string since this may be evaluated before document.body
-        exists in the DOM.
+  'use strict';
 
-        @private
-        @property rootElement
-        @type DOMElement
-        @default 'body'
-      */
-      rootElement: 'body',
+  var EMPTY_ARRAY = [];
 
-      /**
-        It enables events to be dispatched to the view's `eventManager.` When present,
-        this object takes precedence over handling of events on the view itself.
+  var ClassNamesSupport = mixin.Mixin.create({
+    concatenatedProperties: ['classNames', 'classNameBindings'],
 
-        Note that most Ember applications do not use this feature. If your app also
-        does not use it, consider setting this property to false to gain some performance
-        improvement by allowing the EventDispatcher to skip the search for the
-        `eventManager` on the view tree.
+    init: function() {
+      this._super.apply(this, arguments);
 
-        ```javascript
-        var EventDispatcher = Em.EventDispatcher.extend({
-          events: {
-              click       : 'click',
-              focusin     : 'focusIn',
-              focusout    : 'focusOut',
-              change      : 'change'
-          },
-          canDispatchToEventManager: false
-        });
-        container.register('event_dispatcher:main', EventDispatcher);
-        ```
+      Ember['default'].assert("Only arrays are allowed for 'classNameBindings'", ember_metal__utils.typeOf(this.classNameBindings) === 'array');
+      this.classNameBindings = native_array.A(this.classNameBindings.slice());
 
-        @property canDispatchToEventManager
-        @type boolean
-        @default 'true'
-        @since 1.7.0
-      */
-      canDispatchToEventManager: true,
+      Ember['default'].assert("Only arrays of static class strings are allowed for 'classNames'. For dynamic classes, use 'classNameBindings'.", ember_metal__utils.typeOf(this.classNames) === 'array');
+      this.classNames = native_array.A(this.classNames.slice());
+    },
 
-      /**
-        Sets up event listeners for standard browser events.
+    /**
+      Standard CSS class names to apply to the view's outer element. This
+      property automatically inherits any class names defined by the view's
+      superclasses as well.
 
-        This will be called after the browser sends a `DOMContentReady` event. By
-        default, it will set up all of the listeners on the document body. If you
-        would like to register the listeners on a different element, set the event
-        dispatcher's `root` property.
+      @property classNames
+      @type Array
+      @default ['ember-view']
+    */
+    classNames: ['ember-view'],
 
-        @private
-        @method setup
-        @param addedEvents {Hash}
-      */
-      setup: function(addedEvents, rootElement) {
-        var event, events = get(this, 'events');
+    /**
+      A list of properties of the view to apply as class names. If the property
+      is a string value, the value of that string will be applied as a class
+      name.
 
-        merge(events, addedEvents || {});
+      ```javascript
+      // Applies the 'high' class to the view element
+      Ember.View.extend({
+        classNameBindings: ['priority']
+        priority: 'high'
+      });
+      ```
 
-        if (!isNone(rootElement)) {
-          set(this, 'rootElement', rootElement);
-        }
+      If the value of the property is a Boolean, the name of that property is
+      added as a dasherized class name.
 
-        rootElement = jQuery(get(this, 'rootElement'));
+      ```javascript
+      // Applies the 'is-urgent' class to the view element
+      Ember.View.extend({
+        classNameBindings: ['isUrgent']
+        isUrgent: true
+      });
+      ```
 
-        Ember.assert(fmt('You cannot use the same root element (%@) multiple times in an Ember.Application', [rootElement.selector || rootElement[0].tagName]), !rootElement.is('.ember-application'));
-        Ember.assert('You cannot make a new Ember.Application using a root element that is a descendent of an existing Ember.Application', !rootElement.closest('.ember-application').length);
-        Ember.assert('You cannot make a new Ember.Application using a root element that is an ancestor of an existing Ember.Application', !rootElement.find('.ember-application').length);
+      If you would prefer to use a custom value instead of the dasherized
+      property name, you can pass a binding like this:
 
-        rootElement.addClass('ember-application');
+      ```javascript
+      // Applies the 'urgent' class to the view element
+      Ember.View.extend({
+        classNameBindings: ['isUrgent:urgent']
+        isUrgent: true
+      });
+      ```
 
-        Ember.assert('Unable to add "ember-application" class to rootElement. Make sure you set rootElement to the body or an element in the body.', rootElement.is('.ember-application'));
+      This list of properties is inherited from the view's superclasses as well.
 
-        for (event in events) {
-          if (events.hasOwnProperty(event)) {
-            this.setupHandler(rootElement, event, events[event]);
-          }
-        }
-      },
+      @property classNameBindings
+      @type Array
+      @default []
+    */
+    classNameBindings: EMPTY_ARRAY,
 
-      /**
-        Registers an event listener on the rootElement. If the given event is
-        triggered, the provided event handler will be triggered on the target view.
+    /**
+      Iterates over the view's `classNameBindings` array, inserts the value
+      of the specified property into the `classNames` array, then creates an
+      observer to update the view's element if the bound property ever changes
+      in the future.
 
-        If the target view does not implement the event handler, or if the handler
-        returns `false`, the parent view will be called. The event will continue to
-        bubble to each successive parent view until it reaches the top.
+      @method _applyClassNameBindings
+      @private
+    */
+    _applyClassNameBindings: function() {
+      var classBindings = this.classNameBindings;
 
-        @private
-        @method setupHandler
-        @param {Element} rootElement
-        @param {String} event the browser-originated event to listen to
-        @param {String} eventName the name of the method to call on the view
-      */
-      setupHandler: function(rootElement, event, eventName) {
-        var self = this;
+      if (!classBindings || !classBindings.length) { return; }
 
-        rootElement.on(event + '.ember', '.ember-view', function(evt, triggeringManager) {
-          var view = View.views[this.id];
-          var result = true;
+      var classNames = this.classNames;
+      var elem, newClass, dasherizedClass;
 
-          var manager = self.canDispatchToEventManager ? self._findNearestEventManager(view, eventName) : null;
+      // Loop through all of the configured bindings. These will be either
+      // property names ('isUrgent') or property paths relative to the view
+      // ('content.isUrgent')
+      enumerable_utils.forEach(classBindings, function(binding) {
 
-          if (manager && manager !== triggeringManager) {
-            result = self._dispatchEvent(manager, evt, eventName, view);
-          } else if (view) {
-            result = self._bubbleEvent(view, evt, eventName);
-          }
+        var boundBinding;
+        if (utils.isStream(binding)) {
+          boundBinding = binding;
+        } else {
+          boundBinding = class_name_binding.streamifyClassNameBinding(this, binding, '_view.');
+        }
 
-          return result;
-        });
+        // Variable in which the old class value is saved. The observer function
+        // closes over this variable, so it knows which string to remove when
+        // the property changes.
+        var oldClass;
+
+        // Set up an observer on the context. If the property changes, toggle the
+        // class name.
+        var observer = this._wrapAsScheduled(function() {
+          // Get the current value of the property
+          elem = this.$();
+          newClass = utils.read(boundBinding);
 
-        rootElement.on(event + '.ember', '[data-ember-action]', function(evt) {
-          var actionId = jQuery(evt.currentTarget).attr('data-ember-action');
-          var action   = ActionManager.registeredActions[actionId];
+          // If we had previously added a class to the element, remove it.
+          if (oldClass) {
+            elem.removeClass(oldClass);
+            // Also remove from classNames so that if the view gets rerendered,
+            // the class doesn't get added back to the DOM.
+            classNames.removeObject(oldClass);
+          }
 
-          // We have to check for action here since in some cases, jQuery will trigger
-          // an event on `removeChild` (i.e. focusout) after we've already torn down the
-          // action handlers for the view.
-          if (action && action.eventName === eventName) {
-            return action.handler(evt);
+          // If necessary, add a new class. Make sure we keep track of it so
+          // it can be removed in the future.
+          if (newClass) {
+            elem.addClass(newClass);
+            oldClass = newClass;
+          } else {
+            oldClass = null;
           }
         });
-      },
 
-      _findNearestEventManager: function(view, eventName) {
-        var manager = null;
+        // Get the class name for the property at its current value
+        dasherizedClass = utils.read(boundBinding);
 
-        while (view) {
-          manager = get(view, 'eventManager');
-          if (manager && manager[eventName]) { break; }
+        if (dasherizedClass) {
+          // Ensure that it gets into the classNames array
+          // so it is displayed when we render.
+          enumerable_utils.addObject(classNames, dasherizedClass);
 
-          view = get(view, 'parentView');
+          // Save a reference to the class name so we can remove it
+          // if the observer fires. Remember that this variable has
+          // been closed over by the observer.
+          oldClass = dasherizedClass;
         }
 
-        return manager;
-      },
-
-      _dispatchEvent: function(object, evt, eventName, view) {
-        var result = true;
+        utils.subscribe(boundBinding, observer, this);
+        // Remove className so when the view is rerendered,
+        // the className is added based on binding reevaluation
+        this.one('willClearRender', function() {
+          if (oldClass) {
+            classNames.removeObject(oldClass);
+            oldClass = null;
+          }
+        });
 
-        var handler = object[eventName];
-        if (typeOf(handler) === 'function') {
-          result = run(object, handler, evt, view);
-          // Do not preventDefault in eventManagers.
-          evt.stopPropagation();
-        }
-        else {
-          result = this._bubbleEvent(view, evt, eventName);
-        }
+      }, this);
+    }
+  });
 
-        return result;
-      },
+  exports['default'] = ClassNamesSupport;
 
-      _bubbleEvent: function(view, evt, eventName) {
-        return run.join(view, view.handleEvent, eventName, evt);
-      },
+});
+enifed('ember-views/mixins/component_template_deprecation', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/mixin'], function (exports, Ember, property_get, mixin) {
 
-      destroy: function() {
-        var rootElement = get(this, 'rootElement');
-        jQuery(rootElement).off('.ember', '**').removeClass('ember-application');
-        return this._super();
-      },
+  'use strict';
 
-      toString: function() {
-        return '(EventDispatcher)';
-      }
-    });
-  });
-enifed("ember-views/system/ext",
-  ["ember-metal/run_loop"],
-  function(__dependency1__) {
-    "use strict";
+  exports['default'] = mixin.Mixin.create({
     /**
-    @module ember
-    @submodule ember-views
+      @private
+
+      Moves `templateName` to `layoutName` and `template` to `layout` at extend
+      time if a layout is not also specified.
+
+      Note that this currently modifies the mixin themselves, which is technically
+      dubious but is practically of little consequence. This may change in the
+      future.
+
+      @method willMergeMixin
+      @since 1.4.0
     */
+    willMergeMixin: function(props) {
+      // must call _super here to ensure that the ActionHandler
+      // mixin is setup properly (moves actions -> _actions)
+      //
+      // Calling super is only OK here since we KNOW that
+      // there is another Mixin loaded first.
+      this._super.apply(this, arguments);
 
-    var run = __dependency1__["default"];
+      var deprecatedProperty, replacementProperty;
+      var layoutSpecified = (props.layoutName || props.layout || property_get.get(this, 'layoutName'));
 
-    // Add a new named queue for rendering views that happens
-    // after bindings have synced, and a queue for scheduling actions
-    // that that should occur after view rendering.
-    run._addQueue('render', 'actions');
-    run._addQueue('afterRender', 'render');
-  });
-enifed("ember-views/system/jquery",
-  ["ember-metal/core","ember-metal/enumerable_utils","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.assert
+      if (props.templateName && !layoutSpecified) {
+        deprecatedProperty = 'templateName';
+        replacementProperty = 'layoutName';
 
-    // ES6TODO: the functions on EnumerableUtils need their own exports
-    var forEach = __dependency2__.forEach;
+        props.layoutName = props.templateName;
+        delete props['templateName'];
+      }
 
-    /**
-    Ember Views
+      if (props.template && !layoutSpecified) {
+        deprecatedProperty = 'template';
+        replacementProperty = 'layout';
 
-    @module ember
-    @submodule ember-views
-    @requires ember-runtime
-    @main ember-views
-    */
+        props.layout = props.template;
+        delete props['template'];
+      }
 
-    var jQuery = (Ember.imports && Ember.imports.jQuery) || (this && this.jQuery);
-    if (!jQuery && typeof eriuqer === 'function') {
-      jQuery = eriuqer('jquery');
+      Ember['default'].deprecate('Do not specify ' + deprecatedProperty + ' on a Component, use ' + replacementProperty + ' instead.', !deprecatedProperty);
     }
+  });
 
-    Ember.assert("Ember Views require jQuery between 1.7 and 2.1", jQuery &&
-                 (jQuery().jquery.match(/^((1\.(7|8|9|10|11))|(2\.(0|1)))(\.\d+)?(pre|rc\d?)?/) ||
-                  Ember.ENV.FORCE_JQUERY));
+});
+enifed('ember-views/mixins/instrumentation_support', ['exports', 'ember-metal/mixin', 'ember-metal/computed', 'ember-metal/property_get'], function (exports, mixin, computed, property_get) {
+
+  'use strict';
 
+  var InstrumentationSupport = mixin.Mixin.create({
     /**
-    @module ember
-    @submodule ember-views
+      Used to identify this view during debugging
+
+      @property instrumentDisplay
+      @type String
     */
-    if (jQuery) {
-      // http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html#dndevents
-      var dragEvents = [
-        'dragstart',
-        'drag',
-        'dragenter',
-        'dragleave',
-        'dragover',
-        'drop',
-        'dragend'
-      ];
+    instrumentDisplay: computed.computed(function() {
+      if (this.helperName) {
+        return '{{' + this.helperName + '}}';
+      }
+    }),
 
-      // Copies the `dataTransfer` property from a browser event object onto the
-      // jQuery event object for the specified events
-      forEach(dragEvents, function(eventName) {
-        jQuery.event.fixHooks[eventName] = {
-          props: ['dataTransfer']
-        };
-      });
-    }
+    instrumentName: 'view',
 
-    __exports__["default"] = jQuery;
+    instrumentDetails: function(hash) {
+      hash.template = property_get.get(this, 'templateName');
+      this._super(hash);
+    }
   });
-enifed("ember-views/system/render_buffer",
-  ["ember-views/system/jquery","morph","ember-metal/core","ember-metal/platform","morph/dom-helper/prop","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-views
-    */
 
-    var jQuery = __dependency1__["default"];
-    var DOMHelper = __dependency2__.DOMHelper;
-    var Ember = __dependency3__["default"];
-    var create = __dependency4__.create;
-    var normalizeProperty = __dependency5__.normalizeProperty;
+  exports['default'] = InstrumentationSupport;
 
-    // The HTML spec allows for "omitted start tags". These tags are optional
-    // when their intended child is the first thing in the parent tag. For
-    // example, this is a tbody start tag:
-    //
-    // <table>
-    //   <tbody>
-    //     <tr>
-    //
-    // The tbody may be omitted, and the browser will accept and render:
-    //
-    // <table>
-    //   <tr>
-    //
-    // However, the omitted start tag will still be added to the DOM. Here
-    // we test the string and context to see if the browser is about to
-    // perform this cleanup, but with a special allowance for disregarding
-    // <script tags. This disregarding of <script being the first child item
-    // may bend the official spec a bit, and is only needed for Handlebars
-    // templates.
-    //
-    // http://www.whatwg.org/specs/web-apps/current-work/multipage/syntax.html#optional-tags
-    // describes which tags are omittable. The spec for tbody and colgroup
-    // explains this behavior:
-    //
-    // http://www.whatwg.org/specs/web-apps/current-work/multipage/tables.html#the-tbody-element
-    // http://www.whatwg.org/specs/web-apps/current-work/multipage/tables.html#the-colgroup-element
-    //
-    var omittedStartTagChildren = {
-      tr: document.createElement('tbody'),
-      col: document.createElement('colgroup')
-    };
+});
+enifed('ember-views/mixins/legacy_view_support', ['exports', 'ember-metal/core', 'ember-metal/mixin', 'ember-metal/property_get'], function (exports, Ember, mixin, property_get) {
 
-    var omittedStartTagChildTest = /(?:<script)*.*?<([\w:]+)/i;
+  'use strict';
 
-    function detectOmittedStartTag(string, contextualElement){
-      // Omitted start tags are only inside table tags.
-      if (contextualElement.tagName === 'TABLE') {
-        var omittedStartTagChildMatch = omittedStartTagChildTest.exec(string);
-        if (omittedStartTagChildMatch) {
-          // It is already asserted that the contextual element is a table
-          // and not the proper start tag. Just look up the start tag.
-          return omittedStartTagChildren[omittedStartTagChildMatch[1].toLowerCase()];
-        }
-      }
-    }
+  var LegacyViewSupport = mixin.Mixin.create({
+    beforeRender: function(buffer) {},
 
-    function ClassSet() {
-      this.seen = create(null);
-      this.list = [];
-    }
+    afterRender: function(buffer) {},
 
-    ClassSet.prototype = {
-      add: function(string) {
-        if (this.seen[string] === true) { return; }
-        this.seen[string] = true;
+    mutateChildViews: function(callback) {
+      var childViews = this._childViews;
+      var idx = childViews.length;
+      var view;
 
-        this.list.push(string);
+      while (--idx >= 0) {
+        view = childViews[idx];
+        callback(this, view, idx);
       }
-    };
 
-    var BAD_TAG_NAME_TEST_REGEXP = /[^a-zA-Z0-9\-]/;
-    var BAD_TAG_NAME_REPLACE_REGEXP = /[^a-zA-Z0-9\-]/g;
+      return this;
+    },
 
-    function stripTagName(tagName) {
-      if (!tagName) {
-        return tagName;
-      }
+    /**
+      Removes all children from the `parentView`.
 
-      if (!BAD_TAG_NAME_TEST_REGEXP.test(tagName)) {
-        return tagName;
-      }
+      @method removeAllChildren
+      @return {Ember.View} receiver
+    */
+    removeAllChildren: function() {
+      return this.mutateChildViews(function(parentView, view) {
+        parentView.removeChild(view);
+      });
+    },
 
-      return tagName.replace(BAD_TAG_NAME_REPLACE_REGEXP, '');
-    }
+    destroyAllChildren: function() {
+      return this.mutateChildViews(function(parentView, view) {
+        view.destroy();
+      });
+    },
+
+    /**
+      Return the nearest ancestor whose parent is an instance of
+      `klass`.
 
-    var BAD_CHARS_REGEXP = /&(?!\w+;)|[<>"'`]/g;
-    var POSSIBLE_CHARS_REGEXP = /[&<>"'`]/;
+      @method nearestChildOf
+      @param {Class} klass Subclass of Ember.View (or Ember.View itself)
+      @return Ember.View
+      @deprecated
+    */
+    nearestChildOf: function(klass) {
+      Ember['default'].deprecate("nearestChildOf has been deprecated.");
 
-    function escapeAttribute(value) {
-      // Stolen shamelessly from Handlebars
+      var view = property_get.get(this, 'parentView');
 
-      var escape = {
-        "<": "&lt;",
-        ">": "&gt;",
-        '"': "&quot;",
-        "'": "&#x27;",
-        "`": "&#x60;"
-      };
+      while (view) {
+        if (property_get.get(view, 'parentView') instanceof klass) { return view; }
+        view = property_get.get(view, 'parentView');
+      }
+    },
 
-      var escapeChar = function(chr) {
-        return escape[chr] || "&amp;";
-      };
+    /**
+      Return the nearest ancestor that is an instance of the provided
+      class.
 
-      var string = value.toString();
+      @method nearestInstanceOf
+      @param {Class} klass Subclass of Ember.View (or Ember.View itself)
+      @return Ember.View
+      @deprecated
+    */
+    nearestInstanceOf: function(klass) {
+      Ember['default'].deprecate("nearestInstanceOf is deprecated and will be removed from future releases. Use nearestOfType.");
+      var view = property_get.get(this, 'parentView');
 
-      if(!POSSIBLE_CHARS_REGEXP.test(string)) { return string; }
-      return string.replace(BAD_CHARS_REGEXP, escapeChar);
+      while (view) {
+        if (view instanceof klass) { return view; }
+        view = property_get.get(view, 'parentView');
+      }
     }
+  });
 
-    // IE 6/7 have bugs around setting names on inputs during creation.
-    // From http://msdn.microsoft.com/en-us/library/ie/ms536389(v=vs.85).aspx:
-    // "To include the NAME attribute at run time on objects created with the createElement method, use the eTag."
-    var canSetNameOnInputs = (function() {
-      var div = document.createElement('div');
-      var el = document.createElement('input');
+  exports['default'] = LegacyViewSupport;
 
-      el.setAttribute('name', 'foo');
-      div.appendChild(el);
+});
+enifed('ember-views/mixins/normalized_rerender_if_needed', ['exports', 'ember-metal/property_get', 'ember-metal/mixin', 'ember-metal/merge', 'ember-views/views/states'], function (exports, property_get, mixin, merge, views__states) {
 
-      return !!div.innerHTML.match('foo');
-    })();
+  'use strict';
 
-    /**
-      `Ember.renderBuffer` gathers information regarding the view and generates the
-      final representation. `Ember.renderBuffer` will generate HTML which can be pushed
-      to the DOM.
+  /**
+  @module ember
+  @submodule ember-views
+  */
 
-       ```javascript
-       var buffer = Ember.renderBuffer('div', contextualElement);
-      ```
+  var states = views__states.cloneStates(views__states.states);
 
-      @method renderBuffer
-      @namespace Ember
-      @param {String} tagName tag name (such as 'div' or 'p') used for the buffer
-    */
-    __exports__["default"] = function renderBuffer(tagName, contextualElement) {
-      return new _RenderBuffer(tagName, contextualElement); // jshint ignore:line
-    }
+  merge['default'](states._default, {
+    rerenderIfNeeded: function() { return this; }
+  });
 
-    function _RenderBuffer(tagName, contextualElement) {
-      this.tagName = tagName;
-      this._outerContextualElement = contextualElement;
-      this.buffer = null;
-      this.childViews = [];
-      this.dom = new DOMHelper();
+  merge['default'](states.inDOM, {
+    rerenderIfNeeded: function(view) {
+      if (view.normalizedValue() !== view._lastNormalizedValue) {
+        view.rerender();
+      }
     }
+  });
 
-    _RenderBuffer.prototype = {
+  exports['default'] = mixin.Mixin.create({
+    _states: states,
 
-      reset: function(tagName, contextualElement) {
-        this.tagName = tagName;
-        this.buffer = null;
-        this._element = null;
-        this._outerContextualElement = contextualElement;
-        this.elementClasses = null;
-        this.elementId = null;
-        this.elementAttributes = null;
-        this.elementProperties = null;
-        this.elementTag = null;
-        this.elementStyle = null;
-        this.childViews.length = 0;
-      },
+    normalizedValue: function() {
+      var value = this.lazyValue.value();
+      var valueNormalizer = property_get.get(this, 'valueNormalizerFunc');
+      return valueNormalizer ? valueNormalizer(value) : value;
+    },
+
+    rerenderIfNeeded: function() {
+      this.currentState.rerenderIfNeeded(this);
+    }
+  });
 
-      // The root view's element
-      _element: null,
+});
+enifed('ember-views/mixins/template_rendering_support', ['exports', 'ember-metal/mixin', 'ember-metal/property_get'], function (exports, mixin, property_get) {
 
-      // The root view's contextualElement
-      _outerContextualElement: null,
+  'use strict';
 
-      /**
-        An internal set used to de-dupe class names when `addClass()` is
-        used. After each call to `addClass()`, the `classes` property
-        will be updated.
+  var _renderView;
+  function renderView(view, buffer, template) {
+    if (_renderView === undefined) {
+      _renderView = eriuqer('ember-htmlbars/system/render-view')['default'];
+    }
+    _renderView(view, buffer, template);
+  }
 
-        @private
-        @property elementClasses
-        @type Array
-        @default null
-      */
-      elementClasses: null,
+  var TemplateRenderingSupport = mixin.Mixin.create({
+    /**
+      Called on your view when it should push strings of HTML into a
+      `Ember.RenderBuffer`. Most users will want to override the `template`
+      or `templateName` properties instead of this method.
 
-      /**
-        Array of class names which will be applied in the class attribute.
+      By default, `Ember.View` will look for a function in the `template`
+      property and invoke it with the value of `context`. The value of
+      `context` will be the view's controller unless you override it.
 
-        You can use `setClasses()` to set this property directly. If you
-        use `addClass()`, it will be maintained for you.
+      @method render
+      @param {Ember.RenderBuffer} buffer The render buffer
+    */
+    render: function(buffer) {
+      // If this view has a layout, it is the responsibility of the
+      // the layout to render the view's template. Otherwise, render the template
+      // directly.
+      var template = property_get.get(this, 'layout') || property_get.get(this, 'template');
+      renderView(this, buffer, template);
+    }
+  });
+
+  exports['default'] = TemplateRenderingSupport;
+
+});
+enifed('ember-views/mixins/text_support', ['exports', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/mixin', 'ember-runtime/mixins/target_action_support'], function (exports, property_get, property_set, mixin, TargetActionSupport) {
+
+  'use strict';
+
+  /**
+  @module ember
+  @submodule ember-views
+  */
+
+  var TextSupport = mixin.Mixin.create(TargetActionSupport['default'], {
+    value: "",
+
+    attributeBindings: [
+      'autocapitalize',
+      'autocorrect',
+      'autofocus',
+      'disabled',
+      'form',
+      'maxlength',
+      'placeholder',
+      'readonly',
+      'required',
+      'selectionDirection',
+      'spellcheck',
+      'tabindex',
+      'title'
+    ],
+    placeholder: null,
+    disabled: false,
+    maxlength: null,
+
+    init: function() {
+      this._super.apply(this, arguments);
+      this.on("paste", this, this._elementValueDidChange);
+      this.on("cut", this, this._elementValueDidChange);
+      this.on("input", this, this._elementValueDidChange);
+    },
+
+    /**
+      The action to be sent when the user presses the return key.
+
+      This is similar to the `{{action}}` helper, but is fired when
+      the user presses the return key when editing a text field, and sends
+      the value of the field as the context.
+
+      @property action
+      @type String
+      @default null
+    */
+    action: null,
 
-        @property classes
-        @type Array
-        @default null
-      */
-      classes: null,
+    /**
+      The event that should send the action.
 
-      /**
-        The id in of the element, to be applied in the id attribute.
+      Options are:
 
-        You should not set this property yourself, rather, you should use
-        the `id()` method of `Ember.RenderBuffer`.
+      * `enter`: the user pressed enter
+      * `keyPress`: the user pressed a key
 
-        @property elementId
-        @type String
-        @default null
-      */
-      elementId: null,
+      @property onEvent
+      @type String
+      @default enter
+    */
+    onEvent: 'enter',
 
-      /**
-        A hash keyed on the name of the attribute and whose value will be
-        applied to that attribute. For example, if you wanted to apply a
-        `data-view="Foo.bar"` property to an element, you would set the
-        elementAttributes hash to `{'data-view':'Foo.bar'}`.
+    /**
+      Whether the `keyUp` event that triggers an `action` to be sent continues
+      propagating to other views.
 
-        You should not maintain this hash yourself, rather, you should use
-        the `attr()` method of `Ember.RenderBuffer`.
+      By default, when the user presses the return key on their keyboard and
+      the text field has an `action` set, the action will be sent to the view's
+      controller and the key event will stop propagating.
 
-        @property elementAttributes
-        @type Hash
-        @default {}
-      */
-      elementAttributes: null,
+      If you would like parent views to receive the `keyUp` event even after an
+      action has been dispatched, set `bubbles` to true.
 
-      /**
-        A hash keyed on the name of the properties and whose value will be
-        applied to that property. For example, if you wanted to apply a
-        `checked=true` property to an element, you would set the
-        elementProperties hash to `{'checked':true}`.
+      @property bubbles
+      @type Boolean
+      @default false
+    */
+    bubbles: false,
 
-        You should not maintain this hash yourself, rather, you should use
-        the `prop()` method of `Ember.RenderBuffer`.
+    interpretKeyEvents: function(event) {
+      var map = TextSupport.KEY_EVENTS;
+      var method = map[event.keyCode];
 
-        @property elementProperties
-        @type Hash
-        @default {}
-      */
-      elementProperties: null,
+      this._elementValueDidChange();
+      if (method) { return this[method](event); }
+    },
 
-      /**
-        The tagname of the element an instance of `Ember.RenderBuffer` represents.
+    _elementValueDidChange: function() {
+      property_set.set(this, 'value', this.$().val());
+    },
 
-        Usually, this gets set as the first parameter to `Ember.RenderBuffer`. For
-        example, if you wanted to create a `p` tag, then you would call
+    change: function(event) {
+      this._elementValueDidChange(event);
+    },
 
-        ```javascript
-        Ember.RenderBuffer('p', contextualElement)
-        ```
+    /**
+      Allows you to specify a controller action to invoke when either the `enter`
+      key is pressed or, in the case of the field being a textarea, when a newline
+      is inserted. To use this method, give your field an `insert-newline`
+      attribute. The value of that attribute should be the name of the action
+      in your controller that you wish to invoke.
 
-        @property elementTag
-        @type String
-        @default null
-      */
-      elementTag: null,
+      For an example on how to use the `insert-newline` attribute, please
+      reference the example near the top of this file.
+
+      @method insertNewline
+      @param {Event} event
+    */
+    insertNewline: function(event) {
+      sendAction('enter', this, event);
+      sendAction('insert-newline', this, event);
+    },
 
-      /**
-        A hash keyed on the name of the style attribute and whose value will
-        be applied to that attribute. For example, if you wanted to apply a
-        `background-color:black;` style to an element, you would set the
-        elementStyle hash to `{'background-color':'black'}`.
+    /**
+      Allows you to specify a controller action to invoke when the escape button
+      is pressed. To use this method, give your field an `escape-press`
+      attribute. The value of that attribute should be the name of the action
+      in your controller that you wish to invoke.
 
-        You should not maintain this hash yourself, rather, you should use
-        the `style()` method of `Ember.RenderBuffer`.
+      For an example on how to use the `escape-press` attribute, please reference
+      the example near the top of this file.
 
-        @property elementStyle
-        @type Hash
-        @default {}
-      */
-      elementStyle: null,
+      @method cancel
+      @param {Event} event
+    */
+    cancel: function(event) {
+      sendAction('escape-press', this, event);
+    },
 
-      pushChildView: function (view) {
-        var index = this.childViews.length;
-        this.childViews[index] = view;
-        this.push("<script id='morph-"+index+"' type='text/x-placeholder'>\x3C/script>");
-      },
+    /**
+      Allows you to specify a controller action to invoke when a field receives
+      focus. To use this method, give your field a `focus-in` attribute. The value
+      of that attribute should be the name of the action in your controller
+      that you wish to invoke.
 
-      hydrateMorphs: function (contextualElement) {
-        var childViews = this.childViews;
-        var el = this._element;
-        for (var i=0,l=childViews.length; i<l; i++) {
-          var childView = childViews[i];
-          var ref = el.querySelector('#morph-'+i);
-
-          Ember.assert('An error occurred while setting up template bindings. Please check ' +
-                       (childView && childView._parentView && childView._parentView._debugTemplateName ?
-                            '"' + childView._parentView._debugTemplateName + '" template ' :
-                            ''
-                       )  + 'for invalid markup or bindings within HTML comments.',
-                       ref);
-
-          var parent = ref.parentNode;
-
-          childView._morph = this.dom.insertMorphBefore(
-            parent,
-            ref,
-            parent.nodeType === 1 ? parent : contextualElement
-          );
-          parent.removeChild(ref);
-        }
-      },
+      For an example on how to use the `focus-in` attribute, please reference the
+      example near the top of this file.
 
-      /**
-        Adds a string of HTML to the `RenderBuffer`.
+      @method focusIn
+      @param {Event} event
+    */
+    focusIn: function(event) {
+      sendAction('focus-in', this, event);
+    },
 
-        @method push
-        @param {String} string HTML to push into the buffer
-        @chainable
-      */
-      push: function(content) {
-        if (typeof content === 'string') {
-          if (this.buffer === null) {
-            this.buffer = '';
-          }
-          Ember.assert("A string cannot be pushed into the buffer after a fragment", !this.buffer.nodeType);
-          this.buffer += content;
-        } else {
-          Ember.assert("A fragment cannot be pushed into a buffer that contains content", !this.buffer);
-          this.buffer = content;
-        }
-        return this;
-      },
+    /**
+      Allows you to specify a controller action to invoke when a field loses
+      focus. To use this method, give your field a `focus-out` attribute. The value
+      of that attribute should be the name of the action in your controller
+      that you wish to invoke.
 
-      /**
-        Adds a class to the buffer, which will be rendered to the class attribute.
+      For an example on how to use the `focus-out` attribute, please reference the
+      example near the top of this file.
 
-        @method addClass
-        @param {String} className Class name to add to the buffer
-        @chainable
-      */
-      addClass: function(className) {
-        // lazily create elementClasses
-        this.elementClasses = (this.elementClasses || new ClassSet());
-        this.elementClasses.add(className);
-        this.classes = this.elementClasses.list;
+      @method focusOut
+      @param {Event} event
+    */
+    focusOut: function(event) {
+      this._elementValueDidChange(event);
+      sendAction('focus-out', this, event);
+    },
 
-        return this;
-      },
+    /**
+      Allows you to specify a controller action to invoke when a key is pressed.
+      To use this method, give your field a `key-press` attribute. The value of
+      that attribute should be the name of the action in your controller you
+      that wish to invoke.
 
-      setClasses: function(classNames) {
-        this.elementClasses = null;
-        var len = classNames.length;
-        var i;
-        for (i = 0; i < len; i++) {
-          this.addClass(classNames[i]);
-        }
-      },
+      For an example on how to use the `key-press` attribute, please reference the
+      example near the top of this file.
 
-      /**
-        Sets the elementID to be used for the element.
+      @method keyPress
+      @param {Event} event
+    */
+    keyPress: function(event) {
+      sendAction('key-press', this, event);
+    },
 
-        @method id
-        @param {String} id
-        @chainable
-      */
-      id: function(id) {
-        this.elementId = id;
-        return this;
-      },
+    /**
+      Allows you to specify a controller action to invoke when a key-up event is
+      fired. To use this method, give your field a `key-up` attribute. The value
+      of that attribute should be the name of the action in your controller
+      that you wish to invoke.
 
-      // duck type attribute functionality like jQuery so a render buffer
-      // can be used like a jQuery object in attribute binding scenarios.
+      For an example on how to use the `key-up` attribute, please reference the
+      example near the top of this file.
 
-      /**
-        Adds an attribute which will be rendered to the element.
+      @method keyUp
+      @param {Event} event
+    */
+    keyUp: function(event) {
+      this.interpretKeyEvents(event);
 
-        @method attr
-        @param {String} name The name of the attribute
-        @param {String} value The value to add to the attribute
-        @chainable
-        @return {Ember.RenderBuffer|String} this or the current attribute value
-      */
-      attr: function(name, value) {
-        var attributes = this.elementAttributes = (this.elementAttributes || {});
+      this.sendAction('key-up', property_get.get(this, 'value'), event);
+    },
 
-        if (arguments.length === 1) {
-          return attributes[name];
-        } else {
-          attributes[name] = value;
-        }
+    /**
+      Allows you to specify a controller action to invoke when a key-down event is
+      fired. To use this method, give your field a `key-down` attribute. The value
+      of that attribute should be the name of the action in your controller that
+      you wish to invoke.
 
-        return this;
-      },
+      For an example on how to use the `key-down` attribute, please reference the
+      example near the top of this file.
 
-      /**
-        Remove an attribute from the list of attributes to render.
+      @method keyDown
+      @param {Event} event
+    */
+    keyDown: function(event) {
+      this.sendAction('key-down', property_get.get(this, 'value'), event);
+    }
+  });
 
-        @method removeAttr
-        @param {String} name The name of the attribute
-        @chainable
-      */
-      removeAttr: function(name) {
-        var attributes = this.elementAttributes;
-        if (attributes) { delete attributes[name]; }
+  TextSupport.KEY_EVENTS = {
+    13: 'insertNewline',
+    27: 'cancel'
+  };
 
-        return this;
-      },
+  // In principle, this shouldn't be necessary, but the legacy
+  // sendAction semantics for TextField are different from
+  // the component semantics so this method normalizes them.
+  function sendAction(eventName, view, event) {
+    var action = property_get.get(view, eventName);
+    var on = property_get.get(view, 'onEvent');
+    var value = property_get.get(view, 'value');
 
-      /**
-        Adds a property which will be rendered to the element.
+    // back-compat support for keyPress as an event name even though
+    // it's also a method name that consumes the event (and therefore
+    // incompatible with sendAction semantics).
+    if (on === eventName || (on === 'keyPress' && eventName === 'key-press')) {
+      view.sendAction('action', value);
+    }
 
-        @method prop
-        @param {String} name The name of the property
-        @param {String} value The value to add to the property
-        @chainable
-        @return {Ember.RenderBuffer|String} this or the current property value
-      */
-      prop: function(name, value) {
-        var properties = this.elementProperties = (this.elementProperties || {});
+    view.sendAction(eventName, value);
 
-        if (arguments.length === 1) {
-          return properties[name];
-        } else {
-          properties[name] = value;
-        }
+    if (action || on === eventName) {
+      if (!property_get.get(view, 'bubbles')) {
+        event.stopPropagation();
+      }
+    }
+  }
 
-        return this;
-      },
+  exports['default'] = TextSupport;
 
-      /**
-        Remove an property from the list of properties to render.
+});
+enifed('ember-views/mixins/view_child_views_support', ['exports', 'ember-metal/core', 'ember-metal/mixin', 'ember-metal/computed', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/set_properties', 'ember-metal/error', 'ember-metal/enumerable_utils', 'ember-runtime/system/native_array'], function (exports, Ember, mixin, computed, property_get, property_set, setProperties, EmberError, enumerable_utils, native_array) {
 
-        @method removeProp
-        @param {String} name The name of the property
-        @chainable
-      */
-      removeProp: function(name) {
-        var properties = this.elementProperties;
-        if (properties) { delete properties[name]; }
+  'use strict';
 
-        return this;
-      },
+  var childViewsProperty = computed.computed(function() {
+    var childViews = this._childViews;
+    var ret = native_array.A();
 
-      /**
-        Adds a style to the style attribute which will be rendered to the element.
+    enumerable_utils.forEach(childViews, function(view) {
+      var currentChildViews;
+      if (view.isVirtual) {
+        if (currentChildViews = property_get.get(view, 'childViews')) {
+          ret.pushObjects(currentChildViews);
+        }
+      } else {
+        ret.push(view);
+      }
+    });
 
-        @method style
-        @param {String} name Name of the style
-        @param {String} value
-        @chainable
-      */
-      style: function(name, value) {
-        this.elementStyle = (this.elementStyle || {});
+    ret.replace = function (idx, removedCount, addedViews) {
+      throw new EmberError['default']("childViews is immutable");
+    };
 
-        this.elementStyle[name] = value;
-        return this;
-      },
+    return ret;
+  });
 
-      generateElement: function() {
-        var tagName = this.tagName;
-        var id = this.elementId;
-        var classes = this.classes;
-        var attrs = this.elementAttributes;
-        var props = this.elementProperties;
-        var style = this.elementStyle;
-        var styleBuffer = '';
-        var attr, prop, tagString;
-
-        if (attrs && attrs.name && !canSetNameOnInputs) {
-          // IE allows passing a tag to createElement. See note on `canSetNameOnInputs` above as well.
-          tagString = '<'+stripTagName(tagName)+' name="'+escapeAttribute(attrs.name)+'">';
-        } else {
-          tagString = tagName;
-        }
+  var EMPTY_ARRAY = [];
 
-        var element = this.dom.createElement(tagString, this.outerContextualElement());
+  var ViewChildViewsSupport = mixin.Mixin.create({
+    /**
+      Array of child views. You should never edit this array directly.
+      Instead, use `appendChild` and `removeFromParent`.
 
-        if (id) {
-          this.dom.setAttribute(element, 'id', id);
-          this.elementId = null;
-        }
-        if (classes) {
-          this.dom.setAttribute(element, 'class', classes.join(' '));
-          this.classes = null;
-          this.elementClasses = null;
-        }
+      @property childViews
+      @type Array
+      @default []
+      @private
+    */
+    childViews: childViewsProperty,
 
-        if (style) {
-          for (prop in style) {
-            styleBuffer += (prop + ':' + style[prop] + ';');
-          }
+    _childViews: EMPTY_ARRAY,
 
-          this.dom.setAttribute(element, 'style', styleBuffer);
+    init: function() {
+      // setup child views. be sure to clone the child views array first
+      this._childViews = this._childViews.slice();
 
-          this.elementStyle = null;
-        }
+      this._super.apply(this, arguments);
+    },
 
-        if (attrs) {
-          for (attr in attrs) {
-            this.dom.setAttribute(element, attr, attrs[attr]);
-          }
+    appendChild: function(view, options) {
+      return this.currentState.appendChild(this, view, options);
+    },
 
-          this.elementAttributes = null;
-        }
+    /**
+      Removes the child view from the parent view.
 
-        if (props) {
-          for (prop in props) {
-            var normalizedCase = normalizeProperty(element, prop.toLowerCase()) || prop;
+      @method removeChild
+      @param {Ember.View} view
+      @return {Ember.View} receiver
+    */
+    removeChild: function(view) {
+      // If we're destroying, the entire subtree will be
+      // freed, and the DOM will be handled separately,
+      // so no need to mess with childViews.
+      if (this.isDestroying) { return; }
 
-            this.dom.setPropertyStrict(element, normalizedCase, props[prop]);
-          }
+      // update parent node
+      property_set.set(view, '_parentView', null);
 
-          this.elementProperties = null;
-        }
+      // remove view from childViews array.
+      var childViews = this._childViews;
 
-        this._element = element;
-      },
+      enumerable_utils.removeObject(childViews, view);
 
-      /**
-        @method element
-        @return {DOMElement} The element corresponding to the generated HTML
-          of this buffer
-      */
-      element: function() {
-        var content = this.innerContent();
-        // No content means a text node buffer, with the content
-        // in _element. Ember._BoundView is an example.
-        if (content === null)  {
-          return this._element;
-        }
+      this.propertyDidChange('childViews'); // HUH?! what happened to will change?
 
-        var contextualElement = this.innerContextualElement(content);
-        this.dom.detectNamespace(contextualElement);
+      return this;
+    },
 
-        if (!this._element) {
-          this._element = document.createDocumentFragment();
-        }
+    /**
+      Instantiates a view to be added to the childViews array during view
+      initialization. You generally will not call this method directly unless
+      you are overriding `createChildViews()`. Note that this method will
+      automatically configure the correct settings on the new view instance to
+      act as a child of the parent.
 
-        if (content.nodeType) {
-          this._element.appendChild(content);
-        } else {
-          var nodes;
-          nodes = this.dom.parseHTML(content, contextualElement);
-          while (nodes[0]) {
-            this._element.appendChild(nodes[0]);
-          }
-        }
-        // This should only happen with legacy string buffers
-        if (this.childViews.length > 0) {
-          this.hydrateMorphs(contextualElement);
-        }
+      @method createChildView
+      @param {Class|String} viewClass
+      @param {Hash} [attrs] Attributes to add
+      @return {Ember.View} new instance
+    */
+    createChildView: function(maybeViewClass, _attrs) {
+      if (!maybeViewClass) {
+        throw new TypeError("createChildViews first argument must exist");
+      }
 
-        return this._element;
-      },
+      if (maybeViewClass.isView && maybeViewClass._parentView === this && maybeViewClass.container === this.container) {
+        return maybeViewClass;
+      }
 
-      /**
-        Generates the HTML content for this buffer.
+      var attrs = _attrs || {};
+      var view;
+      attrs._parentView = this;
+      attrs.renderer = this.renderer;
 
-        @method string
-        @return {String} The generated HTML
-      */
-      string: function() {
-        if (this._element) {
-          // Firefox versions < 11 do not have support for element.outerHTML.
-          var thisElement = this.element();
-          var outerHTML = thisElement.outerHTML;
-          if (typeof outerHTML === 'undefined') {
-            return jQuery('<div/>').append(thisElement).html();
-          }
-          return outerHTML;
-        } else {
-          return this.innerString();
-        }
-      },
+      if (maybeViewClass.isViewClass) {
+        attrs.container = this.container;
 
-      outerContextualElement: function() {
-        if (!this._outerContextualElement) {
-          Ember.deprecate("The render buffer expects an outer contextualElement to exist." +
-                          " This ensures DOM that requires context is correctly generated (tr, SVG tags)." +
-                          " Defaulting to document.body, but this will be removed in the future");
-          this.outerContextualElement = document.body;
-        }
-        return this._outerContextualElement;
-      },
+        view = maybeViewClass.create(attrs);
 
-      innerContextualElement: function(html) {
-        var innerContextualElement;
-        if (this._element && this._element.nodeType === 1) {
-          innerContextualElement = this._element;
-        } else {
-          innerContextualElement = this.outerContextualElement();
+        // don't set the property on a virtual view, as they are invisible to
+        // consumers of the view API
+        if (view.viewName) {
+          property_set.set(property_get.get(this, 'concreteView'), view.viewName, view);
         }
+      } else if ('string' === typeof maybeViewClass) {
+        var fullName = 'view:' + maybeViewClass;
+        var ViewKlass = this.container.lookupFactory(fullName);
 
-        var omittedStartTag;
-        if (html) {
-          omittedStartTag = detectOmittedStartTag(html, innerContextualElement);
-        }
-        return omittedStartTag || innerContextualElement;
-      },
+        Ember['default'].assert("Could not find view: '" + fullName + "'", !!ViewKlass);
 
-      innerString: function() {
-        var content = this.innerContent();
-        if (content && !content.nodeType) {
-          return content;
-        }
-      },
+        view = ViewKlass.create(attrs);
+      } else {
+        view = maybeViewClass;
+        Ember['default'].assert('You must pass instance or subclass of View', view.isView);
 
-      innerContent: function() {
-        return this.buffer;
+        attrs.container = this.container;
+        setProperties['default'](view, attrs);
       }
-    };
-  });
-enifed("ember-views/system/renderer",
-  ["ember-metal/core","ember-metal-views/renderer","ember-metal/platform","ember-views/system/render_buffer","ember-metal/run_loop","ember-metal/property_set","ember-metal/property_get","ember-metal/instrumentation","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var Renderer = __dependency2__["default"];
-    var create = __dependency3__.create;
-    var renderBuffer = __dependency4__["default"];
-    var run = __dependency5__["default"];
-    var set = __dependency6__.set;
-    var get = __dependency7__.get;
-    var _instrumentStart = __dependency8__._instrumentStart;
-    var subscribers = __dependency8__.subscribers;
-
-    function EmberRenderer() {
-      this.buffer = renderBuffer();
-      this._super$constructor();
-    }
-
-    EmberRenderer.prototype = create(Renderer.prototype);
-    EmberRenderer.prototype.constructor = EmberRenderer;
-    EmberRenderer.prototype._super$constructor = Renderer;
-
-    EmberRenderer.prototype.scheduleRender =
-      function EmberRenderer_scheduleRender(ctx, fn) {
-        return run.scheduleOnce('render', ctx, fn);
-      };
 
-    EmberRenderer.prototype.cancelRender =
-      function EmberRenderer_cancelRender(id) {
-        run.cancel(id);
-      };
+      return view;
+    }
+  });
 
-    EmberRenderer.prototype.createElement =
-      function EmberRenderer_createElement(view, contextualElement) {
-        // If this is the top-most view, start a new buffer. Otherwise,
-        // create a new buffer relative to the original using the
-        // provided buffer operation (for example, `insertAfter` will
-        // insert a new buffer after the "parent buffer").
-        var tagName = view.tagName;
-        if (tagName === undefined) {
-          tagName = get(view, 'tagName');
-          Ember.deprecate('In the future using a computed property to define tagName will not be permitted. That value will be respected, but changing it will not update the element.', !tagName);
-        }
-        var classNameBindings = view.classNameBindings;
-        var taglessViewWithClassBindings = tagName === '' && (classNameBindings && classNameBindings.length > 0);
+  exports['default'] = ViewChildViewsSupport;
 
-        if (tagName === null || tagName === undefined) {
-          tagName = 'div';
-        }
+  exports.childViewsProperty = childViewsProperty;
 
-        Ember.assert('You cannot use `classNameBindings` on a tag-less view: ' + view.toString(), !taglessViewWithClassBindings);
+});
+enifed('ember-views/mixins/view_context_support', ['exports', 'ember-metal/mixin', 'ember-metal/computed', 'ember-metal/property_get', 'ember-metal/property_set'], function (exports, mixin, computed, property_get, property_set) {
 
-        var buffer = view.buffer = this.buffer;
-        buffer.reset(tagName, contextualElement);
+  'use strict';
 
-        if (view.beforeRender) {
-          view.beforeRender(buffer);
-        }
+  var ViewContextSupport = mixin.Mixin.create({
+    /**
+      The object from which templates should access properties.
 
-        if (tagName !== '') {
-          if (view.applyAttributesToBuffer) {
-            view.applyAttributesToBuffer(buffer);
-          }
-          buffer.generateElement();
-        }
+      This object will be passed to the template function each time the render
+      method is called, but it is up to the individual function to decide what
+      to do with it.
 
-        if (view.render) {
-          view.render(buffer);
-        }
+      By default, this will be the view's controller.
 
-        if (view.afterRender) {
-          view.afterRender(buffer);
-        }
+      @property context
+      @type Object
+    */
+    context: computed.computed(function(key, value) {
+      if (arguments.length === 2) {
+        property_set.set(this, '_context', value);
+        return value;
+      } else {
+        return property_get.get(this, '_context');
+      }
+    })["volatile"](),
 
-        var element = buffer.element();
+    /**
+      Private copy of the view's template context. This can be set directly
+      by Handlebars without triggering the observer that causes the view
+      to be re-rendered.
 
-        view.buffer = null;
-        if (element && element.nodeType === 1) {
-          view.element = element;
-        }
-        return element;
-      };
+      The context of a view is looked up as follows:
 
-    EmberRenderer.prototype.destroyView = function destroyView(view) {
-      view.removedFromDOM = true;
-      view.destroy();
-    };
+      1. Supplied context (usually by Handlebars)
+      2. Specified controller
+      3. `parentView`'s context (for a child of a ContainerView)
 
-    EmberRenderer.prototype.childViews = function childViews(view) {
-      return view._childViews;
-    };
+      The code in Handlebars that overrides the `_context` property first
+      checks to see whether the view has a specified controller. This is
+      something of a hack and should be revisited.
 
-    Renderer.prototype.willCreateElement = function (view) {
-      if (subscribers.length && view.instrumentDetails) {
-        view._instrumentEnd = _instrumentStart('render.'+view.instrumentName, function viewInstrumentDetails() {
-          var details = {};
-          view.instrumentDetails(details);
-          return details;
-        });
-      }
-      if (view._transitionTo) {
-        view._transitionTo('inBuffer');
-      }
-    }; // inBuffer
-    Renderer.prototype.didCreateElement = function (view) {
-      if (view._transitionTo) {
-        view._transitionTo('hasElement');
+      @property _context
+      @private
+    */
+    _context: computed.computed(function(key, value) {
+      if (arguments.length === 2) {
+        return value;
       }
-      if (view._instrumentEnd) {
-        view._instrumentEnd();
+
+      var parentView, controller;
+
+      if (controller = property_get.get(this, 'controller')) {
+        return controller;
       }
-    }; // hasElement
-    Renderer.prototype.willInsertElement = function (view) {
-      if (view.trigger) { view.trigger('willInsertElement'); }
-    }; // will place into DOM
-    Renderer.prototype.didInsertElement = function (view) {
-      if (view._transitionTo) {
-        view._transitionTo('inDOM');
+
+      parentView = this._parentView;
+      if (parentView) {
+        return property_get.get(parentView, '_context');
       }
-      if (view.trigger) { view.trigger('didInsertElement'); }
-    }; // inDOM // placed into DOM
 
-    Renderer.prototype.willRemoveElement = function (view) {};
+      return null;
+    }),
 
-    Renderer.prototype.willDestroyElement = function (view) {
-      if (view.trigger) { view.trigger('willDestroyElement'); }
-      if (view.trigger) { view.trigger('willClearRender'); }
-    };
+    _controller: null,
+
+    /**
+      The controller managing this view. If this property is set, it will be
+      made available for use by the template.
 
-    Renderer.prototype.didDestroyElement = function (view) {
-      set(view, 'element', null);
-      if (view._transitionTo) {
-        view._transitionTo('preRender');
+      @property controller
+      @type Object
+    */
+    controller: computed.computed(function(key, value) {
+      if (arguments.length === 2) {
+        this._controller = value;
+        return value;
       }
-    }; // element destroyed so view.destroy shouldn't try to remove it removedFromDOM
 
-    __exports__["default"] = EmberRenderer;
+      if (this._controller) {
+        return this._controller;
+      }
+
+      var parentView = this._parentView;
+      return parentView ? property_get.get(parentView, 'controller') : null;
+    })
   });
-enifed("ember-views/system/sanitize_attribute_value",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /* jshint scripturl:true */
 
-    var parsingNode;
-    var badProtocols = {
-      'javascript:': true,
-      'vbscript:': true
-    };
+  exports['default'] = ViewContextSupport;
 
-    var badTags = {
-      'A': true,
-      'BODY': true,
-      'LINK': true,
-      'IMG': true,
-      'IFRAME': true
-    };
+});
+enifed('ember-views/mixins/view_keyword_support', ['exports', 'ember-metal/mixin', 'ember-metal/platform/create', 'ember-views/streams/key_stream'], function (exports, mixin, create, KeyStream) {
 
-    var badAttributes = {
-      'href': true,
-      'src': true,
-      'background': true
-    };
-    __exports__.badAttributes = badAttributes;
-    __exports__["default"] = function sanitizeAttributeValue(element, attribute, value) {
-      var tagName;
+  'use strict';
 
-      if (!parsingNode) {
-        parsingNode = document.createElement('a');
-      }
+  var ViewKeywordSupport = mixin.Mixin.create({
+    init: function() {
+      this._super.apply(this, arguments);
 
-      if (!element) {
-        tagName = null;
-      } else {
-        tagName = element.tagName;
+      if (!this._keywords) {
+        this._keywords = create['default'](null);
       }
+      this._keywords._view = this;
+      this._keywords.view = undefined;
+      this._keywords.controller = new KeyStream['default'](this, 'controller');
+      this._setupKeywords();
+    },
 
-      if (value && value.toHTML) {
-        return value.toHTML();
-      }
+    _setupKeywords: function() {
+      var keywords = this._keywords;
+      var contextView = this._contextView || this._parentView;
 
-      if ((tagName === null || badTags[tagName]) && badAttributes[attribute]) {
-        parsingNode.href = value;
+      if (contextView) {
+        var parentKeywords = contextView._keywords;
 
-        if (badProtocols[parsingNode.protocol] === true) {
-          return 'unsafe:' + value;
+        keywords.view = this.isVirtual ? parentKeywords.view : this;
+
+        for (var name in parentKeywords) {
+          if (keywords[name]) {
+            continue;
+          }
+
+          keywords[name] = parentKeywords[name];
         }
+      } else {
+        keywords.view = this.isVirtual ? null : this;
       }
-
-      return value;
     }
   });
-enifed("ember-views/system/utils",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-views
-    */
 
-    function isSimpleClick(event) {
-      var modifier = event.shiftKey || event.metaKey || event.altKey || event.ctrlKey;
-      var secondaryClick = event.which > 1; // IE9 may return undefined
+  exports['default'] = ViewKeywordSupport;
 
-      return !modifier && !secondaryClick;
-    }
+});
+enifed('ember-views/mixins/view_state_support', ['exports', 'ember-metal/core', 'ember-metal/mixin'], function (exports, Ember, mixin) {
 
-    __exports__.isSimpleClick = isSimpleClick;/**
-      @private
-      @method getViewRange
-      @param {Ember.View} view
-    */
-    function getViewRange(view) {
-      var range = document.createRange();
-      range.setStartAfter(view._morph.start);
-      range.setEndBefore(view._morph.end);
-      return range;
-    }
+  'use strict';
 
-    /**
-      `getViewClientRects` provides information about the position of the border
-      box edges of a view relative to the viewport.
+  var ViewStateSupport = mixin.Mixin.create({
+    transitionTo: function(state, children) {
+      Ember['default'].deprecate("Ember.View#transitionTo has been deprecated, it is for internal use only");
+      this._transitionTo(state, children);
+    },
 
-      It is only intended to be used by development tools like the Ember Inpsector
-      and may not work on older browsers.
+    _transitionTo: function(state, children) {
+      var priorState = this.currentState;
+      var currentState = this.currentState = this._states[state];
+      this._state = state;
 
-      @private
-      @method getViewClientRects
-      @param {Ember.View} view
-    */
-    function getViewClientRects(view) {
-      var range = getViewRange(view);
-      return range.getClientRects();
+      if (priorState && priorState.exit) { priorState.exit(this); }
+      if (currentState.enter) { currentState.enter(this); }
     }
+  });
 
-    __exports__.getViewClientRects = getViewClientRects;/**
-      `getViewBoundingClientRect` provides information about the position of the
-      bounding border box edges of a view relative to the viewport.
+  exports['default'] = ViewStateSupport;
 
-      It is only intended to be used by development tools like the Ember Inpsector
-      and may not work on older browsers.
+});
+enifed('ember-views/mixins/view_stream_support', ['exports', 'ember-metal/mixin', 'ember-metal/streams/stream_binding', 'ember-views/streams/key_stream', 'ember-views/streams/context_stream', 'ember-metal/platform/create', 'ember-metal/streams/utils'], function (exports, mixin, StreamBinding, KeyStream, ContextStream, create, utils) {
 
-      @private
-      @method getViewBoundingClientRect
-      @param {Ember.View} view
-    */
-    function getViewBoundingClientRect(view) {
-      var range = getViewRange(view);
-      return range.getBoundingClientRect();
-    }
+  'use strict';
 
-    __exports__.getViewBoundingClientRect = getViewBoundingClientRect;
-  });
-enifed("ember-views/views/bound_view",
-  ["ember-metal/property_get","ember-metal/property_set","ember-metal/merge","ember-htmlbars/utils/string","ember-views/views/states","ember-views/views/metamorph_view","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-views
-    */
+  var ViewStreamSupport = mixin.Mixin.create({
+    init: function() {
+      this._baseContext = undefined;
+      this._contextStream = undefined;
+      this._streamBindings = undefined;
+      this._super.apply(this, arguments);
+    },
 
-    var get = __dependency1__.get;
-    var set = __dependency2__.set;
-    var merge = __dependency3__["default"];
-    var escapeExpression = __dependency4__.escapeExpression;
-    var SafeString = __dependency4__.SafeString;
-    var cloneStates = __dependency5__.cloneStates;
-    var viewStates = __dependency5__.states;
-    var _MetamorphView = __dependency6__["default"];
+    getStream: function(path) {
+      var stream = this._getContextStream().get(path);
 
-    function K() { return this; }
+      stream._label = path;
 
-    var states = cloneStates(viewStates);
+      return stream;
+    },
 
-    merge(states._default, {
-      rerenderIfNeeded: K
-    });
+    _willDestroyElement: function() {
+      if (this._streamBindings) {
+        this._destroyStreamBindings();
+      }
+      if (this._contextStream) {
+        this._destroyContextStream();
+      }
+    },
 
-    merge(states.inDOM, {
-      rerenderIfNeeded: function(view) {
-        if (view.normalizedValue() !== view._lastNormalizedValue) {
-          view.rerender();
-        }
+    _getBindingForStream: function(pathOrStream) {
+      if (this._streamBindings === undefined) {
+        this._streamBindings = create['default'](null);
       }
-    });
 
-    /**
-      `Ember._BoundView` is a private view created by the Handlebars
-      `{{bind}}` helpers that is used to keep track of bound properties.
+      var path = pathOrStream;
+      if (utils.isStream(pathOrStream)) {
+        path = pathOrStream._label;
 
-      Every time a property is bound using a `{{mustache}}`, an anonymous subclass
-      of `Ember._BoundView` is created with the appropriate sub-template
-      and context set up. When the associated property changes, just the template
-      for this view will re-render.
+        if (!path) {
+          // if no _label is present on the provided stream
+          // it is likely a subexpr and cannot be set (so it
+          // does not need a StreamBinding)
+          return pathOrStream;
+        }
+      }
 
-      @class _BoundView
-      @namespace Ember
-      @extends Ember._MetamorphView
-      @private
-    */
-    var BoundView = _MetamorphView.extend({
-      instrumentName: 'bound',
+      if (this._streamBindings[path] !== undefined) {
+        return this._streamBindings[path];
+      } else {
+        var stream = this._getContextStream().get(path);
+        var streamBinding = new StreamBinding['default'](stream);
 
-      _states: states,
+        streamBinding._label = path;
 
-      /**
-        The function used to determine if the `displayTemplate` or
-        `inverseTemplate` should be rendered. This should be a function that takes
-        a value and returns a Boolean.
+        return this._streamBindings[path] = streamBinding;
+      }
+    },
 
-        @property shouldDisplayFunc
-        @type Function
-        @default null
-      */
-      shouldDisplayFunc: null,
+    _destroyStreamBindings: function() {
+      var streamBindings = this._streamBindings;
+      for (var path in streamBindings) {
+        streamBindings[path].destroy();
+      }
+      this._streamBindings = undefined;
+    },
 
-      /**
-        Whether the template rendered by this view gets passed the context object
-        of its parent template, or gets passed the value of retrieving `path`
-        from the `pathRoot`.
-
-        For example, this is true when using the `{{#if}}` helper, because the
-        template inside the helper should look up properties relative to the same
-        object as outside the block. This would be `false` when used with `{{#with
-        foo}}` because the template should receive the object found by evaluating
-        `foo`.
-
-        @property preserveContext
-        @type Boolean
-        @default false
-      */
-      preserveContext: false,
+    _getContextStream: function() {
+      if (this._contextStream === undefined) {
+        this._baseContext = new KeyStream['default'](this, 'context');
+        this._contextStream = new ContextStream['default'](this);
+      }
 
-      /**
-        If `preserveContext` is true, this is the object that will be used
-        to render the template.
+      return this._contextStream;
+    },
 
-        @property previousContext
-        @type Object
-      */
-      previousContext: null,
+    _destroyContextStream: function() {
+      this._baseContext.destroy();
+      this._baseContext = undefined;
+      this._contextStream.destroy();
+      this._contextStream = undefined;
+    },
 
-      /**
-        The template to render when `shouldDisplayFunc` evaluates to `true`.
+    _unsubscribeFromStreamBindings: function() {
+      for (var key in this._streamBindingSubscriptions) {
+        var streamBinding = this[key + 'Binding'];
+        var callback = this._streamBindingSubscriptions[key];
+        streamBinding.unsubscribe(callback);
+      }
+    }
+  });
 
-        @property displayTemplate
-        @type Function
-        @default null
-      */
-      displayTemplate: null,
+  exports['default'] = ViewStreamSupport;
 
-      /**
-        The template to render when `shouldDisplayFunc` evaluates to `false`.
+});
+enifed('ember-views/mixins/view_target_action_support', ['exports', 'ember-metal/mixin', 'ember-runtime/mixins/target_action_support', 'ember-metal/alias'], function (exports, mixin, TargetActionSupport, alias) {
 
-        @property inverseTemplate
-        @type Function
-        @default null
-      */
-      inverseTemplate: null,
+  'use strict';
 
-      lazyValue: null,
+  exports['default'] = mixin.Mixin.create(TargetActionSupport['default'], {
+    /**
+    @property target
+    */
+    target: alias['default']('controller'),
+    /**
+    @property actionContext
+    */
+    actionContext: alias['default']('context')
+  });
 
-      normalizedValue: function() {
-        var value = this.lazyValue.value();
-        var valueNormalizer = get(this, 'valueNormalizerFunc');
-        return valueNormalizer ? valueNormalizer(value) : value;
-      },
+});
+enifed('ember-views/mixins/visibility_support', ['exports', 'ember-metal/mixin', 'ember-metal/property_get', 'ember-metal/run_loop'], function (exports, mixin, property_get, run) {
 
-      rerenderIfNeeded: function() {
-        this.currentState.rerenderIfNeeded(this);
-      },
+  'use strict';
 
-      /**
-        Determines which template to invoke, sets up the correct state based on
-        that logic, then invokes the default `Ember.View` `render` implementation.
+  function K() { return this; }
 
-        This method will first look up the `path` key on `pathRoot`,
-        then pass that value to the `shouldDisplayFunc` function. If that returns
-        `true,` the `displayTemplate` function will be rendered to DOM. Otherwise,
-        `inverseTemplate`, if specified, will be rendered.
+  var VisibilitySupport = mixin.Mixin.create({
+    /**
+      If `false`, the view will appear hidden in DOM.
 
-        For example, if this `Ember._BoundView` represented the `{{#with
-        foo}}` helper, it would look up the `foo` property of its context, and
-        `shouldDisplayFunc` would always return true. The object found by looking
-        up `foo` would be passed to `displayTemplate`.
+      @property isVisible
+      @type Boolean
+      @default null
+    */
+    isVisible: true,
 
-        @method render
-        @param {Ember.RenderBuffer} buffer
-      */
-      render: function(buffer) {
-        // If not invoked via a triple-mustache ({{{foo}}}), escape
-        // the content of the template.
-        var escape = get(this, 'isEscaped');
+    becameVisible: K,
+    becameHidden: K,
 
-        var shouldDisplay = get(this, 'shouldDisplayFunc');
-        var preserveContext = get(this, 'preserveContext');
-        var context = get(this, 'previousContext');
+    /**
+      When the view's `isVisible` property changes, toggle the visibility
+      element of the actual DOM element.
 
-        var inverseTemplate = get(this, 'inverseTemplate');
-        var displayTemplate = get(this, 'displayTemplate');
+      @method _isVisibleDidChange
+      @private
+    */
+    _isVisibleDidChange: mixin.observer('isVisible', function() {
+      if (this._isVisible === property_get.get(this, 'isVisible')) { return ; }
+      run['default'].scheduleOnce('render', this, this._toggleVisibility);
+    }),
 
-        var result = this.normalizedValue();
+    _toggleVisibility: function() {
+      var $el = this.$();
+      var isVisible = property_get.get(this, 'isVisible');
 
-        this._lastNormalizedValue = result;
+      if (this._isVisible === isVisible) { return ; }
 
-        // First, test the conditional to see if we should
-        // render the template or not.
-        if (shouldDisplay(result)) {
-          set(this, 'template', displayTemplate);
+      // It's important to keep these in sync, even if we don't yet have
+      // an element in the DOM to manipulate:
+      this._isVisible = isVisible;
 
-          // If we are preserving the context (for example, if this
-          // is an #if block, call the template with the same object.
-          if (preserveContext) {
-            set(this, '_context', context);
-          } else {
-          // Otherwise, determine if this is a block bind or not.
-          // If so, pass the specified object to the template
-            if (displayTemplate) {
-              set(this, '_context', result);
-            } else {
-            // This is not a bind block, just push the result of the
-            // expression to the render context and return.
-              if (result === null || result === undefined) {
-                result = "";
-              } else if (!(result instanceof SafeString)) {
-                result = String(result);
-              }
+      if (!$el) { return; }
 
-              if (escape) { result = escapeExpression(result); }
-              buffer.push(result);
-              return;
-            }
-          }
-        } else if (inverseTemplate) {
-          set(this, 'template', inverseTemplate);
+      $el.toggle(isVisible);
 
-          if (preserveContext) {
-            set(this, '_context', context);
-          } else {
-            set(this, '_context', result);
-          }
-        } else {
-          set(this, 'template', function() { return ''; });
-        }
+      if (this._isAncestorHidden()) { return; }
 
-        return this._super(buffer);
+      if (isVisible) {
+        this._notifyBecameVisible();
+      } else {
+        this._notifyBecameHidden();
       }
-    });
+    },
 
-    __exports__["default"] = BoundView;
-  });
-enifed("ember-views/views/checkbox",
-  ["ember-metal/property_get","ember-metal/property_set","ember-views/views/view","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var get = __dependency1__.get;
-    var set = __dependency2__.set;
-    var View = __dependency3__["default"];
+    _notifyBecameVisible: function() {
+      this.trigger('becameVisible');
 
-    /**
-    @module ember
-    @submodule ember-views
-    */
+      this.forEachChildView(function(view) {
+        var isVisible = property_get.get(view, 'isVisible');
 
-    /**
-      The internal class used to create text inputs when the `{{input}}`
-      helper is used with `type` of `checkbox`.
+        if (isVisible || isVisible === null) {
+          view._notifyBecameVisible();
+        }
+      });
+    },
 
-      See [handlebars.helpers.input](/api/classes/Ember.Handlebars.helpers.html#method_input)  for usage details.
+    _notifyBecameHidden: function() {
+      this.trigger('becameHidden');
+      this.forEachChildView(function(view) {
+        var isVisible = property_get.get(view, 'isVisible');
 
-      ## Direct manipulation of `checked`
+        if (isVisible || isVisible === null) {
+          view._notifyBecameHidden();
+        }
+      });
+    },
 
-      The `checked` attribute of an `Ember.Checkbox` object should always be set
-      through the Ember object or by interacting with its rendered element
-      representation via the mouse, keyboard, or touch. Updating the value of the
-      checkbox via jQuery will result in the checked value of the object and its
-      element losing synchronization.
+    _isAncestorHidden: function() {
+      var parent = property_get.get(this, 'parentView');
 
-      ## Layout and LayoutName properties
+      while (parent) {
+        if (property_get.get(parent, 'isVisible') === false) { return true; }
 
-      Because HTML `input` elements are self closing `layout` and `layoutName`
-      properties will not be applied. See [Ember.View](/api/classes/Ember.View.html)'s
-      layout section for more information.
+        parent = property_get.get(parent, 'parentView');
+      }
 
-      @class Checkbox
-      @namespace Ember
-      @extends Ember.View
-    */
-    __exports__["default"] = View.extend({
-      instrumentDisplay: '{{input type="checkbox"}}',
+      return false;
+    }
+  });
 
-      classNames: ['ember-checkbox'],
+  exports['default'] = VisibilitySupport;
 
-      tagName: 'input',
+});
+enifed('ember-views/streams/class_name_binding', ['exports', 'ember-metal/streams/utils', 'ember-metal/property_get', 'ember-runtime/system/string', 'ember-metal/utils'], function (exports, utils, property_get, string, ember_metal__utils) {
 
-      attributeBindings: [
-        'type',
-        'checked',
-        'indeterminate',
-        'disabled',
-        'tabindex',
-        'name',
-        'autofocus',
-        'required',
-        'form'
-      ],
+  'use strict';
 
-      type: 'checkbox',
-      checked: false,
-      disabled: false,
-      indeterminate: false,
+  exports.parsePropertyPath = parsePropertyPath;
+  exports.classStringForValue = classStringForValue;
+  exports.streamifyClassNameBinding = streamifyClassNameBinding;
 
-      init: function() {
-        this._super();
-        this.on('change', this, this._updateElementValue);
-      },
+  function parsePropertyPath(path) {
+    var split = path.split(':');
+    var propertyPath = split[0];
+    var classNames = "";
+    var className, falsyClassName;
 
-      didInsertElement: function() {
-        this._super();
-        get(this, 'element').indeterminate = !!get(this, 'indeterminate');
-      },
+    // check if the property is defined as prop:class or prop:trueClass:falseClass
+    if (split.length > 1) {
+      className = split[1];
+      if (split.length === 3) {
+        falsyClassName = split[2];
+      }
 
-      _updateElementValue: function() {
-        set(this, 'checked', this.$().prop('checked'));
+      classNames = ':' + className;
+      if (falsyClassName) {
+        classNames += ":" + falsyClassName;
       }
-    });
-  });
-enifed("ember-views/views/collection_view",
-  ["ember-metal/core","ember-metal/binding","ember-metal/property_get","ember-metal/property_set","ember-runtime/system/string","ember-views/views/container_view","ember-views/views/core_view","ember-views/views/view","ember-metal/mixin","ember-views/streams/utils","ember-runtime/mixins/array","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __exports__) {
-    "use strict";
+    }
 
-    /**
-    @module ember
-    @submodule ember-views
-    */
+    return {
+      path: propertyPath,
+      classNames: classNames,
+      className: (className === '') ? undefined : className,
+      falsyClassName: falsyClassName
+    };
+  }
 
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var isGlobalPath = __dependency2__.isGlobalPath;
-    var get = __dependency3__.get;
-    var set = __dependency4__.set;
-    var fmt = __dependency5__.fmt;
-    var ContainerView = __dependency6__["default"];
-    var CoreView = __dependency7__["default"];
-    var View = __dependency8__["default"];
-    var observer = __dependency9__.observer;
-    var beforeObserver = __dependency9__.beforeObserver;
-    var readViewFactory = __dependency10__.readViewFactory;
-    var EmberArray = __dependency11__["default"];
+  /**
+    Get the class name for a given value, based on the path, optional
+    `className` and optional `falsyClassName`.
+
+    - if a `className` or `falsyClassName` has been specified:
+      - if the value is truthy and `className` has been specified,
+        `className` is returned
+      - if the value is falsy and `falsyClassName` has been specified,
+        `falsyClassName` is returned
+      - otherwise `null` is returned
+    - if the value is `true`, the dasherized last part of the supplied path
+      is returned
+    - if the value is not `false`, `undefined` or `null`, the `value`
+      is returned
+    - if none of the above rules apply, `null` is returned
+
+    @method classStringForValue
+    @param path
+    @param val
+    @param className
+    @param falsyClassName
+    @static
+    @private
+  */
+  function classStringForValue(path, val, className, falsyClassName) {
+    if (ember_metal__utils.isArray(val)) {
+      val = property_get.get(val, 'length') !== 0;
+    }
 
-    /**
-      `Ember.CollectionView` is an `Ember.View` descendent responsible for managing
-      a collection (an array or array-like object) by maintaining a child view object
-      and associated DOM representation for each item in the array and ensuring
-      that child views and their associated rendered HTML are updated when items in
-      the array are added, removed, or replaced.
+    // When using the colon syntax, evaluate the truthiness or falsiness
+    // of the value to determine which className to return
+    if (className || falsyClassName) {
+      if (className && !!val) {
+        return className;
 
-      ## Setting content
+      } else if (falsyClassName && !val) {
+        return falsyClassName;
 
-      The managed collection of objects is referenced as the `Ember.CollectionView`
-      instance's `content` property.
+      } else {
+        return null;
+      }
 
-      ```javascript
-      someItemsView = Ember.CollectionView.create({
-        content: ['A', 'B','C']
-      })
-      ```
+    // If value is a Boolean and true, return the dasherized property
+    // name.
+    } else if (val === true) {
+      // Normalize property path to be suitable for use
+      // as a class name. For exaple, content.foo.barBaz
+      // becomes bar-baz.
+      var parts = path.split('.');
+      return string.dasherize(parts[parts.length-1]);
 
-      The view for each item in the collection will have its `content` property set
-      to the item.
+    // If the value is not false, undefined, or null, return the current
+    // value of the property.
+    } else if (val !== false && val != null) {
+      return val;
 
-      ## Specifying `itemViewClass`
+    // Nothing to display. Return null so that the old class is removed
+    // but no new class is added.
+    } else {
+      return null;
+    }
+  }
 
-      By default the view class for each item in the managed collection will be an
-      instance of `Ember.View`. You can supply a different class by setting the
-      `CollectionView`'s `itemViewClass` property.
+  function streamifyClassNameBinding(view, classNameBinding, prefix) {
+    prefix = prefix || '';
+    Ember.assert("classNameBindings must not have spaces in them. Multiple class name bindings can be provided as elements of an array, e.g. ['foo', ':bar']", classNameBinding.indexOf(' ') === -1);
+    var parsedPath = parsePropertyPath(classNameBinding);
+    if (parsedPath.path === '') {
+      return classStringForValue(
+        parsedPath.path,
+        true,
+        parsedPath.className,
+        parsedPath.falsyClassName
+      );
+    } else {
+      var pathValue = view.getStream(prefix+parsedPath.path);
+      return utils.chain(pathValue, function() {
+        return classStringForValue(
+          parsedPath.path,
+          utils.read(pathValue),
+          parsedPath.className,
+          parsedPath.falsyClassName
+        );
+      });
+    }
+  }
 
-      Given the following application code:
+});
+enifed('ember-views/streams/context_stream', ['exports', 'ember-metal/core', 'ember-metal/merge', 'ember-metal/platform/create', 'ember-metal/path_cache', 'ember-metal/streams/stream', 'ember-metal/streams/simple'], function (exports, Ember, merge, create, path_cache, Stream, SimpleStream) {
 
-      ```javascript
-      var App = Ember.Application.create();
-      App.ItemListView = Ember.CollectionView.extend({
-        classNames: ['a-collection'],
-        content: ['A','B','C'],
-        itemViewClass: Ember.View.extend({
-          template: Ember.Handlebars.compile("the letter: {{view.content}}")
-        })
-      });
-      ```
+  'use strict';
 
-      And a simple application template:
+  function ContextStream(view) {
+    Ember['default'].assert("ContextStream error: the argument is not a view", view && view.isView);
 
-      ```handlebars
-      {{view 'item-list'}}
-      ```
+    this.init();
+    this.view = view;
+  }
 
-      The following HTML will result:
+  ContextStream.prototype = create['default'](Stream['default'].prototype);
 
-      ```html
-      <div class="ember-view a-collection">
-        <div class="ember-view">the letter: A</div>
-        <div class="ember-view">the letter: B</div>
-        <div class="ember-view">the letter: C</div>
-      </div>
-      ```
+  merge['default'](ContextStream.prototype, {
+    value: function() {},
 
-      ## Automatic matching of parent/child tagNames
+    _makeChildStream: function(key, _fullPath) {
+      var stream;
 
-      Setting the `tagName` property of a `CollectionView` to any of
-      "ul", "ol", "table", "thead", "tbody", "tfoot", "tr", or "select" will result
-      in the item views receiving an appropriately matched `tagName` property.
+      if (key === '' || key === 'this') {
+        stream = this.view._baseContext;
+      } else if (path_cache.isGlobal(key) && Ember['default'].lookup[key]) {
+        Ember['default'].deprecate("Global lookup of " + _fullPath + " from a Handlebars template is deprecated.");
+        stream = new SimpleStream['default'](Ember['default'].lookup[key]);
+        stream._isGlobal = true;
+      } else if (key in this.view._keywords) {
+        stream = new SimpleStream['default'](this.view._keywords[key]);
+      } else {
+        stream = new SimpleStream['default'](this.view._baseContext.get(key));
+      }
 
-      Given the following application code:
+      stream._isRoot = true;
 
-      ```javascript
-      var App = Ember.Application.create();
-      App.UnorderedListView = Ember.CollectionView.create({
-        tagName: 'ul',
-        content: ['A','B','C'],
-        itemViewClass: Ember.View.extend({
-          template: Ember.Handlebars.compile("the letter: {{view.content}}")
-        })
-      });
-      ```
+      if (key === 'controller') {
+        stream._isController = true;
+      }
+
+      return stream;
+    }
+  });
 
-      And a simple application template:
+  exports['default'] = ContextStream;
 
-      ```handlebars
-      {{view 'unordered-list-view'}}
-      ```
+});
+enifed('ember-views/streams/key_stream', ['exports', 'ember-metal/core', 'ember-metal/merge', 'ember-metal/platform/create', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/observer', 'ember-metal/streams/stream', 'ember-metal/streams/utils'], function (exports, Ember, merge, create, property_get, property_set, observer, Stream, utils) {
 
-      The following HTML will result:
+  'use strict';
 
-      ```html
-      <ul class="ember-view a-collection">
-        <li class="ember-view">the letter: A</li>
-        <li class="ember-view">the letter: B</li>
-        <li class="ember-view">the letter: C</li>
-      </ul>
-      ```
+  function KeyStream(source, key) {
+    Ember['default'].assert("KeyStream error: key must be a non-empty string", typeof key === 'string' && key.length > 0);
+    Ember['default'].assert("KeyStream error: key must not have a '.'", key.indexOf('.') === -1);
 
-      Additional `tagName` pairs can be provided by adding to
-      `Ember.CollectionView.CONTAINER_MAP`. For example:
+    this.init();
+    this.source = source;
+    this.obj = undefined;
+    this.key = key;
 
-      ```javascript
-      Ember.CollectionView.CONTAINER_MAP['article'] = 'section'
-      ```
+    if (utils.isStream(source)) {
+      source.subscribe(this._didChange, this);
+    }
+  }
 
-      ## Programmatic creation of child views
+  KeyStream.prototype = create['default'](Stream['default'].prototype);
 
-      For cases where additional customization beyond the use of a single
-      `itemViewClass` or `tagName` matching is required CollectionView's
-      `createChildView` method can be overidden:
+  merge['default'](KeyStream.prototype, {
+    valueFn: function() {
+      var prevObj = this.obj;
+      var nextObj = utils.read(this.source);
 
-      ```javascript
-      App.CustomCollectionView = Ember.CollectionView.extend({
-        createChildView: function(viewClass, attrs) {
-          if (attrs.content.kind == 'album') {
-            viewClass = App.AlbumView;
-          } else {
-            viewClass = App.SongView;
-          }
-          return this._super(viewClass, attrs);
+      if (nextObj !== prevObj) {
+        if (prevObj && typeof prevObj === 'object') {
+          observer.removeObserver(prevObj, this.key, this, this._didChange);
+        }
+
+        if (nextObj && typeof nextObj === 'object') {
+          observer.addObserver(nextObj, this.key, this, this._didChange);
         }
-      });
-      ```
 
-      ## Empty View
+        this.obj = nextObj;
+      }
 
-      You can provide an `Ember.View` subclass to the `Ember.CollectionView`
-      instance as its `emptyView` property. If the `content` property of a
-      `CollectionView` is set to `null` or an empty array, an instance of this view
-      will be the `CollectionView`s only child.
+      if (nextObj) {
+        return property_get.get(nextObj, this.key);
+      }
+    },
 
-      ```javascript
-      var App = Ember.Application.create();
-      App.ListWithNothing = Ember.CollectionView.create({
-        classNames: ['nothing'],
-        content: null,
-        emptyView: Ember.View.extend({
-          template: Ember.Handlebars.compile("The collection is empty")
-        })
-      });
-      ```
+    setValue: function(value) {
+      if (this.obj) {
+        property_set.set(this.obj, this.key, value);
+      }
+    },
 
-      And a simple application template:
+    setSource: function(nextSource) {
+      Ember['default'].assert("KeyStream error: source must be an object", typeof nextSource === 'object');
 
-      ```handlebars
-      {{view 'list-with-nothing'}}
-      ```
+      var prevSource = this.source;
 
-      The following HTML will result:
+      if (nextSource !== prevSource) {
+        if (utils.isStream(prevSource)) {
+          prevSource.unsubscribe(this._didChange, this);
+        }
 
-      ```html
-      <div class="ember-view nothing">
-        <div class="ember-view">
-          The collection is empty
-        </div>
-      </div>
-      ```
+        if (utils.isStream(nextSource)) {
+          nextSource.subscribe(this._didChange, this);
+        }
 
-      ## Adding and Removing items
+        this.source = nextSource;
+        this.notify();
+      }
+    },
 
-      The `childViews` property of a `CollectionView` should not be directly
-      manipulated. Instead, add, remove, replace items from its `content` property.
-      This will trigger appropriate changes to its rendered HTML.
+    _didChange: function() {
+      this.notify();
+    },
 
+    _super$destroy: Stream['default'].prototype.destroy,
 
-      @class CollectionView
-      @namespace Ember
-      @extends Ember.ContainerView
-      @since Ember 0.9
-    */
-    var CollectionView = ContainerView.extend({
+    destroy: function() {
+      if (this._super$destroy()) {
+        if (utils.isStream(this.source)) {
+          this.source.unsubscribe(this._didChange, this);
+        }
 
-      /**
-        A list of items to be displayed by the `Ember.CollectionView`.
+        if (this.obj && typeof this.obj === 'object') {
+          observer.removeObserver(this.obj, this.key, this, this._didChange);
+        }
 
-        @property content
-        @type Ember.Array
-        @default null
-      */
-      content: null,
+        this.source = undefined;
+        this.obj = undefined;
+        return true;
+      }
+    }
+  });
 
-      /**
-        This provides metadata about what kind of empty view class this
-        collection would like if it is being instantiated from another
-        system (like Handlebars)
+  exports['default'] = KeyStream;
 
-        @private
-        @property emptyViewClass
-      */
-      emptyViewClass: View,
+  // The transpiler does not resolve cycles, so we export
+  // the `_makeChildStream` method onto `Stream` here.
 
-      /**
-        An optional view to display if content is set to an empty array.
+  Stream['default'].prototype._makeChildStream = function(key) {
+    return new KeyStream(this, key);
+  };
 
-        @property emptyView
-        @type Ember.View
-        @default null
-      */
-      emptyView: null,
+});
+enifed('ember-views/streams/should_display', ['exports', 'ember-metal/streams/stream', 'ember-metal/streams/utils', 'ember-metal/platform/create', 'ember-metal/property_get', 'ember-metal/utils'], function (exports, Stream, utils, create, property_get, ember_metal__utils) {
 
-      /**
-        @property itemViewClass
-        @type Ember.View
-        @default Ember.View
-      */
-      itemViewClass: View,
+  'use strict';
 
-      /**
-        Setup a CollectionView
+  function shouldDisplay(predicate) {
+    if (utils.isStream(predicate)) {
+      return new ShouldDisplayStream(predicate);
+    }
 
-        @method init
-      */
-      init: function() {
-        var ret = this._super();
-        this._contentDidChange();
-        return ret;
-      },
+    var truthy = predicate && property_get.get(predicate, 'isTruthy');
+    if (typeof truthy === 'boolean') { return truthy; }
 
-      /**
-        Invoked when the content property is about to change. Notifies observers that the
-        entire array content will change.
+    if (ember_metal__utils.isArray(predicate)) {
+      return property_get.get(predicate, 'length') !== 0;
+    } else {
+      return !!predicate;
+    }
+  }
+  exports['default'] = shouldDisplay;
+
+  function ShouldDisplayStream(predicateStream) {
+    this.init();
+    this.oldPredicate = undefined;
+    this.predicateStream = predicateStream;
+    this.isTruthyStream = predicateStream.get('isTruthy');
+    this.lengthStream = undefined;
+    utils.subscribe(this.predicateStream, this.notify, this);
+    utils.subscribe(this.isTruthyStream, this.notify, this);
+  }
 
-        @private
-        @method _contentWillChange
-      */
-      _contentWillChange: beforeObserver('content', function() {
-        var content = this.get('content');
+  ShouldDisplayStream.prototype = create['default'](Stream['default'].prototype);
 
-        if (content) { content.removeArrayObserver(this); }
-        var len = content ? get(content, 'length') : 0;
-        this.arrayWillChange(content, 0, len);
-      }),
+  ShouldDisplayStream.prototype.valueFn = function() {
+    var oldPredicate = this.oldPredicate;
+    var newPredicate = utils.read(this.predicateStream);
+    var newIsArray = ember_metal__utils.isArray(newPredicate);
 
-      /**
-        Check to make sure that the content has changed, and if so,
-        update the children directly. This is always scheduled
-        asynchronously, to allow the element to be created before
-        bindings have synchronized and vice versa.
+    if (newPredicate !== oldPredicate) {
 
-        @private
-        @method _contentDidChange
-      */
-      _contentDidChange: observer('content', function() {
-        var content = get(this, 'content');
+      if (this.lengthStream && !newIsArray) {
+        utils.unsubscribe(this.lengthStream, this.notify, this);
+        this.lengthStream = undefined;
+      }
 
-        if (content) {
-          this._assertArrayLike(content);
-          content.addArrayObserver(this);
-        }
+      if (!this.lengthStream && newIsArray) {
+        this.lengthStream = this.predicateStream.get('length');
+        utils.subscribe(this.lengthStream, this.notify, this);
+      }
+      this.oldPredicate = newPredicate;
+    }
 
-        var len = content ? get(content, 'length') : 0;
-        this.arrayDidChange(content, 0, null, len);
-      }),
+    var truthy = utils.read(this.isTruthyStream);
+    if (typeof truthy === 'boolean') {
+      return truthy;
+    }
 
-      /**
-        Ensure that the content implements Ember.Array
+    if (this.lengthStream) {
+      var length = utils.read(this.lengthStream);
+      return length !== 0;
+    }
 
-        @private
-        @method _assertArrayLike
-      */
-      _assertArrayLike: function(content) {
-        Ember.assert(fmt("an Ember.CollectionView's content must implement Ember.Array. You passed %@", [content]), EmberArray.detect(content));
-      },
+    return !!newPredicate;
+  };
 
-      /**
-        Removes the content and content observers.
+});
+enifed('ember-views/streams/utils', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/path_cache', 'ember-runtime/system/string', 'ember-metal/streams/utils', 'ember-views/views/view', 'ember-runtime/mixins/controller'], function (exports, Ember, property_get, path_cache, string, utils, View, ControllerMixin) {
 
-        @method destroy
-      */
-      destroy: function() {
-        if (!this._super()) { return; }
+  'use strict';
 
-        var content = get(this, 'content');
-        if (content) { content.removeArrayObserver(this); }
+  exports.readViewFactory = readViewFactory;
+  exports.readComponentFactory = readComponentFactory;
+  exports.readUnwrappedModel = readUnwrappedModel;
 
-        if (this._createdEmptyView) {
-          this._createdEmptyView.destroy();
-        }
+  function readViewFactory(object, container) {
+    var value = utils.read(object);
+    var viewClass;
 
-        return this;
-      },
+    if (typeof value === 'string') {
+      if (path_cache.isGlobal(value)) {
+        viewClass = property_get.get(null, value);
+        Ember['default'].deprecate(
+          'Resolved the view "'+value+'" on the global context. Pass a view name to be looked up on the container instead, such as {{view "select"}}.',
+          !viewClass,
+          { url: 'http://emberjs.com/guides/deprecations/#toc_global-lookup-of-views' }
+        );
+      } else {
+        Ember['default'].assert("View requires a container to resolve views not passed in through the context", !!container);
+        viewClass = container.lookupFactory('view:'+value);
+      }
+    } else {
+      viewClass = value;
+    }
 
-      /**
-        Called when a mutation to the underlying content array will occur.
+    Ember['default'].assert(string.fmt(value+" must be a subclass or an instance of Ember.View, not %@", [viewClass]), View['default'].detect(viewClass) || View['default'].detectInstance(viewClass));
 
-        This method will remove any views that are no longer in the underlying
-        content array.
+    return viewClass;
+  }
 
-        Invokes whenever the content array itself will change.
+  function readComponentFactory(nameOrStream, container) {
+    var name = utils.read(nameOrStream);
+    var componentLookup = container.lookup('component-lookup:main');
+    Ember['default'].assert("Could not find 'component-lookup:main' on the provided container," +
+                 " which is necessary for performing component lookups", componentLookup);
 
-        @method arrayWillChange
-        @param {Array} content the managed collection of objects
-        @param {Number} start the index at which the changes will occur
-        @param {Number} removed number of object to be removed from content
-      */
-      arrayWillChange: function(content, start, removedCount) {
-        // If the contents were empty before and this template collection has an
-        // empty view remove it now.
-        var emptyView = get(this, 'emptyView');
-        if (emptyView && emptyView instanceof View) {
-          emptyView.removeFromParent();
-        }
+    return componentLookup.lookupFactory(name, container);
+  }
 
-        // Loop through child views that correspond with the removed items.
-        // Note that we loop from the end of the array to the beginning because
-        // we are mutating it as we go.
-        var childViews = this._childViews;
-        var childView, idx;
+  function readUnwrappedModel(object) {
+    if (utils.isStream(object)) {
+      var result = object.value();
 
-        for (idx = start + removedCount - 1; idx >= start; idx--) {
-          childView = childViews[idx];
-          childView.destroy();
+      // If the path is exactly `controller` then we don't unwrap it.
+      if (!object._isController) {
+        while (ControllerMixin['default'].detect(result)) {
+          result = property_get.get(result, 'model');
         }
-      },
+      }
 
-      /**
-        Called when a mutation to the underlying content array occurs.
+      return result;
+    } else {
+      return object;
+    }
+  }
 
-        This method will replay that mutation against the views that compose the
-        `Ember.CollectionView`, ensuring that the view reflects the model.
+});
+enifed('ember-views/system/action_manager', ['exports'], function (exports) {
 
-        This array observer is added in `contentDidChange`.
+  'use strict';
 
-        @method arrayDidChange
-        @param {Array} content the managed collection of objects
-        @param {Number} start the index at which the changes occurred
-        @param {Number} removed number of object removed from content
-        @param {Number} added number of object added to content
-      */
-      arrayDidChange: function(content, start, removed, added) {
-        var addedViews = [];
-        var view, item, idx, len, itemViewClass, emptyView, itemViewProps;
+  /**
+  @module ember
+  @submodule ember-views
+  */
 
-        len = content ? get(content, 'length') : 0;
+  function ActionManager() {}
 
-        if (len) {
-          itemViewProps = this._itemViewProps || {};
-          itemViewClass = get(this, 'itemViewClass');
+  /**
+    Global action id hash.
 
-          itemViewClass = readViewFactory(itemViewClass, this.container);
+    @private
+    @property registeredActions
+    @type Object
+  */
+  ActionManager.registeredActions = {};
 
-          for (idx = start; idx < start+added; idx++) {
-            item = content.objectAt(idx);
+  exports['default'] = ActionManager;
 
-            itemViewProps.content = item;
-            itemViewProps._blockArguments = [item];
-            itemViewProps.contentIndex = idx;
+});
+enifed('ember-views/system/event_dispatcher', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/is_none', 'ember-metal/run_loop', 'ember-metal/utils', 'ember-runtime/system/string', 'ember-runtime/system/object', 'ember-views/system/jquery', 'ember-views/system/action_manager', 'ember-views/views/view', 'ember-metal/merge'], function (exports, Ember, property_get, property_set, isNone, run, utils, string, EmberObject, jQuery, ActionManager, View, merge) {
 
-            view = this.createChildView(itemViewClass, itemViewProps);
+  'use strict';
 
-            addedViews.push(view);
-          }
-        } else {
-          emptyView = get(this, 'emptyView');
+  /**
+  @module ember
+  @submodule ember-views
+  */
+  exports['default'] = EmberObject['default'].extend({
 
-          if (!emptyView) { return; }
+    /**
+      The set of events names (and associated handler function names) to be setup
+      and dispatched by the `EventDispatcher`. Custom events can added to this list at setup
+      time, generally via the `Ember.Application.customEvents` hash. Only override this
+      default set to prevent the EventDispatcher from listening on some events all together.
 
-          if ('string' === typeof emptyView && isGlobalPath(emptyView)) {
-            emptyView = get(emptyView) || emptyView;
-          }
+      This set will be modified by `setup` to also include any events added at that time.
 
-          emptyView = this.createChildView(emptyView);
+      @property events
+      @type Object
+    */
+    events: {
+      touchstart  : 'touchStart',
+      touchmove   : 'touchMove',
+      touchend    : 'touchEnd',
+      touchcancel : 'touchCancel',
+      keydown     : 'keyDown',
+      keyup       : 'keyUp',
+      keypress    : 'keyPress',
+      mousedown   : 'mouseDown',
+      mouseup     : 'mouseUp',
+      contextmenu : 'contextMenu',
+      click       : 'click',
+      dblclick    : 'doubleClick',
+      mousemove   : 'mouseMove',
+      focusin     : 'focusIn',
+      focusout    : 'focusOut',
+      mouseenter  : 'mouseEnter',
+      mouseleave  : 'mouseLeave',
+      submit      : 'submit',
+      input       : 'input',
+      change      : 'change',
+      dragstart   : 'dragStart',
+      drag        : 'drag',
+      dragenter   : 'dragEnter',
+      dragleave   : 'dragLeave',
+      dragover    : 'dragOver',
+      drop        : 'drop',
+      dragend     : 'dragEnd'
+    },
+
+    /**
+      The root DOM element to which event listeners should be attached. Event
+      listeners will be attached to the document unless this is overridden.
+
+      Can be specified as a DOMElement or a selector string.
+
+      The default body is a string since this may be evaluated before document.body
+      exists in the DOM.
 
-          addedViews.push(emptyView);
-          set(this, 'emptyView', emptyView);
+      @private
+      @property rootElement
+      @type DOMElement
+      @default 'body'
+    */
+    rootElement: 'body',
 
-          if (CoreView.detect(emptyView)) {
-            this._createdEmptyView = emptyView;
-          }
-        }
+    /**
+      It enables events to be dispatched to the view's `eventManager.` When present,
+      this object takes precedence over handling of events on the view itself.
 
-        this.replace(start, 0, addedViews);
-      },
+      Note that most Ember applications do not use this feature. If your app also
+      does not use it, consider setting this property to false to gain some performance
+      improvement by allowing the EventDispatcher to skip the search for the
+      `eventManager` on the view tree.
 
-      /**
-        Instantiates a view to be added to the childViews array during view
-        initialization. You generally will not call this method directly unless
-        you are overriding `createChildViews()`. Note that this method will
-        automatically configure the correct settings on the new view instance to
-        act as a child of the parent.
-
-        The tag name for the view will be set to the tagName of the viewClass
-        passed in.
-
-        @method createChildView
-        @param {Class} viewClass
-        @param {Hash} [attrs] Attributes to add
-        @return {Ember.View} new instance
-      */
-      createChildView: function(view, attrs) {
-        view = this._super(view, attrs);
+      ```javascript
+      var EventDispatcher = Em.EventDispatcher.extend({
+        events: {
+            click       : 'click',
+            focusin     : 'focusIn',
+            focusout    : 'focusOut',
+            change      : 'change'
+        },
+        canDispatchToEventManager: false
+      });
+      container.register('event_dispatcher:main', EventDispatcher);
+      ```
 
-        var itemTagName = get(view, 'tagName');
+      @property canDispatchToEventManager
+      @type boolean
+      @default 'true'
+      @since 1.7.0
+    */
+    canDispatchToEventManager: true,
 
-        if (itemTagName === null || itemTagName === undefined) {
-          itemTagName = CollectionView.CONTAINER_MAP[get(this, 'tagName')];
-          set(view, 'tagName', itemTagName);
-        }
+    /**
+      Sets up event listeners for standard browser events.
 
-        return view;
-      }
-    });
+      This will be called after the browser sends a `DOMContentReady` event. By
+      default, it will set up all of the listeners on the document body. If you
+      would like to register the listeners on a different element, set the event
+      dispatcher's `root` property.
 
-    /**
-      A map of parent tags to their default child tags. You can add
-      additional parent tags if you want collection views that use
-      a particular parent tag to default to a child tag.
+      @private
+      @method setup
+      @param addedEvents {Hash}
+    */
+    setup: function(addedEvents, rootElement) {
+      var event;
+      var events = property_get.get(this, 'events');
 
-      @property CONTAINER_MAP
-      @type Hash
-      @static
-      @final
-    */
-    CollectionView.CONTAINER_MAP = {
-      ul: 'li',
-      ol: 'li',
-      table: 'tr',
-      thead: 'tr',
-      tbody: 'tr',
-      tfoot: 'tr',
-      tr: 'td',
-      select: 'option'
-    };
+      merge['default'](events, addedEvents || {});
 
-    __exports__["default"] = CollectionView;
-  });
-enifed("ember-views/views/component",
-  ["ember-metal/core","ember-views/mixins/component_template_deprecation","ember-runtime/mixins/target_action_support","ember-views/views/view","ember-metal/property_get","ember-metal/property_set","ember-metal/is_none","ember-metal/computed","ember-htmlbars/templates/component","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.assert, Ember.Handlebars
+      if (!isNone['default'](rootElement)) {
+        property_set.set(this, 'rootElement', rootElement);
+      }
 
-    var ComponentTemplateDeprecation = __dependency2__["default"];
-    var TargetActionSupport = __dependency3__["default"];
-    var View = __dependency4__["default"];
+      rootElement = jQuery['default'](property_get.get(this, 'rootElement'));
 
-    var get = __dependency5__.get;
-    var set = __dependency6__.set;
-    var isNone = __dependency7__["default"];
+      Ember['default'].assert(string.fmt('You cannot use the same root element (%@) multiple times in an Ember.Application', [rootElement.selector || rootElement[0].tagName]), !rootElement.is('.ember-application'));
+      Ember['default'].assert('You cannot make a new Ember.Application using a root element that is a descendent of an existing Ember.Application', !rootElement.closest('.ember-application').length);
+      Ember['default'].assert('You cannot make a new Ember.Application using a root element that is an ancestor of an existing Ember.Application', !rootElement.find('.ember-application').length);
 
-    var computed = __dependency8__.computed;
-    var defaultComponentLayout = __dependency9__["default"];
+      rootElement.addClass('ember-application');
 
-    var a_slice = Array.prototype.slice;
+      Ember['default'].assert('Unable to add "ember-application" class to rootElement. Make sure you set rootElement to the body or an element in the body.', rootElement.is('.ember-application'));
 
-    /**
-    @module ember
-    @submodule ember-views
-    */
+      for (event in events) {
+        if (events.hasOwnProperty(event)) {
+          this.setupHandler(rootElement, event, events[event]);
+        }
+      }
+    },
 
     /**
-      An `Ember.Component` is a view that is completely
-      isolated. Properties accessed in its templates go
-      to the view object and actions are targeted at
-      the view object. There is no access to the
-      surrounding context or outer controller; all
-      contextual information must be passed in.
-
-      The easiest way to create an `Ember.Component` is via
-      a template. If you name a template
-      `components/my-foo`, you will be able to use
-      `{{my-foo}}` in other templates, which will make
-      an instance of the isolated component.
+      Registers an event listener on the rootElement. If the given event is
+      triggered, the provided event handler will be triggered on the target view.
 
-      ```handlebars
-      {{app-profile person=currentUser}}
-      ```
+      If the target view does not implement the event handler, or if the handler
+      returns `false`, the parent view will be called. The event will continue to
+      bubble to each successive parent view until it reaches the top.
 
-      ```handlebars
-      <!-- app-profile template -->
-      <h1>{{person.title}}</h1>
-      <img {{bind-attr src=person.avatar}}>
-      <p class='signature'>{{person.signature}}</p>
-      ```
+      @private
+      @method setupHandler
+      @param {Element} rootElement
+      @param {String} event the browser-originated event to listen to
+      @param {String} eventName the name of the method to call on the view
+    */
+    setupHandler: function(rootElement, event, eventName) {
+      var self = this;
 
-      You can use `yield` inside a template to
-      include the **contents** of any block attached to
-      the component. The block will be executed in the
-      context of the surrounding context or outer controller:
+      rootElement.on(event + '.ember', '.ember-view', function(evt, triggeringManager) {
+        var view = View['default'].views[this.id];
+        var result = true;
 
-      ```handlebars
-      {{#app-profile person=currentUser}}
-        <p>Admin mode</p>
-        {{! Executed in the controller's context. }}
-      {{/app-profile}}
-      ```
+        var manager = self.canDispatchToEventManager ? self._findNearestEventManager(view, eventName) : null;
 
-      ```handlebars
-      <!-- app-profile template -->
-      <h1>{{person.title}}</h1>
-      {{! Executed in the components context. }}
-      {{yield}} {{! block contents }}
-      ```
+        if (manager && manager !== triggeringManager) {
+          result = self._dispatchEvent(manager, evt, eventName, view);
+        } else if (view) {
+          result = self._bubbleEvent(view, evt, eventName);
+        }
 
-      If you want to customize the component, in order to
-      handle events or actions, you implement a subclass
-      of `Ember.Component` named after the name of the
-      component. Note that `Component` needs to be appended to the name of
-      your subclass like `AppProfileComponent`.
+        return result;
+      });
 
-      For example, you could implement the action
-      `hello` for the `app-profile` component:
+      rootElement.on(event + '.ember', '[data-ember-action]', function(evt) {
+        var actionId = jQuery['default'](evt.currentTarget).attr('data-ember-action');
+        var action   = ActionManager['default'].registeredActions[actionId];
 
-      ```javascript
-      App.AppProfileComponent = Ember.Component.extend({
-        actions: {
-          hello: function(name) {
-            console.log("Hello", name);
-          }
+        // We have to check for action here since in some cases, jQuery will trigger
+        // an event on `removeChild` (i.e. focusout) after we've already torn down the
+        // action handlers for the view.
+        if (action && action.eventName === eventName) {
+          return action.handler(evt);
         }
       });
-      ```
+    },
 
-      And then use it in the component's template:
+    _findNearestEventManager: function(view, eventName) {
+      var manager = null;
 
-      ```handlebars
-      <!-- app-profile template -->
+      while (view) {
+        manager = property_get.get(view, 'eventManager');
+        if (manager && manager[eventName]) { break; }
 
-      <h1>{{person.title}}</h1>
-      {{yield}} <!-- block contents -->
+        view = property_get.get(view, 'parentView');
+      }
 
-      <button {{action 'hello' person.name}}>
-        Say Hello to {{person.name}}
-      </button>
-      ```
+      return manager;
+    },
 
-      Components must have a `-` in their name to avoid
-      conflicts with built-in controls that wrap HTML
-      elements. This is consistent with the same
-      requirement in web components.
+    _dispatchEvent: function(object, evt, eventName, view) {
+      var result = true;
 
-      @class Component
-      @namespace Ember
-      @extends Ember.View
-    */
-    var Component = View.extend(TargetActionSupport, ComponentTemplateDeprecation, {
-      instrumentName: 'component',
-      instrumentDisplay: computed(function() {
-        if (this._debugContainerKey) {
-          return '{{' + this._debugContainerKey.split(':')[1] + '}}';
-        }
-      }),
+      var handler = object[eventName];
+      if (utils.typeOf(handler) === 'function') {
+        result = run['default'](object, handler, evt, view);
+        // Do not preventDefault in eventManagers.
+        evt.stopPropagation();
+      } else {
+        result = this._bubbleEvent(view, evt, eventName);
+      }
 
-      init: function() {
-        this._super();
-        this._keywords.view = this;
-        set(this, 'context', this);
-        set(this, 'controller', this);
-      },
+      return result;
+    },
 
-      defaultLayout: defaultComponentLayout,
+    _bubbleEvent: function(view, evt, eventName) {
+      return run['default'].join(view, view.handleEvent, eventName, evt);
+    },
 
-      /**
-      A components template property is set by passing a block
-      during its invocation. It is executed within the parent context.
+    destroy: function() {
+      var rootElement = property_get.get(this, 'rootElement');
+      jQuery['default'](rootElement).off('.ember', '**').removeClass('ember-application');
+      return this._super.apply(this, arguments);
+    },
 
-      Example:
+    toString: function() {
+      return '(EventDispatcher)';
+    }
+  });
 
-      ```handlebars
-      {{#my-component}}
-        // something that is run in the context
-        // of the parent context
-      {{/my-component}}
-      ```
+});
+enifed('ember-views/system/ext', ['ember-metal/run_loop'], function (run) {
 
-      Specifying a template directly to a component is deprecated without
-      also specifying the layout property.
+	'use strict';
 
-      @deprecated
-      @property template
-      */
-      template: computed(function(key, value) {
-        if (value !== undefined) { return value; }
+	/**
+	@module ember
+	@submodule ember-views
+	*/
 
-        var templateName = get(this, 'templateName');
-        var template = this.templateForName(templateName, 'template');
+	run['default']._addQueue('render', 'actions');
+	run['default']._addQueue('afterRender', 'render');
 
-        Ember.assert("You specified the templateName " + templateName + " for " + this + ", but it did not exist.", !templateName || !!template);
+});
+enifed('ember-views/system/jquery', ['exports', 'ember-metal/core', 'ember-metal/enumerable_utils', 'ember-metal/environment'], function (exports, Ember, enumerable_utils, environment) {
 
-        return template || get(this, 'defaultTemplate');
-      }).property('templateName'),
+  'use strict';
 
-      /**
-      Specifying a components `templateName` is deprecated without also
-      providing the `layout` or `layoutName` properties.
+  var jQuery;
 
-      @deprecated
-      @property templateName
-      */
-      templateName: null,
-
-      _setupKeywords: function() {},
-
-      _yield: function(context, options, morph, blockArguments) {
-        var view = options.data.view;
-        var parentView = this._parentView;
-        var template = get(this, 'template');
-
-        if (template) {
-          Ember.assert("A Component must have a parent view in order to yield.", parentView);
-
-          view.appendChild(View, {
-            isVirtual: true,
-            tagName: '',
-            template: template,
-            _blockArguments: blockArguments,
-            _contextView: parentView,
-            _morph: morph,
-            context: get(parentView, 'context'),
-            controller: get(parentView, 'controller')
-          });
-        }
-      },
+  if (environment['default'].hasDOM) {
+    // mainContext is set in `package/loader/lib/main.js` to the `this` context before entering strict mode
+    jQuery = (Ember['default'].imports && Ember['default'].imports.jQuery) || (mainContext && mainContext.jQuery); //jshint ignore:line
+    if (!jQuery && typeof eriuqer === 'function') {
+      jQuery = eriuqer('jquery');
+    }
 
-      /**
-        If the component is currently inserted into the DOM of a parent view, this
-        property will point to the controller of the parent view.
+    Ember['default'].assert("Ember Views require jQuery between 1.7 and 2.1", jQuery &&
+                 (jQuery().jquery.match(/^((1\.(7|8|9|10|11))|(2\.(0|1)))(\.\d+)?(pre|rc\d?)?/) ||
+                  Ember['default'].ENV.FORCE_JQUERY));
 
-        @property targetObject
-        @type Ember.Controller
-        @default null
-      */
-      targetObject: computed(function(key) {
-        var parentView = get(this, '_parentView');
-        return parentView ? get(parentView, 'controller') : null;
-      }).property('_parentView'),
+    /**
+    @module ember
+    @submodule ember-views
+    */
+    if (jQuery) {
+      // http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html#dndevents
+      var dragEvents = [
+        'dragstart',
+        'drag',
+        'dragenter',
+        'dragleave',
+        'dragover',
+        'drop',
+        'dragend'
+      ];
 
-      /**
-        Triggers a named action on the controller context where the component is used if
-        this controller has registered for notifications of the action.
+      // Copies the `dataTransfer` property from a browser event object onto the
+      // jQuery event object for the specified events
+      enumerable_utils.forEach(dragEvents, function(eventName) {
+        jQuery.event.fixHooks[eventName] = {
+          props: ['dataTransfer']
+        };
+      });
+    }
+  }
 
-        For example a component for playing or pausing music may translate click events
-        into action notifications of "play" or "stop" depending on some internal state
-        of the component:
+  exports['default'] = jQuery;
 
+});
+enifed('ember-views/system/lookup_partial', ['exports', 'ember-metal/core'], function (exports, Ember) {
 
-        ```javascript
-        App.PlayButtonComponent = Ember.Component.extend({
-          click: function(){
-            if (this.get('isPlaying')) {
-              this.sendAction('play');
-            } else {
-              this.sendAction('stop');
-            }
-          }
-        });
-        ```
+  'use strict';
 
-        When used inside a template these component actions are configured to
-        trigger actions in the outer application context:
+  function lookupPartial(view, templateName) {
+    var nameParts = templateName.split("/");
+    var lastPart = nameParts[nameParts.length - 1];
 
-        ```handlebars
-        {{! application.hbs }}
-        {{play-button play="musicStarted" stop="musicStopped"}}
-        ```
+    nameParts[nameParts.length - 1] = "_" + lastPart;
 
-        When the component receives a browser `click` event it translate this
-        interaction into application-specific semantics ("play" or "stop") and
-        triggers the specified action name on the controller for the template
-        where the component is used:
+    var underscoredName = nameParts.join('/');
+    var template = view.templateForName(underscoredName);
+    if (!template) {
+      template = view.templateForName(templateName);
+    }
 
+    Ember['default'].assert(
+      'Unable to find partial with name "' + templateName + '"',
+      !!template
+    );
 
-        ```javascript
-        App.ApplicationController = Ember.Controller.extend({
-          actions: {
-            musicStarted: function(){
-              // called when the play button is clicked
-              // and the music started playing
-            },
-            musicStopped: function(){
-              // called when the play button is clicked
-              // and the music stopped playing
-            }
-          }
-        });
-        ```
+    return template;
+  }
+  exports['default'] = lookupPartial;
 
-        If no action name is passed to `sendAction` a default name of "action"
-        is assumed.
+});
+enifed('ember-views/system/platform', ['exports', 'ember-metal/environment'], function (exports, environment) {
 
-        ```javascript
-        App.NextButtonComponent = Ember.Component.extend({
-          click: function(){
-            this.sendAction();
-          }
-        });
-        ```
+  'use strict';
 
-        ```handlebars
-        {{! application.hbs }}
-        {{next-button action="playNextSongInAlbum"}}
-        ```
+  var canSetNameOnInputs = environment['default'].hasDOM && (function() {
+    var div = document.createElement('div');
+    var el = document.createElement('input');
 
-        ```javascript
-        App.ApplicationController = Ember.Controller.extend({
-          actions: {
-            playNextSongInAlbum: function(){
-              ...
-            }
-          }
-        });
-        ```
+    el.setAttribute('name', 'foo');
+    div.appendChild(el);
 
-        @method sendAction
-        @param [action] {String} the action to trigger
-        @param [context] {*} a context to send with the action
-      */
-      sendAction: function(action) {
-        var actionName;
-        var contexts = a_slice.call(arguments, 1);
-
-        // Send the default action
-        if (action === undefined) {
-          actionName = get(this, 'action');
-          Ember.assert("The default action was triggered on the component " + this.toString() +
-                       ", but the action name (" + actionName + ") was not a string.",
-                       isNone(actionName) || typeof actionName === 'string');
-        } else {
-          actionName = get(this, action);
-          Ember.assert("The " + action + " action was triggered on the component " +
-                       this.toString() + ", but the action name (" + actionName +
-                       ") was not a string.",
-                       isNone(actionName) || typeof actionName === 'string');
-        }
+    return !!div.innerHTML.match('foo');
+  })();
 
-        // If no action name for that action could be found, just abort.
-        if (actionName === undefined) { return; }
+  exports.canSetNameOnInputs = canSetNameOnInputs;
 
-        this.triggerAction({
-          action: actionName,
-          actionContext: contexts
-        });
-      },
+});
+enifed('ember-views/system/render_buffer', ['exports', 'ember-views/system/jquery', 'ember-metal/core', 'ember-metal/platform/create', 'dom-helper/prop', 'ember-views/system/platform'], function (exports, jQuery, Ember, o_create, dom_helper__prop, platform) {
 
-      send: function(actionName) {
-        var args = [].slice.call(arguments, 1);
-        var target;
-        var hasAction = this._actions && this._actions[actionName];
+  'use strict';
 
-        if (hasAction) {
-          if (this._actions[actionName].apply(this, args) === true) {
-            // handler returned true, so this action will bubble
-          } else {
-            return;
-          }
-        }
+  /**
+  @module ember
+  @submodule ember-views
+  */
 
-        if (target = get(this, 'target')) {
-          Ember.assert("The `target` for " + this + " (" + target +
-                       ") does not have a `send` method", typeof target.send === 'function');
-          target.send.apply(target, arguments);
-        } else {
-          if (!hasAction) {
-            throw new Error(Ember.inspect(this) + ' had no action handler for: ' + actionName);
-          }
-        }
-      }
-    });
+  var omittedStartTagChildren;
+  var omittedStartTagChildTest = /(?:<script)*.*?<([\w:]+)/i;
 
-    __exports__["default"] = Component;
-  });
-enifed("ember-views/views/container_view",
-  ["ember-metal/core","ember-metal/merge","ember-runtime/mixins/mutable_array","ember-metal/property_get","ember-metal/property_set","ember-views/views/view","ember-views/views/states","ember-metal/error","ember-metal/enumerable_utils","ember-metal/computed","ember-metal/run_loop","ember-metal/properties","ember-metal/mixin","ember-runtime/system/native_array","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.assert, Ember.deprecate
+  function detectOmittedStartTag(dom, string, contextualElement) {
+    omittedStartTagChildren = omittedStartTagChildren || {
+      tr: dom.createElement('tbody'),
+      col: dom.createElement('colgroup')
+    };
 
-    var merge = __dependency2__["default"];
-    var MutableArray = __dependency3__["default"];
-    var get = __dependency4__.get;
-    var set = __dependency5__.set;
+    // Omitted start tags are only inside table tags.
+    if (contextualElement.tagName === 'TABLE') {
+      var omittedStartTagChildMatch = omittedStartTagChildTest.exec(string);
+      if (omittedStartTagChildMatch) {
+        // It is already asserted that the contextual element is a table
+        // and not the proper start tag. Just look up the start tag.
+        return omittedStartTagChildren[omittedStartTagChildMatch[1].toLowerCase()];
+      }
+    }
+  }
 
-    var View = __dependency6__["default"];
+  function ClassSet() {
+    this.seen = o_create['default'](null);
+    this.list = [];
+  }
 
-    var cloneStates = __dependency7__.cloneStates;
-    var EmberViewStates = __dependency7__.states;
+  ClassSet.prototype = {
+    add: function(string) {
+      if (this.seen[string] === true) { return; }
+      this.seen[string] = true;
 
-    var EmberError = __dependency8__["default"];
+      this.list.push(string);
+    }
+  };
 
-    var forEach = __dependency9__.forEach;
+  var BAD_TAG_NAME_TEST_REGEXP = /[^a-zA-Z0-9\-]/;
+  var BAD_TAG_NAME_REPLACE_REGEXP = /[^a-zA-Z0-9\-]/g;
 
-    var computed = __dependency10__.computed;
-    var run = __dependency11__["default"];
-    var defineProperty = __dependency12__.defineProperty;
-    var observer = __dependency13__.observer;
-    var beforeObserver = __dependency13__.beforeObserver;
-    var emberA = __dependency14__.A;
+  function stripTagName(tagName) {
+    if (!tagName) {
+      return tagName;
+    }
 
-    function K() { return this; }
+    if (!BAD_TAG_NAME_TEST_REGEXP.test(tagName)) {
+      return tagName;
+    }
 
-    /**
-    @module ember
-    @submodule ember-views
-    */
+    return tagName.replace(BAD_TAG_NAME_REPLACE_REGEXP, '');
+  }
 
-    var states = cloneStates(EmberViewStates);
+  var BAD_CHARS_REGEXP = /&(?!\w+;)|[<>"'`]/g;
+  var POSSIBLE_CHARS_REGEXP = /[&<>"'`]/;
 
-    /**
-      A `ContainerView` is an `Ember.View` subclass that implements `Ember.MutableArray`
-      allowing programmatic management of its child views.
+  function escapeAttribute(value) {
+    // Stolen shamelessly from Handlebars
 
-      ## Setting Initial Child Views
+    var escape = {
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#x27;",
+      "`": "&#x60;"
+    };
 
-      The initial array of child views can be set in one of two ways. You can
-      provide a `childViews` property at creation time that contains instance of
-      `Ember.View`:
+    var escapeChar = function(chr) {
+      return escape[chr] || "&amp;";
+    };
 
-      ```javascript
-      aContainer = Ember.ContainerView.create({
-        childViews: [Ember.View.create(), Ember.View.create()]
-      });
-      ```
+    var string = value.toString();
 
-      You can also provide a list of property names whose values are instances of
-      `Ember.View`:
+    if (!POSSIBLE_CHARS_REGEXP.test(string)) { return string; }
+    return string.replace(BAD_CHARS_REGEXP, escapeChar);
+  }
 
-      ```javascript
-      aContainer = Ember.ContainerView.create({
-        childViews: ['aView', 'bView', 'cView'],
-        aView: Ember.View.create(),
-        bView: Ember.View.create(),
-        cView: Ember.View.create()
-      });
-      ```
+  /**
+    `Ember.RenderBuffer` gathers information regarding the view and generates the
+    final representation. `Ember.RenderBuffer` will generate HTML which can be pushed
+    to the DOM.
 
-      The two strategies can be combined:
+     ```javascript
+     var buffer = new Ember.RenderBuffer('div', contextualElement);
+    ```
 
-      ```javascript
-      aContainer = Ember.ContainerView.create({
-        childViews: ['aView', Ember.View.create()],
-        aView: Ember.View.create()
-      });
-      ```
+    @method renderBuffer
+    @namespace Ember
+    @param {String} tagName tag name (such as 'div' or 'p') used for the buffer
+  */
 
-      Each child view's rendering will be inserted into the container's rendered
-      HTML in the same order as its position in the `childViews` property.
+  var RenderBuffer = function(domHelper) {
+    this.buffer = null;
+    this.childViews = [];
+    this.attrNodes = [];
 
-      ## Adding and Removing Child Views
+    Ember['default'].assert("RenderBuffer requires a DOM helper to be passed to its constructor.", !!domHelper);
 
-      The container view implements `Ember.MutableArray` allowing programmatic management of its child views.
+    this.dom = domHelper;
+  };
 
-      To remove a view, pass that view into a `removeObject` call on the container view.
+  RenderBuffer.prototype = {
 
-      Given an empty `<body>` the following code
+    reset: function(tagName, contextualElement) {
+      this.tagName = tagName;
+      this.buffer = null;
+      this._element = null;
+      this._outerContextualElement = contextualElement;
+      this.elementClasses = null;
+      this.elementId = null;
+      this.elementAttributes = null;
+      this.elementProperties = null;
+      this.elementTag = null;
+      this.elementStyle = null;
+      this.childViews.length = 0;
+      this.attrNodes.length = 0;
+    },
 
-      ```javascript
-      aContainer = Ember.ContainerView.create({
-        classNames: ['the-container'],
-        childViews: ['aView', 'bView'],
-        aView: Ember.View.create({
-          template: Ember.Handlebars.compile("A")
-        }),
-        bView: Ember.View.create({
-          template: Ember.Handlebars.compile("B")
-        })
-      });
+    // The root view's element
+    _element: null,
 
-      aContainer.appendTo('body');
-      ```
+    // The root view's contextualElement
+    _outerContextualElement: null,
 
-      Results in the HTML
+    /**
+      An internal set used to de-dupe class names when `addClass()` is
+      used. After each call to `addClass()`, the `classes` property
+      will be updated.
 
-      ```html
-      <div class="ember-view the-container">
-        <div class="ember-view">A</div>
-        <div class="ember-view">B</div>
-      </div>
-      ```
+      @private
+      @property elementClasses
+      @type Array
+      @default null
+    */
+    elementClasses: null,
 
-      Removing a view
+    /**
+      Array of class names which will be applied in the class attribute.
 
-      ```javascript
-      aContainer.toArray();  // [aContainer.aView, aContainer.bView]
-      aContainer.removeObject(aContainer.get('bView'));
-      aContainer.toArray();  // [aContainer.aView]
-      ```
+      You can use `setClasses()` to set this property directly. If you
+      use `addClass()`, it will be maintained for you.
 
-      Will result in the following HTML
+      @property classes
+      @type Array
+      @default null
+    */
+    classes: null,
 
-      ```html
-      <div class="ember-view the-container">
-        <div class="ember-view">A</div>
-      </div>
-      ```
+    /**
+      The id in of the element, to be applied in the id attribute.
 
-      Similarly, adding a child view is accomplished by adding `Ember.View` instances to the
-      container view.
+      You should not set this property yourself, rather, you should use
+      the `id()` method of `Ember.RenderBuffer`.
 
-      Given an empty `<body>` the following code
+      @property elementId
+      @type String
+      @default null
+    */
+    elementId: null,
 
-      ```javascript
-      aContainer = Ember.ContainerView.create({
-        classNames: ['the-container'],
-        childViews: ['aView', 'bView'],
-        aView: Ember.View.create({
-          template: Ember.Handlebars.compile("A")
-        }),
-        bView: Ember.View.create({
-          template: Ember.Handlebars.compile("B")
-        })
-      });
+    /**
+      A hash keyed on the name of the attribute and whose value will be
+      applied to that attribute. For example, if you wanted to apply a
+      `data-view="Foo.bar"` property to an element, you would set the
+      elementAttributes hash to `{'data-view':'Foo.bar'}`.
 
-      aContainer.appendTo('body');
-      ```
+      You should not maintain this hash yourself, rather, you should use
+      the `attr()` method of `Ember.RenderBuffer`.
 
-      Results in the HTML
+      @property elementAttributes
+      @type Hash
+      @default {}
+    */
+    elementAttributes: null,
 
-      ```html
-      <div class="ember-view the-container">
-        <div class="ember-view">A</div>
-        <div class="ember-view">B</div>
-      </div>
-      ```
+    /**
+      A hash keyed on the name of the properties and whose value will be
+      applied to that property. For example, if you wanted to apply a
+      `checked=true` property to an element, you would set the
+      elementProperties hash to `{'checked':true}`.
 
-      Adding a view
+      You should not maintain this hash yourself, rather, you should use
+      the `prop()` method of `Ember.RenderBuffer`.
 
-      ```javascript
-      AnotherViewClass = Ember.View.extend({
-        template: Ember.Handlebars.compile("Another view")
-      });
+      @property elementProperties
+      @type Hash
+      @default {}
+    */
+    elementProperties: null,
 
-      aContainer.toArray();  // [aContainer.aView, aContainer.bView]
-      aContainer.pushObject(AnotherViewClass.create());
-      aContainer.toArray(); // [aContainer.aView, aContainer.bView, <AnotherViewClass instance>]
-      ```
+    /**
+      The tagname of the element an instance of `Ember.RenderBuffer` represents.
 
-      Will result in the following HTML
+      Usually, this gets set as the first parameter to `Ember.RenderBuffer`. For
+      example, if you wanted to create a `p` tag, then you would call
 
-      ```html
-      <div class="ember-view the-container">
-        <div class="ember-view">A</div>
-        <div class="ember-view">B</div>
-        <div class="ember-view">Another view</div>
-      </div>
+      ```javascript
+      Ember.RenderBuffer('p', contextualElement)
       ```
 
-      ## Templates and Layout
+      @property elementTag
+      @type String
+      @default null
+    */
+    elementTag: null,
 
-      A `template`, `templateName`, `defaultTemplate`, `layout`, `layoutName` or
-      `defaultLayout` property on a container view will not result in the template
-      or layout being rendered. The HTML contents of a `Ember.ContainerView`'s DOM
-      representation will only be the rendered HTML of its child views.
+    /**
+      A hash keyed on the name of the style attribute and whose value will
+      be applied to that attribute. For example, if you wanted to apply a
+      `background-color:black;` style to an element, you would set the
+      elementStyle hash to `{'background-color':'black'}`.
 
-      @class ContainerView
-      @namespace Ember
-      @extends Ember.View
-    */
-    var ContainerView = View.extend(MutableArray, {
-      _states: states,
+      You should not maintain this hash yourself, rather, you should use
+      the `style()` method of `Ember.RenderBuffer`.
 
-      willWatchProperty: function(prop){
-        Ember.deprecate(
-          "ContainerViews should not be observed as arrays. This behavior will change in future implementations of ContainerView.",
-          !prop.match(/\[]/) && prop.indexOf('@') !== 0
+      @property elementStyle
+      @type Hash
+      @default {}
+    */
+    elementStyle: null,
+
+    pushChildView: function (view) {
+      var index = this.childViews.length;
+      this.childViews[index] = view;
+      this.push("<script id='morph-"+index+"' type='text/x-placeholder'>\x3C/script>");
+    },
+
+    pushAttrNode: function (node) {
+      var index = this.attrNodes.length;
+      this.attrNodes[index] = node;
+    },
+
+    hydrateMorphs: function (contextualElement) {
+      var childViews = this.childViews;
+      var el = this._element;
+      for (var i=0,l=childViews.length; i<l; i++) {
+        var childView = childViews[i];
+        var ref = el.querySelector('#morph-'+i);
+
+        Ember['default'].assert('An error occurred while setting up template bindings. Please check ' +
+                     (childView && childView._parentView && childView._parentView._debugTemplateName ?
+                          '"' + childView._parentView._debugTemplateName + '" template ' :
+                          ''
+                     )  + 'for invalid markup or bindings within HTML comments.',
+                     ref);
+
+        var parent = ref.parentNode;
+
+        childView._morph = this.dom.insertMorphBefore(
+          parent,
+          ref,
+          parent.nodeType === 1 ? parent : contextualElement
         );
-      },
-
-      init: function() {
-        this._super();
+        parent.removeChild(ref);
+      }
+    },
 
-        var childViews = get(this, 'childViews');
-        Ember.deprecate('Setting `childViews` on a Container is deprecated.', Ember.isEmpty(childViews));
+    /**
+      Adds a string of HTML to the `RenderBuffer`.
 
-        // redefine view's childViews property that was obliterated
-        defineProperty(this, 'childViews', View.childViewsProperty);
+      @method push
+      @param {String} string HTML to push into the buffer
+      @chainable
+    */
+    push: function(content) {
+      if (typeof content === 'string') {
+        if (this.buffer === null) {
+          this.buffer = '';
+        }
+        Ember['default'].assert("A string cannot be pushed into the buffer after a fragment", !this.buffer.nodeType);
+        this.buffer += content;
+      } else {
+        Ember['default'].assert("A fragment cannot be pushed into a buffer that contains content", !this.buffer);
+        this.buffer = content;
+      }
+      return this;
+    },
 
-        var _childViews = this._childViews;
+    /**
+      Adds a class to the buffer, which will be rendered to the class attribute.
 
-        forEach(childViews, function(viewName, idx) {
-          var view;
+      @method addClass
+      @param {String} className Class name to add to the buffer
+      @chainable
+    */
+    addClass: function(className) {
+      // lazily create elementClasses
+      this.elementClasses = (this.elementClasses || new ClassSet());
+      this.elementClasses.add(className);
+      this.classes = this.elementClasses.list;
 
-          if ('string' === typeof viewName) {
-            view = get(this, viewName);
-            view = this.createChildView(view);
-            set(this, viewName, view);
-          } else {
-            view = this.createChildView(viewName);
-          }
+      return this;
+    },
 
-          _childViews[idx] = view;
-        }, this);
+    setClasses: function(classNames) {
+      this.elementClasses = null;
+      var len = classNames.length;
+      var i;
+      for (i = 0; i < len; i++) {
+        this.addClass(classNames[i]);
+      }
+    },
 
-        var currentView = get(this, 'currentView');
-        if (currentView) {
-          if (!_childViews.length) { _childViews = this._childViews = this._childViews.slice(); }
-          _childViews.push(this.createChildView(currentView));
-        }
-      },
+    /**
+      Sets the elementID to be used for the element.
 
-      replace: function(idx, removedCount, addedViews) {
-        var addedCount = addedViews ? get(addedViews, 'length') : 0;
-        var self = this;
-        Ember.assert("You can't add a child to a container - the child is already a child of another view", emberA(addedViews).every(function(item) { return !get(item, '_parentView') || get(item, '_parentView') === self; }));
+      @method id
+      @param {String} id
+      @chainable
+    */
+    id: function(id) {
+      this.elementId = id;
+      return this;
+    },
 
-        this.arrayContentWillChange(idx, removedCount, addedCount);
-        this.childViewsWillChange(this._childViews, idx, removedCount);
+    // duck type attribute functionality like jQuery so a render buffer
+    // can be used like a jQuery object in attribute binding scenarios.
 
-        if (addedCount === 0) {
-          this._childViews.splice(idx, removedCount) ;
-        } else {
-          var args = [idx, removedCount].concat(addedViews);
-          if (addedViews.length && !this._childViews.length) { this._childViews = this._childViews.slice(); }
-          this._childViews.splice.apply(this._childViews, args);
-        }
+    /**
+      Adds an attribute which will be rendered to the element.
 
-        this.arrayContentDidChange(idx, removedCount, addedCount);
-        this.childViewsDidChange(this._childViews, idx, removedCount, addedCount);
+      @method attr
+      @param {String} name The name of the attribute
+      @param {String} value The value to add to the attribute
+      @chainable
+      @return {Ember.RenderBuffer|String} this or the current attribute value
+    */
+    attr: function(name, value) {
+      var attributes = this.elementAttributes = (this.elementAttributes || {});
 
-        return this;
-      },
+      if (arguments.length === 1) {
+        return attributes[name];
+      } else {
+        attributes[name] = value;
+      }
 
-      objectAt: function(idx) {
-        return this._childViews[idx];
-      },
+      return this;
+    },
 
-      length: computed(function () {
-        return this._childViews.length;
-      })["volatile"](),
+    /**
+      Remove an attribute from the list of attributes to render.
 
-      /**
-        Instructs each child view to render to the passed render buffer.
+      @method removeAttr
+      @param {String} name The name of the attribute
+      @chainable
+    */
+    removeAttr: function(name) {
+      var attributes = this.elementAttributes;
+      if (attributes) { delete attributes[name]; }
 
-        @private
-        @method render
-        @param {Ember.RenderBuffer} buffer the buffer to render to
-      */
-      render: function(buffer) {
-        var element = buffer.element();
-        var dom = buffer.dom;
-
-        if (this.tagName === '') {
-          element = dom.createDocumentFragment();
-          buffer._element = element;
-          this._childViewsMorph = dom.appendMorph(element, this._morph.contextualElement);
-        } else {
-          this._childViewsMorph = dom.createMorph(element, element.lastChild, null);
-        }
+      return this;
+    },
 
-        return element;
-      },
+    /**
+      Adds a property which will be rendered to the element.
 
-      instrumentName: 'container',
+      @method prop
+      @param {String} name The name of the property
+      @param {String} value The value to add to the property
+      @chainable
+      @return {Ember.RenderBuffer|String} this or the current property value
+    */
+    prop: function(name, value) {
+      var properties = this.elementProperties = (this.elementProperties || {});
 
-      /**
-        When a child view is removed, destroy its element so that
-        it is removed from the DOM.
+      if (arguments.length === 1) {
+        return properties[name];
+      } else {
+        properties[name] = value;
+      }
 
-        The array observer that triggers this action is set up in the
-        `renderToBuffer` method.
+      return this;
+    },
 
-        @private
-        @method childViewsWillChange
-        @param {Ember.Array} views the child views array before mutation
-        @param {Number} start the start position of the mutation
-        @param {Number} removed the number of child views removed
-      **/
-      childViewsWillChange: function(views, start, removed) {
-        this.propertyWillChange('childViews');
-
-        if (removed > 0) {
-          var changedViews = views.slice(start, start+removed);
-          // transition to preRender before clearing parentView
-          this.currentState.childViewsWillChange(this, views, start, removed);
-          this.initializeViews(changedViews, null, null);
-        }
-      },
+    /**
+      Remove an property from the list of properties to render.
 
-      removeChild: function(child) {
-        this.removeObject(child);
-        return this;
-      },
+      @method removeProp
+      @param {String} name The name of the property
+      @chainable
+    */
+    removeProp: function(name) {
+      var properties = this.elementProperties;
+      if (properties) { delete properties[name]; }
 
-      /**
-        When a child view is added, make sure the DOM gets updated appropriately.
+      return this;
+    },
 
-        If the view has already rendered an element, we tell the child view to
-        create an element and insert it into the DOM. If the enclosing container
-        view has already written to a buffer, but not yet converted that buffer
-        into an element, we insert the string representation of the child into the
-        appropriate place in the buffer.
+    /**
+      Adds a style to the style attribute which will be rendered to the element.
 
-        @private
-        @method childViewsDidChange
-        @param {Ember.Array} views the array of child views after the mutation has occurred
-        @param {Number} start the start position of the mutation
-        @param {Number} removed the number of child views removed
-        @param {Number} added the number of child views added
-      */
-      childViewsDidChange: function(views, start, removed, added) {
-        if (added > 0) {
-          var changedViews = views.slice(start, start+added);
-          this.initializeViews(changedViews, this);
-          this.currentState.childViewsDidChange(this, views, start, added);
-        }
-        this.propertyDidChange('childViews');
-      },
+      @method style
+      @param {String} name Name of the style
+      @param {String} value
+      @chainable
+    */
+    style: function(name, value) {
+      this.elementStyle = (this.elementStyle || {});
 
-      initializeViews: function(views, parentView) {
-        forEach(views, function(view) {
-          set(view, '_parentView', parentView);
+      this.elementStyle[name] = value;
+      return this;
+    },
+
+    generateElement: function() {
+      var tagName = this.tagName;
+      var id = this.elementId;
+      var classes = this.classes;
+      var attrs = this.elementAttributes;
+      var props = this.elementProperties;
+      var style = this.elementStyle;
+      var styleBuffer = '';
+      var attr, prop, tagString;
+
+      if (!platform.canSetNameOnInputs && attrs && attrs.name) {
+        // IE allows passing a tag to createElement. See note on `canSetNameOnInputs` above as well.
+        tagString = '<'+stripTagName(tagName)+' name="'+escapeAttribute(attrs.name)+'">';
+      } else {
+        tagString = tagName;
+      }
 
-          if (!view.container && parentView) {
-            set(view, 'container', parentView.container);
-          }
-        });
-      },
+      var element = this.dom.createElement(tagString, this.outerContextualElement());
 
-      currentView: null,
+      if (id) {
+        this.dom.setAttribute(element, 'id', id);
+        this.elementId = null;
+      }
+      if (classes) {
+        this.dom.setAttribute(element, 'class', classes.join(' '));
+        this.classes = null;
+        this.elementClasses = null;
+      }
 
-      _currentViewWillChange: beforeObserver('currentView', function() {
-        var currentView = get(this, 'currentView');
-        if (currentView) {
-          currentView.destroy();
+      if (style) {
+        for (prop in style) {
+          styleBuffer += (prop + ':' + style[prop] + ';');
         }
-      }),
 
-      _currentViewDidChange: observer('currentView', function() {
-        var currentView = get(this, 'currentView');
-        if (currentView) {
-          Ember.assert("You tried to set a current view that already has a parent. Make sure you don't have multiple outlets in the same view.", !get(currentView, '_parentView'));
-          this.pushObject(currentView);
-        }
-      }),
+        this.dom.setAttribute(element, 'style', styleBuffer);
 
-      _ensureChildrenAreInDOM: function () {
-        this.currentState.ensureChildrenAreInDOM(this);
+        this.elementStyle = null;
       }
-    });
 
-    merge(states._default, {
-      childViewsWillChange: K,
-      childViewsDidChange: K,
-      ensureChildrenAreInDOM: K
-    });
+      if (attrs) {
+        for (attr in attrs) {
+          this.dom.setAttribute(element, attr, attrs[attr]);
+        }
 
-    merge(states.inBuffer, {
-      childViewsDidChange: function(parentView, views, start, added) {
-        throw new EmberError('You cannot modify child views while in the inBuffer state');
+        this.elementAttributes = null;
       }
-    });
 
-    merge(states.hasElement, {
-      childViewsWillChange: function(view, views, start, removed) {
-        for (var i=start; i<start+removed; i++) {
-          var _view = views[i];
-          _view._unsubscribeFromStreamBindings();
-          _view.remove();
+      if (props) {
+        for (prop in props) {
+          var normalizedCase = dom_helper__prop.normalizeProperty(element, prop.toLowerCase()) || prop;
+
+          this.dom.setPropertyStrict(element, normalizedCase, props[prop]);
         }
-      },
 
-      childViewsDidChange: function(view, views, start, added) {
-        run.scheduleOnce('render', view, '_ensureChildrenAreInDOM');
-      },
+        this.elementProperties = null;
+      }
 
-      ensureChildrenAreInDOM: function(view) {
-        var childViews = view._childViews;
-        var renderer = view._renderer;
+      this._element = element;
+    },
 
-        var i, len, childView;
-        for (i = 0, len = childViews.length; i < len; i++) {
-          childView = childViews[i];
-          if (!childView._elementCreated) {
-            renderer.renderTree(childView, view, i);
-          }
+    /**
+      @method element
+      @return {DOMElement} The element corresponding to the generated HTML
+        of this buffer
+    */
+    element: function() {
+
+      if (this._element && this.attrNodes.length > 0) {
+        var i, l, attrMorph, attrNode;
+        for (i=0, l=this.attrNodes.length; i<l; i++) {
+          attrNode = this.attrNodes[i];
+          attrMorph = this.dom.createAttrMorph(this._element, attrNode.attrName);
+          attrNode._morph = attrMorph;
         }
       }
-    });
 
-    __exports__["default"] = ContainerView;
-  });
-enifed("ember-views/views/core_view",
-  ["ember-views/system/renderer","ember-views/views/states","ember-runtime/system/object","ember-runtime/mixins/evented","ember-runtime/mixins/action_handler","ember-metal/property_get","ember-metal/computed","ember-metal/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
-    "use strict";
-    var Rerender = __dependency1__["default"];
+      var content = this.innerContent();
+      // No content means a text node buffer, with the content
+      // in _element. Ember._BoundView is an example.
+      if (content === null) {
+        return this._element;
+      }
 
-    var cloneStates = __dependency2__.cloneStates;
-    var states = __dependency2__.states;
-    var EmberObject = __dependency3__["default"];
-    var Evented = __dependency4__["default"];
-    var ActionHandler = __dependency5__["default"];
+      var contextualElement = this.innerContextualElement(content);
+      this.dom.detectNamespace(contextualElement);
 
-    var get = __dependency6__.get;
-    var computed = __dependency7__.computed;
+      if (!this._element) {
+        this._element = this.dom.createDocumentFragment();
+      }
+
+      if (content.nodeType) {
+        this._element.appendChild(content);
+      } else {
+        var frag = this.dom.parseHTML(content, contextualElement);
+        this._element.appendChild(frag);
+      }
 
-    var typeOf = __dependency8__.typeOf;
+      // This should only happen with legacy string buffers
+      if (this.childViews.length > 0) {
+        this.hydrateMorphs(contextualElement);
+      }
 
-    function K() { return this; }
+      return this._element;
+    },
 
     /**
-      `Ember.CoreView` is an abstract class that exists to give view-like behavior
-      to both Ember's main view class `Ember.View` and other classes like
-      `Ember._SimpleMetamorphView` that don't need the fully functionaltiy of
-      `Ember.View`.
-
-      Unless you have specific needs for `CoreView`, you will use `Ember.View`
-      in your applications.
+      Generates the HTML content for this buffer.
 
-      @class CoreView
-      @namespace Ember
-      @extends Ember.Object
-      @uses Ember.Evented
-      @uses Ember.ActionHandler
+      @method string
+      @return {String} The generated HTML
     */
-    var CoreView = EmberObject.extend(Evented, ActionHandler, {
-      isView: true,
-      isVirtual: false,
+    string: function() {
+      if (this._element) {
+        // Firefox versions < 11 do not have support for element.outerHTML.
+        var thisElement = this.element();
+        var outerHTML = thisElement.outerHTML;
+        if (typeof outerHTML === 'undefined') {
+          return jQuery['default']('<div/>').append(thisElement).html();
+        }
+        return outerHTML;
+      } else {
+        return this.innerString();
+      }
+    },
 
-      _states: cloneStates(states),
+    outerContextualElement: function() {
+      if (this._outerContextualElement === undefined) {
+        Ember['default'].deprecate("The render buffer expects an outer contextualElement to exist." +
+                        " This ensures DOM that requires context is correctly generated (tr, SVG tags)." +
+                        " Defaulting to document.body, but this will be removed in the future");
+        this.outerContextualElement = document.body;
+      }
+      return this._outerContextualElement;
+    },
 
-      init: function() {
-        this._super();
-        this._state = 'preRender';
-        this.currentState = this._states.preRender;
-        this._isVisible = get(this, 'isVisible');
-      },
+    innerContextualElement: function(html) {
+      var innerContextualElement;
+      if (this._element && this._element.nodeType === 1) {
+        innerContextualElement = this._element;
+      } else {
+        innerContextualElement = this.outerContextualElement();
+      }
 
-      /**
-        If the view is currently inserted into the DOM of a parent view, this
-        property will point to the parent of the view.
+      var omittedStartTag;
+      if (html) {
+        omittedStartTag = detectOmittedStartTag(this.dom, html, innerContextualElement);
+      }
+      return omittedStartTag || innerContextualElement;
+    },
 
-        @property parentView
-        @type Ember.View
-        @default null
-      */
-      parentView: computed('_parentView', function() {
-        var parent = this._parentView;
+    innerString: function() {
+      var content = this.innerContent();
+      if (content && !content.nodeType) {
+        return content;
+      }
+    },
 
-        if (parent && parent.isVirtual) {
-          return get(parent, 'parentView');
-        } else {
-          return parent;
-        }
-      }),
+    innerContent: function() {
+      return this.buffer;
+    }
+  };
 
-      _state: null,
+  exports['default'] = RenderBuffer;
 
-      _parentView: null,
+});
+enifed('ember-views/system/renderer', ['exports', 'ember-metal/core', 'ember-metal-views/renderer', 'ember-metal/platform/create', 'ember-views/system/render_buffer', 'ember-metal/run_loop', 'ember-metal/property_get', 'ember-metal/instrumentation'], function (exports, Ember, Renderer, create, RenderBuffer, run, property_get, instrumentation) {
 
-      // return the current view, not including virtual views
-      concreteView: computed('parentView', function() {
-        if (!this.isVirtual) { return this; }
-        else { return get(this, 'parentView.concreteView'); }
-      }),
+  'use strict';
 
-      instrumentName: 'core_view',
+  function EmberRenderer(domHelper, _destinedForDOM) {
+    this._super$constructor(domHelper, _destinedForDOM);
+    this.buffer = new RenderBuffer['default'](domHelper);
+  }
 
-      instrumentDetails: function(hash) {
-        hash.object = this.toString();
-        hash.containerKey = this._debugContainerKey;
-        hash.view = this;
-      },
+  EmberRenderer.prototype = create['default'](Renderer['default'].prototype);
+  EmberRenderer.prototype.constructor = EmberRenderer;
+  EmberRenderer.prototype._super$constructor = Renderer['default'];
 
-      /**
-        Override the default event firing from `Ember.Evented` to
-        also call methods with the given name.
+  EmberRenderer.prototype.scheduleRender =
+    function EmberRenderer_scheduleRender(ctx, fn) {
+      return run['default'].scheduleOnce('render', ctx, fn);
+    };
 
-        @method trigger
-        @param name {String}
-        @private
-      */
-      trigger: function() {
-        this._super.apply(this, arguments);
-        var name = arguments[0];
-        var method = this[name];
-        if (method) {
-          var length = arguments.length;
-          var args = new Array(length - 1);
-          for (var i = 1; i < length; i++) {
-            args[i - 1] = arguments[i];
-          }
-          return method.apply(this, args);
-        }
-      },
+  EmberRenderer.prototype.cancelRender =
+    function EmberRenderer_cancelRender(id) {
+      run['default'].cancel(id);
+    };
 
-      has: function(name) {
-        return typeOf(this[name]) === 'function' || this._super(name);
-      },
+  EmberRenderer.prototype.createElement =
+    function EmberRenderer_createElement(view, contextualElement) {
+      // If this is the top-most view, start a new buffer. Otherwise,
+      // create a new buffer relative to the original using the
+      // provided buffer operation (for example, `insertAfter` will
+      // insert a new buffer after the "parent buffer").
+      var tagName = view.tagName;
+      if (tagName !== null && typeof tagName === 'object' && tagName.isDescriptor) {
+        tagName = property_get.get(view, 'tagName');
+        Ember['default'].deprecate('In the future using a computed property to define tagName will not be permitted. That value will be respected, but changing it will not update the element.', !tagName);
+      }
+      var classNameBindings = view.classNameBindings;
+      var taglessViewWithClassBindings = tagName === '' && (classNameBindings && classNameBindings.length > 0);
+
+      if (tagName === null || tagName === undefined) {
+        tagName = 'div';
+      }
 
-      destroy: function() {
-        var parent = this._parentView;
+      Ember['default'].assert('You cannot use `classNameBindings` on a tag-less view: ' + view.toString(), !taglessViewWithClassBindings);
 
-        if (!this._super()) { return; }
+      var buffer = view.buffer = this.buffer;
+      buffer.reset(tagName, contextualElement);
 
+      if (view.beforeRender) {
+        view.beforeRender(buffer);
+      }
 
-        // destroy the element -- this will avoid each child view destroying
-        // the element over and over again...
-        if (!this.removedFromDOM && this._renderer) {
-          this._renderer.remove(this, true);
+      if (tagName !== '') {
+        if (view.applyAttributesToBuffer) {
+          view.applyAttributesToBuffer(buffer);
         }
+        buffer.generateElement();
+      }
 
-        // remove from parent if found. Don't call removeFromParent,
-        // as removeFromParent will try to remove the element from
-        // the DOM again.
-        if (parent) { parent.removeChild(this); }
+      if (view.render) {
+        view.render(buffer);
+      }
 
-        this._transitionTo('destroying', false);
+      if (view.afterRender) {
+        view.afterRender(buffer);
+      }
 
-        return this;
-      },
+      var element = buffer.element();
 
-      clearRenderedChildren: K,
-      _transitionTo: K,
-      destroyElement: K
-    });
+      view.buffer = null;
+      if (element && element.nodeType === 1) {
+        view.element = element;
+      }
+      return element;
+    };
 
-    CoreView.reopenClass({
-      renderer: new Rerender()
-    });
+  EmberRenderer.prototype.destroyView = function destroyView(view) {
+    view.removedFromDOM = true;
+    view.destroy();
+  };
 
-    __exports__["default"] = CoreView;
-  });
-enifed("ember-views/views/each",
-  ["ember-metal/core","ember-runtime/system/string","ember-metal/property_get","ember-metal/property_set","ember-views/views/collection_view","ember-metal/binding","ember-runtime/mixins/controller","ember-runtime/controllers/array_controller","ember-runtime/mixins/array","ember-metal/observer","ember-views/views/metamorph_view","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    var fmt = __dependency2__.fmt;
-    var get = __dependency3__.get;
-    var set = __dependency4__.set;
-    var CollectionView = __dependency5__["default"];
-    var Binding = __dependency6__.Binding;
-    var ControllerMixin = __dependency7__["default"];
-    var ArrayController = __dependency8__["default"];
-    var EmberArray = __dependency9__["default"];
-
-    var addObserver = __dependency10__.addObserver;
-    var removeObserver = __dependency10__.removeObserver;
-    var addBeforeObserver = __dependency10__.addBeforeObserver;
-    var removeBeforeObserver = __dependency10__.removeBeforeObserver;
-
-    var _MetamorphView = __dependency11__["default"];
-    var _Metamorph = __dependency11__._Metamorph;
-
-    __exports__["default"] = CollectionView.extend(_Metamorph, {
+  EmberRenderer.prototype.childViews = function childViews(view) {
+    return view._childViews;
+  };
 
-      init: function() {
-        var itemController = get(this, 'itemController');
-        var binding;
-
-        if (itemController) {
-          var controller = get(this, 'controller.container').lookupFactory('controller:array').create({
-            _isVirtual: true,
-            parentController: get(this, 'controller'),
-            itemController: itemController,
-            target: get(this, 'controller'),
-            _eachView: this
-          });
+  Renderer['default'].prototype.willCreateElement = function (view) {
+    if (instrumentation.subscribers.length && view.instrumentDetails) {
+      view._instrumentEnd = instrumentation._instrumentStart('render.'+view.instrumentName, function viewInstrumentDetails() {
+        var details = {};
+        view.instrumentDetails(details);
+        return details;
+      });
+    }
+    if (view._transitionTo) {
+      view._transitionTo('inBuffer');
+    }
+  }; // inBuffer
+  Renderer['default'].prototype.didCreateElement = function (view) {
+    if (view._transitionTo) {
+      view._transitionTo('hasElement');
+    }
+    if (view._instrumentEnd) {
+      view._instrumentEnd();
+    }
+  }; // hasElement
+  Renderer['default'].prototype.willInsertElement = function (view) {
+    if (this._destinedForDOM) {
+      if (view.trigger) { view.trigger('willInsertElement'); }
+    }
+  }; // will place into DOM
+  Renderer['default'].prototype.didInsertElement = function (view) {
+    if (view._transitionTo) {
+      view._transitionTo('inDOM');
+    }
 
-          this.disableContentObservers(function() {
-            set(this, 'content', controller);
-            binding = new Binding('content', '_eachView.dataSource').oneWay();
-            binding.connect(controller);
-          });
+    if (this._destinedForDOM) {
+      if (view.trigger) { view.trigger('didInsertElement'); }
+    }
+  }; // inDOM // placed into DOM
 
-          set(this, '_arrayController', controller);
-        } else {
-          this.disableContentObservers(function() {
-            binding = new Binding('content', 'dataSource').oneWay();
-            binding.connect(this);
-          });
-        }
+  Renderer['default'].prototype.willRemoveElement = function (view) {};
 
-        return this._super();
-      },
+  Renderer['default'].prototype.willDestroyElement = function (view) {
+    if (this._destinedForDOM) {
+      if (view._willDestroyElement) {
+        view._willDestroyElement();
+      }
+      if (view.trigger) {
+        view.trigger('willDestroyElement');
+        view.trigger('willClearRender');
+      }
+    }
+  };
 
-      _assertArrayLike: function(content) {
-        Ember.assert(fmt("The value that #each loops over must be an Array. You " +
-                         "passed %@, but it should have been an ArrayController",
-                         [content.constructor]),
-                         !ControllerMixin.detect(content) ||
-                           (content && content.isGenerated) ||
-                           content instanceof ArrayController);
-        Ember.assert(fmt("The value that #each loops over must be an Array. You passed %@",
-                         [(ControllerMixin.detect(content) &&
-                           content.get('model') !== undefined) ?
-                           fmt("'%@' (wrapped in %@)", [content.get('model'), content]) : content]),
-                         EmberArray.detect(content));
-      },
+  Renderer['default'].prototype.didDestroyElement = function (view) {
+    view.element = null;
+    if (view._transitionTo) {
+      view._transitionTo('preRender');
+    }
+  }; // element destroyed so view.destroy shouldn't try to remove it removedFromDOM
 
-      disableContentObservers: function(callback) {
-        removeBeforeObserver(this, 'content', null, '_contentWillChange');
-        removeObserver(this, 'content', null, '_contentDidChange');
+  exports['default'] = EmberRenderer;
 
-        callback.call(this);
+});
+enifed('ember-views/system/utils', ['exports'], function (exports) {
 
-        addBeforeObserver(this, 'content', null, '_contentWillChange');
-        addObserver(this, 'content', null, '_contentDidChange');
-      },
+  'use strict';
 
-      itemViewClass: _MetamorphView,
-      emptyViewClass: _MetamorphView,
+  exports.isSimpleClick = isSimpleClick;
+  exports.getViewClientRects = getViewClientRects;
+  exports.getViewBoundingClientRect = getViewBoundingClientRect;
 
-      createChildView: function(view, attrs) {
-        view = this._super(view, attrs);
+  /**
+  @module ember
+  @submodule ember-views
+  */
 
-        var content = get(view, 'content');
-        var keyword = get(this, 'keyword');
+  function isSimpleClick(event) {
+    var modifier = event.shiftKey || event.metaKey || event.altKey || event.ctrlKey;
+    var secondaryClick = event.which > 1; // IE9 may return undefined
 
-        if (keyword) {
-          view._keywords[keyword] = content;
-        }
+    return !modifier && !secondaryClick;
+  }
 
-        // If {{#each}} is looping over an array of controllers,
-        // point each child view at their respective controller.
-        if (content && content.isController) {
-          set(view, 'controller', content);
-        }
+  /**
+    @private
+    @method getViewRange
+    @param {Ember.View} view
+  */
+  function getViewRange(view) {
+    var range = document.createRange();
+    range.setStartBefore(view._morph.firstNode);
+    range.setEndAfter(view._morph.lastNode);
+    return range;
+  }
 
-        return view;
-      },
+  /**
+    `getViewClientRects` provides information about the position of the border
+    box edges of a view relative to the viewport.
 
-      destroy: function() {
-        if (!this._super()) { return; }
+    It is only intended to be used by development tools like the Ember Inspector
+    and may not work on older browsers.
 
-        var arrayController = get(this, '_arrayController');
+    @private
+    @method getViewClientRects
+    @param {Ember.View} view
+  */
+  function getViewClientRects(view) {
+    var range = getViewRange(view);
+    return range.getClientRects();
+  }
 
-        if (arrayController) {
-          arrayController.destroy();
-        }
+  /**
+    `getViewBoundingClientRect` provides information about the position of the
+    bounding border box edges of a view relative to the viewport.
 
-        return this;
+    It is only intended to be used by development tools like the Ember Inpsector
+    and may not work on older browsers.
+
+    @private
+    @method getViewBoundingClientRect
+    @param {Ember.View} view
+  */
+  function getViewBoundingClientRect(view) {
+    var range = getViewRange(view);
+    return range.getBoundingClientRect();
+  }
+
+});
+enifed('ember-views/views/bound_component_view', ['exports', 'ember-views/views/metamorph_view', 'ember-metal/streams/utils', 'ember-views/streams/utils', 'ember-htmlbars/system/merge-view-bindings', 'ember-metal/error', 'ember-views/views/container_view'], function (exports, metamorph_view, utils, streams__utils, mergeViewBindings, EmberError, ContainerView) {
+
+  'use strict';
+
+  /**
+  @module ember
+  @submodule ember-views
+  */
+
+  exports['default'] = ContainerView['default'].extend(metamorph_view._Metamorph, {
+    init: function() {
+      this._super.apply(this, arguments);
+      var componentNameStream = this._boundComponentOptions.componentNameStream;
+      var container = this.container;
+      this.componentClassStream = utils.chain(componentNameStream, function() {
+        return streams__utils.readComponentFactory(componentNameStream, container);
+      });
+
+      utils.subscribe(this.componentClassStream, this._updateBoundChildComponent, this);
+      this._updateBoundChildComponent();
+    },
+    willDestroy: function() {
+      utils.unsubscribe(this.componentClassStream, this._updateBoundChildComponent, this);
+      this._super.apply(this, arguments);
+    },
+    _updateBoundChildComponent: function() {
+      this.replace(0, 1, [this._createNewComponent()]);
+    },
+    _createNewComponent: function() {
+      var componentClass = utils.read(this.componentClassStream);
+      if (!componentClass) {
+        throw new EmberError['default']('HTMLBars error: Could not find component named "' + utils.read(this._boundComponentOptions.componentNameStream) + '".');
+      }
+      var hash    = this._boundComponentOptions;
+      var hashForComponent = {};
+
+      var prop;
+      for (prop in hash) {
+        if (prop === '_boundComponentOptions' || prop === 'componentClassStream') { continue; }
+        hashForComponent[prop] = hash[prop];
       }
-    });
+
+      var props   = {};
+      mergeViewBindings['default'](this, props, hashForComponent);
+      return this.createChildView(componentClass, props);
+    }
   });
-enifed("ember-views/views/metamorph_view",
-  ["ember-metal/core","ember-views/views/core_view","ember-views/views/view","ember-metal/mixin","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    /*jshint newcap:false*/
-    var Ember = __dependency1__["default"];
-    // Ember.deprecate
 
-    var CoreView = __dependency2__["default"];
-    var View = __dependency3__["default"];
-    var Mixin = __dependency4__.Mixin;
+});
+enifed('ember-views/views/bound_if_view', ['exports', 'ember-metal/run_loop', 'ember-views/views/metamorph_view', 'ember-views/mixins/normalized_rerender_if_needed', 'ember-htmlbars/system/render-view'], function (exports, run, _MetamorphView, NormalizedRerenderIfNeededSupport, renderView) {
 
-    /**
-    @module ember
-    @submodule ember-views
-    */
+  'use strict';
 
-    // The `morph` and `outerHTML` properties are internal only
-    // and not observable.
+  exports['default'] = _MetamorphView['default'].extend(NormalizedRerenderIfNeededSupport['default'], {
+    init: function() {
+      this._super.apply(this, arguments);
 
-    /**
-      @class _Metamorph
-      @namespace Ember
-      @private
-    */
-    var _Metamorph = Mixin.create({
-      isVirtual: true,
-      tagName: '',
+      var self = this;
 
-      instrumentName: 'metamorph',
+      this.conditionStream.subscribe(this._wrapAsScheduled(function() {
+        run['default'].scheduleOnce('render', self, 'rerenderIfNeeded');
+      }));
+    },
 
-      init: function() {
-        this._super();
-        Ember.deprecate('Supplying a tagName to Metamorph views is unreliable and is deprecated.' +
-                        ' You may be setting the tagName on a Handlebars helper that creates a Metamorph.', !this.tagName);
-      }
-    });
-    __exports__._Metamorph = _Metamorph;
-    /**
-      @class _MetamorphView
-      @namespace Ember
-      @extends Ember.View
-      @uses Ember._Metamorph
-      @private
-    */
-    __exports__["default"] = View.extend(_Metamorph);
+    normalizedValue: function() {
+      return this.conditionStream.value();
+    },
 
-    /**
-      @class _SimpleMetamorphView
-      @namespace Ember
-      @extends Ember.CoreView
-      @uses Ember._Metamorph
-      @private
-    */
-    var _SimpleMetamorphView = CoreView.extend(_Metamorph);
-    __exports__._SimpleMetamorphView = _SimpleMetamorphView;
+    render: function(buffer) {
+      var result = this.conditionStream.value();
+      this._lastNormalizedValue = result;
+
+      var template = result ? this.truthyTemplate : this.falsyTemplate;
+      renderView['default'](this, buffer, template);
+    }
   });
-enifed("ember-views/views/select",
-  ["ember-metal/enumerable_utils","ember-metal/property_get","ember-metal/property_set","ember-views/views/view","ember-views/views/collection_view","ember-metal/utils","ember-metal/is_none","ember-metal/computed","ember-runtime/system/native_array","ember-metal/mixin","ember-metal/properties","ember-metal/run_loop","ember-htmlbars/templates/select","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-views
-    */
 
-    var forEach = __dependency1__.forEach;
-    var indexOf = __dependency1__.indexOf;
-    var indexesOf = __dependency1__.indexesOf;
-    var replace = __dependency1__.replace;
+});
+enifed('ember-views/views/bound_partial_view', ['exports', 'ember-views/views/metamorph_view', 'ember-views/mixins/normalized_rerender_if_needed', 'ember-views/system/lookup_partial', 'ember-metal/run_loop', 'ember-htmlbars/system/render-view', 'ember-htmlbars/templates/empty'], function (exports, _MetamorphView, NormalizedRerenderIfNeededSupport, lookupPartial, run, renderView, emptyTemplate) {
 
-    var get = __dependency2__.get;
-    var set = __dependency3__.set;
-    var View = __dependency4__["default"];
-    var CollectionView = __dependency5__["default"];
-    var isArray = __dependency6__.isArray;
-    var isNone = __dependency7__["default"];
-    var computed = __dependency8__.computed;
-    var emberA = __dependency9__.A;
-    var observer = __dependency10__.observer;
-    var defineProperty = __dependency11__.defineProperty;
-    var run = __dependency12__["default"];
+  'use strict';
 
-    var htmlbarsTemplate = __dependency13__["default"];
+  /**
+  @module ember
+  @submodule ember-views
+  */
 
-    var defaultTemplate = htmlbarsTemplate;
+  exports['default'] = _MetamorphView['default'].extend(NormalizedRerenderIfNeededSupport['default'], {
+    init: function() {
+      this._super.apply(this, arguments);
 
-    var selectOptionDefaultTemplate = {
-      isHTMLBars: true,
-      render: function(context, env, contextualElement) {
-        var lazyValue = context.getStream('view.label');
+      var self = this;
 
-        lazyValue.subscribe(context._wrapAsScheduled(function() {
-          run.scheduleOnce('render', context, 'rerender');
-        }));
+      this.templateNameStream.subscribe(this._wrapAsScheduled(function() {
+        run['default'].scheduleOnce('render', self, 'rerenderIfNeeded');
+      }));
+    },
+
+    normalizedValue: function() {
+      return this.templateNameStream.value();
+    },
 
-        return lazyValue.value();
+    render: function(buffer) {
+      var templateName = this.normalizedValue();
+      this._lastNormalizedValue = templateName;
+
+      var template;
+      if (templateName) {
+        template = lookupPartial['default'](this, templateName);
       }
-    };
 
-    var SelectOption = View.extend({
-      instrumentDisplay: 'Ember.SelectOption',
+      renderView['default'](this, buffer, template || emptyTemplate['default']);
+    }
+  });
 
-      tagName: 'option',
-      attributeBindings: ['value', 'selected'],
+});
+enifed('ember-views/views/checkbox', ['exports', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-views/views/view'], function (exports, property_get, property_set, View) {
 
-      defaultTemplate: selectOptionDefaultTemplate,
+  'use strict';
 
-      init: function() {
-        this.labelPathDidChange();
-        this.valuePathDidChange();
+  exports['default'] = View['default'].extend({
+    instrumentDisplay: '{{input type="checkbox"}}',
 
-        this._super();
-      },
+    classNames: ['ember-checkbox'],
 
-      selected: computed(function() {
-        var content = get(this, 'content');
-        var selection = get(this, 'parentView.selection');
-        if (get(this, 'parentView.multiple')) {
-          return selection && indexOf(selection, content.valueOf()) > -1;
-        } else {
-          // Primitives get passed through bindings as objects... since
-          // `new Number(4) !== 4`, we use `==` below
-          return content == selection; // jshint ignore:line
-        }
-      }).property('content', 'parentView.selection'),
+    tagName: 'input',
 
-      labelPathDidChange: observer('parentView.optionLabelPath', function() {
-        var labelPath = get(this, 'parentView.optionLabelPath');
+    attributeBindings: [
+      'type',
+      'checked',
+      'indeterminate',
+      'disabled',
+      'tabindex',
+      'name',
+      'autofocus',
+      'required',
+      'form'
+    ],
 
-        if (!labelPath) { return; }
+    type: 'checkbox',
+    checked: false,
+    disabled: false,
+    indeterminate: false,
 
-        defineProperty(this, 'label', computed(function() {
-          return get(this, labelPath);
-        }).property(labelPath));
-      }),
+    init: function() {
+      this._super.apply(this, arguments);
+      this.on('change', this, this._updateElementValue);
+    },
 
-      valuePathDidChange: observer('parentView.optionValuePath', function() {
-        var valuePath = get(this, 'parentView.optionValuePath');
+    didInsertElement: function() {
+      this._super.apply(this, arguments);
+      property_get.get(this, 'element').indeterminate = !!property_get.get(this, 'indeterminate');
+    },
 
-        if (!valuePath) { return; }
+    _updateElementValue: function() {
+      property_set.set(this, 'checked', this.$().prop('checked'));
+    }
+  });
 
-        defineProperty(this, 'value', computed(function() {
-          return get(this, valuePath);
-        }).property(valuePath));
-      })
-    });
+});
+enifed('ember-views/views/collection_view', ['exports', 'ember-metal/core', 'ember-metal/binding', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-runtime/system/string', 'ember-views/views/container_view', 'ember-views/views/core_view', 'ember-views/views/view', 'ember-metal/mixin', 'ember-views/streams/utils', 'ember-runtime/mixins/array'], function (exports, Ember, binding, property_get, property_set, string, ContainerView, CoreView, View, mixin, utils, EmberArray) {
 
-    var SelectOptgroup = CollectionView.extend({
-      instrumentDisplay: 'Ember.SelectOptgroup',
+  'use strict';
 
-      tagName: 'optgroup',
-      attributeBindings: ['label'],
 
-      selectionBinding: 'parentView.selection',
-      multipleBinding: 'parentView.multiple',
-      optionLabelPathBinding: 'parentView.optionLabelPath',
-      optionValuePathBinding: 'parentView.optionValuePath',
+  /**
+  @module ember
+  @submodule ember-views
+  */
 
-      itemViewClassBinding: 'parentView.optionView'
-    });
+  var CollectionView = ContainerView['default'].extend({
 
     /**
-      The `Ember.Select` view class renders a
-      [select](https://developer.mozilla.org/en/HTML/Element/select) HTML element,
-      allowing the user to choose from a list of options.
+      A list of items to be displayed by the `Ember.CollectionView`.
 
-      The text and `value` property of each `<option>` element within the
-      `<select>` element are populated from the objects in the `Element.Select`'s
-      `content` property. The underlying data object of the selected `<option>` is
-      stored in the `Element.Select`'s `value` property.
+      @property content
+      @type Ember.Array
+      @default null
+    */
+    content: null,
 
-      ## The Content Property (array of strings)
+    /**
+      This provides metadata about what kind of empty view class this
+      collection would like if it is being instantiated from another
+      system (like Handlebars)
 
-      The simplest version of an `Ember.Select` takes an array of strings as its
-      `content` property. The string will be used as both the `value` property and
-      the inner text of each `<option>` element inside the rendered `<select>`.
+      @private
+      @property emptyViewClass
+    */
+    emptyViewClass: View['default'],
 
-      Example:
+    /**
+      An optional view to display if content is set to an empty array.
 
-      ```javascript
-      App.ApplicationController = Ember.ObjectController.extend({
-        names: ["Yehuda", "Tom"]
-      });
-      ```
+      @property emptyView
+      @type Ember.View
+      @default null
+    */
+    emptyView: null,
 
-      ```handlebars
-      {{view "select" content=names}}
-      ```
+    /**
+      @property itemViewClass
+      @type Ember.View
+      @default Ember.View
+    */
+    itemViewClass: View['default'],
 
-      Would result in the following HTML:
+    /**
+      Setup a CollectionView
 
-      ```html
-      <select class="ember-select">
-        <option value="Yehuda">Yehuda</option>
-        <option value="Tom">Tom</option>
-      </select>
-      ```
+      @method init
+    */
+    init: function() {
+      var ret = this._super.apply(this, arguments);
+      this._contentDidChange();
+      return ret;
+    },
 
-      You can control which `<option>` is selected through the `Ember.Select`'s
-      `value` property:
+    /**
+      Invoked when the content property is about to change. Notifies observers that the
+      entire array content will change.
 
-      ```javascript
-      App.ApplicationController = Ember.ObjectController.extend({
-        selectedName: 'Tom',
-        names: ["Yehuda", "Tom"]
-      });
-      ```
+      @private
+      @method _contentWillChange
+    */
+    _contentWillChange: mixin.beforeObserver('content', function() {
+      var content = this.get('content');
 
-      ```handlebars
-      {{view "select" content=names value=selectedName}}
-      ```
+      if (content) { content.removeArrayObserver(this); }
+      var len = content ? property_get.get(content, 'length') : 0;
+      this.arrayWillChange(content, 0, len);
+    }),
 
-      Would result in the following HTML with the `<option>` for 'Tom' selected:
+    /**
+      Check to make sure that the content has changed, and if so,
+      update the children directly. This is always scheduled
+      asynchronously, to allow the element to be created before
+      bindings have synchronized and vice versa.
 
-      ```html
-      <select class="ember-select">
-        <option value="Yehuda">Yehuda</option>
-        <option value="Tom" selected="selected">Tom</option>
-      </select>
-      ```
+      @private
+      @method _contentDidChange
+    */
+    _contentDidChange: mixin.observer('content', function() {
+      var content = property_get.get(this, 'content');
 
-      A user interacting with the rendered `<select>` to choose "Yehuda" would
-      update the value of `selectedName` to "Yehuda".
+      if (content) {
+        this._assertArrayLike(content);
+        content.addArrayObserver(this);
+      }
 
-      ## The Content Property (array of Objects)
+      var len = content ? property_get.get(content, 'length') : 0;
+      this.arrayDidChange(content, 0, null, len);
+    }),
 
-      An `Ember.Select` can also take an array of JavaScript or Ember objects as
-      its `content` property.
+    /**
+      Ensure that the content implements Ember.Array
 
-      When using objects you need to tell the `Ember.Select` which property should
-      be accessed on each object to supply the `value` attribute of the `<option>`
-      and which property should be used to supply the element text.
+      @private
+      @method _assertArrayLike
+    */
+    _assertArrayLike: function(content) {
+      Ember['default'].assert(string.fmt("an Ember.CollectionView's content must implement Ember.Array. You passed %@", [content]), EmberArray['default'].detect(content));
+    },
 
-      The `optionValuePath` option is used to specify the path on each object to
-      the desired property for the `value` attribute. The `optionLabelPath`
-      specifies the path on each object to the desired property for the
-      element's text. Both paths must reference each object itself as `content`:
+    /**
+      Removes the content and content observers.
 
-      ```javascript
-      App.ApplicationController = Ember.ObjectController.extend({
-        programmers: [
-          {firstName: "Yehuda", id: 1},
-          {firstName: "Tom",    id: 2}
-        ]
-      });
-      ```
+      @method destroy
+    */
+    destroy: function() {
+      if (!this._super.apply(this, arguments)) { return; }
 
-      ```handlebars
-      {{view "select"
-             content=programmers
-             optionValuePath="content.id"
-             optionLabelPath="content.firstName"}}
-      ```
+      var content = property_get.get(this, 'content');
+      if (content) { content.removeArrayObserver(this); }
 
-      Would result in the following HTML:
+      if (this._createdEmptyView) {
+        this._createdEmptyView.destroy();
+      }
 
-      ```html
-      <select class="ember-select">
-        <option value="1">Yehuda</option>
-        <option value="2">Tom</option>
-      </select>
-      ```
+      return this;
+    },
 
-      The `value` attribute of the selected `<option>` within an `Ember.Select`
-      can be bound to a property on another object:
+    /**
+      Called when a mutation to the underlying content array will occur.
 
-      ```javascript
-      App.ApplicationController = Ember.ObjectController.extend({
-        programmers: [
-          {firstName: "Yehuda", id: 1},
-          {firstName: "Tom",    id: 2}
-        ],
-        currentProgrammer: {
-          id: 2
-        }
-      });
-      ```
+      This method will remove any views that are no longer in the underlying
+      content array.
 
-      ```handlebars
-      {{view "select"
-             content=programmers
-             optionValuePath="content.id"
-             optionLabelPath="content.firstName"
-             value=currentProgrammer.id}}
-      ```
+      Invokes whenever the content array itself will change.
 
-      Would result in the following HTML with a selected option:
+      @method arrayWillChange
+      @param {Array} content the managed collection of objects
+      @param {Number} start the index at which the changes will occur
+      @param {Number} removed number of object to be removed from content
+    */
+    arrayWillChange: function(content, start, removedCount) {
+      // If the contents were empty before and this template collection has an
+      // empty view remove it now.
+      var emptyView = property_get.get(this, 'emptyView');
+      if (emptyView && emptyView instanceof View['default']) {
+        emptyView.removeFromParent();
+      }
 
-      ```html
-      <select class="ember-select">
-        <option value="1">Yehuda</option>
-        <option value="2" selected="selected">Tom</option>
-      </select>
-      ```
+      // Loop through child views that correspond with the removed items.
+      // Note that we loop from the end of the array to the beginning because
+      // we are mutating it as we go.
+      var childViews = this._childViews;
+      var childView, idx;
 
-      Interacting with the rendered element by selecting the first option
-      ('Yehuda') will update the `id` of `currentProgrammer`
-      to match the `value` property of the newly selected `<option>`.
+      for (idx = start + removedCount - 1; idx >= start; idx--) {
+        childView = childViews[idx];
+        childView.destroy();
+      }
+    },
 
-      Alternatively, you can control selection through the underlying objects
-      used to render each object by binding the `selection` option. When the selected
-      `<option>` is changed, the property path provided to `selection`
-      will be updated to match the content object of the rendered `<option>`
-      element:
+    /**
+      Called when a mutation to the underlying content array occurs.
 
-      ```javascript
+      This method will replay that mutation against the views that compose the
+      `Ember.CollectionView`, ensuring that the view reflects the model.
 
-      var yehuda = {firstName: "Yehuda", id: 1, bff4eva: 'tom'}
-      var tom = {firstName: "Tom", id: 2, bff4eva: 'yehuda'};
+      This array observer is added in `contentDidChange`.
 
-      App.ApplicationController = Ember.ObjectController.extend({
-        selectedPerson: tom,
-        programmers: [ yehuda, tom ]
-      });
-      ```
+      @method arrayDidChange
+      @param {Array} content the managed collection of objects
+      @param {Number} start the index at which the changes occurred
+      @param {Number} removed number of object removed from content
+      @param {Number} added number of object added to content
+    */
+    arrayDidChange: function(content, start, removed, added) {
+      var addedViews = [];
+      var view, item, idx, len, itemViewClass, emptyView, itemViewProps;
 
-      ```handlebars
-      {{view "select"
-             content=programmers
-             optionValuePath="content.id"
-             optionLabelPath="content.firstName"
-             selection=selectedPerson}}
-      ```
+      len = content ? property_get.get(content, 'length') : 0;
 
-      Would result in the following HTML with a selected option:
+      if (len) {
+        itemViewProps = this._itemViewProps || {};
+        itemViewClass = property_get.get(this, 'itemViewClass');
 
-      ```html
-      <select class="ember-select">
-        <option value="1">Yehuda</option>
-        <option value="2" selected="selected">Tom</option>
-      </select>
-      ```
+        itemViewClass = utils.readViewFactory(itemViewClass, this.container);
 
-      Interacting with the rendered element by selecting the first option
-      ('Yehuda') will update the `selectedPerson` to match the object of
-      the newly selected `<option>`. In this case it is the first object
-      in the `programmers`
+        for (idx = start; idx < start+added; idx++) {
+          item = content.objectAt(idx);
+          itemViewProps._context = this.keyword ? this.get('context') : item;
+          itemViewProps.content = item;
+          itemViewProps.contentIndex = idx;
 
-      ## Supplying a Prompt
+          view = this.createChildView(itemViewClass, itemViewProps);
 
-      A `null` value for the `Ember.Select`'s `value` or `selection` property
-      results in there being no `<option>` with a `selected` attribute:
 
-      ```javascript
-      App.ApplicationController = Ember.ObjectController.extend({
-        selectedProgrammer: null,
-        programmers: ["Yehuda", "Tom"]
-      });
-      ```
+            if (this.blockParams > 1) {
+              view._blockArguments = [item, view.getStream('_view.contentIndex')];
+            } else if (this.blockParams === 1) {
+              view._blockArguments = [item];
+            }
 
-      ``` handlebars
-      {{view "select"
-             content=programmers
-             value=selectedProgrammer
-      }}
-      ```
+          addedViews.push(view);
+        }
 
-      Would result in the following HTML:
+        this.replace(start, 0, addedViews);
 
-      ```html
-      <select class="ember-select">
-        <option value="Yehuda">Yehuda</option>
-        <option value="Tom">Tom</option>
-      </select>
-      ```
 
-      Although `selectedProgrammer` is `null` and no `<option>`
-      has a `selected` attribute the rendered HTML will display the
-      first item as though it were selected. You can supply a string
-      value for the `Ember.Select` to display when there is no selection
-      with the `prompt` option:
+          if (this.blockParams > 1) {
+            var childViews = this._childViews;
+            for (idx = start+added; idx < len; idx++) {
+              view = childViews[idx];
+              property_set.set(view, 'contentIndex', idx);
+            }
+          }
 
-      ```javascript
-      App.ApplicationController = Ember.ObjectController.extend({
-        selectedProgrammer: null,
-        programmers: [ "Yehuda", "Tom" ]
-      });
-      ```
+      } else {
+        emptyView = property_get.get(this, 'emptyView');
 
-      ```handlebars
-      {{view "select"
-             content=programmers
-             value=selectedProgrammer
-             prompt="Please select a name"
-      }}
-      ```
+        if (!emptyView) { return; }
 
-      Would result in the following HTML:
+        if ('string' === typeof emptyView && binding.isGlobalPath(emptyView)) {
+          emptyView = property_get.get(emptyView) || emptyView;
+        }
 
-      ```html
-      <select class="ember-select">
-        <option>Please select a name</option>
-        <option value="Yehuda">Yehuda</option>
-        <option value="Tom">Tom</option>
-      </select>
-      ```
+        emptyView = this.createChildView(emptyView);
 
-      @class Select
-      @namespace Ember
-      @extends Ember.View
-    */
-    var Select = View.extend({
-      instrumentDisplay: 'Ember.Select',
+        addedViews.push(emptyView);
+        property_set.set(this, 'emptyView', emptyView);
 
-      tagName: 'select',
-      classNames: ['ember-select'],
-      defaultTemplate: defaultTemplate,
-      attributeBindings: ['multiple', 'disabled', 'tabindex', 'name', 'required', 'autofocus',
-                          'form', 'size'],
+        if (CoreView['default'].detect(emptyView)) {
+          this._createdEmptyView = emptyView;
+        }
 
-      /**
-        The `multiple` attribute of the select element. Indicates whether multiple
-        options can be selected.
+        this.replace(start, 0, addedViews);
+      }
+    },
 
-        @property multiple
-        @type Boolean
-        @default false
-      */
-      multiple: false,
+    /**
+      Instantiates a view to be added to the childViews array during view
+      initialization. You generally will not call this method directly unless
+      you are overriding `createChildViews()`. Note that this method will
+      automatically configure the correct settings on the new view instance to
+      act as a child of the parent.
 
-      /**
-        The `disabled` attribute of the select element. Indicates whether
-        the element is disabled from interactions.
+      The tag name for the view will be set to the tagName of the viewClass
+      passed in.
 
-        @property disabled
-        @type Boolean
-        @default false
-      */
-      disabled: false,
+      @method createChildView
+      @param {Class} viewClass
+      @param {Hash} [attrs] Attributes to add
+      @return {Ember.View} new instance
+    */
+    createChildView: function(_view, attrs) {
+      var view = this._super(_view, attrs);
 
-      /**
-        The `required` attribute of the select element. Indicates whether
-        a selected option is required for form validation.
+      var itemTagName = property_get.get(view, 'tagName');
 
-        @property required
-        @type Boolean
-        @default false
-        @since 1.5.0
-      */
-      required: false,
+      if (itemTagName === null || itemTagName === undefined) {
+        itemTagName = CollectionView.CONTAINER_MAP[property_get.get(this, 'tagName')];
+        property_set.set(view, 'tagName', itemTagName);
+      }
 
-      /**
-        The list of options.
+      return view;
+    }
+  });
 
-        If `optionLabelPath` and `optionValuePath` are not overridden, this should
-        be a list of strings, which will serve simultaneously as labels and values.
+  /**
+    A map of parent tags to their default child tags. You can add
+    additional parent tags if you want collection views that use
+    a particular parent tag to default to a child tag.
 
-        Otherwise, this should be a list of objects. For instance:
+    @property CONTAINER_MAP
+    @type Hash
+    @static
+    @final
+  */
+  CollectionView.CONTAINER_MAP = {
+    ul: 'li',
+    ol: 'li',
+    table: 'tr',
+    thead: 'tr',
+    tbody: 'tr',
+    tfoot: 'tr',
+    tr: 'td',
+    select: 'option'
+  };
+
+  exports['default'] = CollectionView;
+
+});
+enifed('ember-views/views/component', ['exports', 'ember-metal/core', 'ember-views/mixins/component_template_deprecation', 'ember-runtime/mixins/target_action_support', 'ember-views/views/view', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/is_none', 'ember-metal/computed', 'ember-htmlbars/templates/component'], function (exports, Ember, ComponentTemplateDeprecation, TargetActionSupport, View, property_get, property_set, isNone, computed, defaultComponentLayout) {
+
+  'use strict';
+
+  var a_slice = Array.prototype.slice;
+
+  /**
+  @module ember
+  @submodule ember-views
+  */
+
+  /**
+    An `Ember.Component` is a view that is completely
+    isolated. Properties accessed in its templates go
+    to the view object and actions are targeted at
+    the view object. There is no access to the
+    surrounding context or outer controller; all
+    contextual information must be passed in.
+
+    The easiest way to create an `Ember.Component` is via
+    a template. If you name a template
+    `components/my-foo`, you will be able to use
+    `{{my-foo}}` in other templates, which will make
+    an instance of the isolated component.
 
-        ```javascript
-        var App = Ember.Application.create();
-        var App.MySelect = Ember.Select.extend({
-          content: Ember.A([
-              { id: 1, firstName: 'Yehuda' },
-              { id: 2, firstName: 'Tom' }
-            ]),
-          optionLabelPath: 'content.firstName',
-          optionValuePath: 'content.id'
-        });
-        ```
+    ```handlebars
+    {{app-profile person=currentUser}}
+    ```
 
-        @property content
-        @type Array
-        @default null
-      */
-      content: null,
+    ```handlebars
+    <!-- app-profile template -->
+    <h1>{{person.title}}</h1>
+    <img {{bind-attr src=person.avatar}}>
+    <p class='signature'>{{person.signature}}</p>
+    ```
 
-      /**
-        When `multiple` is `false`, the element of `content` that is currently
-        selected, if any.
+    You can use `yield` inside a template to
+    include the **contents** of any block attached to
+    the component. The block will be executed in the
+    context of the surrounding context or outer controller:
 
-        When `multiple` is `true`, an array of such elements.
+    ```handlebars
+    {{#app-profile person=currentUser}}
+      <p>Admin mode</p>
+      {{! Executed in the controller's context. }}
+    {{/app-profile}}
+    ```
 
-        @property selection
-        @type Object or Array
-        @default null
-      */
-      selection: null,
+    ```handlebars
+    <!-- app-profile template -->
+    <h1>{{person.title}}</h1>
+    {{! Executed in the components context. }}
+    {{yield}} {{! block contents }}
+    ```
 
-      /**
-        In single selection mode (when `multiple` is `false`), value can be used to
-        get the current selection's value or set the selection by its value.
+    If you want to customize the component, in order to
+    handle events or actions, you implement a subclass
+    of `Ember.Component` named after the name of the
+    component. Note that `Component` needs to be appended to the name of
+    your subclass like `AppProfileComponent`.
 
-        It is not currently supported in multiple selection mode.
+    For example, you could implement the action
+    `hello` for the `app-profile` component:
 
-        @property value
-        @type String
-        @default null
-      */
-      value: computed(function(key, value) {
-        if (arguments.length === 2) { return value; }
-        var valuePath = get(this, 'optionValuePath').replace(/^content\.?/, '');
-        return valuePath ? get(this, 'selection.' + valuePath) : get(this, 'selection');
-      }).property('selection'),
+    ```javascript
+    App.AppProfileComponent = Ember.Component.extend({
+      actions: {
+        hello: function(name) {
+          console.log("Hello", name);
+        }
+      }
+    });
+    ```
 
-      /**
-        If given, a top-most dummy option will be rendered to serve as a user
-        prompt.
+    And then use it in the component's template:
 
-        @property prompt
-        @type String
-        @default null
-      */
-      prompt: null,
+    ```handlebars
+    <!-- app-profile template -->
 
-      /**
-        The path of the option labels. See [content](/api/classes/Ember.Select.html#property_content).
+    <h1>{{person.title}}</h1>
+    {{yield}} <!-- block contents -->
 
-        @property optionLabelPath
-        @type String
-        @default 'content'
-      */
-      optionLabelPath: 'content',
+    <button {{action 'hello' person.name}}>
+      Say Hello to {{person.name}}
+    </button>
+    ```
 
-      /**
-        The path of the option values. See [content](/api/classes/Ember.Select.html#property_content).
+    Components must have a `-` in their name to avoid
+    conflicts with built-in controls that wrap HTML
+    elements. This is consistent with the same
+    requirement in web components.
 
-        @property optionValuePath
-        @type String
-        @default 'content'
-      */
-      optionValuePath: 'content',
+    @class Component
+    @namespace Ember
+    @extends Ember.View
+  */
+  var Component = View['default'].extend(TargetActionSupport['default'], ComponentTemplateDeprecation['default'], {
+    /*
+      This is set so that the proto inspection in appendTemplatedView does not
+      think that it should set the components `context` to that of the parent view.
+    */
+    controller: null,
+    context: null,
 
-      /**
-        The path of the option group.
-        When this property is used, `content` should be sorted by `optionGroupPath`.
+    instrumentName: 'component',
+    instrumentDisplay: computed.computed(function() {
+      if (this._debugContainerKey) {
+        return '{{' + this._debugContainerKey.split(':')[1] + '}}';
+      }
+    }),
 
-        @property optionGroupPath
-        @type String
-        @default null
-      */
-      optionGroupPath: null,
+    init: function() {
+      this._super.apply(this, arguments);
+      this._keywords.view = this;
+      property_set.set(this, 'context', this);
+      property_set.set(this, 'controller', this);
+    },
 
-      /**
-        The view class for optgroup.
+    defaultLayout: defaultComponentLayout['default'],
 
-        @property groupView
-        @type Ember.View
-        @default Ember.SelectOptgroup
-      */
-      groupView: SelectOptgroup,
+    /**
+    A components template property is set by passing a block
+    during its invocation. It is executed within the parent context.
 
-      groupedContent: computed(function() {
-        var groupPath = get(this, 'optionGroupPath');
-        var groupedContent = emberA();
-        var content = get(this, 'content') || [];
+    Example:
 
-        forEach(content, function(item) {
-          var label = get(item, groupPath);
+    ```handlebars
+    {{#my-component}}
+      // something that is run in the context
+      // of the parent context
+    {{/my-component}}
+    ```
 
-          if (get(groupedContent, 'lastObject.label') !== label) {
-            groupedContent.pushObject({
-              label: label,
-              content: emberA()
-            });
-          }
+    Specifying a template directly to a component is deprecated without
+    also specifying the layout property.
 
-          get(groupedContent, 'lastObject.content').push(item);
-        });
+    @deprecated
+    @property template
+    */
+    template: computed.computed(function(key, value) {
+      if (value !== undefined) { return value; }
 
-        return groupedContent;
-      }).property('optionGroupPath', 'content.@each'),
+      var templateName = property_get.get(this, 'templateName');
+      var template = this.templateForName(templateName, 'template');
 
-      /**
-        The view class for option.
+      Ember['default'].assert("You specified the templateName " + templateName + " for " + this + ", but it did not exist.", !templateName || !!template);
 
-        @property optionView
-        @type Ember.View
-        @default Ember.SelectOption
-      */
-      optionView: SelectOption,
+      return template || property_get.get(this, 'defaultTemplate');
+    }).property('templateName'),
 
-      _change: function() {
-        if (get(this, 'multiple')) {
-          this._changeMultiple();
-        } else {
-          this._changeSingle();
-        }
-      },
+    /**
+    Specifying a components `templateName` is deprecated without also
+    providing the `layout` or `layoutName` properties.
 
-      selectionDidChange: observer('selection.@each', function() {
-        var selection = get(this, 'selection');
-        if (get(this, 'multiple')) {
-          if (!isArray(selection)) {
-            set(this, 'selection', emberA([selection]));
-            return;
-          }
-          this._selectionDidChangeMultiple();
-        } else {
-          this._selectionDidChangeSingle();
-        }
-      }),
+    @deprecated
+    @property templateName
+    */
+    templateName: null,
 
-      valueDidChange: observer('value', function() {
-        var content = get(this, 'content');
-        var value = get(this, 'value');
-        var valuePath = get(this, 'optionValuePath').replace(/^content\.?/, '');
-        var selectedValue = (valuePath ? get(this, 'selection.' + valuePath) : get(this, 'selection'));
-        var selection;
+    _setupKeywords: function() {},
 
-        if (value !== selectedValue) {
-          selection = content ? content.find(function(obj) {
-            return value === (valuePath ? get(obj, valuePath) : obj);
-          }) : null;
+    _yield: function(context, options, morph, blockArguments) {
+      var view = options.data.view;
+      var parentView = this._parentView;
+      var template = property_get.get(this, 'template');
 
-          this.set('selection', selection);
-        }
-      }),
+      if (template) {
+        Ember['default'].assert("A Component must have a parent view in order to yield.", parentView);
+
+        view.appendChild(View['default'], {
+          isVirtual: true,
+          tagName: '',
+          template: template,
+          _blockArguments: blockArguments,
+          _contextView: parentView,
+          _morph: morph,
+          context: property_get.get(parentView, 'context'),
+          controller: property_get.get(parentView, 'controller')
+        });
+      }
+    },
 
-      _setDefaults: function() {
-        var selection = get(this, 'selection');
-        var value = get(this, 'value');
+    /**
+      If the component is currently inserted into the DOM of a parent view, this
+      property will point to the controller of the parent view.
 
-        if (!isNone(selection)) { this.selectionDidChange(); }
-        if (!isNone(value)) { this.valueDidChange(); }
-        if (isNone(selection)) {
-          this._change();
-        }
-      },
+      @property targetObject
+      @type Ember.Controller
+      @default null
+    */
+    targetObject: computed.computed(function(key) {
+      var parentView = this._parentView;
+      return parentView ? property_get.get(parentView, 'controller') : null;
+    }).property('_parentView'),
 
-      _changeSingle: function() {
-        var selectedIndex = this.$()[0].selectedIndex;
-        var content = get(this, 'content');
-        var prompt = get(this, 'prompt');
+    /**
+      Triggers a named action on the controller context where the component is used if
+      this controller has registered for notifications of the action.
 
-        if (!content || !get(content, 'length')) { return; }
-        if (prompt && selectedIndex === 0) { set(this, 'selection', null); return; }
+      For example a component for playing or pausing music may translate click events
+      into action notifications of "play" or "stop" depending on some internal state
+      of the component:
 
-        if (prompt) { selectedIndex -= 1; }
-        set(this, 'selection', content.objectAt(selectedIndex));
-      },
 
-      _changeMultiple: function() {
-        var options = this.$('option:selected');
-        var prompt = get(this, 'prompt');
-        var offset = prompt ? 1 : 0;
-        var content = get(this, 'content');
-        var selection = get(this, 'selection');
-
-        if (!content) { return; }
-        if (options) {
-          var selectedIndexes = options.map(function() {
-            return this.index - offset;
-          }).toArray();
-          var newSelection = content.objectsAt(selectedIndexes);
-
-          if (isArray(selection)) {
-            replace(selection, 0, get(selection, 'length'), newSelection);
+      ```javascript
+      App.PlayButtonComponent = Ember.Component.extend({
+        click: function() {
+          if (this.get('isPlaying')) {
+            this.sendAction('play');
           } else {
-            set(this, 'selection', newSelection);
+            this.sendAction('stop');
           }
         }
-      },
+      });
+      ```
 
-      _selectionDidChangeSingle: function() {
-        var content = get(this, 'content');
-        var selection = get(this, 'selection');
-        var self = this;
-        if (selection && selection.then) {
-          selection.then(function(resolved) {
-            // Ensure that we don't overwrite a new selection
-            if (self.get('selection') === selection) {
-              self._setSelectionIndex(content, resolved);
-            }
-          });
-        } else {
-          this._setSelectionIndex(content, selection);
-        }
-      },
+      When used inside a template these component actions are configured to
+      trigger actions in the outer application context:
 
-      _setSelectionIndex: function(content, selection) {
-        var el = get(this, 'element');
-        if (!el) { return; }
+      ```handlebars
+      {{! application.hbs }}
+      {{play-button play="musicStarted" stop="musicStopped"}}
+      ```
 
-        var selectionIndex = content ? indexOf(content, selection) : -1;
-        var prompt = get(this, 'prompt');
+      When the component receives a browser `click` event it translate this
+      interaction into application-specific semantics ("play" or "stop") and
+      triggers the specified action name on the controller for the template
+      where the component is used:
 
-        if (prompt) { selectionIndex += 1; }
-        if (el) { el.selectedIndex = selectionIndex; }
-      },
 
-      _selectionDidChangeMultiple: function() {
-        var content = get(this, 'content');
-        var selection = get(this, 'selection');
-        var selectedIndexes = content ? indexesOf(content, selection) : [-1];
-        var prompt = get(this, 'prompt');
-        var offset = prompt ? 1 : 0;
-        var options = this.$('option');
-        var adjusted;
-
-        if (options) {
-          options.each(function() {
-            adjusted = this.index > -1 ? this.index - offset : -1;
-            this.selected = indexOf(selectedIndexes, adjusted) > -1;
-          });
+      ```javascript
+      App.ApplicationController = Ember.Controller.extend({
+        actions: {
+          musicStarted: function() {
+            // called when the play button is clicked
+            // and the music started playing
+          },
+          musicStopped: function() {
+            // called when the play button is clicked
+            // and the music stopped playing
+          }
         }
-      },
-
-      init: function() {
-        this._super();
-        this.on("didInsertElement", this, this._setDefaults);
-        this.on("change", this, this._change);
-      }
-    });
+      });
+      ```
 
-    __exports__["default"] = Select;
-    __exports__.Select = Select;
-    __exports__.SelectOption = SelectOption;
-    __exports__.SelectOptgroup = SelectOptgroup;
-  });
-enifed("ember-views/views/simple_bound_view",
-  ["ember-metal/error","ember-metal/run_loop","ember-htmlbars/utils/string","ember-metal/utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    /**
-    @module ember
-    @submodule ember-views
-    */
+      If no action name is passed to `sendAction` a default name of "action"
+      is assumed.
 
-    var EmberError = __dependency1__["default"];
-    var run = __dependency2__["default"];
-    var htmlbarsSafeString = __dependency3__.SafeString;
-    var htmlbarsHtmlSafe = __dependency3__.htmlSafe;
-    var GUID_KEY = __dependency4__.GUID_KEY;
-    var uuid = __dependency4__.uuid;
+      ```javascript
+      App.NextButtonComponent = Ember.Component.extend({
+        click: function() {
+          this.sendAction();
+        }
+      });
+      ```
 
-    function K() { return this; }
+      ```handlebars
+      {{! application.hbs }}
+      {{next-button action="playNextSongInAlbum"}}
+      ```
 
-    var SafeString = htmlbarsSafeString;
-    var htmlSafe = htmlbarsHtmlSafe;
+      ```javascript
+      App.ApplicationController = Ember.Controller.extend({
+        actions: {
+          playNextSongInAlbum: function() {
+            ...
+          }
+        }
+      });
+      ```
 
-    function SimpleBoundView(lazyValue, isEscaped) {
-      this.lazyValue = lazyValue;
-      this.isEscaped = isEscaped;
-      this[GUID_KEY] = uuid();
-      this._lastNormalizedValue = undefined;
-      this.state = 'preRender';
-      this.updateId = null;
-      this._parentView = null;
-      this.buffer = null;
-      this._morph = null;
-    }
+      @method sendAction
+      @param [action] {String} the action to trigger
+      @param [context] {*} a context to send with the action
+    */
+    sendAction: function(action) {
+      var actionName;
+      var contexts = a_slice.call(arguments, 1);
 
-    SimpleBoundView.prototype = {
-      isVirtual: true,
-      isView: true,
-      tagName: '',
+      // Send the default action
+      if (action === undefined) {
+        actionName = property_get.get(this, 'action');
+        Ember['default'].assert("The default action was triggered on the component " + this.toString() +
+                     ", but the action name (" + actionName + ") was not a string.",
+                     isNone['default'](actionName) || typeof actionName === 'string');
+      } else {
+        actionName = property_get.get(this, action);
+        Ember['default'].assert("The " + action + " action was triggered on the component " +
+                     this.toString() + ", but the action name (" + actionName +
+                     ") was not a string.",
+                     isNone['default'](actionName) || typeof actionName === 'string');
+      }
 
-      destroy: function () {
-        if (this.updateId) {
-          run.cancel(this.updateId);
-          this.updateId = null;
-        }
-        if (this._parentView) {
-          this._parentView.removeChild(this);
-        }
-        this.morph = null;
-        this.state = 'destroyed';
-      },
+      // If no action name for that action could be found, just abort.
+      if (actionName === undefined) { return; }
 
-      propertyWillChange: K,
+      this.triggerAction({
+        action: actionName,
+        actionContext: contexts
+      });
+    },
 
-      propertyDidChange: K,
+    send: function(actionName) {
+      var args = [].slice.call(arguments, 1);
+      var target;
+      var hasAction = this._actions && this._actions[actionName];
 
-      normalizedValue: function() {
-        var result = this.lazyValue.value();
+      if (hasAction) {
+        var shouldBubble = this._actions[actionName].apply(this, args) === true;
+        if (!shouldBubble) { return; }
+      }
 
-        if (result === null || result === undefined) {
-          result = "";
-        } else if (!this.isEscaped && !(result instanceof SafeString)) {
-          result = htmlSafe(result);
+      if (target = property_get.get(this, 'target')) {
+        Ember['default'].assert("The `target` for " + this + " (" + target +
+                     ") does not have a `send` method", typeof target.send === 'function');
+        target.send.apply(target, arguments);
+      } else {
+        if (!hasAction) {
+          throw new Error(Ember['default'].inspect(this) + ' had no action handler for: ' + actionName);
         }
+      }
+    }
+  });
 
-        return result;
-      },
+  exports['default'] = Component;
 
-      render: function(buffer) {
-        var value = this.normalizedValue();
-        this._lastNormalizedValue = value;
-        buffer._element = value;
-      },
+});
+enifed('ember-views/views/container_view', ['exports', 'ember-metal/core', 'ember-metal/merge', 'ember-runtime/mixins/mutable_array', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-views/views/view', 'ember-views/views/states', 'ember-metal/error', 'ember-metal/enumerable_utils', 'ember-metal/computed', 'ember-metal/run_loop', 'ember-metal/properties', 'ember-metal/mixin', 'ember-runtime/system/native_array'], function (exports, Ember, merge, MutableArray, property_get, property_set, View, views__states, EmberError, enumerable_utils, computed, run, properties, mixin, native_array) {
 
-      rerender: function() {
-        switch(this.state) {
-          case 'preRender':
-          case 'destroyed':
-            break;
-          case 'inBuffer':
-            throw new EmberError("Something you did tried to replace an {{expression}} before it was inserted into the DOM.");
-          case 'hasElement':
-          case 'inDOM':
-            this.updateId = run.scheduleOnce('render', this, 'update');
-            break;
-        }
-        return this;
-      },
+  'use strict';
 
-      update: function () {
-        this.updateId = null;
-        var value = this.normalizedValue();
-        // doesn't diff SafeString instances
-        if (value !== this._lastNormalizedValue) {
-          this._lastNormalizedValue = value;
-          this._morph.setContent(value);
-        }
-      },
+  function K() { return this; }
 
-      _transitionTo: function(state) {
-        this.state = state;
-      }
-    };
+  /**
+  @module ember
+  @submodule ember-views
+  */
 
-    function appendSimpleBoundView(parentView, morph, stream) {
-      var view = new SimpleBoundView(stream, morph.escaped);
-      view._morph = morph;
+  var states = views__states.cloneStates(views__states.states);
 
-      stream.subscribe(parentView._wrapAsScheduled(function() {
-        run.scheduleOnce('render', view, 'rerender');
-      }));
+  /**
+    A `ContainerView` is an `Ember.View` subclass that implements `Ember.MutableArray`
+    allowing programmatic management of its child views.
 
-      parentView.appendChild(view);
-    }
+    ## Setting Initial Child Views
 
-    __exports__.appendSimpleBoundView = appendSimpleBoundView;__exports__["default"] = SimpleBoundView;
-  });
-enifed("ember-views/views/states",
-  ["ember-metal/platform","ember-metal/merge","ember-views/views/states/default","ember-views/views/states/pre_render","ember-views/views/states/in_buffer","ember-views/views/states/has_element","ember-views/views/states/in_dom","ember-views/views/states/destroying","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
-    "use strict";
-    var create = __dependency1__.create;
-    var merge = __dependency2__["default"];
-    var _default = __dependency3__["default"];
-    var preRender = __dependency4__["default"];
-    var inBuffer = __dependency5__["default"];
-    var hasElement = __dependency6__["default"];
-    var inDOM = __dependency7__["default"];
-    var destroying = __dependency8__["default"];
-
-    function cloneStates(from) {
-      var into = {};
-
-      into._default = {};
-      into.preRender = create(into._default);
-      into.destroying = create(into._default);
-      into.inBuffer = create(into._default);
-      into.hasElement = create(into._default);
-      into.inDOM = create(into.hasElement);
-
-      for (var stateName in from) {
-        if (!from.hasOwnProperty(stateName)) { continue; }
-        merge(into[stateName], from[stateName]);
-      }
-
-      return into;
-    }
-
-    __exports__.cloneStates = cloneStates;var states = {
-      _default: _default,
-      preRender: preRender,
-      inDOM: inDOM,
-      inBuffer: inBuffer,
-      hasElement: hasElement,
-      destroying: destroying
-    };
-    __exports__.states = states;
-  });
-enifed("ember-views/views/states/default",
-  ["ember-metal/error","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var EmberError = __dependency1__["default"];
+    The initial array of child views can be set in one of two ways. You can
+    provide a `childViews` property at creation time that contains instance of
+    `Ember.View`:
 
-    function K() { return this; }
+    ```javascript
+    aContainer = Ember.ContainerView.create({
+      childViews: [Ember.View.create(), Ember.View.create()]
+    });
+    ```
 
-    /**
-    @module ember
-    @submodule ember-views
-    */
-    __exports__["default"] = {
-      // appendChild is only legal while rendering the buffer.
-      appendChild: function() {
-        throw new EmberError("You can't use appendChild outside of the rendering process");
-      },
+    You can also provide a list of property names whose values are instances of
+    `Ember.View`:
 
-      $: function() {
-        return undefined;
-      },
+    ```javascript
+    aContainer = Ember.ContainerView.create({
+      childViews: ['aView', 'bView', 'cView'],
+      aView: Ember.View.create(),
+      bView: Ember.View.create(),
+      cView: Ember.View.create()
+    });
+    ```
 
-      getElement: function() {
-        return null;
-      },
+    The two strategies can be combined:
 
-      // Handle events from `Ember.EventDispatcher`
-      handleEvent: function() {
-        return true; // continue event propagation
-      },
+    ```javascript
+    aContainer = Ember.ContainerView.create({
+      childViews: ['aView', Ember.View.create()],
+      aView: Ember.View.create()
+    });
+    ```
 
-      destroyElement: function(view) {
-        if (view._renderer)
-          view._renderer.remove(view, false);
-        return view;
-      },
+    Each child view's rendering will be inserted into the container's rendered
+    HTML in the same order as its position in the `childViews` property.
 
-      rerender: K,
-      invokeObserver: K
-    };
-  });
-enifed("ember-views/views/states/destroying",
-  ["ember-metal/merge","ember-metal/platform","ember-runtime/system/string","ember-views/views/states/default","ember-metal/error","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
-    var merge = __dependency1__["default"];
-    var create = __dependency2__.create;
-    var fmt = __dependency3__.fmt;
-    var _default = __dependency4__["default"];
-    var EmberError = __dependency5__["default"];
-    /**
-    @module ember
-    @submodule ember-views
-    */
+    ## Adding and Removing Child Views
 
-    var destroyingError = "You can't call %@ on a view being destroyed";
+    The container view implements `Ember.MutableArray` allowing programmatic management of its child views.
 
-    var destroying = create(_default);
+    To remove a view, pass that view into a `removeObject` call on the container view.
 
-    merge(destroying, {
-      appendChild: function() {
-        throw new EmberError(fmt(destroyingError, ['appendChild']));
-      },
-      rerender: function() {
-        throw new EmberError(fmt(destroyingError, ['rerender']));
-      },
-      destroyElement: function() {
-        throw new EmberError(fmt(destroyingError, ['destroyElement']));
-      }
-    });
+    Given an empty `<body>` the following code
 
-    __exports__["default"] = destroying;
-  });
-enifed("ember-views/views/states/has_element",
-  ["ember-views/views/states/default","ember-metal/run_loop","ember-metal/merge","ember-metal/platform","ember-views/system/jquery","ember-metal/error","ember-metal/property_get","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
-    "use strict";
-    var _default = __dependency1__["default"];
-    var run = __dependency2__["default"];
-    var merge = __dependency3__["default"];
-    var create = __dependency4__.create;
-    var jQuery = __dependency5__["default"];
-    var EmberError = __dependency6__["default"];
+    ```javascript
+    aContainer = Ember.ContainerView.create({
+      classNames: ['the-container'],
+      childViews: ['aView', 'bView'],
+      aView: Ember.View.create({
+        template: Ember.Handlebars.compile("A")
+      }),
+      bView: Ember.View.create({
+        template: Ember.Handlebars.compile("B")
+      })
+    });
 
-    /**
-    @module ember
-    @submodule ember-views
-    */
+    aContainer.appendTo('body');
+    ```
 
-    var get = __dependency7__.get;
+    Results in the HTML
 
-    var hasElement = create(_default);
+    ```html
+    <div class="ember-view the-container">
+      <div class="ember-view">A</div>
+      <div class="ember-view">B</div>
+    </div>
+    ```
 
-    merge(hasElement, {
-      $: function(view, sel) {
-        var elem = view.get('concreteView').element;
-        return sel ? jQuery(sel, elem) : jQuery(elem);
-      },
+    Removing a view
 
-      getElement: function(view) {
-        var parent = get(view, 'parentView');
-        if (parent) { parent = get(parent, 'element'); }
-        if (parent) { return view.findElementInParentElement(parent); }
-        return jQuery("#" + get(view, 'elementId'))[0];
-      },
+    ```javascript
+    aContainer.toArray();  // [aContainer.aView, aContainer.bView]
+    aContainer.removeObject(aContainer.get('bView'));
+    aContainer.toArray();  // [aContainer.aView]
+    ```
 
-      // once the view has been inserted into the DOM, rerendering is
-      // deferred to allow bindings to synchronize.
-      rerender: function(view) {
-        if (view._root._morph && !view._elementInserted) {
-          throw new EmberError("Something you did caused a view to re-render after it rendered but before it was inserted into the DOM.");
-        }
-        // TODO: should be scheduled with renderer
-        run.scheduleOnce('render', function () {
-          if (view.isDestroying) return;
-          view._renderer.renderTree(view, view._parentView);
-        });
-      },
+    Will result in the following HTML
 
-      // once the view is already in the DOM, destroying it removes it
-      // from the DOM, nukes its element, and puts it back into the
-      // preRender state if inDOM.
+    ```html
+    <div class="ember-view the-container">
+      <div class="ember-view">A</div>
+    </div>
+    ```
 
-      destroyElement: function(view) {
-        view._renderer.remove(view, false);
-        return view;
-      },
+    Similarly, adding a child view is accomplished by adding `Ember.View` instances to the
+    container view.
 
-      // Handle events from `Ember.EventDispatcher`
-      handleEvent: function(view, eventName, evt) {
-        if (view.has(eventName)) {
-          // Handler should be able to re-dispatch events, so we don't
-          // preventDefault or stopPropagation.
-          return view.trigger(eventName, evt);
-        } else {
-          return true; // continue event propagation
-        }
-      },
+    Given an empty `<body>` the following code
 
-      invokeObserver: function(target, observer) {
-        observer.call(target);
-      }
+    ```javascript
+    aContainer = Ember.ContainerView.create({
+      classNames: ['the-container'],
+      childViews: ['aView', 'bView'],
+      aView: Ember.View.create({
+        template: Ember.Handlebars.compile("A")
+      }),
+      bView: Ember.View.create({
+        template: Ember.Handlebars.compile("B")
+      })
     });
 
-    __exports__["default"] = hasElement;
-  });
-enifed("ember-views/views/states/in_buffer",
-  ["ember-views/views/states/default","ember-metal/error","ember-views/system/jquery","ember-metal/platform","ember-metal/merge","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
-    var _default = __dependency1__["default"];
-    var EmberError = __dependency2__["default"];
-
-    var jQuery = __dependency3__["default"];
-    var create = __dependency4__.create;
-    var merge = __dependency5__["default"];
+    aContainer.appendTo('body');
+    ```
 
-    /**
-    @module ember
-    @submodule ember-views
-    */
+    Results in the HTML
 
-    var inBuffer = create(_default);
+    ```html
+    <div class="ember-view the-container">
+      <div class="ember-view">A</div>
+      <div class="ember-view">B</div>
+    </div>
+    ```
 
-    merge(inBuffer, {
-      $: function(view, sel) {
-        // if we don't have an element yet, someone calling this.$() is
-        // trying to update an element that isn't in the DOM. Instead,
-        // rerender the view to allow the render method to reflect the
-        // changes.
-        view.rerender();
-        return jQuery();
-      },
+    Adding a view
 
-      // when a view is rendered in a buffer, rerendering it simply
-      // replaces the existing buffer with a new one
-      rerender: function(view) {
-        throw new EmberError("Something you did caused a view to re-render after it rendered but before it was inserted into the DOM.");
-      },
+    ```javascript
+    AnotherViewClass = Ember.View.extend({
+      template: Ember.Handlebars.compile("Another view")
+    });
 
-      // when a view is rendered in a buffer, appending a child
-      // view will render that view and append the resulting
-      // buffer into its buffer.
-      appendChild: function(view, childView, options) {
-        var buffer = view.buffer;
-        var _childViews = view._childViews;
+    aContainer.toArray();  // [aContainer.aView, aContainer.bView]
+    aContainer.pushObject(AnotherViewClass.create());
+    aContainer.toArray(); // [aContainer.aView, aContainer.bView, <AnotherViewClass instance>]
+    ```
 
-        childView = view.createChildView(childView, options);
-        if (!_childViews.length) { _childViews = view._childViews = _childViews.slice(); }
-        _childViews.push(childView);
+    Will result in the following HTML
 
-        if (!childView._morph) {
-          buffer.pushChildView(childView);
-        }
+    ```html
+    <div class="ember-view the-container">
+      <div class="ember-view">A</div>
+      <div class="ember-view">B</div>
+      <div class="ember-view">Another view</div>
+    </div>
+    ```
 
-        view.propertyDidChange('childViews');
+    ## Templates and Layout
 
-        return childView;
-      },
+    A `template`, `templateName`, `defaultTemplate`, `layout`, `layoutName` or
+    `defaultLayout` property on a container view will not result in the template
+    or layout being rendered. The HTML contents of a `Ember.ContainerView`'s DOM
+    representation will only be the rendered HTML of its child views.
 
-      invokeObserver: function(target, observer) {
-        observer.call(target);
-      }
-    });
+    @class ContainerView
+    @namespace Ember
+    @extends Ember.View
+  */
+  var ContainerView = View['default'].extend(MutableArray['default'], {
+    _states: states,
+
+    willWatchProperty: function(prop) {
+      Ember['default'].deprecate(
+        "ContainerViews should not be observed as arrays. This behavior will change in future implementations of ContainerView.",
+        !prop.match(/\[]/) && prop.indexOf('@') !== 0
+      );
+    },
 
-    __exports__["default"] = inBuffer;
-  });
-enifed("ember-views/views/states/in_dom",
-  ["ember-metal/core","ember-metal/platform","ember-metal/merge","ember-metal/error","ember-metal/observer","ember-views/views/states/has_element","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
-    "use strict";
-    var Ember = __dependency1__["default"];
-    // Ember.assert
-    var create = __dependency2__.create;
-    var merge = __dependency3__["default"];
-    var EmberError = __dependency4__["default"];
-    var addBeforeObserver = __dependency5__.addBeforeObserver;
+    init: function() {
+      this._super.apply(this, arguments);
 
-    var hasElement = __dependency6__["default"];
-    /**
-    @module ember
-    @submodule ember-views
-    */
+      var childViews = property_get.get(this, 'childViews');
+      Ember['default'].deprecate('Setting `childViews` on a Container is deprecated.', Ember['default'].isEmpty(childViews));
 
-    var inDOM = create(hasElement);
+      // redefine view's childViews property that was obliterated
+      properties.defineProperty(this, 'childViews', View['default'].childViewsProperty);
 
-    var View;
+      var _childViews = this._childViews;
 
-    merge(inDOM, {
-      enter: function(view) {
-        if (!View) { View = requireModule('ember-views/views/view')["default"]; } // ES6TODO: this sucks. Have to avoid cycles...
+      enumerable_utils.forEach(childViews, function(viewName, idx) {
+        var view;
 
-        // Register the view for event handling. This hash is used by
-        // Ember.EventDispatcher to dispatch incoming events.
-        if (!view.isVirtual) {
-          Ember.assert("Attempted to register a view with an id already in use: "+view.elementId, !View.views[view.elementId]);
-          View.views[view.elementId] = view;
+        if ('string' === typeof viewName) {
+          view = property_get.get(this, viewName);
+          view = this.createChildView(view);
+          property_set.set(this, viewName, view);
+        } else {
+          view = this.createChildView(viewName);
         }
 
-        Ember.runInDebug(function() {
-          addBeforeObserver(view, 'elementId', function() {
-            throw new EmberError("Changing a view's elementId after creation is not allowed");
-          });
-        });
-      },
-
-      exit: function(view) {
-        if (!View) { View = requireModule('ember-views/views/view')["default"]; } // ES6TODO: this sucks. Have to avoid cycles...
+        _childViews[idx] = view;
+      }, this);
 
-        if (!this.isVirtual) delete View.views[view.elementId];
+      var currentView = property_get.get(this, 'currentView');
+      if (currentView) {
+        if (!_childViews.length) { _childViews = this._childViews = this._childViews.slice(); }
+        _childViews.push(this.createChildView(currentView));
       }
-    });
+    },
 
-    __exports__["default"] = inDOM;
-  });
-enifed("ember-views/views/states/pre_render",
-  ["ember-views/views/states/default","ember-metal/platform","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var _default = __dependency1__["default"];
-    var create = __dependency2__.create;
+    replace: function(idx, removedCount, addedViews) {
+      var addedCount = addedViews ? property_get.get(addedViews, 'length') : 0;
+      var self = this;
+      Ember['default'].assert("You can't add a child to a container - the child is already a child of another view", native_array.A(addedViews).every(function(item) { return !item._parentView || item._parentView === self; }));
 
-    /**
-    @module ember
-    @submodule ember-views
-    */
-    var preRender = create(_default);
+      this.arrayContentWillChange(idx, removedCount, addedCount);
+      this.childViewsWillChange(this._childViews, idx, removedCount);
 
-    __exports__["default"] = preRender;
-  });
-enifed("ember-views/views/text_area",
-  ["ember-metal/property_get","ember-views/views/component","ember-views/mixins/text_support","ember-metal/mixin","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
+      if (addedCount === 0) {
+        this._childViews.splice(idx, removedCount);
+      } else {
+        var args = [idx, removedCount].concat(addedViews);
+        if (addedViews.length && !this._childViews.length) { this._childViews = this._childViews.slice(); }
+        this._childViews.splice.apply(this._childViews, args);
+      }
 
-    /**
-    @module ember
-    @submodule ember-views
-    */
-    var get = __dependency1__.get;
-    var Component = __dependency2__["default"];
-    var TextSupport = __dependency3__["default"];
-    var observer = __dependency4__.observer;
+      this.arrayContentDidChange(idx, removedCount, addedCount);
+      this.childViewsDidChange(this._childViews, idx, removedCount, addedCount);
 
-    /**
-      The internal class used to create textarea element when the `{{textarea}}`
-      helper is used.
+      return this;
+    },
 
-      See [handlebars.helpers.textarea](/api/classes/Ember.Handlebars.helpers.html#method_textarea)  for usage details.
+    objectAt: function(idx) {
+      return this._childViews[idx];
+    },
 
-      ## Layout and LayoutName properties
+    length: computed.computed(function () {
+      return this._childViews.length;
+    })["volatile"](),
 
-      Because HTML `textarea` elements do not contain inner HTML the `layout` and
-      `layoutName` properties will not be applied. See [Ember.View](/api/classes/Ember.View.html)'s
-      layout section for more information.
+    /**
+      Instructs each child view to render to the passed render buffer.
 
-      @class TextArea
-      @namespace Ember
-      @extends Ember.Component
-      @uses Ember.TextSupport
+      @private
+      @method render
+      @param {Ember.RenderBuffer} buffer the buffer to render to
     */
-    __exports__["default"] = Component.extend(TextSupport, {
-      instrumentDisplay: '{{textarea}}',
+    render: function(buffer) {
+      var element = buffer.element();
+      var dom = buffer.dom;
 
-      classNames: ['ember-text-area'],
+      if (this.tagName === '') {
+        element = dom.createDocumentFragment();
+        buffer._element = element;
+        this._childViewsMorph = dom.appendMorph(element, this._morph.contextualElement);
+      } else {
+        this._childViewsMorph = dom.appendMorph(element);
+      }
 
-      tagName: "textarea",
-      attributeBindings: [
-        'rows',
-        'cols',
-        'name',
-        'selectionEnd',
-        'selectionStart',
-        'wrap',
-        'lang',
-        'dir'
-      ],
-      rows: null,
-      cols: null,
+      return element;
+    },
 
-      _updateElementValue: observer('value', function() {
-        // We do this check so cursor position doesn't get affected in IE
-        var value = get(this, 'value');
-        var $el = this.$();
-        if ($el && value !== $el.val()) {
-          $el.val(value);
-        }
-      }),
+    instrumentName: 'container',
 
-      init: function() {
-        this._super();
-        this.on("didInsertElement", this, this._updateElementValue);
-      }
-    });
-  });
-enifed("ember-views/views/text_field",
-  ["ember-views/views/component","ember-views/mixins/text_support","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
     /**
-    @module ember
-    @submodule ember-views
-    */
-    var Component = __dependency1__["default"];
-    var TextSupport = __dependency2__["default"];
-
-    /**
-
-      The internal class used to create text inputs when the `{{input}}`
-      helper is used with `type` of `text`.
-
-      See [Handlebars.helpers.input](/api/classes/Ember.Handlebars.helpers.html#method_input)  for usage details.
-
-      ## Layout and LayoutName properties
-
-      Because HTML `input` elements are self closing `layout` and `layoutName`
-      properties will not be applied. See [Ember.View](/api/classes/Ember.View.html)'s
-      layout section for more information.
-
-      @class TextField
-      @namespace Ember
-      @extends Ember.Component
-      @uses Ember.TextSupport
-    */
-    __exports__["default"] = Component.extend(TextSupport, {
-      instrumentDisplay: '{{input type="text"}}',
-
-      classNames: ['ember-text-field'],
-      tagName: "input",
-      attributeBindings: [
-        'accept',
-        'autocomplete',
-        'autosave',
-        'dir',
-        'formaction',
-        'formenctype',
-        'formmethod',
-        'formnovalidate',
-        'formtarget',
-        'height',
-        'inputmode',
-        'lang',
-        'list',
-        'max',
-        'min',
-        'multiple',
-        'name',
-        'pattern',
-        'size',
-        'step',
-        'type',
-        'value',
-        'width'
-      ],
+      When a child view is removed, destroy its element so that
+      it is removed from the DOM.
 
-      defaultLayout: null,
+      The array observer that triggers this action is set up in the
+      `renderToBuffer` method.
 
-      /**
-        The `value` attribute of the input element. As the user inputs text, this
-        property is updated live.
+      @private
+      @method childViewsWillChange
+      @param {Ember.Array} views the child views array before mutation
+      @param {Number} start the start position of the mutation
+      @param {Number} removed the number of child views removed
+    **/
+    childViewsWillChange: function(views, start, removed) {
+      this.propertyWillChange('childViews');
 
-        @property value
-        @type String
-        @default ""
-      */
-      value: "",
+      if (removed > 0) {
+        var changedViews = views.slice(start, start+removed);
+        // transition to preRender before clearing parentView
+        this.currentState.childViewsWillChange(this, views, start, removed);
+        this.initializeViews(changedViews, null, null);
+      }
+    },
 
-      /**
-        The `type` attribute of the input element.
+    removeChild: function(child) {
+      this.removeObject(child);
+      return this;
+    },
 
-        @property type
-        @type String
-        @default "text"
-      */
-      type: "text",
+    /**
+      When a child view is added, make sure the DOM gets updated appropriately.
 
-      /**
-        The `size` of the text field in characters.
+      If the view has already rendered an element, we tell the child view to
+      create an element and insert it into the DOM. If the enclosing container
+      view has already written to a buffer, but not yet converted that buffer
+      into an element, we insert the string representation of the child into the
+      appropriate place in the buffer.
 
-        @property size
-        @type String
-        @default null
-      */
-      size: null,
+      @private
+      @method childViewsDidChange
+      @param {Ember.Array} views the array of child views after the mutation has occurred
+      @param {Number} start the start position of the mutation
+      @param {Number} removed the number of child views removed
+      @param {Number} added the number of child views added
+    */
+    childViewsDidChange: function(views, start, removed, added) {
+      if (added > 0) {
+        var changedViews = views.slice(start, start+added);
+        this.initializeViews(changedViews, this);
+        this.currentState.childViewsDidChange(this, views, start, added);
+      }
+      this.propertyDidChange('childViews');
+    },
 
-      /**
-        The `pattern` attribute of input element.
+    initializeViews: function(views, parentView) {
+      enumerable_utils.forEach(views, function(view) {
+        property_set.set(view, '_parentView', parentView);
 
-        @property pattern
-        @type String
-        @default null
-      */
-      pattern: null,
+        if (!view.container && parentView) {
+          property_set.set(view, 'container', parentView.container);
+        }
+      });
+    },
 
-      /**
-        The `min` attribute of input element used with `type="number"` or `type="range"`.
+    currentView: null,
 
-        @property min
-        @type String
-        @default null
-        @since 1.4.0
-      */
-      min: null,
+    _currentViewWillChange: mixin.beforeObserver('currentView', function() {
+      var currentView = property_get.get(this, 'currentView');
+      if (currentView) {
+        currentView.destroy();
+      }
+    }),
 
-      /**
-        The `max` attribute of input element used with `type="number"` or `type="range"`.
+    _currentViewDidChange: mixin.observer('currentView', function() {
+      var currentView = property_get.get(this, 'currentView');
+      if (currentView) {
+        Ember['default'].assert("You tried to set a current view that already has a parent. Make sure you don't have multiple outlets in the same view.", !currentView._parentView);
+        this.pushObject(currentView);
+      }
+    }),
 
-        @property max
-        @type String
-        @default null
-        @since 1.4.0
-      */
-      max: null
-    });
-  });
-enifed("ember-views/views/view",
-  ["ember-metal/core","ember-metal/platform","ember-runtime/mixins/evented","ember-runtime/system/object","ember-metal/error","ember-metal/property_get","ember-metal/property_set","ember-metal/set_properties","ember-metal/run_loop","ember-metal/observer","ember-metal/properties","ember-metal/utils","ember-metal/computed","ember-metal/mixin","ember-views/streams/key_stream","ember-metal/streams/stream_binding","ember-views/streams/context_stream","ember-metal/is_none","ember-metal/deprecate_property","ember-runtime/system/native_array","ember-views/streams/class_name_binding","ember-metal/enumerable_utils","ember-metal/property_events","ember-views/system/jquery","ember-views/system/ext","ember-views/views/core_view","ember-metal/streams/utils","ember-views/system/sanitize_attribute_value","morph/dom-helper/prop","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __dependency21__, __dependency22__, __dependency23__, __dependency24__, __dependency25__, __dependency26__, __dependency27__, __dependency28__, __dependency29__, __exports__) {
-    "use strict";
-    // Ember.assert, Ember.deprecate, Ember.warn, Ember.TEMPLATES,
-    // jQuery, Ember.lookup,
-    // Ember.ContainerView circular dependency
-    // Ember.ENV
-    var Ember = __dependency1__["default"];
-    var create = __dependency2__.create;
-
-    var Evented = __dependency3__["default"];
-    var EmberObject = __dependency4__["default"];
-    var EmberError = __dependency5__["default"];
-    var get = __dependency6__.get;
-    var set = __dependency7__.set;
-    var setProperties = __dependency8__["default"];
-    var run = __dependency9__["default"];
-    var addObserver = __dependency10__.addObserver;
-    var removeObserver = __dependency10__.removeObserver;
-    var defineProperty = __dependency11__.defineProperty;
-    var guidFor = __dependency12__.guidFor;
-    var computed = __dependency13__.computed;
-    var observer = __dependency14__.observer;
-    var KeyStream = __dependency15__["default"];
-    var StreamBinding = __dependency16__["default"];
-    var ContextStream = __dependency17__["default"];
-
-    var typeOf = __dependency12__.typeOf;
-    var isNone = __dependency18__["default"];
-    var Mixin = __dependency14__.Mixin;
-    var deprecateProperty = __dependency19__.deprecateProperty;
-    var emberA = __dependency20__.A;
-
-    var streamifyClassNameBinding = __dependency21__.streamifyClassNameBinding;
-
-    // ES6TODO: functions on EnumerableUtils should get their own export
-    var forEach = __dependency22__.forEach;
-    var addObject = __dependency22__.addObject;
-    var removeObject = __dependency22__.removeObject;
-
-    var beforeObserver = __dependency14__.beforeObserver;
-
-    var propertyWillChange = __dependency23__.propertyWillChange;
-    var propertyDidChange = __dependency23__.propertyDidChange;
-
-    var jQuery = __dependency24__["default"];
-     // for the side effect of extending Ember.run.queues
-
-    var CoreView = __dependency26__["default"];
-    var subscribe = __dependency27__.subscribe;
-    var read = __dependency27__.read;
-    var isStream = __dependency27__.isStream;
-    var sanitizeAttributeValue = __dependency28__["default"];
-    var normalizeProperty = __dependency29__.normalizeProperty;
-
-    function K() { return this; }
-
-    // Circular dep
-    var _htmlbarsDefaultEnv;
-    function buildHTMLBarsDefaultEnv(){
-      if (!_htmlbarsDefaultEnv) {
-        _htmlbarsDefaultEnv = eriuqer('ember-htmlbars').defaultEnv;
-      }
-      return create(_htmlbarsDefaultEnv);
+    _ensureChildrenAreInDOM: function () {
+      this.currentState.ensureChildrenAreInDOM(this);
     }
+  });
 
-    /**
-    @module ember
-    @submodule ember-views
-    */
-    var childViewsProperty = computed(function() {
-      var childViews = this._childViews;
-      var ret = emberA();
-
-      forEach(childViews, function(view) {
-        var currentChildViews;
-        if (view.isVirtual) {
-          if (currentChildViews = get(view, 'childViews')) {
-            ret.pushObjects(currentChildViews);
-          }
-        } else {
-          ret.push(view);
-        }
-      });
-
-      ret.replace = function (idx, removedCount, addedViews) {
-        throw new EmberError("childViews is immutable");
-      };
-
-      return ret;
-    });
+  merge['default'](states._default, {
+    childViewsWillChange: K,
+    childViewsDidChange: K,
+    ensureChildrenAreInDOM: K
+  });
 
-    Ember.warn("The VIEW_PRESERVES_CONTEXT flag has been removed and the functionality can no longer be disabled.", Ember.ENV.VIEW_PRESERVES_CONTEXT !== false);
+  merge['default'](states.inBuffer, {
+    childViewsDidChange: function(parentView, views, start, added) {
+      throw new EmberError['default']('You cannot modify child views while in the inBuffer state');
+    }
+  });
 
-    /**
-      Global hash of shared templates. This will automatically be populated
-      by the build tools so that you can store your Handlebars templates in
-      separate files that get loaded into JavaScript at buildtime.
+  merge['default'](states.hasElement, {
+    childViewsWillChange: function(view, views, start, removed) {
+      for (var i=start; i<start+removed; i++) {
+        var _view = views[i];
+        _view._unsubscribeFromStreamBindings();
+        _view.remove();
+      }
+    },
 
-      @property TEMPLATES
-      @for Ember
-      @type Hash
-    */
-    Ember.TEMPLATES = {};
+    childViewsDidChange: function(view, views, start, added) {
+      run['default'].scheduleOnce('render', view, '_ensureChildrenAreInDOM');
+    },
 
-    var EMPTY_ARRAY = [];
+    ensureChildrenAreInDOM: function(view) {
+      var childViews = view._childViews;
+      var renderer = view._renderer;
 
-    /**
-      `Ember.View` is the class in Ember responsible for encapsulating templates of
-      HTML content, combining templates with data to render as sections of a page's
-      DOM, and registering and responding to user-initiated events.
+      var refMorph = null;
+      for (var i = childViews.length-1; i >= 0; i--) {
+        var childView = childViews[i];
+        if (!childView._elementCreated) {
+          renderer.renderTree(childView, view, refMorph);
+        }
+        refMorph = childView._morph;
+      }
+    }
+  });
 
-      ## HTML Tag
+  exports['default'] = ContainerView;
 
-      The default HTML tag name used for a view's DOM representation is `div`. This
-      can be customized by setting the `tagName` property. The following view
-      class:
+});
+enifed('ember-views/views/core_view', ['exports', 'ember-views/system/renderer', 'dom-helper', 'ember-views/views/states', 'ember-runtime/system/object', 'ember-runtime/mixins/evented', 'ember-runtime/mixins/action_handler', 'ember-metal/property_get', 'ember-metal/computed', 'ember-metal/utils'], function (exports, Renderer, DOMHelper, states, EmberObject, Evented, ActionHandler, property_get, computed, utils) {
 
-      ```javascript
-      ParagraphView = Ember.View.extend({
-        tagName: 'em'
-      });
-      ```
+  'use strict';
 
-      Would result in instances with the following HTML:
+  function K() { return this; }
 
-      ```html
-      <em id="ember1" class="ember-view"></em>
-      ```
+  // Normally, the renderer is injected by the container when the view is looked
+  // up. However, if someone creates a view without looking it up via the
+  // container (e.g. `Ember.View.create().append()`) then we create a fallback
+  // DOM renderer that is shared. In general, this path should be avoided since
+  // views created this way cannot run in a node environment.
+  var renderer;
 
-      ## HTML `class` Attribute
+  /**
+    `Ember.CoreView` is an abstract class that exists to give view-like behavior
+    to both Ember's main view class `Ember.View` and other classes that don't need
+    the fully functionaltiy of `Ember.View`.
 
-      The HTML `class` attribute of a view's tag can be set by providing a
-      `classNames` property that is set to an array of strings:
+    Unless you have specific needs for `CoreView`, you will use `Ember.View`
+    in your applications.
 
-      ```javascript
-      MyView = Ember.View.extend({
-        classNames: ['my-class', 'my-other-class']
-      });
-      ```
+    @class CoreView
+    @namespace Ember
+    @extends Ember.Object
+    @uses Ember.Evented
+    @uses Ember.ActionHandler
+  */
+  var CoreView = EmberObject['default'].extend(Evented['default'], ActionHandler['default'], {
+    isView: true,
+    isVirtual: false,
 
-      Will result in view instances with an HTML representation of:
+    _states: states.cloneStates(states.states),
 
-      ```html
-      <div id="ember1" class="ember-view my-class my-other-class"></div>
-      ```
+    init: function() {
+      this._super.apply(this, arguments);
+      this._state = 'preRender';
+      this.currentState = this._states.preRender;
+      this._isVisible = property_get.get(this, 'isVisible');
 
-      `class` attribute values can also be set by providing a `classNameBindings`
-      property set to an array of properties names for the view. The return value
-      of these properties will be added as part of the value for the view's `class`
-      attribute. These properties can be computed properties:
+      // Fallback for legacy cases where the view was created directly
+      // via `create()` instead of going through the container.
+      if (!this.renderer) {
+        renderer = renderer || new Renderer['default'](new DOMHelper['default']());
+        this.renderer = renderer;
+      }
+    },
 
-      ```javascript
-      MyView = Ember.View.extend({
-        classNameBindings: ['propertyA', 'propertyB'],
-        propertyA: 'from-a',
-        propertyB: function() {
-          if (someLogic) { return 'from-b'; }
-        }.property()
-      });
-      ```
+    /**
+      If the view is currently inserted into the DOM of a parent view, this
+      property will point to the parent of the view.
 
-      Will result in view instances with an HTML representation of:
+      @property parentView
+      @type Ember.View
+      @default null
+    */
+    parentView: computed.computed('_parentView', function() {
+      var parent = this._parentView;
 
-      ```html
-      <div id="ember1" class="ember-view from-a from-b"></div>
-      ```
+      if (parent && parent.isVirtual) {
+        return property_get.get(parent, 'parentView');
+      } else {
+        return parent;
+      }
+    }),
 
-      If the value of a class name binding returns a boolean the property name
-      itself will be used as the class name if the property is true. The class name
-      will not be added if the value is `false` or `undefined`.
+    _state: null,
 
-      ```javascript
-      MyView = Ember.View.extend({
-        classNameBindings: ['hovered'],
-        hovered: true
-      });
-      ```
+    _parentView: null,
 
-      Will result in view instances with an HTML representation of:
+    // return the current view, not including virtual views
+    concreteView: computed.computed('parentView', function() {
+      if (!this.isVirtual) {
+        return this;
+      } else {
+        return property_get.get(this, 'parentView.concreteView');
+      }
+    }),
 
-      ```html
-      <div id="ember1" class="ember-view hovered"></div>
-      ```
+    instrumentName: 'core_view',
 
-      When using boolean class name bindings you can supply a string value other
-      than the property name for use as the `class` HTML attribute by appending the
-      preferred value after a ":" character when defining the binding:
+    instrumentDetails: function(hash) {
+      hash.object = this.toString();
+      hash.containerKey = this._debugContainerKey;
+      hash.view = this;
+    },
 
-      ```javascript
-      MyView = Ember.View.extend({
-        classNameBindings: ['awesome:so-very-cool'],
-        awesome: true
-      });
-      ```
+    /**
+      Override the default event firing from `Ember.Evented` to
+      also call methods with the given name.
 
-      Will result in view instances with an HTML representation of:
+      @method trigger
+      @param name {String}
+      @private
+    */
+    trigger: function() {
+      this._super.apply(this, arguments);
+      var name = arguments[0];
+      var method = this[name];
+      if (method) {
+        var length = arguments.length;
+        var args = new Array(length - 1);
+        for (var i = 1; i < length; i++) {
+          args[i - 1] = arguments[i];
+        }
+        return method.apply(this, args);
+      }
+    },
 
-      ```html
-      <div id="ember1" class="ember-view so-very-cool"></div>
-      ```
+    has: function(name) {
+      return utils.typeOf(this[name]) === 'function' || this._super(name);
+    },
 
-      Boolean value class name bindings whose property names are in a
-      camelCase-style format will be converted to a dasherized format:
+    destroy: function() {
+      var parent = this._parentView;
 
-      ```javascript
-      MyView = Ember.View.extend({
-        classNameBindings: ['isUrgent'],
-        isUrgent: true
-      });
-      ```
+      if (!this._super.apply(this, arguments)) { return; }
 
-      Will result in view instances with an HTML representation of:
 
-      ```html
-      <div id="ember1" class="ember-view is-urgent"></div>
-      ```
+      // destroy the element -- this will avoid each child view destroying
+      // the element over and over again...
+      if (!this.removedFromDOM && this._renderer) {
+        this._renderer.remove(this, true);
+      }
 
-      Class name bindings can also refer to object values that are found by
-      traversing a path relative to the view itself:
+      // remove from parent if found. Don't call removeFromParent,
+      // as removeFromParent will try to remove the element from
+      // the DOM again.
+      if (parent) { parent.removeChild(this); }
 
-      ```javascript
-      MyView = Ember.View.extend({
-        classNameBindings: ['messages.empty']
-        messages: Ember.Object.create({
-          empty: true
-        })
-      });
-      ```
+      this._transitionTo('destroying', false);
 
-      Will result in view instances with an HTML representation of:
+      return this;
+    },
 
-      ```html
-      <div id="ember1" class="ember-view empty"></div>
-      ```
+    clearRenderedChildren: K,
+    _transitionTo: K,
+    destroyElement: K
+  });
 
-      If you want to add a class name for a property which evaluates to true and
-      and a different class name if it evaluates to false, you can pass a binding
-      like this:
+  CoreView.reopenClass({
+    isViewClass: true
+  });
 
-      ```javascript
-      // Applies 'enabled' class when isEnabled is true and 'disabled' when isEnabled is false
-      Ember.View.extend({
-        classNameBindings: ['isEnabled:enabled:disabled']
-        isEnabled: true
-      });
-      ```
+  exports['default'] = CoreView;
 
-      Will result in view instances with an HTML representation of:
+});
+enifed('ember-views/views/each', ['exports', 'ember-metal/core', 'ember-runtime/system/string', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-views/views/collection_view', 'ember-metal/binding', 'ember-runtime/mixins/controller', 'ember-runtime/controllers/array_controller', 'ember-runtime/mixins/array', 'ember-metal/observer', 'ember-views/views/metamorph_view'], function (exports, Ember, string, property_get, property_set, CollectionView, ember_metal__binding, ControllerMixin, ArrayController, EmberArray, observer, metamorph_view) {
 
-      ```html
-      <div id="ember1" class="ember-view enabled"></div>
-      ```
+  'use strict';
 
-      When isEnabled is `false`, the resulting HTML reprensentation looks like
-      this:
+  exports['default'] = CollectionView['default'].extend(metamorph_view._Metamorph, {
 
-      ```html
-      <div id="ember1" class="ember-view disabled"></div>
-      ```
+    init: function() {
+      var itemController = property_get.get(this, 'itemController');
+      var binding;
 
-      This syntax offers the convenience to add a class if a property is `false`:
+      if (itemController) {
+        var controller = property_get.get(this, 'controller.container').lookupFactory('controller:array').create({
+          _isVirtual: true,
+          parentController: property_get.get(this, 'controller'),
+          itemController: itemController,
+          target: property_get.get(this, 'controller'),
+          _eachView: this
+        });
 
-      ```javascript
-      // Applies no class when isEnabled is true and class 'disabled' when isEnabled is false
-      Ember.View.extend({
-        classNameBindings: ['isEnabled::disabled']
-        isEnabled: true
-      });
-      ```
+        this.disableContentObservers(function() {
+          property_set.set(this, 'content', controller);
+          binding = new ember_metal__binding.Binding('content', '_eachView.dataSource').oneWay();
+          binding.connect(controller);
+        });
 
-      Will result in view instances with an HTML representation of:
+        this._arrayController = controller;
+      } else {
+        this.disableContentObservers(function() {
+          binding = new ember_metal__binding.Binding('content', 'dataSource').oneWay();
+          binding.connect(this);
+        });
+      }
 
-      ```html
-      <div id="ember1" class="ember-view"></div>
-      ```
+      return this._super.apply(this, arguments);
+    },
 
-      When the `isEnabled` property on the view is set to `false`, it will result
-      in view instances with an HTML representation of:
+    _assertArrayLike: function(content) {
+      Ember['default'].assert(string.fmt("The value that #each loops over must be an Array. You " +
+                       "passed %@, but it should have been an ArrayController",
+                       [content.constructor]),
+                       !ControllerMixin['default'].detect(content) ||
+                         (content && content.isGenerated) ||
+                         content instanceof ArrayController['default']);
+      Ember['default'].assert(string.fmt("The value that #each loops over must be an Array. You passed %@",
+                       [(ControllerMixin['default'].detect(content) &&
+                         content.get('model') !== undefined) ?
+                         string.fmt("'%@' (wrapped in %@)", [content.get('model'), content]) : content]),
+                       EmberArray['default'].detect(content));
+    },
 
-      ```html
-      <div id="ember1" class="ember-view disabled"></div>
-      ```
+    disableContentObservers: function(callback) {
+      observer.removeBeforeObserver(this, 'content', null, '_contentWillChange');
+      observer.removeObserver(this, 'content', null, '_contentDidChange');
 
-      Updates to the the value of a class name binding will result in automatic
-      update of the  HTML `class` attribute in the view's rendered HTML
-      representation. If the value becomes `false` or `undefined` the class name
-      will be removed.
+      callback.call(this);
 
-      Both `classNames` and `classNameBindings` are concatenated properties. See
-      [Ember.Object](/api/classes/Ember.Object.html) documentation for more
-      information about concatenated properties.
+      observer.addBeforeObserver(this, 'content', null, '_contentWillChange');
+      observer.addObserver(this, 'content', null, '_contentDidChange');
+    },
 
-      ## HTML Attributes
+    itemViewClass: metamorph_view["default"],
+    emptyViewClass: metamorph_view["default"],
 
-      The HTML attribute section of a view's tag can be set by providing an
-      `attributeBindings` property set to an array of property names on the view.
-      The return value of these properties will be used as the value of the view's
-      HTML associated attribute:
+    createChildView: function(_view, attrs) {
+      var view = this._super(_view, attrs);
 
-      ```javascript
-      AnchorView = Ember.View.extend({
-        tagName: 'a',
-        attributeBindings: ['href'],
-        href: 'http://google.com'
-      });
-      ```
+      var content = property_get.get(view, 'content');
+      var keyword = property_get.get(this, 'keyword');
 
-      Will result in view instances with an HTML representation of:
+      if (keyword) {
+        view._keywords[keyword] = content;
+      }
 
-      ```html
-      <a id="ember1" class="ember-view" href="http://google.com"></a>
-      ```
+      // If {{#each}} is looping over an array of controllers,
+      // point each child view at their respective controller.
+      if (content && content.isController) {
+        property_set.set(view, 'controller', content);
+      }
 
-      One property can be mapped on to another by placing a ":" between
-      the source property and the destination property:
+      return view;
+    },
 
-      ```javascript
-      AnchorView = Ember.View.extend({
-        tagName: 'a',
-        attributeBindings: ['url:href'],
-        url: 'http://google.com'
-      });
-      ```
+    destroy: function() {
+      if (!this._super.apply(this, arguments)) { return; }
 
-      Will result in view instances with an HTML representation of:
+      if (this._arrayController) {
+        this._arrayController.destroy();
+      }
 
-      ```html
-      <a id="ember1" class="ember-view" href="http://google.com"></a>
-      ```
+      return this;
+    }
+  });
 
-      If the return value of an `attributeBindings` monitored property is a boolean
-      the property will follow HTML's pattern of repeating the attribute's name as
-      its value:
+});
+enifed('ember-views/views/metamorph_view', ['exports', 'ember-metal/core', 'ember-views/views/view', 'ember-metal/mixin'], function (exports, Ember, View, mixin) {
 
-      ```javascript
-      MyTextInput = Ember.View.extend({
-        tagName: 'input',
-        attributeBindings: ['disabled'],
-        disabled: true
-      });
-      ```
+  'use strict';
 
-      Will result in view instances with an HTML representation of:
+  /*jshint newcap:false*/
+  var _Metamorph = mixin.Mixin.create({
+    isVirtual: true,
+    tagName: '',
 
-      ```html
-      <input id="ember1" class="ember-view" disabled="disabled" />
-      ```
+    instrumentName: 'metamorph',
 
-      `attributeBindings` can refer to computed properties:
+    init: function() {
+      this._super.apply(this, arguments);
+      Ember['default'].deprecate(
+        'Supplying a tagName to Metamorph views is unreliable and is deprecated.' +
+        ' You may be setting the tagName on a Handlebars helper that creates a Metamorph.',
+        !this.tagName
+      );
+    }
+  });
 
-      ```javascript
-      MyTextInput = Ember.View.extend({
-        tagName: 'input',
-        attributeBindings: ['disabled'],
-        disabled: function() {
-          if (someLogic) {
-            return true;
-          } else {
-            return false;
-          }
-        }.property()
-      });
-      ```
+  /**
+    @class _MetamorphView
+    @namespace Ember
+    @extends Ember.View
+    @uses Ember._Metamorph
+    @private
+  */
+  exports['default'] = View['default'].extend(_Metamorph);
 
-      Updates to the the property of an attribute binding will result in automatic
-      update of the  HTML attribute in the view's rendered HTML representation.
+  exports._Metamorph = _Metamorph;
 
-      `attributeBindings` is a concatenated property. See [Ember.Object](/api/classes/Ember.Object.html)
-      documentation for more information about concatenated properties.
+});
+enifed('ember-views/views/select', ['exports', 'ember-metal/enumerable_utils', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-views/views/view', 'ember-views/views/collection_view', 'ember-metal/utils', 'ember-metal/is_none', 'ember-metal/computed', 'ember-runtime/system/native_array', 'ember-metal/mixin', 'ember-metal/properties', 'ember-metal/run_loop', 'ember-htmlbars/templates/select'], function (exports, enumerable_utils, property_get, property_set, View, CollectionView, utils, isNone, computed, native_array, mixin, properties, run, htmlbarsTemplate) {
 
-      ## Templates
+  'use strict';
 
-      The HTML contents of a view's rendered representation are determined by its
-      template. Templates can be any function that accepts an optional context
-      parameter and returns a string of HTML that will be inserted within the
-      view's tag. Most typically in Ember this function will be a compiled
-      `Ember.Handlebars` template.
+  /**
+  @module ember
+  @submodule ember-views
+  */
 
-      ```javascript
-      AView = Ember.View.extend({
-        template: Ember.Handlebars.compile('I am the template')
-      });
-      ```
+  var defaultTemplate = htmlbarsTemplate['default'];
 
-      Will result in view instances with an HTML representation of:
+  var selectOptionDefaultTemplate = {
+    isHTMLBars: true,
+    revision: 'Ember@1.11.0',
+    render: function(context, env, contextualElement) {
+      var lazyValue = context.getStream('view.label');
 
-      ```html
-      <div id="ember1" class="ember-view">I am the template</div>
-      ```
+      lazyValue.subscribe(context._wrapAsScheduled(function() {
+        run['default'].scheduleOnce('render', context, 'rerender');
+      }));
 
-      Within an Ember application is more common to define a Handlebars templates as
-      part of a page:
+      return lazyValue.value();
+    }
+  };
 
-      ```html
-      <script type='text/x-handlebars' data-template-name='some-template'>
-        Hello
-      </script>
-      ```
+  var SelectOption = View['default'].extend({
+    instrumentDisplay: 'Ember.SelectOption',
 
-      And associate it by name using a view's `templateName` property:
+    tagName: 'option',
+    attributeBindings: ['value', 'selected'],
 
-      ```javascript
-      AView = Ember.View.extend({
-        templateName: 'some-template'
-      });
-      ```
+    defaultTemplate: selectOptionDefaultTemplate,
 
-      If you have nested resources, your Handlebars template will look like this:
+    init: function() {
+      this.labelPathDidChange();
+      this.valuePathDidChange();
 
-      ```html
-      <script type='text/x-handlebars' data-template-name='posts/new'>
-        <h1>New Post</h1>
-      </script>
-      ```
+      this._super.apply(this, arguments);
+    },
 
-      And `templateName` property:
+    selected: computed.computed(function() {
+      var value = property_get.get(this, 'value');
+      var selection = property_get.get(this, 'parentView.selection');
+      if (property_get.get(this, 'parentView.multiple')) {
+        return selection && enumerable_utils.indexOf(selection, value) > -1;
+      } else {
+        // Primitives get passed through bindings as objects... since
+        // `new Number(4) !== 4`, we use `==` below
+        return value === property_get.get(this, 'parentView.value');
+      }
+    }).property('content', 'parentView.selection'),
 
-      ```javascript
-      AView = Ember.View.extend({
-        templateName: 'posts/new'
-      });
-      ```
+    labelPathDidChange: mixin.observer('parentView.optionLabelPath', function() {
+      var labelPath = property_get.get(this, 'parentView.optionLabelPath');
+      properties.defineProperty(this, 'label', computed.computed.alias(labelPath));
+    }),
 
-      Using a value for `templateName` that does not have a Handlebars template
-      with a matching `data-template-name` attribute will throw an error.
+    valuePathDidChange: mixin.observer('parentView.optionValuePath', function() {
+      var valuePath = property_get.get(this, 'parentView.optionValuePath');
+      properties.defineProperty(this, 'value', computed.computed.alias(valuePath));
+    })
+  });
 
-      For views classes that may have a template later defined (e.g. as the block
-      portion of a `{{view}}` Handlebars helper call in another template or in
-      a subclass), you can provide a `defaultTemplate` property set to compiled
-      template function. If a template is not later provided for the view instance
-      the `defaultTemplate` value will be used:
+  var SelectOptgroup = CollectionView['default'].extend({
+    instrumentDisplay: 'Ember.SelectOptgroup',
 
-      ```javascript
-      AView = Ember.View.extend({
-        defaultTemplate: Ember.Handlebars.compile('I was the default'),
-        template: null,
-        templateName: null
-      });
-      ```
+    tagName: 'optgroup',
+    attributeBindings: ['label'],
 
-      Will result in instances with an HTML representation of:
+    selectionBinding: 'parentView.selection',
+    multipleBinding: 'parentView.multiple',
+    optionLabelPathBinding: 'parentView.optionLabelPath',
+    optionValuePathBinding: 'parentView.optionValuePath',
 
-      ```html
-      <div id="ember1" class="ember-view">I was the default</div>
-      ```
+    itemViewClassBinding: 'parentView.optionView'
+  });
 
-      If a `template` or `templateName` is provided it will take precedence over
-      `defaultTemplate`:
+  /**
+    The `Ember.Select` view class renders a
+    [select](https://developer.mozilla.org/en/HTML/Element/select) HTML element,
+    allowing the user to choose from a list of options.
 
-      ```javascript
-      AView = Ember.View.extend({
-        defaultTemplate: Ember.Handlebars.compile('I was the default')
-      });
+    The text and `value` property of each `<option>` element within the
+    `<select>` element are populated from the objects in the `Element.Select`'s
+    `content` property. The underlying data object of the selected `<option>` is
+    stored in the `Element.Select`'s `value` property.
 
-      aView = AView.create({
-        template: Ember.Handlebars.compile('I was the template, not default')
-      });
-      ```
+    ## The Content Property (array of strings)
 
-      Will result in the following HTML representation when rendered:
+    The simplest version of an `Ember.Select` takes an array of strings as its
+    `content` property. The string will be used as both the `value` property and
+    the inner text of each `<option>` element inside the rendered `<select>`.
 
-      ```html
-      <div id="ember1" class="ember-view">I was the template, not default</div>
-      ```
+    Example:
 
-      ## View Context
+    ```javascript
+    App.ApplicationController = Ember.ObjectController.extend({
+      names: ["Yehuda", "Tom"]
+    });
+    ```
 
-      The default context of the compiled template is the view's controller:
+    ```handlebars
+    {{view "select" content=names}}
+    ```
 
-      ```javascript
-      AView = Ember.View.extend({
-        template: Ember.Handlebars.compile('Hello {{excitedGreeting}}')
-      });
+    Would result in the following HTML:
 
-      aController = Ember.Object.create({
-        firstName: 'Barry',
-        excitedGreeting: function() {
-          return this.get("content.firstName") + "!!!"
-        }.property()
-      });
+    ```html
+    <select class="ember-select">
+      <option value="Yehuda">Yehuda</option>
+      <option value="Tom">Tom</option>
+    </select>
+    ```
 
-      aView = AView.create({
-        controller: aController
-      });
-      ```
+    You can control which `<option>` is selected through the `Ember.Select`'s
+    `value` property:
 
-      Will result in an HTML representation of:
+    ```javascript
+    App.ApplicationController = Ember.ObjectController.extend({
+      selectedName: 'Tom',
+      names: ["Yehuda", "Tom"]
+    });
+    ```
 
-      ```html
-      <div id="ember1" class="ember-view">Hello Barry!!!</div>
-      ```
+    ```handlebars
+    {{view "select" content=names value=selectedName}}
+    ```
 
-      A context can also be explicitly supplied through the view's `context`
-      property. If the view has neither `context` nor `controller` properties, the
-      `parentView`'s context will be used.
+    Would result in the following HTML with the `<option>` for 'Tom' selected:
 
-      ## Layouts
+    ```html
+    <select class="ember-select">
+      <option value="Yehuda">Yehuda</option>
+      <option value="Tom" selected="selected">Tom</option>
+    </select>
+    ```
 
-      Views can have a secondary template that wraps their main template. Like
-      primary templates, layouts can be any function that  accepts an optional
-      context parameter and returns a string of HTML that will be inserted inside
-      view's tag. Views whose HTML element is self closing (e.g. `<input />`)
-      cannot have a layout and this property will be ignored.
+    A user interacting with the rendered `<select>` to choose "Yehuda" would
+    update the value of `selectedName` to "Yehuda".
 
-      Most typically in Ember a layout will be a compiled `Ember.Handlebars`
-      template.
+    ## The Content Property (array of Objects)
 
-      A view's layout can be set directly with the `layout` property or reference
-      an existing Handlebars template by name with the `layoutName` property.
+    An `Ember.Select` can also take an array of JavaScript or Ember objects as
+    its `content` property.
 
-      A template used as a layout must contain a single use of the Handlebars
-      `{{yield}}` helper. The HTML contents of a view's rendered `template` will be
-      inserted at this location:
+    When using objects you need to tell the `Ember.Select` which property should
+    be accessed on each object to supply the `value` attribute of the `<option>`
+    and which property should be used to supply the element text.
 
-      ```javascript
-      AViewWithLayout = Ember.View.extend({
-        layout: Ember.Handlebars.compile("<div class='my-decorative-class'>{{yield}}</div>"),
-        template: Ember.Handlebars.compile("I got wrapped")
-      });
-      ```
+    The `optionValuePath` option is used to specify the path on each object to
+    the desired property for the `value` attribute. The `optionLabelPath`
+    specifies the path on each object to the desired property for the
+    element's text. Both paths must reference each object itself as `content`:
 
-      Will result in view instances with an HTML representation of:
+    ```javascript
+    App.ApplicationController = Ember.ObjectController.extend({
+      programmers: [
+        {firstName: "Yehuda", id: 1},
+        {firstName: "Tom",    id: 2}
+      ]
+    });
+    ```
 
-      ```html
-      <div id="ember1" class="ember-view">
-        <div class="my-decorative-class">
-          I got wrapped
-        </div>
-      </div>
-      ```
+    ```handlebars
+    {{view "select"
+           content=programmers
+           optionValuePath="content.id"
+           optionLabelPath="content.firstName"}}
+    ```
 
-      See [Ember.Handlebars.helpers.yield](/api/classes/Ember.Handlebars.helpers.html#method_yield)
-      for more information.
+    Would result in the following HTML:
 
-      ## Responding to Browser Events
+    ```html
+    <select class="ember-select">
+      <option value="1">Yehuda</option>
+      <option value="2">Tom</option>
+    </select>
+    ```
 
-      Views can respond to user-initiated events in one of three ways: method
-      implementation, through an event manager, and through `{{action}}` helper use
-      in their template or layout.
+    The `value` attribute of the selected `<option>` within an `Ember.Select`
+    can be bound to a property on another object:
 
-      ### Method Implementation
+    ```javascript
+    App.ApplicationController = Ember.ObjectController.extend({
+      programmers: [
+        {firstName: "Yehuda", id: 1},
+        {firstName: "Tom",    id: 2}
+      ],
+      currentProgrammer: {
+        id: 2
+      }
+    });
+    ```
 
-      Views can respond to user-initiated events by implementing a method that
-      matches the event name. A `jQuery.Event` object will be passed as the
-      argument to this method.
+    ```handlebars
+    {{view "select"
+           content=programmers
+           optionValuePath="content.id"
+           optionLabelPath="content.firstName"
+           value=currentProgrammer.id}}
+    ```
 
-      ```javascript
-      AView = Ember.View.extend({
-        click: function(event) {
-          // will be called when when an instance's
-          // rendered element is clicked
-        }
-      });
-      ```
+    Would result in the following HTML with a selected option:
 
-      ### Event Managers
+    ```html
+    <select class="ember-select">
+      <option value="1">Yehuda</option>
+      <option value="2" selected="selected">Tom</option>
+    </select>
+    ```
 
-      Views can define an object as their `eventManager` property. This object can
-      then implement methods that match the desired event names. Matching events
-      that occur on the view's rendered HTML or the rendered HTML of any of its DOM
-      descendants will trigger this method. A `jQuery.Event` object will be passed
-      as the first argument to the method and an  `Ember.View` object as the
-      second. The `Ember.View` will be the view whose rendered HTML was interacted
-      with. This may be the view with the `eventManager` property or one of its
-      descendent views.
+    Interacting with the rendered element by selecting the first option
+    ('Yehuda') will update the `id` of `currentProgrammer`
+    to match the `value` property of the newly selected `<option>`.
 
-      ```javascript
-      AView = Ember.View.extend({
-        eventManager: Ember.Object.create({
-          doubleClick: function(event, view) {
-            // will be called when when an instance's
-            // rendered element or any rendering
-            // of this views's descendent
-            // elements is clicked
-          }
-        })
-      });
-      ```
+    Alternatively, you can control selection through the underlying objects
+    used to render each object by binding the `selection` option. When the selected
+    `<option>` is changed, the property path provided to `selection`
+    will be updated to match the content object of the rendered `<option>`
+    element:
 
-      An event defined for an event manager takes precedence over events of the
-      same name handled through methods on the view.
+    ```javascript
 
-      ```javascript
-      AView = Ember.View.extend({
-        mouseEnter: function(event) {
-          // will never trigger.
-        },
-        eventManager: Ember.Object.create({
-          mouseEnter: function(event, view) {
-            // takes precedence over AView#mouseEnter
-          }
-        })
-      });
-      ```
+    var yehuda = {firstName: "Yehuda", id: 1, bff4eva: 'tom'}
+    var tom = {firstName: "Tom", id: 2, bff4eva: 'yehuda'};
 
-      Similarly a view's event manager will take precedence for events of any views
-      rendered as a descendent. A method name that matches an event name will not
-      be called if the view instance was rendered inside the HTML representation of
-      a view that has an `eventManager` property defined that handles events of the
-      name. Events not handled by the event manager will still trigger method calls
-      on the descendent.
+    App.ApplicationController = Ember.ObjectController.extend({
+      selectedPerson: tom,
+      programmers: [ yehuda, tom ]
+    });
+    ```
 
-      ```javascript
-      var App = Ember.Application.create();
-      App.OuterView = Ember.View.extend({
-        template: Ember.Handlebars.compile("outer {{#view 'inner'}}inner{{/view}} outer"),
-        eventManager: Ember.Object.create({
-          mouseEnter: function(event, view) {
-            // view might be instance of either
-            // OuterView or InnerView depending on
-            // where on the page the user interaction occurred
-          }
-        })
-      });
+    ```handlebars
+    {{view "select"
+           content=programmers
+           optionValuePath="content.id"
+           optionLabelPath="content.firstName"
+           selection=selectedPerson}}
+    ```
 
-      App.InnerView = Ember.View.extend({
-        click: function(event) {
-          // will be called if rendered inside
-          // an OuterView because OuterView's
-          // eventManager doesn't handle click events
-        },
-        mouseEnter: function(event) {
-          // will never be called if rendered inside
-          // an OuterView.
-        }
-      });
-      ```
+    Would result in the following HTML with a selected option:
 
-      ### Handlebars `{{action}}` Helper
+    ```html
+    <select class="ember-select">
+      <option value="1">Yehuda</option>
+      <option value="2" selected="selected">Tom</option>
+    </select>
+    ```
 
-      See [Handlebars.helpers.action](/api/classes/Ember.Handlebars.helpers.html#method_action).
+    Interacting with the rendered element by selecting the first option
+    ('Yehuda') will update the `selectedPerson` to match the object of
+    the newly selected `<option>`. In this case it is the first object
+    in the `programmers`
 
-      ### Event Names
+    ## Supplying a Prompt
 
-      All of the event handling approaches described above respond to the same set
-      of events. The names of the built-in events are listed below. (The hash of
-      built-in events exists in `Ember.EventDispatcher`.) Additional, custom events
-      can be registered by using `Ember.Application.customEvents`.
+    A `null` value for the `Ember.Select`'s `value` or `selection` property
+    results in there being no `<option>` with a `selected` attribute:
 
-      Touch events:
+    ```javascript
+    App.ApplicationController = Ember.ObjectController.extend({
+      selectedProgrammer: null,
+      programmers: ["Yehuda", "Tom"]
+    });
+    ```
 
-      * `touchStart`
-      * `touchMove`
-      * `touchEnd`
-      * `touchCancel`
+    ``` handlebars
+    {{view "select"
+           content=programmers
+           value=selectedProgrammer
+    }}
+    ```
 
-      Keyboard events
+    Would result in the following HTML:
 
-      * `keyDown`
-      * `keyUp`
-      * `keyPress`
+    ```html
+    <select class="ember-select">
+      <option value="Yehuda">Yehuda</option>
+      <option value="Tom">Tom</option>
+    </select>
+    ```
 
-      Mouse events
+    Although `selectedProgrammer` is `null` and no `<option>`
+    has a `selected` attribute the rendered HTML will display the
+    first item as though it were selected. You can supply a string
+    value for the `Ember.Select` to display when there is no selection
+    with the `prompt` option:
 
-      * `mouseDown`
-      * `mouseUp`
-      * `contextMenu`
-      * `click`
-      * `doubleClick`
-      * `mouseMove`
-      * `focusIn`
-      * `focusOut`
-      * `mouseEnter`
-      * `mouseLeave`
+    ```javascript
+    App.ApplicationController = Ember.ObjectController.extend({
+      selectedProgrammer: null,
+      programmers: [ "Yehuda", "Tom" ]
+    });
+    ```
 
-      Form events:
+    ```handlebars
+    {{view "select"
+           content=programmers
+           value=selectedProgrammer
+           prompt="Please select a name"
+    }}
+    ```
 
-      * `submit`
-      * `change`
-      * `focusIn`
-      * `focusOut`
-      * `input`
+    Would result in the following HTML:
 
-      HTML5 drag and drop events:
+    ```html
+    <select class="ember-select">
+      <option>Please select a name</option>
+      <option value="Yehuda">Yehuda</option>
+      <option value="Tom">Tom</option>
+    </select>
+    ```
 
-      * `dragStart`
-      * `drag`
-      * `dragEnter`
-      * `dragLeave`
-      * `dragOver`
-      * `dragEnd`
-      * `drop`
+    @class Select
+    @namespace Ember
+    @extends Ember.View
+  */
+  var Select = View['default'].extend({
+    instrumentDisplay: 'Ember.Select',
 
-      ## Handlebars `{{view}}` Helper
+    tagName: 'select',
+    classNames: ['ember-select'],
+    defaultTemplate: defaultTemplate,
+    attributeBindings: ['multiple', 'disabled', 'tabindex', 'name', 'required', 'autofocus',
+                        'form', 'size'],
 
-      Other `Ember.View` instances can be included as part of a view's template by
-      using the `{{view}}` Handlebars helper. See [Ember.Handlebars.helpers.view](/api/classes/Ember.Handlebars.helpers.html#method_view)
-      for additional information.
+    /**
+      The `multiple` attribute of the select element. Indicates whether multiple
+      options can be selected.
 
-      @class View
-      @namespace Ember
-      @extends Ember.CoreView
+      @property multiple
+      @type Boolean
+      @default false
     */
-    var View = CoreView.extend({
+    multiple: false,
 
-      concatenatedProperties: ['classNames', 'classNameBindings', 'attributeBindings'],
+    /**
+      The `disabled` attribute of the select element. Indicates whether
+      the element is disabled from interactions.
 
-      /**
-        @property isView
-        @type Boolean
-        @default true
-        @static
-      */
-      isView: true,
+      @property disabled
+      @type Boolean
+      @default false
+    */
+    disabled: false,
 
-      // ..........................................................
-      // TEMPLATE SUPPORT
-      //
+    /**
+      The `required` attribute of the select element. Indicates whether
+      a selected option is required for form validation.
 
-      /**
-        The name of the template to lookup if no template is provided.
+      @property required
+      @type Boolean
+      @default false
+      @since 1.5.0
+    */
+    required: false,
 
-        By default `Ember.View` will lookup a template with this name in
-        `Ember.TEMPLATES` (a shared global object).
+    /**
+      The list of options.
 
-        @property templateName
-        @type String
-        @default null
-      */
-      templateName: null,
+      If `optionLabelPath` and `optionValuePath` are not overridden, this should
+      be a list of strings, which will serve simultaneously as labels and values.
 
-      /**
-        The name of the layout to lookup if no layout is provided.
+      Otherwise, this should be a list of objects. For instance:
 
-        By default `Ember.View` will lookup a template with this name in
-        `Ember.TEMPLATES` (a shared global object).
+      ```javascript
+      var App = Ember.Application.create();
+      var App.MySelect = Ember.Select.extend({
+        content: Ember.A([
+            { id: 1, firstName: 'Yehuda' },
+            { id: 2, firstName: 'Tom' }
+          ]),
+        optionLabelPath: 'content.firstName',
+        optionValuePath: 'content.id'
+      });
+      ```
 
-        @property layoutName
-        @type String
-        @default null
-      */
-      layoutName: null,
+      @property content
+      @type Array
+      @default null
+    */
+    content: null,
 
-      /**
-        Used to identify this view during debugging
+    /**
+      When `multiple` is `false`, the element of `content` that is currently
+      selected, if any.
 
-        @property instrumentDisplay
-        @type String
-      */
-      instrumentDisplay: computed(function() {
-        if (this.helperName) {
-          return '{{' + this.helperName + '}}';
-        }
-      }),
+      When `multiple` is `true`, an array of such elements.
 
-      /**
-        The template used to render the view. This should be a function that
-        accepts an optional context parameter and returns a string of HTML that
-        will be inserted into the DOM relative to its parent view.
+      @property selection
+      @type Object or Array
+      @default null
+    */
+    selection: null,
 
-        In general, you should set the `templateName` property instead of setting
-        the template yourself.
+    /**
+      In single selection mode (when `multiple` is `false`), value can be used to
+      get the current selection's value or set the selection by its value.
 
-        @property template
-        @type Function
-      */
-      template: computed('templateName', function(key, value) {
-        if (value !== undefined) { return value; }
+      It is not currently supported in multiple selection mode.
 
-        var templateName = get(this, 'templateName');
-        var template = this.templateForName(templateName, 'template');
+      @property value
+      @type String
+      @default null
+    */
+    value: computed.computed('_valuePath', 'selection', function(key, value) {
+      if (arguments.length === 2) { return value; }
+      var valuePath = property_get.get(this, '_valuePath');
+      return valuePath ? property_get.get(this, 'selection.' + valuePath) : property_get.get(this, 'selection');
+    }),
 
-        Ember.assert("You specified the templateName " + templateName + " for " + this + ", but it did not exist.", !templateName || !!template);
+    /**
+      If given, a top-most dummy option will be rendered to serve as a user
+      prompt.
 
-        return template || get(this, 'defaultTemplate');
-      }),
+      @property prompt
+      @type String
+      @default null
+    */
+    prompt: null,
 
-      _controller: null,
+    /**
+      The path of the option labels. See [content](/api/classes/Ember.Select.html#property_content).
 
-      /**
-        The controller managing this view. If this property is set, it will be
-        made available for use by the template.
+      @property optionLabelPath
+      @type String
+      @default 'content'
+    */
+    optionLabelPath: 'content',
 
-        @property controller
-        @type Object
-      */
-      controller: computed(function(key, value) {
-        if (arguments.length === 2) {
-          this._controller = value;
-          return value;
-        }
+    /**
+      The path of the option values. See [content](/api/classes/Ember.Select.html#property_content).
 
-        if (this._controller) {
-          return this._controller;
-        }
+      @property optionValuePath
+      @type String
+      @default 'content'
+    */
+    optionValuePath: 'content',
 
-        var parentView = get(this, '_parentView');
-        return parentView ? get(parentView, 'controller') : null;
-      }),
+    /**
+      The path of the option group.
+      When this property is used, `content` should be sorted by `optionGroupPath`.
 
-      /**
-        A view may contain a layout. A layout is a regular template but
-        supersedes the `template` property during rendering. It is the
-        responsibility of the layout template to retrieve the `template`
-        property from the view (or alternatively, call `Handlebars.helpers.yield`,
-        `{{yield}}`) to render it in the correct location.
-
-        This is useful for a view that has a shared wrapper, but which delegates
-        the rendering of the contents of the wrapper to the `template` property
-        on a subclass.
-
-        @property layout
-        @type Function
-      */
-      layout: computed(function(key) {
-        var layoutName = get(this, 'layoutName');
-        var layout = this.templateForName(layoutName, 'layout');
+      @property optionGroupPath
+      @type String
+      @default null
+    */
+    optionGroupPath: null,
 
-        Ember.assert("You specified the layoutName " + layoutName + " for " + this + ", but it did not exist.", !layoutName || !!layout);
+    /**
+      The view class for optgroup.
 
-        return layout || get(this, 'defaultLayout');
-      }).property('layoutName'),
+      @property groupView
+      @type Ember.View
+      @default Ember.SelectOptgroup
+    */
+    groupView: SelectOptgroup,
 
-      _yield: function(context, options, morph) {
-        var template = get(this, 'template');
+    groupedContent: computed.computed(function() {
+      var groupPath = property_get.get(this, 'optionGroupPath');
+      var groupedContent = native_array.A();
+      var content = property_get.get(this, 'content') || [];
 
-        if (template) {
-          var useHTMLBars = false;
-          
-            useHTMLBars = template.isHTMLBars;
-          
+      enumerable_utils.forEach(content, function(item) {
+        var label = property_get.get(item, groupPath);
 
-          if (useHTMLBars) {
-            return template.render(this, options, morph.contextualElement);
-          } else {
-            return template(context, options);
-          }
+        if (property_get.get(groupedContent, 'lastObject.label') !== label) {
+          groupedContent.pushObject({
+            label: label,
+            content: native_array.A()
+          });
         }
-      },
-
-      _blockArguments: EMPTY_ARRAY,
-
-      templateForName: function(name, type) {
-        if (!name) { return; }
-        Ember.assert("templateNames are not allowed to contain periods: "+name, name.indexOf('.') === -1);
 
-        if (!this.container) {
-          throw new EmberError('Container was not found when looking up a views template. ' +
-                     'This is most likely due to manually instantiating an Ember.View. ' +
-                     'See: http://git.io/EKPpnA');
-        }
+        property_get.get(groupedContent, 'lastObject.content').push(item);
+      });
 
-        return this.container.lookup('template:' + name);
-      },
+      return groupedContent;
+    }).property('optionGroupPath', 'content.@each'),
 
-      /**
-        The object from which templates should access properties.
+    /**
+      The view class for option.
 
-        This object will be passed to the template function each time the render
-        method is called, but it is up to the individual function to decide what
-        to do with it.
+      @property optionView
+      @type Ember.View
+      @default Ember.SelectOption
+    */
+    optionView: SelectOption,
 
-        By default, this will be the view's controller.
+    _change: function() {
+      if (property_get.get(this, 'multiple')) {
+        this._changeMultiple();
+      } else {
+        this._changeSingle();
+      }
+    },
 
-        @property context
-        @type Object
-      */
-      context: computed(function(key, value) {
-        if (arguments.length === 2) {
-          set(this, '_context', value);
-          return value;
-        } else {
-          return get(this, '_context');
+    selectionDidChange: mixin.observer('selection.@each', function() {
+      var selection = property_get.get(this, 'selection');
+      if (property_get.get(this, 'multiple')) {
+        if (!utils.isArray(selection)) {
+          property_set.set(this, 'selection', native_array.A([selection]));
+          return;
         }
-      })["volatile"](),
-
-      /**
-        Private copy of the view's template context. This can be set directly
-        by Handlebars without triggering the observer that causes the view
-        to be re-rendered.
+        this._selectionDidChangeMultiple();
+      } else {
+        this._selectionDidChangeSingle();
+      }
+    }),
 
-        The context of a view is looked up as follows:
+    valueDidChange: mixin.observer('value', function() {
+      var content = property_get.get(this, 'content');
+      var value = property_get.get(this, 'value');
+      var valuePath = property_get.get(this, 'optionValuePath').replace(/^content\.?/, '');
+      var selectedValue = (valuePath ? property_get.get(this, 'selection.' + valuePath) : property_get.get(this, 'selection'));
+      var selection;
 
-        1. Supplied context (usually by Handlebars)
-        2. Specified controller
-        3. `parentView`'s context (for a child of a ContainerView)
+      if (value !== selectedValue) {
+        selection = content ? content.find(function(obj) {
+          return value === (valuePath ? property_get.get(obj, valuePath) : obj);
+        }) : null;
 
-        The code in Handlebars that overrides the `_context` property first
-        checks to see whether the view has a specified controller. This is
-        something of a hack and should be revisited.
+        this.set('selection', selection);
+      }
+    }),
 
-        @property _context
-        @private
-      */
-      _context: computed(function(key, value) {
-        if (arguments.length === 2) {
-          return value;
-        }
+    _setDefaults: function() {
+      var selection = property_get.get(this, 'selection');
+      var value = property_get.get(this, 'value');
 
-        var parentView, controller;
+      if (!isNone['default'](selection)) { this.selectionDidChange(); }
+      if (!isNone['default'](value)) { this.valueDidChange(); }
+      if (isNone['default'](selection)) {
+        this._change();
+      }
+    },
 
-        if (controller = get(this, 'controller')) {
-          return controller;
-        }
+    _changeSingle: function() {
+      var selectedIndex = this.$()[0].selectedIndex;
+      var content = property_get.get(this, 'content');
+      var prompt = property_get.get(this, 'prompt');
 
-        parentView = this._parentView;
-        if (parentView) {
-          return get(parentView, '_context');
-        }
+      if (!content || !property_get.get(content, 'length')) { return; }
+      if (prompt && selectedIndex === 0) {
+        property_set.set(this, 'selection', null);
+        return;
+      }
 
-        return null;
-      }),
+      if (prompt) { selectedIndex -= 1; }
+      property_set.set(this, 'selection', content.objectAt(selectedIndex));
+    },
 
-      /**
-        If a value that affects template rendering changes, the view should be
-        re-rendered to reflect the new value.
+    _changeMultiple: function() {
+      var options = this.$('option:selected');
+      var prompt = property_get.get(this, 'prompt');
+      var offset = prompt ? 1 : 0;
+      var content = property_get.get(this, 'content');
+      var selection = property_get.get(this, 'selection');
 
-        @method _contextDidChange
-        @private
-      */
-      _contextDidChange: observer('context', function() {
-        this.rerender();
-      }),
+      if (!content) { return; }
+      if (options) {
+        var selectedIndexes = options.map(function() {
+          return this.index - offset;
+        }).toArray();
+        var newSelection = content.objectsAt(selectedIndexes);
 
-      /**
-        If `false`, the view will appear hidden in DOM.
+        if (utils.isArray(selection)) {
+          enumerable_utils.replace(selection, 0, property_get.get(selection, 'length'), newSelection);
+        } else {
+          property_set.set(this, 'selection', newSelection);
+        }
+      }
+    },
 
-        @property isVisible
-        @type Boolean
-        @default null
-      */
-      isVisible: true,
+    _selectionDidChangeSingle: function() {
+      var value = property_get.get(this, 'value');
+      var self = this;
+      if (value && value.then) {
+        value.then(function (resolved) {
+          // Ensure that we don't overwrite new value
+          if (property_get.get(self, 'value') === value) {
+            self._setSelectedIndex(resolved);
+          }
+        });
+      } else {
+        this._setSelectedIndex(value);
+      }
+    },
 
-      /**
-        Array of child views. You should never edit this array directly.
-        Instead, use `appendChild` and `removeFromParent`.
+    _setSelectedIndex: function (selectionValue) {
+      var el = property_get.get(this, 'element');
+      var content = property_get.get(this, 'contentValues');
+      if (!el) { return; }
 
-        @property childViews
-        @type Array
-        @default []
-        @private
-      */
-      childViews: childViewsProperty,
+      var selectionIndex = enumerable_utils.indexOf(content, selectionValue);
+      var prompt = property_get.get(this, 'prompt');
 
-      _childViews: EMPTY_ARRAY,
+      if (prompt) { selectionIndex += 1; }
+      if (el) { el.selectedIndex = selectionIndex; }
+    },
 
-      // When it's a virtual view, we need to notify the parent that their
-      // childViews will change.
-      _childViewsWillChange: beforeObserver('childViews', function() {
-        if (this.isVirtual) {
-          var parentView = get(this, 'parentView');
-          if (parentView) { propertyWillChange(parentView, 'childViews'); }
-        }
-      }),
+    _valuePath: computed.computed('optionValuePath', function () {
+      var optionValuePath = property_get.get(this, 'optionValuePath');
+      return optionValuePath.replace(/^content\.?/, '');
+    }),
 
-      // When it's a virtual view, we need to notify the parent that their
-      // childViews did change.
-      _childViewsDidChange: observer('childViews', function() {
-        if (this.isVirtual) {
-          var parentView = get(this, 'parentView');
-          if (parentView) { propertyDidChange(parentView, 'childViews'); }
-        }
-      }),
+    contentValues: computed.computed('content.[]', '_valuePath', function () {
+      var valuePath = property_get.get(this, '_valuePath');
+      var content = property_get.get(this, 'content') || [];
 
-      /**
-        Return the nearest ancestor that is an instance of the provided
-        class.
+      if (valuePath) {
+        return enumerable_utils.map(content, function (el) { return property_get.get(el, valuePath); });
+      } else {
+        return enumerable_utils.map(content, function (el) { return el; });
+      }
+    }),
 
-        @method nearestInstanceOf
-        @param {Class} klass Subclass of Ember.View (or Ember.View itself)
-        @return Ember.View
-        @deprecated
-      */
-      nearestInstanceOf: function(klass) {
-        Ember.deprecate("nearestInstanceOf is deprecated and will be removed from future releases. Use nearestOfType.");
-        var view = get(this, 'parentView');
+    _selectionDidChangeMultiple: function() {
+      var content = property_get.get(this, 'content');
+      var selection = property_get.get(this, 'selection');
+      var selectedIndexes = content ? enumerable_utils.indexesOf(content, selection) : [-1];
+      var prompt = property_get.get(this, 'prompt');
+      var offset = prompt ? 1 : 0;
+      var options = this.$('option');
+      var adjusted;
 
-        while (view) {
-          if (view instanceof klass) { return view; }
-          view = get(view, 'parentView');
-        }
-      },
+      if (options) {
+        options.each(function() {
+          adjusted = this.index > -1 ? this.index - offset : -1;
+          this.selected = enumerable_utils.indexOf(selectedIndexes, adjusted) > -1;
+        });
+      }
+    },
 
-      /**
-        Return the nearest ancestor that is an instance of the provided
-        class or mixin.
+    init: function() {
+      this._super.apply(this, arguments);
+      this.on("didInsertElement", this, this._setDefaults);
+      this.on("change", this, this._change);
+    }
+  });
 
-        @method nearestOfType
-        @param {Class,Mixin} klass Subclass of Ember.View (or Ember.View itself),
-               or an instance of Ember.Mixin.
-        @return Ember.View
-      */
-      nearestOfType: function(klass) {
-        var view = get(this, 'parentView');
-        var isOfType = klass instanceof Mixin ?
-                       function(view) { return klass.detect(view); } :
-                       function(view) { return klass.detect(view.constructor); };
+  exports['default'] = Select;
 
-        while (view) {
-          if (isOfType(view)) { return view; }
-          view = get(view, 'parentView');
-        }
-      },
+  exports.Select = Select;
+  exports.SelectOption = SelectOption;
+  exports.SelectOptgroup = SelectOptgroup;
 
-      /**
-        Return the nearest ancestor that has a given property.
+});
+enifed('ember-views/views/simple_bound_view', ['exports', 'ember-metal/error', 'ember-metal/run_loop', 'ember-metal/utils'], function (exports, EmberError, run, utils) {
 
-        @method nearestWithProperty
-        @param {String} property A property name
-        @return Ember.View
-      */
-      nearestWithProperty: function(property) {
-        var view = get(this, 'parentView');
+  'use strict';
 
-        while (view) {
-          if (property in view) { return view; }
-          view = get(view, 'parentView');
-        }
-      },
+  exports.appendSimpleBoundView = appendSimpleBoundView;
 
-      /**
-        Return the nearest ancestor whose parent is an instance of
-        `klass`.
+  /**
+  @module ember
+  @submodule ember-views
+  */
 
-        @method nearestChildOf
-        @param {Class} klass Subclass of Ember.View (or Ember.View itself)
-        @return Ember.View
-      */
-      nearestChildOf: function(klass) {
-        var view = get(this, 'parentView');
+  function K() { return this; }
 
-        while (view) {
-          if (get(view, 'parentView') instanceof klass) { return view; }
-          view = get(view, 'parentView');
-        }
-      },
+  function SimpleBoundView(parentView, renderer, morph, stream) {
+    this.stream = stream;
+    this[utils.GUID_KEY] = utils.uuid();
+    this._lastNormalizedValue = undefined;
+    this.state = 'preRender';
+    this.updateId = null;
+    this._parentView = parentView;
+    this.buffer = null;
+    this._morph = morph;
+    this.renderer = renderer;
+  }
 
-      /**
-        When the parent view changes, recursively invalidate `controller`
+  SimpleBoundView.prototype = {
+    isVirtual: true,
+    isView: true,
+    tagName: '',
 
-        @method _parentViewDidChange
-        @private
-      */
-      _parentViewDidChange: observer('_parentView', function() {
-        if (this.isDestroying) { return; }
+    destroy: function () {
+      if (this.updateId) {
+        run['default'].cancel(this.updateId);
+        this.updateId = null;
+      }
+      if (this._parentView) {
+        this._parentView.removeChild(this);
+      }
+      this.morph = null;
+      this.state = 'destroyed';
+    },
 
-        this._setupKeywords();
-        this.trigger('parentViewDidChange');
+    propertyWillChange: K,
 
-        if (get(this, 'parentView.controller') && !get(this, 'controller')) {
-          this.notifyPropertyChange('controller');
-        }
-      }),
+    propertyDidChange: K,
 
-      _controllerDidChange: observer('controller', function() {
-        if (this.isDestroying) { return; }
+    normalizedValue: function() {
+      var result = this.stream.value();
 
-        this.rerender();
+      if (result === null || result === undefined) {
+        return "";
+      } else {
+        return result;
+      }
+    },
 
-        this.forEachChildView(function(view) {
-          view.propertyDidChange('controller');
-        });
-      }),
+    render: function(buffer) {
+      var value = this.normalizedValue();
+      this._lastNormalizedValue = value;
+      buffer._element = value;
+    },
 
-      _setupKeywords: function() {
-        var keywords = this._keywords;
-        var contextView = this._contextView || this._parentView;
+    rerender: function() {
+      switch (this.state) {
+        case 'preRender':
+        case 'destroyed':
+          break;
+        case 'inBuffer':
+          throw new EmberError['default']("Something you did tried to replace an {{expression}} before it was inserted into the DOM.");
+        case 'hasElement':
+        case 'inDOM':
+          this.updateId = run['default'].scheduleOnce('render', this, 'update');
+          break;
+      }
+      return this;
+    },
 
-        if (contextView) {
-          var parentKeywords = contextView._keywords;
+    update: function () {
+      this.updateId = null;
+      var value = this.normalizedValue();
+      // doesn't diff SafeString instances
+      if (value !== this._lastNormalizedValue) {
+        this._lastNormalizedValue = value;
+        this._morph.setContent(value);
+      }
+    },
 
-          keywords.view = this.isVirtual ? parentKeywords.view : this;
+    _transitionTo: function(state) {
+      this.state = state;
+    }
+  };
 
-          for (var name in parentKeywords) {
-            if (keywords[name]) continue;
-            keywords[name] = parentKeywords[name];
-          }
-        } else {
-          keywords.view = this.isVirtual ? null : this;
-        }
-      },
+  SimpleBoundView.create = function(attrs) {
+    return new SimpleBoundView(attrs._parentView, attrs.renderer, attrs._morph, attrs.stream);
+  };
 
-      /**
-        Called on your view when it should push strings of HTML into a
-        `Ember.RenderBuffer`. Most users will want to override the `template`
-        or `templateName` properties instead of this method.
+  SimpleBoundView.isViewClass = true;
 
-        By default, `Ember.View` will look for a function in the `template`
-        property and invoke it with the value of `context`. The value of
-        `context` will be the view's controller unless you override it.
+  function appendSimpleBoundView(parentView, morph, stream) {
+    var view = parentView.appendChild(SimpleBoundView, { _morph: morph, stream: stream });
 
-        @method render
-        @param {Ember.RenderBuffer} buffer The render buffer
-      */
-      render: function(buffer) {
-        // If this view has a layout, it is the responsibility of the
-        // the layout to render the view's template. Otherwise, render the template
-        // directly.
-        var template = get(this, 'layout') || get(this, 'template');
-
-        if (template) {
-          var context = get(this, 'context');
-          var output;
-
-          var data = {
-            view: this,
-            buffer: buffer,
-            isRenderData: true
-          };
+    stream.subscribe(parentView._wrapAsScheduled(function() {
+      run['default'].scheduleOnce('render', view, 'rerender');
+    }));
+  }
 
-          // Invoke the template with the provided template context, which
-          // is the view's controller by default. A hash of data is also passed that provides
-          // the template with access to the view and render buffer.
+  exports['default'] = SimpleBoundView;
 
-          // The template should write directly to the render buffer instead
-          // of returning a string.
-          var options = { data: data };
-          var useHTMLBars = false;
+});
+enifed('ember-views/views/states', ['exports', 'ember-metal/platform/create', 'ember-metal/merge', 'ember-views/views/states/default', 'ember-views/views/states/pre_render', 'ember-views/views/states/in_buffer', 'ember-views/views/states/has_element', 'ember-views/views/states/in_dom', 'ember-views/views/states/destroying'], function (exports, create, merge, _default, preRender, inBuffer, hasElement, inDOM, destroying) {
 
-          
-            useHTMLBars = template.isHTMLBars;
-          
+  'use strict';
 
-          if (useHTMLBars) {
-            Ember.assert('template must be an object. Did you mean to call Ember.Handlebars.compile("...") or specify templateName instead?', typeof template === 'object');
-            var env = Ember.merge(buildHTMLBarsDefaultEnv(), options);
-            output = template.render(this, env, buffer.innerContextualElement(), this._blockArguments);
-          } else {
-            Ember.assert('template must be a function. Did you mean to call Ember.Handlebars.compile("...") or specify templateName instead?', typeof template === 'function');
-            output = template(context, options);
-          }
+  exports.cloneStates = cloneStates;
 
-          // If the template returned a string instead of writing to the buffer,
-          // push the string onto the buffer.
-          if (output !== undefined) { buffer.push(output); }
-        }
-      },
+  function cloneStates(from) {
+    var into = {};
 
-      /**
-        Renders the view again. This will work regardless of whether the
-        view is already in the DOM or not. If the view is in the DOM, the
-        rendering process will be deferred to give bindings a chance
-        to synchronize.
+    into._default = {};
+    into.preRender = create['default'](into._default);
+    into.destroying = create['default'](into._default);
+    into.inBuffer = create['default'](into._default);
+    into.hasElement = create['default'](into._default);
+    into.inDOM = create['default'](into.hasElement);
 
-        If children were added during the rendering process using `appendChild`,
-        `rerender` will remove them, because they will be added again
-        if needed by the next `render`.
+    for (var stateName in from) {
+      if (!from.hasOwnProperty(stateName)) { continue; }
+      merge['default'](into[stateName], from[stateName]);
+    }
 
-        In general, if the display of your view changes, you should modify
-        the DOM element directly instead of manually calling `rerender`, which can
-        be slow.
+    return into;
+  }
 
-        @method rerender
-      */
-      rerender: function() {
-        return this.currentState.rerender(this);
-      },
+  var states = {
+    _default: _default['default'],
+    preRender: preRender['default'],
+    inDOM: inDOM['default'],
+    inBuffer: inBuffer['default'],
+    hasElement: hasElement['default'],
+    destroying: destroying['default']
+  };
 
-      /**
-        Iterates over the view's `classNameBindings` array, inserts the value
-        of the specified property into the `classNames` array, then creates an
-        observer to update the view's element if the bound property ever changes
-        in the future.
+  exports.states = states;
 
-        @method _applyClassNameBindings
-        @private
-      */
-      _applyClassNameBindings: function(classBindings) {
-        var classNames = this.classNames;
-        var elem, newClass, dasherizedClass;
-
-        // Loop through all of the configured bindings. These will be either
-        // property names ('isUrgent') or property paths relative to the view
-        // ('content.isUrgent')
-        forEach(classBindings, function(binding) {
-
-          var boundBinding;
-          if (isStream(binding)) {
-            boundBinding = binding;
-          } else {
-            boundBinding = streamifyClassNameBinding(this, binding, '_view.');
-          }
+});
+enifed('ember-views/views/states/default', ['exports', 'ember-metal/error'], function (exports, EmberError) {
 
-          // Variable in which the old class value is saved. The observer function
-          // closes over this variable, so it knows which string to remove when
-          // the property changes.
-          var oldClass;
-
-          // Set up an observer on the context. If the property changes, toggle the
-          // class name.
-          var observer = this._wrapAsScheduled(function() {
-            // Get the current value of the property
-            elem = this.$();
-            newClass = read(boundBinding);
-
-            // If we had previously added a class to the element, remove it.
-            if (oldClass) {
-              elem.removeClass(oldClass);
-              // Also remove from classNames so that if the view gets rerendered,
-              // the class doesn't get added back to the DOM.
-              classNames.removeObject(oldClass);
-            }
+  'use strict';
 
-            // If necessary, add a new class. Make sure we keep track of it so
-            // it can be removed in the future.
-            if (newClass) {
-              elem.addClass(newClass);
-              oldClass = newClass;
-            } else {
-              oldClass = null;
-            }
-          });
+  function K() { return this; }
 
-          // Get the class name for the property at its current value
-          dasherizedClass = read(boundBinding);
+  /**
+  @module ember
+  @submodule ember-views
+  */
+  exports['default'] = {
+    // appendChild is only legal while rendering the buffer.
+    appendChild: function() {
+      throw new EmberError['default']("You can't use appendChild outside of the rendering process");
+    },
 
-          if (dasherizedClass) {
-            // Ensure that it gets into the classNames array
-            // so it is displayed when we render.
-            addObject(classNames, dasherizedClass);
+    $: function() {
+      return undefined;
+    },
 
-            // Save a reference to the class name so we can remove it
-            // if the observer fires. Remember that this variable has
-            // been closed over by the observer.
-            oldClass = dasherizedClass;
-          }
+    getElement: function() {
+      return null;
+    },
 
-          subscribe(boundBinding, observer, this);
-          // Remove className so when the view is rerendered,
-          // the className is added based on binding reevaluation
-          this.one('willClearRender', function() {
-            if (oldClass) {
-              classNames.removeObject(oldClass);
-              oldClass = null;
-            }
-          });
+    // Handle events from `Ember.EventDispatcher`
+    handleEvent: function() {
+      return true; // continue event propagation
+    },
 
-        }, this);
-      },
+    destroyElement: function(view) {
+      if (view._renderer) {
+        view._renderer.remove(view, false);
+      }
 
-      _unspecifiedAttributeBindings: null,
+      return view;
+    },
 
-      /**
-        Iterates through the view's attribute bindings, sets up observers for each,
-        then applies the current value of the attributes to the passed render buffer.
+    rerender: K,
+    invokeObserver: K
+  };
 
-        @method _applyAttributeBindings
-        @param {Ember.RenderBuffer} buffer
-        @private
-      */
-      _applyAttributeBindings: function(buffer, attributeBindings) {
-        var attributeValue;
-        var unspecifiedAttributeBindings = this._unspecifiedAttributeBindings = this._unspecifiedAttributeBindings || {};
+});
+enifed('ember-views/views/states/destroying', ['exports', 'ember-metal/merge', 'ember-metal/platform/create', 'ember-runtime/system/string', 'ember-views/views/states/default', 'ember-metal/error'], function (exports, merge, create, string, _default, EmberError) {
 
-        forEach(attributeBindings, function(binding) {
-          var split = binding.split(':');
-          var property = split[0];
-          var attributeName = split[1] || property;
+  'use strict';
 
-          Ember.assert('You cannot use class as an attributeBinding, use classNameBindings instead.', attributeName !== 'class');
+  var destroyingError = "You can't call %@ on a view being destroyed";
 
-          if (property in this) {
-            this._setupAttributeBindingObservation(property, attributeName);
+  var destroying = create['default'](_default['default']);
 
-            // Determine the current value and add it to the render buffer
-            // if necessary.
-            attributeValue = get(this, property);
-            View.applyAttributeBindings(buffer, attributeName, attributeValue);
-          } else {
-            unspecifiedAttributeBindings[property] = attributeName;
-          }
-        }, this);
+  merge['default'](destroying, {
+    appendChild: function() {
+      throw new EmberError['default'](string.fmt(destroyingError, ['appendChild']));
+    },
+    rerender: function() {
+      throw new EmberError['default'](string.fmt(destroyingError, ['rerender']));
+    },
+    destroyElement: function() {
+      throw new EmberError['default'](string.fmt(destroyingError, ['destroyElement']));
+    }
+  });
 
-        // Lazily setup setUnknownProperty after attributeBindings are initially applied
-        this.setUnknownProperty = this._setUnknownProperty;
-      },
+  exports['default'] = destroying;
 
-      _setupAttributeBindingObservation: function(property, attributeName) {
-        var attributeValue, elem;
+});
+enifed('ember-views/views/states/has_element', ['exports', 'ember-views/views/states/default', 'ember-metal/run_loop', 'ember-metal/merge', 'ember-metal/platform/create', 'ember-views/system/jquery', 'ember-metal/error', 'ember-metal/property_get'], function (exports, _default, run, merge, create, jQuery, EmberError, property_get) {
 
-        // Create an observer to add/remove/change the attribute if the
-        // JavaScript property changes.
-        var observer = function() {
-          elem = this.$();
+  'use strict';
 
-          attributeValue = get(this, property);
+  var hasElement = create['default'](_default['default']);
 
-          var normalizedName = normalizeProperty(elem, attributeName.toLowerCase()) || attributeName;
-          View.applyAttributeBindings(elem, normalizedName, attributeValue);
-        };
+  merge['default'](hasElement, {
+    $: function(view, sel) {
+      var elem = view.get('concreteView').element;
+      return sel ? jQuery['default'](sel, elem) : jQuery['default'](elem);
+    },
 
-        this.registerObserver(this, property, observer);
-      },
+    getElement: function(view) {
+      var parent = property_get.get(view, 'parentView');
+      if (parent) { parent = property_get.get(parent, 'element'); }
+      if (parent) { return view.findElementInParentElement(parent); }
+      return jQuery['default']("#" + property_get.get(view, 'elementId'))[0];
+    },
 
-      /**
-        We're using setUnknownProperty as a hook to setup attributeBinding observers for
-        properties that aren't defined on a view at initialization time.
+    // once the view has been inserted into the DOM, rerendering is
+    // deferred to allow bindings to synchronize.
+    rerender: function(view) {
+      if (view._root._morph && !view._elementInserted) {
+        throw new EmberError['default']("Something you did caused a view to re-render after it rendered but before it was inserted into the DOM.");
+      }
+      // TODO: should be scheduled with renderer
+      run['default'].scheduleOnce('render', function () {
+        if (view.isDestroying) {
+          return;
+        }
 
-        Note: setUnknownProperty will only be called once for each property.
+        view._renderer.renderTree(view, view._parentView);
+      });
+    },
 
-        @method setUnknownProperty
-        @param key
-        @param value
-        @private
-      */
-      setUnknownProperty: null, // Gets defined after initialization by _applyAttributeBindings
+    // once the view is already in the DOM, destroying it removes it
+    // from the DOM, nukes its element, and puts it back into the
+    // preRender state if inDOM.
 
-      _setUnknownProperty: function(key, value) {
-        var attributeName = this._unspecifiedAttributeBindings && this._unspecifiedAttributeBindings[key];
-        if (attributeName) {
-          this._setupAttributeBindingObservation(key, attributeName);
-        }
+    destroyElement: function(view) {
+      view._renderer.remove(view, false);
+      return view;
+    },
 
-        defineProperty(this, key);
-        return set(this, key, value);
-      },
+    // Handle events from `Ember.EventDispatcher`
+    handleEvent: function(view, eventName, evt) {
+      if (view.has(eventName)) {
+        // Handler should be able to re-dispatch events, so we don't
+        // preventDefault or stopPropagation.
+        return view.trigger(eventName, evt);
+      } else {
+        return true; // continue event propagation
+      }
+    },
 
-      /**
-        Given a property name, returns a dasherized version of that
-        property name if the property evaluates to a non-falsy value.
+    invokeObserver: function(target, observer) {
+      observer.call(target);
+    }
+  });
 
-        For example, if the view has property `isUrgent` that evaluates to true,
-        passing `isUrgent` to this method will return `"is-urgent"`.
+  exports['default'] = hasElement;
 
-        @method _classStringForProperty
-        @param property
-        @private
-      */
-      _classStringForProperty: function(parsedPath) {
-        return View._classStringForValue(parsedPath.path, parsedPath.stream.value(), parsedPath.className, parsedPath.falsyClassName);
-      },
+});
+enifed('ember-views/views/states/in_buffer', ['exports', 'ember-views/views/states/default', 'ember-metal/error', 'ember-views/system/jquery', 'ember-metal/platform/create', 'ember-metal/merge'], function (exports, _default, EmberError, jQuery, create, merge) {
 
-      // ..........................................................
-      // ELEMENT SUPPORT
-      //
+  'use strict';
 
-      /**
-        Returns the current DOM element for the view.
+  var inBuffer = create['default'](_default['default']);
 
-        @property element
-        @type DOMElement
-      */
-      element: null,
+  merge['default'](inBuffer, {
+    $: function(view, sel) {
+      // if we don't have an element yet, someone calling this.$() is
+      // trying to update an element that isn't in the DOM. Instead,
+      // rerender the view to allow the render method to reflect the
+      // changes.
+      view.rerender();
+      return jQuery['default']();
+    },
 
-      /**
-        Returns a jQuery object for this view's element. If you pass in a selector
-        string, this method will return a jQuery object, using the current element
-        as its buffer.
+    // when a view is rendered in a buffer, rerendering it simply
+    // replaces the existing buffer with a new one
+    rerender: function(view) {
+      throw new EmberError['default']("Something you did caused a view to re-render after it rendered but before it was inserted into the DOM.");
+    },
 
-        For example, calling `view.$('li')` will return a jQuery object containing
-        all of the `li` elements inside the DOM element of this view.
+    // when a view is rendered in a buffer, appending a child
+    // view will render that view and append the resulting
+    // buffer into its buffer.
+    appendChild: function(view, childView, options) {
+      var buffer = view.buffer;
+      var _childViews = view._childViews;
 
-        @method $
-        @param {String} [selector] a jQuery-compatible selector string
-        @return {jQuery} the jQuery object for the DOM node
-      */
-      $: function(sel) {
-        return this.currentState.$(this, sel);
-      },
+      childView = view.createChildView(childView, options);
+      if (!_childViews.length) { _childViews = view._childViews = _childViews.slice(); }
+      _childViews.push(childView);
 
-      mutateChildViews: function(callback) {
-        var childViews = this._childViews;
-        var idx = childViews.length;
-        var view;
+      if (!childView._morph) {
+        buffer.pushChildView(childView);
+      }
 
-        while(--idx >= 0) {
-          view = childViews[idx];
-          callback(this, view, idx);
-        }
+      view.propertyDidChange('childViews');
 
-        return this;
-      },
+      return childView;
+    },
 
-      forEachChildView: function(callback) {
-        var childViews = this._childViews;
+    appendAttr: function(view, attrNode) {
+      var buffer = view.buffer;
+      var _childViews = view._childViews;
 
-        if (!childViews) { return this; }
+      if (!_childViews.length) { _childViews = view._childViews = _childViews.slice(); }
+      _childViews.push(attrNode);
 
-        var len = childViews.length;
-        var view, idx;
+      if (!attrNode._morph) {
+        Ember.assert("bound attributes that do not have a morph must have a buffer", !!buffer);
+        buffer.pushAttrNode(attrNode);
+      }
 
-        for (idx = 0; idx < len; idx++) {
-          view = childViews[idx];
-          callback(view);
-        }
+      view.propertyDidChange('childViews');
 
-        return this;
-      },
+      return attrNode;
+    },
 
-      /**
-        Appends the view's element to the specified parent element.
+    invokeObserver: function(target, observer) {
+      observer.call(target);
+    }
+  });
 
-        If the view does not have an HTML representation yet, `createElement()`
-        will be called automatically.
+  exports['default'] = inBuffer;
 
-        Note that this method just schedules the view to be appended; the DOM
-        element will not be appended to the given element until all bindings have
-        finished synchronizing.
+});
+enifed('ember-views/views/states/in_dom', ['exports', 'ember-metal/core', 'ember-metal/platform/create', 'ember-metal/merge', 'ember-metal/error', 'ember-metal/observer', 'ember-views/views/states/has_element'], function (exports, Ember, create, merge, EmberError, observer, hasElement) {
 
-        This is not typically a function that you will need to call directly when
-        building your application. You might consider using `Ember.ContainerView`
-        instead. If you do need to use `appendTo`, be sure that the target element
-        you are providing is associated with an `Ember.Application` and does not
-        have an ancestor element that is associated with an Ember view.
+  'use strict';
 
-        @method appendTo
-        @param {String|DOMElement|jQuery} A selector, element, HTML string, or jQuery object
-        @return {Ember.View} receiver
-      */
-      appendTo: function(selector) {
-        var target = jQuery(selector);
+  var inDOM = create['default'](hasElement['default']);
 
-        Ember.assert("You tried to append to (" + selector + ") but that isn't in the DOM", target.length > 0);
-        Ember.assert("You cannot append to an existing Ember.View. Consider using Ember.ContainerView instead.", !target.is('.ember-view') && !target.parents().is('.ember-view'));
+  var View;
 
-        this.constructor.renderer.appendTo(this, target[0]);
+  merge['default'](inDOM, {
+    enter: function(view) {
+      if (!View) { View = requireModule('ember-views/views/view')["default"]; } // ES6TODO: this sucks. Have to avoid cycles...
 
-        return this;
-      },
+      // Register the view for event handling. This hash is used by
+      // Ember.EventDispatcher to dispatch incoming events.
+      if (!view.isVirtual) {
+        Ember['default'].assert("Attempted to register a view with an id already in use: "+view.elementId, !View.views[view.elementId]);
+        View.views[view.elementId] = view;
+      }
 
-      /**
-        Replaces the content of the specified parent element with this view's
-        element. If the view does not have an HTML representation yet,
-        the element will be generated automatically.
+      Ember['default'].runInDebug(function() {
+        observer.addBeforeObserver(view, 'elementId', function() {
+          throw new EmberError['default']("Changing a view's elementId after creation is not allowed");
+        });
+      });
+    },
 
-        Note that this method just schedules the view to be appended; the DOM
-        element will not be appended to the given element until all bindings have
-        finished synchronizing
+    exit: function(view) {
+      if (!View) { View = requireModule('ember-views/views/view')["default"]; } // ES6TODO: this sucks. Have to avoid cycles...
 
-        @method replaceIn
-        @param {String|DOMElement|jQuery} target A selector, element, HTML string, or jQuery object
-        @return {Ember.View} received
-      */
-      replaceIn: function(selector) {
-        var target = jQuery(selector);
+      if (!this.isVirtual) {
+        delete View.views[view.elementId];
+      }
+    },
 
-        Ember.assert("You tried to replace in (" + selector + ") but that isn't in the DOM", target.length > 0);
-        Ember.assert("You cannot replace an existing Ember.View. Consider using Ember.ContainerView instead.", !target.is('.ember-view') && !target.parents().is('.ember-view'));
+    appendAttr: function(view, attrNode) {
+      var _childViews = view._childViews;
 
-        this.constructor.renderer.replaceIn(this, target[0]);
+      if (!_childViews.length) { _childViews = view._childViews = _childViews.slice(); }
+      _childViews.push(attrNode);
 
-        return this;
-      },
+      attrNode._parentView = view;
+      view.renderer.appendAttrTo(attrNode, view.element, attrNode.attrName);
 
-      /**
-        Appends the view's element to the document body. If the view does
-        not have an HTML representation yet
-        the element will be generated automatically.
+      view.propertyDidChange('childViews');
 
-        If your application uses the `rootElement` property, you must append
-        the view within that element. Rendering views outside of the `rootElement`
-        is not supported.
+      return attrNode;
+    }
 
-        Note that this method just schedules the view to be appended; the DOM
-        element will not be appended to the document body until all bindings have
-        finished synchronizing.
+  });
 
-        @method append
-        @return {Ember.View} receiver
-      */
-      append: function() {
-        return this.appendTo(document.body);
-      },
+  exports['default'] = inDOM;
 
-      /**
-        Removes the view's element from the element to which it is attached.
+});
+enifed('ember-views/views/states/pre_render', ['exports', 'ember-views/views/states/default', 'ember-metal/platform/create'], function (exports, _default, create) {
 
-        @method remove
-        @return {Ember.View} receiver
-      */
-      remove: function() {
-        // What we should really do here is wait until the end of the run loop
-        // to determine if the element has been re-appended to a different
-        // element.
-        // In the interim, we will just re-render if that happens. It is more
-        // important than elements get garbage collected.
-        if (!this.removedFromDOM) { this.destroyElement(); }
-      },
+	'use strict';
 
-      /**
-        The HTML `id` of the view's element in the DOM. You can provide this
-        value yourself but it must be unique (just as in HTML):
+	var preRender = create['default'](_default['default']);
 
-        ```handlebars
-          {{my-component elementId="a-really-cool-id"}}
-        ```
+	exports['default'] = preRender;
 
-        If not manually set a default value will be provided by the framework.
+});
+enifed('ember-views/views/text_area', ['exports', 'ember-metal/property_get', 'ember-views/views/component', 'ember-views/mixins/text_support', 'ember-metal/mixin'], function (exports, property_get, Component, TextSupport, mixin) {
 
-        Once rendered an element's `elementId` is considered immutable and you
-        should never change it.
+  'use strict';
 
-        @property elementId
-        @type String
-      */
-      elementId: null,
 
-      /**
-        Attempts to discover the element in the parent element. The default
-        implementation looks for an element with an ID of `elementId` (or the
-        view's guid if `elementId` is null). You can override this method to
-        provide your own form of lookup. For example, if you want to discover your
-        element using a CSS class name instead of an ID.
-
-        @method findElementInParentElement
-        @param {DOMElement} parentElement The parent's DOM element
-        @return {DOMElement} The discovered element
-      */
-      findElementInParentElement: function(parentElem) {
-        var id = "#" + this.elementId;
-        return jQuery(id)[0] || jQuery(id, parentElem)[0];
-      },
+  /**
+  @module ember
+  @submodule ember-views
+  */
+  exports['default'] = Component['default'].extend(TextSupport['default'], {
+    instrumentDisplay: '{{textarea}}',
 
-      /**
-        Creates a DOM representation of the view and all of its child views by
-        recursively calling the `render()` method.
+    classNames: ['ember-text-area'],
 
-        After the element has been inserted into the DOM, `didInsertElement` will
-        be called on this view and all of its child views.
+    tagName: "textarea",
+    attributeBindings: [
+      'rows',
+      'cols',
+      'name',
+      'selectionEnd',
+      'selectionStart',
+      'wrap',
+      'lang',
+      'dir'
+    ],
+    rows: null,
+    cols: null,
+
+    _updateElementValue: mixin.observer('value', function() {
+      // We do this check so cursor position doesn't get affected in IE
+      var value = property_get.get(this, 'value');
+      var $el = this.$();
+      if ($el && value !== $el.val()) {
+        $el.val(value);
+      }
+    }),
+
+    init: function() {
+      this._super.apply(this, arguments);
+      this.on("didInsertElement", this, this._updateElementValue);
+    }
+  });
+
+});
+enifed('ember-views/views/text_field', ['exports', 'ember-views/views/component', 'ember-views/mixins/text_support'], function (exports, Component, TextSupport) {
+
+  'use strict';
+
+  /**
+  @module ember
+  @submodule ember-views
+  */
+  exports['default'] = Component['default'].extend(TextSupport['default'], {
+    instrumentDisplay: '{{input type="text"}}',
+
+    classNames: ['ember-text-field'],
+    tagName: "input",
+    attributeBindings: [
+      'accept',
+      'autocomplete',
+      'autosave',
+      'dir',
+      'formaction',
+      'formenctype',
+      'formmethod',
+      'formnovalidate',
+      'formtarget',
+      'height',
+      'inputmode',
+      'lang',
+      'list',
+      'max',
+      'min',
+      'multiple',
+      'name',
+      'pattern',
+      'size',
+      'step',
+      'type',
+      'value',
+      'width'
+    ],
 
-        @method createElement
-        @return {Ember.View} receiver
-      */
-      createElement: function() {
-        if (this.element) { return this; }
+    defaultLayout: null,
 
-        this._didCreateElementWithoutMorph = true;
-        this.constructor.renderer.renderTree(this);
+    /**
+      The `value` attribute of the input element. As the user inputs text, this
+      property is updated live.
 
-        return this;
-      },
+      @property value
+      @type String
+      @default ""
+    */
+    value: "",
 
-      /**
-        Called when a view is going to insert an element into the DOM.
+    /**
+      The `type` attribute of the input element.
 
-        @event willInsertElement
-      */
-      willInsertElement: K,
+      @property type
+      @type String
+      @default "text"
+    */
+    type: "text",
 
-      /**
-        Called when the element of the view has been inserted into the DOM
-        or after the view was re-rendered. Override this function to do any
-        set up that requires an element in the document body.
+    /**
+      The `size` of the text field in characters.
 
-        When a view has children, didInsertElement will be called on the
-        child view(s) first, bubbling upwards through the hierarchy.
+      @property size
+      @type String
+      @default null
+    */
+    size: null,
 
-        @event didInsertElement
-      */
-      didInsertElement: K,
+    /**
+      The `pattern` attribute of input element.
 
-      /**
-        Called when the view is about to rerender, but before anything has
-        been torn down. This is a good opportunity to tear down any manual
-        observers you have installed based on the DOM state
+      @property pattern
+      @type String
+      @default null
+    */
+    pattern: null,
 
-        @event willClearRender
-      */
-      willClearRender: K,
+    /**
+      The `min` attribute of input element used with `type="number"` or `type="range"`.
 
-      /**
-        Destroys any existing element along with the element for any child views
-        as well. If the view does not currently have a element, then this method
-        will do nothing.
+      @property min
+      @type String
+      @default null
+      @since 1.4.0
+    */
+    min: null,
 
-        If you implement `willDestroyElement()` on your view, then this method will
-        be invoked on your view before your element is destroyed to give you a
-        chance to clean up any event handlers, etc.
+    /**
+      The `max` attribute of input element used with `type="number"` or `type="range"`.
 
-        If you write a `willDestroyElement()` handler, you can assume that your
-        `didInsertElement()` handler was called earlier for the same element.
+      @property max
+      @type String
+      @default null
+      @since 1.4.0
+    */
+    max: null
+  });
 
-        You should not call or override this method yourself, but you may
-        want to implement the above callbacks.
+});
+enifed('ember-views/views/view', ['exports', 'ember-metal/core', 'ember-runtime/mixins/evented', 'ember-runtime/system/object', 'ember-metal/error', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-metal/observer', 'ember-metal/utils', 'ember-metal/computed', 'ember-metal/mixin', 'ember-metal/deprecate_property', 'ember-metal/property_events', 'ember-views/system/jquery', 'ember-views/system/ext', 'ember-views/views/core_view', 'ember-views/mixins/view_stream_support', 'ember-views/mixins/view_keyword_support', 'ember-views/mixins/view_context_support', 'ember-views/mixins/view_child_views_support', 'ember-views/mixins/view_state_support', 'ember-views/mixins/template_rendering_support', 'ember-views/mixins/class_names_support', 'ember-views/mixins/attribute_bindings_support', 'ember-views/mixins/legacy_view_support', 'ember-views/mixins/instrumentation_support', 'ember-views/mixins/visibility_support'], function (exports, Ember, Evented, EmberObject, EmberError, property_get, run, observer, utils, computed, mixin, deprecate_property, property_events, jQuery, __dep13__, CoreView, ViewStreamSupport, ViewKeywordSupport, ViewContextSupport, view_child_views_support, ViewStateSupport, TemplateRenderingSupport, ClassNamesSupport, AttributeBindingsSupport, LegacyViewSupport, InstrumentationSupport, VisibilitySupport) {
 
-        @method destroyElement
-        @return {Ember.View} receiver
-      */
-      destroyElement: function() {
-        return this.currentState.destroyElement(this);
-      },
+  'use strict';
 
-      /**
-        Called when the element of the view is going to be destroyed. Override
-        this function to do any teardown that requires an element, like removing
-        event listeners.
+  // Ember.assert, Ember.deprecate, Ember.warn, Ember.TEMPLATES,
+  // jQuery, Ember.lookup,
+  // Ember.ContainerView circular dependency
+  // Ember.ENV
+  function K() { return this; }
 
-        Please note: any property changes made during this event will have no
-        effect on object observers.
+  /**
+  @module ember
+  @submodule ember-views
+  */
 
-        @event willDestroyElement
-      */
-      willDestroyElement: K,
+  Ember['default'].warn("The VIEW_PRESERVES_CONTEXT flag has been removed and the functionality can no longer be disabled.", Ember['default'].ENV.VIEW_PRESERVES_CONTEXT !== false);
 
-      /**
-        Called when the parentView property has changed.
+  /**
+    Global hash of shared templates. This will automatically be populated
+    by the build tools so that you can store your Handlebars templates in
+    separate files that get loaded into JavaScript at buildtime.
 
-        @event parentViewDidChange
-      */
-      parentViewDidChange: K,
+    @property TEMPLATES
+    @for Ember
+    @type Hash
+  */
+  Ember['default'].TEMPLATES = {};
 
-      instrumentName: 'view',
+  var EMPTY_ARRAY = [];
 
-      instrumentDetails: function(hash) {
-        hash.template = get(this, 'templateName');
-        this._super(hash);
-      },
+  /**
+    `Ember.View` is the class in Ember responsible for encapsulating templates of
+    HTML content, combining templates with data to render as sections of a page's
+    DOM, and registering and responding to user-initiated events.
 
-      beforeRender: function(buffer) {},
+    ## HTML Tag
 
-      afterRender: function(buffer) {},
+    The default HTML tag name used for a view's DOM representation is `div`. This
+    can be customized by setting the `tagName` property. The following view
+    class:
 
-      applyAttributesToBuffer: function(buffer) {
-        // Creates observers for all registered class name and attribute bindings,
-        // then adds them to the element.
-        var classNameBindings = this.classNameBindings;
-        if (classNameBindings.length) {
-          this._applyClassNameBindings(classNameBindings);
-        }
+    ```javascript
+    ParagraphView = Ember.View.extend({
+      tagName: 'em'
+    });
+    ```
 
-        // Pass the render buffer so the method can apply attributes directly.
-        // This isn't needed for class name bindings because they use the
-        // existing classNames infrastructure.
-        var attributeBindings = this.attributeBindings;
-        if (attributeBindings.length) {
-          this._applyAttributeBindings(buffer, attributeBindings);
-        }
+    Would result in instances with the following HTML:
 
-        buffer.setClasses(this.classNames);
-        buffer.id(this.elementId);
+    ```html
+    <em id="ember1" class="ember-view"></em>
+    ```
 
-        var role = get(this, 'ariaRole');
-        if (role) {
-          buffer.attr('role', role);
-        }
+    ## HTML `class` Attribute
 
-        if (get(this, 'isVisible') === false) {
-          buffer.style('display', 'none');
-        }
-      },
+    The HTML `class` attribute of a view's tag can be set by providing a
+    `classNames` property that is set to an array of strings:
 
-      // ..........................................................
-      // STANDARD RENDER PROPERTIES
-      //
+    ```javascript
+    MyView = Ember.View.extend({
+      classNames: ['my-class', 'my-other-class']
+    });
+    ```
 
-      /**
-        Tag name for the view's outer element. The tag name is only used when an
-        element is first created. If you change the `tagName` for an element, you
-        must destroy and recreate the view element.
+    Will result in view instances with an HTML representation of:
 
-        By default, the render buffer will use a `<div>` tag for views.
+    ```html
+    <div id="ember1" class="ember-view my-class my-other-class"></div>
+    ```
 
-        @property tagName
-        @type String
-        @default null
-      */
+    `class` attribute values can also be set by providing a `classNameBindings`
+    property set to an array of properties names for the view. The return value
+    of these properties will be added as part of the value for the view's `class`
+    attribute. These properties can be computed properties:
 
-      // We leave this null by default so we can tell the difference between
-      // the default case and a user-specified tag.
-      tagName: null,
+    ```javascript
+    MyView = Ember.View.extend({
+      classNameBindings: ['propertyA', 'propertyB'],
+      propertyA: 'from-a',
+      propertyB: function() {
+        if (someLogic) { return 'from-b'; }
+      }.property()
+    });
+    ```
 
-      /**
-        The WAI-ARIA role of the control represented by this view. For example, a
-        button may have a role of type 'button', or a pane may have a role of
-        type 'alertdialog'. This property is used by assistive software to help
-        visually challenged users navigate rich web applications.
+    Will result in view instances with an HTML representation of:
 
-        The full list of valid WAI-ARIA roles is available at:
-        [http://www.w3.org/TR/wai-aria/roles#roles_categorization](http://www.w3.org/TR/wai-aria/roles#roles_categorization)
+    ```html
+    <div id="ember1" class="ember-view from-a from-b"></div>
+    ```
 
-        @property ariaRole
-        @type String
-        @default null
-      */
-      ariaRole: null,
+    If the value of a class name binding returns a boolean the property name
+    itself will be used as the class name if the property is true. The class name
+    will not be added if the value is `false` or `undefined`.
 
-      /**
-        Standard CSS class names to apply to the view's outer element. This
-        property automatically inherits any class names defined by the view's
-        superclasses as well.
+    ```javascript
+    MyView = Ember.View.extend({
+      classNameBindings: ['hovered'],
+      hovered: true
+    });
+    ```
 
-        @property classNames
-        @type Array
-        @default ['ember-view']
-      */
-      classNames: ['ember-view'],
+    Will result in view instances with an HTML representation of:
 
-      /**
-        A list of properties of the view to apply as class names. If the property
-        is a string value, the value of that string will be applied as a class
-        name.
+    ```html
+    <div id="ember1" class="ember-view hovered"></div>
+    ```
 
-        ```javascript
-        // Applies the 'high' class to the view element
-        Ember.View.extend({
-          classNameBindings: ['priority']
-          priority: 'high'
-        });
-        ```
+    When using boolean class name bindings you can supply a string value other
+    than the property name for use as the `class` HTML attribute by appending the
+    preferred value after a ":" character when defining the binding:
 
-        If the value of the property is a Boolean, the name of that property is
-        added as a dasherized class name.
+    ```javascript
+    MyView = Ember.View.extend({
+      classNameBindings: ['awesome:so-very-cool'],
+      awesome: true
+    });
+    ```
 
-        ```javascript
-        // Applies the 'is-urgent' class to the view element
-        Ember.View.extend({
-          classNameBindings: ['isUrgent']
-          isUrgent: true
-        });
-        ```
+    Will result in view instances with an HTML representation of:
 
-        If you would prefer to use a custom value instead of the dasherized
-        property name, you can pass a binding like this:
+    ```html
+    <div id="ember1" class="ember-view so-very-cool"></div>
+    ```
 
-        ```javascript
-        // Applies the 'urgent' class to the view element
-        Ember.View.extend({
-          classNameBindings: ['isUrgent:urgent']
-          isUrgent: true
-        });
-        ```
+    Boolean value class name bindings whose property names are in a
+    camelCase-style format will be converted to a dasherized format:
 
-        This list of properties is inherited from the view's superclasses as well.
+    ```javascript
+    MyView = Ember.View.extend({
+      classNameBindings: ['isUrgent'],
+      isUrgent: true
+    });
+    ```
 
-        @property classNameBindings
-        @type Array
-        @default []
-      */
-      classNameBindings: EMPTY_ARRAY,
+    Will result in view instances with an HTML representation of:
 
-      /**
-        A list of properties of the view to apply as attributes. If the property is
-        a string value, the value of that string will be applied as the attribute.
+    ```html
+    <div id="ember1" class="ember-view is-urgent"></div>
+    ```
 
-        ```javascript
-        // Applies the type attribute to the element
-        // with the value "button", like <div type="button">
-        Ember.View.extend({
-          attributeBindings: ['type'],
-          type: 'button'
-        });
-        ```
+    Class name bindings can also refer to object values that are found by
+    traversing a path relative to the view itself:
 
-        If the value of the property is a Boolean, the name of that property is
-        added as an attribute.
+    ```javascript
+    MyView = Ember.View.extend({
+      classNameBindings: ['messages.empty']
+      messages: Ember.Object.create({
+        empty: true
+      })
+    });
+    ```
 
-        ```javascript
-        // Renders something like <div enabled="enabled">
-        Ember.View.extend({
-          attributeBindings: ['enabled'],
-          enabled: true
-        });
-        ```
+    Will result in view instances with an HTML representation of:
 
-        @property attributeBindings
-      */
-      attributeBindings: EMPTY_ARRAY,
+    ```html
+    <div id="ember1" class="ember-view empty"></div>
+    ```
 
-      // .......................................................
-      // CORE DISPLAY METHODS
-      //
+    If you want to add a class name for a property which evaluates to true and
+    and a different class name if it evaluates to false, you can pass a binding
+    like this:
 
-      /**
-        Setup a view, but do not finish waking it up.
+    ```javascript
+    // Applies 'enabled' class when isEnabled is true and 'disabled' when isEnabled is false
+    Ember.View.extend({
+      classNameBindings: ['isEnabled:enabled:disabled']
+      isEnabled: true
+    });
+    ```
 
-        * configure `childViews`
-        * register the view with the global views hash, which is used for event
-          dispatch
+    Will result in view instances with an HTML representation of:
 
-        @method init
-        @private
-      */
-      init: function() {
-        if (!this.isVirtual && !this.elementId) {
-          this.elementId = guidFor(this);
-        }
+    ```html
+    <div id="ember1" class="ember-view enabled"></div>
+    ```
 
-        this._super();
+    When isEnabled is `false`, the resulting HTML representation looks like
+    this:
 
-        // setup child views. be sure to clone the child views array first
-        this._childViews = this._childViews.slice();
-        this._baseContext = undefined;
-        this._contextStream = undefined;
-        this._streamBindings = undefined;
+    ```html
+    <div id="ember1" class="ember-view disabled"></div>
+    ```
 
-        if (!this._keywords) {
-          this._keywords = create(null);
-        }
-        this._keywords._view = this;
-        this._keywords.view = undefined;
-        this._keywords.controller = new KeyStream(this, 'controller');
-        this._setupKeywords();
+    This syntax offers the convenience to add a class if a property is `false`:
 
-        Ember.assert("Only arrays are allowed for 'classNameBindings'", typeOf(this.classNameBindings) === 'array');
-        this.classNameBindings = emberA(this.classNameBindings.slice());
+    ```javascript
+    // Applies no class when isEnabled is true and class 'disabled' when isEnabled is false
+    Ember.View.extend({
+      classNameBindings: ['isEnabled::disabled']
+      isEnabled: true
+    });
+    ```
 
-        Ember.assert("Only arrays of static class strings are allowed for 'classNames'. For dynamic classes, use 'classNameBindings'.", typeOf(this.classNames) === 'array');
-        this.classNames = emberA(this.classNames.slice());
-      },
+    Will result in view instances with an HTML representation of:
 
-      appendChild: function(view, options) {
-        return this.currentState.appendChild(this, view, options);
-      },
+    ```html
+    <div id="ember1" class="ember-view"></div>
+    ```
 
-      /**
-        Removes the child view from the parent view.
+    When the `isEnabled` property on the view is set to `false`, it will result
+    in view instances with an HTML representation of:
 
-        @method removeChild
-        @param {Ember.View} view
-        @return {Ember.View} receiver
-      */
-      removeChild: function(view) {
-        // If we're destroying, the entire subtree will be
-        // freed, and the DOM will be handled separately,
-        // so no need to mess with childViews.
-        if (this.isDestroying) { return; }
+    ```html
+    <div id="ember1" class="ember-view disabled"></div>
+    ```
 
-        // update parent node
-        set(view, '_parentView', null);
+    Updates to the the value of a class name binding will result in automatic
+    update of the  HTML `class` attribute in the view's rendered HTML
+    representation. If the value becomes `false` or `undefined` the class name
+    will be removed.
 
-        // remove view from childViews array.
-        var childViews = this._childViews;
+    Both `classNames` and `classNameBindings` are concatenated properties. See
+    [Ember.Object](/api/classes/Ember.Object.html) documentation for more
+    information about concatenated properties.
 
-        removeObject(childViews, view);
+    ## HTML Attributes
 
-        this.propertyDidChange('childViews'); // HUH?! what happened to will change?
+    The HTML attribute section of a view's tag can be set by providing an
+    `attributeBindings` property set to an array of property names on the view.
+    The return value of these properties will be used as the value of the view's
+    HTML associated attribute:
 
-        return this;
-      },
+    ```javascript
+    AnchorView = Ember.View.extend({
+      tagName: 'a',
+      attributeBindings: ['href'],
+      href: 'http://google.com'
+    });
+    ```
 
-      /**
-        Removes all children from the `parentView`.
+    Will result in view instances with an HTML representation of:
 
-        @method removeAllChildren
-        @return {Ember.View} receiver
-      */
-      removeAllChildren: function() {
-        return this.mutateChildViews(function(parentView, view) {
-          parentView.removeChild(view);
-        });
-      },
+    ```html
+    <a id="ember1" class="ember-view" href="http://google.com"></a>
+    ```
 
-      destroyAllChildren: function() {
-        return this.mutateChildViews(function(parentView, view) {
-          view.destroy();
-        });
-      },
+    One property can be mapped on to another by placing a ":" between
+    the source property and the destination property:
 
-      /**
-        Removes the view from its `parentView`, if one is found. Otherwise
-        does nothing.
+    ```javascript
+    AnchorView = Ember.View.extend({
+      tagName: 'a',
+      attributeBindings: ['url:href'],
+      url: 'http://google.com'
+    });
+    ```
 
-        @method removeFromParent
-        @return {Ember.View} receiver
-      */
-      removeFromParent: function() {
-        var parent = this._parentView;
+    Will result in view instances with an HTML representation of:
 
-        // Remove DOM element from parent
-        this.remove();
+    ```html
+    <a id="ember1" class="ember-view" href="http://google.com"></a>
+    ```
 
-        if (parent) { parent.removeChild(this); }
-        return this;
-      },
+    Namespaced attributes (e.g. `xlink:href`) are supported, but have to be
+    mapped, since `:` is not a valid character for properties in Javascript:
 
-      /**
-        You must call `destroy` on a view to destroy the view (and all of its
-        child views). This will remove the view from any parent node, then make
-        sure that the DOM element managed by the view can be released by the
-        memory manager.
+    ```javascript
+    UseView = Ember.View.extend({
+      tagName: 'use',
+      attributeBindings: ['xlinkHref:xlink:href'],
+      xlinkHref: '#triangle'
+    });
+    ```
+    Will result in view instances with an HTML representation of:
 
-        @method destroy
-      */
-      destroy: function() {
-        // get parentView before calling super because it'll be destroyed
-        var nonVirtualParentView = get(this, 'parentView');
-        var viewName = this.viewName;
+    ```html
+    <use xlink:href="#triangle"></use>
+    ```
 
-        if (!this._super()) { return; }
+    If the return value of an `attributeBindings` monitored property is a boolean
+    the property will follow HTML's pattern of repeating the attribute's name as
+    its value:
 
-        // remove from non-virtual parent view if viewName was specified
-        if (viewName && nonVirtualParentView) {
-          nonVirtualParentView.set(viewName, null);
-        }
+    ```javascript
+    MyTextInput = Ember.View.extend({
+      tagName: 'input',
+      attributeBindings: ['disabled'],
+      disabled: true
+    });
+    ```
 
-        return this;
-      },
+    Will result in view instances with an HTML representation of:
 
-      /**
-        Instantiates a view to be added to the childViews array during view
-        initialization. You generally will not call this method directly unless
-        you are overriding `createChildViews()`. Note that this method will
-        automatically configure the correct settings on the new view instance to
-        act as a child of the parent.
-
-        @method createChildView
-        @param {Class|String} viewClass
-        @param {Hash} [attrs] Attributes to add
-        @return {Ember.View} new instance
-      */
-      createChildView: function(view, attrs) {
-        if (!view) {
-          throw new TypeError("createChildViews first argument must exist");
-        }
+    ```html
+    <input id="ember1" class="ember-view" disabled="disabled" />
+    ```
+
+    `attributeBindings` can refer to computed properties:
 
-        if (view.isView && view._parentView === this && view.container === this.container) {
-          return view;
+    ```javascript
+    MyTextInput = Ember.View.extend({
+      tagName: 'input',
+      attributeBindings: ['disabled'],
+      disabled: function() {
+        if (someLogic) {
+          return true;
+        } else {
+          return false;
         }
+      }.property()
+    });
+    ```
 
-        attrs = attrs || {};
-        attrs._parentView = this;
-
-        if (CoreView.detect(view)) {
-          attrs.container = this.container;
-          view = view.create(attrs);
-
-          // don't set the property on a virtual view, as they are invisible to
-          // consumers of the view API
-          if (view.viewName) {
-            set(get(this, 'concreteView'), view.viewName, view);
-          }
-        } else if ('string' === typeof view) {
-          var fullName = 'view:' + view;
-          var ViewKlass = this.container.lookupFactory(fullName);
-
-          Ember.assert("Could not find view: '" + fullName + "'", !!ViewKlass);
+    Updates to the the property of an attribute binding will result in automatic
+    update of the  HTML attribute in the view's rendered HTML representation.
 
-          view = ViewKlass.create(attrs);
-        } else {
-          Ember.assert('You must pass instance or subclass of View', view.isView);
+    `attributeBindings` is a concatenated property. See [Ember.Object](/api/classes/Ember.Object.html)
+    documentation for more information about concatenated properties.
 
-          attrs.container = this.container;
-          setProperties(view, attrs);
-        }
+    ## Templates
 
-        return view;
-      },
+    The HTML contents of a view's rendered representation are determined by its
+    template. Templates can be any function that accepts an optional context
+    parameter and returns a string of HTML that will be inserted within the
+    view's tag. Most typically in Ember this function will be a compiled
+    `Ember.Handlebars` template.
 
-      becameVisible: K,
-      becameHidden: K,
+    ```javascript
+    AView = Ember.View.extend({
+      template: Ember.Handlebars.compile('I am the template')
+    });
+    ```
 
-      /**
-        When the view's `isVisible` property changes, toggle the visibility
-        element of the actual DOM element.
+    Will result in view instances with an HTML representation of:
 
-        @method _isVisibleDidChange
-        @private
-      */
-      _isVisibleDidChange: observer('isVisible', function() {
-        if (this._isVisible === get(this, 'isVisible')) { return ; }
-        run.scheduleOnce('render', this, this._toggleVisibility);
-      }),
+    ```html
+    <div id="ember1" class="ember-view">I am the template</div>
+    ```
 
-      _toggleVisibility: function() {
-        var $el = this.$();
-        var isVisible = get(this, 'isVisible');
+    Within an Ember application is more common to define a Handlebars templates as
+    part of a page:
 
-        if (this._isVisible === isVisible) { return ; }
+    ```html
+    <script type='text/x-handlebars' data-template-name='some-template'>
+      Hello
+    </script>
+    ```
 
-        // It's important to keep these in sync, even if we don't yet have
-        // an element in the DOM to manipulate:
-        this._isVisible = isVisible;
+    And associate it by name using a view's `templateName` property:
 
-        if (!$el) { return; }
+    ```javascript
+    AView = Ember.View.extend({
+      templateName: 'some-template'
+    });
+    ```
 
-        $el.toggle(isVisible);
+    If you have nested resources, your Handlebars template will look like this:
 
-        if (this._isAncestorHidden()) { return; }
+    ```html
+    <script type='text/x-handlebars' data-template-name='posts/new'>
+      <h1>New Post</h1>
+    </script>
+    ```
 
-        if (isVisible) {
-          this._notifyBecameVisible();
-        } else {
-          this._notifyBecameHidden();
-        }
-      },
+    And `templateName` property:
 
-      _notifyBecameVisible: function() {
-        this.trigger('becameVisible');
+    ```javascript
+    AView = Ember.View.extend({
+      templateName: 'posts/new'
+    });
+    ```
 
-        this.forEachChildView(function(view) {
-          var isVisible = get(view, 'isVisible');
+    Using a value for `templateName` that does not have a Handlebars template
+    with a matching `data-template-name` attribute will throw an error.
 
-          if (isVisible || isVisible === null) {
-            view._notifyBecameVisible();
-          }
-        });
-      },
+    For views classes that may have a template later defined (e.g. as the block
+    portion of a `{{view}}` Handlebars helper call in another template or in
+    a subclass), you can provide a `defaultTemplate` property set to compiled
+    template function. If a template is not later provided for the view instance
+    the `defaultTemplate` value will be used:
 
-      _notifyBecameHidden: function() {
-        this.trigger('becameHidden');
-        this.forEachChildView(function(view) {
-          var isVisible = get(view, 'isVisible');
+    ```javascript
+    AView = Ember.View.extend({
+      defaultTemplate: Ember.Handlebars.compile('I was the default'),
+      template: null,
+      templateName: null
+    });
+    ```
 
-          if (isVisible || isVisible === null) {
-            view._notifyBecameHidden();
-          }
-        });
-      },
+    Will result in instances with an HTML representation of:
 
-      _isAncestorHidden: function() {
-        var parent = get(this, 'parentView');
+    ```html
+    <div id="ember1" class="ember-view">I was the default</div>
+    ```
 
-        while (parent) {
-          if (get(parent, 'isVisible') === false) { return true; }
+    If a `template` or `templateName` is provided it will take precedence over
+    `defaultTemplate`:
 
-          parent = get(parent, 'parentView');
-        }
+    ```javascript
+    AView = Ember.View.extend({
+      defaultTemplate: Ember.Handlebars.compile('I was the default')
+    });
 
-        return false;
-      },
-      transitionTo: function(state, children) {
-        Ember.deprecate("Ember.View#transitionTo has been deprecated, it is for internal use only");
-        this._transitionTo(state, children);
-      },
-      _transitionTo: function(state, children) {
-        var priorState = this.currentState;
-        var currentState = this.currentState = this._states[state];
-        this._state = state;
+    aView = AView.create({
+      template: Ember.Handlebars.compile('I was the template, not default')
+    });
+    ```
 
-        if (priorState && priorState.exit) { priorState.exit(this); }
-        if (currentState.enter) { currentState.enter(this); }
-      },
+    Will result in the following HTML representation when rendered:
 
-      // .......................................................
-      // EVENT HANDLING
-      //
+    ```html
+    <div id="ember1" class="ember-view">I was the template, not default</div>
+    ```
 
-      /**
-        Handle events from `Ember.EventDispatcher`
+    ## View Context
 
-        @method handleEvent
-        @param eventName {String}
-        @param evt {Event}
-        @private
-      */
-      handleEvent: function(eventName, evt) {
-        return this.currentState.handleEvent(this, eventName, evt);
-      },
+    The default context of the compiled template is the view's controller:
 
-      registerObserver: function(root, path, target, observer) {
-        if (!observer && 'function' === typeof target) {
-          observer = target;
-          target = null;
-        }
+    ```javascript
+    AView = Ember.View.extend({
+      template: Ember.Handlebars.compile('Hello {{excitedGreeting}}')
+    });
 
-        if (!root || typeof root !== 'object') {
-          return;
-        }
+    aController = Ember.Object.create({
+      firstName: 'Barry',
+      excitedGreeting: function() {
+        return this.get("content.firstName") + "!!!"
+      }.property()
+    });
 
-        var scheduledObserver = this._wrapAsScheduled(observer);
+    aView = AView.create({
+      controller: aController
+    });
+    ```
 
-        addObserver(root, path, target, scheduledObserver);
+    Will result in an HTML representation of:
 
-        this.one('willClearRender', function() {
-          removeObserver(root, path, target, scheduledObserver);
-        });
-      },
+    ```html
+    <div id="ember1" class="ember-view">Hello Barry!!!</div>
+    ```
 
-      _wrapAsScheduled: function(fn) {
-        var view = this;
-        var stateCheckedFn = function() {
-          view.currentState.invokeObserver(this, fn);
-        };
-        var scheduledFn = function() {
-          run.scheduleOnce('render', this, stateCheckedFn);
-        };
-        return scheduledFn;
-      },
+    A context can also be explicitly supplied through the view's `context`
+    property. If the view has neither `context` nor `controller` properties, the
+    `parentView`'s context will be used.
 
-      getStream: function(path) {
-        var stream = this._getContextStream().get(path);
+    ## Layouts
 
-        stream._label = path;
+    Views can have a secondary template that wraps their main template. Like
+    primary templates, layouts can be any function that  accepts an optional
+    context parameter and returns a string of HTML that will be inserted inside
+    view's tag. Views whose HTML element is self closing (e.g. `<input />`)
+    cannot have a layout and this property will be ignored.
 
-        return stream;
-      },
+    Most typically in Ember a layout will be a compiled `Ember.Handlebars`
+    template.
 
-      _getBindingForStream: function(pathOrStream) {
-        if (this._streamBindings === undefined) {
-          this._streamBindings = create(null);
-          this.one('willDestroyElement', this, this._destroyStreamBindings);
-        }
+    A view's layout can be set directly with the `layout` property or reference
+    an existing Handlebars template by name with the `layoutName` property.
 
-        var path = pathOrStream;
-        if (isStream(pathOrStream)) {
-          path = pathOrStream._label;
+    A template used as a layout must contain a single use of the Handlebars
+    `{{yield}}` helper. The HTML contents of a view's rendered `template` will be
+    inserted at this location:
 
-          if (!path) {
-            // if no _label is present on the provided stream
-            // it is likely a subexpr and cannot be set (so it
-            // does not need a StreamBinding)
-            return pathOrStream;
-          }
-        }
+    ```javascript
+    AViewWithLayout = Ember.View.extend({
+      layout: Ember.Handlebars.compile("<div class='my-decorative-class'>{{yield}}</div>"),
+      template: Ember.Handlebars.compile("I got wrapped")
+    });
+    ```
 
-        if (this._streamBindings[path] !== undefined) {
-          return this._streamBindings[path];
-        } else {
-          var stream = this._getContextStream().get(path);
-          var streamBinding = new StreamBinding(stream);
+    Will result in view instances with an HTML representation of:
 
-          streamBinding._label = path;
+    ```html
+    <div id="ember1" class="ember-view">
+      <div class="my-decorative-class">
+        I got wrapped
+      </div>
+    </div>
+    ```
 
-          return this._streamBindings[path] = streamBinding;
-        }
-      },
+    See [Ember.Handlebars.helpers.yield](/api/classes/Ember.Handlebars.helpers.html#method_yield)
+    for more information.
 
-      _destroyStreamBindings: function() {
-        var streamBindings = this._streamBindings;
-        for (var path in streamBindings) {
-          streamBindings[path].destroy();
-        }
-        this._streamBindings = undefined;
-      },
+    ## Responding to Browser Events
 
-      _getContextStream: function() {
-        if (this._contextStream === undefined) {
-          this._baseContext = new KeyStream(this, 'context');
-          this._contextStream = new ContextStream(this);
-          this.one('willDestroyElement', this, this._destroyContextStream);
-        }
+    Views can respond to user-initiated events in one of three ways: method
+    implementation, through an event manager, and through `{{action}}` helper use
+    in their template or layout.
 
-        return this._contextStream;
-      },
+    ### Method Implementation
 
-      _destroyContextStream: function() {
-        this._baseContext.destroy();
-        this._baseContext = undefined;
-        this._contextStream.destroy();
-        this._contextStream = undefined;
-      },
+    Views can respond to user-initiated events by implementing a method that
+    matches the event name. A `jQuery.Event` object will be passed as the
+    argument to this method.
 
-      _unsubscribeFromStreamBindings: function() {
-        for (var key in this._streamBindingSubscriptions) {
-          var streamBinding = this[key + 'Binding'];
-          var callback = this._streamBindingSubscriptions[key];
-          streamBinding.unsubscribe(callback);
-        }
+    ```javascript
+    AView = Ember.View.extend({
+      click: function(event) {
+        // will be called when when an instance's
+        // rendered element is clicked
       }
     });
+    ```
 
-    deprecateProperty(View.prototype, 'state', '_state');
-    deprecateProperty(View.prototype, 'states', '_states');
-
-    /*
-      Describe how the specified actions should behave in the various
-      states that a view can exist in. Possible states:
+    ### Event Managers
 
-      * preRender: when a view is first instantiated, and after its
-        element was destroyed, it is in the preRender state
-      * inBuffer: once a view has been rendered, but before it has
-        been inserted into the DOM, it is in the inBuffer state
-      * hasElement: the DOM representation of the view is created,
-        and is ready to be inserted
-      * inDOM: once a view has been inserted into the DOM it is in
-        the inDOM state. A view spends the vast majority of its
-        existence in this state.
-      * destroyed: once a view has been destroyed (using the destroy
-        method), it is in this state. No further actions can be invoked
-        on a destroyed view.
-    */
+    Views can define an object as their `eventManager` property. This object can
+    then implement methods that match the desired event names. Matching events
+    that occur on the view's rendered HTML or the rendered HTML of any of its DOM
+    descendants will trigger this method. A `jQuery.Event` object will be passed
+    as the first argument to the method and an  `Ember.View` object as the
+    second. The `Ember.View` will be the view whose rendered HTML was interacted
+    with. This may be the view with the `eventManager` property or one of its
+    descendant views.
 
-      // in the destroyed state, everything is illegal
+    ```javascript
+    AView = Ember.View.extend({
+      eventManager: Ember.Object.create({
+        doubleClick: function(event, view) {
+          // will be called when when an instance's
+          // rendered element or any rendering
+          // of this view's descendant
+          // elements is clicked
+        }
+      })
+    });
+    ```
 
-      // before rendering has begun, all legal manipulations are noops.
+    An event defined for an event manager takes precedence over events of the
+    same name handled through methods on the view.
 
-      // inside the buffer, legal manipulations are done on the buffer
+    ```javascript
+    AView = Ember.View.extend({
+      mouseEnter: function(event) {
+        // will never trigger.
+      },
+      eventManager: Ember.Object.create({
+        mouseEnter: function(event, view) {
+          // takes precedence over AView#mouseEnter
+        }
+      })
+    });
+    ```
 
-      // once the view has been inserted into the DOM, legal manipulations
-      // are done on the DOM element.
+    Similarly a view's event manager will take precedence for events of any views
+    rendered as a descendant. A method name that matches an event name will not
+    be called if the view instance was rendered inside the HTML representation of
+    a view that has an `eventManager` property defined that handles events of the
+    name. Events not handled by the event manager will still trigger method calls
+    on the descendant.
 
-    var mutation = EmberObject.extend(Evented).create();
-    // TODO MOVE TO RENDERER HOOKS
-    View.addMutationListener = function(callback) {
-      mutation.on('change', callback);
-    };
+    ```javascript
+    var App = Ember.Application.create();
+    App.OuterView = Ember.View.extend({
+      template: Ember.Handlebars.compile("outer {{#view 'inner'}}inner{{/view}} outer"),
+      eventManager: Ember.Object.create({
+        mouseEnter: function(event, view) {
+          // view might be instance of either
+          // OuterView or InnerView depending on
+          // where on the page the user interaction occurred
+        }
+      })
+    });
 
-    View.removeMutationListener = function(callback) {
-      mutation.off('change', callback);
-    };
+    App.InnerView = Ember.View.extend({
+      click: function(event) {
+        // will be called if rendered inside
+        // an OuterView because OuterView's
+        // eventManager doesn't handle click events
+      },
+      mouseEnter: function(event) {
+        // will never be called if rendered inside
+        // an OuterView.
+      }
+    });
+    ```
 
-    View.notifyMutationListeners = function() {
-      mutation.trigger('change');
-    };
+    ### Handlebars `{{action}}` Helper
 
-    /**
-      Global views hash
+    See [Handlebars.helpers.action](/api/classes/Ember.Handlebars.helpers.html#method_action).
 
-      @property views
-      @static
-      @type Hash
-    */
-    View.views = {};
-
-    // If someone overrides the child views computed property when
-    // defining their class, we want to be able to process the user's
-    // supplied childViews and then restore the original computed property
-    // at view initialization time. This happens in Ember.ContainerView's init
-    // method.
-    View.childViewsProperty = childViewsProperty;
-
-    // Used by Handlebars helpers, view element attributes
-    View.applyAttributeBindings = function(elem, name, initialValue) {
-      var value = sanitizeAttributeValue(elem[0], name, initialValue);
-      var type = typeOf(value);
-
-      // if this changes, also change the logic in ember-handlebars/lib/helpers/binding.js
-      if (name !== 'value' && (type === 'string' || (type === 'number' && !isNaN(value)))) {
-        if (value !== elem.attr(name)) {
-          elem.attr(name, value);
-        }
-      } else if (name === 'value' || type === 'boolean') {
-        if (isNone(value) || value === false) {
-          // `null`, `undefined` or `false` should remove attribute
-          elem.removeAttr(name);
-          // In IE8 `prop` couldn't remove attribute when name is `required`.
-          if (name === 'required') {
-            elem.removeProp(name);
-          } else {
-            elem.prop(name, '');
-          }
-        } else if (value !== elem.prop(name)) {
-          // value should always be properties
-          elem.prop(name, value);
-        }
-      } else if (!value) {
-        elem.removeAttr(name);
-      }
-    };
+    ### Event Names
 
-    __exports__["default"] = View;
-  });
-enifed("ember-views/views/with_view",
-  ["ember-metal/property_set","ember-metal/utils","ember-views/views/bound_view","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
+    All of the event handling approaches described above respond to the same set
+    of events. The names of the built-in events are listed below. (The hash of
+    built-in events exists in `Ember.EventDispatcher`.) Additional, custom events
+    can be registered by using `Ember.Application.customEvents`.
 
-    /**
-    @module ember
-    @submodule ember-views
-    */
+    Touch events:
 
-    var set = __dependency1__.set;
-    var apply = __dependency2__.apply;
-    var BoundView = __dependency3__["default"];
+    * `touchStart`
+    * `touchMove`
+    * `touchEnd`
+    * `touchCancel`
 
-    __exports__["default"] = BoundView.extend({
-      init: function() {
-        apply(this, this._super, arguments);
+    Keyboard events
 
-        var controllerName  = this.templateHash.controller;
+    * `keyDown`
+    * `keyUp`
+    * `keyPress`
 
-        if (controllerName) {
-          var previousContext = this.previousContext;
-          var controller = this.container.lookupFactory('controller:'+controllerName).create({
-            parentController: previousContext,
-            target: previousContext
-          });
+    Mouse events
 
-          this._generatedController = controller;
+    * `mouseDown`
+    * `mouseUp`
+    * `contextMenu`
+    * `click`
+    * `doubleClick`
+    * `mouseMove`
+    * `focusIn`
+    * `focusOut`
+    * `mouseEnter`
+    * `mouseLeave`
 
-          if (this.preserveContext) {
-            this._blockArguments = [ controller ];
-            this.lazyValue.subscribe(function(modelStream) {
-              set(controller, 'model', modelStream.value());
-            });
-          } else {
-            set(this, 'controller', controller);
-            this.valueNormalizerFunc = function(result) {
-              controller.set('model', result);
-              return controller;
-            };
-          }
+    Form events:
 
-          set(controller, 'model', this.lazyValue.value());
-        } else {
-          if (this.preserveContext) {
-            this._blockArguments = [ this.lazyValue ];
-          }
-        }
-      },
+    * `submit`
+    * `change`
+    * `focusIn`
+    * `focusOut`
+    * `input`
 
-      willDestroy: function() {
-        this._super();
+    HTML5 drag and drop events:
 
-        if (this._generatedController) {
-          this._generatedController.destroy();
-        }
-      }
-    });
-  });
-enifed("ember",
-  ["ember-metal","ember-runtime","ember-views","ember-routing","ember-application","ember-extension-support","ember-htmlbars","ember-routing-htmlbars","ember-runtime/system/lazy_load"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__) {
-    "use strict";
-    /* global navigator */
-    // require the main entry points for each of these packages
-    // this is so that the global exports occur properly
+    * `dragStart`
+    * `drag`
+    * `dragEnter`
+    * `dragLeave`
+    * `dragOver`
+    * `dragEnd`
+    * `drop`
 
-    var runLoadHooks = __dependency9__.runLoadHooks;
+    ## Handlebars `{{view}}` Helper
 
-    if (Ember.__loader.registry['ember-template-compiler']) {
-      requireModule('ember-template-compiler');
-    }
+    Other `Ember.View` instances can be included as part of a view's template by
+    using the `{{view}}` Handlebars helper. See [Ember.Handlebars.helpers.view](/api/classes/Ember.Handlebars.helpers.html#method_view)
+    for additional information.
 
-    // do this to ensure that Ember.Test is defined properly on the global
-    // if it is present.
-    if (Ember.__loader.registry['ember-testing']) {
-      requireModule('ember-testing');
-    }
+    @class View
+    @namespace Ember
+    @extends Ember.CoreView
+  */
+  // jscs:disable validateIndentation
+  var View = CoreView['default'].extend(
+    ViewStreamSupport['default'],
+    ViewKeywordSupport['default'],
+    ViewContextSupport['default'],
+    view_child_views_support["default"],
+    ViewStateSupport['default'],
+    TemplateRenderingSupport['default'],
+    ClassNamesSupport['default'],
+    AttributeBindingsSupport['default'],
+    LegacyViewSupport['default'],
+    InstrumentationSupport['default'],
+    VisibilitySupport['default'], {
+
+    /**
+      @property isView
+      @type Boolean
+      @default true
+      @static
+    */
+    isView: true,
 
-    runLoadHooks('Ember');
+    // ..........................................................
+    // TEMPLATE SUPPORT
+    //
 
     /**
-    Ember
-
-    @module ember
-    */
+      The name of the template to lookup if no template is provided.
 
-    Ember.deprecate('Usage of Ember is deprecated for Internet Explorer 6 and 7, support will be removed in the next major version.', !navigator.userAgent.match(/MSIE [67]/));
-  });
-enifed("htmlbars-util",
-  ["./htmlbars-util/safe-string","./htmlbars-util/handlebars/utils","./htmlbars-util/namespaces","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var SafeString = __dependency1__["default"];
-    var escapeExpression = __dependency2__.escapeExpression;
-    var getAttrNamespace = __dependency3__.getAttrNamespace;
+      By default `Ember.View` will lookup a template with this name in
+      `Ember.TEMPLATES` (a shared global object).
 
-    __exports__.SafeString = SafeString;
-    __exports__.escapeExpression = escapeExpression;
-    __exports__.getAttrNamespace = getAttrNamespace;
-  });
-enifed("htmlbars-util/array-utils",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    function forEach(array, callback, binding) {
-      var i, l;
-      if (binding === undefined) {
-        for (i = 0, l = array.length; i < l; i++) {
-          callback(array[i], i, array);
-        }
-      } else {
-        for (i = 0, l = array.length; i < l; i++) {
-          callback.call(binding, array[i], i, array);
-        }
-      }
-    }
+      @property templateName
+      @type String
+      @default null
+    */
+    templateName: null,
 
-    __exports__.forEach = forEach;function map(array, callback) {
-      var output = [];
-      var i, l;
+    /**
+      The name of the layout to lookup if no layout is provided.
 
-      for (i = 0, l = array.length; i < l; i++) {
-        output.push(callback(array[i], i, array));
-      }
+      By default `Ember.View` will lookup a template with this name in
+      `Ember.TEMPLATES` (a shared global object).
 
-      return output;
-    }
+      @property layoutName
+      @type String
+      @default null
+    */
+    layoutName: null,
 
-    __exports__.map = map;var getIdx;
-    if (Array.prototype.indexOf) {
-      getIdx = function(array, obj, from){
-        return array.indexOf(obj, from);
-      };
-    } else {
-      getIdx = function(array, obj, from) {
-        if (from === undefined || from === null) {
-          from = 0;
-        } else if (from < 0) {
-          from = Math.max(0, array.length + from);
-        }
-        for (var i = from, l= array.length; i < l; i++) {
-          if (array[i] === obj) {
-            return i;
-          }
-        }
-        return -1;
-      };
-    }
+    /**
+      The template used to render the view. This should be a function that
+      accepts an optional context parameter and returns a string of HTML that
+      will be inserted into the DOM relative to its parent view.
 
-    var indexOfArray = getIdx;
-    __exports__.indexOfArray = indexOfArray;
-  });
-enifed("htmlbars-util/handlebars/safe-string",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    // Build out our basic SafeString type
-    function SafeString(string) {
-      this.string = string;
-    }
+      In general, you should set the `templateName` property instead of setting
+      the template yourself.
 
-    SafeString.prototype.toString = SafeString.prototype.toHTML = function() {
-      return "" + this.string;
-    };
+      @property template
+      @type Function
+    */
+    template: computed.computed('templateName', function(key, value) {
+      if (value !== undefined) { return value; }
 
-    __exports__["default"] = SafeString;
-  });
-enifed("htmlbars-util/handlebars/utils",
-  ["./safe-string","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    /*jshint -W004 */
-    var SafeString = __dependency1__["default"];
+      var templateName = property_get.get(this, 'templateName');
+      var template = this.templateForName(templateName, 'template');
 
-    var escape = {
-      "&": "&amp;",
-      "<": "&lt;",
-      ">": "&gt;",
-      '"': "&quot;",
-      "'": "&#x27;",
-      "`": "&#x60;"
-    };
+      Ember['default'].assert("You specified the templateName " + templateName + " for " + this + ", but it did not exist.", !templateName || !!template);
 
-    var badChars = /[&<>"'`]/g;
-    var possible = /[&<>"'`]/;
+      return template || property_get.get(this, 'defaultTemplate');
+    }),
 
-    function escapeChar(chr) {
-      return escape[chr];
-    }
+    /**
+      A view may contain a layout. A layout is a regular template but
+      supersedes the `template` property during rendering. It is the
+      responsibility of the layout template to retrieve the `template`
+      property from the view (or alternatively, call `Handlebars.helpers.yield`,
+      `{{yield}}`) to render it in the correct location.
 
-    function extend(obj /* , ...source */) {
-      for (var i = 1; i < arguments.length; i++) {
-        for (var key in arguments[i]) {
-          if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
-            obj[key] = arguments[i][key];
-          }
+      This is useful for a view that has a shared wrapper, but which delegates
+      the rendering of the contents of the wrapper to the `template` property
+      on a subclass.
+
+      @property layout
+      @type Function
+    */
+    layout: computed.computed(function(key) {
+      var layoutName = property_get.get(this, 'layoutName');
+      var layout = this.templateForName(layoutName, 'layout');
+
+      Ember['default'].assert("You specified the layoutName " + layoutName + " for " + this + ", but it did not exist.", !layoutName || !!layout);
+
+      return layout || property_get.get(this, 'defaultLayout');
+    }).property('layoutName'),
+
+    _yield: function(context, options, morph) {
+      var template = property_get.get(this, 'template');
+
+      if (template) {
+        if (template.isHTMLBars) {
+          return template.render(context, options, morph.contextualElement);
+        } else {
+          return template(context, options);
         }
       }
+    },
 
-      return obj;
-    }
+    _blockArguments: EMPTY_ARRAY,
 
-    __exports__.extend = extend;var toString = Object.prototype.toString;
-    __exports__.toString = toString;
-    // Sourced from lodash
-    // https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
-    var isFunction = function(value) {
-      return typeof value === 'function';
-    };
-    // fallback for older versions of Chrome and Safari
-    /* istanbul ignore next */
-    if (isFunction(/x/)) {
-      isFunction = function(value) {
-        return typeof value === 'function' && toString.call(value) === '[object Function]';
-      };
-    }
-    var isFunction;
-    __exports__.isFunction = isFunction;
-    /* istanbul ignore next */
-    var isArray = Array.isArray || function(value) {
-      return (value && typeof value === 'object') ? toString.call(value) === '[object Array]' : false;
-    };
-    __exports__.isArray = isArray;
+    templateForName: function(name, type) {
+      if (!name) { return; }
+      Ember['default'].assert("templateNames are not allowed to contain periods: "+name, name.indexOf('.') === -1);
 
-    function escapeExpression(string) {
-      // don't escape SafeStrings, since they're already safe
-      if (string && string.toHTML) {
-        return string.toHTML();
-      } else if (string == null) {
-        return "";
-      } else if (!string) {
-        return string + '';
+      if (!this.container) {
+        throw new EmberError['default']('Container was not found when looking up a views template. ' +
+                   'This is most likely due to manually instantiating an Ember.View. ' +
+                   'See: http://git.io/EKPpnA');
       }
 
-      // Force a string conversion as this will be done by the append regardless and
-      // the regex test will do this transparently behind the scenes, causing issues if
-      // an object's to string has escaped characters in it.
-      string = "" + string;
+      return this.container.lookup('template:' + name);
+    },
 
-      if(!possible.test(string)) { return string; }
-      return string.replace(badChars, escapeChar);
-    }
+    /**
+      If a value that affects template rendering changes, the view should be
+      re-rendered to reflect the new value.
 
-    __exports__.escapeExpression = escapeExpression;function isEmpty(value) {
-      if (!value && value !== 0) {
-        return true;
-      } else if (isArray(value) && value.length === 0) {
-        return true;
-      } else {
-        return false;
+      @method _contextDidChange
+      @private
+    */
+    _contextDidChange: mixin.observer('context', function() {
+      this.rerender();
+    }),
+
+    // When it's a virtual view, we need to notify the parent that their
+    // childViews will change.
+    _childViewsWillChange: mixin.beforeObserver('childViews', function() {
+      if (this.isVirtual) {
+        var parentView = property_get.get(this, 'parentView');
+        if (parentView) { property_events.propertyWillChange(parentView, 'childViews'); }
       }
-    }
+    }),
 
-    __exports__.isEmpty = isEmpty;function appendContextPath(contextPath, id) {
-      return (contextPath ? contextPath + '.' : '') + id;
-    }
+    // When it's a virtual view, we need to notify the parent that their
+    // childViews did change.
+    _childViewsDidChange: mixin.observer('childViews', function() {
+      if (this.isVirtual) {
+        var parentView = property_get.get(this, 'parentView');
+        if (parentView) { property_events.propertyDidChange(parentView, 'childViews'); }
+      }
+    }),
 
-    __exports__.appendContextPath = appendContextPath;
-  });
-enifed("htmlbars-util/namespaces",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    // ref http://dev.w3.org/html5/spec-LC/namespaces.html
-    var defaultNamespaces = {
-      html: 'http://www.w3.org/1999/xhtml',
-      mathml: 'http://www.w3.org/1998/Math/MathML',
-      svg: 'http://www.w3.org/2000/svg',
-      xlink: 'http://www.w3.org/1999/xlink',
-      xml: 'http://www.w3.org/XML/1998/namespace'
-    };
+    /**
+      Return the nearest ancestor that is an instance of the provided
+      class or mixin.
 
-    function getAttrNamespace(attrName) {
-      var namespace;
+      @method nearestOfType
+      @param {Class,Mixin} klass Subclass of Ember.View (or Ember.View itself),
+             or an instance of Ember.Mixin.
+      @return Ember.View
+    */
+    nearestOfType: function(klass) {
+      var view = property_get.get(this, 'parentView');
+      var isOfType = klass instanceof mixin.Mixin ?
+                     function(view) { return klass.detect(view); } :
+                     function(view) { return klass.detect(view.constructor); };
 
-      var colonIndex = attrName.indexOf(':');
-      if (colonIndex !== -1) {
-        var prefix = attrName.slice(0, colonIndex);
-        namespace = defaultNamespaces[prefix];
+      while (view) {
+        if (isOfType(view)) { return view; }
+        view = property_get.get(view, 'parentView');
       }
+    },
 
-      return namespace || null;
-    }
+    /**
+      Return the nearest ancestor that has a given property.
 
-    __exports__.getAttrNamespace = getAttrNamespace;
-  });
-enifed("htmlbars-util/object-utils",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    function merge(options, defaults) {
-      for (var prop in defaults) {
-        if (options.hasOwnProperty(prop)) { continue; }
-        options[prop] = defaults[prop];
+      @method nearestWithProperty
+      @param {String} property A property name
+      @return Ember.View
+    */
+    nearestWithProperty: function(property) {
+      var view = property_get.get(this, 'parentView');
+
+      while (view) {
+        if (property in view) { return view; }
+        view = property_get.get(view, 'parentView');
       }
-      return options;
-    }
+    },
 
-    __exports__.merge = merge;
-  });
-enifed("htmlbars-util/quoting",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    function escapeString(str) {
-      str = str.replace(/\\/g, "\\\\");
-      str = str.replace(/"/g, '\\"');
-      str = str.replace(/\n/g, "\\n");
-      return str;
-    }
+    /**
+      When the parent view changes, recursively invalidate `controller`
 
-    __exports__.escapeString = escapeString;
+      @method _parentViewDidChange
+      @private
+    */
+    _parentViewDidChange: mixin.observer('_parentView', function() {
+      if (this.isDestroying) { return; }
 
-    function string(str) {
-      return '"' + escapeString(str) + '"';
-    }
+      this._setupKeywords();
+      this.trigger('parentViewDidChange');
 
-    __exports__.string = string;
+      if (property_get.get(this, 'parentView.controller') && !property_get.get(this, 'controller')) {
+        this.notifyPropertyChange('controller');
+      }
+    }),
 
-    function array(a) {
-      return "[" + a + "]";
-    }
+    _controllerDidChange: mixin.observer('controller', function() {
+      if (this.isDestroying) { return; }
 
-    __exports__.array = array;
+      this.rerender();
 
-    function hash(pairs) {
-      return "{" + pairs.join(", ") + "}";
-    }
+      this.forEachChildView(function(view) {
+        view.propertyDidChange('controller');
+      });
+    }),
 
-    __exports__.hash = hash;function repeat(chars, times) {
-      var str = "";
-      while (times--) {
-        str += chars;
-      }
-      return str;
-    }
+    /**
+      Renders the view again. This will work regardless of whether the
+      view is already in the DOM or not. If the view is in the DOM, the
+      rendering process will be deferred to give bindings a chance
+      to synchronize.
 
-    __exports__.repeat = repeat;
-  });
-enifed("htmlbars-util/safe-string",
-  ["./handlebars/safe-string","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var SafeString = __dependency1__["default"];
+      If children were added during the rendering process using `appendChild`,
+      `rerender` will remove them, because they will be added again
+      if needed by the next `render`.
 
-    __exports__["default"] = SafeString;
-  });
-enifed("morph",
-  ["./morph/morph","./morph/attr-morph","./morph/dom-helper","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var Morph = __dependency1__["default"];
-    var AttrMorph = __dependency2__["default"];
-    var DOMHelper = __dependency3__["default"];
+      In general, if the display of your view changes, you should modify
+      the DOM element directly instead of manually calling `rerender`, which can
+      be slow.
 
-    __exports__.Morph = Morph;
-    __exports__.AttrMorph = AttrMorph;
-    __exports__.DOMHelper = DOMHelper;
-  });
-enifed("morph/attr-morph",
-  ["./attr-morph/sanitize-attribute-value","./dom-helper/prop","./dom-helper/build-html-dom","../htmlbars-util","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
-    "use strict";
-    var sanitizeAttributeValue = __dependency1__.sanitizeAttributeValue;
-    var isAttrRemovalValue = __dependency2__.isAttrRemovalValue;
-    var normalizeProperty = __dependency2__.normalizeProperty;
-    var svgNamespace = __dependency3__.svgNamespace;
-    var getAttrNamespace = __dependency4__.getAttrNamespace;
+      @method rerender
+    */
+    rerender: function() {
+      return this.currentState.rerender(this);
+    },
 
-    function updateProperty(value) {
-      this.domHelper.setPropertyStrict(this.element, this.attrName, value);
-    }
+    /**
+      Given a property name, returns a dasherized version of that
+      property name if the property evaluates to a non-falsy value.
 
-    function updateAttribute(value) {
-      if (isAttrRemovalValue(value)) {
-        this.domHelper.removeAttribute(this.element, this.attrName);
-      } else {
-        this.domHelper.setAttribute(this.element, this.attrName, value);
-      }
-    }
+      For example, if the view has property `isUrgent` that evaluates to true,
+      passing `isUrgent` to this method will return `"is-urgent"`.
 
-    function updateAttributeNS(value) {
-      if (isAttrRemovalValue(value)) {
-        this.domHelper.removeAttribute(this.element, this.attrName);
-      } else {
-        this.domHelper.setAttributeNS(this.element, this.namespace, this.attrName, value);
-      }
-    }
+      @method _classStringForProperty
+      @param property
+      @private
+    */
+    _classStringForProperty: function(parsedPath) {
+      return View._classStringForValue(parsedPath.path, parsedPath.stream.value(), parsedPath.className, parsedPath.falsyClassName);
+    },
 
-    function AttrMorph(element, attrName, domHelper, namespace) {
-      this.element = element;
-      this.domHelper = domHelper;
-      this.namespace = namespace !== undefined ? namespace : getAttrNamespace(attrName);
-      this.escaped = true;
+    // ..........................................................
+    // ELEMENT SUPPORT
+    //
 
-      var normalizedAttrName = normalizeProperty(this.element, attrName);
-      if (this.namespace) {
-        this._update = updateAttributeNS;
-        this.attrName = attrName;
-      } else {
-        if (element.namespaceURI === svgNamespace || attrName === 'style' || !normalizedAttrName) {
-          this.attrName = attrName;
-          this._update = updateAttribute;
-        } else {
-          this.attrName = normalizedAttrName;
-          this._update = updateProperty;
-        }
+    /**
+      Returns the current DOM element for the view.
+
+      @property element
+      @type DOMElement
+    */
+    element: null,
+
+    /**
+      Returns a jQuery object for this view's element. If you pass in a selector
+      string, this method will return a jQuery object, using the current element
+      as its buffer.
+
+      For example, calling `view.$('li')` will return a jQuery object containing
+      all of the `li` elements inside the DOM element of this view.
+
+      @method $
+      @param {String} [selector] a jQuery-compatible selector string
+      @return {jQuery} the jQuery object for the DOM node
+    */
+    $: function(sel) {
+      Ember['default'].assert('You cannot access this.$() on a component with `tagName: \'\'` specified.', this.tagName !== '');
+      return this.currentState.$(this, sel);
+    },
+
+    forEachChildView: function(callback) {
+      var childViews = this._childViews;
+
+      if (!childViews) { return this; }
+
+      var len = childViews.length;
+      var view, idx;
+
+      for (idx = 0; idx < len; idx++) {
+        view = childViews[idx];
+        callback(view);
       }
-    }
 
-    AttrMorph.prototype.setContent = function (value) {
-      if (this.escaped) {
-        var sanitized = sanitizeAttributeValue(this.element, this.attrName, value);
-        this._update(sanitized, this.namespace);
-      } else {
-        this._update(value, this.namespace);
-      }
-    };
+      return this;
+    },
+
+    /**
+      Appends the view's element to the specified parent element.
+
+      If the view does not have an HTML representation yet, `createElement()`
+      will be called automatically.
+
+      Note that this method just schedules the view to be appended; the DOM
+      element will not be appended to the given element until all bindings have
+      finished synchronizing.
+
+      This is not typically a function that you will need to call directly when
+      building your application. You might consider using `Ember.ContainerView`
+      instead. If you do need to use `appendTo`, be sure that the target element
+      you are providing is associated with an `Ember.Application` and does not
+      have an ancestor element that is associated with an Ember view.
+
+      @method appendTo
+      @param {String|DOMElement|jQuery} A selector, element, HTML string, or jQuery object
+      @return {Ember.View} receiver
+    */
+    appendTo: function(selector) {
+      var target = jQuery['default'](selector);
+
+      Ember['default'].assert("You tried to append to (" + selector + ") but that isn't in the DOM", target.length > 0);
+      Ember['default'].assert("You cannot append to an existing Ember.View. Consider using Ember.ContainerView instead.", !target.is('.ember-view') && !target.parents().is('.ember-view'));
+
+      this.renderer.appendTo(this, target[0]);
+
+      return this;
+    },
+
+    /**
+      Replaces the content of the specified parent element with this view's
+      element. If the view does not have an HTML representation yet,
+      the element will be generated automatically.
+
+      Note that this method just schedules the view to be appended; the DOM
+      element will not be appended to the given element until all bindings have
+      finished synchronizing
+
+      @method replaceIn
+      @param {String|DOMElement|jQuery} target A selector, element, HTML string, or jQuery object
+      @return {Ember.View} received
+    */
+    replaceIn: function(selector) {
+      var target = jQuery['default'](selector);
+
+      Ember['default'].assert("You tried to replace in (" + selector + ") but that isn't in the DOM", target.length > 0);
+      Ember['default'].assert("You cannot replace an existing Ember.View. Consider using Ember.ContainerView instead.", !target.is('.ember-view') && !target.parents().is('.ember-view'));
+
+      this.renderer.replaceIn(this, target[0]);
+
+      return this;
+    },
+
+    /**
+      Appends the view's element to the document body. If the view does
+      not have an HTML representation yet
+      the element will be generated automatically.
+
+      If your application uses the `rootElement` property, you must append
+      the view within that element. Rendering views outside of the `rootElement`
+      is not supported.
+
+      Note that this method just schedules the view to be appended; the DOM
+      element will not be appended to the document body until all bindings have
+      finished synchronizing.
+
+      @method append
+      @return {Ember.View} receiver
+    */
+    append: function() {
+      return this.appendTo(document.body);
+    },
+
+    /**
+      Removes the view's element from the element to which it is attached.
+
+      @method remove
+      @return {Ember.View} receiver
+    */
+    remove: function() {
+      // What we should really do here is wait until the end of the run loop
+      // to determine if the element has been re-appended to a different
+      // element.
+      // In the interim, we will just re-render if that happens. It is more
+      // important than elements get garbage collected.
+      if (!this.removedFromDOM) { this.destroyElement(); }
+    },
 
-    __exports__["default"] = AttrMorph;
-  });
-enifed("morph/attr-morph/sanitize-attribute-value",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /* jshint scripturl:true */
+    /**
+      The HTML `id` of the view's element in the DOM. You can provide this
+      value yourself but it must be unique (just as in HTML):
 
-    var parsingNode;
-    var badProtocols = {
-      'javascript:': true,
-      'vbscript:': true
-    };
+      ```handlebars
+        {{my-component elementId="a-really-cool-id"}}
+      ```
 
-    var badTags = {
-      'A': true,
-      'BODY': true,
-      'LINK': true,
-      'IMG': true,
-      'IFRAME': true
-    };
+      If not manually set a default value will be provided by the framework.
 
-    var badAttributes = {
-      'href': true,
-      'src': true,
-      'background': true
-    };
-    __exports__.badAttributes = badAttributes;
-    function sanitizeAttributeValue(element, attribute, value) {
-      var tagName;
+      Once rendered an element's `elementId` is considered immutable and you
+      should never change it.
 
-      if (!parsingNode) {
-        parsingNode = document.createElement('a');
-      }
+      @property elementId
+      @type String
+    */
+    elementId: null,
 
-      if (!element) {
-        tagName = null;
-      } else {
-        tagName = element.tagName;
-      }
+    /**
+      Attempts to discover the element in the parent element. The default
+      implementation looks for an element with an ID of `elementId` (or the
+      view's guid if `elementId` is null). You can override this method to
+      provide your own form of lookup. For example, if you want to discover your
+      element using a CSS class name instead of an ID.
 
-      if (value && value.toHTML) {
-        return value.toHTML();
-      }
+      @method findElementInParentElement
+      @param {DOMElement} parentElement The parent's DOM element
+      @return {DOMElement} The discovered element
+    */
+    findElementInParentElement: function(parentElem) {
+      var id = "#" + this.elementId;
+      return jQuery['default'](id)[0] || jQuery['default'](id, parentElem)[0];
+    },
 
-      if ((tagName === null || badTags[tagName]) && badAttributes[attribute]) {
-        parsingNode.href = value;
+    /**
+      Creates a DOM representation of the view and all of its child views by
+      recursively calling the `render()` method.
 
-        if (badProtocols[parsingNode.protocol] === true) {
-          return 'unsafe:' + value;
-        }
-      }
+      After the element has been inserted into the DOM, `didInsertElement` will
+      be called on this view and all of its child views.
 
-      return value;
-    }
+      @method createElement
+      @return {Ember.View} receiver
+    */
+    createElement: function() {
+      if (this.element) { return this; }
 
-    __exports__.sanitizeAttributeValue = sanitizeAttributeValue;
-  });
-enifed("morph/dom-helper",
-  ["../morph/morph","../morph/attr-morph","./dom-helper/build-html-dom","./dom-helper/classes","./dom-helper/prop","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
-    "use strict";
-    var Morph = __dependency1__["default"];
-    var AttrMorph = __dependency2__["default"];
-    var buildHTMLDOM = __dependency3__.buildHTMLDOM;
-    var svgNamespace = __dependency3__.svgNamespace;
-    var svgHTMLIntegrationPoints = __dependency3__.svgHTMLIntegrationPoints;
-    var addClasses = __dependency4__.addClasses;
-    var removeClasses = __dependency4__.removeClasses;
-    var normalizeProperty = __dependency5__.normalizeProperty;
-    var isAttrRemovalValue = __dependency5__.isAttrRemovalValue;
+      this._didCreateElementWithoutMorph = true;
+      this.renderer.renderTree(this);
 
-    var doc = typeof document === 'undefined' ? false : document;
+      return this;
+    },
 
-    var deletesBlankTextNodes = doc && (function(document){
-      var element = document.createElement('div');
-      element.appendChild( document.createTextNode('') );
-      var clonedElement = element.cloneNode(true);
-      return clonedElement.childNodes.length === 0;
-    })(doc);
+    /**
+      Called when a view is going to insert an element into the DOM.
 
-    var ignoresCheckedAttribute = doc && (function(document){
-      var element = document.createElement('input');
-      element.setAttribute('checked', 'checked');
-      var clonedElement = element.cloneNode(false);
-      return !clonedElement.checked;
-    })(doc);
+      @event willInsertElement
+    */
+    willInsertElement: K,
 
-    var canRemoveSvgViewBoxAttribute = doc && (doc.createElementNS ? (function(document){
-      var element = document.createElementNS(svgNamespace, 'svg');
-      element.setAttribute('viewBox', '0 0 100 100');
-      element.removeAttribute('viewBox');
-      return !element.getAttribute('viewBox');
-    })(doc) : true);
+    /**
+      Called when the element of the view has been inserted into the DOM
+      or after the view was re-rendered. Override this function to do any
+      set up that requires an element in the document body.
 
-    var canClone = doc && (function(document){
-      var element = document.createElement('div');
-      element.appendChild( document.createTextNode(' '));
-      element.appendChild( document.createTextNode(' '));
-      var clonedElement = element.cloneNode(true);
-      return clonedElement.childNodes[0].nodeValue === ' ';
-    })(doc);
+      When a view has children, didInsertElement will be called on the
+      child view(s) first, bubbling upwards through the hierarchy.
 
-    // This is not the namespace of the element, but of
-    // the elements inside that elements.
-    function interiorNamespace(element){
-      if (
-        element &&
-        element.namespaceURI === svgNamespace &&
-        !svgHTMLIntegrationPoints[element.tagName]
-      ) {
-        return svgNamespace;
-      } else {
-        return null;
-      }
-    }
+      @event didInsertElement
+    */
+    didInsertElement: K,
 
-    // The HTML spec allows for "omitted start tags". These tags are optional
-    // when their intended child is the first thing in the parent tag. For
-    // example, this is a tbody start tag:
-    //
-    // <table>
-    //   <tbody>
-    //     <tr>
-    //
-    // The tbody may be omitted, and the browser will accept and render:
-    //
-    // <table>
-    //   <tr>
-    //
-    // However, the omitted start tag will still be added to the DOM. Here
-    // we test the string and context to see if the browser is about to
-    // perform this cleanup.
-    //
-    // http://www.whatwg.org/specs/web-apps/current-work/multipage/syntax.html#optional-tags
-    // describes which tags are omittable. The spec for tbody and colgroup
-    // explains this behavior:
-    //
-    // http://www.whatwg.org/specs/web-apps/current-work/multipage/tables.html#the-tbody-element
-    // http://www.whatwg.org/specs/web-apps/current-work/multipage/tables.html#the-colgroup-element
-    //
+    /**
+      Called when the view is about to rerender, but before anything has
+      been torn down. This is a good opportunity to tear down any manual
+      observers you have installed based on the DOM state
 
-    var omittedStartTagChildTest = /<([\w:]+)/;
-    function detectOmittedStartTag(string, contextualElement){
-      // Omitted start tags are only inside table tags.
-      if (contextualElement.tagName === 'TABLE') {
-        var omittedStartTagChildMatch = omittedStartTagChildTest.exec(string);
-        if (omittedStartTagChildMatch) {
-          var omittedStartTagChild = omittedStartTagChildMatch[1];
-          // It is already asserted that the contextual element is a table
-          // and not the proper start tag. Just see if a tag was omitted.
-          return omittedStartTagChild === 'tr' ||
-                 omittedStartTagChild === 'col';
-        }
-      }
-    }
+      @event willClearRender
+    */
+    willClearRender: K,
 
-    function buildSVGDOM(html, dom){
-      var div = dom.document.createElement('div');
-      div.innerHTML = '<svg>'+html+'</svg>';
-      return div.firstChild.childNodes;
-    }
+    /**
+      Destroys any existing element along with the element for any child views
+      as well. If the view does not currently have a element, then this method
+      will do nothing.
 
-    /*
-     * A class wrapping DOM functions to address environment compatibility,
-     * namespaces, contextual elements for morph un-escaped content
-     * insertion.
-     *
-     * When entering a template, a DOMHelper should be passed:
-     *
-     *   template(context, { hooks: hooks, dom: new DOMHelper() });
-     *
-     * TODO: support foreignObject as a passed contextual element. It has
-     * a namespace (svg) that does not match its internal namespace
-     * (xhtml).
-     *
-     * @class DOMHelper
-     * @constructor
-     * @param {HTMLDocument} _document The document DOM methods are proxied to
-     */
-    function DOMHelper(_document){
-      this.document = _document || document;
-      if (!this.document) {
-        throw new Error("A document object must be passed to the DOMHelper, or available on the global scope");
-      }
-      this.canClone = canClone;
-      this.namespace = null;
-    }
+      If you implement `willDestroyElement()` on your view, then this method will
+      be invoked on your view before your element is destroyed to give you a
+      chance to clean up any event handlers, etc.
 
-    var prototype = DOMHelper.prototype;
-    prototype.constructor = DOMHelper;
+      If you write a `willDestroyElement()` handler, you can assume that your
+      `didInsertElement()` handler was called earlier for the same element.
 
-    prototype.getElementById = function(id, rootNode) {
-      rootNode = rootNode || this.document;
-      return rootNode.getElementById(id);
-    };
+      You should not call or override this method yourself, but you may
+      want to implement the above callbacks.
 
-    prototype.insertBefore = function(element, childElement, referenceChild) {
-      return element.insertBefore(childElement, referenceChild);
-    };
+      @method destroyElement
+      @return {Ember.View} receiver
+    */
+    destroyElement: function() {
+      return this.currentState.destroyElement(this);
+    },
 
-    prototype.appendChild = function(element, childElement) {
-      return element.appendChild(childElement);
-    };
+    /**
+      Called when the element of the view is going to be destroyed. Override
+      this function to do any teardown that requires an element, like removing
+      event listeners.
 
-    prototype.childAt = function(element, indices) {
-      var child = element;
+      Please note: any property changes made during this event will have no
+      effect on object observers.
 
-      for (var i = 0; i < indices.length; i++) {
-        child = child.childNodes.item(indices[i]);
-      }
+      @event willDestroyElement
+    */
+    willDestroyElement: K,
 
-      return child;
-    };
+    /**
+      Called when the parentView property has changed.
 
-    // Note to a Fellow Implementor:
-    // Ahh, accessing a child node at an index. Seems like it should be so simple,
-    // doesn't it? Unfortunately, this particular method has caused us a surprising
-    // amount of pain. As you'll note below, this method has been modified to walk
-    // the linked list of child nodes rather than access the child by index
-    // directly, even though there are two (2) APIs in the DOM that do this for us.
-    // If you're thinking to yourself, "What an oversight! What an opportunity to
-    // optimize this code!" then to you I say: stop! For I have a tale to tell.
-    //
-    // First, this code must be compatible with simple-dom for rendering on the
-    // server where there is no real DOM. Previously, we accessed a child node
-    // directly via `element.childNodes[index]`. While we *could* in theory do a
-    // full-fidelity simulation of a live `childNodes` array, this is slow,
-    // complicated and error-prone.
-    //
-    // "No problem," we thought, "we'll just use the similar
-    // `childNodes.item(index)` API." Then, we could just implement our own `item`
-    // method in simple-dom and walk the child node linked list there, allowing
-    // us to retain the performance advantages of the (surely optimized) `item()`
-    // API in the browser.
-    //
-    // Unfortunately, an enterprising soul named Samy Alzahrani discovered that in
-    // IE8, accessing an item out-of-bounds via `item()` causes an exception where
-    // other browsers return null. This necessitated a... check of
-    // `childNodes.length`, bringing us back around to having to support a
-    // full-fidelity `childNodes` array!
-    //
-    // Worst of all, Kris Selden investigated how browsers are actualy implemented
-    // and discovered that they're all linked lists under the hood anyway. Accessing
-    // `childNodes` requires them to allocate a new live collection backed by that
-    // linked list, which is itself a rather expensive operation. Our assumed
-    // optimization had backfired! That is the danger of magical thinking about
-    // the performance of native implementations.
-    //
-    // And this, my friends, is why the following implementation just walks the
-    // linked list, as surprised as that may make you. Please ensure you understand
-    // the above before changing this and submitting a PR.
-    //
-    // Tom Dale, January 18th, 2015, Portland OR
-    prototype.childAtIndex = function(element, index) {
-      var node = element.firstChild;
+      @event parentViewDidChange
+    */
+    parentViewDidChange: K,
 
-      for (var idx = 0; node && idx < index; idx++) {
-        node = node.nextSibling;
+    applyAttributesToBuffer: function(buffer) {
+      // Creates observers for all registered class name and attribute bindings,
+      // then adds them to the element.
+
+      this._applyClassNameBindings();
+
+      // Pass the render buffer so the method can apply attributes directly.
+      // This isn't needed for class name bindings because they use the
+      // existing classNames infrastructure.
+      this._applyAttributeBindings(buffer);
+
+      buffer.setClasses(this.classNames);
+      buffer.id(this.elementId);
+
+      var role = property_get.get(this, 'ariaRole');
+      if (role) {
+        buffer.attr('role', role);
+      }
+
+      if (property_get.get(this, 'isVisible') === false) {
+        buffer.style('display', 'none');
       }
+    },
 
-      return node;
-    };
+    // ..........................................................
+    // STANDARD RENDER PROPERTIES
+    //
 
-    prototype.appendText = function(element, text) {
-      return element.appendChild(this.document.createTextNode(text));
-    };
+    /**
+      Tag name for the view's outer element. The tag name is only used when an
+      element is first created. If you change the `tagName` for an element, you
+      must destroy and recreate the view element.
 
-    prototype.setAttribute = function(element, name, value) {
-      element.setAttribute(name, String(value));
-    };
+      By default, the render buffer will use a `<div>` tag for views.
 
-    prototype.setAttributeNS = function(element, namespace, name, value) {
-      element.setAttributeNS(namespace, name, String(value));
-    };
+      @property tagName
+      @type String
+      @default null
+    */
 
-    if (canRemoveSvgViewBoxAttribute){
-      prototype.removeAttribute = function(element, name) {
-        element.removeAttribute(name);
-      };
-    } else {
-      prototype.removeAttribute = function(element, name) {
-        if (element.tagName === 'svg' && name === 'viewBox') {
-          element.setAttribute(name, null);
-        } else {
-          element.removeAttribute(name);
-        }
-      };
-    }
+    // We leave this null by default so we can tell the difference between
+    // the default case and a user-specified tag.
+    tagName: null,
 
-    prototype.setPropertyStrict = function(element, name, value) {
-      element[name] = value;
-    };
+    /**
+      The WAI-ARIA role of the control represented by this view. For example, a
+      button may have a role of type 'button', or a pane may have a role of
+      type 'alertdialog'. This property is used by assistive software to help
+      visually challenged users navigate rich web applications.
 
-    prototype.setProperty = function(element, name, value, namespace) {
-      var lowercaseName = name.toLowerCase();
-      if (element.namespaceURI === svgNamespace || lowercaseName === 'style') {
-        if (isAttrRemovalValue(value)) {
-          element.removeAttribute(name);
-        } else {
-          if (namespace) {
-            element.setAttributeNS(namespace, name, value);
-          } else {
-            element.setAttribute(name, value);
-          }
-        }
-      } else {
-        var normalized = normalizeProperty(element, name);
-        if (normalized) {
-          element[normalized] = value;
-        } else {
-          if (isAttrRemovalValue(value)) {
-            element.removeAttribute(name);
-          } else {
-            if (namespace && element.setAttributeNS) {
-              element.setAttributeNS(namespace, name, value);
-            } else {
-              element.setAttribute(name, value);
-            }
-          }
-        }
-      }
-    };
+      The full list of valid WAI-ARIA roles is available at:
+      [http://www.w3.org/TR/wai-aria/roles#roles_categorization](http://www.w3.org/TR/wai-aria/roles#roles_categorization)
 
-    if (doc && doc.createElementNS) {
-      // Only opt into namespace detection if a contextualElement
-      // is passed.
-      prototype.createElement = function(tagName, contextualElement) {
-        var namespace = this.namespace;
-        if (contextualElement) {
-          if (tagName === 'svg') {
-            namespace = svgNamespace;
-          } else {
-            namespace = interiorNamespace(contextualElement);
-          }
-        }
-        if (namespace) {
-          return this.document.createElementNS(namespace, tagName);
-        } else {
-          return this.document.createElement(tagName);
-        }
-      };
-      prototype.setAttributeNS = function(element, namespace, name, value) {
-        element.setAttributeNS(namespace, name, String(value));
-      };
-    } else {
-      prototype.createElement = function(tagName) {
-        return this.document.createElement(tagName);
-      };
-      prototype.setAttributeNS = function(element, namespace, name, value) {
-        element.setAttribute(name, String(value));
-      };
-    }
+      @property ariaRole
+      @type String
+      @default null
+    */
+    ariaRole: null,
 
-    prototype.addClasses = addClasses;
-    prototype.removeClasses = removeClasses;
+    // .......................................................
+    // CORE DISPLAY METHODS
+    //
 
-    prototype.setNamespace = function(ns) {
-      this.namespace = ns;
-    };
+    /**
+      Setup a view, but do not finish waking it up.
 
-    prototype.detectNamespace = function(element) {
-      this.namespace = interiorNamespace(element);
-    };
+      * configure `childViews`
+      * register the view with the global views hash, which is used for event
+        dispatch
 
-    prototype.createDocumentFragment = function(){
-      return this.document.createDocumentFragment();
-    };
+      @method init
+      @private
+    */
+    init: function() {
+      if (!this.isVirtual && !this.elementId) {
+        this.elementId = utils.guidFor(this);
+      }
 
-    prototype.createTextNode = function(text){
-      return this.document.createTextNode(text);
-    };
+      this._super.apply(this, arguments);
+    },
 
-    prototype.createComment = function(text){
-      return this.document.createComment(text);
-    };
+    __defineNonEnumerable: function(property) {
+      this[property.name] = property.descriptor.value;
+    },
 
-    prototype.repairClonedNode = function(element, blankChildTextNodes, isChecked){
-      if (deletesBlankTextNodes && blankChildTextNodes.length > 0) {
-        for (var i=0, len=blankChildTextNodes.length;i<len;i++){
-          var textNode = this.document.createTextNode(''),
-              offset = blankChildTextNodes[i],
-              before = this.childAtIndex(element, offset);
-          if (before) {
-            element.insertBefore(textNode, before);
-          } else {
-            element.appendChild(textNode);
-          }
-        }
-      }
-      if (ignoresCheckedAttribute && isChecked) {
-        element.setAttribute('checked', 'checked');
-      }
-    };
+    appendAttr: function(node) {
+      return this.currentState.appendAttr(this, node);
+    },
 
-    prototype.cloneNode = function(element, deep){
-      var clone = element.cloneNode(!!deep);
-      return clone;
-    };
+    /**
+      Removes the view from its `parentView`, if one is found. Otherwise
+      does nothing.
 
-    prototype.createAttrMorph = function(element, attrName, namespace){
-      return new AttrMorph(element, attrName, this, namespace);
-    };
+      @method removeFromParent
+      @return {Ember.View} receiver
+    */
+    removeFromParent: function() {
+      var parent = this._parentView;
 
-    prototype.createUnsafeAttrMorph = function(element, attrName, namespace){
-      var morph = this.createAttrMorph(element, attrName, namespace);
-      morph.escaped = false;
-      return morph;
-    };
+      // Remove DOM element from parent
+      this.remove();
 
-    prototype.createMorph = function(parent, start, end, contextualElement){
-      if (!contextualElement && parent.nodeType === 1) {
-        contextualElement = parent;
+      if (parent) { parent.removeChild(this); }
+      return this;
+    },
+
+    /**
+      You must call `destroy` on a view to destroy the view (and all of its
+      child views). This will remove the view from any parent node, then make
+      sure that the DOM element managed by the view can be released by the
+      memory manager.
+
+      @method destroy
+    */
+    destroy: function() {
+      // get parentView before calling super because it'll be destroyed
+      var nonVirtualParentView = property_get.get(this, 'parentView');
+      var viewName = this.viewName;
+
+      if (!this._super.apply(this, arguments)) { return; }
+
+      // remove from non-virtual parent view if viewName was specified
+      if (viewName && nonVirtualParentView) {
+        nonVirtualParentView.set(viewName, null);
       }
-      return new Morph(parent, start, end, this, contextualElement);
-    };
 
-    prototype.createUnsafeMorph = function(parent, start, end, contextualElement){
-      var morph = this.createMorph(parent, start, end, contextualElement);
-      morph.escaped = false;
-      return morph;
-    };
+      return this;
+    },
 
-    // This helper is just to keep the templates good looking,
-    // passing integers instead of element references.
-    prototype.createMorphAt = function(parent, startIndex, endIndex, contextualElement){
-      var start = startIndex === -1 ? null : this.childAtIndex(parent, startIndex),
-          end = endIndex === -1 ? null : this.childAtIndex(parent, endIndex);
-      return this.createMorph(parent, start, end, contextualElement);
-    };
+    // .......................................................
+    // EVENT HANDLING
+    //
 
-    prototype.createUnsafeMorphAt = function(parent, startIndex, endIndex, contextualElement) {
-      var morph = this.createMorphAt(parent, startIndex, endIndex, contextualElement);
-      morph.escaped = false;
-      return morph;
-    };
+    /**
+      Handle events from `Ember.EventDispatcher`
 
-    prototype.insertMorphBefore = function(element, referenceChild, contextualElement) {
-      var start = this.document.createTextNode('');
-      var end = this.document.createTextNode('');
-      element.insertBefore(start, referenceChild);
-      element.insertBefore(end, referenceChild);
-      return this.createMorph(element, start, end, contextualElement);
-    };
+      @method handleEvent
+      @param eventName {String}
+      @param evt {Event}
+      @private
+    */
+    handleEvent: function(eventName, evt) {
+      return this.currentState.handleEvent(this, eventName, evt);
+    },
 
-    prototype.appendMorph = function(element, contextualElement) {
-      var start = this.document.createTextNode('');
-      var end = this.document.createTextNode('');
-      element.appendChild(start);
-      element.appendChild(end);
-      return this.createMorph(element, start, end, contextualElement);
-    };
+    registerObserver: function(root, path, target, observer) {
+      if (!observer && 'function' === typeof target) {
+        observer = target;
+        target = null;
+      }
 
-    prototype.parseHTML = function(html, contextualElement) {
-      if (interiorNamespace(contextualElement) === svgNamespace) {
-        return buildSVGDOM(html, this);
-      } else {
-        var nodes = buildHTMLDOM(html, contextualElement, this);
-        if (detectOmittedStartTag(html, contextualElement)) {
-          var node = nodes[0];
-          while (node && node.nodeType !== 1) {
-            node = node.nextSibling;
-          }
-          return node.childNodes;
-        } else {
-          return nodes;
-        }
+      if (!root || typeof root !== 'object') {
+        return;
       }
-    };
 
-    var parsingNode;
+      var scheduledObserver = this._wrapAsScheduled(observer);
 
-    // Used to determine whether a URL needs to be sanitized.
-    prototype.protocolForURL = function(url) {
-      if (!parsingNode) {
-        parsingNode = this.document.createElement('a');
-      }
+      observer.addObserver(root, path, target, scheduledObserver);
 
-      parsingNode.href = url;
-      return parsingNode.protocol;
-    };
+      this.one('willClearRender', function() {
+        observer.removeObserver(root, path, target, scheduledObserver);
+      });
+    },
 
-    __exports__["default"] = DOMHelper;
+    _wrapAsScheduled: function(fn) {
+      var view = this;
+      var stateCheckedFn = function() {
+        view.currentState.invokeObserver(this, fn);
+      };
+      var scheduledFn = function() {
+        run['default'].scheduleOnce('render', this, stateCheckedFn);
+      };
+      return scheduledFn;
+    }
   });
-enifed("morph/dom-helper/build-html-dom",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    /* global XMLSerializer:false */
-    var svgHTMLIntegrationPoints = {foreignObject: 1, desc: 1, title: 1};
-    __exports__.svgHTMLIntegrationPoints = svgHTMLIntegrationPoints;var svgNamespace = 'http://www.w3.org/2000/svg';
-    __exports__.svgNamespace = svgNamespace;
-    var doc = typeof document === 'undefined' ? false : document;
+  // jscs:enable validateIndentation
 
-    // Safari does not like using innerHTML on SVG HTML integration
-    // points (desc/title/foreignObject).
-    var needsIntegrationPointFix = doc && (function(document) {
-      if (document.createElementNS === undefined) {
-        return;
-      }
-      // In FF title will not accept innerHTML.
-      var testEl = document.createElementNS(svgNamespace, 'title');
-      testEl.innerHTML = "<div></div>";
-      return testEl.childNodes.length === 0 || testEl.childNodes[0].nodeType !== 1;
-    })(doc);
+  deprecate_property.deprecateProperty(View.prototype, 'state', '_state');
+  deprecate_property.deprecateProperty(View.prototype, 'states', '_states');
 
-    // Internet Explorer prior to 9 does not allow setting innerHTML if the first element
-    // is a "zero-scope" element. This problem can be worked around by making
-    // the first node an invisible text node. We, like Modernizr, use &shy;
-    var needsShy = doc && (function(document) {
-      var testEl = document.createElement('div');
-      testEl.innerHTML = "<div></div>";
-      testEl.firstChild.innerHTML = "<script><\/script>";
-      return testEl.firstChild.innerHTML === '';
-    })(doc);
+  /*
+    Describe how the specified actions should behave in the various
+    states that a view can exist in. Possible states:
 
-    // IE 8 (and likely earlier) likes to move whitespace preceeding
-    // a script tag to appear after it. This means that we can
-    // accidentally remove whitespace when updating a morph.
-    var movesWhitespace = doc && (function(document) {
-      var testEl = document.createElement('div');
-      testEl.innerHTML = "Test: <script type='text/x-placeholder'><\/script>Value";
-      return testEl.childNodes[0].nodeValue === 'Test:' &&
-              testEl.childNodes[2].nodeValue === ' Value';
-    })(doc);
+    * preRender: when a view is first instantiated, and after its
+      element was destroyed, it is in the preRender state
+    * inBuffer: once a view has been rendered, but before it has
+      been inserted into the DOM, it is in the inBuffer state
+    * hasElement: the DOM representation of the view is created,
+      and is ready to be inserted
+    * inDOM: once a view has been inserted into the DOM it is in
+      the inDOM state. A view spends the vast majority of its
+      existence in this state.
+    * destroyed: once a view has been destroyed (using the destroy
+      method), it is in this state. No further actions can be invoked
+      on a destroyed view.
+  */
+
+  // in the destroyed state, everything is illegal
+
+  // before rendering has begun, all legal manipulations are noops.
+
+  // inside the buffer, legal manipulations are done on the buffer
+
+  // once the view has been inserted into the DOM, legal manipulations
+  // are done on the DOM element.
 
-    // IE8 create a selected attribute where they should only
-    // create a property
-    var createsSelectedAttribute = doc && (function(document) {
-      var testEl = document.createElement('div');
-      testEl.innerHTML = "<select><option></option></select>";
-      return testEl.childNodes[0].childNodes[0].getAttribute('selected') === 'selected';
-    })(doc);
+  var mutation = EmberObject['default'].extend(Evented['default']).create();
+  // TODO MOVE TO RENDERER HOOKS
+  View.addMutationListener = function(callback) {
+    mutation.on('change', callback);
+  };
 
-    var detectAutoSelectedOption;
-    if (createsSelectedAttribute) {
-      detectAutoSelectedOption = (function(){
-        var detectAutoSelectedOptionRegex = /<option[^>]*selected/;
-        return function detectAutoSelectedOption(select, option, html) { //jshint ignore:line
-          return select.selectedIndex === 0 &&
-                 !detectAutoSelectedOptionRegex.test(html);
-        };
-      })();
-    } else {
-      detectAutoSelectedOption = function detectAutoSelectedOption(select, option, html) { //jshint ignore:line
-        var selectedAttribute = option.getAttribute('selected');
-        return select.selectedIndex === 0 && (
-                 selectedAttribute === null ||
-                 ( selectedAttribute !== '' && selectedAttribute.toLowerCase() !== 'selected' )
-                );
-      };
-    }
+  View.removeMutationListener = function(callback) {
+    mutation.off('change', callback);
+  };
 
-    var tagNamesRequiringInnerHTMLFix = doc && (function(document) {
-      var tagNamesRequiringInnerHTMLFix;
-      // IE 9 and earlier don't allow us to set innerHTML on col, colgroup, frameset,
-      // html, style, table, tbody, tfoot, thead, title, tr. Detect this and add
-      // them to an initial list of corrected tags.
-      //
-      // Here we are only dealing with the ones which can have child nodes.
-      //
-      var tableNeedsInnerHTMLFix;
-      var tableInnerHTMLTestElement = document.createElement('table');
-      try {
-        tableInnerHTMLTestElement.innerHTML = '<tbody></tbody>';
-      } catch (e) {
-      } finally {
-        tableNeedsInnerHTMLFix = (tableInnerHTMLTestElement.childNodes.length === 0);
-      }
-      if (tableNeedsInnerHTMLFix) {
-        tagNamesRequiringInnerHTMLFix = {
-          colgroup: ['table'],
-          table: [],
-          tbody: ['table'],
-          tfoot: ['table'],
-          thead: ['table'],
-          tr: ['table', 'tbody']
-        };
-      }
+  View.notifyMutationListeners = function() {
+    mutation.trigger('change');
+  };
 
-      // IE 8 doesn't allow setting innerHTML on a select tag. Detect this and
-      // add it to the list of corrected tags.
-      //
-      var selectInnerHTMLTestElement = document.createElement('select');
-      selectInnerHTMLTestElement.innerHTML = '<option></option>';
-      if (!selectInnerHTMLTestElement.childNodes[0]) {
-        tagNamesRequiringInnerHTMLFix = tagNamesRequiringInnerHTMLFix || {};
-        tagNamesRequiringInnerHTMLFix.select = [];
-      }
-      return tagNamesRequiringInnerHTMLFix;
-    })(doc);
+  /**
+    Global views hash
 
-    function scriptSafeInnerHTML(element, html) {
-      // without a leading text node, IE will drop a leading script tag.
-      html = '&shy;'+html;
+    @property views
+    @static
+    @type Hash
+  */
+  View.views = {};
+
+  // If someone overrides the child views computed property when
+  // defining their class, we want to be able to process the user's
+  // supplied childViews and then restore the original computed property
+  // at view initialization time. This happens in Ember.ContainerView's init
+  // method.
+  View.childViewsProperty = view_child_views_support.childViewsProperty;
+
+  exports['default'] = View;
+
+  exports.ViewKeywordSupport = ViewKeywordSupport['default'];
+  exports.ViewStreamSupport = ViewStreamSupport['default'];
+  exports.ViewContextSupport = ViewContextSupport['default'];
+  exports.ViewChildViewsSupport = view_child_views_support["default"];
+  exports.ViewStateSupport = ViewStateSupport['default'];
+  exports.TemplateRenderingSupport = TemplateRenderingSupport['default'];
+  exports.ClassNamesSupport = ClassNamesSupport['default'];
+  exports.AttributeBindingsSupport = AttributeBindingsSupport['default'];
+
+});
+enifed('ember-views/views/with_view', ['exports', 'ember-metal/property_set', 'ember-views/views/metamorph_view', 'ember-views/mixins/normalized_rerender_if_needed', 'ember-metal/run_loop', 'ember-htmlbars/system/render-view'], function (exports, property_set, _MetamorphView, NormalizedRerenderIfNeededSupport, run, renderView) {
+
+  'use strict';
+
+  /**
+  @module ember
+  @submodule ember-views
+  */
+
+  exports['default'] = _MetamorphView['default'].extend(NormalizedRerenderIfNeededSupport['default'], {
+    init: function() {
+      this._super.apply(this, arguments);
+
+      var self = this;
+
+      this.withValue.subscribe(this._wrapAsScheduled(function() {
+        run['default'].scheduleOnce('render', self, 'rerenderIfNeeded');
+      }));
 
-      element.innerHTML = html;
+      var controllerName = this.controllerName;
+      if (controllerName) {
+        var controllerFactory = this.container.lookupFactory('controller:'+controllerName);
+        var controller = controllerFactory.create({
+          parentController: this.previousContext,
+          target: this.previousContext
+        });
 
-      var nodes = element.childNodes;
+        this._generatedController = controller;
 
-      // Look for &shy; to remove it.
-      var shyElement = nodes[0];
-      while (shyElement.nodeType === 1 && !shyElement.nodeName) {
-        shyElement = shyElement.firstChild;
-      }
-      // At this point it's the actual unicode character.
-      if (shyElement.nodeType === 3 && shyElement.nodeValue.charAt(0) === "\u00AD") {
-        var newValue = shyElement.nodeValue.slice(1);
-        if (newValue.length) {
-          shyElement.nodeValue = shyElement.nodeValue.slice(1);
+        if (this.preserveContext) {
+          this._blockArguments = [controller];
+          this.withValue.subscribe(function(modelStream) {
+            property_set.set(controller, 'model', modelStream.value());
+          });
         } else {
-          shyElement.parentNode.removeChild(shyElement);
+          property_set.set(this, 'controller', controller);
+        }
+
+        property_set.set(controller, 'model', this.withValue.value());
+      } else {
+        if (this.preserveContext) {
+          this._blockArguments = [this.withValue];
         }
       }
+    },
 
-      return nodes;
-    }
+    normalizedValue: function() {
+      return this.withValue.value();
+    },
 
-    function buildDOMWithFix(html, contextualElement){
-      var tagName = contextualElement.tagName;
+    render: function(buffer) {
+      var withValue = this.normalizedValue();
+      this._lastNormalizedValue = withValue;
 
-      // Firefox versions < 11 do not have support for element.outerHTML.
-      var outerHTML = contextualElement.outerHTML || new XMLSerializer().serializeToString(contextualElement);
-      if (!outerHTML) {
-        throw "Can't set innerHTML on "+tagName+" in this browser";
+      if (!this.preserveContext && !this.controllerName) {
+        property_set.set(this, '_context', withValue);
       }
 
-      var wrappingTags = tagNamesRequiringInnerHTMLFix[tagName.toLowerCase()];
-      var startTag = outerHTML.match(new RegExp("<"+tagName+"([^>]*)>", 'i'))[0];
-      var endTag = '</'+tagName+'>';
+      var template = withValue ? this.mainTemplate : this.inverseTemplate;
+      renderView['default'](this, buffer, template);
+    },
 
-      var wrappedHTML = [startTag, html, endTag];
+    willDestroy: function() {
+      this._super.apply(this, arguments);
 
-      var i = wrappingTags.length;
-      var wrappedDepth = 1 + i;
-      while(i--) {
-        wrappedHTML.unshift('<'+wrappingTags[i]+'>');
-        wrappedHTML.push('</'+wrappingTags[i]+'>');
+      if (this._generatedController) {
+        this._generatedController.destroy();
       }
+    }
+  });
 
-      var wrapper = document.createElement('div');
-      scriptSafeInnerHTML(wrapper, wrappedHTML.join(''));
-      var element = wrapper;
-      while (wrappedDepth--) {
-        element = element.firstChild;
-        while (element && element.nodeType !== 1) {
-          element = element.nextSibling;
+});
+enifed('ember', ['ember-metal', 'ember-runtime', 'ember-views', 'ember-routing', 'ember-application', 'ember-extension-support', 'ember-htmlbars', 'ember-routing-htmlbars', 'ember-routing-views', 'ember-metal/environment', 'ember-runtime/system/lazy_load'], function (__dep0__, __dep1__, __dep2__, __dep3__, __dep4__, __dep5__, __dep6__, __dep7__, __dep8__, environment, lazy_load) {
+
+  'use strict';
+
+  // require the main entry points for each of these packages
+  // this is so that the global exports occur properly
+  if (Ember.__loader.registry['ember-template-compiler']) {
+    requireModule('ember-template-compiler');
+  }
+
+  // do this to ensure that Ember.Test is defined properly on the global
+  // if it is present.
+  if (Ember.__loader.registry['ember-testing']) {
+    requireModule('ember-testing');
+  }
+
+  lazy_load.runLoadHooks('Ember');
+
+  /**
+  Ember
+
+  @module ember
+  */
+
+  Ember.deprecate(
+    'Usage of Ember is deprecated for Internet Explorer 6 and 7, support will be removed in the next major version.',
+    !environment['default'].userAgent.match(/MSIE [67]/)
+  );
+
+});
+enifed("htmlbars-util",
+  ["./htmlbars-util/safe-string","./htmlbars-util/handlebars/utils","./htmlbars-util/namespaces","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+    "use strict";
+    var SafeString = __dependency1__["default"];
+    var escapeExpression = __dependency2__.escapeExpression;
+    var getAttrNamespace = __dependency3__.getAttrNamespace;
+
+    __exports__.SafeString = SafeString;
+    __exports__.escapeExpression = escapeExpression;
+    __exports__.getAttrNamespace = getAttrNamespace;
+  });
+enifed("htmlbars-util/array-utils",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    function forEach(array, callback, binding) {
+      var i, l;
+      if (binding === undefined) {
+        for (i = 0, l = array.length; i < l; i++) {
+          callback(array[i], i, array);
+        }
+      } else {
+        for (i = 0, l = array.length; i < l; i++) {
+          callback.call(binding, array[i], i, array);
         }
       }
-      while (element && element.tagName !== tagName) {
-        element = element.nextSibling;
+    }
+
+    __exports__.forEach = forEach;function map(array, callback) {
+      var output = [];
+      var i, l;
+
+      for (i = 0, l = array.length; i < l; i++) {
+        output.push(callback(array[i], i, array));
       }
-      return element ? element.childNodes : [];
+
+      return output;
     }
 
-    var buildDOM;
-    if (needsShy) {
-      buildDOM = function buildDOM(html, contextualElement, dom){
-        contextualElement = dom.cloneNode(contextualElement, false);
-        scriptSafeInnerHTML(contextualElement, html);
-        return contextualElement.childNodes;
+    __exports__.map = map;var getIdx;
+    if (Array.prototype.indexOf) {
+      getIdx = function(array, obj, from){
+        return array.indexOf(obj, from);
       };
     } else {
-      buildDOM = function buildDOM(html, contextualElement, dom){
-        contextualElement = dom.cloneNode(contextualElement, false);
-        contextualElement.innerHTML = html;
-        return contextualElement.childNodes;
+      getIdx = function(array, obj, from) {
+        if (from === undefined || from === null) {
+          from = 0;
+        } else if (from < 0) {
+          from = Math.max(0, array.length + from);
+        }
+        for (var i = from, l= array.length; i < l; i++) {
+          if (array[i] === obj) {
+            return i;
+          }
+        }
+        return -1;
       };
     }
 
-    var buildIESafeDOM;
-    if (tagNamesRequiringInnerHTMLFix || movesWhitespace) {
-      buildIESafeDOM = function buildIESafeDOM(html, contextualElement, dom) {
-        // Make a list of the leading text on script nodes. Include
-        // script tags without any whitespace for easier processing later.
-        var spacesBefore = [];
-        var spacesAfter = [];
-        if (typeof html === 'string') {
-          html = html.replace(/(\s*)(<script)/g, function(match, spaces, tag) {
-            spacesBefore.push(spaces);
-            return tag;
-          });
-
-          html = html.replace(/(<\/script>)(\s*)/g, function(match, tag, spaces) {
-            spacesAfter.push(spaces);
-            return tag;
-          });
-        }
-
-        // Fetch nodes
-        var nodes;
-        if (tagNamesRequiringInnerHTMLFix[contextualElement.tagName.toLowerCase()]) {
-          // buildDOMWithFix uses string wrappers for problematic innerHTML.
-          nodes = buildDOMWithFix(html, contextualElement);
-        } else {
-          nodes = buildDOM(html, contextualElement, dom);
-        }
+    var indexOfArray = getIdx;
+    __exports__.indexOfArray = indexOfArray;
+  });
+enifed("htmlbars-util/handlebars/safe-string",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    // Build out our basic SafeString type
+    function SafeString(string) {
+      this.string = string;
+    }
 
-        // Build a list of script tags, the nodes themselves will be
-        // mutated as we add test nodes.
-        var i, j, node, nodeScriptNodes;
-        var scriptNodes = [];
-        for (i=0;i<nodes.length;i++) {
-          node=nodes[i];
-          if (node.nodeType !== 1) {
-            continue;
-          }
-          if (node.tagName === 'SCRIPT') {
-            scriptNodes.push(node);
-          } else {
-            nodeScriptNodes = node.getElementsByTagName('script');
-            for (j=0;j<nodeScriptNodes.length;j++) {
-              scriptNodes.push(nodeScriptNodes[j]);
-            }
-          }
-        }
+    SafeString.prototype.toString = SafeString.prototype.toHTML = function() {
+      return "" + this.string;
+    };
 
-        // Walk the script tags and put back their leading text nodes.
-        var scriptNode, textNode, spaceBefore, spaceAfter;
-        for (i=0;i<scriptNodes.length;i++) {
-          scriptNode = scriptNodes[i];
-          spaceBefore = spacesBefore[i];
-          if (spaceBefore && spaceBefore.length > 0) {
-            textNode = dom.document.createTextNode(spaceBefore);
-            scriptNode.parentNode.insertBefore(textNode, scriptNode);
-          }
+    __exports__["default"] = SafeString;
+  });
+enifed("htmlbars-util/handlebars/utils",
+  ["./safe-string","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    /*jshint -W004 */
+    var SafeString = __dependency1__["default"];
 
-          spaceAfter = spacesAfter[i];
-          if (spaceAfter && spaceAfter.length > 0) {
-            textNode = dom.document.createTextNode(spaceAfter);
-            scriptNode.parentNode.insertBefore(textNode, scriptNode.nextSibling);
-          }
-        }
+    var escape = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#x27;",
+      "`": "&#x60;"
+    };
 
-        return nodes;
-      };
-    } else {
-      buildIESafeDOM = buildDOM;
-    }
+    var badChars = /[&<>"'`]/g;
+    var possible = /[&<>"'`]/;
 
-    // When parsing innerHTML, the browser may set up DOM with some things
-    // not desired. For example, with a select element context and option
-    // innerHTML the first option will be marked selected.
-    //
-    // This method cleans up some of that, resetting those values back to
-    // their defaults.
-    //
-    function buildSafeDOM(html, contextualElement, dom) {
-      var childNodes = buildIESafeDOM(html, contextualElement, dom);
+    function escapeChar(chr) {
+      return escape[chr];
+    }
 
-      if (contextualElement.tagName === 'SELECT') {
-        // Walk child nodes
-        for (var i = 0; childNodes[i]; i++) {
-          // Find and process the first option child node
-          if (childNodes[i].tagName === 'OPTION') {
-            if (detectAutoSelectedOption(childNodes[i].parentNode, childNodes[i], html)) {
-              // If the first node is selected but does not have an attribute,
-              // presume it is not really selected.
-              childNodes[i].parentNode.selectedIndex = -1;
-            }
-            break;
+    function extend(obj /* , ...source */) {
+      for (var i = 1; i < arguments.length; i++) {
+        for (var key in arguments[i]) {
+          if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
+            obj[key] = arguments[i][key];
           }
         }
       }
 
-      return childNodes;
+      return obj;
     }
 
-    var buildHTMLDOM;
-    if (needsIntegrationPointFix) {
-      buildHTMLDOM = function buildHTMLDOM(html, contextualElement, dom){
-        if (svgHTMLIntegrationPoints[contextualElement.tagName]) {
-          return buildSafeDOM(html, document.createElement('div'), dom);
-        } else {
-          return buildSafeDOM(html, contextualElement, dom);
-        }
+    __exports__.extend = extend;var toString = Object.prototype.toString;
+    __exports__.toString = toString;
+    // Sourced from lodash
+    // https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
+    var isFunction = function(value) {
+      return typeof value === 'function';
+    };
+    // fallback for older versions of Chrome and Safari
+    /* istanbul ignore next */
+    if (isFunction(/x/)) {
+      isFunction = function(value) {
+        return typeof value === 'function' && toString.call(value) === '[object Function]';
       };
-    } else {
-      buildHTMLDOM = buildSafeDOM;
     }
+    var isFunction;
+    __exports__.isFunction = isFunction;
+    /* istanbul ignore next */
+    var isArray = Array.isArray || function(value) {
+      return (value && typeof value === 'object') ? toString.call(value) === '[object Array]' : false;
+    };
+    __exports__.isArray = isArray;
 
-    __exports__.buildHTMLDOM = buildHTMLDOM;
-  });
-enifed("morph/dom-helper/classes",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    var doc = typeof document === 'undefined' ? false : document;
+    function escapeExpression(string) {
+      // don't escape SafeStrings, since they're already safe
+      if (string && string.toHTML) {
+        return string.toHTML();
+      } else if (string == null) {
+        return "";
+      } else if (!string) {
+        return string + '';
+      }
 
-    // PhantomJS has a broken classList. See https://github.com/ariya/phantomjs/issues/12782
-    var canClassList = doc && (function(){
-      var d = document.createElement('div');
-      if (!d.classList) {
+      // Force a string conversion as this will be done by the append regardless and
+      // the regex test will do this transparently behind the scenes, causing issues if
+      // an object's to string has escaped characters in it.
+      string = "" + string;
+
+      if(!possible.test(string)) { return string; }
+      return string.replace(badChars, escapeChar);
+    }
+
+    __exports__.escapeExpression = escapeExpression;function isEmpty(value) {
+      if (!value && value !== 0) {
+        return true;
+      } else if (isArray(value) && value.length === 0) {
+        return true;
+      } else {
         return false;
       }
-      d.classList.add('boo');
-      d.classList.add('boo', 'baz');
-      return (d.className === 'boo baz');
-    })();
+    }
 
-    function buildClassList(element) {
-      var classString = (element.getAttribute('class') || '');
-      return classString !== '' && classString !== ' ' ? classString.split(' ') : [];
+    __exports__.isEmpty = isEmpty;function appendContextPath(contextPath, id) {
+      return (contextPath ? contextPath + '.' : '') + id;
     }
 
-    function intersect(containingArray, valuesArray) {
-      var containingIndex = 0;
-      var containingLength = containingArray.length;
-      var valuesIndex = 0;
-      var valuesLength = valuesArray.length;
+    __exports__.appendContextPath = appendContextPath;
+  });
+enifed("htmlbars-util/namespaces",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    // ref http://dev.w3.org/html5/spec-LC/namespaces.html
+    var defaultNamespaces = {
+      html: 'http://www.w3.org/1999/xhtml',
+      mathml: 'http://www.w3.org/1998/Math/MathML',
+      svg: 'http://www.w3.org/2000/svg',
+      xlink: 'http://www.w3.org/1999/xlink',
+      xml: 'http://www.w3.org/XML/1998/namespace'
+    };
 
-      var intersection = new Array(valuesLength);
+    function getAttrNamespace(attrName) {
+      var namespace;
 
-      // TODO: rewrite this loop in an optimal manner
-      for (;containingIndex<containingLength;containingIndex++) {
-        valuesIndex = 0;
-        for (;valuesIndex<valuesLength;valuesIndex++) {
-          if (valuesArray[valuesIndex] === containingArray[containingIndex]) {
-            intersection[valuesIndex] = containingIndex;
-            break;
-          }
-        }
+      var colonIndex = attrName.indexOf(':');
+      if (colonIndex !== -1) {
+        var prefix = attrName.slice(0, colonIndex);
+        namespace = defaultNamespaces[prefix];
       }
 
-      return intersection;
+      return namespace || null;
     }
 
-    function addClassesViaAttribute(element, classNames) {
-      var existingClasses = buildClassList(element);
-
-      var indexes = intersect(existingClasses, classNames);
-      var didChange = false;
-
-      for (var i=0, l=classNames.length; i<l; i++) {
-        if (indexes[i] === undefined) {
-          didChange = true;
-          existingClasses.push(classNames[i]);
-        }
+    __exports__.getAttrNamespace = getAttrNamespace;
+  });
+enifed("htmlbars-util/object-utils",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    function merge(options, defaults) {
+      for (var prop in defaults) {
+        if (options.hasOwnProperty(prop)) { continue; }
+        options[prop] = defaults[prop];
       }
+      return options;
+    }
 
-      if (didChange) {
-        element.setAttribute('class', existingClasses.length > 0 ? existingClasses.join(' ') : '');
-      }
+    __exports__.merge = merge;
+  });
+enifed("htmlbars-util/quoting",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    function escapeString(str) {
+      str = str.replace(/\\/g, "\\\\");
+      str = str.replace(/"/g, '\\"');
+      str = str.replace(/\n/g, "\\n");
+      return str;
     }
 
-    function removeClassesViaAttribute(element, classNames) {
-      var existingClasses = buildClassList(element);
+    __exports__.escapeString = escapeString;
 
-      var indexes = intersect(classNames, existingClasses);
-      var didChange = false;
-      var newClasses = [];
+    function string(str) {
+      return '"' + escapeString(str) + '"';
+    }
 
-      for (var i=0, l=existingClasses.length; i<l; i++) {
-        if (indexes[i] === undefined) {
-          newClasses.push(existingClasses[i]);
-        } else {
-          didChange = true;
-        }
-      }
+    __exports__.string = string;
 
-      if (didChange) {
-        element.setAttribute('class', newClasses.length > 0 ? newClasses.join(' ') : '');
-      }
+    function array(a) {
+      return "[" + a + "]";
     }
 
-    var addClasses, removeClasses;
-    if (canClassList) {
-      addClasses = function addClasses(element, classNames) {
-        if (element.classList) {
-          if (classNames.length === 1) {
-            element.classList.add(classNames[0]);
-          } else if (classNames.length === 2) {
-            element.classList.add(classNames[0], classNames[1]);
-          } else {
-            element.classList.add.apply(element.classList, classNames);
-          }
-        } else {
-          addClassesViaAttribute(element, classNames);
-        }
-      };
-      removeClasses = function removeClasses(element, classNames) {
-        if (element.classList) {
-          if (classNames.length === 1) {
-            element.classList.remove(classNames[0]);
-          } else if (classNames.length === 2) {
-            element.classList.remove(classNames[0], classNames[1]);
-          } else {
-            element.classList.remove.apply(element.classList, classNames);
-          }
-        } else {
-          removeClassesViaAttribute(element, classNames);
-        }
-      };
-    } else {
-      addClasses = addClassesViaAttribute;
-      removeClasses = removeClassesViaAttribute;
-    }
+    __exports__.array = array;
 
-    __exports__.addClasses = addClasses;
-    __exports__.removeClasses = removeClasses;
-  });
-enifed("morph/dom-helper/prop",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    function isAttrRemovalValue(value) {
-      return value === null || value === undefined;
+    function hash(pairs) {
+      return "{" + pairs.join(", ") + "}";
     }
 
-    __exports__.isAttrRemovalValue = isAttrRemovalValue;// TODO should this be an o_create kind of thing?
-    var propertyCaches = {};
-    __exports__.propertyCaches = propertyCaches;
-    function normalizeProperty(element, attrName) {
-      var tagName = element.tagName;
-      var key;
-      var cache = propertyCaches[tagName];
-      if (!cache) {
-        // TODO should this be an o_create kind of thing?
-        cache = {};
-        for (key in element) {
-          cache[key.toLowerCase()] = key;
-        }
-        propertyCaches[tagName] = cache;
+    __exports__.hash = hash;function repeat(chars, times) {
+      var str = "";
+      while (times--) {
+        str += chars;
       }
-
-      // presumes that the attrName has been lowercased.
-      return cache[attrName];
+      return str;
     }
 
-    __exports__.normalizeProperty = normalizeProperty;
+    __exports__.repeat = repeat;
+  });
+enifed("htmlbars-util/safe-string",
+  ["./handlebars/safe-string","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var SafeString = __dependency1__["default"];
+
+    __exports__["default"] = SafeString;
   });
-enifed("morph/morph",
-  ["exports"],
-  function(__exports__) {
+enifed("morph-attr",
+  ["./morph-attr/sanitize-attribute-value","./dom-helper/prop","./dom-helper/build-html-dom","./htmlbars-util","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
     "use strict";
-    var splice = Array.prototype.splice;
+    var sanitizeAttributeValue = __dependency1__.sanitizeAttributeValue;
+    var isAttrRemovalValue = __dependency2__.isAttrRemovalValue;
+    var normalizeProperty = __dependency2__.normalizeProperty;
+    var svgNamespace = __dependency3__.svgNamespace;
+    var getAttrNamespace = __dependency4__.getAttrNamespace;
 
-    function ensureStartEnd(start, end) {
-      if (start === null || end === null) {
-        throw new Error('a fragment parent must have boundary nodes in order to detect insertion');
-      }
+    function updateProperty(value) {
+      this.domHelper.setPropertyStrict(this.element, this.attrName, value);
     }
 
-    function ensureContext(contextualElement) {
-      if (!contextualElement || contextualElement.nodeType !== 1) {
-        throw new Error('An element node must be provided for a contextualElement, you provided ' +
-                        (contextualElement ? 'nodeType ' + contextualElement.nodeType : 'nothing'));
+    function updateAttribute(value) {
+      if (isAttrRemovalValue(value)) {
+        this.domHelper.removeAttribute(this.element, this.attrName);
+      } else {
+        this.domHelper.setAttribute(this.element, this.attrName, value);
       }
     }
 
-    // TODO: this is an internal API, this should be an assert
-    function Morph(parent, start, end, domHelper, contextualElement) {
-      if (parent.nodeType === 11) {
-        ensureStartEnd(start, end);
-        this.element = null;
+    function updateAttributeNS(value) {
+      if (isAttrRemovalValue(value)) {
+        this.domHelper.removeAttribute(this.element, this.attrName);
       } else {
-        this.element = parent;
+        this.domHelper.setAttributeNS(this.element, this.namespace, this.attrName, value);
       }
-      this._parent = parent;
-      this.start = start;
-      this.end = end;
-      this.domHelper = domHelper;
-      ensureContext(contextualElement);
-      this.contextualElement = contextualElement;
-      this.escaped = true;
-      this.reset();
     }
 
-    Morph.prototype.reset = function() {
-      this.text = null;
-      this.owner = null;
-      this.morphs = null;
-      this.before = null;
-      this.after = null;
-    };
+    function AttrMorph(element, attrName, domHelper, namespace) {
+      this.element = element;
+      this.domHelper = domHelper;
+      this.namespace = namespace !== undefined ? namespace : getAttrNamespace(attrName);
+      this.escaped = true;
 
-    Morph.prototype.parent = function () {
-      if (!this.element) {
-        var parent = this.start.parentNode;
-        if (this._parent !== parent) {
-          this._parent = parent;
-        }
-        if (parent.nodeType === 1) {
-          this.element = parent;
+      var normalizedAttrName = normalizeProperty(this.element, attrName);
+      if (this.namespace) {
+        this._update = updateAttributeNS;
+        this.attrName = attrName;
+      } else {
+        if (element.namespaceURI === svgNamespace || attrName === 'style' || !normalizedAttrName) {
+          this.attrName = attrName;
+          this._update = updateAttribute;
+        } else {
+          this.attrName = normalizedAttrName;
+          this._update = updateProperty;
         }
       }
-      return this._parent;
-    };
+    }
 
-    Morph.prototype.destroy = function () {
-      if (this.owner) {
-        this.owner.removeMorph(this);
+    AttrMorph.prototype.setContent = function (value) {
+      if (this.escaped) {
+        var sanitized = sanitizeAttributeValue(this.domHelper, this.element, this.attrName, value);
+        this._update(sanitized, this.namespace);
       } else {
-        clear(this.element || this.parent(), this.start, this.end);
+        this._update(value, this.namespace);
       }
     };
 
-    Morph.prototype.removeMorph = function (morph) {
-      var morphs = this.morphs;
-      for (var i=0, l=morphs.length; i<l; i++) {
-        if (morphs[i] === morph) {
-          this.replace(i, 1);
-          break;
-        }
-      }
-    };
+    __exports__["default"] = AttrMorph;
+
+    __exports__.sanitizeAttributeValue = sanitizeAttributeValue;
+  });
+enifed("morph-attr/sanitize-attribute-value",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /* jshint scripturl:true */
 
-    Morph.prototype.setContent = function (nodeOrString) {
-      this._update(this.element || this.parent(), nodeOrString);
+    var badProtocols = {
+      'javascript:': true,
+      'vbscript:': true
     };
 
-    Morph.prototype.updateNode = function (node) {
-      var parent = this.element || this.parent();
-      if (!node) {
-        return this._updateText(parent, '');
-      }
-      this._updateNode(parent, node);
+    var badTags = {
+      'A': true,
+      'BODY': true,
+      'LINK': true,
+      'IMG': true,
+      'IFRAME': true,
+      'BASE': true
     };
 
-    Morph.prototype.updateText = function (text) {
-      this._updateText(this.element || this.parent(), text);
+    var badTagsForDataURI = {
+      'EMBED': true
     };
 
-    Morph.prototype.updateHTML = function (html) {
-      var parent = this.element || this.parent();
-      if (!html) {
-        return this._updateText(parent, '');
-      }
-      this._updateHTML(parent, html);
+    var badAttributes = {
+      'href': true,
+      'src': true,
+      'background': true
+    };
+    __exports__.badAttributes = badAttributes;
+    var badAttributesForDataURI = {
+      'src': true
     };
 
-    Morph.prototype._update = function (parent, nodeOrString) {
-      if (nodeOrString === null || nodeOrString === undefined) {
-        this._updateText(parent, '');
-      } else if (typeof nodeOrString === 'string') {
-        if (this.escaped) {
-          this._updateText(parent, nodeOrString);
-        } else {
-          this._updateHTML(parent, nodeOrString);
-        }
-      } else if (nodeOrString.nodeType) {
-        this._updateNode(parent, nodeOrString);
-      } else if (nodeOrString.string) { // duck typed SafeString
-        this._updateHTML(parent, nodeOrString.string);
+    function sanitizeAttributeValue(dom, element, attribute, value) {
+      var tagName;
+
+      if (!element) {
+        tagName = null;
       } else {
-        this._updateText(parent, nodeOrString.toString());
+        tagName = element.tagName.toUpperCase();
       }
-    };
 
-    Morph.prototype._updateNode = function (parent, node) {
-      if (this.text) {
-        if (node.nodeType === 3) {
-          this.text.nodeValue = node.nodeValue;
-          return;
-        } else {
-          this.text = null;
-        }
-      }
-      var start = this.start, end = this.end;
-      clear(parent, start, end);
-      parent.insertBefore(node, end);
-      if (this.before !== null) {
-        this.before.end = start.nextSibling;
+      if (value && value.toHTML) {
+        return value.toHTML();
       }
-      if (this.after !== null) {
-        this.after.start = end.previousSibling;
+
+      if ((tagName === null || badTags[tagName]) && badAttributes[attribute]) {
+        var protocol = dom.protocolForURL(value);
+        if (badProtocols[protocol] === true) {
+          return 'unsafe:' + value;
+        }
       }
-    };
 
-    Morph.prototype._updateText = function (parent, text) {
-      if (this.text) {
-        this.text.nodeValue = text;
-        return;
+      if (badTagsForDataURI[tagName] && badAttributesForDataURI[attribute]) {
+        return 'unsafe:' + value;
       }
-      var node = this.domHelper.createTextNode(text);
-      this.text = node;
-      clear(parent, this.start, this.end);
-      parent.insertBefore(node, this.end);
-      if (this.before !== null) {
-        this.before.end = node;
+
+      return value;
+    }
+
+    __exports__.sanitizeAttributeValue = sanitizeAttributeValue;
+  });
+enifed("morph-range",
+  ["./morph-range/utils","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var clear = __dependency1__.clear;
+    var insertBefore = __dependency1__.insertBefore;
+
+    function Morph(domHelper, contextualElement) {
+      this.domHelper = domHelper;
+      // context if content if current content is detached
+      this.contextualElement = contextualElement;
+
+      // flag to force text to setContent to be treated as html
+      this.parseTextAsHTML = false;
+
+      this.firstNode = null;
+      this.lastNode  = null;
+
+      // morph graph
+      this.parentMorph     = null;
+      this.firstChildMorph = null;
+      this.lastChildMorph  = null;
+
+      this.previousMorph = null;
+      this.nextMorph = null;
+    }
+
+    Morph.prototype.setContent = function Morph$setContent(content) {
+      if (content === null || content === undefined) {
+        return this.clear();
       }
-      if (this.after !== null) {
-        this.after.start = node;
+
+      var type = typeof content;
+      switch (type) {
+        case 'string':
+          if (this.parseTextAsHTML) {
+            return this.setHTML(content);
+          }
+          return this.setText(content);
+        case 'object':
+          if (typeof content.nodeType === 'number') {
+            return this.setNode(content);
+          }
+          /* Handlebars.SafeString */
+          if (typeof content.string === 'string') {
+            return this.setHTML(content.string);
+          }
+          if (this.parseTextAsHTML) {
+            return this.setHTML(content.toString());
+          }
+          /* falls through */
+        case 'boolean':
+        case 'number':
+          return this.setText(content.toString());
+        default:
+          throw new TypeError('unsupported content');
       }
     };
 
-    Morph.prototype._updateHTML = function (parent, html) {
-      var start = this.start, end = this.end;
-      clear(parent, start, end);
-      this.text = null;
-      var childNodes = this.domHelper.parseHTML(html, this.contextualElement);
-      appendChildren(parent, end, childNodes);
-      if (this.before !== null) {
-        this.before.end = start.nextSibling;
-      }
-      if (this.after !== null) {
-        this.after.start = end.previousSibling;
-      }
+    Morph.prototype.clear = function Morph$clear() {
+      return this.setNode(this.domHelper.createComment(''));
     };
 
-    Morph.prototype.append = function (node) {
-      if (this.morphs === null) {
-        this.morphs = [];
+    Morph.prototype.setText = function Morph$setText(text) {
+      var firstNode = this.firstNode;
+      var lastNode = this.lastNode;
+
+      if (firstNode &&
+          lastNode === firstNode &&
+          firstNode.nodeType === 3) {
+        firstNode.nodeValue = text;
+        return firstNode;
       }
-      var index = this.morphs.length;
-      return this.insert(index, node);
+
+      return this.setNode(
+        text ? this.domHelper.createTextNode(text) : this.domHelper.createComment('')
+      );
     };
 
-    Morph.prototype.insert = function (index, node) {
-      if (this.morphs === null) {
-        this.morphs = [];
+    Morph.prototype.setNode = function Morph$setNode(newNode) {
+      var firstNode, lastNode;
+      switch (newNode.nodeType) {
+        case 3:
+          firstNode = newNode;
+          lastNode = newNode;
+          break;
+        case 11:
+          firstNode = newNode.firstChild;
+          lastNode = newNode.lastChild;
+          if (firstNode === null) {
+            firstNode = this.domHelper.createComment('');
+            newNode.appendChild(firstNode);
+            lastNode = firstNode;
+          }
+          break;
+        default:
+          firstNode = newNode;
+          lastNode = newNode;
+          break;
       }
-      var parent = this.element || this.parent();
-      var morphs = this.morphs;
-      var before = index > 0 ? morphs[index-1] : null;
-      var after  = index < morphs.length ? morphs[index] : null;
-      var start  = before === null ? this.start : (before.end === null ? parent.lastChild : before.end.previousSibling);
-      var end    = after === null ? this.end : (after.start === null ? parent.firstChild : after.start.nextSibling);
-      var morph  = new Morph(parent, start, end, this.domHelper, this.contextualElement);
 
-      morph.owner = this;
-      morph._update(parent, node);
+      var previousFirstNode = this.firstNode;
+      if (previousFirstNode !== null) {
 
-      if (before !== null) {
-        morph.before = before;
-        before.end = start.nextSibling;
-        before.after = morph;
+        var parentNode = previousFirstNode.parentNode;
+        insertBefore(parentNode, firstNode, lastNode, previousFirstNode);
+        clear(parentNode, previousFirstNode, this.lastNode);
       }
 
-      if (after !== null) {
-        morph.after = after;
-        after.before = morph;
-        after.start = end.previousSibling;
+      this.firstNode = firstNode;
+      this.lastNode  = lastNode;
+
+      if (this.parentMorph) {
+        syncFirstNode(this);
+        syncLastNode(this);
       }
 
-      this.morphs.splice(index, 0, morph);
-      return morph;
+      return newNode;
     };
 
-    Morph.prototype.replace = function (index, removedLength, addedNodes) {
-      if (this.morphs === null) {
-        this.morphs = [];
-      }
-      var parent = this.element || this.parent();
-      var morphs = this.morphs;
-      var before = index > 0 ? morphs[index-1] : null;
-      var after = index+removedLength < morphs.length ? morphs[index+removedLength] : null;
-      var start = before === null ? this.start : (before.end === null ? parent.lastChild : before.end.previousSibling);
-      var end   = after === null ? this.end : (after.start === null ? parent.firstChild : after.start.nextSibling);
-      var addedLength = addedNodes === undefined ? 0 : addedNodes.length;
-      var args, i, current;
+    function syncFirstNode(_morph) {
+      var morph = _morph;
+      var parentMorph;
+      while (parentMorph = morph.parentMorph) {
+        if (morph !== parentMorph.firstChildMorph) {
+          break;
+        }
+        if (morph.firstNode === parentMorph.firstNode) {
+          break;
+        }
 
-      if (removedLength > 0) {
-        clear(parent, start, end);
+        parentMorph.firstNode = morph.firstNode;
+
+        morph = parentMorph;
       }
+    }
 
-      if (addedLength === 0) {
-        if (before !== null) {
-          before.after = after;
-          before.end = end;
+    function syncLastNode(_morph) {
+      var morph = _morph;
+      var parentMorph;
+      while (parentMorph = morph.parentMorph) {
+        if (morph !== parentMorph.lastChildMorph) {
+          break;
         }
-        if (after !== null) {
-          after.before = before;
-          after.start = start;
+        if (morph.lastNode === parentMorph.lastNode) {
+          break;
         }
-        morphs.splice(index, removedLength);
-        return;
+
+        parentMorph.lastNode = morph.lastNode;
+
+        morph = parentMorph;
       }
+    }
 
-      args = new Array(addedLength+2);
-      if (addedLength > 0) {
-        for (i=0; i<addedLength; i++) {
-          args[i+2] = current = new Morph(parent, start, end, this.domHelper, this.contextualElement);
-          current._update(parent, addedNodes[i]);
-          current.owner = this;
-          if (before !== null) {
-            current.before = before;
-            before.end = start.nextSibling;
-            before.after = current;
-          }
-          before = current;
-          start = end === null ? parent.lastChild : end.previousSibling;
+    // return morph content to an undifferentiated state
+    // drops knowledge that the node has content.
+    // this is for rerender, I need to test, but basically
+    // the idea is to leave the content, but allow render again
+    // without appending, so n
+    Morph.prototype.reset = function Morph$reset() {
+      this.firstChildMorph = null;
+      this.lastChildMorph = null;
+    };
+
+    Morph.prototype.destroy = function Morph$destroy() {
+      var parentMorph = this.parentMorph;
+      var previousMorph = this.previousMorph;
+      var nextMorph = this.nextMorph;
+      var firstNode = this.firstNode;
+      var lastNode = this.lastNode;
+      var parentNode = firstNode && firstNode.parentNode;
+
+      if (previousMorph) {
+        if (nextMorph) {
+          previousMorph.nextMorph = nextMorph;
+          nextMorph.previousMorph = previousMorph;
+        } else {
+          previousMorph.nextMorph = null;
+          if (parentMorph) { parentMorph.lastChildMorph = previousMorph; }
+        }
+      } else {
+        if (nextMorph) {
+          nextMorph.previousMorph = null;
+          if (parentMorph) { parentMorph.firstChildMorph = nextMorph; }
+        } else if (parentMorph) {
+          parentMorph.lastChildMorph = parentMorph.firstChildMorph = null;
         }
-        if (after !== null) {
-          current.after = after;
-          after.before = current;
-          after.start = end.previousSibling;
+      }
+
+      this.parentMorph = null;
+      this.firstNode = null;
+      this.lastNode = null;
+
+      if (parentMorph) {
+        if (!parentMorph.firstChildMorph) {
+          // list is empty
+          parentMorph.clear();
+          return;
+        } else {
+          syncFirstNode(parentMorph.firstChildMorph);
+          syncLastNode(parentMorph.lastChildMorph);
         }
       }
 
-      args[0] = index;
-      args[1] = removedLength;
+      clear(parentNode, firstNode, lastNode);
+    };
+
+    Morph.prototype.setHTML = function(text) {
+      var fragment = this.domHelper.parseHTML(text, this.contextualElement);
+      return this.setNode(fragment);
+    };
+
+    Morph.prototype.appendContent = function(content) {
+      return this.insertContentBeforeMorph(content, null);
+    };
 
-      splice.apply(morphs, args);
+    Morph.prototype.insertContentBeforeMorph = function (content, referenceMorph) {
+      var morph = new Morph(this.domHelper, this.contextualElement);
+      morph.setContent(content);
+      this.insertBeforeMorph(morph, referenceMorph);
+      return morph;
     };
 
-    function appendChildren(parent, end, nodeList) {
-      var ref = end;
-      var i = nodeList.length;
-      var node;
+    Morph.prototype.appendMorph = function(morph) {
+      this.insertBeforeMorph(morph, null);
+    };
 
-      while (i--) {
-        node = nodeList[i];
-        parent.insertBefore(node, ref);
-        ref = node;
+    Morph.prototype.insertBeforeMorph = function(morph, referenceMorph) {
+      if (referenceMorph && referenceMorph.parentMorph !== this) {
+        throw new Error('The morph before which the new morph is to be inserted is not a child of this morph.');
       }
-    }
 
-    function clear(parent, start, end) {
-      var current, previous;
-      if (end === null) {
-        current = parent.lastChild;
+      morph.parentMorph = this;
+
+      var parentNode = this.firstNode.parentNode;
+
+      insertBefore(
+        parentNode,
+        morph.firstNode,
+        morph.lastNode,
+        referenceMorph ? referenceMorph.firstNode : this.lastNode.nextSibling
+      );
+
+      // was not in list mode replace current content
+      if (!this.firstChildMorph) {
+        clear(parentNode, this.firstNode, this.lastNode);
+      }
+
+      var previousMorph = referenceMorph ? referenceMorph.previousMorph : this.lastChildMorph;
+      if (previousMorph) {
+        previousMorph.nextMorph = morph;
+        morph.previousMorph = previousMorph;
       } else {
-        current = end.previousSibling;
+        this.firstChildMorph = morph;
       }
 
-      while (current !== null && current !== start) {
-        previous = current.previousSibling;
-        parent.removeChild(current);
-        current = previous;
+      if (referenceMorph) {
+        referenceMorph.previousMorph = morph;
+        morph.nextMorph = referenceMorph;
+      } else {
+        this.lastChildMorph = morph;
       }
-    }
+
+      syncFirstNode(this.firstChildMorph);
+      syncLastNode(this.lastChildMorph);
+    };
 
     __exports__["default"] = Morph;
   });
+enifed("morph-range/utils",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    // inclusive of both nodes
+    function clear(parentNode, firstNode, lastNode) {
+      if (!parentNode) { return; }
+
+      var node = firstNode;
+      var nextNode;
+      do {
+        nextNode = node.nextSibling;
+        parentNode.removeChild(node);
+        if (node === lastNode) {
+          break;
+        }
+        node = nextNode;
+      } while (node);
+    }
+
+    __exports__.clear = clear;function insertBefore(parentNode, firstNode, lastNode, _refNode) {
+      var node = lastNode;
+      var refNode = _refNode;
+      var prevNode;
+      do {
+        prevNode = node.previousSibling;
+        parentNode.insertBefore(node, refNode);
+        if (node === firstNode) {
+          break;
+        }
+        refNode = node;
+        node = prevNode;
+      } while (node);
+    }
+
+    __exports__.insertBefore = insertBefore;
+  });
 enifed("route-recognizer",
   ["./route-recognizer/dsl","exports"],
   function(__dependency1__, __exports__) {
@@ -47910,25 +44359,10 @@ enifed("route-recognizer",
 
     RouteRecognizer.prototype.map = map;
 
-    RouteRecognizer.VERSION = '1.10.0';
+    RouteRecognizer.VERSION = '0.1.5';
 
     __exports__["default"] = RouteRecognizer;
   });
-enifed("route-recognizer.umd",
-  ["./route-recognizer"],
-  function(__dependency1__) {
-    "use strict";
-    var RouteRecognizer = __dependency1__["default"];
-
-    /* global define:true module:true window: true */
-    if (typeof enifed === 'function' && enifed['amd']) {
-      enifed(function() { return RouteRecognizer; });
-    } else if (typeof module !== 'undefined' && module['exports']) {
-      module['exports'] = RouteRecognizer;
-    } else if (typeof this !== 'undefined') {
-      this['RouteRecognizer'] = RouteRecognizer;
-    }
-  });
 enifed("route-recognizer/dsl",
   ["exports"],
   function(__exports__) {
@@ -48394,7 +44828,17 @@ enifed("router/router",
 
     var pop = Array.prototype.pop;
 
-    function Router() {
+    function Router(_options) {
+      var options = _options || {};
+      this.getHandler = options.getHandler || this.getHandler;
+      this.updateURL = options.updateURL || this.updateURL;
+      this.replaceURL = options.replaceURL || this.replaceURL;
+      this.didTransition = options.didTransition || this.didTransition;
+      this.willTransition = options.willTransition || this.willTransition;
+      this.delegate = options.delegate || this.delegate;
+      this.triggerEvent = options.triggerEvent || this.triggerEvent;
+      this.log = options.log || this.log;
+
       this.recognizer = new RouteRecognizer();
       this.reset();
     }
@@ -48418,7 +44862,7 @@ enifed("router/router",
         }
 
         // No-op. No need to create a new transition.
-        return new Transition(this);
+        return this.activeTransition || new Transition(this);
       }
 
       if (isIntermediate) {
@@ -48478,6 +44922,8 @@ enifed("router/router",
         return this.recognizer.hasRoute(route);
       },
 
+      getHandler: function() {},
+
       queryParamsTransition: function(changelist, wasTransitioning, oldState, newState) {
         var router = this;
 
@@ -48672,8 +45118,9 @@ enifed("router/router",
         return intent.applyToState(state, this.recognizer, this.getHandler);
       },
 
-      isActiveIntent: function(handlerName, contexts, queryParams) {
-        var targetHandlerInfos = this.state.handlerInfos,
+      isActiveIntent: function(handlerName, contexts, queryParams, _state) {
+        var state = _state || this.state,
+            targetHandlerInfos = state.handlerInfos,
             found = false, names, object, handlerInfo, handlerObj, i, len;
 
         if (!targetHandlerInfos.length) { return false; }
@@ -48692,8 +45139,8 @@ enifed("router/router",
           return false;
         }
 
-        var state = new TransitionState();
-        state.handlerInfos = targetHandlerInfos.slice(0, index + 1);
+        var testState = new TransitionState();
+        testState.handlerInfos = targetHandlerInfos.slice(0, index + 1);
         recogHandlers = recogHandlers.slice(0, index + 1);
 
         var intent = new NamedTransitionIntent({
@@ -48701,9 +45148,9 @@ enifed("router/router",
           contexts: contexts
         });
 
-        var newState = intent.applyToHandlers(state, recogHandlers, this.getHandler, targetHandler, true, true);
+        var newState = intent.applyToHandlers(testState, recogHandlers, this.getHandler, targetHandler, true, true);
 
-        var handlersEqual = handlerInfosEqual(newState.handlerInfos, state.handlerInfos);
+        var handlersEqual = handlerInfosEqual(newState.handlerInfos, testState.handlerInfos);
         if (!queryParams || !handlersEqual) {
           return handlersEqual;
         }
@@ -48712,7 +45159,7 @@ enifed("router/router",
         var activeQPsOnNewHandler = {};
         merge(activeQPsOnNewHandler, queryParams);
 
-        var activeQueryParams  = this.state.queryParams;
+        var activeQueryParams  = state.queryParams;
         for (var key in activeQueryParams) {
           if (activeQueryParams.hasOwnProperty(key) &&
               activeQPsOnNewHandler.hasOwnProperty(key)) {
@@ -48738,16 +45185,7 @@ enifed("router/router",
 
         @param {String} message The message to log.
       */
-      log: null,
-
-      _willChangeContextEvent: 'willChangeContext',
-      _triggerWillChangeContext: function(handlerInfos, newTransition) {
-        trigger(this, handlerInfos, true, [this._willChangeContextEvent, newTransition]);
-      },
-
-      _triggerWillLeave: function(handlerInfos, newTransition, leavingChecker) {
-        trigger(this, handlerInfos, true, ['willLeave', newTransition, leavingChecker]);
-      }
+      log: null
     };
 
     /**
@@ -48811,32 +45249,33 @@ enifed("router/router",
     */
     function setupContexts(router, newState, transition) {
       var partition = partitionHandlers(router.state, newState);
+      var i, l, handler;
 
-      forEach(partition.exited, function(handlerInfo) {
-        var handler = handlerInfo.handler;
+      for (i=0, l=partition.exited.length; i<l; i++) {
+        handler = partition.exited[i].handler;
         delete handler.context;
 
         callHook(handler, 'reset', true, transition);
         callHook(handler, 'exit', transition);
-      });
+      }
 
       var oldState = router.oldState = router.state;
       router.state = newState;
       var currentHandlerInfos = router.currentHandlerInfos = partition.unchanged.slice();
 
       try {
-        forEach(partition.reset, function(handlerInfo) {
-          var handler = handlerInfo.handler;
+        for (i=0, l=partition.reset.length; i<l; i++) {
+          handler = partition.reset[i].handler;
           callHook(handler, 'reset', false, transition);
-        });
+        }
 
-        forEach(partition.updatedContext, function(handlerInfo) {
-          return handlerEnteredOrUpdated(currentHandlerInfos, handlerInfo, false, transition);
-        });
+        for (i=0, l=partition.updatedContext.length; i<l; i++) {
+          handlerEnteredOrUpdated(currentHandlerInfos, partition.updatedContext[i], false, transition);
+        }
 
-        forEach(partition.entered, function(handlerInfo) {
-          return handlerEnteredOrUpdated(currentHandlerInfos, handlerInfo, true, transition);
-        });
+        for (i=0, l=partition.entered.length; i<l; i++) {
+          handlerEnteredOrUpdated(currentHandlerInfos, partition.entered[i], true, transition);
+        }
       } catch(e) {
         router.state = oldState;
         router.currentHandlerInfos = oldState.handlerInfos;
@@ -49176,15 +45615,13 @@ enifed("router/router",
           }
           return false;
         };
-
-        router._triggerWillLeave(leaving, newTransition, leavingChecker);
-      }
-
-      if (changing.length > 0) {
-        router._triggerWillChangeContext(changing, newTransition);
       }
 
       trigger(router, oldHandlers, true, ['willTransition', newTransition]);
+
+      if (router.willTransition) {
+        router.willTransition(oldHandlers, newState.handlerInfos, newTransition);
+      }
     }
 
     __exports__["default"] = Router;
@@ -49411,8 +45848,8 @@ enifed("router/transition-intent/named-transition-intent",
     });
   });
 enifed("router/transition-intent/url-transition-intent",
-  ["../transition-intent","../transition-state","../handler-info/factory","../utils","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+  ["../transition-intent","../transition-state","../handler-info/factory","../utils","./../unrecognized-url-error","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
     "use strict";
     var TransitionIntent = __dependency1__["default"];
     var TransitionState = __dependency2__["default"];
@@ -49420,6 +45857,7 @@ enifed("router/transition-intent/url-transition-intent",
     var oCreate = __dependency4__.oCreate;
     var merge = __dependency4__.merge;
     var subclass = __dependency4__.subclass;
+    var UnrecognizedURLError = __dependency5__["default"];
 
     __exports__["default"] = subclass(TransitionIntent, {
       url: null,
@@ -49470,15 +45908,6 @@ enifed("router/transition-intent/url-transition-intent",
         return newState;
       }
     });
-
-    /**
-      Promise reject reasons passed to promise rejection
-      handlers for failed transitions.
-     */
-    function UnrecognizedURLError(message) {
-      this.message = (message || "UnrecognizedURLError");
-      this.name = "UnrecognizedURLError";
-    }
   });
 enifed("router/transition-state",
   ["./handler-info","./utils","rsvp/promise","exports"],
@@ -49908,6 +46337,26 @@ enifed("router/transition",
     __exports__.logAbort = logAbort;
     __exports__.TransitionAborted = TransitionAborted;
   });
+enifed("router/unrecognized-url-error",
+  ["./utils","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var oCreate = __dependency1__.oCreate;
+
+    /**
+      Promise reject reasons passed to promise rejection
+      handlers for failed transitions.
+     */
+    function UnrecognizedURLError(message) {
+      this.message = (message || "UnrecognizedURLError");
+      this.name = "UnrecognizedURLError";
+      Error.call(this);
+    }
+
+    UnrecognizedURLError.prototype = oCreate(Error.prototype);
+
+    __exports__["default"] = UnrecognizedURLError;
+  });
 enifed("router/utils",
   ["exports"],
   function(__exports__) {
@@ -50107,15 +46556,23 @@ enifed("router/utils",
              obj[hookName] && hookName;
     }
 
-    function callHook(obj, hookName) {
-      var args = slice.call(arguments, 2);
-      return applyHook(obj, hookName, args);
+    function callHook(obj, _hookName, arg1, arg2) {
+      var hookName = resolveHook(obj, _hookName);
+      return hookName && obj[hookName].call(obj, arg1, arg2);
     }
 
     function applyHook(obj, _hookName, args) {
       var hookName = resolveHook(obj, _hookName);
       if (hookName) {
-        return obj[hookName].apply(obj, args);
+        if (args.length === 0) {
+          return obj[hookName].call(obj);
+        } else if (args.length === 1) {
+          return obj[hookName].call(obj, args[0]);
+        } else if (args.length === 2) {
+          return obj[hookName].call(obj, args[0], args[1]);
+        } else {
+          return obj[hookName].apply(obj, args);
+        }
       }
     }
 
@@ -51992,7 +48449,7 @@ enifed("rsvp/promise",
     /**
       Promise objects represent the eventual result of an asynchronous operation. The
       primary way of interacting with a promise is through its `then` method, which
-      registers callbacks to receive either a promise’s eventual value or the reason
+      registers callbacks to receive either a promise’s eventual value or the reason
       why the promise cannot be fulfilled.
 
       Terminology
@@ -52871,4 +49328,4 @@ enifed("rsvp/utils",
   });
 requireModule("ember");
 
-})();
+})();
\ No newline at end of file