ember-source 1.13.3 → 1.13.4

data/dist/ember.js

@@ -5,7 +5,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   1.13.3
+ * @version   1.13.4
  */
 
 (function() {
@@ -5473,15 +5473,46 @@ enifed("ember-debug", ["exports", "ember-metal/core", "ember-metal/error", "embe
   
     @method deprecateFunc
     @param {String} message A description of the deprecation.
+    @param {Object} [options] The options object for Ember.deprecate.
     @param {Function} func The new function called to replace its deprecated counterpart.
     @return {Function} a new function that wrapped the original function with a deprecation warning
     @private
   */
-  _emberMetalCore["default"].deprecateFunc = function (message, func) {
-    return function () {
-      _emberMetalCore["default"].deprecate(message);
-      return func.apply(this, arguments);
-    };
+  _emberMetalCore["default"].deprecateFunc = function () {
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    if (args.length === 3) {
+      var _ret = (function () {
+        var message = args[0];
+        var options = args[1];
+        var func = args[2];
+
+        return {
+          v: function () {
+            _emberMetalCore["default"].deprecate(message, false, options);
+            return func.apply(this, arguments);
+          }
+        };
+      })();
+
+      if (typeof _ret === "object") return _ret.v;
+    } else {
+      var _ret2 = (function () {
+        var message = args[0];
+        var func = args[1];
+
+        return {
+          v: function () {
+            _emberMetalCore["default"].deprecate(message);
+            return func.apply(this, arguments);
+          }
+        };
+      })();
+
+      if (typeof _ret2 === "object") return _ret2.v;
+    }
   };
 
   /**
@@ -5489,10 +5520,10 @@ enifed("ember-debug", ["exports", "ember-metal/core", "ember-metal/error", "embe
     `Ember.runInDebug()` when doing a production build.
   
     ```javascript
-    Ember.runInDebug(function() {
-      Ember.Handlebars.EachView.reopen({
-        didInsertElement: function() {
-          console.log('I\'m happy');
+    Ember.runInDebug(() => {
+      Ember.Component.reopen({
+        didInsertElement() {
+          console.log("I'm happy");
         }
       });
     });
@@ -6254,6 +6285,30 @@ enifed("ember-htmlbars", ["exports", "ember-metal/core", "ember-template-compile
     _emberMetalCore["default"].Helper = _emberHtmlbarsHelper["default"];
   }
 });
+/**
+
+  &nbsp;
+
+  @module ember
+  @submodule ember-templates
+  @main ember-templates
+  @public
+*/
+
+/**
+
+  [HTMLBars](https://github.com/tildeio/htmlbars) is a [Handlebars](http://handlebarsjs.com/)
+  compatible templating engine used by Ember.js. The classes and namespaces
+  covered by this documentation attempt to focus on APIs for interacting
+  with HTMLBars itself. For more general guidance on Ember.js templates and
+  helpers, please see the [ember-templates](/api/modules/ember-templates.html)
+  package.
+
+  @module ember
+  @submodule ember-htmlbars
+  @main ember-htmlbars
+  @public
+*/
 
 // importing adds template bootstrapping
 // initializer to enable embedded templates
@@ -6468,8 +6523,6 @@ enifed("ember-htmlbars/compat/make-bound-helper", ["exports", "ember-metal/strea
   @submodule ember-htmlbars
   */
 
-  //import Helper from "ember-htmlbars/system/helper";
-
   /**
     A helper function used by `registerBoundHelper`. Takes the
     provided Handlebars helper function fn and returns it in wrapped
@@ -6719,22 +6772,107 @@ enifed("ember-htmlbars/env", ["exports", "ember-metal/environment", "htmlbars-ru
 
   exports.domHelper = domHelper;
 });
-enifed("ember-htmlbars/helper", ["exports", "ember-runtime/system/object"], function (exports, _emberRuntimeSystemObject) {
+enifed('ember-htmlbars/helper', ['exports', 'ember-runtime/system/object'], function (exports, _emberRuntimeSystemObject) {
   exports.helper = helper;
 
-  // Ember.Helper.extend({ compute(params, hash) {} });
+  /**
+    Ember Helpers are functions that can compute values, and are used in templates.
+    For example, this code calls a helper named `format-currency`:
+  
+    ```handlebars
+    <div>{{format-currency cents currency="$"}}</div>
+    ```
+  
+    Additionally a helper can be called as a nested helper (sometimes called a
+    subexpression). In this example, the computed value of a helper is passed
+    to a component named `show-money`:
+  
+    ```handlebars
+    {{show-money amount=(format-currency cents currency="$")}}
+    ```
+  
+    Helpers defined using a class must provide a `compute` function. For example:
+  
+    ```js
+    export default Ember.Helper.extend({
+      compute(params, hash) {
+        let cents = params[0];
+        let currency = hash.currency;
+        return `${currency}${cents * 0.01}`;
+      }
+    });
+    ```
+  
+    Each time the input to a helper changes, the `compute` function will be
+    called again.
+  
+    As instances, these helpers also have access to the container an will accept
+    injected dependencies.
+  
+    Additionally, class helpers can call `recompute` to force a new computation.
+  
+    @class Ember.Helper
+    @public
+  */
   var Helper = _emberRuntimeSystemObject["default"].extend({
     isHelper: true,
+
+    /**
+      On a class-based helper, it may be useful to force a recomputation of that
+      helpers value. This is akin to `rerender` on a component.
+       For example, this component will rerender when the `currentUser` on a
+      session service changes:
+       ```js
+      // app/helpers/current-user-email.js
+      export default Ember.Helper.extend({
+        session: Ember.inject.service(),
+        onNewUser: Ember.observer('session.currentUser', function() {
+          this.recompute();
+        }),
+        compute() {
+          return this.get('session.currentUser.email');
+        }
+      });
+      ```
+       @method recompute
+      @public
+    */
     recompute: function () {
       this._stream.notify();
     }
+
+    /**
+      Override this function when writing a class-based helper.
+       @method compute
+      @param {Array} params The positional arguments to the helper
+      @param {Object} hash The named arguments to the helper
+      @public
+    */
   });
 
   Helper.reopenClass({
     isHelperFactory: true
   });
 
-  // Ember.Helper.helper(function(params, hash) {});
+  /**
+    In many cases, the ceremony of a full `Ember.Helper` class is not required.
+    The `helper` method create pure-function helpers without instances. For
+    example:
+  
+    ```js
+    // app/helpers/format-currency.js
+    export default Ember.Helper.helper(function(params, hash) {
+      let cents = params[0];
+      let currency = hash.currency;
+      return `${currency}${cents * 0.01}`;
+    });
+    ```
+  
+    @static
+    @param {Function} helper The helper function
+    @method helper
+    @public
+  */
 
   function helper(helperFn) {
     return {
@@ -6745,6 +6883,10 @@ enifed("ember-htmlbars/helper", ["exports", "ember-runtime/system/object"], func
 
   exports["default"] = Helper;
 });
+/**
+@module ember
+@submodule ember-templates
+*/
 enifed("ember-htmlbars/helpers", ["exports", "ember-metal/platform/create"], function (exports, _emberMetalPlatformCreate) {
   exports.registerHelper = registerHelper;
 
@@ -7194,7 +7336,7 @@ enifed('ember-htmlbars/helpers/each', ['exports', 'ember-metal/core', 'ember-met
     ```
   
     @method each
-    @for Ember.Handlebars.helpers
+    @for Ember.Templates.helpers
     @public
   */
 
@@ -7287,7 +7429,7 @@ enifed("ember-htmlbars/helpers/if_unless", ["exports", "ember-metal/core", "embe
     ```
   
     @method if
-    @for Ember.Handlebars.helpers
+    @for Ember.Templates.helpers
     @public
   */
   function ifHelper(params, hash, options) {
@@ -7300,7 +7442,7 @@ enifed("ember-htmlbars/helpers/if_unless", ["exports", "ember-metal/core", "embe
     helper can also be used with `unless`.
   
     @method unless
-    @for Ember.Handlebars.helpers
+    @for Ember.Templates.helpers
     @public
   */
   function unlessHelper(params, hash, options) {
@@ -7332,7 +7474,7 @@ enifed("ember-htmlbars/helpers/if_unless", ["exports", "ember-metal/core", "embe
 });
 /**
 @module ember
-@submodule ember-htmlbars
+@submodule ember-templates
 */
 
 // Ember.assert
@@ -7341,32 +7483,37 @@ enifed('ember-htmlbars/helpers/loc', ['exports', 'ember-runtime/system/string'],
 
   /**
   @module ember
-  @submodule ember-htmlbars
+  @submodule ember-templates
   */
 
   /**
     Calls [Ember.String.loc](/api/classes/Ember.String.html#method_loc) with the
-    provided string.
-    This is a convenient way to localize text within a template:
+    provided string. This is a convenient way to localize text within a template.
+    For example:
+  
     ```javascript
     Ember.STRINGS = {
       '_welcome_': 'Bonjour'
     };
     ```
+  
     ```handlebars
     <div class='message'>
       {{loc '_welcome_'}}
     </div>
     ```
+  
     ```html
     <div class='message'>
       Bonjour
     </div>
     ```
+  
     See [Ember.String.loc](/api/classes/Ember.String.html#method_loc) for how to
     set up localized string references.
+  
     @method loc
-    @for Ember.Handlebars.helpers
+    @for Ember.Templates.helpers
     @param {String} str The string to format
     @see {Ember.String#loc}
     @public
@@ -7382,11 +7529,13 @@ enifed("ember-htmlbars/helpers/log", ["exports", "ember-metal/logger"], function
   /**
     `log` allows you to output the value of variables in the current rendering
     context. `log` also accepts primitive types such as strings or numbers.
+  
     ```handlebars
     {{log "myVariable:" myVariable }}
     ```
+  
     @method log
-    @for Ember.Handlebars.helpers
+    @for Ember.Templates.helpers
     @param {*} values
     @public
   */
@@ -7397,7 +7546,7 @@ enifed("ember-htmlbars/helpers/log", ["exports", "ember-metal/logger"], function
 });
 /**
 @module ember
-@submodule ember-htmlbars
+@submodule ember-templates
 */
 enifed("ember-htmlbars/helpers/with", ["exports", "ember-htmlbars/utils/normalize-self", "ember-views/streams/should_display"], function (exports, _emberHtmlbarsUtilsNormalizeSelf, _emberViewsStreamsShould_display) {
   exports["default"] = withHelper;
@@ -7429,7 +7578,7 @@ enifed("ember-htmlbars/helpers/with", ["exports", "ember-htmlbars/utils/normaliz
     the first part of the property path, `foo`. Instead, use `{{#with foo.bar as |baz|}}`.
   
     @method with
-    @for Ember.Handlebars.helpers
+    @for Ember.Templates.helpers
     @param {Object} options
     @return {String} HTML string
     @public
@@ -7464,7 +7613,7 @@ enifed("ember-htmlbars/helpers/with", ["exports", "ember-htmlbars/utils/normaliz
 });
 /**
 @module ember
-@submodule ember-htmlbars
+@submodule ember-templates
 */
 enifed("ember-htmlbars/hooks/bind-local", ["exports", "ember-metal/streams/stream", "ember-metal/streams/proxy-stream"], function (exports, _emberMetalStreamsStream, _emberMetalStreamsProxyStream) {
   exports["default"] = bindLocal;
@@ -7507,7 +7656,6 @@ enifed("ember-htmlbars/hooks/bind-self", ["exports", "ember-metal/streams/proxy-
     }
 
     if (self && self.isView) {
-      scope.view = self;
       newStream(scope.locals, "view", self, null);
       newStream(scope.locals, "controller", scope.locals.view.getKey("controller"));
       newStream(scope, "self", scope.locals.view.getKey("context"), null, true);
@@ -7664,13 +7812,59 @@ enifed("ember-htmlbars/hooks/concat", ["exports", "ember-metal/streams/utils"],
 */
 enifed("ember-htmlbars/hooks/create-fresh-scope", ["exports"], function (exports) {
   exports["default"] = createFreshScope;
+  /*
+    Ember's implementation of HTMLBars creates an enriched scope.
+  
+    * self: same as HTMLBars, this field represents the dynamic lookup
+      of root keys that are not special keywords or block arguments.
+    * blocks: same as HTMLBars, a bundle of named blocks the layout
+      can yield to.
+    * component: indicates that the scope is the layout of a component,
+      which is used to trigger lifecycle hooks for the component when
+      one of the streams in its layout fires.
+    * attrs: a map of key-value attributes sent in by the invoker of
+      a template, and available in the component's layout.
+    * locals: a map of locals, produced by block params (`as |a b|`)
+    * localPresent: a map of available locals to avoid expensive
+      `hasOwnProperty` checks.
+  
+    The `self` field has two special meanings:
+  
+    * If `self` is a view (`isView`), the actual HTMLBars `self` becomes
+      the view's `context`. This is legacy semantics; components always
+      use the component itself as the `this`.
+    * If `self` is a view, two special locals are created: `view` and
+      `controller`. These locals are legacy semantics.
+    * If self has a `hasBoundController` property, it is coming from
+      a legacy form of #with or #each
+      (`{{#with something controller=someController}}`). This has
+      the special effect of giving the child scope the supplied
+      `controller` keyword, with an unrelated `self`. This is
+      legacy functionality, as both the `view` and `controller`
+      keywords have been deprecated.
+  
+    **IMPORTANT**: There are two places in Ember where the ambient
+    controller is looked up. Both of those places use the presence
+    of `scope.locals.view` to indicate that the controller lookup
+    should be dynamic off of the ambient view. If `scope.locals.view`
+    does not exist, the code assumes that it is inside of a top-level
+    template (without a view) and uses the `self` itself as the
+    controller. This means that if you remove `scope.locals.view`
+    (perhaps because we are finally ready to shed the view keyword),
+    there may be unexpected consequences on controller semantics.
+    If this happens to you, I hope you find this comment. - YK & TD
+  
+    In practice, this means that with the exceptions of top-level
+    view-less templates and the legacy `controller=foo` semantics,
+    the controller hierarchy is managed dynamically by looking at
+    the current view's `controller`.
+  */
 
   function createFreshScope() {
     return {
       self: null,
       blocks: {},
       component: null,
-      view: null,
       attrs: null,
       locals: {},
       localPresent: {}
@@ -7701,10 +7895,9 @@ enifed("ember-htmlbars/hooks/did-cleanup-tree", ["exports"], function (exports)
   exports["default"] = didCleanupTree;
 
   function didCleanupTree(env) {
-    var view;
-    if (view = env.view) {
-      view.ownerView.isDestroyingSubtree = false;
-    }
+    // Once we have finsihed cleaning up the render node and sub-nodes, reset
+    // state tracking which view those render nodes belonged to.
+    env.view.ownerView._destroyingSubtreeForView = null;
   }
 });
 enifed("ember-htmlbars/hooks/did-render-node", ["exports"], function (exports) {
@@ -7941,7 +8134,7 @@ enifed("ember-htmlbars/hooks/link-render-node", ["exports", "ember-htmlbars/util
         case "each":
           params[0] = eachParam(params[0]);break;
         default:
-          helper = _emberHtmlbarsSystemLookupHelper.findHelper(path, scope.view, env);
+          helper = _emberHtmlbarsSystemLookupHelper.findHelper(path, env.view, env);
 
           if (helper && helper.isHandlebarsCompat && params[0]) {
             params[0] = processHandlebarsCompatDepKeys(params[0], helper._dependentKeys);
@@ -8124,7 +8317,6 @@ enifed("ember-htmlbars/hooks/update-self", ["exports", "ember-metal/property_get
     Ember.assert("BUG: scope.attrs and self.isView should not both be true", !(scope.attrs && self.isView));
 
     if (self && self.isView) {
-      scope.view = self;
       _emberHtmlbarsUtilsUpdateScope["default"](scope.locals, "view", self, null);
       _emberHtmlbarsUtilsUpdateScope["default"](scope, "self", _emberMetalProperty_get.get(self, "context"), null, true);
       return;
@@ -8140,15 +8332,37 @@ enifed("ember-htmlbars/hooks/update-self", ["exports", "ember-metal/property_get
 enifed("ember-htmlbars/hooks/will-cleanup-tree", ["exports"], function (exports) {
   exports["default"] = willCleanupTree;
 
-  function willCleanupTree(env, morph, destroySelf) {
-    var view = morph.emberView;
-    if (destroySelf && view && view.parentView) {
-      view.parentView.removeChild(view);
-    }
+  function willCleanupTree(env) {
+    var view = env.view;
 
-    if (view = env.view) {
-      view.ownerView.isDestroyingSubtree = true;
-    }
+    // When we go to clean up the render node and all of its children, we may
+    // encounter views/components associated with those nodes along the way. In
+    // those cases, we need to make sure we need to sever the link between the
+    // existing view hierarchy and those views.
+    //
+    // However, we do *not* need to remove the child views of child views, since
+    // severing the connection to their parent effectively severs them from the
+    // view graph.
+    //
+    // For example, imagine the following view graph:
+    //
+    //    A
+    //   / \
+    //  B  C
+    //    / \
+    //   D  E
+    //
+    // If we are cleaning up the node for view C, we need to remove that view
+    // from A's child views. However, we do not need to remove D and E from C's
+    // child views, since removing C transitively removes D and E as well.
+    //
+    // To accomplish this, we track the nearest view to this render node on the
+    // owner view, the root-most view in the graph (A in the example above). If
+    // we detect a view that is a direct child of that view, we remove it from
+    // the `childViews` array. Other parent/child view relationships are
+    // untouched.  This view is then cleared once cleanup is complete in
+    // `didCleanupTree`.
+    view.ownerView._destroyingSubtreeForView = view;
   }
 });
 enifed("ember-htmlbars/keywords", ["exports", "htmlbars-runtime", "ember-metal/platform/create"], function (exports, _htmlbarsRuntime, _emberMetalPlatformCreate) {
@@ -8189,7 +8403,7 @@ enifed("ember-htmlbars/keywords/collection", ["exports", "ember-views/streams/ut
       var read = env.hooks.getValue;
 
       return _emberMetalMerge.assign({}, state, {
-        parentView: read(scope.locals.view),
+        parentView: env.view,
         viewClassOrInstance: getView(read(params[0]), env.container)
       });
     },
@@ -8246,7 +8460,55 @@ enifed("ember-htmlbars/keywords/collection", ["exports", "ember-views/streams/ut
 @module ember
 @submodule ember-htmlbars
 */
-enifed("ember-htmlbars/keywords/component", ["exports", "ember-metal/merge"], function (exports, _emberMetalMerge) {
+enifed('ember-htmlbars/keywords/component', ['exports', 'ember-metal/merge'], function (exports, _emberMetalMerge) {
+
+  /**
+    The `{{component}}` helper lets you add instances of `Ember.Component` to a
+    template. See [Ember.Component](/api/classes/Ember.Component.html) for
+    additional information on how a `Component` functions.
+    `{{component}}`'s primary use is for cases where you want to dynamically
+    change which type of component is rendered as the state of your application
+    changes. The provided block will be applied as the template for the component.
+    Given an empty `<body>` the following template:
+  
+    ```handlebars
+    {{! application.hbs }}
+    {{component infographicComponentName}}
+    ```
+  
+    And the following application code:
+  
+    ```javascript
+    export default Ember.Controller.extend({
+      infographicComponentName: computed('isMarketOpen', {
+        get() {
+          if (this.get('isMarketOpen')) {
+            return 'live-updating-chart';
+          } else {
+            return 'market-close-summary';
+          }
+        }
+      })
+    });
+    ```
+  
+    The `live-updating-chart` component will be appended when `isMarketOpen` is
+    `true`, and the `market-close-summary` component will be appended when
+    `isMarketOpen` is `false`. If the value changes while the app is running,
+    the component will be automatically swapped out accordingly.
+    Note: You should not use this helper when you are consistently rendering the same
+    component. In that case, use standard component syntax, for example:
+  
+    ```handlebars
+    {{! application.hbs }}
+    {{live-updating-chart}}
+    ```
+  
+    @method component
+    @since 1.11.0
+    @for Ember.Templates.helpers
+    @public
+  */
   exports["default"] = {
     setupState: function (lastState, env, scope, params, hash) {
       var componentPath = env.hooks.getValue(params[0]);
@@ -8285,6 +8547,11 @@ enifed("ember-htmlbars/keywords/component", ["exports", "ember-metal/merge"], fu
     env.hooks.component(morph, env, scope, componentPath, params, hash, { "default": template, inverse: inverse }, visitor);
   }
 });
+/**
+  @module ember
+  @submodule ember-templates
+  @public
+*/
 enifed("ember-htmlbars/keywords/customized_outlet", ["exports", "ember-htmlbars/node-managers/view-node-manager", "ember-views/streams/utils", "ember-metal/streams/utils"], function (exports, _emberHtmlbarsNodeManagersViewNodeManager, _emberViewsStreamsUtils, _emberMetalStreamsUtils) {
   exports["default"] = {
     setupState: function (state, env, scope, params, hash) {
@@ -8352,7 +8619,7 @@ enifed("ember-htmlbars/keywords/debugger", ["exports", "ember-metal/logger"], fu
     ```
   
     @method debugger
-    @for Ember.Handlebars.helpers
+    @for Ember.Templates.helpers
     @public
   */
 
@@ -8607,7 +8874,7 @@ enifed("ember-htmlbars/keywords/readonly", ["exports", "ember-htmlbars/keywords/
   }
 });
 enifed("ember-htmlbars/keywords/real_outlet", ["exports", "ember-metal/property_get", "ember-htmlbars/node-managers/view-node-manager", "ember-htmlbars/templates/top-level-view"], function (exports, _emberMetalProperty_get, _emberHtmlbarsNodeManagersViewNodeManager, _emberHtmlbarsTemplatesTopLevelView) {
-  _emberHtmlbarsTemplatesTopLevelView["default"].meta.revision = "Ember@1.13.3";
+  _emberHtmlbarsTemplatesTopLevelView["default"].meta.revision = "Ember@1.13.4";
 
   exports["default"] = {
     willRender: function (renderNode, env) {
@@ -8806,11 +9073,11 @@ enifed("ember-htmlbars/keywords/view", ["exports", "ember-views/streams/utils",
 
       // if parentView exists, use its controller (the default
       // behavior), otherwise use `scope.self` as the controller
-      var controller = scope.view ? null : read(scope.self);
+      var controller = scope.locals.view ? null : read(scope.self);
 
       return {
         manager: state.manager,
-        parentView: scope.view,
+        parentView: env.view,
         controller: controller,
         targetObject: targetObject,
         viewClassOrInstance: viewClassOrInstance
@@ -8902,7 +9169,7 @@ enifed("ember-htmlbars/keywords/view", ["exports", "ember-views/streams/utils",
 @module ember
 @submodule ember-htmlbars
 */
-enifed("ember-htmlbars/keywords/with", ["exports", "htmlbars-runtime", "ember-metal/property_get"], function (exports, _htmlbarsRuntime, _emberMetalProperty_get) {
+enifed('ember-htmlbars/keywords/with', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'htmlbars-runtime', 'ember-metal/streams/utils'], function (exports, _emberMetalCore, _emberMetalProperty_get, _htmlbarsRuntime, _emberMetalStreamsUtils) {
   exports["default"] = {
     setupState: function (state, env, scope, params, hash) {
       var controller = hash.controller;
@@ -8910,8 +9177,14 @@ enifed("ember-htmlbars/keywords/with", ["exports", "htmlbars-runtime", "ember-me
       if (controller) {
         if (!state.controller) {
           var context = params[0];
-          var controllerFactory = env.container.lookupFactory("controller:" + controller);
-          var parentController = scope.view ? _emberMetalProperty_get.get(scope.view, "context") : null;
+          var controllerFactory = env.container.lookupFactory('controller:' + controller);
+          var parentController = null;
+
+          if (scope.locals.controller) {
+            parentController = _emberMetalStreamsUtils.read(scope.locals.controller);
+          } else if (scope.locals.view) {
+            parentController = _emberMetalProperty_get.get(_emberMetalStreamsUtils.read(scope.locals.view), 'context');
+          }
 
           var controllerInstance = controllerFactory.create({
             model: env.hooks.getValue(context),
@@ -8943,19 +9216,19 @@ enifed("ember-htmlbars/keywords/with", ["exports", "htmlbars-runtime", "ember-me
         hash.controller = morph.state.controller;
       }
 
-      Ember.assert("{{#with foo}} must be called with a single argument or the use the " + "{{#with foo as bar}} syntax", params.length === 1);
+      _emberMetalCore["default"].assert('{{#with foo}} must be called with a single argument or the use the ' + '{{#with foo as bar}} syntax', params.length === 1);
 
-      Ember.assert("The {{#with}} helper must be called with a block", !!template);
+      _emberMetalCore["default"].assert('The {{#with}} helper must be called with a block', !!template);
 
       if (template && template.arity === 0) {
-        Ember.deprecate("Using the context switching form of `{{with}}` is deprecated. " + "Please use the block param form (`{{#with bar as |foo|}}`) instead.", false, { url: "http://emberjs.com/guides/deprecations/#toc_more-consistent-handlebars-scope" });
+        _emberMetalCore["default"].deprecate('Using the context switching form of `{{with}}` is deprecated. ' + 'Please use the block param form (`{{#with bar as |foo|}}`) instead.', false, { url: 'http://emberjs.com/guides/deprecations/#toc_more-consistent-handlebars-scope' });
       }
 
-      _htmlbarsRuntime.internal.continueBlock(morph, env, scope, "with", params, hash, template, inverse, visitor);
+      _htmlbarsRuntime.internal.continueBlock(morph, env, scope, 'with', params, hash, template, inverse, visitor);
     },
 
     rerender: function (morph, env, scope, params, hash, template, inverse, visitor) {
-      _htmlbarsRuntime.internal.continueBlock(morph, env, scope, "with", params, hash, template, inverse, visitor);
+      _htmlbarsRuntime.internal.continueBlock(morph, env, scope, 'with', params, hash, template, inverse, visitor);
     }
   };
 });
@@ -9030,14 +9303,13 @@ enifed("ember-htmlbars/morphs/morph", ["exports", "dom-helper", "ember-metal/pla
   };
 
   proto.cleanup = function () {
-    var view;
+    var view = this.emberView;
 
-    if (view = this.emberView) {
-      if (!view.ownerView.isDestroyingSubtree) {
-        view.ownerView.isDestroyingSubtree = true;
-        if (view.parentView) {
-          view.parentView.removeChild(view);
-        }
+    if (view) {
+      var parentView = view.parentView;
+
+      if (parentView && view.ownerView._destroyingSubtreeForView === parentView) {
+        parentView.removeChild(view);
       }
     }
 
@@ -9332,7 +9604,7 @@ enifed("ember-htmlbars/node-managers/component-node-manager", ["exports", "ember
   };
 
   function createComponent(_component, isAngleBracket, _props, renderNode, env) {
-    var attrs = arguments[5] === undefined ? {} : arguments[5];
+    var attrs = arguments.length <= 5 || arguments[5] === undefined ? {} : arguments[5];
 
     var props = _emberMetalMerge.assign({}, _props);
 
@@ -9367,6 +9639,7 @@ enifed("ember-htmlbars/node-managers/component-node-manager", ["exports", "ember
 
     component._renderNode = renderNode;
     renderNode.emberView = component;
+    renderNode.buildChildEnv = buildChildEnv;
     return component;
   }
 
@@ -9421,6 +9694,10 @@ enifed("ember-htmlbars/node-managers/component-node-manager", ["exports", "ember
 
     return target;
   }
+
+  function buildChildEnv(state, env) {
+    return env.childWithView(this.emberView);
+  }
 });
 
 // In theory this should come through the env, but it should
@@ -9582,13 +9859,17 @@ enifed("ember-htmlbars/node-managers/view-node-manager", ["exports", "ember-meta
   }
 
   function createOrUpdateComponent(component, options, createOptions, renderNode, env) {
-    var attrs = arguments[5] === undefined ? {} : arguments[5];
+    var attrs = arguments.length <= 5 || arguments[5] === undefined ? {} : arguments[5];
 
     var snapshot = takeSnapshot(attrs);
     var props = _emberMetalMerge["default"]({}, options);
     var defaultController = _emberViewsViewsView["default"].proto().controller;
     var hasSuppliedController = "controller" in attrs || "controller" in props;
 
+    if (!props.ownerView && options.parentView) {
+      props.ownerView = options.parentView.ownerView;
+    }
+
     props.attrs = snapshot;
     if (component.create) {
       var proto = component.proto();
@@ -9841,7 +10122,7 @@ enifed("ember-htmlbars/system/bootstrap", ["exports", "ember-metal/core", "ember
 
   /**
   @module ember
-  @submodule ember-handlebars
+  @submodule ember-htmlbars
   */
 
   /**
@@ -9850,13 +10131,13 @@ enifed("ember-htmlbars/system/bootstrap", ["exports", "ember-metal/core", "ember
     as as jQuery DOM-ready callback.
   
     Script tags with `text/x-handlebars` will be compiled
-    with Ember's Handlebars and are suitable for use as a view's template.
+    with Ember's template compiler 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.
   
     @private
     @method bootstrap
-    @for Ember.Handlebars
+    @for Ember.HTMLBars
     @static
     @param ctx
   */
@@ -9975,14 +10256,9 @@ enifed("ember-htmlbars/system/dom-helper", ["exports", "dom-helper", "ember-html
 enifed("ember-htmlbars/system/helper", ["exports"], function (exports) {
   /**
   @module ember
-  @submodule ember-htmlbars
+  @submodule ember-templates
   */
 
-  /**
-    @class Helper
-    @namespace Ember.HTMLBars
-    @private
-  */
   function Helper(helper) {
     this.helperFunction = helper;
 
@@ -10086,7 +10362,7 @@ enifed("ember-htmlbars/system/lookup-helper", ["exports", "ember-metal/core", "e
     @private
     @method resolveHelper
     @param {String} name the name of the helper to lookup
-    @return {Handlebars Helper}
+    @return {Helper}
   */
 
   function findHelper(name, view, env) {
@@ -10250,7 +10526,7 @@ enifed("ember-htmlbars/system/render-env", ["exports", "ember-htmlbars/env", "em
   };
 
   RenderEnv.prototype.childWithOutletState = function (outletState) {
-    var hasParentOutlet = arguments[1] === undefined ? this.hasParentOutlet : arguments[1];
+    var hasParentOutlet = arguments.length <= 1 || arguments[1] === undefined ? this.hasParentOutlet : arguments[1];
 
     return new RenderEnv({
       view: this.view,
@@ -11243,9 +11519,9 @@ enifed("ember-htmlbars/utils/normalize-self", ["exports"], function (exports) {
 enifed("ember-htmlbars/utils/string", ["exports", "htmlbars-util", "ember-runtime/system/string"], function (exports, _htmlbarsUtil, _emberRuntimeSystemString) {
 
   /**
-    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.
+    Mark a string as safe for unescaped output with Ember templates. If you
+    return HTML from a helper, use this function to
+    ensure Ember's rendering layer does not escape the HTML.
   
     ```javascript
     Ember.String.htmlSafe('<div>someString</div>')
@@ -11270,18 +11546,6 @@ enifed("ember-htmlbars/utils/string", ["exports", "htmlbars-util", "ember-runtim
 
   _emberRuntimeSystemString["default"].htmlSafe = htmlSafe;
   if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) {
-
-    /**
-      Mark a string as being safe for unescaped output with Handlebars.
-       ```javascript
-      '<div>someString</div>'.htmlSafe()
-      ```
-       See [Ember.String.htmlSafe](/api/classes/Ember.String.html#method_htmlSafe).
-       @method htmlSafe
-      @for String
-      @return {Handlebars.SafeString} a string that will not be html escaped by Handlebars
-      @public
-    */
     String.prototype.htmlSafe = function () {
       return htmlSafe(this);
     };
@@ -11735,20 +11999,20 @@ enifed("ember-metal", ["exports", "ember-metal/core", "ember-metal/merge", "embe
   _emberMetalCore["default"].addObserver = _emberMetalObserver.addObserver;
   _emberMetalCore["default"].observersFor = _emberMetalObserver.observersFor;
   _emberMetalCore["default"].removeObserver = _emberMetalObserver.removeObserver;
-  _emberMetalCore["default"].addBeforeObserver = _emberMetalObserver.addBeforeObserver;
+  _emberMetalCore["default"].addBeforeObserver = _emberMetalCore["default"].deprecateFunc("Ember.addBeforeObserver is deprecated and will be removed in the near future.", { url: "http://emberjs.com/deprecations/v1.x/#toc_beforeobserver" }, _emberMetalObserver._addBeforeObserver);
   _emberMetalCore["default"]._suspendBeforeObserver = _emberMetalObserver._suspendBeforeObserver;
   _emberMetalCore["default"]._suspendBeforeObservers = _emberMetalObserver._suspendBeforeObservers;
   _emberMetalCore["default"]._suspendObserver = _emberMetalObserver._suspendObserver;
   _emberMetalCore["default"]._suspendObservers = _emberMetalObserver._suspendObservers;
-  _emberMetalCore["default"].beforeObserversFor = _emberMetalObserver.beforeObserversFor;
-  _emberMetalCore["default"].removeBeforeObserver = _emberMetalObserver.removeBeforeObserver;
+  _emberMetalCore["default"].beforeObserversFor = _emberMetalCore["default"].deprecateFunc("Ember.beforeObserversFor is deprecated and will be removed in the near future.", { url: "http://emberjs.com/deprecations/v1.x/#toc_beforeobserver" }, _emberMetalObserver._beforeObserversFor);
+  _emberMetalCore["default"].removeBeforeObserver = _emberMetalCore["default"].deprecateFunc("Ember.removeBeforeObserver is deprecated and will be removed in the near future.", { url: "http://emberjs.com/deprecations/v1.x/#toc_beforeobserver" }, _emberMetalObserver._removeBeforeObserver);
 
   _emberMetalCore["default"].IS_BINDING = _emberMetalMixin.IS_BINDING;
   _emberMetalCore["default"].required = _emberMetalMixin.required;
   _emberMetalCore["default"].aliasMethod = _emberMetalMixin.aliasMethod;
   _emberMetalCore["default"].observer = _emberMetalMixin.observer;
-  _emberMetalCore["default"].immediateObserver = _emberMetalMixin.immediateObserver;
-  _emberMetalCore["default"].beforeObserver = _emberMetalMixin.beforeObserver;
+  _emberMetalCore["default"].immediateObserver = _emberMetalMixin._immediateObserver;
+  _emberMetalCore["default"].beforeObserver = _emberMetalCore["default"].deprecateFunc("Ember.beforeObserver is deprecated and will be removed in the near future.", { url: "http://emberjs.com/deprecations/v1.x/#toc_beforeobserver" }, _emberMetalMixin._beforeObserver);
   _emberMetalCore["default"].mixin = _emberMetalMixin.mixin;
   _emberMetalCore["default"].Mixin = _emberMetalMixin.Mixin;
 
@@ -14424,7 +14688,7 @@ enifed('ember-metal/core', ['exports'], function (exports) {
   
     @class Ember
     @static
-    @version 1.13.3
+    @version 1.13.4
     @public
   */
 
@@ -14456,11 +14720,11 @@ enifed('ember-metal/core', ['exports'], function (exports) {
   
     @property VERSION
     @type String
-    @default '1.13.3'
+    @default '1.13.4'
     @static
     @public
   */
-  Ember.VERSION = '1.13.3';
+  Ember.VERSION = '1.13.4';
 
   /**
     The hash of environment variables used to control various configuration
@@ -17057,8 +17321,8 @@ enifed("ember-metal/mixin", ["exports", "ember-metal/core", "ember-metal/merge",
   exports.required = required;
   exports.aliasMethod = aliasMethod;
   exports.observer = observer;
-  exports.immediateObserver = immediateObserver;
-  exports.beforeObserver = beforeObserver;
+  exports._immediateObserver = _immediateObserver;
+  exports._beforeObserver = _beforeObserver;
   // Remove "use strict"; from transpiled module until
   // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
   //
@@ -17450,13 +17714,13 @@ enifed("ember-metal/mixin", ["exports", "ember-metal/core", "ember-metal/merge",
     var prev = obj[key];
 
     if ("function" === typeof prev) {
-      updateObserversAndListeners(obj, key, prev, "__ember_observesBefore__", _emberMetalObserver.removeBeforeObserver);
+      updateObserversAndListeners(obj, key, prev, "__ember_observesBefore__", _emberMetalObserver._removeBeforeObserver);
       updateObserversAndListeners(obj, key, prev, "__ember_observes__", _emberMetalObserver.removeObserver);
       updateObserversAndListeners(obj, key, prev, "__ember_listens__", _emberMetalEvents.removeListener);
     }
 
     if ("function" === typeof observerOrListener) {
-      updateObserversAndListeners(obj, key, observerOrListener, "__ember_observesBefore__", _emberMetalObserver.addBeforeObserver);
+      updateObserversAndListeners(obj, key, observerOrListener, "__ember_observesBefore__", _emberMetalObserver._addBeforeObserver);
       updateObserversAndListeners(obj, key, observerOrListener, "__ember_observes__", _emberMetalObserver.addObserver);
       updateObserversAndListeners(obj, key, observerOrListener, "__ember_listens__", _emberMetalEvents.addListener);
     }
@@ -17933,7 +18197,7 @@ enifed("ember-metal/mixin", ["exports", "ember-metal/core", "ember-metal/merge",
     Also available as `Function.prototype.observesImmediately` if prototype extensions are
     enabled.
   
-    @method immediateObserver
+    @method _immediateObserver
     @for Ember
     @param {String} propertyNames*
     @param {Function} func
@@ -17942,7 +18206,7 @@ enifed("ember-metal/mixin", ["exports", "ember-metal/core", "ember-metal/merge",
     @private
   */
 
-  function immediateObserver() {
+  function _immediateObserver() {
     _emberMetalCore["default"].deprecate("Usage of `Ember.immediateObserver` is deprecated, use `Ember.observer` instead.");
 
     for (var i = 0, l = arguments.length; i < l; i++) {
@@ -17959,9 +18223,9 @@ enifed("ember-metal/mixin", ["exports", "ember-metal/core", "ember-metal/merge",
     Note, `@each.property` observer is called per each add or replace of an element
     and it's not called with a specific enumeration item.
   
-    A `beforeObserver` fires before a property changes.
+    A `_beforeObserver` fires before a property changes.
   
-    A `beforeObserver` is an alternative form of `.observesBefore()`.
+    A `_beforeObserver` is an alternative form of `.observesBefore()`.
   
     ```javascript
     App.PersonView = Ember.View.extend({
@@ -17994,10 +18258,11 @@ enifed("ember-metal/mixin", ["exports", "ember-metal/core", "ember-metal/merge",
     @param {String} propertyNames*
     @param {Function} func
     @return func
+    @deprecated
     @private
   */
 
-  function beforeObserver() {
+  function _beforeObserver() {
     for (var _len5 = arguments.length, args = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
       args[_key5] = arguments[_key5];
     }
@@ -18047,13 +18312,13 @@ enifed("ember-metal/observer", ["exports", "ember-metal/watching", "ember-metal/
   exports.addObserver = addObserver;
   exports.observersFor = observersFor;
   exports.removeObserver = removeObserver;
-  exports.addBeforeObserver = addBeforeObserver;
+  exports._addBeforeObserver = _addBeforeObserver;
   exports._suspendBeforeObserver = _suspendBeforeObserver;
   exports._suspendObserver = _suspendObserver;
   exports._suspendBeforeObservers = _suspendBeforeObservers;
   exports._suspendObservers = _suspendObservers;
-  exports.beforeObserversFor = beforeObserversFor;
-  exports.removeBeforeObserver = removeBeforeObserver;
+  exports._beforeObserversFor = _beforeObserversFor;
+  exports._removeBeforeObserver = _removeBeforeObserver;
 
   /**
   @module ember-metal
@@ -18109,16 +18374,17 @@ enifed("ember-metal/observer", ["exports", "ember-metal/watching", "ember-metal/
   }
 
   /**
-    @method addBeforeObserver
+    @method _addBeforeObserver
     @for Ember
     @param obj
     @param {String} path
     @param {Object|Function} target
     @param {Function|String} [method]
+    @deprecated
     @private
   */
 
-  function addBeforeObserver(obj, path, target, method) {
+  function _addBeforeObserver(obj, path, target, method) {
     _emberMetalEvents.addListener(obj, beforeEvent(path), target, method);
     _emberMetalWatching.watch(obj, path);
 
@@ -18148,7 +18414,7 @@ enifed("ember-metal/observer", ["exports", "ember-metal/watching", "ember-metal/
     return _emberMetalEvents.suspendListeners(obj, events, target, method, callback);
   }
 
-  function beforeObserversFor(obj, path) {
+  function _beforeObserversFor(obj, path) {
     return _emberMetalEvents.listenersFor(obj, beforeEvent(path));
   }
 
@@ -18159,10 +18425,11 @@ enifed("ember-metal/observer", ["exports", "ember-metal/watching", "ember-metal/
     @param {String} path
     @param {Object|Function} target
     @param {Function|String} [method]
+    @deprecated
     @private
   */
 
-  function removeBeforeObserver(obj, path, target, method) {
+  function _removeBeforeObserver(obj, path, target, method) {
     _emberMetalWatching.unwatch(obj, path);
     _emberMetalEvents.removeListener(obj, beforeEvent(path), target, method);
 
@@ -22309,17 +22576,19 @@ enifed("ember-routing-htmlbars/helpers/query-params", ["exports", "ember-metal/c
   exports.queryParamsHelper = queryParamsHelper;
 
   /**
-    This is a sub-expression to be used in conjunction with the link-to helper.
+    This is a helper to be used in conjunction with the link-to helper.
     It will supply url query parameters to the target route.
   
     Example
   
+    ```handlebars
     {{#link-to 'posts' (query-params direction="asc")}}Sort{{/link-to}}
+    ```
   
     @method query-params
-    @for Ember.Handlebars.helpers
+    @for Ember.Templates.helpers
     @param {Object} hash takes a hash of query parameters
-    @return {String} HTML string
+    @return {Object} A `QueryParams` object for `{{link-to}}`
     @public
   */
 
@@ -22340,60 +22609,151 @@ enifed("ember-routing-htmlbars/helpers/query-params", ["exports", "ember-metal/c
 enifed("ember-routing-htmlbars/keywords/action", ["exports", "htmlbars-runtime/hooks", "ember-routing-htmlbars/keywords/closure-action"], function (exports, _htmlbarsRuntimeHooks, _emberRoutingHtmlbarsKeywordsClosureAction) {
 
   /**
-    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.
+    The `{{action}}` helper provides a way to pass triggers for behavior (usually
+    just a function) between components, and into components from controllers.
+  
+    ### Passing functions with the action helper
   
-    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.
+    There are three contexts an action helper can be used in. The first two
+    contexts to discuss are attribute context, and Handlebars value context.
   
-    For more advanced event handling see [Ember.Component](/api/classes/Ember.Component.html)
+    ```handlebars
+    {{! An example of attribute context }}
+    <div onclick={{action "save"}}></div>
+    {{! Examples of Handlebars value context }}
+    {{input on-input=(action "save")}}
+    {{yield (action "refreshData") andAnotherParam}}
+    ```
   
+    In these contexts,
+    the helper is called a "closure action" helper. It's behavior is simple:
+    If passed a function name, read that function off the `actions` property
+    of the current context. Once that function is read (or if a function was
+    passed), create a closure over that function and any arguments.
   
-    ### Use
-    Given the following application Handlebars template on the page
+    The resulting value of an action helper used this way is simply a function.
+    For example with this attribute context example:
   
     ```handlebars
-    <div {{action 'anActionName'}}>
-      click me
-    </div>
+    {{! An example of attribute context }}
+    <div onclick={{action "save"}}></div>
     ```
   
-    And application code
+    The resulting template render logic would be:
   
-    ```javascript
-    App.ApplicationController = Ember.Controller.extend({
+    ```js
+    var div = document.createElement('div');
+    var actionFunction = (function(context){
+      return function() {
+        return context.actions.save.apply(context, arguments);
+      };
+    })(context);
+    div.onclick = actionFunction;
+    ```
+  
+    Thus when the div is clicked, the action on that context is called.
+    Because the `actionFunction` is just a function, closure actions can be
+    passed between components the still execute in the correct context.
+  
+    Here is an example action handler on a component:
+  
+    ```js
+    export default Ember.Component.extend({
       actions: {
-        anActionName: function() {
+        save(/* event *\/) {
+          this.get('model').save();
         }
       }
     });
     ```
   
-    Will result in the following rendered HTML
+    Actions are always looked up on the `actions` property of the current context.
+    This avoids collisions in the naming of common actions, such as `destroy`.
   
-    ```html
-    <div class="ember-view">
-      <div data-ember-action="1">
-        click me
-      </div>
-    </div>
+    Two options can be passed to the `action` helper when it is used in this way.
+  
+    * `target=someProperty` will look to `someProperty` instead of the current
+      context for the `actions` hash. This can be useful when targetting a
+      service for actions.
+    * `value="target.value"` will read the path `target.value` off the first
+      argument to the action when it is called and rewrite the first argument
+      to be that value. This is useful when attaching actions to event listeners.
+  
+    ### Invoking an action
+  
+    Closure actions curry both their scope and any arguments. When invoked, any
+    additional arguments are added to the already curried list.
+  
+    Actions should be invoked using the [sendAction](/api/classes/Ember.Component.html#method_sendAction)
+    method. The first argument to `sendAction` is the action to be called, and
+    additional arguments are passed to the action function. This has interesting
+    properties combined with currying of arguments. For example:
+  
+    ```js
+    export default Ember.Component.extend({
+      actions: {
+        // Usage {{input on-input=(action (action 'setName' model) value="target.value")}}
+        setName(model, name) {
+          model.set('name', name);
+        }
+      }
+    });
+    ```
+  
+    The first argument (`model`) was curried over, and the run-time argument (`event`)
+    becomes a second argument. Action calls be nested this way because each simply
+    returns a function. Any function can be passed to the `{{action` helper, including
+    other actions.
+  
+    Actions invoked with `sendAction` have the same currying behavior as demonstrated
+    with `on-input` above. For example:
+  
+    ```js
+    export default Ember.Component.extend({
+      actions: {
+        setName(model, name) {
+          model.set('name', name);
+        }
+      }
+    });
+    ```
+  
+    ```handlebars
+    {{my-input submit=(action 'setName' model)}}
+    ```
+  
+    ```js
+    // app/components/my-component.js
+    export default Ember.Component.extend({
+      click() {
+        // Note that model is not passed, it was curried in the template
+        this.sendAction('submit', 'bob');
+      }
+    });
     ```
   
-    Clicking "click me" will trigger the `anActionName` action of the
-    `App.ApplicationController`. In this case, no additional parameters will be passed.
+    ### Attaching actions to DOM
   
-    If you provide additional parameters to the helper:
+    The third context the `{{action` helper can be used in we call "element space".
+    For example:
   
     ```handlebars
-    <button {{action 'edit' post}}>Edit</button>
+    {{! An example of element space }}
+    <div {{action "save"}}></div>
     ```
   
-    Those parameters will be passed along as arguments to the JavaScript
-    function implementing the action.
+    Used this way, 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 context (controller or component).
+  
+    If the context of a template is a controller, actions used this way will
+    bubble to routes when the controller does not implement the specified action.
+    Once an action hits a route, it will bubble through the route hierarchy.
   
     ### Event Propagation
   
+    `{{action` helpers called in element space can control event bubbling.
+  
     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
@@ -22418,20 +22778,24 @@ enifed("ember-routing-htmlbars/keywords/action", ["exports", "htmlbars-runtime/h
   
     ### Specifying DOM event type
   
+    `{{action` helpers called in element space can specify an event type.
+  
     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:
   
     ```handlebars
-    <div {{action "anActionName" on="doubleClick"}}>
+    <div {{action "anActionName" on="double-click"}}>
       click me
     </div>
     ```
   
-    See `Ember.View` 'Responding to Browser Events' for a list of
+    See [Event Names](/api/classes/Ember.View.html#toc_event-names) for a list of
     acceptable DOM event names.
   
     ### Specifying whitelisted modifier keys
   
+    `{{action` helpers called in element space can specify modifier keys.
+  
     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.
   
@@ -22453,51 +22817,26 @@ enifed("ember-routing-htmlbars/keywords/action", ["exports", "htmlbars-runtime/h
   
     ### Specifying a Target
   
-    There are several possible target objects for `{{action}}` helpers:
-  
-    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.
-  
-    Alternatively, a `target` option can be provided to the helper to change
+    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:
   
     ```handlebars
-    {{! the application template }}
-    <div {{action "anActionName" target=view}}>
+    {{! app/templates/application.hbs }}
+    <div {{action "anActionName" target=someService}}>
       click me
     </div>
     ```
   
     ```javascript
-    App.ApplicationView = Ember.View.extend({
-      actions: {
-        anActionName: function() {}
-      }
+    // app/controllers/application.js
+    export default Ember.Controller.extend({
+      someService: Ember.inject.service()
     });
-  
     ```
   
-    ### Additional Parameters
-  
-    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 people as |person|}}
-      <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
+    @for Ember.Templates.helpers
     @public
   */
 
@@ -22513,7 +22852,7 @@ enifed("ember-routing-htmlbars/keywords/action", ["exports", "htmlbars-runtime/h
 });
 /**
 @module ember
-@submodule ember-htmlbars
+@submodule ember-templates
 */
 enifed("ember-routing-htmlbars/keywords/closure-action", ["exports", "ember-metal/streams/stream", "ember-metal/array", "ember-metal/streams/utils", "ember-metal/keys", "ember-metal/utils", "ember-metal/property_get", "ember-metal/error"], function (exports, _emberMetalStreamsStream, _emberMetalArray, _emberMetalStreamsUtils, _emberMetalKeys, _emberMetalUtils, _emberMetalProperty_get, _emberMetalError) {
   exports["default"] = closureAction;
@@ -23030,7 +23369,7 @@ enifed("ember-routing-htmlbars/keywords/link-to", ["exports", "ember-metal/strea
     ```
   
     @method link-to
-    @for Ember.Handlebars.helpers
+    @for Ember.Templates.helpers
     @param {String} routeName
     @param {Object} [context]*
     @param [options] {Object} Handlebars key/value pairs of options, you can override any property of Ember.LinkComponent
@@ -23097,7 +23436,7 @@ enifed("ember-routing-htmlbars/keywords/render", ["exports", "ember-metal/core",
       _emberMetalCore["default"].assert("The first argument of {{render}} must be quoted, e.g. {{render \"sidebar\"}}.", typeof name === "string");
 
       return {
-        parentView: scope.view,
+        parentView: env.view,
         manager: prevState.manager,
         controller: prevState.controller,
         childOutletState: childOutletState(name, env)
@@ -23313,7 +23652,7 @@ enifed("ember-routing-views", ["exports", "ember-metal/core", "ember-routing-vie
 @submodule ember-routing-views
 */
 enifed("ember-routing-views/views/link", ["exports", "ember-metal/core", "ember-metal/property_get", "ember-metal/property_set", "ember-metal/computed", "ember-views/system/utils", "ember-views/views/component", "ember-runtime/inject", "ember-runtime/mixins/controller", "ember-htmlbars/templates/link-to"], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalComputed, _emberViewsSystemUtils, _emberViewsViewsComponent, _emberRuntimeInject, _emberRuntimeMixinsController, _emberHtmlbarsTemplatesLinkTo) {
-  _emberHtmlbarsTemplatesLinkTo["default"].meta.revision = "Ember@1.13.3";
+  _emberHtmlbarsTemplatesLinkTo["default"].meta.revision = "Ember@1.13.4";
 
   var linkComponentClassNameBindings = ["active", "loading", "disabled"];
   if (_emberMetalCore["default"].FEATURES.isEnabled("ember-routing-transitioning-classes")) {
@@ -23657,7 +23996,7 @@ enifed("ember-routing-views/views/link", ["exports", "ember-metal/core", "ember-
       if (lastParam && lastParam.isQueryParams) {
         params.pop();
       }
-      var onlyQueryParamsSupplied = params.length === 0;
+      var onlyQueryParamsSupplied = this.attrs.hasBlock ? params.length === 0 : params.length === 1;
       if (onlyQueryParamsSupplied) {
         var appController = this.container.lookup("controller:application");
         if (appController) {
@@ -23844,7 +24183,7 @@ enifed("ember-routing-views/views/link", ["exports", "ember-metal/core", "ember-
 
 // FEATURES, Logger, assert
 enifed("ember-routing-views/views/outlet", ["exports", "ember-views/views/view", "ember-htmlbars/templates/top-level-view"], function (exports, _emberViewsViewsView, _emberHtmlbarsTemplatesTopLevelView) {
-  _emberHtmlbarsTemplatesTopLevelView["default"].meta.revision = "Ember@1.13.3";
+  _emberHtmlbarsTemplatesTopLevelView["default"].meta.revision = "Ember@1.13.4";
 
   var CoreOutletView = _emberViewsViewsView["default"].extend({
     defaultTemplate: _emberHtmlbarsTemplatesTopLevelView["default"],
@@ -26670,7 +27009,7 @@ enifed("ember-routing/system/route", ["exports", "ember-metal/core", "ember-meta
         args[_key] = arguments[_key];
       }
 
-      if (this.router || !_emberMetalCore["default"].testing) {
+      if (this.router && this.router.router || !_emberMetalCore["default"].testing) {
         var _router;
 
         (_router = this.router).send.apply(_router, args);
@@ -26892,6 +27231,10 @@ enifed("ember-routing/system/route", ["exports", "ember-metal/core", "ember-meta
       this.transitionTo('post', thePost);
        // integer passed in, model hook is called
       this.transitionTo('post', 1);
+       // model id passed in, model hook is called
+      // useful for forcing the hook to execute
+      thePost = store.find('post', 1);
+      this.transitionTo('post', thePost.id);
       ```
         This hook follows the asynchronous/promise semantics
       described in the documentation for `beforeModel`. In particular,
@@ -29305,7 +29648,7 @@ enifed('ember-runtime/computed/reduce_computed', ['exports', 'ember-metal/core',
         observerContexts[index] = observerContext;
 
         _emberMetalEnumerable_utils.forEach(itemPropertyKeys, function (propertyKey) {
-          _emberMetalObserver.addBeforeObserver(item, propertyKey, this, observerContext.beforeObserver);
+          _emberMetalObserver._addBeforeObserver(item, propertyKey, this, observerContext.beforeObserver);
           _emberMetalObserver.addObserver(item, propertyKey, this, observerContext.observer);
         }, this);
       }, this);
@@ -29332,7 +29675,7 @@ enifed('ember-runtime/computed/reduce_computed', ['exports', 'ember-metal/core',
           item = observerContext.item;
 
           _emberMetalEnumerable_utils.forEach(itemPropertyKeys, function (propertyKey) {
-            _emberMetalObserver.removeBeforeObserver(item, propertyKey, dependentArrayObserver, beforeObserver);
+            _emberMetalObserver._removeBeforeObserver(item, propertyKey, dependentArrayObserver, beforeObserver);
             _emberMetalObserver.removeObserver(item, propertyKey, dependentArrayObserver, observer);
           });
         });
@@ -29422,7 +29765,7 @@ enifed('ember-runtime/computed/reduce_computed', ['exports', 'ember-metal/core',
 
       function removeObservers(propertyKey) {
         observerContexts[sliceIndex].destroyed = true;
-        _emberMetalObserver.removeBeforeObserver(item, propertyKey, this, observerContexts[sliceIndex].beforeObserver);
+        _emberMetalObserver._removeBeforeObserver(item, propertyKey, this, observerContexts[sliceIndex].beforeObserver);
         _emberMetalObserver.removeObserver(item, propertyKey, this, observerContexts[sliceIndex].observer);
       }
 
@@ -29463,7 +29806,7 @@ enifed('ember-runtime/computed/reduce_computed', ['exports', 'ember-metal/core',
           observerContexts[sliceIndex] = observerContext;
 
           _emberMetalEnumerable_utils.forEach(itemPropertyKeys, function (propertyKey) {
-            _emberMetalObserver.addBeforeObserver(item, propertyKey, this, observerContext.beforeObserver);
+            _emberMetalObserver._addBeforeObserver(item, propertyKey, this, observerContext.beforeObserver);
             _emberMetalObserver.addObserver(item, propertyKey, this, observerContext.observer);
           }, this);
         }
@@ -31116,7 +31459,8 @@ enifed('ember-runtime/controllers/array_controller', ['exports', 'ember-metal/co
     },
 
     init: function () {
-      _emberMetalCore["default"].deprecate(arrayControllerDeprecation);
+      _emberMetalCore["default"].deprecate(arrayControllerDeprecation, this.isGenerated);
+
       this._super.apply(this, arguments);
       this._subControllers = [];
     },
@@ -31497,8 +31841,7 @@ enifed('ember-runtime/ext/function', ['exports', 'ember-metal/core', 'ember-meta
         }.observes('value')
       });
       ```
-       In the future this method may become asynchronous. If you want to ensure
-      synchronous behavior, use `observesImmediately`.
+       In the future this method may become asynchronous.
        See `Ember.observer`.
        @method observes
       @for Function
@@ -31513,6 +31856,19 @@ enifed('ember-runtime/ext/function', ['exports', 'ember-metal/core', 'ember-meta
       return _emberMetalMixin.observer.apply(this, args);
     };
 
+    FunctionPrototype._observesImmediately = function () {
+      _emberMetalCore["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;
+      });
+
+      // observes handles property expansion
+      return this.observes.apply(this, arguments);
+    };
     /**
       The `observesImmediately` extension of Javascript's Function prototype is
       available when `Ember.EXTEND_PROTOTYPES` or
@@ -31532,21 +31888,10 @@ enifed('ember-runtime/ext/function', ['exports', 'ember-metal/core', 'ember-meta
        See `Ember.immediateObserver`.
        @method observesImmediately
       @for Function
+      @deprecated
       @private
     */
-    FunctionPrototype.observesImmediately = function () {
-      _emberMetalCore["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;
-      });
-
-      // observes handles property expansion
-      return this.observes.apply(this, arguments);
-    };
+    FunctionPrototype.observesImmediately = _emberMetalCore["default"].deprecateFunc('Function#observesImmediately is deprecated. Use Function#observes instead', FunctionPrototype._observesImmediately);
 
     /**
       The `observesBefore` extension of Javascript's Function prototype is
@@ -31919,13 +32264,13 @@ enifed("ember-runtime/mixins/-proxy", ["exports", "ember-metal/core", "ember-met
 
     willWatchProperty: function (key) {
       var contentKey = "content." + key;
-      _emberMetalObserver.addBeforeObserver(this, contentKey, null, contentPropertyWillChange);
+      _emberMetalObserver._addBeforeObserver(this, contentKey, null, contentPropertyWillChange);
       _emberMetalObserver.addObserver(this, contentKey, null, contentPropertyDidChange);
     },
 
     didUnwatchProperty: function (key) {
       var contentKey = "content." + key;
-      _emberMetalObserver.removeBeforeObserver(this, contentKey, null, contentPropertyWillChange);
+      _emberMetalObserver._removeBeforeObserver(this, contentKey, null, contentPropertyWillChange);
       _emberMetalObserver.removeObserver(this, contentKey, null, contentPropertyDidChange);
     },
 
@@ -33027,7 +33372,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
       ```
        @property firstObject
       @return {Object} the object or undefined
-      @private
+      @public
     */
     firstObject: _emberMetalComputed.computed('[]', function () {
       if (_emberMetalProperty_get.get(this, 'length') === 0) {
@@ -33055,7 +33400,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
       ```
        @property lastObject
       @return {Object} the last object or undefined
-      @private
+      @public
     */
     lastObject: _emberMetalComputed.computed('[]', function () {
       var len = _emberMetalProperty_get.get(this, 'length');
@@ -33091,7 +33436,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
        @method contains
       @param {Object} obj The object to search for.
       @return {Boolean} `true` if object is found in enumerable.
-      @private
+      @public
     */
     contains: function (obj) {
       var found = this.find(function (item) {
@@ -33152,7 +33497,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
        @method getEach
       @param {String} key name of the property
       @return {Array} The mapped array.
-      @private
+      @public
     */
     getEach: _emberMetalMixin.aliasMethod('mapBy'),
 
@@ -33165,7 +33510,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
       @param {String} key The key to set
       @param {Object} value The object to set
       @return {Object} receiver
-      @private
+      @public
     */
     setEach: function (key, value) {
       return this.forEach(function (item) {
@@ -33192,7 +33537,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
       @param {Function} callback The callback to execute
       @param {Object} [target] The target object to use
       @return {Array} The mapped array.
-      @private
+      @public
     */
     map: function (callback, target) {
       var ret = _emberMetalCore["default"].A();
@@ -33210,7 +33555,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
        @method mapBy
       @param {String} key name of the property
       @return {Array} The mapped array.
-      @private
+      @public
     */
     mapBy: function (key) {
       return this.map(function (next) {
@@ -33251,7 +33596,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
       @param {Function} callback The callback to execute
       @param {Object} [target] The target object to use
       @return {Array} A filtered array.
-      @private
+      @public
     */
     filter: function (callback, target) {
       var ret = _emberMetalCore["default"].A();
@@ -33284,7 +33629,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
       @param {Function} callback The callback to execute
       @param {Object} [target] The target object to use
       @return {Array} A rejected array.
-       @private
+      @public
     */
     reject: function (callback, target) {
       return this.filter(function () {
@@ -33300,7 +33645,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
       @param {String} key the property to test
       @param {*} [value] optional value to test against.
       @return {Array} filtered array
-      @private
+      @public
     */
     filterBy: function (key, value) {
       return this.filter(iter.apply(this, arguments));
@@ -33327,7 +33672,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
       @param {String} key the property to test
       @param {String} [value] optional value to test against.
       @return {Array} rejected array
-      @private
+      @public
     */
     rejectBy: function (key, value) {
       var exactValue = function (item) {
@@ -33377,7 +33722,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
       @param {Function} callback The callback to execute
       @param {Object} [target] The target object to use
       @return {Object} Found item or `undefined`.
-      @private
+      @public
     */
     find: function (callback, target) {
       var len = _emberMetalProperty_get.get(this, 'length');
@@ -33416,7 +33761,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
       @param {String} key the property to test
       @param {String} [value] optional value to test against.
       @return {Object} found item or `undefined`
-      @private
+      @public
     */
     findBy: function (key, value) {
       return this.find(iter.apply(this, arguments));
@@ -33475,7 +33820,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
       @param {String} [value] optional value to test against.
       @deprecated Use `isEvery` instead
       @return {Boolean}
-      @private
+      @public
     */
     everyBy: _emberMetalMixin.aliasMethod('isEvery'),
 
@@ -33490,11 +33835,12 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
     everyProperty: _emberMetalMixin.aliasMethod('isEvery'),
 
     /**
-      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.
+      Returns `true` if the passed property resolves to the value of the second
+      argument 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.
+      @param {String} [value] optional value to test against. Defaults to `true`
       @return {Boolean}
       @since 1.3.0
       @public
@@ -33585,11 +33931,12 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
     some: _emberMetalMixin.aliasMethod('any'),
 
     /**
-      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.
+      Returns `true` if the passed property resolves to the value of the second
+      argument 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.
+      @param {String} [value] optional value to test against. Defaults to `true`
       @return {Boolean}
       @since 1.3.0
       @private
@@ -34982,9 +35329,9 @@ enifed("ember-runtime/mixins/observable", ["exports", "ember-metal/core", "ember
       return this;
     },
 
-    addBeforeObserver: function (key, target, method) {
+    _addBeforeObserver: function (key, target, method) {
       _emberMetalCore["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_deprecate-beforeobservers" });
-      _emberMetalObserver.addBeforeObserver(this, key, target, method);
+      _emberMetalObserver._addBeforeObserver(this, key, target, method);
     },
 
     /**
@@ -35522,7 +35869,7 @@ enifed("ember-runtime/mixins/sortable", ["exports", "ember-metal/core", "ember-m
       }
     }),
 
-    _contentWillChange: _emberMetalMixin.beforeObserver("content", function () {
+    _contentWillChange: _emberMetalMixin._beforeObserver("content", function () {
       var content = _emberMetalProperty_get.get(this, "content");
       var sortProperties = _emberMetalProperty_get.get(this, "sortProperties");
 
@@ -35537,7 +35884,7 @@ enifed("ember-runtime/mixins/sortable", ["exports", "ember-metal/core", "ember-m
       this._super.apply(this, arguments);
     }),
 
-    sortPropertiesWillChange: _emberMetalMixin.beforeObserver("sortProperties", function () {
+    sortPropertiesWillChange: _emberMetalMixin._beforeObserver("sortProperties", function () {
       this._lastSortAscending = undefined;
     }),
 
@@ -35545,7 +35892,7 @@ enifed("ember-runtime/mixins/sortable", ["exports", "ember-metal/core", "ember-m
       this._lastSortAscending = undefined;
     }),
 
-    sortAscendingWillChange: _emberMetalMixin.beforeObserver("sortAscending", function () {
+    sortAscendingWillChange: _emberMetalMixin._beforeObserver("sortAscending", function () {
       this._lastSortAscending = _emberMetalProperty_get.get(this, "sortAscending");
     }),
 
@@ -35909,7 +36256,7 @@ enifed("ember-runtime/system/array_proxy", ["exports", "ember-metal/core", "embe
        @private
       @method _contentWillChange
     */
-    _contentWillChange: _emberMetalMixin.beforeObserver("content", function () {
+    _contentWillChange: _emberMetalMixin._beforeObserver("content", function () {
       this._teardownContent();
     }),
 
@@ -35972,7 +36319,7 @@ enifed("ember-runtime/system/array_proxy", ["exports", "ember-metal/core", "embe
       }
     },
 
-    _arrangedContentWillChange: _emberMetalMixin.beforeObserver("arrangedContent", function () {
+    _arrangedContentWillChange: _emberMetalMixin._beforeObserver("arrangedContent", function () {
       var arrangedContent = _emberMetalProperty_get.get(this, "arrangedContent");
       var len = arrangedContent ? _emberMetalProperty_get.get(arrangedContent, "length") : 0;
 
@@ -37035,7 +37382,7 @@ enifed("ember-runtime/system/each_proxy", ["exports", "ember-metal/core", "ember
       var item = content.objectAt(loc);
       if (item) {
         _emberMetalCore["default"].assert("When using @each to observe the array " + content + ", the array must return an object", _emberRuntimeUtils.typeOf(item) === "instance" || _emberRuntimeUtils.typeOf(item) === "object");
-        _emberMetalObserver.addBeforeObserver(item, keyName, proxy, "contentKeyWillChange");
+        _emberMetalObserver._addBeforeObserver(item, keyName, proxy, "contentKeyWillChange");
         _emberMetalObserver.addObserver(item, keyName, proxy, "contentKeyDidChange");
 
         // keep track of the index each item was found at so we can map
@@ -37061,7 +37408,7 @@ enifed("ember-runtime/system/each_proxy", ["exports", "ember-metal/core", "ember
     while (--loc >= idx) {
       var item = content.objectAt(loc);
       if (item) {
-        _emberMetalObserver.removeBeforeObserver(item, keyName, proxy, "contentKeyWillChange");
+        _emberMetalObserver._removeBeforeObserver(item, keyName, proxy, "contentKeyWillChange");
         _emberMetalObserver.removeObserver(item, keyName, proxy, "contentKeyDidChange");
 
         guid = _emberMetalUtils.guidFor(item);
@@ -37237,14 +37584,14 @@ enifed("ember-runtime/system/lazy_load", ["exports", "ember-metal/core", "ember-
   var loaded = {};
 
   /**
-    Detects when a specific package of Ember (e.g. 'Ember.Handlebars')
+    Detects when a specific package of Ember (e.g. 'Ember.Application')
     has fully loaded and is available for extension.
   
     The provided `callback` will be called with the `name` passed
     resolved from a string into the object:
   
     ``` javascript
-    Ember.onLoad('Ember.Handlebars' function(hbars) {
+    Ember.onLoad('Ember.Application' function(hbars) {
       hbars.registerHelper(...);
     });
     ```
@@ -37268,7 +37615,7 @@ enifed("ember-runtime/system/lazy_load", ["exports", "ember-metal/core", "ember-
   }
 
   /**
-    Called when an Ember.js package (e.g Ember.Handlebars) has finished
+    Called when an Ember.js package (e.g Ember.Application) has finished
     loading. Triggers any callbacks registered for this event.
   
     @method runLoadHooks
@@ -40569,7 +40916,7 @@ enifed("ember-template-compiler/system/compile_options", ["exports", "ember-meta
 
     options.buildMeta = function buildMeta(program) {
       return {
-        revision: "Ember@1.13.3",
+        revision: "Ember@1.13.4",
         loc: program.loc,
         moduleName: options.moduleName
       };
@@ -41998,7 +42345,7 @@ enifed("ember-views/compat/attrs-proxy", ["exports", "ember-metal/property_get",
       }
 
       var attrsKey = "attrs." + key;
-      _emberMetalObserver.addBeforeObserver(this, attrsKey, null, attrsWillChange);
+      _emberMetalObserver._addBeforeObserver(this, attrsKey, null, attrsWillChange);
       _emberMetalObserver.addObserver(this, attrsKey, null, attrsDidChange);
     },
 
@@ -42008,7 +42355,7 @@ enifed("ember-views/compat/attrs-proxy", ["exports", "ember-metal/property_get",
       }
 
       var attrsKey = "attrs." + key;
-      _emberMetalObserver.removeBeforeObserver(this, attrsKey, null, attrsWillChange);
+      _emberMetalObserver._removeBeforeObserver(this, attrsKey, null, attrsWillChange);
       _emberMetalObserver.removeObserver(this, attrsKey, null, attrsDidChange);
     },
 
@@ -43526,7 +43873,7 @@ enifed("ember-views/mixins/view_child_views_support", ["exports", "ember-metal/c
 
   var EMPTY_ARRAY = [];
 
-  var ViewChildViewsSupport = _emberMetalMixin.Mixin.create({
+  exports["default"] = _emberMetalMixin.Mixin.create({
     /**
       Array of child views. You should never edit this array directly.
       Instead, use `appendChild` and `removeFromParent`.
@@ -43543,7 +43890,7 @@ enifed("ember-views/mixins/view_child_views_support", ["exports", "ember-metal/c
       // setup child views. be sure to clone the child views array first
       // 2.0TODO: Remove Ember.A() here
       this.childViews = _emberMetalCore["default"].A(this.childViews.slice());
-      this.ownerView = this;
+      this.ownerView = this.ownerView || this;
     },
 
     appendChild: function (view) {
@@ -43604,6 +43951,8 @@ enifed("ember-views/mixins/view_child_views_support", ["exports", "ember-metal/c
 
       var attrs = _attrs || {};
       var view;
+
+      attrs.parentView = this;
       attrs.renderer = this.renderer;
       attrs._viewRegistry = this._viewRegistry;
 
@@ -43637,8 +43986,11 @@ enifed("ember-views/mixins/view_child_views_support", ["exports", "ember-metal/c
 
     linkChild: function (instance) {
       instance.container = this.container;
-      _emberMetalProperty_set.set(instance, "parentView", this);
-      instance.trigger("parentViewDidChange");
+      if (_emberMetalProperty_get.get(instance, "parentView") !== this) {
+        // linkChild should be idempotentj
+        _emberMetalProperty_set.set(instance, "parentView", this);
+        instance.trigger("parentViewDidChange");
+      }
       instance.ownerView = this.ownerView;
     },
 
@@ -43647,8 +43999,6 @@ enifed("ember-views/mixins/view_child_views_support", ["exports", "ember-metal/c
       instance.trigger("parentViewDidChange");
     }
   });
-
-  exports["default"] = ViewChildViewsSupport;
 });
 /**
 @module ember
@@ -44877,7 +45227,7 @@ enifed("ember-views/views/checkbox", ["exports", "ember-metal/property_get", "em
     The internal class used to create text inputs when the `{{input}}`
     helper is used with `type` of `checkbox`.
   
-    See [handlebars.helpers.input](/api/classes/Ember.Handlebars.helpers.html#method_input)  for usage details.
+    See [Ember.Templates.helpers.input](/api/classes/Ember.Templates.helpers.html#method_input)  for usage details.
   
     ## Direct manipulation of `checked`
   
@@ -44965,7 +45315,7 @@ enifed("ember-views/views/collection_view", ["exports", "ember-metal/core", "emb
       classNames: ['a-collection'],
       content: ['A','B','C'],
       itemViewClass: Ember.View.extend({
-        template: Ember.Handlebars.compile("the letter: {{view.content}}")
+        template: Ember.HTMLBars.compile("the letter: {{view.content}}")
       })
     });
     ```
@@ -45000,7 +45350,7 @@ enifed("ember-views/views/collection_view", ["exports", "ember-metal/core", "emb
       tagName: 'ul',
       content: ['A','B','C'],
       itemViewClass: Ember.View.extend({
-        template: Ember.Handlebars.compile("the letter: {{view.content}}")
+        template: Ember.HTMLBars.compile("the letter: {{view.content}}")
       })
     });
     ```
@@ -45060,7 +45410,7 @@ enifed("ember-views/views/collection_view", ["exports", "ember-metal/core", "emb
       classNames: ['nothing'],
       content: null,
       emptyView: Ember.View.extend({
-        template: Ember.Handlebars.compile("The collection is empty")
+        template: Ember.HTMLBars.compile("The collection is empty")
       })
     });
     ```
@@ -45131,7 +45481,7 @@ enifed("ember-views/views/collection_view", ["exports", "ember-metal/core", "emb
        @private
       @method _contentWillChange
     */
-    _contentWillChange: _emberMetalMixin.beforeObserver("content", function () {
+    _contentWillChange: _emberMetalMixin._beforeObserver("content", function () {
       var content = this.get("content");
 
       if (content) {
@@ -45559,14 +45909,14 @@ enifed("ember-views/views/component", ["exports", "ember-metal/core", "ember-vie
     }),
 
     /**
-      Triggers a named action on the controller context where the component is used if
-      this controller has registered for notifications of the action.
+      Calls a action passed to a component.
        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:
-        ```javascript
-      App.PlayButtonComponent = Ember.Component.extend({
-        click: function() {
+       ```javascript
+      // app/components/play-button.js
+      export default Ember.Component.extend({
+        click() {
           if (this.get('isPlaying')) {
             this.sendAction('play');
           } else {
@@ -45575,55 +45925,56 @@ enifed("ember-views/views/component", ["exports", "ember-metal/core", "ember-vie
         }
       });
       ```
-       When used inside a template these component actions are configured to
-      trigger actions in the outer application context:
+       The actions "play" and "stop" must be passed to this `play-button` component:
        ```handlebars
-      {{! application.hbs }}
-      {{play-button play="musicStarted" stop="musicStopped"}}
+      {{! app/templates/application.hbs }}
+      {{play-button play=(action "musicStarted") stop=(action "musicStopped")}}
       ```
        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:
-        ```javascript
-      App.ApplicationController = Ember.Controller.extend({
+      calls the specified action.
+       ```javascript
+      // app/controller/application.js
+      export default Ember.Controller.extend({
         actions: {
-          musicStarted: function() {
+          musicStarted() {
             // called when the play button is clicked
             // and the music started playing
           },
-          musicStopped: function() {
+          musicStopped() {
             // called when the play button is clicked
             // and the music stopped playing
           }
         }
       });
       ```
-       If no action name is passed to `sendAction` a default name of "action"
+       If no action is passed to `sendAction` a default name of "action"
       is assumed.
        ```javascript
-      App.NextButtonComponent = Ember.Component.extend({
-        click: function() {
+      // app/components/next-button.js
+      export default Ember.Component.extend({
+        click() {
           this.sendAction();
         }
       });
       ```
        ```handlebars
-      {{! application.hbs }}
-      {{next-button action="playNextSongInAlbum"}}
+      {{! app/templates/application.hbs }}
+      {{next-button action=(action "playNextSongInAlbum")}}
       ```
        ```javascript
+      // app/controllers/application.js
       App.ApplicationController = Ember.Controller.extend({
         actions: {
-          playNextSongInAlbum: function() {
+          playNextSongInAlbum() {
             ...
           }
         }
       });
       ```
        @method sendAction
-      @param [action] {String} the action to trigger
-      @param [context] {*} a context to send with the action
+      @param [action] {String} the action to call
+      @param [params] {*} arguments for the action
       @public
     */
     sendAction: function (action) {
@@ -45749,7 +46100,7 @@ enifed("ember-views/views/component", ["exports", "ember-metal/core", "ember-vie
 });
 // Ember.assert, Ember.Handlebars
 enifed("ember-views/views/container_view", ["exports", "ember-metal/core", "ember-runtime/mixins/mutable_array", "ember-views/views/view", "ember-metal/property_get", "ember-metal/property_set", "ember-metal/enumerable_utils", "ember-metal/mixin", "ember-metal/events", "ember-htmlbars/templates/container-view"], function (exports, _emberMetalCore, _emberRuntimeMixinsMutable_array, _emberViewsViewsView, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalEnumerable_utils, _emberMetalMixin, _emberMetalEvents, _emberHtmlbarsTemplatesContainerView) {
-  _emberHtmlbarsTemplatesContainerView["default"].meta.revision = "Ember@1.13.3";
+  _emberHtmlbarsTemplatesContainerView["default"].meta.revision = "Ember@1.13.4";
 
   /**
   @module ember
@@ -45809,10 +46160,10 @@ enifed("ember-views/views/container_view", ["exports", "ember-metal/core", "embe
       classNames: ['the-container'],
       childViews: ['aView', 'bView'],
       aView: Ember.View.create({
-        template: Ember.Handlebars.compile("A")
+        template: Ember.HTMLBars.compile("A")
       }),
       bView: Ember.View.create({
-        template: Ember.Handlebars.compile("B")
+        template: Ember.HTMLBars.compile("B")
       })
     });
   
@@ -45854,10 +46205,10 @@ enifed("ember-views/views/container_view", ["exports", "ember-metal/core", "embe
       classNames: ['the-container'],
       childViews: ['aView', 'bView'],
       aView: Ember.View.create({
-        template: Ember.Handlebars.compile("A")
+        template: Ember.HTMLBars.compile("A")
       }),
       bView: Ember.View.create({
-        template: Ember.Handlebars.compile("B")
+        template: Ember.HTMLBars.compile("B")
       })
     });
   
@@ -45877,7 +46228,7 @@ enifed("ember-views/views/container_view", ["exports", "ember-metal/core", "embe
   
     ```javascript
     AnotherViewClass = Ember.View.extend({
-      template: Ember.Handlebars.compile("Another view")
+      template: Ember.HTMLBars.compile("Another view")
     });
   
     aContainer.toArray();  // [aContainer.aView, aContainer.bView]
@@ -45961,7 +46312,7 @@ enifed("ember-views/views/container_view", ["exports", "ember-metal/core", "embe
       }
     },
 
-    _currentViewWillChange: _emberMetalMixin.beforeObserver("currentView", function () {
+    _currentViewWillChange: _emberMetalMixin._beforeObserver("currentView", function () {
       var currentView = _emberMetalProperty_get.get(this, "currentView");
       if (currentView) {
         currentView.destroy();
@@ -45981,7 +46332,7 @@ enifed("ember-views/views/container_view", ["exports", "ember-metal/core", "embe
     replace: function (idx, removedCount) {
       var _this = this;
 
-      var addedViews = arguments[2] === undefined ? [] : arguments[2];
+      var addedViews = arguments.length <= 2 || arguments[2] === undefined ? [] : arguments[2];
 
       var addedCount = _emberMetalProperty_get.get(addedViews, "length");
       var childViews = _emberMetalProperty_get.get(this, "childViews");
@@ -46099,7 +46450,7 @@ enifed("ember-views/views/core_view", ["exports", "ember-metal-views/renderer",
         this.renderer = renderer;
       }
 
-      this.isDestroyingSubtree = false;
+      this._destroyingSubtreeForView = null;
       this._dispatching = null;
     },
 
@@ -46149,24 +46500,21 @@ enifed("ember-views/views/core_view", ["exports", "ember-metal-views/renderer",
     },
 
     destroy: function () {
-      var parent = this.parentView;
-
       if (!this._super.apply(this, arguments)) {
         return;
       }
 
       this.currentState.cleanup(this);
 
-      if (!this.ownerView.isDestroyingSubtree) {
-        this.ownerView.isDestroyingSubtree = true;
-        if (parent) {
-          parent.removeChild(this);
-        }
-        if (this._renderNode) {
-          Ember.assert("BUG: Render node exists without concomitant env.", this.ownerView.env);
-          _htmlbarsRuntime.internal.clearMorph(this._renderNode, this.ownerView.env, true);
-        }
-        this.ownerView.isDestroyingSubtree = false;
+      // If the destroyingSubtreeForView property is not set but we have an
+      // associated render node, it means this view is being destroyed from user
+      // code and not via a change in the templating layer (like an {{if}}
+      // becoming falsy, for example).  In this case, it is our responsibility to
+      // make sure that any render nodes created as part of the rendering process
+      // are cleaned up.
+      if (!this.ownerView._destroyingSubtreeForView && this._renderNode) {
+        Ember.assert("BUG: Render node exists without concomitant env.", this.ownerView.env);
+        _htmlbarsRuntime.internal.clearMorph(this._renderNode, this.ownerView.env, true);
       }
 
       return this;
@@ -46775,7 +47123,7 @@ enifed("ember-views/views/select", ["exports", "ember-metal/enumerable_utils", "
     },
 
     _selectedIndex: function (value) {
-      var defaultIndex = arguments[1] === undefined ? 0 : arguments[1];
+      var defaultIndex = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];
 
       var content = _emberMetalProperty_get.get(this, "contentValues");
 
@@ -47097,7 +47445,7 @@ enifed("ember-views/views/states/has_element", ["exports", "ember-views/views/st
 @module ember
 @submodule ember-views
 */
-enifed("ember-views/views/states/in_dom", ["exports", "ember-metal/platform/create", "ember-metal/merge", "ember-metal/error", "ember-metal/observer", "ember-views/views/states/has_element"], function (exports, _emberMetalPlatformCreate, _emberMetalMerge, _emberMetalError, _emberMetalObserver, _emberViewsViewsStatesHas_element) {
+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, _emberMetalCore, _emberMetalPlatformCreate, _emberMetalMerge, _emberMetalError, _emberMetalObserver, _emberViewsViewsStatesHas_element) {
   /**
   @module ember
   @submodule ember-views
@@ -47109,13 +47457,13 @@ enifed("ember-views/views/states/in_dom", ["exports", "ember-metal/platform/crea
     enter: function (view) {
       // Register the view for event handling. This hash is used by
       // Ember.EventDispatcher to dispatch incoming events.
-      if (view.tagName !== "") {
+      if (view.tagName !== '') {
         view._register();
       }
 
-      Ember.runInDebug(function () {
-        _emberMetalObserver.addBeforeObserver(view, "elementId", function () {
-          throw new _emberMetalError["default"]("Changing a view's elementId after creation is not allowed");
+      _emberMetalCore["default"].runInDebug(function () {
+        _emberMetalObserver._addBeforeObserver(view, 'elementId', function () {
+          throw new _emberMetalError["default"]('Changing a view\'s elementId after creation is not allowed');
         });
       });
     },
@@ -47135,7 +47483,7 @@ enifed("ember-views/views/states/in_dom", ["exports", "ember-metal/platform/crea
       attrNode.parentView = view;
       view.renderer.appendAttrTo(attrNode, view.element, attrNode.attrName);
 
-      view.propertyDidChange("childViews");
+      view.propertyDidChange('childViews');
 
       return attrNode;
     }
@@ -47167,7 +47515,7 @@ enifed("ember-views/views/text_area", ["exports", "ember-views/views/component",
     The internal class used to create textarea element when the `{{textarea}}`
     helper is used.
   
-    See [handlebars.helpers.textarea](/api/classes/Ember.Handlebars.helpers.html#method_textarea)  for usage details.
+    See [Ember.Templates.helpers.textarea](/api/classes/Ember.Templates.helpers.html#method_textarea)  for usage details.
   
     ## Layout and LayoutName properties
   
@@ -47229,7 +47577,7 @@ enifed("ember-views/views/text_field", ["exports", "ember-metal/computed", "embe
     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.
+    See [Ember.Templates.helpers.input](/api/classes/Ember.Templates.helpers.html#method_input)  for usage details.
   
     ## Layout and LayoutName properties
   
@@ -47639,11 +47987,11 @@ enifed("ember-views/views/view", ["exports", "ember-metal/core", "ember-runtime/
     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.
+    template.
   
     ```javascript
     AView = Ember.View.extend({
-      template: Ember.Handlebars.compile('I am the template')
+      template: Ember.HTMLBars.compile('I am the template')
     });
     ```
   
@@ -47686,18 +48034,18 @@ enifed("ember-views/views/view", ["exports", "ember-metal/core", "ember-runtime/
     });
     ```
   
-    Using a value for `templateName` that does not have a Handlebars template
+    Using a value for `templateName` that does not have a template
     with a matching `data-template-name` attribute will throw an error.
   
     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
+    portion of a `{{view}}` 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:
   
     ```javascript
     AView = Ember.View.extend({
-      defaultTemplate: Ember.Handlebars.compile('I was the default'),
+      defaultTemplate: Ember.HTMLBars.compile('I was the default'),
       template: null,
       templateName: null
     });
@@ -47714,11 +48062,11 @@ enifed("ember-views/views/view", ["exports", "ember-metal/core", "ember-runtime/
   
     ```javascript
     AView = Ember.View.extend({
-      defaultTemplate: Ember.Handlebars.compile('I was the default')
+      defaultTemplate: Ember.HTMLBars.compile('I was the default')
     });
   
     aView = AView.create({
-      template: Ember.Handlebars.compile('I was the template, not default')
+      template: Ember.HTMLBars.compile('I was the template, not default')
     });
     ```
   
@@ -47734,7 +48082,7 @@ enifed("ember-views/views/view", ["exports", "ember-metal/core", "ember-runtime/
   
     ```javascript
     AView = Ember.View.extend({
-      template: Ember.Handlebars.compile('Hello {{excitedGreeting}}')
+      template: Ember.HTMLBars.compile('Hello {{excitedGreeting}}')
     });
   
     aController = Ember.Object.create({
@@ -47767,20 +48115,19 @@ enifed("ember-views/views/view", ["exports", "ember-metal/core", "ember-runtime/
     view's tag. Views whose HTML element is self closing (e.g. `<input />`)
     cannot have a layout and this property will be ignored.
   
-    Most typically in Ember a layout will be a compiled `Ember.Handlebars`
-    template.
+    Most typically in Ember a layout will be a compiled template.
   
     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 existing template by name with the `layoutName` property.
   
-    A template used as a layout must contain a single use of the Handlebars
+    A template used as a layout must contain a single use of the
     `{{yield}}` helper. The HTML contents of a view's rendered `template` will be
     inserted at this location:
   
     ```javascript
     AViewWithLayout = Ember.View.extend({
-      layout: Ember.Handlebars.compile("<div class='my-decorative-class'>{{yield}}</div>"),
-      template: Ember.Handlebars.compile("I got wrapped")
+      layout: Ember.HTMLBars.compile("<div class='my-decorative-class'>{{yield}}</div>"),
+      template: Ember.HTMLBars.compile("I got wrapped")
     });
     ```
   
@@ -47794,7 +48141,7 @@ enifed("ember-views/views/view", ["exports", "ember-metal/core", "ember-runtime/
     </div>
     ```
   
-    See [Ember.Handlebars.helpers.yield](/api/classes/Ember.Handlebars.helpers.html#method_yield)
+    See [Ember.Templates.helpers.yield](/api/classes/Ember.Templates.helpers.html#method_yield)
     for more information.
   
     ## Responding to Browser Events
@@ -47868,7 +48215,7 @@ enifed("ember-views/views/view", ["exports", "ember-metal/core", "ember-runtime/
     ```javascript
     var App = Ember.Application.create();
     App.OuterView = Ember.View.extend({
-      template: Ember.Handlebars.compile("outer {{#view 'inner'}}inner{{/view}} outer"),
+      template: Ember.HTMLBars.compile("outer {{#view 'inner'}}inner{{/view}} outer"),
       eventManager: Ember.Object.create({
         mouseEnter: function(event, view) {
           // view might be instance of either
@@ -47891,9 +48238,9 @@ enifed("ember-views/views/view", ["exports", "ember-metal/core", "ember-runtime/
     });
     ```
   
-    ### Handlebars `{{action}}` Helper
+    ### `{{action}}` Helper
   
-    See [Handlebars.helpers.action](/api/classes/Ember.Handlebars.helpers.html#method_action).
+    See [Ember.Templates.helpers.action](/api/classes/Ember.Templates.helpers.html#method_action).
   
     ### Event Names
   
@@ -47946,10 +48293,10 @@ enifed("ember-views/views/view", ["exports", "ember-metal/core", "ember-runtime/
     * `dragEnd`
     * `drop`
   
-    ## Handlebars `{{view}}` Helper
+    ## `{{view}}` Helper
   
     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)
+    using the `{{view}}` helper. See [Ember.Templates.helpers.view](/api/classes/Ember.Templates.helpers.html#method_view)
     for additional information.
   
     @class View
@@ -49650,7 +49997,7 @@ enifed("htmlbars-runtime/hooks", ["exports", "./render", "../morph-range/morph-l
   */
 
   function bindBlock(env, scope, block) {
-    var name = arguments[3] === undefined ? "default" : arguments[3];
+    var name = arguments.length <= 3 || arguments[3] === undefined ? "default" : arguments[3];
 
     scope.blocks[name] = block;
   }