+ ```
+
+ ### Non-block version of collection
+
+ If you provide an `itemViewClass` option that has its own `template` you may
+ omit the block.
+
+ The following template:
+
+ ```handlebars
+ {{! application.hbs }}
+ {{collection content=model itemViewClass="an-item"}}
+ ```
+
+ And application code
+
+ ```javascript
+ App = Ember.Application.create();
+ App.ApplicationRoute = Ember.Route.extend({
+ model: function(){
+ return [{name: 'Yehuda'},{name: 'Tom'},{name: 'Peter'}];
+ }
+ });
+
+ App.AnItemView = Ember.View.extend({
+ template: Ember.Handlebars.compile("Greetings {{view.content.name}}")
+ });
+ ```
+
+ Will result in the HTML structure below
+
+ ```html
+
+
Greetings Yehuda
+
Greetings Tom
+
Greetings Peter
+
+ ```
+
+ ### Specifying a CollectionView subclass
+
+ By default the `{{collection}}` helper will create an instance of
+ `Ember.CollectionView`. You can supply a `Ember.CollectionView` subclass to
+ the helper by passing it as the first argument:
+
+ ```handlebars
+ {{#collection "my-custom-collection" content=model}}
+ Hi {{view.content.name}}
+ {{/collection}}
+ ```
+
+ This example would look for the class `App.MyCustomCollection`.
+
+ ### Forwarded `item.*`-named Options
+
+ As with the `{{view}}`, helper options passed to the `{{collection}}` will be
+ set on the resulting `Ember.CollectionView` as properties. Additionally,
+ options prefixed with `item` will be applied to the views rendered for each
+ item (note the camelcasing):
+
+ ```handlebars
+ {{#collection content=model
+ itemTagName="p"
+ itemClassNames="greeting"}}
+ Howdy {{view.content.name}}
+ {{/collection}}
+ ```
+
+ Will result in the following HTML structure:
+
+ ```html
+
+
Howdy Yehuda
+
Howdy Tom
+
Howdy Peter
+
+ ```
+
+ @method collection
+ @for Ember.Handlebars.helpers
+ @param {String} path
+ @param {Hash} options
+ @return {String} HTML string
+ @deprecated Use `{{each}}` helper instead.
+ */
+ function collectionHelper(params, hash, options, env) {
+ var path = params[0];
+
+ Ember.deprecate("Using the {{collection}} helper without specifying a class has been" +
+ " deprecated as the {{each}} helper now supports the same functionality.", path !== 'collection');
+
+ Ember.assert("You cannot pass more than one argument to the collection helper", params.length <= 1);
+
+ var data = env.data;
+ var template = options.template;
+ var inverse = options.inverse;
+ var view = data.view;
+
+ // This should be deterministic, and should probably come from a
+ // parent view and not the controller.
+ var controller = get(view, 'controller');
+ var container = (controller && controller.container ? controller.container : view.container);
+
+ // If passed a path string, convert that into an object.
+ // Otherwise, just default to the standard class.
+ var collectionClass;
+ if (path) {
+ collectionClass = readViewFactory(path, container);
+ Ember.assert(fmt("%@ #collection: Could not find collection class %@", [data.view, path]), !!collectionClass);
+ }
+ else {
+ collectionClass = CollectionView;
+ }
+
+ var itemHash = {};
+ var match;
+
+ // Extract item view class if provided else default to the standard class
+ var collectionPrototype = collectionClass.proto();
+ var itemViewClass;
+
+ if (hash.itemView) {
+ itemViewClass = readViewFactory(hash.itemView, container);
+ } else if (hash.itemViewClass) {
+ itemViewClass = readViewFactory(hash.itemViewClass, container);
+ } else {
+ itemViewClass = collectionPrototype.itemViewClass;
+ }
+
+ if (typeof itemViewClass === 'string') {
+ itemViewClass = container.lookupFactory('view:'+itemViewClass);
+ }
+
+ Ember.assert(fmt("%@ #collection: Could not find itemViewClass %@", [data.view, itemViewClass]), !!itemViewClass);
+
+ delete hash.itemViewClass;
+ delete hash.itemView;
+
+ // Go through options passed to the {{collection}} helper and extract options
+ // that configure item views instead of the collection itself.
+ for (var prop in hash) {
+ if (prop === 'itemController' || prop === 'itemClassBinding') {
+ continue;
+ }
+ if (hash.hasOwnProperty(prop)) {
+ match = prop.match(/^item(.)(.*)$/);
+ if (match) {
+ var childProp = match[1].toLowerCase() + match[2];
+
+ if (IS_BINDING.test(prop)) {
+ itemHash[childProp] = view._getBindingForStream(hash[prop]);
+ } else {
+ itemHash[childProp] = hash[prop];
+ }
+ delete hash[prop];
+ }
+ }
+ }
+
+ if (template) {
+ itemHash.template = template;
+ delete options.template;
+ }
+
+ var emptyViewClass;
+ if (inverse) {
+ emptyViewClass = get(collectionPrototype, 'emptyViewClass');
+ emptyViewClass = emptyViewClass.extend({
+ template: inverse,
+ tagName: itemHash.tagName
+ });
+ } else if (hash.emptyViewClass) {
+ emptyViewClass = readViewFactory(hash.emptyViewClass, container);
+ }
+ if (emptyViewClass) { hash.emptyView = emptyViewClass; }
+
+ if (hash.keyword) {
+ itemHash._contextBinding = Binding.oneWay('_parentView.context');
+ } else {
+ itemHash._contextBinding = Binding.oneWay('content');
+ }
+
+ var viewOptions = ViewHelper.propertiesFromHTMLOptions(itemHash, {}, { data: data });
+
+ if (hash.itemClassBinding) {
+ var itemClassBindings = hash.itemClassBinding.split(' ');
+ viewOptions.classNameBindings = map(itemClassBindings, function(classBinding){
+ return streamifyClassNameBinding(view, classBinding);
+ });
+ }
+
+ hash.itemViewClass = itemViewClass;
+ hash._itemViewProps = viewOptions;
+
+ options.helperName = options.helperName || 'collection';
+
+ return env.helpers.view.helperFunction.call(this, [collectionClass], hash, options, env);
+ }
+
+ __exports__.collectionHelper = collectionHelper;
+ });
+enifed("ember-htmlbars/helpers/debugger",
+ ["ember-metal/logger","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ /*jshint debug:true*/
+
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+ var Logger = __dependency1__["default"];
+
+ /**
+ Execute the `debugger` statement in the current context.
+
+ ```handlebars
+ {{debugger}}
+ ```
+
+ Before invoking the `debugger` statement, there
+ are a few helpful variables defined in the
+ body of this helper that you can inspect while
+ debugging that describe how and where this
+ helper was invoked:
+
+ - templateContext: this is most likely a controller
+ from which this template looks up / displays properties
+ - typeOfTemplateContext: a string description of
+ what the templateContext is
+
+ For example, if you're wondering why a value `{{foo}}`
+ isn't rendering as expected within a template, you
+ could place a `{{debugger}}` statement, and when
+ the `debugger;` breakpoint is hit, you can inspect
+ `templateContext`, determine if it's the object you
+ expect, and/or evaluate expressions in the console
+ to perform property lookups on the `templateContext`:
+
+ ```
+ > templateContext.get('foo') // -> ""
+ ```
+
+ @method debugger
+ @for Ember.Handlebars.helpers
+ @param {String} property
+ */
+ function debuggerHelper() {
+
+ // These are helpful values you can inspect while debugging.
+ /* jshint unused: false */
+ var view = this;
+ Logger.info('Use `this` to access the view context.');
+
+ debugger;
+ }
+
+ __exports__.debuggerHelper = debuggerHelper;
+ });
+enifed("ember-htmlbars/helpers/each",
+ ["ember-metal/core","ember-views/views/each","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+ var Ember = __dependency1__["default"];
+ // Ember.assert;
+ var EachView = __dependency2__["default"];
+
+ /**
+ The `{{#each}}` helper loops over elements in a collection. It is an extension
+ of the base Handlebars `{{#each}}` helper.
+
+ The default behavior of `{{#each}}` is to yield its inner block once for every
+ item in an array.
+
+ ```javascript
+ var developers = [{name: 'Yehuda'},{name: 'Tom'}, {name: 'Paul'}];
+ ```
+
+ ```handlebars
+ {{#each person in developers}}
+ {{person.name}}
+ {{! `this` is whatever it was outside the #each }}
+ {{/each}}
+ ```
+
+ The same rules apply to arrays of primitives, but the items may need to be
+ references with `{{this}}`.
+
+ ```javascript
+ var developerNames = ['Yehuda', 'Tom', 'Paul']
+ ```
+
+ ```handlebars
+ {{#each name in developerNames}}
+ {{name}}
+ {{/each}}
+ ```
+
+ ### {{else}} condition
+
+ `{{#each}}` can have a matching `{{else}}`. The contents of this block will render
+ if the collection is empty.
+
+ ```
+ {{#each person in developers}}
+ {{person.name}}
+ {{else}}
+
Sorry, nobody is available for this task.
+ {{/each}}
+ ```
+
+ ### Specifying an alternative view for each item
+
+ `itemViewClass` can control which view will be used during the render of each
+ item's template.
+
+ The following template:
+
+ ```handlebars
+
+ ```
+
+ Will use the following view for each item
+
+ ```javascript
+ App.PersonView = Ember.View.extend({
+ tagName: 'li'
+ });
+ ```
+
+ Resulting in HTML output that looks like the following:
+
+ ```html
+
+
Yehuda
+
Tom
+
Paul
+
+ ```
+
+ `itemViewClass` also enables a non-block form of `{{each}}`. The view
+ must {{#crossLink "Ember.View/toc_templates"}}provide its own template{{/crossLink}},
+ and then the block should be dropped. An example that outputs the same HTML
+ as the previous one:
+
+ ```javascript
+ App.PersonView = Ember.View.extend({
+ tagName: 'li',
+ template: '{{developer.name}}'
+ });
+ ```
+
+ ```handlebars
+
+ {{each developer in developers itemViewClass="person"}}
+
+ ```
+
+ ### Specifying an alternative view for no items (else)
+
+ The `emptyViewClass` option provides the same flexibility to the `{{else}}`
+ case of the each helper.
+
+ ```javascript
+ App.NoPeopleView = Ember.View.extend({
+ tagName: 'li',
+ template: 'No person is available, sorry'
+ });
+ ```
+
+ ```handlebars
+
+ {{#each developer in developers emptyViewClass="no-people"}}
+
{{developer.name}}
+ {{/each}}
+
+ ```
+
+ ### Wrapping each item in a controller
+
+ Controllers in Ember manage state and decorate data. In many cases,
+ providing a controller for each item in a list can be useful.
+ Specifically, an {{#crossLink "Ember.ObjectController"}}Ember.ObjectController{{/crossLink}}
+ should probably be used. Item controllers are passed the item they
+ will present as a `model` property, and an object controller will
+ proxy property lookups to `model` for us.
+
+ This allows state and decoration to be added to the controller
+ while any other property lookups are delegated to the model. An example:
+
+ ```javascript
+ App.RecruitController = Ember.ObjectController.extend({
+ isAvailableForHire: function() {
+ return !this.get('isEmployed') && this.get('isSeekingWork');
+ }.property('isEmployed', 'isSeekingWork')
+ })
+ ```
+
+ ```handlebars
+ {{#each person in developers itemController="recruit"}}
+ {{person.name}} {{#if person.isAvailableForHire}}Hire me!{{/if}}
+ {{/each}}
+ ```
+
+ @method each
+ @for Ember.Handlebars.helpers
+ @param [name] {String} name for item (used with `in`)
+ @param [path] {String} path
+ @param [options] {Object} Handlebars key/value pairs of options
+ @param [options.itemViewClass] {String} a path to a view class used for each item
+ @param [options.emptyViewClass] {String} a path to a view class used for each item
+ @param [options.itemController] {String} name of a controller to be created for each item
+ */
+ function eachHelper(params, hash, options, env) {
+ var helperName = 'each';
+ var path = params[0] || this.getStream('');
+
+ Ember.assert(
+ "If you pass more than one argument to the each helper, " +
+ "it must be in the form #each foo in bar",
+ params.length <= 1
+ );
+
+ if (options.template && options.template.blockParams) {
+ hash.keyword = true;
+ }
+
+ Ember.deprecate(
+ "Using the context switching form of {{each}} is deprecated. " +
+ "Please use the keyword form (`{{#each foo in bar}}`) instead.",
+ hash.keyword === true || typeof hash.keyword === 'string',
+ { url: 'http://emberjs.com/guides/deprecations/#toc_more-consistent-handlebars-scope' }
+ );
+
+ hash.dataSource = path;
+ options.helperName = options.helperName || helperName;
+
+ return env.helpers.collection.helperFunction.call(this, [EachView], hash, options, env);
+ }
+
+ __exports__.EachView = EachView;
+ __exports__.eachHelper = eachHelper;
+ });
+enifed("ember-htmlbars/helpers/if_unless",
+ ["ember-metal/core","ember-htmlbars/helpers/binding","ember-metal/property_get","ember-metal/utils","ember-views/streams/conditional_stream","ember-metal/streams/utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+ var bind = __dependency2__.bind;
+
+ var get = __dependency3__.get;
+ var isArray = __dependency4__.isArray;
+ var ConditionalStream = __dependency5__["default"];
+ var isStream = __dependency6__.isStream;
+
+ function shouldDisplayIfHelperContent(result) {
+ var truthy = result && get(result, 'isTruthy');
+ if (typeof truthy === 'boolean') { return truthy; }
+
+ if (isArray(result)) {
+ return get(result, 'length') !== 0;
+ } else {
+ return !!result;
+ }
+ }
+
+ var EMPTY_TEMPLATE = {
+ isHTMLBars: true,
+ render: function() {
+ return '';
+ }
+ };
+ /**
+ Use the `boundIf` helper to create a conditional that re-evaluates
+ whenever the truthiness of the bound value changes.
+
+ ```handlebars
+ {{#boundIf "content.shouldDisplayTitle"}}
+ {{content.title}}
+ {{/boundIf}}
+ ```
+
+ @private
+ @method boundIf
+ @for Ember.Handlebars.helpers
+ @param {String} property Property to bind
+ @param {Function} fn Context to provide for rendering
+ @return {String} HTML string
+ */
+ function boundIfHelper(params, hash, options, env) {
+ options.helperName = options.helperName || 'boundIf';
+ return bind.call(this, params[0], hash, options, env, true, shouldDisplayIfHelperContent, shouldDisplayIfHelperContent, [
+ 'isTruthy',
+ 'length'
+ ]);
+ }
+
+ /**
+ @private
+
+ Use the `unboundIf` helper to create a conditional that evaluates once.
+
+ ```handlebars
+ {{#unboundIf "content.shouldDisplayTitle"}}
+ {{content.title}}
+ {{/unboundIf}}
+ ```
+
+ @method unboundIf
+ @for Ember.Handlebars.helpers
+ @param {String} property Property to bind
+ @param {Function} fn Context to provide for rendering
+ @return {String} HTML string
+ @since 1.4.0
+ */
+ function unboundIfHelper(params, hash, options, env) {
+ var template = options.template;
+ var value = params[0];
+
+ if (isStream(params[0])) {
+ value = params[0].value();
+ }
+
+ if (!shouldDisplayIfHelperContent(value)) {
+ template = options.inverse || EMPTY_TEMPLATE;
+ }
+
+ return template.render(this, env, options.morph.contextualElement);
+ }
+
+ function _inlineIfAssertion(params) {
+ Ember.assert("If helper in inline form expects between two and three arguments", params.length === 2 || params.length === 3);
+ }
+
+ /**
+ See [boundIf](/api/classes/Ember.Handlebars.helpers.html#method_boundIf)
+ and [unboundIf](/api/classes/Ember.Handlebars.helpers.html#method_unboundIf)
+
+ @method if
+ @for Ember.Handlebars.helpers
+ @param {Function} context
+ @param {Hash} options
+ @return {String} HTML string
+ */
+ function ifHelper(params, hash, options, env) {
+ Ember.assert("If helper in block form expect exactly one argument", !options.template || params.length === 1);
+
+ options.inverse = options.inverse || EMPTY_TEMPLATE;
+
+ options.helperName = options.helperName || ('if ');
+
+ if (env.data.isUnbound) {
+ env.data.isUnbound = false;
+ return env.helpers.unboundIf.helperFunction.call(this, params, hash, options, env);
+ } else {
+ return env.helpers.boundIf.helperFunction.call(this, params, hash, options, env);
+ }
+ }
+
+ /**
+ @method unless
+ @for Ember.Handlebars.helpers
+ @param {Function} context
+ @param {Hash} options
+ @return {String} HTML string
+ */
+ function unlessHelper(params, hash, options, env) {
+ Ember.assert("You must pass exactly one argument to the unless helper", params.length === 1);
+ Ember.assert("You must pass a block to the unless helper", !!options.template);
+
+ var template = options.template;
+ var inverse = options.inverse || EMPTY_TEMPLATE;
+ var helperName = 'unless';
+
+ options.template = inverse;
+ options.inverse = template;
+
+ options.helperName = options.helperName || helperName;
+
+ if (env.data.isUnbound) {
+ env.data.isUnbound = false;
+ return env.helpers.unboundIf.helperFunction.call(this, params, hash, options, env);
+ } else {
+ return env.helpers.boundIf.helperFunction.call(this, params, hash, options, env);
+ }
+ }
+
+ __exports__.ifHelper = ifHelper;
+ __exports__.boundIfHelper = boundIfHelper;
+ __exports__.unboundIfHelper = unboundIfHelper;
+ __exports__.unlessHelper = unlessHelper;
+ });
+enifed("ember-htmlbars/helpers/input",
+ ["ember-views/views/checkbox","ember-views/views/text_field","ember-metal/streams/utils","ember-metal/core","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ var Checkbox = __dependency1__["default"];
+ var TextField = __dependency2__["default"];
+ var read = __dependency3__.read;
+
+ var Ember = __dependency4__["default"];
+ // Ember.assert
+
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ /**
+
+ The `{{input}}` helper inserts an HTML `` tag into the template,
+ with a `type` value of either `text` or `checkbox`. If no `type` is provided,
+ `text` will be the default value applied. The attributes of `{{input}}`
+ match those of the native HTML tag as closely as possible for these two types.
+
+ ## Use as text field
+ An `{{input}}` with no `type` or a `type` of `text` will render an HTML text input.
+ The following HTML attributes can be set via the helper:
+
+
+
`readonly`
`required`
`autofocus`
+
`value`
`placeholder`
`disabled`
+
`size`
`tabindex`
`maxlength`
+
`name`
`min`
`max`
+
`pattern`
`accept`
`autocomplete`
+
`autosave`
`formaction`
`formenctype`
+
`formmethod`
`formnovalidate`
`formtarget`
+
`height`
`inputmode`
`multiple`
+
`step`
`width`
`form`
+
`selectionDirection`
`spellcheck`
+
+
+
+ When set to a quoted string, these values will be directly applied to the HTML
+ element. When left unquoted, these values will be bound to a property on the
+ template's current rendering context (most typically a controller instance).
+
+ ## Unbound:
+
+ ```handlebars
+ {{input value="http://www.facebook.com"}}
+ ```
+
+
+ ```html
+
+ ```
+
+ ## Bound:
+
+ ```javascript
+ App.ApplicationController = Ember.Controller.extend({
+ firstName: "Stanley",
+ entryNotAllowed: true
+ });
+ ```
+
+
+ ```handlebars
+ {{input type="text" value=firstName disabled=entryNotAllowed size="50"}}
+ ```
+
+
+ ```html
+
+ ```
+
+ ## Actions
+
+ The helper can send multiple actions based on user events.
+
+ The action property defines the action which is sent when
+ the user presses the return key.
+
+ ```handlebars
+ {{input action="submit"}}
+ ```
+
+ The helper allows some user events to send actions.
+
+ * `enter`
+ * `insert-newline`
+ * `escape-press`
+ * `focus-in`
+ * `focus-out`
+ * `key-press`
+
+
+ For example, if you desire an action to be sent when the input is blurred,
+ you only need to setup the action name to the event name property.
+
+ ```handlebars
+ {{input focus-in="alertMessage"}}
+ ```
+
+ See more about [Text Support Actions](/api/classes/Ember.TextField.html)
+
+ ## Extension
+
+ Internally, `{{input type="text"}}` creates an instance of `Ember.TextField`, passing
+ arguments from the helper to `Ember.TextField`'s `create` method. You can extend the
+ capabilities of text inputs in your applications by reopening this class. For example,
+ if you are building a Bootstrap project where `data-*` attributes are used, you
+ can add one to the `TextField`'s `attributeBindings` property:
+
+
+ ```javascript
+ Ember.TextField.reopen({
+ attributeBindings: ['data-error']
+ });
+ ```
+
+ Keep in mind when writing `Ember.TextField` subclasses that `Ember.TextField`
+ itself extends `Ember.Component`, meaning that it does NOT inherit
+ the `controller` of the parent view.
+
+ See more about [Ember components](/api/classes/Ember.Component.html)
+
+
+ ## Use as checkbox
+
+ An `{{input}}` with a `type` of `checkbox` will render an HTML checkbox input.
+ The following HTML attributes can be set via the helper:
+
+ * `checked`
+ * `disabled`
+ * `tabindex`
+ * `indeterminate`
+ * `name`
+ * `autofocus`
+ * `form`
+
+
+ When set to a quoted string, these values will be directly applied to the HTML
+ element. When left unquoted, these values will be bound to a property on the
+ template's current rendering context (most typically a controller instance).
+
+ ## Unbound:
+
+ ```handlebars
+ {{input type="checkbox" name="isAdmin"}}
+ ```
+
+ ```html
+
+ ```
+
+ ## Bound:
+
+ ```javascript
+ App.ApplicationController = Ember.Controller.extend({
+ isAdmin: true
+ });
+ ```
+
+
+ ```handlebars
+ {{input type="checkbox" checked=isAdmin }}
+ ```
+
+
+ ```html
+
+ ```
+
+ ## Extension
+
+ Internally, `{{input type="checkbox"}}` creates an instance of `Ember.Checkbox`, passing
+ arguments from the helper to `Ember.Checkbox`'s `create` method. You can extend the
+ capablilties of checkbox inputs in your applications by reopening this class. For example,
+ if you wanted to add a css class to all checkboxes in your application:
+
+
+ ```javascript
+ Ember.Checkbox.reopen({
+ classNames: ['my-app-checkbox']
+ });
+ ```
+
+
+ @method input
+ @for Ember.Handlebars.helpers
+ @param {Hash} options
+ */
+ function inputHelper(params, hash, options, env) {
+ Ember.assert('You can only pass attributes to the `input` helper, not arguments', params.length === 0);
+
+ var onEvent = hash.on;
+ var inputType;
+
+ inputType = read(hash.type);
+
+ if (inputType === 'checkbox') {
+ delete hash.type;
+
+ Ember.assert("{{input type='checkbox'}} does not support setting `value=someBooleanValue`;" +
+ " you must use `checked=someBooleanValue` instead.", !hash.hasOwnProperty('value'));
+
+ env.helpers.view.helperFunction.call(this, [Checkbox], hash, options, env);
+ } else {
+ delete hash.on;
+
+ hash.onEvent = onEvent || 'enter';
+ env.helpers.view.helperFunction.call(this, [TextField], hash, options, env);
+ }
+ }
+
+ __exports__.inputHelper = inputHelper;
+ });
+enifed("ember-htmlbars/helpers/loc",
+ ["ember-metal/core","ember-runtime/system/string","ember-metal/streams/utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ var loc = __dependency2__.loc;
+ var isStream = __dependency3__.isStream;
+
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ /**
+ 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:
+
+ ```javascript
+ Ember.STRINGS = {
+ '_welcome_': 'Bonjour'
+ };
+ ```
+
+ ```handlebars
+
+ {{loc '_welcome_'}}
+
+ ```
+
+ ```html
+
+ Bonjour
+
+ ```
+
+ 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
+ @param {String} str The string to format
+ @see {Ember.String#loc}
+ */
+ function locHelper(params, hash, options, env) {
+ Ember.assert('You cannot pass bindings to `loc` helper', (function ifParamsContainBindings() {
+ for (var i = 0, l = params.length; i < l; i++) {
+ if (isStream(params[i])) {
+ return false;
+ }
+ }
+ return true;
+ })());
+
+ return loc.apply(this, params);
+ }
+
+ __exports__.locHelper = locHelper;
+ });
+enifed("ember-htmlbars/helpers/log",
+ ["ember-metal/logger","ember-metal/streams/utils","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+ var Logger = __dependency1__["default"];
+ var read = __dependency2__.read;
+
+ /**
+ `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
+ @param {String} property
+ */
+ function logHelper(params, hash, options, env) {
+ var logger = Logger.log;
+ var values = [];
+
+ for (var i = 0; i < params.length; i++) {
+ values.push(read(params[i]));
+ }
+
+ logger.apply(logger, values);
+ }
+
+ __exports__.logHelper = logHelper;
+ });
+enifed("ember-htmlbars/helpers/partial",
+ ["ember-metal/core","ember-metal/is_none","./binding","ember-metal/streams/utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+
+ var isNone = __dependency2__["default"];
+ var bind = __dependency3__.bind;
+ var isStream = __dependency4__.isStream;
+
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ /**
+ The `partial` helper renders another template without
+ changing the template context:
+
+ ```handlebars
+ {{foo}}
+ {{partial "nav"}}
+ ```
+
+ The above example template will render a template named
+ "_nav", which has the same context as the parent template
+ it's rendered into, so if the "_nav" template also referenced
+ `{{foo}}`, it would print the same thing as the `{{foo}}`
+ in the above example.
+
+ If a "_nav" template isn't found, the `partial` helper will
+ fall back to a template named "nav".
+
+ ## Bound template names
+
+ The parameter supplied to `partial` can also be a path
+ to a property containing a template name, e.g.:
+
+ ```handlebars
+ {{partial someTemplateName}}
+ ```
+
+ The above example will look up the value of `someTemplateName`
+ on the template context (e.g. a controller) and use that
+ value as the name of the template to render. If the resolved
+ value is falsy, nothing will be rendered. If `someTemplateName`
+ changes, the partial will be re-rendered using the new template
+ name.
+
+
+ @method partial
+ @for Ember.Handlebars.helpers
+ @param {String} partialName the name of the template to render minus the leading underscore
+ */
+
+ function partialHelper(params, hash, options, env) {
+ options.helperName = options.helperName || 'partial';
+
+ var name = params[0];
+
+ if (isStream(name)) {
+ options.template = createPartialTemplate(name);
+ bind.call(this, name, hash, options, env, true, exists);
+ } else {
+ return renderPartial(name, this, env, options.morph.contextualElement);
+ }
+ }
+
+ __exports__.partialHelper = partialHelper;function exists(value) {
+ return !isNone(value);
+ }
+
+ function lookupPartial(view, templateName) {
+ var nameParts = templateName.split("/");
+ var lastPart = nameParts[nameParts.length - 1];
+
+ nameParts[nameParts.length - 1] = "_" + lastPart;
+
+ var underscoredName = nameParts.join('/');
+ var template = view.templateForName(underscoredName);
+ if (!template) {
+ template = view.templateForName(templateName);
+ }
+
+ Ember.assert('Unable to find partial with name "'+templateName+'"', !!template);
+
+ return template;
+ }
+
+ function renderPartial(name, view, env, contextualElement) {
+ var template = lookupPartial(view, name);
+ return template.render(view, env, contextualElement);
+ }
+
+ function createPartialTemplate(nameStream) {
+ return {
+ isHTMLBars: true,
+ render: function(view, env, contextualElement) {
+ return renderPartial(nameStream.value(), view, env, contextualElement);
+ }
+ };
+ }
+ });
+enifed("ember-htmlbars/helpers/template",
+ ["ember-metal/core","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // Ember.deprecate;
+
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ /**
+ @deprecated
+ @method template
+ @for Ember.Handlebars.helpers
+ @param {String} templateName the template to render
+ */
+ function templateHelper(params, hash, options, env) {
+ Ember.deprecate("The `template` helper has been deprecated in favor of the `partial` helper." +
+ " Please use `partial` instead, which will work the same way.");
+
+ options.helperName = options.helperName || 'template';
+
+ return env.helpers.partial.helperFunction.call(this, params, hash, options, env);
+ }
+
+ __exports__.templateHelper = templateHelper;
+ });
+enifed("ember-htmlbars/helpers/text_area",
+ ["ember-metal/core","ember-views/views/text_area","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+ var TextArea = __dependency2__["default"];
+
+ /**
+ `{{textarea}}` inserts a new instance of `
+ ```
+
+ Bound:
+
+ In the following example, the `writtenWords` property on `App.ApplicationController`
+ will be updated live as the user types 'Lots of text that IS bound' into
+ the text area of their browser's window.
+
+ ```javascript
+ App.ApplicationController = Ember.Controller.extend({
+ writtenWords: "Lots of text that IS bound"
+ });
+ ```
+
+ ```handlebars
+ {{textarea value=writtenWords}}
+ ```
+
+ Would result in the following HTML:
+
+ ```html
+
+ ```
+
+ If you wanted a one way binding between the text area and a div tag
+ somewhere else on your screen, you could use `Ember.computed.oneWay`:
+
+ ```javascript
+ App.ApplicationController = Ember.Controller.extend({
+ writtenWords: "Lots of text that IS bound",
+ outputWrittenWords: Ember.computed.oneWay("writtenWords")
+ });
+ ```
+
+ ```handlebars
+ {{textarea value=writtenWords}}
+
+
+ {{outputWrittenWords}}
+
+ ```
+
+ Would result in the following HTML:
+
+ ```html
+
+
+ <-- the following div will be updated in real time as you type -->
+
+
+ Lots of text that IS bound
+
+ ```
+
+ Finally, this example really shows the power and ease of Ember when two
+ properties are bound to eachother via `Ember.computed.alias`. Type into
+ either text area box and they'll both stay in sync. Note that
+ `Ember.computed.alias` costs more in terms of performance, so only use it when
+ your really binding in both directions:
+
+ ```javascript
+ App.ApplicationController = Ember.Controller.extend({
+ writtenWords: "Lots of text that IS bound",
+ twoWayWrittenWords: Ember.computed.alias("writtenWords")
+ });
+ ```
+
+ ```handlebars
+ {{textarea value=writtenWords}}
+ {{textarea value=twoWayWrittenWords}}
+ ```
+
+ ```html
+
+
+ <-- both updated in real time -->
+
+
+ ```
+
+ ## Actions
+
+ The helper can send multiple actions based on user events.
+
+ The action property defines the action which is send when
+ the user presses the return key.
+
+ ```handlebars
+ {{input action="submit"}}
+ ```
+
+ The helper allows some user events to send actions.
+
+ * `enter`
+ * `insert-newline`
+ * `escape-press`
+ * `focus-in`
+ * `focus-out`
+ * `key-press`
+
+ For example, if you desire an action to be sent when the input is blurred,
+ you only need to setup the action name to the event name property.
+
+ ```handlebars
+ {{textarea focus-in="alertMessage"}}
+ ```
+
+ See more about [Text Support Actions](/api/classes/Ember.TextArea.html)
+
+ ## Extension
+
+ Internally, `{{textarea}}` creates an instance of `Ember.TextArea`, passing
+ arguments from the helper to `Ember.TextArea`'s `create` method. You can
+ extend the capabilities of text areas in your application by reopening this
+ class. For example, if you are building a Bootstrap project where `data-*`
+ attributes are used, you can globally add support for a `data-*` attribute
+ on all `{{textarea}}`s' in your app by reopening `Ember.TextArea` or
+ `Ember.TextSupport` and adding it to the `attributeBindings` concatenated
+ property:
+
+ ```javascript
+ Ember.TextArea.reopen({
+ attributeBindings: ['data-error']
+ });
+ ```
+
+ Keep in mind when writing `Ember.TextArea` subclasses that `Ember.TextArea`
+ itself extends `Ember.Component`, meaning that it does NOT inherit
+ the `controller` of the parent view.
+
+ See more about [Ember components](/api/classes/Ember.Component.html)
+
+ @method textarea
+ @for Ember.Handlebars.helpers
+ @param {Hash} options
+ */
+ function textareaHelper(params, hash, options, env) {
+ Ember.assert('You can only pass attributes to the `textarea` helper, not arguments', params.length === 0);
+
+ return env.helpers.view.helperFunction.call(this, [TextArea], hash, options, env);
+ }
+
+ __exports__.textareaHelper = textareaHelper;
+ });
+enifed("ember-htmlbars/helpers/unbound",
+ ["ember-htmlbars/system/lookup-helper","ember-metal/streams/utils","ember-metal/error","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var lookupHelper = __dependency1__["default"];
+ var read = __dependency2__.read;
+ var EmberError = __dependency3__["default"];
+
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ /**
+ `unbound` allows you to output a property without binding. *Important:* The
+ output will not be updated if the property changes. Use with caution.
+
+ ```handlebars
+
{{unbound somePropertyThatDoesntChange}}
+ ```
+
+ `unbound` can also be used in conjunction with a bound helper to
+ render it in its unbound form:
+
+ ```handlebars
+
+ ```
+
+ @method unbound
+ @for Ember.Handlebars.helpers
+ @param {String} property
+ @return {String} HTML string
+ */
+ function unboundHelper(params, hash, options, env) {
+ var length = params.length;
+ var result;
+
+ options.helperName = options.helperName || 'unbound';
+
+ if (length === 1) {
+ result = read(params[0]);
+ } else if (length >= 2) {
+ env.data.isUnbound = true;
+
+ var helperName = params[0]._label;
+ var args = [];
+
+ for (var i = 1, l = params.length; i < l; i++) {
+ var value = read(params[i]);
+
+ args.push(value);
+ }
+
+ var helper = lookupHelper(helperName, this, env);
+
+ if (!helper) {
+ throw new EmberError('HTMLBars error: Could not find component or helper named ' + helperName + '.');
+ }
+
+ result = helper.helperFunction.call(this, args, hash, options, env);
+
+ delete env.data.isUnbound;
+ }
+
+ return result;
+ }
+
+ __exports__.unboundHelper = unboundHelper;
+ });
+enifed("ember-htmlbars/helpers/view",
+ ["ember-metal/core","ember-runtime/system/object","ember-metal/property_get","ember-metal/streams/simple","ember-metal/keys","ember-metal/mixin","ember-metal/streams/utils","ember-views/streams/utils","ember-views/views/view","ember-metal/enumerable_utils","ember-views/streams/class_name_binding","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ // Ember.warn, Ember.assert
+ var EmberObject = __dependency2__["default"];
+ var get = __dependency3__.get;
+ var SimpleStream = __dependency4__["default"];
+ var keys = __dependency5__["default"];
+ var IS_BINDING = __dependency6__.IS_BINDING;
+ var read = __dependency7__.read;
+ var isStream = __dependency7__.isStream;
+ var readViewFactory = __dependency8__.readViewFactory;
+ var View = __dependency9__["default"];
+
+ var map = __dependency10__.map;
+ var streamifyClassNameBinding = __dependency11__.streamifyClassNameBinding;
+
+ function makeBindings(hash, options, view) {
+ for (var prop in hash) {
+ var value = hash[prop];
+
+ // Classes are processed separately
+ if (prop === 'class' && isStream(value)) {
+ hash.classBinding = value._label;
+ delete hash['class'];
+ continue;
+ }
+
+ if (prop === 'classBinding') {
+ continue;
+ }
+
+ if (IS_BINDING.test(prop)) {
+ if (isStream(value)) {
+ Ember.warn("You're attempting to render a view by passing " +
+ prop + " " +
+ "to a view helper without a quoted value, " +
+ "but this syntax is ambiguous. You should either surround " +
+ prop + "'s value in quotes or remove `Binding` " +
+ "from " + prop + ".");
+ } else if (typeof value === 'string') {
+ hash[prop] = view._getBindingForStream(value);
+ }
+ } else {
+ if (isStream(value) && prop !== 'id') {
+ hash[prop + 'Binding'] = view._getBindingForStream(value);
+ delete hash[prop];
+ }
+ }
+ }
+ }
+
+ var ViewHelper = EmberObject.create({
+ propertiesFromHTMLOptions: function(hash, options, env) {
+ var view = env.data.view;
+ var classes = read(hash['class']);
+
+ var extensions = {
+ helperName: options.helperName || ''
+ };
+
+ if (hash.id) {
+ extensions.elementId = read(hash.id);
+ }
+
+ if (hash.tag) {
+ extensions.tagName = hash.tag;
+ }
+
+ if (classes) {
+ classes = classes.split(' ');
+ extensions.classNames = classes;
+ }
+
+ if (hash.classBinding) {
+ extensions.classNameBindings = hash.classBinding.split(' ');
+ }
+
+ if (hash.classNameBindings) {
+ if (extensions.classNameBindings === undefined) {
+ extensions.classNameBindings = [];
+ }
+ extensions.classNameBindings = extensions.classNameBindings.concat(hash.classNameBindings.split(' '));
+ }
+
+ if (hash.attributeBindings) {
+ Ember.assert("Setting 'attributeBindings' via template helpers is not allowed." +
+ " Please subclass Ember.View and set it there instead.");
+ extensions.attributeBindings = null;
+ }
+
+ // Set the proper context for all bindings passed to the helper. This applies to regular attribute bindings
+ // as well as class name bindings. If the bindings are local, make them relative to the current context
+ // instead of the view.
+
+ var hashKeys = keys(hash);
+
+ for (var i = 0, l = hashKeys.length; i < l; i++) {
+ var prop = hashKeys[i];
+
+ if (prop !== 'classNameBindings') {
+ extensions[prop] = hash[prop];
+ }
+ }
+
+ if (extensions.classNameBindings) {
+ extensions.classNameBindings = map(extensions.classNameBindings, function(classNameBinding){
+ var binding = streamifyClassNameBinding(view, classNameBinding);
+ if (isStream(binding)) {
+ return binding;
+ } else {
+ // returning a stream informs the classNameBindings logic
+ // in views/view that this value is already processed.
+ return new SimpleStream(binding);
+ }
+ });
+ }
+
+ return extensions;
+ },
+
+ helper: function(newView, hash, options, env) {
+ var data = env.data;
+ var template = options.template;
+ var newViewProto;
+
+ makeBindings(hash, options, env.data.view);
+
+ var viewOptions = this.propertiesFromHTMLOptions(hash, options, env);
+ var currentView = data.view;
+
+ if (View.detectInstance(newView)) {
+ newViewProto = newView;
+ } else {
+ newViewProto = newView.proto();
+ }
+
+ if (template) {
+ Ember.assert(
+ "You cannot provide a template block if you also specified a templateName",
+ !get(viewOptions, 'templateName') && !get(newViewProto, 'templateName')
+ );
+ viewOptions.template = template;
+ }
+
+ // We only want to override the `_context` computed property if there is
+ // no specified controller. See View#_context for more information.
+ if (!newViewProto.controller && !newViewProto.controllerBinding && !viewOptions.controller && !viewOptions.controllerBinding) {
+ viewOptions._context = get(currentView, 'context'); // TODO: is this right?!
+ }
+
+ viewOptions._morph = options.morph;
+
+ currentView.appendChild(newView, viewOptions);
+ },
+
+ instanceHelper: function(newView, hash, options, env) {
+ var data = env.data;
+ var template = options.template;
+
+ makeBindings(hash, options, env.data.view);
+
+ Ember.assert(
+ 'Only a instance of a view may be passed to the ViewHelper.instanceHelper',
+ View.detectInstance(newView)
+ );
+
+ var viewOptions = this.propertiesFromHTMLOptions(hash, options, env);
+ var currentView = data.view;
+
+ if (template) {
+ Ember.assert(
+ "You cannot provide a template block if you also specified a templateName",
+ !get(viewOptions, 'templateName') && !get(newView, 'templateName')
+ );
+ viewOptions.template = template;
+ }
+
+ // We only want to override the `_context` computed property if there is
+ // no specified controller. See View#_context for more information.
+ if (!newView.controller && !newView.controllerBinding &&
+ !viewOptions.controller && !viewOptions.controllerBinding) {
+ viewOptions._context = get(currentView, 'context'); // TODO: is this right?!
+ }
+
+ viewOptions._morph = options.morph;
+
+ currentView.appendChild(newView, viewOptions);
+ }
+ });
+ __exports__.ViewHelper = ViewHelper;
+ /**
+ `{{view}}` inserts a new instance of an `Ember.View` into a template passing its
+ options to the `Ember.View`'s `create` method and using the supplied block as
+ the view's own template.
+
+ An empty `` and the following template:
+
+ ```handlebars
+ A span:
+ {{#view tagName="span"}}
+ hello.
+ {{/view}}
+ ```
+
+ Will result in HTML structure:
+
+ ```html
+
+
+
+
+ A span:
+
+ Hello.
+
+
+
+ ```
+
+ ### `parentView` setting
+
+ The `parentView` property of the new `Ember.View` instance created through
+ `{{view}}` will be set to the `Ember.View` instance of the template where
+ `{{view}}` was called.
+
+ ```javascript
+ aView = Ember.View.create({
+ template: Ember.Handlebars.compile("{{#view}} my parent: {{parentView.elementId}} {{/view}}")
+ });
+
+ aView.appendTo('body');
+ ```
+
+ Will result in HTML structure:
+
+ ```html
+
+
+ my parent: ember1
+
+
+ ```
+
+ ### Setting CSS id and class attributes
+
+ The HTML `id` attribute can be set on the `{{view}}`'s resulting element with
+ the `id` option. This option will _not_ be passed to `Ember.View.create`.
+
+ ```handlebars
+ {{#view tagName="span" id="a-custom-id"}}
+ hello.
+ {{/view}}
+ ```
+
+ Results in the following HTML structure:
+
+ ```html
+
+
+ hello.
+
+
+ ```
+
+ The HTML `class` attribute can be set on the `{{view}}`'s resulting element
+ with the `class` or `classNameBindings` options. The `class` option will
+ directly set the CSS `class` attribute and will not be passed to
+ `Ember.View.create`. `classNameBindings` will be passed to `create` and use
+ `Ember.View`'s class name binding functionality:
+
+ ```handlebars
+ {{#view tagName="span" class="a-custom-class"}}
+ hello.
+ {{/view}}
+ ```
+
+ Results in the following HTML structure:
+
+ ```html
+
+
+ hello.
+
+
+ ```
+
+ ### Supplying a different view class
+
+ `{{view}}` can take an optional first argument before its supplied options to
+ specify a path to a custom view class.
+
+ ```handlebars
+ {{#view "custom"}}{{! will look up App.CustomView }}
+ hello.
+ {{/view}}
+ ```
+
+ The first argument can also be a relative path accessible from the current
+ context.
+
+ ```javascript
+ MyApp = Ember.Application.create({});
+ MyApp.OuterView = Ember.View.extend({
+ innerViewClass: Ember.View.extend({
+ classNames: ['a-custom-view-class-as-property']
+ }),
+ template: Ember.Handlebars.compile('{{#view view.innerViewClass}} hi {{/view}}')
+ });
+
+ MyApp.OuterView.create().appendTo('body');
+ ```
+
+ Will result in the following HTML:
+
+ ```html
+
+
+ hi
+
+
+ ```
+
+ ### Blockless use
+
+ If you supply a custom `Ember.View` subclass that specifies its own template
+ or provide a `templateName` option to `{{view}}` it can be used without
+ supplying a block. Attempts to use both a `templateName` option and supply a
+ block will throw an error.
+
+ ```javascript
+ var App = Ember.Application.create();
+ App.WithTemplateDefinedView = Ember.View.extend({
+ templateName: 'defined-template'
+ });
+ ```
+
+ ```handlebars
+ {{! application.hbs }}
+ {{view 'with-template-defined'}}
+ ```
+
+ ```handlebars
+ {{! defined-template.hbs }}
+ Some content for the defined template view.
+ ```
+
+ ### `viewName` property
+
+ You can supply a `viewName` option to `{{view}}`. The `Ember.View` instance
+ will be referenced as a property of its parent view by this name.
+
+ ```javascript
+ aView = Ember.View.create({
+ template: Ember.Handlebars.compile('{{#view viewName="aChildByName"}} hi {{/view}}')
+ });
+
+ aView.appendTo('body');
+ aView.get('aChildByName') // the instance of Ember.View created by {{view}} helper
+ ```
+
+ @method view
+ @for Ember.Handlebars.helpers
+ @param {String} path
+ @param {Hash} options
+ @return {String} HTML string
+ */
+ function viewHelper(params, hash, options, env) {
+ Ember.assert("The view helper only takes a single argument", params.length <= 2);
+
+ var container = this.container || read(this._keywords.view).container;
+ var viewClass;
+
+ if (params.length === 0) {
+ if (container) {
+ viewClass = container.lookupFactory('view:toplevel');
+ } else {
+ viewClass = View;
+ }
+ } else {
+ var pathStream = params[0];
+ viewClass = readViewFactory(pathStream, container);
+ }
+
+ options.helperName = options.helperName || 'view';
+
+ return ViewHelper.helper(viewClass, hash, options, env);
+ }
+
+ __exports__.viewHelper = viewHelper;
+ });
+enifed("ember-htmlbars/helpers/with",
+ ["ember-metal/core","ember-metal/is_none","ember-htmlbars/helpers/binding","ember-views/views/with_view","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+ var isNone = __dependency2__["default"];
+ var bind = __dependency3__.bind;
+ var WithView = __dependency4__["default"];
+
+ /**
+ Use the `{{with}}` helper when you want to aliases the to a new name. It's helpful
+ for semantic clarity and to retain default scope or to reference from another
+ `{{with}}` block.
+
+ ```handlebars
+ // posts might not be
+ {{#with user.posts as blogPosts}}
+
+ There are {{blogPosts.length}} blog posts written by {{user.name}}.
+
+
+ {{#each post in blogPosts}}
+
{{post.title}}
+ {{/each}}
+ {{/with}}
+ ```
+
+ Without the `as` operator, it would be impossible to reference `user.name` in the example above.
+
+ NOTE: The alias should not reuse a name from the bound property path.
+ For example: `{{#with foo.bar as foo}}` is not supported because it attempts to alias using
+ the first part of the property path, `foo`. Instead, use `{{#with foo.bar as baz}}`.
+
+ ### `controller` option
+
+ Adding `controller='something'` instructs the `{{with}}` helper to create and use an instance of
+ the specified controller wrapping the aliased keyword.
+
+ This is very similar to using an `itemController` option with the `{{each}}` helper.
+
+ ```handlebars
+ {{#with users.posts as posts controller='userBlogPosts'}}
+ {{!- `posts` is wrapped in our controller instance }}
+ {{/with}}
+ ```
+
+ In the above example, the `posts` keyword is now wrapped in the `userBlogPost` controller,
+ which provides an elegant way to decorate the context with custom
+ functions/properties.
+
+ @method with
+ @for Ember.Handlebars.helpers
+ @param {Function} context
+ @param {Hash} options
+ @return {String} HTML string
+ */
+ function withHelper(params, hash, options, env) {
+ Ember.assert(
+ "{{#with foo}} must be called with a single argument or the use the " +
+ "{{#with foo as bar}} syntax",
+ params.length === 1
+ );
+
+ Ember.assert(
+ "The {{#with}} helper must be called with a block",
+ !!options.template
+ );
+
+ var preserveContext;
+
+ if (options.template.blockParams) {
+ preserveContext = true;
+ } else {
+ Ember.deprecate(
+ "Using the context switching form of `{{with}}` is deprecated. " +
+ "Please use the keyword form (`{{with foo as bar}}`) instead.",
+ false,
+ { url: 'http://emberjs.com/guides/deprecations/#toc_more-consistent-handlebars-scope' }
+ );
+ preserveContext = false;
+ }
+
+ bind.call(this, params[0], hash, options, env, preserveContext, exists, undefined, undefined, WithView);
+ }
+
+ __exports__.withHelper = withHelper;function exists(value) {
+ return !isNone(value);
+ }
+ });
+enifed("ember-htmlbars/helpers/yield",
+ ["ember-metal/core","ember-metal/property_get","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+
+ var get = __dependency2__.get;
+
+ /**
+ `{{yield}}` denotes an area of a template that will be rendered inside
+ of another template. It has two main uses:
+
+ ### Use with `layout`
+ When used in a Handlebars template that is assigned to an `Ember.View`
+ instance's `layout` property Ember will render the layout template first,
+ inserting the view's own rendered output at the `{{yield}}` location.
+
+ An empty `` and the following application code:
+
+ ```javascript
+ AView = Ember.View.extend({
+ classNames: ['a-view-with-layout'],
+ layout: Ember.Handlebars.compile('
{{yield}}
'),
+ template: Ember.Handlebars.compile('I am wrapped')
+ });
+
+ aView = AView.create();
+ aView.appendTo('body');
+ ```
+
+ Will result in the following HTML output:
+
+ ```html
+
+
+
+ I am wrapped
+
+
+
+ ```
+
+ The `yield` helper cannot be used outside of a template assigned to an
+ `Ember.View`'s `layout` property and will throw an error if attempted.
+
+ ```javascript
+ BView = Ember.View.extend({
+ classNames: ['a-view-with-layout'],
+ template: Ember.Handlebars.compile('{{yield}}')
+ });
+
+ bView = BView.create();
+ bView.appendTo('body');
+
+ // throws
+ // Uncaught Error: assertion failed:
+ // You called yield in a template that was not a layout
+ ```
+
+ ### Use with Ember.Component
+ When designing components `{{yield}}` is used to denote where, inside the component's
+ template, an optional block passed to the component should render:
+
+ ```handlebars
+
+ {{#labeled-textfield value=someProperty}}
+ First name:
+ {{/labeled-textfield}}
+ ```
+
+ ```handlebars
+
+
+ ```
+
+ Result:
+
+ ```html
+
+ ```
+
+ @method yield
+ @for Ember.Handlebars.helpers
+ @param {Hash} options
+ @return {String} HTML string
+ */
+ function yieldHelper(params, hash, options, env) {
+ var view = this;
+
+ // Yea gods
+ while (view && !get(view, 'layout')) {
+ if (view._contextView) {
+ view = view._contextView;
+ } else {
+ view = get(view, '_parentView');
+ }
+ }
+
+ Ember.assert("You called yield in a template that was not a layout", !!view);
+
+ return view._yield(null, env, options.morph, params);
+ }
+
+ __exports__.yieldHelper = yieldHelper;
+ });
+enifed("ember-htmlbars/hooks/attribute",
+ ["ember-views/attr_nodes/attr_node","ember-metal/error","ember-metal/streams/utils","ember-views/system/sanitize_attribute_value","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var AttrNode = __dependency1__["default"];
+ var EmberError = __dependency2__["default"];
+ var isStream = __dependency3__.isStream;
+ var sanitizeAttributeValue = __dependency4__["default"];
+
+ var boundAttributesEnabled = false;
+
+
+ __exports__["default"] = function attribute(env, morph, element, attrName, attrValue) {
+ if (boundAttributesEnabled) {
+ var attrNode = new AttrNode(attrName, attrValue);
+ attrNode._morph = morph;
+ env.data.view.appendChild(attrNode);
+ } else {
+ if (isStream(attrValue)) {
+ throw new EmberError('Bound attributes are not yet supported in Ember.js');
+ } else {
+ var sanitizedValue = sanitizeAttributeValue(element, attrName, attrValue);
+ env.dom.setProperty(element, attrName, sanitizedValue);
+ }
+ }
+ }
+ });
+enifed("ember-htmlbars/hooks/block",
+ ["ember-views/views/simple_bound_view","ember-metal/streams/utils","ember-htmlbars/system/lookup-helper","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var appendSimpleBoundView = __dependency1__.appendSimpleBoundView;
+ var isStream = __dependency2__.isStream;
+ var lookupHelper = __dependency3__["default"];
+
+ __exports__["default"] = function block(env, morph, view, path, params, hash, template, inverse) {
+ var helper = lookupHelper(path, view, env);
+
+ Ember.assert("A helper named `"+path+"` could not be found", helper);
+
+ var options = {
+ morph: morph,
+ template: template,
+ inverse: inverse,
+ isBlock: true
+ };
+ var result = helper.helperFunction.call(view, params, hash, options, env);
+
+ if (isStream(result)) {
+ appendSimpleBoundView(view, morph, result);
+ } else {
+ morph.setContent(result);
+ }
+ }
+ });
+enifed("ember-htmlbars/hooks/component",
+ ["ember-metal/core","ember-htmlbars/system/lookup-helper","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ var lookupHelper = __dependency2__["default"];
+
+ __exports__["default"] = function component(env, morph, view, tagName, attrs, template) {
+ var helper = lookupHelper(tagName, view, env);
+
+ Ember.assert('You specified `' + tagName + '` in your template, but a component for `' + tagName + '` could not be found.', !!helper);
+
+ return helper.helperFunction.call(view, [], attrs, {morph: morph, template: template}, env);
+ }
+ });
+enifed("ember-htmlbars/hooks/concat",
+ ["ember-metal/streams/utils","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var streamConcat = __dependency1__.concat;
+
+ __exports__["default"] = function concat(env, parts) {
+ return streamConcat(parts, '');
+ }
+ });
+enifed("ember-htmlbars/hooks/content",
+ ["ember-views/views/simple_bound_view","ember-metal/streams/utils","ember-htmlbars/system/lookup-helper","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var appendSimpleBoundView = __dependency1__.appendSimpleBoundView;
+ var isStream = __dependency2__.isStream;
+ var lookupHelper = __dependency3__["default"];
+
+ __exports__["default"] = function content(env, morph, view, path) {
+ var helper = lookupHelper(path, view, env);
+ var result;
+
+ if (helper) {
+ var options = {
+ morph: morph,
+ isInline: true
+ };
+ result = helper.helperFunction.call(view, [], {}, options, env);
+ } else {
+ result = view.getStream(path);
+ }
+
+ if (isStream(result)) {
+ appendSimpleBoundView(view, morph, result);
+ } else {
+ morph.setContent(result);
+ }
+ }
+ });
+enifed("ember-htmlbars/hooks/element",
+ ["ember-metal/core","ember-metal/streams/utils","ember-htmlbars/system/lookup-helper","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ var read = __dependency2__.read;
+ var lookupHelper = __dependency3__["default"];
+
+ __exports__["default"] = function element(env, domElement, view, path, params, hash) { //jshint ignore:line
+ var helper = lookupHelper(path, view, env);
+ var valueOrLazyValue;
+
+ if (helper) {
+ var options = {
+ element: domElement
+ };
+ valueOrLazyValue = helper.helperFunction.call(view, params, hash, options, env);
+ } else {
+ valueOrLazyValue = view.getStream(path);
+ }
+
+ var value = read(valueOrLazyValue);
+ if (value) {
+ Ember.deprecate('Returning a string of attributes from a helper inside an element is deprecated.');
+
+ var parts = value.toString().split(/\s+/);
+ for (var i = 0, l = parts.length; i < l; i++) {
+ var attrParts = parts[i].split('=');
+ var attrName = attrParts[0];
+ var attrValue = attrParts[1];
+
+ attrValue = attrValue.replace(/^['"]/, '').replace(/['"]$/, '');
+
+ env.dom.setAttribute(domElement, attrName, attrValue);
+ }
+ }
+ }
+ });
+enifed("ember-htmlbars/hooks/get",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ __exports__["default"] = function get(env, view, path) {
+ return view.getStream(path);
+ }
+ });
+enifed("ember-htmlbars/hooks/inline",
+ ["ember-views/views/simple_bound_view","ember-metal/streams/utils","ember-htmlbars/system/lookup-helper","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var appendSimpleBoundView = __dependency1__.appendSimpleBoundView;
+ var isStream = __dependency2__.isStream;
+ var lookupHelper = __dependency3__["default"];
+
+ __exports__["default"] = function inline(env, morph, view, path, params, hash) {
+ var helper = lookupHelper(path, view, env);
+
+ Ember.assert("A helper named '"+path+"' could not be found", helper);
+
+ var result = helper.helperFunction.call(view, params, hash, {morph: morph}, env);
+
+ if (isStream(result)) {
+ appendSimpleBoundView(view, morph, result);
+ } else {
+ morph.setContent(result);
+ }
+ }
+ });
+enifed("ember-htmlbars/hooks/set",
+ ["ember-metal/core","ember-metal/error","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ var EmberError = __dependency2__["default"];
+
+ __exports__["default"] = function set(env, view, name, value) {
+
+ view._keywords[name] = value;
+ }
+ });
+enifed("ember-htmlbars/hooks/subexpr",
+ ["ember-htmlbars/system/lookup-helper","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var lookupHelper = __dependency1__["default"];
+
+ __exports__["default"] = function subexpr(env, view, path, params, hash) {
+ var helper = lookupHelper(path, view, env);
+
+ Ember.assert("A helper named '"+path+"' could not be found", helper);
+
+ var options = {
+ isInline: true
+ };
+ return helper.helperFunction.call(view, params, hash, options, env);
+ }
+ });
+enifed("ember-htmlbars/system/bootstrap",
+ ["ember-metal/core","ember-views/component_lookup","ember-views/system/jquery","ember-metal/error","ember-runtime/system/lazy_load","ember-template-compiler/system/compile","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
+ "use strict";
+ /*globals Handlebars */
+
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ var ComponentLookup = __dependency2__["default"];
+ var jQuery = __dependency3__["default"];
+ var EmberError = __dependency4__["default"];
+ var onLoad = __dependency5__.onLoad;
+ var htmlbarsCompile = __dependency6__["default"];
+
+ /**
+ @module ember
+ @submodule ember-handlebars
+ */
+
+ /**
+ Find templates stored in the head tag as script tags and make them available
+ to `Ember.CoreView` in the global `Ember.TEMPLATES` object. This will be run
+ as as jQuery DOM-ready callback.
+
+ Script tags with `text/x-handlebars` will be compiled
+ with Ember's Handlebars and are suitable for use as a view's template.
+ Those with type `text/x-raw-handlebars` will be compiled with regular
+ Handlebars and are suitable for use in views' computed properties.
+
+ @private
+ @method bootstrap
+ @for Ember.Handlebars
+ @static
+ @param ctx
+ */
+ function bootstrap(ctx) {
+ var selectors = 'script[type="text/x-handlebars"], script[type="text/x-raw-handlebars"]';
+
+ jQuery(selectors, ctx)
+ .each(function() {
+ // Get a reference to the script tag
+ var script = jQuery(this);
+
+ var compile = (script.attr('type') === 'text/x-raw-handlebars') ?
+ jQuery.proxy(Handlebars.compile, Handlebars) :
+ htmlbarsCompile;
+ // Get the name of the script, used by Ember.View's templateName property.
+ // First look for data-template-name attribute, then fall back to its
+ // id if no name is found.
+ var templateName = script.attr('data-template-name') || script.attr('id') || 'application';
+ var template = compile(script.html());
+
+ // Check if template of same name already exists
+ if (Ember.TEMPLATES[templateName] !== undefined) {
+ throw new EmberError('Template named "' + templateName + '" already exists.');
+ }
+
+ // For templates which have a name, we save them and then remove them from the DOM
+ Ember.TEMPLATES[templateName] = template;
+
+ // Remove script tag from DOM
+ script.remove();
+ });
+ }
+
+ function _bootstrap() {
+ bootstrap( jQuery(document) );
+ }
+
+ function registerComponentLookup(container) {
+ container.register('component-lookup:main', ComponentLookup);
+ }
+
+ /*
+ We tie this to application.load to ensure that we've at least
+ attempted to bootstrap at the point that the application is loaded.
+
+ We also tie this to document ready since we're guaranteed that all
+ the inline templates are present at this point.
+
+ There's no harm to running this twice, since we remove the templates
+ from the DOM after processing.
+ */
+
+ onLoad('Ember.Application', function(Application) {
+
+
+ Application.initializer({
+ name: 'domTemplates',
+ initialize: _bootstrap
+ });
+
+ Application.initializer({
+ name: 'registerComponentLookup',
+ after: 'domTemplates',
+ initialize: registerComponentLookup
+ });
+
+
+ });
+
+ __exports__["default"] = bootstrap;
+ });
+enifed("ember-htmlbars/system/helper",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ /**
+ @class Helper
+ @namespace Ember.HTMLBars
+ */
+ function Helper(helper) {
+ this.helperFunction = helper;
+
+ this.isHelper = true;
+ this.isHTMLBars = true;
+ }
+
+ __exports__["default"] = Helper;
+ });
+enifed("ember-htmlbars/system/lookup-helper",
+ ["ember-metal/core","ember-metal/cache","ember-htmlbars/system/make-view-helper","ember-htmlbars/compat/helper","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ var Cache = __dependency2__["default"];
+ var makeViewHelper = __dependency3__["default"];
+ var HandlebarsCompatibleHelper = __dependency4__["default"];
+
+ var ISNT_HELPER_CACHE = new Cache(1000, function(key) {
+ return key.indexOf('-') === -1;
+ });
+ __exports__.ISNT_HELPER_CACHE = ISNT_HELPER_CACHE;
+ /**
+ Used to lookup/resolve handlebars helpers. The lookup order is:
+
+ * Look for a registered helper
+ * If a dash exists in the name:
+ * Look for a helper registed in the container
+ * Use Ember.ComponentLookup to find an Ember.Component that resolves
+ to the given name
+
+ @private
+ @method resolveHelper
+ @param {Container} container
+ @param {String} name the name of the helper to lookup
+ @return {Handlebars Helper}
+ */
+ __exports__["default"] = function lookupHelper(name, view, env) {
+ var helper = env.helpers[name];
+ if (helper) {
+ return helper;
+ }
+
+ var container = view.container;
+
+ if (!container || ISNT_HELPER_CACHE.get(name)) {
+ return;
+ }
+
+ var helperName = 'helper:' + name;
+ helper = container.lookup(helperName);
+ if (!helper) {
+ var componentLookup = container.lookup('component-lookup:main');
+ Ember.assert("Could not find 'component-lookup:main' on the provided container," +
+ " which is necessary for performing component lookups", componentLookup);
+
+ var Component = componentLookup.lookupFactory(name, container);
+ if (Component) {
+ helper = makeViewHelper(Component);
+ container.register(helperName, helper);
+ }
+ }
+
+ if (helper && !helper.isHTMLBars) {
+ helper = new HandlebarsCompatibleHelper(helper);
+ container.unregister(helperName);
+ container.register(helperName, helper);
+ }
+
+ return helper;
+ }
+ });
+enifed("ember-htmlbars/system/make-view-helper",
+ ["ember-metal/core","ember-htmlbars/system/helper","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+ var Helper = __dependency2__["default"];
+
+ /**
+ Returns a helper function that renders the provided ViewClass.
+
+ Used internally by Ember.Handlebars.helper and other methods
+ involving helper/component registration.
+
+ @private
+ @method makeViewHelper
+ @param {Function} ViewClass view class constructor
+ @since 1.2.0
+ */
+ __exports__["default"] = function makeViewHelper(ViewClass) {
+ function helperFunc(params, hash, options, env) {
+ Ember.assert("You can only pass attributes (such as name=value) not bare " +
+ "values to a helper for a View found in '" + ViewClass.toString() + "'", params.length === 0);
+
+ return env.helpers.view.helperFunction.call(this, [ViewClass], hash, options, env);
+ }
+
+ return new Helper(helperFunc);
+ }
+ });
+enifed("ember-htmlbars/system/make_bound_helper",
+ ["ember-metal/core","ember-htmlbars/system/helper","ember-metal/streams/stream","ember-metal/streams/utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ // Ember.FEATURES, Ember.assert, Ember.Handlebars, Ember.lookup
+ var Helper = __dependency2__["default"];
+
+ var Stream = __dependency3__["default"];
+ var readArray = __dependency4__.readArray;
+ var readHash = __dependency4__.readHash;
+ var subscribe = __dependency4__.subscribe;
+ var scanHash = __dependency4__.scanHash;
+ var scanArray = __dependency4__.scanArray;
+
+ /**
+ Create a bound helper. Accepts a function that receives the ordered and hash parameters
+ from the template. If a bound property was provided in the template it will be resolved to its
+ value and any changes to the bound property cause the helper function to be re-ran with the updated
+ values.
+
+ * `params` - An array of resolved ordered parameters.
+ * `hash` - An object containing the hash parameters.
+
+ For example:
+
+ * With an unqouted ordered parameter:
+
+ ```javascript
+ {{x-capitalize foo}}
+ ```
+
+ Assuming `foo` was set to `"bar"`, the bound helper would receive `["bar"]` as its first argument, and
+ an empty hash as its second.
+
+ * With a quoted ordered parameter:
+
+ ```javascript
+ {{x-capitalize "foo"}}
+ ```
+
+ The bound helper would receive `["foo"]` as its first argument, and an empty hash as its second.
+
+ * With an unquoted hash parameter:
+
+ ```javascript
+ {{x-repeat "foo" count=repeatCount}}
+ ```
+
+ Assuming that `repeatCount` resolved to 2, the bound helper would receive `["foo"]` as its first argument,
+ and { count: 2 } as its second.
+
+ @private
+ @method makeBoundHelper
+ @for Ember.HTMLBars
+ @param {Function} function
+ @since 1.10.0
+ */
+ __exports__["default"] = function makeBoundHelper(fn) {
+ function helperFunc(params, hash, options, env) {
+ var view = this;
+ var numParams = params.length;
+ var param, prop;
+
+ Ember.assert("makeBoundHelper generated helpers do not support use with blocks", !options.template);
+
+ function valueFn() {
+ return fn.call(view, readArray(params), readHash(hash), options, env);
+ }
+
+ // If none of the hash parameters are bound, act as an unbound helper.
+ // This prevents views from being unnecessarily created
+ var hasStream = scanArray(params) || scanHash(hash);
+
+ if (env.data.isUnbound || !hasStream) {
+ return valueFn();
+ } else {
+ var lazyValue = new Stream(valueFn);
+
+ for (var i = 0; i < numParams; i++) {
+ param = params[i];
+ subscribe(param, lazyValue.notify, lazyValue);
+ }
+
+ for (prop in hash) {
+ param = hash[prop];
+ subscribe(param, lazyValue.notify, lazyValue);
+ }
+
+ return lazyValue;
+ }
+ }
+
+ return new Helper(helperFunc);
+ }
+ });
+enifed("ember-htmlbars/templates/component",
+ ["ember-template-compiler/system/template","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var template = __dependency1__["default"];
+ var t = (function() {
+ return {
+ isHTMLBars: true,
+ blockParams: 0,
+ cachedFragment: null,
+ hasRendered: false,
+ build: function build(dom) {
+ var el0 = dom.createDocumentFragment();
+ var el1 = dom.createTextNode("");
+ dom.appendChild(el0, el1);
+ var el1 = dom.createTextNode("");
+ dom.appendChild(el0, el1);
+ return el0;
+ },
+ render: function render(context, env, contextualElement) {
+ var dom = env.dom;
+ var hooks = env.hooks, content = hooks.content;
+ dom.detectNamespace(contextualElement);
+ var fragment;
+ if (env.useFragmentCache && dom.canClone) {
+ if (this.cachedFragment === null) {
+ fragment = this.build(dom);
+ if (this.hasRendered) {
+ this.cachedFragment = fragment;
+ } else {
+ this.hasRendered = true;
+ }
+ }
+ if (this.cachedFragment) {
+ fragment = dom.cloneNode(this.cachedFragment, true);
+ }
+ } else {
+ fragment = this.build(dom);
+ }
+ if (this.cachedFragment) { dom.repairClonedNode(fragment,[0,1]); }
+ var morph0 = dom.createMorphAt(fragment,0,1,contextualElement);
+ content(env, morph0, context, "yield");
+ return fragment;
+ }
+ };
+ }());
+ __exports__["default"] = template(t);
+ });
+enifed("ember-htmlbars/templates/select-option",
+ ["ember-template-compiler/system/template","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var template = __dependency1__["default"];
+ var t = (function() {
+ return {
+ isHTMLBars: true,
+ blockParams: 0,
+ cachedFragment: null,
+ hasRendered: false,
+ build: function build(dom) {
+ var el0 = dom.createDocumentFragment();
+ var el1 = dom.createTextNode("");
+ dom.appendChild(el0, el1);
+ var el1 = dom.createTextNode("");
+ dom.appendChild(el0, el1);
+ return el0;
+ },
+ render: function render(context, env, contextualElement) {
+ var dom = env.dom;
+ var hooks = env.hooks, content = hooks.content;
+ dom.detectNamespace(contextualElement);
+ var fragment;
+ if (env.useFragmentCache && dom.canClone) {
+ if (this.cachedFragment === null) {
+ fragment = this.build(dom);
+ if (this.hasRendered) {
+ this.cachedFragment = fragment;
+ } else {
+ this.hasRendered = true;
+ }
+ }
+ if (this.cachedFragment) {
+ fragment = dom.cloneNode(this.cachedFragment, true);
+ }
+ } else {
+ fragment = this.build(dom);
+ }
+ if (this.cachedFragment) { dom.repairClonedNode(fragment,[0,1]); }
+ var morph0 = dom.createMorphAt(fragment,0,1,contextualElement);
+ content(env, morph0, context, "view.label");
+ return fragment;
+ }
+ };
+ }());
+ __exports__["default"] = template(t);
+ });
+enifed("ember-htmlbars/templates/select",
+ ["ember-template-compiler/system/template","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var template = __dependency1__["default"];
+ var t = (function() {
+ var child0 = (function() {
+ return {
+ isHTMLBars: true,
+ blockParams: 0,
+ cachedFragment: null,
+ hasRendered: false,
+ build: function build(dom) {
+ var el0 = dom.createElement("option");
+ dom.setAttribute(el0,"value","");
+ return el0;
+ },
+ render: function render(context, env, contextualElement) {
+ var dom = env.dom;
+ var hooks = env.hooks, content = hooks.content;
+ dom.detectNamespace(contextualElement);
+ var fragment;
+ if (env.useFragmentCache && dom.canClone) {
+ if (this.cachedFragment === null) {
+ fragment = this.build(dom);
+ if (this.hasRendered) {
+ this.cachedFragment = fragment;
+ } else {
+ this.hasRendered = true;
+ }
+ }
+ if (this.cachedFragment) {
+ fragment = dom.cloneNode(this.cachedFragment, true);
+ }
+ } else {
+ fragment = this.build(dom);
+ }
+ var morph0 = dom.createMorphAt(fragment,-1,-1);
+ content(env, morph0, context, "view.prompt");
+ return fragment;
+ }
+ };
+ }());
+ var child1 = (function() {
+ var child0 = (function() {
+ return {
+ isHTMLBars: true,
+ blockParams: 0,
+ cachedFragment: null,
+ hasRendered: false,
+ build: function build(dom) {
+ var el0 = dom.createDocumentFragment();
+ var el1 = dom.createTextNode("");
+ dom.appendChild(el0, el1);
+ var el1 = dom.createTextNode("");
+ dom.appendChild(el0, el1);
+ return el0;
+ },
+ render: function render(context, env, contextualElement) {
+ var dom = env.dom;
+ var hooks = env.hooks, get = hooks.get, inline = hooks.inline;
+ dom.detectNamespace(contextualElement);
+ var fragment;
+ if (env.useFragmentCache && dom.canClone) {
+ if (this.cachedFragment === null) {
+ fragment = this.build(dom);
+ if (this.hasRendered) {
+ this.cachedFragment = fragment;
+ } else {
+ this.hasRendered = true;
+ }
+ }
+ if (this.cachedFragment) {
+ fragment = dom.cloneNode(this.cachedFragment, true);
+ }
+ } else {
+ fragment = this.build(dom);
+ }
+ if (this.cachedFragment) { dom.repairClonedNode(fragment,[0,1]); }
+ var morph0 = dom.createMorphAt(fragment,0,1,contextualElement);
+ inline(env, morph0, context, "view", [get(env, context, "view.groupView")], {"content": get(env, context, "group.content"), "label": get(env, context, "group.label")});
+ return fragment;
+ }
+ };
+ }());
+ return {
+ isHTMLBars: true,
+ blockParams: 0,
+ cachedFragment: null,
+ hasRendered: false,
+ build: function build(dom) {
+ var el0 = dom.createDocumentFragment();
+ var el1 = dom.createTextNode("");
+ dom.appendChild(el0, el1);
+ var el1 = dom.createTextNode("");
+ dom.appendChild(el0, el1);
+ return el0;
+ },
+ render: function render(context, env, contextualElement) {
+ var dom = env.dom;
+ var hooks = env.hooks, get = hooks.get, block = hooks.block;
+ dom.detectNamespace(contextualElement);
+ var fragment;
+ if (env.useFragmentCache && dom.canClone) {
+ if (this.cachedFragment === null) {
+ fragment = this.build(dom);
+ if (this.hasRendered) {
+ this.cachedFragment = fragment;
+ } else {
+ this.hasRendered = true;
+ }
+ }
+ if (this.cachedFragment) {
+ fragment = dom.cloneNode(this.cachedFragment, true);
+ }
+ } else {
+ fragment = this.build(dom);
+ }
+ if (this.cachedFragment) { dom.repairClonedNode(fragment,[0,1]); }
+ var morph0 = dom.createMorphAt(fragment,0,1,contextualElement);
+ block(env, morph0, context, "each", [get(env, context, "view.groupedContent")], {"keyword": "group"}, child0, null);
+ return fragment;
+ }
+ };
+ }());
+ var child2 = (function() {
+ var child0 = (function() {
+ return {
+ isHTMLBars: true,
+ blockParams: 0,
+ cachedFragment: null,
+ hasRendered: false,
+ build: function build(dom) {
+ var el0 = dom.createDocumentFragment();
+ var el1 = dom.createTextNode("");
+ dom.appendChild(el0, el1);
+ var el1 = dom.createTextNode("");
+ dom.appendChild(el0, el1);
+ return el0;
+ },
+ render: function render(context, env, contextualElement) {
+ var dom = env.dom;
+ var hooks = env.hooks, get = hooks.get, inline = hooks.inline;
+ dom.detectNamespace(contextualElement);
+ var fragment;
+ if (env.useFragmentCache && dom.canClone) {
+ if (this.cachedFragment === null) {
+ fragment = this.build(dom);
+ if (this.hasRendered) {
+ this.cachedFragment = fragment;
+ } else {
+ this.hasRendered = true;
+ }
+ }
+ if (this.cachedFragment) {
+ fragment = dom.cloneNode(this.cachedFragment, true);
+ }
+ } else {
+ fragment = this.build(dom);
+ }
+ if (this.cachedFragment) { dom.repairClonedNode(fragment,[0,1]); }
+ var morph0 = dom.createMorphAt(fragment,0,1,contextualElement);
+ inline(env, morph0, context, "view", [get(env, context, "view.optionView")], {"content": get(env, context, "item")});
+ return fragment;
+ }
+ };
+ }());
+ return {
+ isHTMLBars: true,
+ blockParams: 0,
+ cachedFragment: null,
+ hasRendered: false,
+ build: function build(dom) {
+ var el0 = dom.createDocumentFragment();
+ var el1 = dom.createTextNode("");
+ dom.appendChild(el0, el1);
+ var el1 = dom.createTextNode("");
+ dom.appendChild(el0, el1);
+ return el0;
+ },
+ render: function render(context, env, contextualElement) {
+ var dom = env.dom;
+ var hooks = env.hooks, get = hooks.get, block = hooks.block;
+ dom.detectNamespace(contextualElement);
+ var fragment;
+ if (env.useFragmentCache && dom.canClone) {
+ if (this.cachedFragment === null) {
+ fragment = this.build(dom);
+ if (this.hasRendered) {
+ this.cachedFragment = fragment;
+ } else {
+ this.hasRendered = true;
+ }
+ }
+ if (this.cachedFragment) {
+ fragment = dom.cloneNode(this.cachedFragment, true);
+ }
+ } else {
+ fragment = this.build(dom);
+ }
+ if (this.cachedFragment) { dom.repairClonedNode(fragment,[0,1]); }
+ var morph0 = dom.createMorphAt(fragment,0,1,contextualElement);
+ block(env, morph0, context, "each", [get(env, context, "view.content")], {"keyword": "item"}, child0, null);
+ return fragment;
+ }
+ };
+ }());
+ return {
+ isHTMLBars: true,
+ blockParams: 0,
+ cachedFragment: null,
+ hasRendered: false,
+ build: function build(dom) {
+ var el0 = dom.createDocumentFragment();
+ var el1 = dom.createTextNode("");
+ dom.appendChild(el0, el1);
+ var el1 = dom.createTextNode("");
+ dom.appendChild(el0, el1);
+ var el1 = dom.createTextNode("\n");
+ dom.appendChild(el0, el1);
+ return el0;
+ },
+ render: function render(context, env, contextualElement) {
+ var dom = env.dom;
+ var hooks = env.hooks, get = hooks.get, block = hooks.block;
+ dom.detectNamespace(contextualElement);
+ var fragment;
+ if (env.useFragmentCache && dom.canClone) {
+ if (this.cachedFragment === null) {
+ fragment = this.build(dom);
+ if (this.hasRendered) {
+ this.cachedFragment = fragment;
+ } else {
+ this.hasRendered = true;
+ }
+ }
+ if (this.cachedFragment) {
+ fragment = dom.cloneNode(this.cachedFragment, true);
+ }
+ } else {
+ fragment = this.build(dom);
+ }
+ if (this.cachedFragment) { dom.repairClonedNode(fragment,[0,1]); }
+ var morph0 = dom.createMorphAt(fragment,0,1,contextualElement);
+ var morph1 = dom.createMorphAt(fragment,1,2,contextualElement);
+ block(env, morph0, context, "if", [get(env, context, "view.prompt")], {}, child0, null);
+ block(env, morph1, context, "if", [get(env, context, "view.optionGroupPath")], {}, child1, child2);
+ return fragment;
+ }
+ };
+ }());
+ __exports__["default"] = template(t);
+ });
+enifed("ember-htmlbars/utils/string",
+ ["htmlbars-util","ember-runtime/system/string","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ // required so we can extend this object.
+ var SafeString = __dependency1__.SafeString;
+ var escapeExpression = __dependency1__.escapeExpression;
+ var EmberStringUtils = __dependency2__["default"];
+
+ /**
+ 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.
+
+ ```javascript
+ Ember.String.htmlSafe('
someString
')
+ ```
+
+ @method htmlSafe
+ @for Ember.String
+ @static
+ @return {Handlebars.SafeString} a string that will not be html escaped by Handlebars
+ */
+ function htmlSafe(str) {
+ if (str === null || str === undefined) {
+ return "";
+ }
+
+ if (typeof str !== 'string') {
+ str = ''+str;
+ }
+ return new SafeString(str);
+ }
+
+ EmberStringUtils.htmlSafe = htmlSafe;
+ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) {
+
+ /**
+ Mark a string as being safe for unescaped output with Handlebars.
+
+ ```javascript
+ '
someString
'.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
+ */
+ String.prototype.htmlSafe = function() {
+ return htmlSafe(this);
+ };
+ }
+
+ __exports__.SafeString = SafeString;
+ __exports__.htmlSafe = htmlSafe;
+ __exports__.escapeExpression = escapeExpression;
+ });
+enifed("ember-metal-views",
+ ["ember-metal-views/renderer","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var Renderer = __dependency1__["default"];
+ __exports__.Renderer = Renderer;
+ });
+enifed("ember-metal-views/renderer",
+ ["morph","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var DOMHelper = __dependency1__.DOMHelper;
+
+ function Renderer() {
+ this._uuid = 0;
+ this._views = new Array(2000);
+ this._queue = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
+ this._parents = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
+ this._elements = new Array(17);
+ this._inserts = {};
+ this._dom = new DOMHelper();
+ }
+
+ function Renderer_renderTree(_view, _parentView, _insertAt) {
+ var views = this._views;
+ views[0] = _view;
+ var insertAt = _insertAt === undefined ? -1 : _insertAt;
+ var index = 0;
+ var total = 1;
+ var levelBase = _parentView ? _parentView._level+1 : 0;
+
+ var root = _parentView == null ? _view : _parentView._root;
+
+ // if root view has a _morph assigned
+ var willInsert = !!root._morph;
+
+ var queue = this._queue;
+ queue[0] = 0;
+ var length = 1;
+
+ var parentIndex = -1;
+ var parents = this._parents;
+ var parent = _parentView || null;
+ var elements = this._elements;
+ var element = null;
+ var contextualElement = null;
+ var level = 0;
+
+ var view = _view;
+ var children, i, child;
+ while (length) {
+ elements[level] = element;
+ if (!view._morph) {
+ // ensure props we add are in same order
+ view._morph = null;
+ }
+ view._root = root;
+ this.uuid(view);
+ view._level = levelBase + level;
+ if (view._elementCreated) {
+ this.remove(view, false, true);
+ }
+
+ this.willCreateElement(view);
+
+ contextualElement = view._morph && view._morph.contextualElement;
+ if (!contextualElement && parent && parent._childViewsMorph) {
+ contextualElement = parent._childViewsMorph.contextualElement;
+ }
+ if (!contextualElement && view._didCreateElementWithoutMorph) {
+ // This code path is only used by createElement and rerender when createElement
+ // was previously called on a view.
+ contextualElement = document.body;
+ }
+ element = this.createElement(view, contextualElement);
+
+ parents[level++] = parentIndex;
+ parentIndex = index;
+ parent = view;
+
+ // enqueue for end
+ queue[length++] = index;
+ // enqueue children
+ children = this.childViews(view);
+ if (children) {
+ for (i=children.length-1;i>=0;i--) {
+ child = children[i];
+ index = total++;
+ views[index] = child;
+ queue[length++] = index;
+ view = child;
+ }
+ }
+
+ index = queue[--length];
+ view = views[index];
+
+ while (parentIndex === index) {
+ level--;
+ view._elementCreated = true;
+ this.didCreateElement(view);
+ if (willInsert) {
+ this.willInsertElement(view);
+ }
+
+ if (level === 0) {
+ length--;
+ break;
+ }
+
+ parentIndex = parents[level];
+ parent = parentIndex === -1 ? _parentView : views[parentIndex];
+ this.insertElement(view, parent, element, -1);
+ index = queue[--length];
+ view = views[index];
+ element = elements[level];
+ elements[level] = null;
+ }
+ }
+
+ this.insertElement(view, _parentView, element, insertAt);
+
+ for (i=total-1; i>=0; i--) {
+ if (willInsert) {
+ views[i]._elementInserted = true;
+ this.didInsertElement(views[i]);
+ }
+ views[i] = null;
+ }
+
+ return element;
+ }
+
+ Renderer.prototype.uuid = function Renderer_uuid(view) {
+ if (view._uuid === undefined) {
+ view._uuid = ++this._uuid;
+ view._renderer = this;
+ } // else assert(view._renderer === this)
+ return view._uuid;
+ };
+
+ Renderer.prototype.scheduleInsert =
+ function Renderer_scheduleInsert(view, morph) {
+ if (view._morph || view._elementCreated) {
+ throw new Error("You cannot insert a View that has already been rendered");
+ }
+ Ember.assert("You cannot insert a View without a morph", morph);
+ view._morph = morph;
+ var viewId = this.uuid(view);
+ this._inserts[viewId] = this.scheduleRender(this, function scheduledRenderTree() {
+ this._inserts[viewId] = null;
+ this.renderTree(view);
+ });
+ };
+
+ Renderer.prototype.appendTo =
+ function Renderer_appendTo(view, target) {
+ var morph = this._dom.appendMorph(target);
+ this.scheduleInsert(view, morph);
+ };
+
+ Renderer.prototype.replaceIn =
+ function Renderer_replaceIn(view, target) {
+ var morph = this._dom.createMorph(target, null, null);
+ this.scheduleInsert(view, morph);
+ };
+
+ function Renderer_remove(_view, shouldDestroy, reset) {
+ var viewId = this.uuid(_view);
+
+ if (this._inserts[viewId]) {
+ this.cancelRender(this._inserts[viewId]);
+ this._inserts[viewId] = undefined;
+ }
+
+ if (!_view._elementCreated) {
+ return;
+ }
+
+ var removeQueue = [];
+ var destroyQueue = [];
+ var morph = _view._morph;
+ var idx, len, view, queue, childViews, i, l;
+
+ removeQueue.push(_view);
+
+ for (idx=0; idx -1;
+ };
+
+ var defineNativeShim = function(nativeFunc, shim) {
+ if (isNativeFunc(nativeFunc)) {
+ return nativeFunc;
+ }
+ return shim;
+ };
+
+ // From: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/map
+ var map = defineNativeShim(ArrayPrototype.map, function(fun /*, thisp */) {
+ //"use strict";
+
+ if (this === void 0 || this === null || typeof fun !== "function") {
+ throw new TypeError();
+ }
+
+ var t = Object(this);
+ var len = t.length >>> 0;
+ var res = new Array(len);
+ var thisp = arguments[1];
+
+ for (var i = 0; i < len; i++) {
+ if (i in t) {
+ res[i] = fun.call(thisp, t[i], i, t);
+ }
+ }
+
+ return res;
+ });
+
+ // From: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/foreach
+ var forEach = defineNativeShim(ArrayPrototype.forEach, function(fun /*, thisp */) {
+ //"use strict";
+
+ if (this === void 0 || this === null || typeof fun !== "function") {
+ throw new TypeError();
+ }
+
+ var t = Object(this);
+ var len = t.length >>> 0;
+ var thisp = arguments[1];
+
+ for (var i = 0; i < len; i++) {
+ if (i in t) {
+ fun.call(thisp, t[i], i, t);
+ }
+ }
+ });
+
+ var indexOf = defineNativeShim(ArrayPrototype.indexOf, function (obj, fromIndex) {
+ if (fromIndex === null || fromIndex === undefined) {
+ fromIndex = 0;
+ }
+ else if (fromIndex < 0) {
+ fromIndex = Math.max(0, this.length + fromIndex);
+ }
+
+ for (var i = fromIndex, j = this.length; i < j; i++) {
+ if (this[i] === obj) {
+ return i;
+ }
+ }
+ return -1;
+ });
+
+ var lastIndexOf = defineNativeShim(ArrayPrototype.lastIndexOf, function(obj, fromIndex) {
+ var len = this.length;
+ var idx;
+
+ if (fromIndex === undefined) fromIndex = len-1;
+ else fromIndex = (fromIndex < 0) ? Math.ceil(fromIndex) : Math.floor(fromIndex);
+ if (fromIndex < 0) fromIndex += len;
+
+ for(idx = fromIndex;idx>=0;idx--) {
+ if (this[idx] === obj) return idx ;
+ }
+ return -1;
+ });
+
+ var filter = defineNativeShim(ArrayPrototype.filter, function (fn, context) {
+ var i, value;
+ var result = [];
+ var length = this.length;
+
+ for (i = 0; i < length; i++) {
+ if (this.hasOwnProperty(i)) {
+ value = this[i];
+ if (fn.call(context, value, i, this)) {
+ result.push(value);
+ }
+ }
+ }
+ return result;
+ });
+
+ if (Ember.SHIM_ES5) {
+ ArrayPrototype.map = ArrayPrototype.map || map;
+ ArrayPrototype.forEach = ArrayPrototype.forEach || forEach;
+ ArrayPrototype.filter = ArrayPrototype.filter || filter;
+ ArrayPrototype.indexOf = ArrayPrototype.indexOf || indexOf;
+ ArrayPrototype.lastIndexOf = ArrayPrototype.lastIndexOf || lastIndexOf;
+ }
+
+ /**
+ Array polyfills to support ES5 features in older browsers.
+
+ @namespace Ember
+ @property ArrayPolyfills
+ */
+ __exports__.map = map;
+ __exports__.forEach = forEach;
+ __exports__.filter = filter;
+ __exports__.indexOf = indexOf;
+ __exports__.lastIndexOf = lastIndexOf;
+ });
+enifed("ember-metal/binding",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/observer","ember-metal/run_loop","ember-metal/path_cache","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // Ember.Logger, Ember.LOG_BINDINGS, assert
+ var get = __dependency2__.get;
+ var trySet = __dependency3__.trySet;
+ var guidFor = __dependency4__.guidFor;
+ var addObserver = __dependency5__.addObserver;
+ var removeObserver = __dependency5__.removeObserver;
+ var _suspendObserver = __dependency5__._suspendObserver;
+ var run = __dependency6__["default"];
+ var isGlobalPath = __dependency7__.isGlobal;
+
+
+ // ES6TODO: where is Ember.lookup defined?
+ /**
+ @module ember-metal
+ */
+
+ // ..........................................................
+ // CONSTANTS
+ //
+
+ /**
+ Debug parameter you can turn on. This will log all bindings that fire to
+ the console. This should be disabled in production code. Note that you
+ can also enable this from the console or temporarily.
+
+ @property LOG_BINDINGS
+ @for Ember
+ @type Boolean
+ @default false
+ */
+ Ember.LOG_BINDINGS = false || !!Ember.ENV.LOG_BINDINGS;
+
+ /**
+ Returns true if the provided path is global (e.g., `MyApp.fooController.bar`)
+ instead of local (`foo.bar.baz`).
+
+ @method isGlobalPath
+ @for Ember
+ @private
+ @param {String} path
+ @return Boolean
+ */
+
+ function getWithGlobals(obj, path) {
+ return get(isGlobalPath(path) ? Ember.lookup : obj, path);
+ }
+
+ // ..........................................................
+ // BINDING
+ //
+
+ function Binding(toPath, fromPath) {
+ this._direction = undefined;
+ this._from = fromPath;
+ this._to = toPath;
+ this._readyToSync = undefined;
+ this._oneWay = undefined;
+ }
+
+ /**
+ @class Binding
+ @namespace Ember
+ */
+
+ Binding.prototype = {
+ /**
+ This copies the Binding so it can be connected to another object.
+
+ @method copy
+ @return {Ember.Binding} `this`
+ */
+ copy: function () {
+ var copy = new Binding(this._to, this._from);
+ if (this._oneWay) { copy._oneWay = true; }
+ return copy;
+ },
+
+ // ..........................................................
+ // CONFIG
+ //
+
+ /**
+ This will set `from` property path to the specified value. It will not
+ attempt to resolve this property path to an actual object until you
+ connect the binding.
+
+ The binding will search for the property path starting at the root object
+ you pass when you `connect()` the binding. It follows the same rules as
+ `get()` - see that method for more information.
+
+ @method from
+ @param {String} path the property path to connect to
+ @return {Ember.Binding} `this`
+ */
+ from: function(path) {
+ this._from = path;
+ return this;
+ },
+
+ /**
+ This will set the `to` property path to the specified value. It will not
+ attempt to resolve this property path to an actual object until you
+ connect the binding.
+
+ The binding will search for the property path starting at the root object
+ you pass when you `connect()` the binding. It follows the same rules as
+ `get()` - see that method for more information.
+
+ @method to
+ @param {String|Tuple} path A property path or tuple
+ @return {Ember.Binding} `this`
+ */
+ to: function(path) {
+ this._to = path;
+ return this;
+ },
+
+ /**
+ Configures the binding as one way. A one-way binding will relay changes
+ on the `from` side to the `to` side, but not the other way around. This
+ means that if you change the `to` side directly, the `from` side may have
+ a different value.
+
+ @method oneWay
+ @return {Ember.Binding} `this`
+ */
+ oneWay: function() {
+ this._oneWay = true;
+ return this;
+ },
+
+ /**
+ @method toString
+ @return {String} string representation of binding
+ */
+ toString: function() {
+ var oneWay = this._oneWay ? '[oneWay]' : '';
+ return "Ember.Binding<" + guidFor(this) + ">(" + this._from + " -> " + this._to + ")" + oneWay;
+ },
+
+ // ..........................................................
+ // CONNECT AND SYNC
+ //
+
+ /**
+ Attempts to connect this binding instance so that it can receive and relay
+ changes. This method will raise an exception if you have not set the
+ from/to properties yet.
+
+ @method connect
+ @param {Object} obj The root object for this binding.
+ @return {Ember.Binding} `this`
+ */
+ connect: function(obj) {
+ Ember.assert('Must pass a valid object to Ember.Binding.connect()', !!obj);
+
+ var fromPath = this._from;
+ var toPath = this._to;
+ trySet(obj, toPath, getWithGlobals(obj, fromPath));
+
+ // add an observer on the object to be notified when the binding should be updated
+ addObserver(obj, fromPath, this, this.fromDidChange);
+
+ // if the binding is a two-way binding, also set up an observer on the target
+ if (!this._oneWay) {
+ addObserver(obj, toPath, this, this.toDidChange);
+ }
+
+ this._readyToSync = true;
+
+ return this;
+ },
+
+ /**
+ Disconnects the binding instance. Changes will no longer be relayed. You
+ will not usually need to call this method.
+
+ @method disconnect
+ @param {Object} obj The root object you passed when connecting the binding.
+ @return {Ember.Binding} `this`
+ */
+ disconnect: function(obj) {
+ Ember.assert('Must pass a valid object to Ember.Binding.disconnect()', !!obj);
+
+ var twoWay = !this._oneWay;
+
+ // remove an observer on the object so we're no longer notified of
+ // changes that should update bindings.
+ removeObserver(obj, this._from, this, this.fromDidChange);
+
+ // if the binding is two-way, remove the observer from the target as well
+ if (twoWay) {
+ removeObserver(obj, this._to, this, this.toDidChange);
+ }
+
+ this._readyToSync = false; // disable scheduled syncs...
+ return this;
+ },
+
+ // ..........................................................
+ // PRIVATE
+ //
+
+ /* called when the from side changes */
+ fromDidChange: function(target) {
+ this._scheduleSync(target, 'fwd');
+ },
+
+ /* called when the to side changes */
+ toDidChange: function(target) {
+ this._scheduleSync(target, 'back');
+ },
+
+ _scheduleSync: function(obj, dir) {
+ var existingDir = this._direction;
+
+ // if we haven't scheduled the binding yet, schedule it
+ if (existingDir === undefined) {
+ run.schedule('sync', this, this._sync, obj);
+ this._direction = dir;
+ }
+
+ // If both a 'back' and 'fwd' sync have been scheduled on the same object,
+ // default to a 'fwd' sync so that it remains deterministic.
+ if (existingDir === 'back' && dir === 'fwd') {
+ this._direction = 'fwd';
+ }
+ },
+
+ _sync: function(obj) {
+ var log = Ember.LOG_BINDINGS;
+
+ // don't synchronize destroyed objects or disconnected bindings
+ if (obj.isDestroyed || !this._readyToSync) { return; }
+
+ // get the direction of the binding for the object we are
+ // synchronizing from
+ var direction = this._direction;
+
+ var fromPath = this._from;
+ var toPath = this._to;
+
+ this._direction = undefined;
+
+ // if we're synchronizing from the remote object...
+ if (direction === 'fwd') {
+ var fromValue = getWithGlobals(obj, this._from);
+ if (log) {
+ Ember.Logger.log(' ', this.toString(), '->', fromValue, obj);
+ }
+ if (this._oneWay) {
+ trySet(obj, toPath, fromValue);
+ } else {
+ _suspendObserver(obj, toPath, this, this.toDidChange, function () {
+ trySet(obj, toPath, fromValue);
+ });
+ }
+ // if we're synchronizing *to* the remote object
+ } else if (direction === 'back') {
+ var toValue = get(obj, this._to);
+ if (log) {
+ Ember.Logger.log(' ', this.toString(), '<-', toValue, obj);
+ }
+ _suspendObserver(obj, fromPath, this, this.fromDidChange, function () {
+ trySet(isGlobalPath(fromPath) ? Ember.lookup : obj, fromPath, toValue);
+ });
+ }
+ }
+
+ };
+
+ function mixinProperties(to, from) {
+ for (var key in from) {
+ if (from.hasOwnProperty(key)) {
+ to[key] = from[key];
+ }
+ }
+ }
+
+ mixinProperties(Binding, {
+
+ /*
+ See `Ember.Binding.from`.
+
+ @method from
+ @static
+ */
+ from: function(from) {
+ var C = this;
+ return new C(undefined, from);
+ },
+
+ /*
+ See `Ember.Binding.to`.
+
+ @method to
+ @static
+ */
+ to: function(to) {
+ var C = this;
+ return new C(to, undefined);
+ },
+
+ /**
+ Creates a new Binding instance and makes it apply in a single direction.
+ A one-way binding will relay changes on the `from` side object (supplied
+ as the `from` argument) the `to` side, but not the other way around.
+ This means that if you change the "to" side directly, the "from" side may have
+ a different value.
+
+ See `Binding.oneWay`.
+
+ @method oneWay
+ @param {String} from from path.
+ @param {Boolean} [flag] (Optional) passing nothing here will make the
+ binding `oneWay`. You can instead pass `false` to disable `oneWay`, making the
+ binding two way again.
+ @return {Ember.Binding} `this`
+ */
+ oneWay: function(from, flag) {
+ var C = this;
+ return new C(undefined, from).oneWay(flag);
+ }
+
+ });
+ /**
+ An `Ember.Binding` connects the properties of two objects so that whenever
+ the value of one property changes, the other property will be changed also.
+
+ ## Automatic Creation of Bindings with `/^*Binding/`-named Properties
+
+ You do not usually create Binding objects directly but instead describe
+ bindings in your class or object definition using automatic binding
+ detection.
+
+ Properties ending in a `Binding` suffix will be converted to `Ember.Binding`
+ instances. The value of this property should be a string representing a path
+ to another object or a custom binding instance created using Binding helpers
+ (see "One Way Bindings"):
+
+ ```
+ valueBinding: "MyApp.someController.title"
+ ```
+
+ This will create a binding from `MyApp.someController.title` to the `value`
+ property of your object instance automatically. Now the two values will be
+ kept in sync.
+
+ ## One Way Bindings
+
+ One especially useful binding customization you can use is the `oneWay()`
+ helper. This helper tells Ember that you are only interested in
+ receiving changes on the object you are binding from. For example, if you
+ are binding to a preference and you want to be notified if the preference
+ has changed, but your object will not be changing the preference itself, you
+ could do:
+
+ ```
+ bigTitlesBinding: Ember.Binding.oneWay("MyApp.preferencesController.bigTitles")
+ ```
+
+ This way if the value of `MyApp.preferencesController.bigTitles` changes the
+ `bigTitles` property of your object will change also. However, if you
+ change the value of your `bigTitles` property, it will not update the
+ `preferencesController`.
+
+ One way bindings are almost twice as fast to setup and twice as fast to
+ execute because the binding only has to worry about changes to one side.
+
+ You should consider using one way bindings anytime you have an object that
+ may be created frequently and you do not intend to change a property; only
+ to monitor it for changes (such as in the example above).
+
+ ## Adding Bindings Manually
+
+ All of the examples above show you how to configure a custom binding, but the
+ result of these customizations will be a binding template, not a fully active
+ Binding instance. The binding will actually become active only when you
+ instantiate the object the binding belongs to. It is useful however, to
+ understand what actually happens when the binding is activated.
+
+ For a binding to function it must have at least a `from` property and a `to`
+ property. The `from` property path points to the object/key that you want to
+ bind from while the `to` path points to the object/key you want to bind to.
+
+ When you define a custom binding, you are usually describing the property
+ you want to bind from (such as `MyApp.someController.value` in the examples
+ above). When your object is created, it will automatically assign the value
+ you want to bind `to` based on the name of your binding key. In the
+ examples above, during init, Ember objects will effectively call
+ something like this on your binding:
+
+ ```javascript
+ binding = Ember.Binding.from("valueBinding").to("value");
+ ```
+
+ This creates a new binding instance based on the template you provide, and
+ sets the to path to the `value` property of the new object. Now that the
+ binding is fully configured with a `from` and a `to`, it simply needs to be
+ connected to become active. This is done through the `connect()` method:
+
+ ```javascript
+ binding.connect(this);
+ ```
+
+ Note that when you connect a binding you pass the object you want it to be
+ connected to. This object will be used as the root for both the from and
+ to side of the binding when inspecting relative paths. This allows the
+ binding to be automatically inherited by subclassed objects as well.
+
+ This also allows you to bind between objects using the paths you declare in
+ `from` and `to`:
+
+ ```javascript
+ // Example 1
+ binding = Ember.Binding.from("App.someObject.value").to("value");
+ binding.connect(this);
+
+ // Example 2
+ binding = Ember.Binding.from("parentView.value").to("App.someObject.value");
+ binding.connect(this);
+ ```
+
+ Now that the binding is connected, it will observe both the from and to side
+ and relay changes.
+
+ If you ever needed to do so (you almost never will, but it is useful to
+ understand this anyway), you could manually create an active binding by
+ using the `Ember.bind()` helper method. (This is the same method used by
+ to setup your bindings on objects):
+
+ ```javascript
+ Ember.bind(MyApp.anotherObject, "value", "MyApp.someController.value");
+ ```
+
+ Both of these code fragments have the same effect as doing the most friendly
+ form of binding creation like so:
+
+ ```javascript
+ MyApp.anotherObject = Ember.Object.create({
+ valueBinding: "MyApp.someController.value",
+
+ // OTHER CODE FOR THIS OBJECT...
+ });
+ ```
+
+ Ember's built in binding creation method makes it easy to automatically
+ create bindings for you. You should always use the highest-level APIs
+ available, even if you understand how it works underneath.
+
+ @class Binding
+ @namespace Ember
+ @since Ember 0.9
+ */
+ // Ember.Binding = Binding; ES6TODO: where to put this?
+
+
+ /**
+ Global helper method to create a new binding. Just pass the root object
+ along with a `to` and `from` path to create and connect the binding.
+
+ @method bind
+ @for Ember
+ @param {Object} obj The root object of the transform.
+ @param {String} to The path to the 'to' side of the binding.
+ Must be relative to obj.
+ @param {String} from The path to the 'from' side of the binding.
+ Must be relative to obj or a global path.
+ @return {Ember.Binding} binding instance
+ */
+ function bind(obj, to, from) {
+ return new Binding(to, from).connect(obj);
+ }
+
+ __exports__.bind = bind;/**
+ @method oneWay
+ @for Ember
+ @param {Object} obj The root object of the transform.
+ @param {String} to The path to the 'to' side of the binding.
+ Must be relative to obj.
+ @param {String} from The path to the 'from' side of the binding.
+ Must be relative to obj or a global path.
+ @return {Ember.Binding} binding instance
+ */
+ function oneWay(obj, to, from) {
+ return new Binding(to, from).oneWay().connect(obj);
+ }
+
+ __exports__.oneWay = oneWay;__exports__.Binding = Binding;
+ __exports__.isGlobalPath = isGlobalPath;
+ });
+enifed("ember-metal/cache",
+ ["ember-metal/dictionary","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var dictionary = __dependency1__["default"];
+ __exports__["default"] = Cache;
+
+ function Cache(limit, func) {
+ this.store = dictionary(null);
+ this.size = 0;
+ this.misses = 0;
+ this.hits = 0;
+ this.limit = limit;
+ this.func = func;
+ }
+
+ var UNDEFINED = function() { };
+
+ Cache.prototype = {
+ set: function(key, value) {
+ if (this.limit > this.size) {
+ this.size ++;
+ if (value === undefined) {
+ this.store[key] = UNDEFINED;
+ } else {
+ this.store[key] = value;
+ }
+ }
+
+ return value;
+ },
+
+ get: function(key) {
+ var value = this.store[key];
+
+ if (value === undefined) {
+ this.misses ++;
+ value = this.set(key, this.func(key));
+ } else if (value === UNDEFINED) {
+ this.hits ++;
+ value = undefined;
+ } else {
+ this.hits ++;
+ // nothing to translate
+ }
+
+ return value;
+ },
+
+ purge: function() {
+ this.store = dictionary(null);
+ this.size = 0;
+ this.hits = 0;
+ this.misses = 0;
+ }
+ };
+ });
+enifed("ember-metal/chains",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/array","ember-metal/watch_key","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // warn, assert, etc;
+ var get = __dependency2__.get;
+ var normalizeTuple = __dependency2__.normalizeTuple;
+ var metaFor = __dependency3__.meta;
+ var forEach = __dependency4__.forEach;
+ var watchKey = __dependency5__.watchKey;
+ var unwatchKey = __dependency5__.unwatchKey;
+
+ var warn = Ember.warn;
+ var FIRST_KEY = /^([^\.]+)/;
+
+ function firstKey(path) {
+ return path.match(FIRST_KEY)[0];
+ }
+
+ var pendingQueue = [];
+
+ // attempts to add the pendingQueue chains again. If some of them end up
+ // back in the queue and reschedule is true, schedules a timeout to try
+ // again.
+ function flushPendingChains() {
+ if (pendingQueue.length === 0) { return; } // nothing to do
+
+ var queue = pendingQueue;
+ pendingQueue = [];
+
+ forEach.call(queue, function(q) {
+ q[0].add(q[1]);
+ });
+
+ warn('Watching an undefined global, Ember expects watched globals to be' +
+ ' setup by the time the run loop is flushed, check for typos', pendingQueue.length === 0);
+ }
+
+ __exports__.flushPendingChains = flushPendingChains;function addChainWatcher(obj, keyName, node) {
+ if (!obj || ('object' !== typeof obj)) { return; } // nothing to do
+
+ var m = metaFor(obj);
+ var nodes = m.chainWatchers;
+
+ if (!m.hasOwnProperty('chainWatchers')) {
+ nodes = m.chainWatchers = {};
+ }
+
+ if (!nodes[keyName]) {
+ nodes[keyName] = [];
+ }
+ nodes[keyName].push(node);
+ watchKey(obj, keyName, m);
+ }
+
+ function removeChainWatcher(obj, keyName, node) {
+ if (!obj || 'object' !== typeof obj) { return; } // nothing to do
+
+ var m = obj['__ember_meta__'];
+ if (m && !m.hasOwnProperty('chainWatchers')) { return; } // nothing to do
+
+ var nodes = m && m.chainWatchers;
+
+ if (nodes && nodes[keyName]) {
+ nodes = nodes[keyName];
+ for (var i = 0, l = nodes.length; i < l; i++) {
+ if (nodes[i] === node) {
+ nodes.splice(i, 1);
+ break;
+ }
+ }
+ }
+ unwatchKey(obj, keyName, m);
+ }
+
+ // A ChainNode watches a single key on an object. If you provide a starting
+ // value for the key then the node won't actually watch it. For a root node
+ // pass null for parent and key and object for value.
+ function ChainNode(parent, key, value) {
+ this._parent = parent;
+ this._key = key;
+
+ // _watching is true when calling get(this._parent, this._key) will
+ // return the value of this node.
+ //
+ // It is false for the root of a chain (because we have no parent)
+ // and for global paths (because the parent node is the object with
+ // the observer on it)
+ this._watching = value===undefined;
+
+ this._value = value;
+ this._paths = {};
+ if (this._watching) {
+ this._object = parent.value();
+ if (this._object) {
+ addChainWatcher(this._object, this._key, this);
+ }
+ }
+
+ // Special-case: the EachProxy relies on immediate evaluation to
+ // establish its observers.
+ //
+ // TODO: Replace this with an efficient callback that the EachProxy
+ // can implement.
+ if (this._parent && this._parent._key === '@each') {
+ this.value();
+ }
+ }
+
+ var ChainNodePrototype = ChainNode.prototype;
+
+ function lazyGet(obj, key) {
+ if (!obj) return undefined;
+
+ var meta = obj['__ember_meta__'];
+ // check if object meant only to be a prototype
+ if (meta && meta.proto === obj) {
+ return undefined;
+ }
+
+ if (key === "@each") {
+ return get(obj, key);
+ }
+
+ // if a CP only return cached value
+ var desc = meta && meta.descs[key];
+ if (desc && desc._cacheable) {
+ if (key in meta.cache) {
+ return meta.cache[key];
+ } else {
+ return undefined;
+ }
+ }
+
+ return get(obj, key);
+ }
+
+ ChainNodePrototype.value = function() {
+ if (this._value === undefined && this._watching) {
+ var obj = this._parent.value();
+ this._value = lazyGet(obj, this._key);
+ }
+ return this._value;
+ };
+
+ ChainNodePrototype.destroy = function() {
+ if (this._watching) {
+ var obj = this._object;
+ if (obj) {
+ removeChainWatcher(obj, this._key, this);
+ }
+ this._watching = false; // so future calls do nothing
+ }
+ };
+
+ // copies a top level object only
+ ChainNodePrototype.copy = function(obj) {
+ var ret = new ChainNode(null, null, obj);
+ var paths = this._paths;
+ var path;
+
+ for (path in paths) {
+ // this check will also catch non-number vals.
+ if (paths[path] <= 0) {
+ continue;
+ }
+ ret.add(path);
+ }
+ return ret;
+ };
+
+ // called on the root node of a chain to setup watchers on the specified
+ // path.
+ ChainNodePrototype.add = function(path) {
+ var obj, tuple, key, src, paths;
+
+ paths = this._paths;
+ paths[path] = (paths[path] || 0) + 1;
+
+ obj = this.value();
+ tuple = normalizeTuple(obj, path);
+
+ // the path was a local path
+ if (tuple[0] && tuple[0] === obj) {
+ path = tuple[1];
+ key = firstKey(path);
+ path = path.slice(key.length+1);
+
+ // global path, but object does not exist yet.
+ // put into a queue and try to connect later.
+ } else if (!tuple[0]) {
+ pendingQueue.push([this, path]);
+ tuple.length = 0;
+ return;
+
+ // global path, and object already exists
+ } else {
+ src = tuple[0];
+ key = path.slice(0, 0-(tuple[1].length+1));
+ path = tuple[1];
+ }
+
+ tuple.length = 0;
+ this.chain(key, path, src);
+ };
+
+ // called on the root node of a chain to teardown watcher on the specified
+ // path
+ ChainNodePrototype.remove = function(path) {
+ var obj, tuple, key, src, paths;
+
+ paths = this._paths;
+ if (paths[path] > 0) {
+ paths[path]--;
+ }
+
+ obj = this.value();
+ tuple = normalizeTuple(obj, path);
+ if (tuple[0] === obj) {
+ path = tuple[1];
+ key = firstKey(path);
+ path = path.slice(key.length+1);
+ } else {
+ src = tuple[0];
+ key = path.slice(0, 0-(tuple[1].length+1));
+ path = tuple[1];
+ }
+
+ tuple.length = 0;
+ this.unchain(key, path);
+ };
+
+ ChainNodePrototype.count = 0;
+
+ ChainNodePrototype.chain = function(key, path, src) {
+ var chains = this._chains;
+ var node;
+ if (!chains) {
+ chains = this._chains = {};
+ }
+
+ node = chains[key];
+ if (!node) {
+ node = chains[key] = new ChainNode(this, key, src);
+ }
+ node.count++; // count chains...
+
+ // chain rest of path if there is one
+ if (path) {
+ key = firstKey(path);
+ path = path.slice(key.length+1);
+ node.chain(key, path); // NOTE: no src means it will observe changes...
+ }
+ };
+
+ ChainNodePrototype.unchain = function(key, path) {
+ var chains = this._chains;
+ var node = chains[key];
+
+ // unchain rest of path first...
+ if (path && path.length > 1) {
+ var nextKey = firstKey(path);
+ var nextPath = path.slice(nextKey.length + 1);
+ node.unchain(nextKey, nextPath);
+ }
+
+ // delete node if needed.
+ node.count--;
+ if (node.count<=0) {
+ delete chains[node._key];
+ node.destroy();
+ }
+
+ };
+
+ ChainNodePrototype.willChange = function(events) {
+ var chains = this._chains;
+ if (chains) {
+ for(var key in chains) {
+ if (!chains.hasOwnProperty(key)) {
+ continue;
+ }
+ chains[key].willChange(events);
+ }
+ }
+
+ if (this._parent) {
+ this._parent.chainWillChange(this, this._key, 1, events);
+ }
+ };
+
+ ChainNodePrototype.chainWillChange = function(chain, path, depth, events) {
+ if (this._key) {
+ path = this._key + '.' + path;
+ }
+
+ if (this._parent) {
+ this._parent.chainWillChange(this, path, depth+1, events);
+ } else {
+ if (depth > 1) {
+ events.push(this.value(), path);
+ }
+ path = 'this.' + path;
+ if (this._paths[path] > 0) {
+ events.push(this.value(), path);
+ }
+ }
+ };
+
+ ChainNodePrototype.chainDidChange = function(chain, path, depth, events) {
+ if (this._key) {
+ path = this._key + '.' + path;
+ }
+
+ if (this._parent) {
+ this._parent.chainDidChange(this, path, depth+1, events);
+ } else {
+ if (depth > 1) {
+ events.push(this.value(), path);
+ }
+ path = 'this.' + path;
+ if (this._paths[path] > 0) {
+ events.push(this.value(), path);
+ }
+ }
+ };
+
+ ChainNodePrototype.didChange = function(events) {
+ // invalidate my own value first.
+ if (this._watching) {
+ var obj = this._parent.value();
+ if (obj !== this._object) {
+ removeChainWatcher(this._object, this._key, this);
+ this._object = obj;
+ addChainWatcher(obj, this._key, this);
+ }
+ this._value = undefined;
+
+ // Special-case: the EachProxy relies on immediate evaluation to
+ // establish its observers.
+ if (this._parent && this._parent._key === '@each') {
+ this.value();
+ }
+ }
+
+ // then notify chains...
+ var chains = this._chains;
+ if (chains) {
+ for(var key in chains) {
+ if (!chains.hasOwnProperty(key)) { continue; }
+ chains[key].didChange(events);
+ }
+ }
+
+ // if no events are passed in then we only care about the above wiring update
+ if (events === null) {
+ return;
+ }
+
+ // and finally tell parent about my path changing...
+ if (this._parent) {
+ this._parent.chainDidChange(this, this._key, 1, events);
+ }
+ };
+
+ function finishChains(obj) {
+ // We only create meta if we really have to
+ var m = obj['__ember_meta__'];
+ var chains, chainWatchers, chainNodes;
+
+ if (m) {
+ // finish any current chains node watchers that reference obj
+ chainWatchers = m.chainWatchers;
+ if (chainWatchers) {
+ for(var key in chainWatchers) {
+ if (!chainWatchers.hasOwnProperty(key)) {
+ continue;
+ }
+
+ chainNodes = chainWatchers[key];
+ if (chainNodes) {
+ for (var i=0,l=chainNodes.length;i 1) {
+ args = a_slice.call(arguments);
+ func = args.pop();
+ }
+
+ if (typeof func !== "function") {
+ throw new EmberError("Computed Property declared without a property function");
+ }
+
+ var cp = new ComputedProperty(func);
+
+ if (args) {
+ cp.property.apply(cp, args);
+ }
+
+ return cp;
+ }
+
+ /**
+ Returns the cached value for a property, if one exists.
+ This can be useful for peeking at the value of a computed
+ property that is generated lazily, without accidentally causing
+ it to be created.
+
+ @method cacheFor
+ @for Ember
+ @param {Object} obj the object whose property you want to check
+ @param {String} key the name of the property whose cached value you want
+ to return
+ @return {Object} the cached value
+ */
+ function cacheFor(obj, key) {
+ var meta = obj['__ember_meta__'];
+ var cache = meta && meta.cache;
+ var ret = cache && cache[key];
+
+ if (ret === UNDEFINED) {
+ return undefined;
+ }
+ return ret;
+ }
+
+ cacheFor.set = function(cache, key, value) {
+ if (value === undefined) {
+ cache[key] = UNDEFINED;
+ } else {
+ cache[key] = value;
+ }
+ };
+
+ cacheFor.get = function(cache, key) {
+ var ret = cache[key];
+ if (ret === UNDEFINED) {
+ return undefined;
+ }
+ return ret;
+ };
+
+ cacheFor.remove = function(cache, key) {
+ cache[key] = undefined;
+ };
+
+ __exports__.ComputedProperty = ComputedProperty;
+ __exports__.computed = computed;
+ __exports__.cacheFor = cacheFor;
+ });
+enifed("ember-metal/computed_macros",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/computed","ember-metal/is_empty","ember-metal/is_none","ember-metal/alias"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ var get = __dependency2__.get;
+ var set = __dependency3__.set;
+ var computed = __dependency4__.computed;
+ var isEmpty = __dependency5__["default"];
+ var isNone = __dependency6__["default"];
+ var alias = __dependency7__["default"];
+
+ /**
+ @module ember-metal
+ */
+
+ var a_slice = [].slice;
+
+ function getProperties(self, propertyNames) {
+ var ret = {};
+ for(var i = 0; i < propertyNames.length; i++) {
+ ret[propertyNames[i]] = get(self, propertyNames[i]);
+ }
+ return ret;
+ }
+
+ function registerComputed(name, macro) {
+ computed[name] = function(dependentKey) {
+ var args = a_slice.call(arguments);
+ return computed(dependentKey, function() {
+ return macro.apply(this, args);
+ });
+ };
+ }
+
+ function registerComputedWithProperties(name, macro) {
+ computed[name] = function() {
+ var properties = a_slice.call(arguments);
+
+ var computedFunc = computed(function() {
+ return macro.apply(this, [getProperties(this, properties)]);
+ });
+
+ return computedFunc.property.apply(computedFunc, properties);
+ };
+ }
+
+ /**
+ A computed property that returns true if the value of the dependent
+ property is null, an empty string, empty array, or empty function.
+
+ Example
+
+ ```javascript
+ var ToDoList = Ember.Object.extend({
+ isDone: Ember.computed.empty('todos')
+ });
+
+ var todoList = ToDoList.create({
+ todos: ['Unit Test', 'Documentation', 'Release']
+ });
+
+ todoList.get('isDone'); // false
+ todoList.get('todos').clear();
+ todoList.get('isDone'); // true
+ ```
+
+ @since 1.6.0
+ @method computed.empty
+ @for Ember
+ @param {String} dependentKey
+ @return {Ember.ComputedProperty} computed property which negate
+ the original value for property
+ */
+ computed.empty = function (dependentKey) {
+ return computed(dependentKey + '.length', function () {
+ return isEmpty(get(this, dependentKey));
+ });
+ };
+
+ /**
+ A computed property that returns true if the value of the dependent
+ property is NOT null, an empty string, empty array, or empty function.
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ hasStuff: Ember.computed.notEmpty('backpack')
+ });
+
+ var hamster = Hamster.create({ backpack: ['Food', 'Sleeping Bag', 'Tent'] });
+
+ hamster.get('hasStuff'); // true
+ hamster.get('backpack').clear(); // []
+ hamster.get('hasStuff'); // false
+ ```
+
+ @method computed.notEmpty
+ @for Ember
+ @param {String} dependentKey
+ @return {Ember.ComputedProperty} computed property which returns true if
+ original value for property is not empty.
+ */
+ computed.notEmpty = function(dependentKey) {
+ return computed(dependentKey + '.length', function () {
+ return !isEmpty(get(this, dependentKey));
+ });
+ };
+
+ /**
+ A computed property that returns true if the value of the dependent
+ property is null or undefined. This avoids errors from JSLint complaining
+ about use of ==, which can be technically confusing.
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ isHungry: Ember.computed.none('food')
+ });
+
+ var hamster = Hamster.create();
+
+ hamster.get('isHungry'); // true
+ hamster.set('food', 'Banana');
+ hamster.get('isHungry'); // false
+ hamster.set('food', null);
+ hamster.get('isHungry'); // true
+ ```
+
+ @method computed.none
+ @for Ember
+ @param {String} dependentKey
+ @return {Ember.ComputedProperty} computed property which
+ returns true if original value for property is null or undefined.
+ */
+ registerComputed('none', function(dependentKey) {
+ return isNone(get(this, dependentKey));
+ });
+
+ /**
+ A computed property that returns the inverse boolean value
+ of the original value for the dependent property.
+
+ Example
+
+ ```javascript
+ var User = Ember.Object.extend({
+ isAnonymous: Ember.computed.not('loggedIn')
+ });
+
+ var user = User.create({loggedIn: false});
+
+ user.get('isAnonymous'); // true
+ user.set('loggedIn', true);
+ user.get('isAnonymous'); // false
+ ```
+
+ @method computed.not
+ @for Ember
+ @param {String} dependentKey
+ @return {Ember.ComputedProperty} computed property which returns
+ inverse of the original value for property
+ */
+ registerComputed('not', function(dependentKey) {
+ return !get(this, dependentKey);
+ });
+
+ /**
+ A computed property that converts the provided dependent property
+ into a boolean value.
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ hasBananas: Ember.computed.bool('numBananas')
+ });
+
+ var hamster = Hamster.create();
+
+ hamster.get('hasBananas'); // false
+ hamster.set('numBananas', 0);
+ hamster.get('hasBananas'); // false
+ hamster.set('numBananas', 1);
+ hamster.get('hasBananas'); // true
+ hamster.set('numBananas', null);
+ hamster.get('hasBananas'); // false
+ ```
+
+ @method computed.bool
+ @for Ember
+ @param {String} dependentKey
+ @return {Ember.ComputedProperty} computed property which converts
+ to boolean the original value for property
+ */
+ registerComputed('bool', function(dependentKey) {
+ return !!get(this, dependentKey);
+ });
+
+ /**
+ A computed property which matches the original value for the
+ dependent property against a given RegExp, returning `true`
+ if they values matches the RegExp and `false` if it does not.
+
+ Example
+
+ ```javascript
+ var User = Ember.Object.extend({
+ hasValidEmail: Ember.computed.match('email', /^.+@.+\..+$/)
+ });
+
+ var user = User.create({loggedIn: false});
+
+ user.get('hasValidEmail'); // false
+ user.set('email', '');
+ user.get('hasValidEmail'); // false
+ user.set('email', 'ember_hamster@example.com');
+ user.get('hasValidEmail'); // true
+ ```
+
+ @method computed.match
+ @for Ember
+ @param {String} dependentKey
+ @param {RegExp} regexp
+ @return {Ember.ComputedProperty} computed property which match
+ the original value for property against a given RegExp
+ */
+ registerComputed('match', function(dependentKey, regexp) {
+ var value = get(this, dependentKey);
+ return typeof value === 'string' ? regexp.test(value) : false;
+ });
+
+ /**
+ A computed property that returns true if the provided dependent property
+ is equal to the given value.
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ napTime: Ember.computed.equal('state', 'sleepy')
+ });
+
+ var hamster = Hamster.create();
+
+ hamster.get('napTime'); // false
+ hamster.set('state', 'sleepy');
+ hamster.get('napTime'); // true
+ hamster.set('state', 'hungry');
+ hamster.get('napTime'); // false
+ ```
+
+ @method computed.equal
+ @for Ember
+ @param {String} dependentKey
+ @param {String|Number|Object} value
+ @return {Ember.ComputedProperty} computed property which returns true if
+ the original value for property is equal to the given value.
+ */
+ registerComputed('equal', function(dependentKey, value) {
+ return get(this, dependentKey) === value;
+ });
+
+ /**
+ A computed property that returns true if the provided dependent property
+ is greater than the provided value.
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ hasTooManyBananas: Ember.computed.gt('numBananas', 10)
+ });
+
+ var hamster = Hamster.create();
+
+ hamster.get('hasTooManyBananas'); // false
+ hamster.set('numBananas', 3);
+ hamster.get('hasTooManyBananas'); // false
+ hamster.set('numBananas', 11);
+ hamster.get('hasTooManyBananas'); // true
+ ```
+
+ @method computed.gt
+ @for Ember
+ @param {String} dependentKey
+ @param {Number} value
+ @return {Ember.ComputedProperty} computed property which returns true if
+ the original value for property is greater than given value.
+ */
+ registerComputed('gt', function(dependentKey, value) {
+ return get(this, dependentKey) > value;
+ });
+
+ /**
+ A computed property that returns true if the provided dependent property
+ is greater than or equal to the provided value.
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ hasTooManyBananas: Ember.computed.gte('numBananas', 10)
+ });
+
+ var hamster = Hamster.create();
+
+ hamster.get('hasTooManyBananas'); // false
+ hamster.set('numBananas', 3);
+ hamster.get('hasTooManyBananas'); // false
+ hamster.set('numBananas', 10);
+ hamster.get('hasTooManyBananas'); // true
+ ```
+
+ @method computed.gte
+ @for Ember
+ @param {String} dependentKey
+ @param {Number} value
+ @return {Ember.ComputedProperty} computed property which returns true if
+ the original value for property is greater or equal then given value.
+ */
+ registerComputed('gte', function(dependentKey, value) {
+ return get(this, dependentKey) >= value;
+ });
+
+ /**
+ A computed property that returns true if the provided dependent property
+ is less than the provided value.
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ needsMoreBananas: Ember.computed.lt('numBananas', 3)
+ });
+
+ var hamster = Hamster.create();
+
+ hamster.get('needsMoreBananas'); // true
+ hamster.set('numBananas', 3);
+ hamster.get('needsMoreBananas'); // false
+ hamster.set('numBananas', 2);
+ hamster.get('needsMoreBananas'); // true
+ ```
+
+ @method computed.lt
+ @for Ember
+ @param {String} dependentKey
+ @param {Number} value
+ @return {Ember.ComputedProperty} computed property which returns true if
+ the original value for property is less then given value.
+ */
+ registerComputed('lt', function(dependentKey, value) {
+ return get(this, dependentKey) < value;
+ });
+
+ /**
+ A computed property that returns true if the provided dependent property
+ is less than or equal to the provided value.
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ needsMoreBananas: Ember.computed.lte('numBananas', 3)
+ });
+
+ var hamster = Hamster.create();
+
+ hamster.get('needsMoreBananas'); // true
+ hamster.set('numBananas', 5);
+ hamster.get('needsMoreBananas'); // false
+ hamster.set('numBananas', 3);
+ hamster.get('needsMoreBananas'); // true
+ ```
+
+ @method computed.lte
+ @for Ember
+ @param {String} dependentKey
+ @param {Number} value
+ @return {Ember.ComputedProperty} computed property which returns true if
+ the original value for property is less or equal than given value.
+ */
+ registerComputed('lte', function(dependentKey, value) {
+ return get(this, dependentKey) <= value;
+ });
+
+ /**
+ A computed property that performs a logical `and` on the
+ original values for the provided dependent properties.
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ readyForCamp: Ember.computed.and('hasTent', 'hasBackpack')
+ });
+
+ var hamster = Hamster.create();
+
+ hamster.get('readyForCamp'); // false
+ hamster.set('hasTent', true);
+ hamster.get('readyForCamp'); // false
+ hamster.set('hasBackpack', true);
+ hamster.get('readyForCamp'); // true
+ ```
+
+ @method computed.and
+ @for Ember
+ @param {String} dependentKey*
+ @return {Ember.ComputedProperty} computed property which performs
+ a logical `and` on the values of all the original values for properties.
+ */
+ registerComputedWithProperties('and', function(properties) {
+ for (var key in properties) {
+ if (properties.hasOwnProperty(key) && !properties[key]) {
+ return false;
+ }
+ }
+ return true;
+ });
+
+ /**
+ A computed property which performs a logical `or` on the
+ original values for the provided dependent properties.
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ readyForRain: Ember.computed.or('hasJacket', 'hasUmbrella')
+ });
+
+ var hamster = Hamster.create();
+
+ hamster.get('readyForRain'); // false
+ hamster.set('hasJacket', true);
+ hamster.get('readyForRain'); // true
+ ```
+
+ @method computed.or
+ @for Ember
+ @param {String} dependentKey*
+ @return {Ember.ComputedProperty} computed property which performs
+ a logical `or` on the values of all the original values for properties.
+ */
+ registerComputedWithProperties('or', function(properties) {
+ for (var key in properties) {
+ if (properties.hasOwnProperty(key) && properties[key]) {
+ return true;
+ }
+ }
+ return false;
+ });
+
+ /**
+ A computed property that returns the first truthy value
+ from a list of dependent properties.
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ hasClothes: Ember.computed.any('hat', 'shirt')
+ });
+
+ var hamster = Hamster.create();
+
+ hamster.get('hasClothes'); // null
+ hamster.set('shirt', 'Hawaiian Shirt');
+ hamster.get('hasClothes'); // 'Hawaiian Shirt'
+ ```
+
+ @method computed.any
+ @for Ember
+ @param {String} dependentKey*
+ @return {Ember.ComputedProperty} computed property which returns
+ the first truthy value of given list of properties.
+ */
+ registerComputedWithProperties('any', function(properties) {
+ for (var key in properties) {
+ if (properties.hasOwnProperty(key) && properties[key]) {
+ return properties[key];
+ }
+ }
+ return null;
+ });
+
+ /**
+ A computed property that returns the array of values
+ for the provided dependent properties.
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ clothes: Ember.computed.collect('hat', 'shirt')
+ });
+
+ var hamster = Hamster.create();
+
+ hamster.get('clothes'); // [null, null]
+ hamster.set('hat', 'Camp Hat');
+ hamster.set('shirt', 'Camp Shirt');
+ hamster.get('clothes'); // ['Camp Hat', 'Camp Shirt']
+ ```
+
+ @method computed.collect
+ @for Ember
+ @param {String} dependentKey*
+ @return {Ember.ComputedProperty} computed property which maps
+ values of all passed in properties to an array.
+ */
+ registerComputedWithProperties('collect', function(properties) {
+ var res = Ember.A();
+ for (var key in properties) {
+ if (properties.hasOwnProperty(key)) {
+ if (isNone(properties[key])) {
+ res.push(null);
+ } else {
+ res.push(properties[key]);
+ }
+ }
+ }
+ return res;
+ });
+
+ /**
+ Creates a new property that is an alias for another property
+ on an object. Calls to `get` or `set` this property behave as
+ though they were called on the original property.
+
+ ```javascript
+ var Person = Ember.Object.extend({
+ name: 'Alex Matchneer',
+ nomen: Ember.computed.alias('name')
+ });
+
+ var alex = Person.create();
+
+ alex.get('nomen'); // 'Alex Matchneer'
+ alex.get('name'); // 'Alex Matchneer'
+
+ alex.set('nomen', '@machty');
+ alex.get('name'); // '@machty'
+ ```
+
+ @method computed.alias
+ @for Ember
+ @param {String} dependentKey
+ @return {Ember.ComputedProperty} computed property which creates an
+ alias to the original value for property.
+ */
+ computed.alias = alias;
+
+ /**
+ Where `computed.alias` aliases `get` and `set`, and allows for bidirectional
+ data flow, `computed.oneWay` only provides an aliased `get`. The `set` will
+ not mutate the upstream property, rather causes the current property to
+ become the value set. This causes the downstream property to permanently
+ diverge from the upstream property.
+
+ Example
+
+ ```javascript
+ var User = Ember.Object.extend({
+ firstName: null,
+ lastName: null,
+ nickName: Ember.computed.oneWay('firstName')
+ });
+
+ var teddy = User.create({
+ firstName: 'Teddy',
+ lastName: 'Zeenny'
+ });
+
+ teddy.get('nickName'); // 'Teddy'
+ teddy.set('nickName', 'TeddyBear'); // 'TeddyBear'
+ teddy.get('firstName'); // 'Teddy'
+ ```
+
+ @method computed.oneWay
+ @for Ember
+ @param {String} dependentKey
+ @return {Ember.ComputedProperty} computed property which creates a
+ one way computed property to the original value for property.
+ */
+ computed.oneWay = function(dependentKey) {
+ return alias(dependentKey).oneWay();
+ };
+
+ /**
+ This is a more semantically meaningful alias of `computed.oneWay`,
+ whose name is somewhat ambiguous as to which direction the data flows.
+
+ @method computed.reads
+ @for Ember
+ @param {String} dependentKey
+ @return {Ember.ComputedProperty} computed property which creates a
+ one way computed property to the original value for property.
+ */
+ computed.reads = computed.oneWay;
+
+ /**
+ Where `computed.oneWay` provides oneWay bindings, `computed.readOnly` provides
+ a readOnly one way binding. Very often when using `computed.oneWay` one does
+ not also want changes to propagate back up, as they will replace the value.
+
+ This prevents the reverse flow, and also throws an exception when it occurs.
+
+ Example
+
+ ```javascript
+ var User = Ember.Object.extend({
+ firstName: null,
+ lastName: null,
+ nickName: Ember.computed.readOnly('firstName')
+ });
+
+ var teddy = User.create({
+ firstName: 'Teddy',
+ lastName: 'Zeenny'
+ });
+
+ teddy.get('nickName'); // 'Teddy'
+ teddy.set('nickName', 'TeddyBear'); // throws Exception
+ // throw new Ember.Error('Cannot Set: nickName on: ' );`
+ teddy.get('firstName'); // 'Teddy'
+ ```
+
+ @method computed.readOnly
+ @for Ember
+ @param {String} dependentKey
+ @return {Ember.ComputedProperty} computed property which creates a
+ one way computed property to the original value for property.
+ @since 1.5.0
+ */
+ computed.readOnly = function(dependentKey) {
+ return alias(dependentKey).readOnly();
+ };
+ /**
+ A computed property that acts like a standard getter and setter,
+ but returns the value at the provided `defaultPath` if the
+ property itself has not been set to a value
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ wishList: Ember.computed.defaultTo('favoriteFood')
+ });
+
+ var hamster = Hamster.create({ favoriteFood: 'Banana' });
+
+ hamster.get('wishList'); // 'Banana'
+ hamster.set('wishList', 'More Unit Tests');
+ hamster.get('wishList'); // 'More Unit Tests'
+ hamster.get('favoriteFood'); // 'Banana'
+ ```
+
+ @method computed.defaultTo
+ @for Ember
+ @param {String} defaultPath
+ @return {Ember.ComputedProperty} computed property which acts like
+ a standard getter and setter, but defaults to the value from `defaultPath`.
+ @deprecated Use `Ember.computed.oneWay` or custom CP with default instead.
+ */
+ // ES6TODO: computed should have its own export path so you can do import {defaultTo} from computed
+ computed.defaultTo = function(defaultPath) {
+ return computed(function(key, newValue, cachedValue) {
+ Ember.deprecate('Usage of Ember.computed.defaultTo is deprecated, use `Ember.computed.oneWay` instead.');
+
+ if (arguments.length === 1) {
+ return get(this, defaultPath);
+ }
+ return newValue != null ? newValue : get(this, defaultPath);
+ });
+ };
+
+ /**
+ Creates a new property that is an alias for another property
+ on an object. Calls to `get` or `set` this property behave as
+ though they were called on the original property, but also
+ print a deprecation warning.
+
+ @method computed.deprecatingAlias
+ @for Ember
+ @param {String} dependentKey
+ @return {Ember.ComputedProperty} computed property which creates an
+ alias with a deprecation to the original value for property.
+ @since 1.7.0
+ */
+ computed.deprecatingAlias = function(dependentKey) {
+ return computed(dependentKey, function(key, value) {
+ Ember.deprecate('Usage of `' + key + '` is deprecated, use `' + dependentKey + '` instead.');
+
+ if (arguments.length > 1) {
+ set(this, dependentKey, value);
+ return value;
+ } else {
+ return get(this, dependentKey);
+ }
+ });
+ };
+ });
+enifed("ember-metal/core",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ /*globals Ember:true,ENV,EmberENV,MetamorphENV:true */
+
+ /**
+ @module ember
+ @submodule ember-metal
+ */
+
+ /**
+ All Ember methods and functions are defined inside of this namespace. You
+ generally should not add new properties to this namespace as it may be
+ overwritten by future versions of Ember.
+
+ You can also use the shorthand `Em` instead of `Ember`.
+
+ Ember-Runtime is a framework that provides core functions for Ember including
+ cross-platform functions, support for property observing and objects. Its
+ focus is on small size and performance. You can use this in place of or
+ along-side other cross-platform libraries such as jQuery.
+
+ The core Runtime framework is based on the jQuery API with a number of
+ performance optimizations.
+
+ @class Ember
+ @static
+ @version 1.10.1
+ */
+
+ if ('undefined' === typeof Ember) {
+ // Create core object. Make it act like an instance of Ember.Namespace so that
+ // objects assigned to it are given a sane string representation.
+ Ember = {};
+ }
+
+ // Default imports, exports and lookup to the global object;
+ Ember.imports = Ember.imports || this;
+ Ember.lookup = Ember.lookup || this;
+ var exports = Ember.exports = Ember.exports || this;
+
+ // aliases needed to keep minifiers from removing the global context
+ exports.Em = exports.Ember = Ember;
+
+ // Make sure these are set whether Ember was already defined or not
+
+ Ember.isNamespace = true;
+
+ Ember.toString = function() { return "Ember"; };
+
+
+ /**
+ @property VERSION
+ @type String
+ @default '1.10.1'
+ @static
+ */
+ Ember.VERSION = '1.10.1';
+
+ /**
+ Standard environmental variables. You can define these in a global `EmberENV`
+ variable before loading Ember to control various configuration settings.
+
+ For backwards compatibility with earlier versions of Ember the global `ENV`
+ variable will be used if `EmberENV` is not defined.
+
+ @property ENV
+ @type Hash
+ */
+
+ if (Ember.ENV) {
+ // do nothing if Ember.ENV is already setup
+ } else if ('undefined' !== typeof EmberENV) {
+ Ember.ENV = EmberENV;
+ } else if('undefined' !== typeof ENV) {
+ Ember.ENV = ENV;
+ } else {
+ Ember.ENV = {};
+ }
+
+ Ember.config = Ember.config || {};
+
+ // We disable the RANGE API by default for performance reasons
+ if ('undefined' === typeof Ember.ENV.DISABLE_RANGE_API) {
+ Ember.ENV.DISABLE_RANGE_API = true;
+ }
+
+ if ("undefined" === typeof MetamorphENV) {
+ exports.MetamorphENV = {};
+ }
+
+ MetamorphENV.DISABLE_RANGE_API = Ember.ENV.DISABLE_RANGE_API;
+
+ /**
+ Hash of enabled Canary features. Add to this before creating your application.
+
+ You can also define `EmberENV.FEATURES` if you need to enable features flagged at runtime.
+
+ @class FEATURES
+ @namespace Ember
+ @static
+ @since 1.1.0
+ */
+
+ Ember.FEATURES = Ember.ENV.FEATURES || {};
+
+ /**
+ Test that a feature is enabled. Parsed by Ember's build tools to leave
+ experimental features out of beta/stable builds.
+
+ You can define the following configuration options:
+
+ * `EmberENV.ENABLE_ALL_FEATURES` - force all features to be enabled.
+ * `EmberENV.ENABLE_OPTIONAL_FEATURES` - enable any features that have not been explicitly
+ enabled/disabled.
+
+ @method isEnabled
+ @param {String} feature
+ @return {Boolean}
+ @for Ember.FEATURES
+ @since 1.1.0
+ */
+
+ Ember.FEATURES.isEnabled = function(feature) {
+ var featureValue = Ember.FEATURES[feature];
+
+ if (Ember.ENV.ENABLE_ALL_FEATURES) {
+ return true;
+ } else if (featureValue === true || featureValue === false || featureValue === undefined) {
+ return featureValue;
+ } else if (Ember.ENV.ENABLE_OPTIONAL_FEATURES) {
+ return true;
+ } else {
+ return false;
+ }
+ };
+
+ // ..........................................................
+ // BOOTSTRAP
+ //
+
+ /**
+ Determines whether Ember should enhance some built-in object prototypes to
+ provide a more friendly API. If enabled, a few methods will be added to
+ `Function`, `String`, and `Array`. `Object.prototype` will not be enhanced,
+ which is the one that causes most trouble for people.
+
+ In general we recommend leaving this option set to true since it rarely
+ conflicts with other code. If you need to turn it off however, you can
+ define an `EmberENV.EXTEND_PROTOTYPES` config to disable it.
+
+ @property EXTEND_PROTOTYPES
+ @type Boolean
+ @default true
+ @for Ember
+ */
+ Ember.EXTEND_PROTOTYPES = Ember.ENV.EXTEND_PROTOTYPES;
+
+ if (typeof Ember.EXTEND_PROTOTYPES === 'undefined') {
+ Ember.EXTEND_PROTOTYPES = true;
+ }
+
+ /**
+ Determines whether Ember logs a full stack trace during deprecation warnings
+
+ @property LOG_STACKTRACE_ON_DEPRECATION
+ @type Boolean
+ @default true
+ */
+ Ember.LOG_STACKTRACE_ON_DEPRECATION = (Ember.ENV.LOG_STACKTRACE_ON_DEPRECATION !== false);
+
+ /**
+ Determines whether Ember should add ECMAScript 5 Array shims to older browsers.
+
+ @property SHIM_ES5
+ @type Boolean
+ @default Ember.EXTEND_PROTOTYPES
+ */
+ Ember.SHIM_ES5 = (Ember.ENV.SHIM_ES5 === false) ? false : Ember.EXTEND_PROTOTYPES;
+
+ /**
+ Determines whether Ember logs info about version of used libraries
+
+ @property LOG_VERSION
+ @type Boolean
+ @default true
+ */
+ Ember.LOG_VERSION = (Ember.ENV.LOG_VERSION === false) ? false : true;
+
+ /**
+ Empty function. Useful for some operations. Always returns `this`.
+
+ @method K
+ @private
+ @return {Object}
+ */
+ function K() { return this; }
+ __exports__.K = K;
+ Ember.K = K;
+ //TODO: ES6 GLOBAL TODO
+
+ // Stub out the methods defined by the ember-debug package in case it's not loaded
+
+ if ('undefined' === typeof Ember.assert) { Ember.assert = K; }
+ if ('undefined' === typeof Ember.warn) { Ember.warn = K; }
+ if ('undefined' === typeof Ember.debug) { Ember.debug = K; }
+ if ('undefined' === typeof Ember.runInDebug) { Ember.runInDebug = K; }
+ if ('undefined' === typeof Ember.deprecate) { Ember.deprecate = K; }
+ if ('undefined' === typeof Ember.deprecateFunc) {
+ Ember.deprecateFunc = function(_, func) { return func; };
+ }
+
+ __exports__["default"] = Ember;
+ });
+enifed("ember-metal/dependent_keys",
+ ["ember-metal/platform","ember-metal/watching","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ // Remove "use strict"; from transpiled module until
+ // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
+ //
+ // REMOVE_USE_STRICT: true
+
+ var o_create = __dependency1__.create;
+ var watch = __dependency2__.watch;
+ var unwatch = __dependency2__.unwatch;
+
+ /**
+ @module ember-metal
+ */
+
+ // ..........................................................
+ // DEPENDENT KEYS
+ //
+
+ // data structure:
+ // meta.deps = {
+ // 'depKey': {
+ // 'keyName': count,
+ // }
+ // }
+
+ /*
+ This function returns a map of unique dependencies for a
+ given object and key.
+ */
+ function keysForDep(depsMeta, depKey) {
+ var keys = depsMeta[depKey];
+ if (!keys) {
+ // if there are no dependencies yet for a the given key
+ // create a new empty list of dependencies for the key
+ keys = depsMeta[depKey] = {};
+ } else if (!depsMeta.hasOwnProperty(depKey)) {
+ // otherwise if the dependency list is inherited from
+ // a superclass, clone the hash
+ keys = depsMeta[depKey] = o_create(keys);
+ }
+ return keys;
+ }
+
+ function metaForDeps(meta) {
+ return keysForDep(meta, 'deps');
+ }
+
+ function addDependentKeys(desc, obj, keyName, meta) {
+ // the descriptor has a list of dependent keys, so
+ // add all of its dependent keys.
+ var depKeys = desc._dependentKeys, depsMeta, idx, len, depKey, keys;
+ if (!depKeys) return;
+
+ depsMeta = metaForDeps(meta);
+
+ for(idx = 0, len = depKeys.length; idx < len; idx++) {
+ depKey = depKeys[idx];
+ // Lookup keys meta for depKey
+ keys = keysForDep(depsMeta, depKey);
+ // Increment the number of times depKey depends on keyName.
+ keys[keyName] = (keys[keyName] || 0) + 1;
+ // Watch the depKey
+ watch(obj, depKey, meta);
+ }
+ }
+
+ __exports__.addDependentKeys = addDependentKeys;function removeDependentKeys(desc, obj, keyName, meta) {
+ // the descriptor has a list of dependent keys, so
+ // remove all of its dependent keys.
+ var depKeys = desc._dependentKeys, depsMeta, idx, len, depKey, keys;
+ if (!depKeys) return;
+
+ depsMeta = metaForDeps(meta);
+
+ for(idx = 0, len = depKeys.length; idx < len; idx++) {
+ depKey = depKeys[idx];
+ // Lookup keys meta for depKey
+ keys = keysForDep(depsMeta, depKey);
+ // Decrement the number of times depKey depends on keyName.
+ keys[keyName] = (keys[keyName] || 0) - 1;
+ // Unwatch the depKey
+ unwatch(obj, depKey, meta);
+ }
+ }
+
+ __exports__.removeDependentKeys = removeDependentKeys;
+ });
+enifed("ember-metal/deprecate_property",
+ ["ember-metal/core","ember-metal/platform","ember-metal/properties","ember-metal/property_get","ember-metal/property_set","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+ "use strict";
+ /**
+ @module ember-metal
+ */
+
+ var Ember = __dependency1__["default"];
+ var hasPropertyAccessors = __dependency2__.hasPropertyAccessors;
+ var defineProperty = __dependency3__.defineProperty;
+ var get = __dependency4__.get;
+ var set = __dependency5__.set;
+
+
+ /**
+ Used internally to allow changing properties in a backwards compatible way, and print a helpful
+ deprecation warning.
+
+ @method deprecateProperty
+ @param {Object} object The object to add the deprecated property to.
+ @param {String} deprecatedKey The property to add (and print deprecation warnings upon accessing).
+ @param {String} newKey The property that will be aliased.
+ @private
+ @since 1.7.0
+ */
+
+ function deprecateProperty(object, deprecatedKey, newKey) {
+ function deprecate() {
+ Ember.deprecate('Usage of `' + deprecatedKey + '` is deprecated, use `' + newKey + '` instead.');
+ }
+
+ if (hasPropertyAccessors) {
+ defineProperty(object, deprecatedKey, {
+ configurable: true,
+ enumerable: false,
+ set: function(value) { deprecate(); set(this, newKey, value); },
+ get: function() { deprecate(); return get(this, newKey); }
+ });
+ }
+ }
+
+ __exports__.deprecateProperty = deprecateProperty;
+ });
+enifed("ember-metal/dictionary",
+ ["ember-metal/platform","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var create = __dependency1__.create;
+
+ // the delete is meant to hint at runtimes that this object should remain in
+ // dictionary mode. This is clearly a runtime specific hack, but currently it
+ // appears worthwile in some usecases. Please note, these deletes do increase
+ // the cost of creation dramatically over a plain Object.create. And as this
+ // only makes sense for long-lived dictionaries that aren't instantiated often.
+ __exports__["default"] = function makeDictionary(parent) {
+ var dict = create(parent);
+ dict['_dict'] = null;
+ delete dict['_dict'];
+ return dict;
+ }
+ });
+enifed("ember-metal/enumerable_utils",
+ ["ember-metal/array","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var _filter = __dependency1__.filter;
+ var a_forEach = __dependency1__.forEach;
+ var _indexOf = __dependency1__.indexOf;
+ var _map = __dependency1__.map;
+
+ var splice = Array.prototype.splice;
+
+ /**
+ * Defines some convenience methods for working with Enumerables.
+ * `Ember.EnumerableUtils` uses `Ember.ArrayPolyfills` when necessary.
+ *
+ * @class EnumerableUtils
+ * @namespace Ember
+ * @static
+ * */
+
+ /**
+ * Calls the map function on the passed object with a specified callback. This
+ * uses `Ember.ArrayPolyfill`'s-map method when necessary.
+ *
+ * @method map
+ * @param {Object} obj The object that should be mapped
+ * @param {Function} callback The callback to execute
+ * @param {Object} thisArg Value to use as this when executing *callback*
+ *
+ * @return {Array} An array of mapped values.
+ */
+ function map(obj, callback, thisArg) {
+ return obj.map ? obj.map(callback, thisArg) : _map.call(obj, callback, thisArg);
+ }
+
+ __exports__.map = map;/**
+ * Calls the forEach function on the passed object with a specified callback. This
+ * uses `Ember.ArrayPolyfill`'s-forEach method when necessary.
+ *
+ * @method forEach
+ * @param {Object} obj The object to call forEach on
+ * @param {Function} callback The callback to execute
+ * @param {Object} thisArg Value to use as this when executing *callback*
+ *
+ */
+ function forEach(obj, callback, thisArg) {
+ return obj.forEach ? obj.forEach(callback, thisArg) : a_forEach.call(obj, callback, thisArg);
+ }
+
+ __exports__.forEach = forEach;/**
+ * Calls the filter function on the passed object with a specified callback. This
+ * uses `Ember.ArrayPolyfill`'s-filter method when necessary.
+ *
+ * @method filter
+ * @param {Object} obj The object to call filter on
+ * @param {Function} callback The callback to execute
+ * @param {Object} thisArg Value to use as this when executing *callback*
+ *
+ * @return {Array} An array containing the filtered values
+ * @since 1.4.0
+ */
+ function filter(obj, callback, thisArg) {
+ return obj.filter ? obj.filter(callback, thisArg) : _filter.call(obj, callback, thisArg);
+ }
+
+ __exports__.filter = filter;/**
+ * Calls the indexOf function on the passed object with a specified callback. This
+ * uses `Ember.ArrayPolyfill`'s-indexOf method when necessary.
+ *
+ * @method indexOf
+ * @param {Object} obj The object to call indexOn on
+ * @param {Function} callback The callback to execute
+ * @param {Object} index The index to start searching from
+ *
+ */
+ function indexOf(obj, element, index) {
+ return obj.indexOf ? obj.indexOf(element, index) : _indexOf.call(obj, element, index);
+ }
+
+ __exports__.indexOf = indexOf;/**
+ * Returns an array of indexes of the first occurrences of the passed elements
+ * on the passed object.
+ *
+ * ```javascript
+ * var array = [1, 2, 3, 4, 5];
+ * Ember.EnumerableUtils.indexesOf(array, [2, 5]); // [1, 4]
+ *
+ * var fubar = "Fubarr";
+ * Ember.EnumerableUtils.indexesOf(fubar, ['b', 'r']); // [2, 4]
+ * ```
+ *
+ * @method indexesOf
+ * @param {Object} obj The object to check for element indexes
+ * @param {Array} elements The elements to search for on *obj*
+ *
+ * @return {Array} An array of indexes.
+ *
+ */
+ function indexesOf(obj, elements) {
+ return elements === undefined ? [] : map(elements, function(item) {
+ return indexOf(obj, item);
+ });
+ }
+
+ __exports__.indexesOf = indexesOf;/**
+ * Adds an object to an array. If the array already includes the object this
+ * method has no effect.
+ *
+ * @method addObject
+ * @param {Array} array The array the passed item should be added to
+ * @param {Object} item The item to add to the passed array
+ *
+ * @return 'undefined'
+ */
+ function addObject(array, item) {
+ var index = indexOf(array, item);
+ if (index === -1) { array.push(item); }
+ }
+
+ __exports__.addObject = addObject;/**
+ * Removes an object from an array. If the array does not contain the passed
+ * object this method has no effect.
+ *
+ * @method removeObject
+ * @param {Array} array The array to remove the item from.
+ * @param {Object} item The item to remove from the passed array.
+ *
+ * @return 'undefined'
+ */
+ function removeObject(array, item) {
+ var index = indexOf(array, item);
+ if (index !== -1) { array.splice(index, 1); }
+ }
+
+ __exports__.removeObject = removeObject;function _replace(array, idx, amt, objects) {
+ var args = [].concat(objects);
+ var ret = [];
+ // https://code.google.com/p/chromium/issues/detail?id=56588
+ var size = 60000;
+ var start = idx;
+ var ends = amt;
+ var count, chunk;
+
+ while (args.length) {
+ count = ends > size ? size : ends;
+ if (count <= 0) { count = 0; }
+
+ chunk = args.splice(0, size);
+ chunk = [start, count].concat(chunk);
+
+ start += size;
+ ends -= count;
+
+ ret = ret.concat(splice.apply(array, chunk));
+ }
+ return ret;
+ }
+
+ __exports__._replace = _replace;/**
+ * Replaces objects in an array with the passed objects.
+ *
+ * ```javascript
+ * var array = [1,2,3];
+ * Ember.EnumerableUtils.replace(array, 1, 2, [4, 5]); // [1, 4, 5]
+ *
+ * var array = [1,2,3];
+ * Ember.EnumerableUtils.replace(array, 1, 1, [4, 5]); // [1, 4, 5, 3]
+ *
+ * var array = [1,2,3];
+ * Ember.EnumerableUtils.replace(array, 10, 1, [4, 5]); // [1, 2, 3, 4, 5]
+ * ```
+ *
+ * @method replace
+ * @param {Array} array The array the objects should be inserted into.
+ * @param {Number} idx Starting index in the array to replace. If *idx* >=
+ * length, then append to the end of the array.
+ * @param {Number} amt Number of elements that should be removed from the array,
+ * starting at *idx*
+ * @param {Array} objects An array of zero or more objects that should be
+ * inserted into the array at *idx*
+ *
+ * @return {Array} The modified array.
+ */
+ function replace(array, idx, amt, objects) {
+ if (array.replace) {
+ return array.replace(idx, amt, objects);
+ } else {
+ return _replace(array, idx, amt, objects);
+ }
+ }
+
+ __exports__.replace = replace;/**
+ * Calculates the intersection of two arrays. This method returns a new array
+ * filled with the records that the two passed arrays share with each other.
+ * If there is no intersection, an empty array will be returned.
+ *
+ * ```javascript
+ * var array1 = [1, 2, 3, 4, 5];
+ * var array2 = [1, 3, 5, 6, 7];
+ *
+ * Ember.EnumerableUtils.intersection(array1, array2); // [1, 3, 5]
+ *
+ * var array1 = [1, 2, 3];
+ * var array2 = [4, 5, 6];
+ *
+ * Ember.EnumerableUtils.intersection(array1, array2); // []
+ * ```
+ *
+ * @method intersection
+ * @param {Array} array1 The first array
+ * @param {Array} array2 The second array
+ *
+ * @return {Array} The intersection of the two passed arrays.
+ */
+ function intersection(array1, array2) {
+ var result = [];
+ forEach(array1, function(element) {
+ if (indexOf(array2, element) >= 0) {
+ result.push(element);
+ }
+ });
+
+ return result;
+ }
+
+ __exports__.intersection = intersection;// TODO: this only exists to maintain the existing api, as we move forward it
+ // should only be part of the "global build" via some shim
+ __exports__["default"] = {
+ _replace: _replace,
+ addObject: addObject,
+ filter: filter,
+ forEach: forEach,
+ indexOf: indexOf,
+ indexesOf: indexesOf,
+ intersection: intersection,
+ map: map,
+ removeObject: removeObject,
+ replace: replace
+ };
+ });
+enifed("ember-metal/error",
+ ["ember-metal/platform","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var create = __dependency1__.create;
+
+ var errorProps = [
+ 'description',
+ 'fileName',
+ 'lineNumber',
+ 'message',
+ 'name',
+ 'number',
+ 'stack'
+ ];
+
+ /**
+ A subclass of the JavaScript Error object for use in Ember.
+
+ @class Error
+ @namespace Ember
+ @extends Error
+ @constructor
+ */
+ function EmberError() {
+ var tmp = Error.apply(this, arguments);
+
+ // Adds a `stack` property to the given error object that will yield the
+ // stack trace at the time captureStackTrace was called.
+ // When collecting the stack trace all frames above the topmost call
+ // to this function, including that call, will be left out of the
+ // stack trace.
+ // This is useful because we can hide Ember implementation details
+ // that are not very helpful for the user.
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, Ember.Error);
+ }
+ // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
+ for (var idx = 0; idx < errorProps.length; idx++) {
+ this[errorProps[idx]] = tmp[errorProps[idx]];
+ }
+ }
+
+ EmberError.prototype = create(Error.prototype);
+
+ __exports__["default"] = EmberError;
+ });
+enifed("ember-metal/events",
+ ["ember-metal/core","ember-metal/utils","ember-metal/platform","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ // Remove "use strict"; from transpiled module until
+ // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
+ //
+ // REMOVE_USE_STRICT: true
+
+ /**
+ @module ember-metal
+ */
+ var Ember = __dependency1__["default"];
+ var metaFor = __dependency2__.meta;
+ var tryFinally = __dependency2__.tryFinally;
+ var apply = __dependency2__.apply;
+ var applyStr = __dependency2__.applyStr;
+ var create = __dependency3__.create;
+
+ var a_slice = [].slice;
+
+ /* listener flags */
+ var ONCE = 1;
+ var SUSPENDED = 2;
+
+
+ /*
+ The event system uses a series of nested hashes to store listeners on an
+ object. When a listener is registered, or when an event arrives, these
+ hashes are consulted to determine which target and action pair to invoke.
+
+ The hashes are stored in the object's meta hash, and look like this:
+
+ // Object's meta hash
+ {
+ listeners: { // variable name: `listenerSet`
+ "foo:changed": [ // variable name: `actions`
+ target, method, flags
+ ]
+ }
+ }
+
+ */
+
+ function indexOf(array, target, method) {
+ var index = -1;
+ // hashes are added to the end of the event array
+ // so it makes sense to start searching at the end
+ // of the array and search in reverse
+ for (var i = array.length - 3 ; i >=0; i -= 3) {
+ if (target === array[i] && method === array[i + 1]) {
+ index = i; break;
+ }
+ }
+ return index;
+ }
+
+ function actionsFor(obj, eventName) {
+ var meta = metaFor(obj, true);
+ var actions;
+ var listeners = meta.listeners;
+
+ if (!listeners) {
+ listeners = meta.listeners = create(null);
+ listeners.__source__ = obj;
+ } else if (listeners.__source__ !== obj) {
+ // setup inherited copy of the listeners object
+ listeners = meta.listeners = create(listeners);
+ listeners.__source__ = obj;
+ }
+
+ actions = listeners[eventName];
+
+ // if there are actions, but the eventName doesn't exist in our listeners, then copy them from the prototype
+ if (actions && actions.__source__ !== obj) {
+ actions = listeners[eventName] = listeners[eventName].slice();
+ actions.__source__ = obj;
+ } else if (!actions) {
+ actions = listeners[eventName] = [];
+ actions.__source__ = obj;
+ }
+
+ return actions;
+ }
+
+ function accumulateListeners(obj, eventName, otherActions) {
+ var meta = obj['__ember_meta__'];
+ var actions = meta && meta.listeners && meta.listeners[eventName];
+
+ if (!actions) { return; }
+
+ var newActions = [];
+
+ for (var i = actions.length - 3; i >= 0; i -= 3) {
+ var target = actions[i];
+ var method = actions[i+1];
+ var flags = actions[i+2];
+ var actionIndex = indexOf(otherActions, target, method);
+
+ if (actionIndex === -1) {
+ otherActions.push(target, method, flags);
+ newActions.push(target, method, flags);
+ }
+ }
+
+ return newActions;
+ }
+
+ __exports__.accumulateListeners = accumulateListeners;/**
+ Add an event listener
+
+ @method addListener
+ @for Ember
+ @param obj
+ @param {String} eventName
+ @param {Object|Function} target A target object or a function
+ @param {Function|String} method A function or the name of a function to be called on `target`
+ @param {Boolean} once A flag whether a function should only be called once
+ */
+ function addListener(obj, eventName, target, method, once) {
+ Ember.assert("You must pass at least an object and event name to Ember.addListener", !!obj && !!eventName);
+
+ if (!method && 'function' === typeof target) {
+ method = target;
+ target = null;
+ }
+
+ var actions = actionsFor(obj, eventName);
+ var actionIndex = indexOf(actions, target, method);
+ var flags = 0;
+
+ if (once) flags |= ONCE;
+
+ if (actionIndex !== -1) { return; }
+
+ actions.push(target, method, flags);
+
+ if ('function' === typeof obj.didAddListener) {
+ obj.didAddListener(eventName, target, method);
+ }
+ }
+
+ __exports__.addListener = addListener;/**
+ Remove an event listener
+
+ Arguments should match those passed to `Ember.addListener`.
+
+ @method removeListener
+ @for Ember
+ @param obj
+ @param {String} eventName
+ @param {Object|Function} target A target object or a function
+ @param {Function|String} method A function or the name of a function to be called on `target`
+ */
+ function removeListener(obj, eventName, target, method) {
+ Ember.assert("You must pass at least an object and event name to Ember.removeListener", !!obj && !!eventName);
+
+ if (!method && 'function' === typeof target) {
+ method = target;
+ target = null;
+ }
+
+ function _removeListener(target, method) {
+ var actions = actionsFor(obj, eventName);
+ var actionIndex = indexOf(actions, target, method);
+
+ // action doesn't exist, give up silently
+ if (actionIndex === -1) { return; }
+
+ actions.splice(actionIndex, 3);
+
+ if ('function' === typeof obj.didRemoveListener) {
+ obj.didRemoveListener(eventName, target, method);
+ }
+ }
+
+ if (method) {
+ _removeListener(target, method);
+ } else {
+ var meta = obj['__ember_meta__'];
+ var actions = meta && meta.listeners && meta.listeners[eventName];
+
+ if (!actions) { return; }
+ for (var i = actions.length - 3; i >= 0; i -= 3) {
+ _removeListener(actions[i], actions[i+1]);
+ }
+ }
+ }
+
+ /**
+ Suspend listener during callback.
+
+ This should only be used by the target of the event listener
+ when it is taking an action that would cause the event, e.g.
+ an object might suspend its property change listener while it is
+ setting that property.
+
+ @method suspendListener
+ @for Ember
+
+ @private
+ @param obj
+ @param {String} eventName
+ @param {Object|Function} target A target object or a function
+ @param {Function|String} method A function or the name of a function to be called on `target`
+ @param {Function} callback
+ */
+ function suspendListener(obj, eventName, target, method, callback) {
+ if (!method && 'function' === typeof target) {
+ method = target;
+ target = null;
+ }
+
+ var actions = actionsFor(obj, eventName);
+ var actionIndex = indexOf(actions, target, method);
+
+ if (actionIndex !== -1) {
+ actions[actionIndex+2] |= SUSPENDED; // mark the action as suspended
+ }
+
+ function tryable() { return callback.call(target); }
+ function finalizer() { if (actionIndex !== -1) { actions[actionIndex+2] &= ~SUSPENDED; } }
+
+ return tryFinally(tryable, finalizer);
+ }
+
+ __exports__.suspendListener = suspendListener;/**
+ Suspends multiple listeners during a callback.
+
+ @method suspendListeners
+ @for Ember
+
+ @private
+ @param obj
+ @param {Array} eventNames Array of event names
+ @param {Object|Function} target A target object or a function
+ @param {Function|String} method A function or the name of a function to be called on `target`
+ @param {Function} callback
+ */
+ function suspendListeners(obj, eventNames, target, method, callback) {
+ if (!method && 'function' === typeof target) {
+ method = target;
+ target = null;
+ }
+
+ var suspendedActions = [];
+ var actionsList = [];
+ var eventName, actions, i, l;
+
+ for (i=0, l=eventNames.length; i= 0; i -= 3) { // looping in reverse for once listeners
+ var target = actions[i], method = actions[i+1], flags = actions[i+2];
+ if (!method) { continue; }
+ if (flags & SUSPENDED) { continue; }
+ if (flags & ONCE) { removeListener(obj, eventName, target, method); }
+ if (!target) { target = obj; }
+ if ('string' === typeof method) {
+ if (params) {
+ applyStr(target, method, params);
+ } else {
+ target[method]();
+ }
+ } else {
+ if (params) {
+ apply(target, method, params);
+ } else {
+ method.call(target);
+ }
+ }
+ }
+ return true;
+ }
+
+ __exports__.sendEvent = sendEvent;/**
+ @private
+ @method hasListeners
+ @for Ember
+ @param obj
+ @param {String} eventName
+ */
+ function hasListeners(obj, eventName) {
+ var meta = obj['__ember_meta__'];
+ var actions = meta && meta.listeners && meta.listeners[eventName];
+
+ return !!(actions && actions.length);
+ }
+
+ __exports__.hasListeners = hasListeners;/**
+ @private
+ @method listenersFor
+ @for Ember
+ @param obj
+ @param {String} eventName
+ */
+ function listenersFor(obj, eventName) {
+ var ret = [];
+ var meta = obj['__ember_meta__'];
+ var actions = meta && meta.listeners && meta.listeners[eventName];
+
+ if (!actions) { return ret; }
+
+ for (var i = 0, l = actions.length; i < l; i += 3) {
+ var target = actions[i];
+ var method = actions[i+1];
+ ret.push([target, method]);
+ }
+
+ return ret;
+ }
+
+ __exports__.listenersFor = listenersFor;/**
+ Define a property as a function that should be executed when
+ a specified event or events are triggered.
+
+
+ ``` javascript
+ var Job = Ember.Object.extend({
+ logCompleted: Ember.on('completed', function() {
+ console.log('Job completed!');
+ })
+ });
+
+ var job = Job.create();
+
+ Ember.sendEvent(job, 'completed'); // Logs 'Job completed!'
+ ```
+
+ @method on
+ @for Ember
+ @param {String} eventNames*
+ @param {Function} func
+ @return func
+ */
+ function on(){
+ var func = a_slice.call(arguments, -1)[0];
+ var events = a_slice.call(arguments, 0, -1);
+ func.__ember_listens__ = events;
+ return func;
+ }
+
+ __exports__.on = on;__exports__.removeListener = removeListener;
+ });
+enifed("ember-metal/expand_properties",
+ ["ember-metal/core","ember-metal/error","ember-metal/enumerable_utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ var EmberError = __dependency2__["default"];
+ var forEach = __dependency3__.forEach;
+
+ /**
+ @module ember-metal
+ */
+
+ var BRACE_EXPANSION = /^((?:[^\.]*\.)*)\{(.*)\}$/;
+ var SPLIT_REGEX = /\{|\}/;
+
+ /**
+ Expands `pattern`, invoking `callback` for each expansion.
+
+ The only pattern supported is brace-expansion, anything else will be passed
+ once to `callback` directly.
+
+ Example
+
+ ```js
+ function echo(arg){ console.log(arg); }
+
+ Ember.expandProperties('foo.bar', echo); //=> 'foo.bar'
+ Ember.expandProperties('{foo,bar}', echo); //=> 'foo', 'bar'
+ Ember.expandProperties('foo.{bar,baz}', echo); //=> 'foo.bar', 'foo.baz'
+ Ember.expandProperties('{foo,bar}.baz', echo); //=> '{foo,bar}.baz'
+ Ember.expandProperties('foo.{bar,baz}.@each', echo) //=> 'foo.bar.@each', 'foo.baz.@each'
+ Ember.expandProperties('{foo,bar}.{spam,eggs}', echo) //=> 'foo.spam', 'foo.eggs', 'bar.spam', 'bar.eggs'
+ Ember.expandProperties('{foo}.bar.{baz}') //=> 'foo.bar.baz'
+ ```
+
+ @method
+ @private
+ @param {String} pattern The property pattern to expand.
+ @param {Function} callback The callback to invoke. It is invoked once per
+ expansion, and is passed the expansion.
+ */
+ __exports__["default"] = function expandProperties(pattern, callback) {
+ if (pattern.indexOf(' ') > -1) {
+ throw new EmberError('Brace expanded properties cannot contain spaces, ' +
+ 'e.g. `user.{firstName, lastName}` should be `user.{firstName,lastName}`');
+ }
+
+
+ return newExpandProperties(pattern, callback);
+ }
+
+ function oldExpandProperties(pattern, callback) {
+ var match, prefix, list;
+
+ if (match = BRACE_EXPANSION.exec(pattern)) {
+ prefix = match[1];
+ list = match[2];
+
+ forEach(list.split(','), function (suffix) {
+ callback(prefix + suffix);
+ });
+ } else {
+ callback(pattern);
+ }
+ }
+
+ function newExpandProperties(pattern, callback) {
+ if ('string' === Ember.typeOf(pattern)) {
+ var parts = pattern.split(SPLIT_REGEX);
+ var properties = [parts];
+
+ forEach(parts, function(part, index) {
+ if (part.indexOf(',') >= 0) {
+ properties = duplicateAndReplace(properties, part.split(','), index);
+ }
+ });
+
+ forEach(properties, function(property) {
+ callback(property.join(''));
+ });
+ } else {
+ callback(pattern);
+ }
+ }
+
+ function duplicateAndReplace(properties, currentParts, index) {
+ var all = [];
+
+ forEach(properties, function(property) {
+ forEach(currentParts, function(part) {
+ var current = property.slice(0);
+ current[index] = part;
+ all.push(current);
+ });
+ });
+
+ return all;
+ }
+ });
+enifed("ember-metal/get_properties",
+ ["ember-metal/property_get","ember-metal/utils","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var get = __dependency1__.get;
+ var typeOf = __dependency2__.typeOf;
+
+ /**
+ To get multiple properties at once, call `Ember.getProperties`
+ with an object followed by a list of strings or an array:
+
+ ```javascript
+ Ember.getProperties(record, 'firstName', 'lastName', 'zipCode');
+ // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+ ```
+
+ is equivalent to:
+
+ ```javascript
+ Ember.getProperties(record, ['firstName', 'lastName', 'zipCode']);
+ // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+ ```
+
+ @method getProperties
+ @for Ember
+ @param {Object} obj
+ @param {String...|Array} list of keys to get
+ @return {Object}
+ */
+ __exports__["default"] = function getProperties(obj) {
+ var ret = {};
+ var propertyNames = arguments;
+ var i = 1;
+
+ if (arguments.length === 2 && typeOf(arguments[1]) === 'array') {
+ i = 0;
+ propertyNames = arguments[1];
+ }
+ for(var len = propertyNames.length; i < len; i++) {
+ ret[propertyNames[i]] = get(obj, propertyNames[i]);
+ }
+ return ret;
+ }
+ });
+enifed("ember-metal/injected_property",
+ ["ember-metal/core","ember-metal/computed","ember-metal/alias","ember-metal/properties","ember-metal/platform","ember-metal/utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+ var ComputedProperty = __dependency2__.ComputedProperty;
+ var AliasedProperty = __dependency3__.AliasedProperty;
+ var Descriptor = __dependency4__.Descriptor;
+ var create = __dependency5__.create;
+ var meta = __dependency6__.meta;
+
+ /**
+ Read-only property that returns the result of a container lookup.
+
+ @class InjectedProperty
+ @namespace Ember
+ @extends Ember.Descriptor
+ @constructor
+ @param {String} type The container type the property will lookup
+ @param {String} name (optional) The name the property will lookup, defaults
+ to the property's name
+ */
+ function InjectedProperty(type, name) {
+ this.type = type;
+ this.name = name;
+
+ this._super$Constructor(injectedPropertyGet);
+ AliasedPropertyPrototype.oneWay.call(this);
+ }
+
+ function injectedPropertyGet(keyName) {
+ var desc = meta(this).descs[keyName];
+
+ Ember.assert("Attempting to lookup an injected property on an object " +
+ "without a container, ensure that the object was " +
+ "instantiated via a container.", this.container);
+
+ return this.container.lookup(desc.type + ':' + (desc.name || keyName));
+ }
+
+ InjectedProperty.prototype = create(Descriptor.prototype);
+
+ var InjectedPropertyPrototype = InjectedProperty.prototype;
+ var ComputedPropertyPrototype = ComputedProperty.prototype;
+ var AliasedPropertyPrototype = AliasedProperty.prototype;
+
+ InjectedPropertyPrototype._super$Constructor = ComputedProperty;
+
+ InjectedPropertyPrototype.get = ComputedPropertyPrototype.get;
+ InjectedPropertyPrototype.readOnly = ComputedPropertyPrototype.readOnly;
+
+ InjectedPropertyPrototype.teardown = ComputedPropertyPrototype.teardown;
+
+ __exports__["default"] = InjectedProperty;
+ });
+enifed("ember-metal/instrumentation",
+ ["ember-metal/core","ember-metal/utils","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ var tryCatchFinally = __dependency2__.tryCatchFinally;
+
+ /**
+ The purpose of the Ember Instrumentation module is
+ to provide efficient, general-purpose instrumentation
+ for Ember.
+
+ Subscribe to a listener by using `Ember.subscribe`:
+
+ ```javascript
+ Ember.subscribe("render", {
+ before: function(name, timestamp, payload) {
+
+ },
+
+ after: function(name, timestamp, payload) {
+
+ }
+ });
+ ```
+
+ If you return a value from the `before` callback, that same
+ value will be passed as a fourth parameter to the `after`
+ callback.
+
+ Instrument a block of code by using `Ember.instrument`:
+
+ ```javascript
+ Ember.instrument("render.handlebars", payload, function() {
+ // rendering logic
+ }, binding);
+ ```
+
+ Event names passed to `Ember.instrument` are namespaced
+ by periods, from more general to more specific. Subscribers
+ can listen for events by whatever level of granularity they
+ are interested in.
+
+ In the above example, the event is `render.handlebars`,
+ and the subscriber listened for all events beginning with
+ `render`. It would receive callbacks for events named
+ `render`, `render.handlebars`, `render.container`, or
+ even `render.handlebars.layout`.
+
+ @class Instrumentation
+ @namespace Ember
+ @static
+ */
+ var subscribers = [];
+ __exports__.subscribers = subscribers;var cache = {};
+
+ var populateListeners = function(name) {
+ var listeners = [];
+ var subscriber;
+
+ for (var i=0, l=subscribers.length; i -1) {
+ list.splice(index, 1);
+ }
+ this.size = list.length;
+ return true;
+ } else {
+ return false;
+ }
+ },
+
+ /**
+ @method isEmpty
+ @return {Boolean}
+ */
+ isEmpty: function() {
+ return this.size === 0;
+ },
+
+ /**
+ @method has
+ @param obj
+ @return {Boolean}
+ */
+ has: function(obj) {
+ if (this.size === 0) { return false; }
+
+ var guid = guidFor(obj);
+ var presenceSet = this.presenceSet;
+
+ return presenceSet[guid] === true;
+ },
+
+ /**
+ @method forEach
+ @param {Function} fn
+ @param self
+ */
+ forEach: function(fn /*, thisArg*/) {
+ if (typeof fn !== 'function') {
+ missingFunction(fn);
+ }
+
+ if (this.size === 0) { return; }
+
+ var list = this.list;
+ var length = arguments.length;
+ var i;
+
+ if (length === 2) {
+ for (i = 0; i < list.length; i++) {
+ fn.call(arguments[1], list[i]);
+ }
+ } else {
+ for (i = 0; i < list.length; i++) {
+ fn(list[i]);
+ }
+ }
+ },
+
+ /**
+ @method toArray
+ @return {Array}
+ */
+ toArray: function() {
+ return this.list.slice();
+ },
+
+ /**
+ @method copy
+ @return {Ember.OrderedSet}
+ */
+ copy: function() {
+ var Constructor = this.constructor;
+ var set = new Constructor();
+
+ set._silenceRemoveDeprecation = this._silenceRemoveDeprecation;
+ set.presenceSet = copyNull(this.presenceSet);
+ set.list = this.toArray();
+ set.size = this.size;
+
+ return set;
+ }
+ };
+
+ deprecateProperty(OrderedSet.prototype, 'length', 'size');
+
+ /**
+ A Map stores values indexed by keys. Unlike JavaScript's
+ default Objects, the keys of a Map can be any JavaScript
+ object.
+
+ Internally, a Map has two data structures:
+
+ 1. `keys`: an OrderedSet of all of the existing keys
+ 2. `values`: a JavaScript Object indexed by the `Ember.guidFor(key)`
+
+ When a key/value pair is added for the first time, we
+ add the key to the `keys` OrderedSet, and create or
+ replace an entry in `values`. When an entry is deleted,
+ we delete its entry in `keys` and `values`.
+
+ @class Map
+ @namespace Ember
+ @private
+ @constructor
+ */
+ function Map() {
+ if (this instanceof this.constructor) {
+ this.keys = OrderedSet.create();
+ this.keys._silenceRemoveDeprecation = true;
+ this.values = create(null);
+ this.size = 0;
+ } else {
+ missingNew("OrderedSet");
+ }
+ }
+
+ Ember.Map = Map;
+
+ /**
+ @method create
+ @static
+ */
+ Map.create = function() {
+ var Constructor = this;
+ return new Constructor();
+ };
+
+ Map.prototype = {
+ constructor: Map,
+
+ /**
+ This property will change as the number of objects in the map changes.
+
+ @since 1.8.0
+ @property size
+ @type number
+ @default 0
+ */
+ size: 0,
+
+ /**
+ Retrieve the value associated with a given key.
+
+ @method get
+ @param {*} key
+ @return {*} the value associated with the key, or `undefined`
+ */
+ get: function(key) {
+ if (this.size === 0) { return; }
+
+ var values = this.values;
+ var guid = guidFor(key);
+
+ return values[guid];
+ },
+
+ /**
+ Adds a value to the map. If a value for the given key has already been
+ provided, the new value will replace the old value.
+
+ @method set
+ @param {*} key
+ @param {*} value
+ @return {Ember.Map}
+ */
+ set: function(key, value) {
+ var keys = this.keys;
+ var values = this.values;
+ var guid = guidFor(key);
+
+ // ensure we don't store -0
+ var k = key === -0 ? 0 : key;
+
+ keys.add(k, guid);
+
+ values[guid] = value;
+
+ this.size = keys.size;
+
+ return this;
+ },
+
+ /**
+ @deprecated see delete
+ Removes a value from the map for an associated key.
+
+ @method remove
+ @param {*} key
+ @return {Boolean} true if an item was removed, false otherwise
+ */
+ remove: function(key) {
+ Ember.deprecate('Calling `Map.prototype.remove` has been deprecated, please use `Map.prototype.delete` instead.');
+
+ return this["delete"](key);
+ },
+
+ /**
+ Removes a value from the map for an associated key.
+
+ @since 1.8.0
+ @method delete
+ @param {*} key
+ @return {Boolean} true if an item was removed, false otherwise
+ */
+ "delete": function(key) {
+ if (this.size === 0) { return false; }
+ // don't use ES6 "delete" because it will be annoying
+ // to use in browsers that are not ES6 friendly;
+ var keys = this.keys;
+ var values = this.values;
+ var guid = guidFor(key);
+
+ if (keys["delete"](key, guid)) {
+ delete values[guid];
+ this.size = keys.size;
+ return true;
+ } else {
+ return false;
+ }
+ },
+
+ /**
+ Check whether a key is present.
+
+ @method has
+ @param {*} key
+ @return {Boolean} true if the item was present, false otherwise
+ */
+ has: function(key) {
+ return this.keys.has(key);
+ },
+
+ /**
+ Iterate over all the keys and values. Calls the function once
+ for each key, passing in value, key, and the map being iterated over,
+ in that order.
+
+ The keys are guaranteed to be iterated over in insertion order.
+
+ @method forEach
+ @param {Function} callback
+ @param {*} self if passed, the `this` value inside the
+ callback. By default, `this` is the map.
+ */
+ forEach: function(callback /*, thisArg*/) {
+ if (typeof callback !== 'function') {
+ missingFunction(callback);
+ }
+
+ if (this.size === 0) { return; }
+
+ var length = arguments.length;
+ var map = this;
+ var cb, thisArg;
+
+ if (length === 2) {
+ thisArg = arguments[1];
+ cb = function(key) {
+ callback.call(thisArg, map.get(key), key, map);
+ };
+ } else {
+ cb = function(key) {
+ callback(map.get(key), key, map);
+ };
+ }
+
+ this.keys.forEach(cb);
+ },
+
+ /**
+ @method clear
+ */
+ clear: function() {
+ this.keys.clear();
+ this.values = create(null);
+ this.size = 0;
+ },
+
+ /**
+ @method copy
+ @return {Ember.Map}
+ */
+ copy: function() {
+ return copyMap(this, new Map());
+ }
+ };
+
+ deprecateProperty(Map.prototype, 'length', 'size');
+
+ /**
+ @class MapWithDefault
+ @namespace Ember
+ @extends Ember.Map
+ @private
+ @constructor
+ @param [options]
+ @param {*} [options.defaultValue]
+ */
+ function MapWithDefault(options) {
+ this._super$constructor();
+ this.defaultValue = options.defaultValue;
+ }
+
+ /**
+ @method create
+ @static
+ @param [options]
+ @param {*} [options.defaultValue]
+ @return {Ember.MapWithDefault|Ember.Map} If options are passed, returns
+ `Ember.MapWithDefault` otherwise returns `Ember.Map`
+ */
+ MapWithDefault.create = function(options) {
+ if (options) {
+ return new MapWithDefault(options);
+ } else {
+ return new Map();
+ }
+ };
+
+ MapWithDefault.prototype = create(Map.prototype);
+ MapWithDefault.prototype.constructor = MapWithDefault;
+ MapWithDefault.prototype._super$constructor = Map;
+ MapWithDefault.prototype._super$get = Map.prototype.get;
+
+ /**
+ Retrieve the value associated with a given key.
+
+ @method get
+ @param {*} key
+ @return {*} the value associated with the key, or the default value
+ */
+ MapWithDefault.prototype.get = function(key) {
+ var hasValue = this.has(key);
+
+ if (hasValue) {
+ return this._super$get(key);
+ } else {
+ var defaultValue = this.defaultValue(key);
+ this.set(key, defaultValue);
+ return defaultValue;
+ }
+ };
+
+ /**
+ @method copy
+ @return {Ember.MapWithDefault}
+ */
+ MapWithDefault.prototype.copy = function() {
+ var Constructor = this.constructor;
+ return copyMap(this, new Constructor({
+ defaultValue: this.defaultValue
+ }));
+ };
+
+ __exports__["default"] = Map;
+
+ __exports__.OrderedSet = OrderedSet;
+ __exports__.Map = Map;
+ __exports__.MapWithDefault = MapWithDefault;
+ });
+enifed("ember-metal/merge",
+ ["ember-metal/keys","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var keys = __dependency1__["default"];
+
+ /**
+ Merge the contents of two objects together into the first object.
+
+ ```javascript
+ Ember.merge({first: 'Tom'}, {last: 'Dale'}); // {first: 'Tom', last: 'Dale'}
+ var a = {first: 'Yehuda'}, b = {last: 'Katz'};
+ Ember.merge(a, b); // a == {first: 'Yehuda', last: 'Katz'}, b == {last: 'Katz'}
+ ```
+
+ @method merge
+ @for Ember
+ @param {Object} original The object to merge into
+ @param {Object} updates The object to copy properties from
+ @return {Object}
+ */
+ __exports__["default"] = function merge(original, updates) {
+ if (!updates || typeof updates !== 'object') {
+ return original;
+ }
+
+ var props = keys(updates);
+ var prop;
+ var length = props.length;
+
+ for (var i = 0; i < length; i++) {
+ prop = props[i];
+ original[prop] = updates[prop];
+ }
+
+ return original;
+ }
+ });
+enifed("ember-metal/mixin",
+ ["ember-metal/core","ember-metal/merge","ember-metal/array","ember-metal/platform","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/expand_properties","ember-metal/properties","ember-metal/computed","ember-metal/binding","ember-metal/observer","ember-metal/events","ember-metal/streams/utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __exports__) {
+ // Remove "use strict"; from transpiled module until
+ // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
+ //
+ // REMOVE_USE_STRICT: true
+
+ /**
+ @module ember
+ @submodule ember-metal
+ */
+
+ var Ember = __dependency1__["default"];
+ // warn, assert, wrap, et;
+ var merge = __dependency2__["default"];
+ var a_indexOf = __dependency3__.indexOf;
+ var a_forEach = __dependency3__.forEach;
+ var o_create = __dependency4__.create;
+ var get = __dependency5__.get;
+ var set = __dependency6__.set;
+ var trySet = __dependency6__.trySet;
+ var guidFor = __dependency7__.guidFor;
+ var metaFor = __dependency7__.meta;
+ var wrap = __dependency7__.wrap;
+ var makeArray = __dependency7__.makeArray;
+ var isArray = __dependency7__.isArray;
+ var expandProperties = __dependency8__["default"];
+ var Descriptor = __dependency9__.Descriptor;
+ var defineProperty = __dependency9__.defineProperty;
+ var ComputedProperty = __dependency10__.ComputedProperty;
+ var Binding = __dependency11__.Binding;
+ var addObserver = __dependency12__.addObserver;
+ var removeObserver = __dependency12__.removeObserver;
+ var addBeforeObserver = __dependency12__.addBeforeObserver;
+ var removeBeforeObserver = __dependency12__.removeBeforeObserver;
+ var _suspendObserver = __dependency12__._suspendObserver;
+ var addListener = __dependency13__.addListener;
+ var removeListener = __dependency13__.removeListener;
+ var isStream = __dependency14__.isStream;
+
+ var REQUIRED;
+ var a_slice = [].slice;
+
+ function superFunction(){
+ var func = this.__nextSuper;
+ var ret;
+
+ if (func) {
+ var length = arguments.length;
+ this.__nextSuper = null;
+ if (length === 0) {
+ ret = func.call(this);
+ } else if (length === 1) {
+ ret = func.call(this, arguments[0]);
+ } else if (length === 2) {
+ ret = func.call(this, arguments[0], arguments[1]);
+ } else {
+ ret = func.apply(this, arguments);
+ }
+ this.__nextSuper = func;
+ return ret;
+ }
+ }
+
+ // ensure we prime superFunction to mitigate
+ // v8 bug potentially incorrectly deopts this function: https://code.google.com/p/v8/issues/detail?id=3709
+ var primer = {
+ __nextSuper: function(a,b,c,d ) { }
+ };
+
+ superFunction.call(primer);
+ superFunction.call(primer, 1);
+ superFunction.call(primer, 1, 2);
+ superFunction.call(primer, 1, 2, 3);
+
+ function mixinsMeta(obj) {
+ var m = metaFor(obj, true);
+ var ret = m.mixins;
+ if (!ret) {
+ ret = m.mixins = {};
+ } else if (!m.hasOwnProperty('mixins')) {
+ ret = m.mixins = o_create(ret);
+ }
+ return ret;
+ }
+
+ function isMethod(obj) {
+ return 'function' === typeof obj &&
+ obj.isMethod !== false &&
+ obj !== Boolean &&
+ obj !== Object &&
+ obj !== Number &&
+ obj !== Array &&
+ obj !== Date &&
+ obj !== String;
+ }
+
+ var CONTINUE = {};
+
+ function mixinProperties(mixinsMeta, mixin) {
+ var guid;
+
+ if (mixin instanceof Mixin) {
+ guid = guidFor(mixin);
+ if (mixinsMeta[guid]) { return CONTINUE; }
+ mixinsMeta[guid] = mixin;
+ return mixin.properties;
+ } else {
+ return mixin; // apply anonymous mixin properties
+ }
+ }
+
+ function concatenatedMixinProperties(concatProp, props, values, base) {
+ var concats;
+
+ // reset before adding each new mixin to pickup concats from previous
+ concats = values[concatProp] || base[concatProp];
+ if (props[concatProp]) {
+ concats = concats ? concats.concat(props[concatProp]) : props[concatProp];
+ }
+
+ return concats;
+ }
+
+ function giveDescriptorSuper(meta, key, property, values, descs) {
+ var superProperty;
+
+ // Computed properties override methods, and do not call super to them
+ if (values[key] === undefined) {
+ // Find the original descriptor in a parent mixin
+ superProperty = descs[key];
+ }
+
+ // If we didn't find the original descriptor in a parent mixin, find
+ // it on the original object.
+ superProperty = superProperty || meta.descs[key];
+
+ if (superProperty === undefined || !(superProperty instanceof ComputedProperty)) {
+ return property;
+ }
+
+ // Since multiple mixins may inherit from the same parent, we need
+ // to clone the computed property so that other mixins do not receive
+ // the wrapped version.
+ property = o_create(property);
+ property.func = wrap(property.func, superProperty.func);
+
+ return property;
+ }
+
+ var sourceAvailable = (function() {
+ return this;
+ }).toString().indexOf('return this;') > -1;
+
+ function giveMethodSuper(obj, key, method, values, descs) {
+ var superMethod;
+
+ // Methods overwrite computed properties, and do not call super to them.
+ if (descs[key] === undefined) {
+ // Find the original method in a parent mixin
+ superMethod = values[key];
+ }
+
+ // If we didn't find the original value in a parent mixin, find it in
+ // the original object
+ superMethod = superMethod || obj[key];
+
+ // Only wrap the new method if the original method was a function
+ if (superMethod === undefined || 'function' !== typeof superMethod) {
+ return method;
+ }
+
+ var hasSuper;
+ if (sourceAvailable) {
+ hasSuper = method.__hasSuper;
+
+ if (hasSuper === undefined) {
+ hasSuper = method.toString().indexOf('_super') > -1;
+ method.__hasSuper = hasSuper;
+ }
+ }
+
+ if (sourceAvailable === false || hasSuper) {
+ return wrap(method, superMethod);
+ } else {
+ return method;
+ }
+ }
+
+ function applyConcatenatedProperties(obj, key, value, values) {
+ var baseValue = values[key] || obj[key];
+
+ if (baseValue) {
+ if ('function' === typeof baseValue.concat) {
+ if (value === null || value === undefined) {
+ return baseValue;
+ } else {
+ return baseValue.concat(value);
+ }
+ } else {
+ return makeArray(baseValue).concat(value);
+ }
+ } else {
+ return makeArray(value);
+ }
+ }
+
+ function applyMergedProperties(obj, key, value, values) {
+ var baseValue = values[key] || obj[key];
+
+ Ember.assert("You passed in `" + JSON.stringify(value) + "` as the value for `" + key +
+ "` but `" + key + "` cannot be an Array", !isArray(value));
+
+ if (!baseValue) { return value; }
+
+ var newBase = merge({}, baseValue);
+ var hasFunction = false;
+
+ for (var prop in value) {
+ if (!value.hasOwnProperty(prop)) { continue; }
+
+ var propValue = value[prop];
+ if (isMethod(propValue)) {
+ // TODO: support for Computed Properties, etc?
+ hasFunction = true;
+ newBase[prop] = giveMethodSuper(obj, prop, propValue, baseValue, {});
+ } else {
+ newBase[prop] = propValue;
+ }
+ }
+
+ if (hasFunction) {
+ newBase._super = superFunction;
+ }
+
+ return newBase;
+ }
+
+ function addNormalizedProperty(base, key, value, meta, descs, values, concats, mergings) {
+ if (value instanceof Descriptor) {
+ if (value === REQUIRED && descs[key]) { return CONTINUE; }
+
+ // Wrap descriptor function to implement
+ // __nextSuper() if needed
+ if (value.func) {
+ value = giveDescriptorSuper(meta, key, value, values, descs);
+ }
+
+ descs[key] = value;
+ values[key] = undefined;
+ } else {
+ if ((concats && a_indexOf.call(concats, key) >= 0) ||
+ key === 'concatenatedProperties' ||
+ key === 'mergedProperties') {
+ value = applyConcatenatedProperties(base, key, value, values);
+ } else if ((mergings && a_indexOf.call(mergings, key) >= 0)) {
+ value = applyMergedProperties(base, key, value, values);
+ } else if (isMethod(value)) {
+ value = giveMethodSuper(base, key, value, values, descs);
+ }
+
+ descs[key] = undefined;
+ values[key] = value;
+ }
+ }
+
+ function mergeMixins(mixins, m, descs, values, base, keys) {
+ var mixin, props, key, concats, mergings, meta;
+
+ function removeKeys(keyName) {
+ delete descs[keyName];
+ delete values[keyName];
+ }
+
+ for(var i=0, l=mixins.length; i 0) {
+ var m = new Array(length);
+
+ for (var i = 0; i < length; i++) {
+ var x = args[i];
+ if (x instanceof Mixin) {
+ m[i] = x;
+ } else {
+ m[i] = new Mixin(undefined, x);
+ }
+ }
+
+ this.mixins = m;
+ } else {
+ this.mixins = undefined;
+ }
+ this.ownerConstructor = undefined;
+ }
+
+ Mixin._apply = applyMixin;
+
+ Mixin.applyPartial = function(obj) {
+ var args = a_slice.call(arguments, 1);
+ return applyMixin(obj, args, true);
+ };
+
+ Mixin.finishPartial = finishPartial;
+
+ // ES6TODO: this relies on a global state?
+ Ember.anyUnprocessedMixins = false;
+
+ /**
+ @method create
+ @static
+ @param arguments*
+ */
+ Mixin.create = function() {
+ // ES6TODO: this relies on a global state?
+ Ember.anyUnprocessedMixins = true;
+ var M = this;
+ var length = arguments.length;
+ var args = new Array(length);
+ for (var i = 0; i < length; i++) {
+ args[i] = arguments[i];
+ }
+ return new M(args, undefined);
+ };
+
+ var MixinPrototype = Mixin.prototype;
+
+ /**
+ @method reopen
+ @param arguments*
+ */
+ MixinPrototype.reopen = function() {
+ var mixin;
+
+ if (this.properties) {
+ mixin = new Mixin(undefined, this.properties);
+ this.properties = undefined;
+ this.mixins = [mixin];
+ } else if (!this.mixins) {
+ this.mixins = [];
+ }
+
+ var len = arguments.length;
+ var mixins = this.mixins;
+ var idx;
+
+ for(idx=0; idx < len; idx++) {
+ mixin = arguments[idx];
+ Ember.assert('Expected hash or Mixin instance, got ' + Object.prototype.toString.call(mixin),
+ typeof mixin === 'object' && mixin !== null &&
+ Object.prototype.toString.call(mixin) !== '[object Array]');
+
+ if (mixin instanceof Mixin) {
+ mixins.push(mixin);
+ } else {
+ mixins.push(new Mixin(undefined, mixin));
+ }
+ }
+
+ return this;
+ };
+
+ /**
+ @method apply
+ @param obj
+ @return applied object
+ */
+ MixinPrototype.apply = function(obj) {
+ return applyMixin(obj, [this], false);
+ };
+
+ MixinPrototype.applyPartial = function(obj) {
+ return applyMixin(obj, [this], true);
+ };
+
+ function _detect(curMixin, targetMixin, seen) {
+ var guid = guidFor(curMixin);
+
+ if (seen[guid]) { return false; }
+ seen[guid] = true;
+
+ if (curMixin === targetMixin) { return true; }
+ var mixins = curMixin.mixins;
+ var loc = mixins ? mixins.length : 0;
+ while (--loc >= 0) {
+ if (_detect(mixins[loc], targetMixin, seen)) { return true; }
+ }
+ return false;
+ }
+
+ /**
+ @method detect
+ @param obj
+ @return {Boolean}
+ */
+ MixinPrototype.detect = function(obj) {
+ if (!obj) { return false; }
+ if (obj instanceof Mixin) { return _detect(obj, this, {}); }
+ var m = obj['__ember_meta__'];
+ var mixins = m && m.mixins;
+ if (mixins) {
+ return !!mixins[guidFor(this)];
+ }
+ return false;
+ };
+
+ MixinPrototype.without = function() {
+ var ret = new Mixin([this]);
+ ret._without = a_slice.call(arguments);
+ return ret;
+ };
+
+ function _keys(ret, mixin, seen) {
+ if (seen[guidFor(mixin)]) { return; }
+ seen[guidFor(mixin)] = true;
+
+ if (mixin.properties) {
+ var props = mixin.properties;
+ for (var key in props) {
+ if (props.hasOwnProperty(key)) { ret[key] = true; }
+ }
+ } else if (mixin.mixins) {
+ a_forEach.call(mixin.mixins, function(x) { _keys(ret, x, seen); });
+ }
+ }
+
+ MixinPrototype.keys = function() {
+ var keys = {};
+ var seen = {};
+ var ret = [];
+ _keys(keys, this, seen);
+ for(var key in keys) {
+ if (keys.hasOwnProperty(key)) {
+ ret.push(key);
+ }
+ }
+ return ret;
+ };
+
+ // returns the mixins currently applied to the specified object
+ // TODO: Make Ember.mixin
+ Mixin.mixins = function(obj) {
+ var m = obj['__ember_meta__'];
+ var mixins = m && m.mixins;
+ var ret = [];
+
+ if (!mixins) { return ret; }
+
+ for (var key in mixins) {
+ var mixin = mixins[key];
+
+ // skip primitive mixins since these are always anonymous
+ if (!mixin.properties) { ret.push(mixin); }
+ }
+
+ return ret;
+ };
+
+ REQUIRED = new Descriptor();
+ REQUIRED.toString = function() { return '(Required Property)'; };
+
+ /**
+ Denotes a required property for a mixin
+
+ @method required
+ @for Ember
+ */
+ function required() {
+ return REQUIRED;
+ }
+
+ __exports__.required = required;function Alias(methodName) {
+ this.methodName = methodName;
+ }
+
+ Alias.prototype = new Descriptor();
+
+ /**
+ Makes a method available via an additional name.
+
+ ```javascript
+ App.Person = Ember.Object.extend({
+ name: function() {
+ return 'Tomhuda Katzdale';
+ },
+ moniker: Ember.aliasMethod('name')
+ });
+
+ var goodGuy = App.Person.create();
+
+ goodGuy.name(); // 'Tomhuda Katzdale'
+ goodGuy.moniker(); // 'Tomhuda Katzdale'
+ ```
+
+ @method aliasMethod
+ @for Ember
+ @param {String} methodName name of the method to alias
+ @return {Ember.Descriptor}
+ */
+ function aliasMethod(methodName) {
+ return new Alias(methodName);
+ }
+
+ __exports__.aliasMethod = aliasMethod;// ..........................................................
+ // OBSERVER HELPER
+ //
+
+ /**
+ Specify a method that observes property changes.
+
+ ```javascript
+ Ember.Object.extend({
+ valueObserver: Ember.observer('value', function() {
+ // Executes whenever the "value" property changes
+ })
+ });
+ ```
+
+ In the future this method may become asynchronous. If you want to ensure
+ synchronous behavior, use `immediateObserver`.
+
+ Also available as `Function.prototype.observes` if prototype extensions are
+ enabled.
+
+ @method observer
+ @for Ember
+ @param {String} propertyNames*
+ @param {Function} func
+ @return func
+ */
+ function observer() {
+ var func = a_slice.call(arguments, -1)[0];
+ var paths;
+
+ var addWatchedProperty = function (path) { paths.push(path); };
+ var _paths = a_slice.call(arguments, 0, -1);
+
+ if (typeof func !== "function") {
+ // revert to old, soft-deprecated argument ordering
+
+ func = arguments[0];
+ _paths = a_slice.call(arguments, 1);
+ }
+
+ paths = [];
+
+ for (var i=0; i<_paths.length; ++i) {
+ expandProperties(_paths[i], addWatchedProperty);
+ }
+
+ if (typeof func !== "function") {
+ throw new Ember.Error("Ember.observer called without a function");
+ }
+
+ func.__ember_observes__ = paths;
+ return func;
+ }
+
+ __exports__.observer = observer;/**
+ Specify a method that observes property changes.
+
+ ```javascript
+ Ember.Object.extend({
+ valueObserver: Ember.immediateObserver('value', function() {
+ // Executes whenever the "value" property changes
+ })
+ });
+ ```
+
+ In the future, `Ember.observer` may become asynchronous. In this event,
+ `Ember.immediateObserver` will maintain the synchronous behavior.
+
+ Also available as `Function.prototype.observesImmediately` if prototype extensions are
+ enabled.
+
+ @method immediateObserver
+ @for Ember
+ @param {String} propertyNames*
+ @param {Function} func
+ @return func
+ */
+ function immediateObserver() {
+ for (var i=0, l=arguments.length; i this.changingFrom ? 'green' : 'red';
+ // logic
+ }
+ }),
+
+ friendsDidChange: Ember.observer('friends.@each.name', function(obj, keyName) {
+ // some logic
+ // obj.get(keyName) returns friends array
+ })
+ });
+ ```
+
+ Also available as `Function.prototype.observesBefore` if prototype extensions are
+ enabled.
+
+ @method beforeObserver
+ @for Ember
+ @param {String} propertyNames*
+ @param {Function} func
+ @return func
+ */
+ function beforeObserver() {
+ var func = a_slice.call(arguments, -1)[0];
+ var paths;
+
+ var addWatchedProperty = function(path) { paths.push(path); };
+
+ var _paths = a_slice.call(arguments, 0, -1);
+
+ if (typeof func !== "function") {
+ // revert to old, soft-deprecated argument ordering
+
+ func = arguments[0];
+ _paths = a_slice.call(arguments, 1);
+ }
+
+ paths = [];
+
+ for (var i=0; i<_paths.length; ++i) {
+ expandProperties(_paths[i], addWatchedProperty);
+ }
+
+ if (typeof func !== "function") {
+ throw new Ember.Error("Ember.beforeObserver called without a function");
+ }
+
+ func.__ember_observesBefore__ = paths;
+ return func;
+ }
+
+ __exports__.beforeObserver = beforeObserver;__exports__.IS_BINDING = IS_BINDING;
+ __exports__.Mixin = Mixin;
+ });
+enifed("ember-metal/observer",
+ ["ember-metal/watching","ember-metal/array","ember-metal/events","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var watch = __dependency1__.watch;
+ var unwatch = __dependency1__.unwatch;
+ var map = __dependency2__.map;
+ var listenersFor = __dependency3__.listenersFor;
+ var addListener = __dependency3__.addListener;
+ var removeListener = __dependency3__.removeListener;
+ var suspendListeners = __dependency3__.suspendListeners;
+ var suspendListener = __dependency3__.suspendListener;
+ /**
+ @module ember-metal
+ */
+
+ var AFTER_OBSERVERS = ':change';
+ var BEFORE_OBSERVERS = ':before';
+
+ function changeEvent(keyName) {
+ return keyName + AFTER_OBSERVERS;
+ }
+
+ function beforeEvent(keyName) {
+ return keyName + BEFORE_OBSERVERS;
+ }
+
+ /**
+ @method addObserver
+ @for Ember
+ @param obj
+ @param {String} path
+ @param {Object|Function} targetOrMethod
+ @param {Function|String} [method]
+ */
+ function addObserver(obj, _path, target, method) {
+ addListener(obj, changeEvent(_path), target, method);
+ watch(obj, _path);
+
+ return this;
+ }
+
+ __exports__.addObserver = addObserver;function observersFor(obj, path) {
+ return listenersFor(obj, changeEvent(path));
+ }
+
+ __exports__.observersFor = observersFor;/**
+ @method removeObserver
+ @for Ember
+ @param obj
+ @param {String} path
+ @param {Object|Function} target
+ @param {Function|String} [method]
+ */
+ function removeObserver(obj, path, target, method) {
+ unwatch(obj, path);
+ removeListener(obj, changeEvent(path), target, method);
+
+ return this;
+ }
+
+ __exports__.removeObserver = removeObserver;/**
+ @method addBeforeObserver
+ @for Ember
+ @param obj
+ @param {String} path
+ @param {Object|Function} target
+ @param {Function|String} [method]
+ */
+ function addBeforeObserver(obj, path, target, method) {
+ addListener(obj, beforeEvent(path), target, method);
+ watch(obj, path);
+
+ return this;
+ }
+
+ __exports__.addBeforeObserver = addBeforeObserver;// Suspend observer during callback.
+ //
+ // This should only be used by the target of the observer
+ // while it is setting the observed path.
+ function _suspendBeforeObserver(obj, path, target, method, callback) {
+ return suspendListener(obj, beforeEvent(path), target, method, callback);
+ }
+
+ __exports__._suspendBeforeObserver = _suspendBeforeObserver;function _suspendObserver(obj, path, target, method, callback) {
+ return suspendListener(obj, changeEvent(path), target, method, callback);
+ }
+
+ __exports__._suspendObserver = _suspendObserver;function _suspendBeforeObservers(obj, paths, target, method, callback) {
+ var events = map.call(paths, beforeEvent);
+ return suspendListeners(obj, events, target, method, callback);
+ }
+
+ __exports__._suspendBeforeObservers = _suspendBeforeObservers;function _suspendObservers(obj, paths, target, method, callback) {
+ var events = map.call(paths, changeEvent);
+ return suspendListeners(obj, events, target, method, callback);
+ }
+
+ __exports__._suspendObservers = _suspendObservers;function beforeObserversFor(obj, path) {
+ return listenersFor(obj, beforeEvent(path));
+ }
+
+ __exports__.beforeObserversFor = beforeObserversFor;/**
+ @method removeBeforeObserver
+ @for Ember
+ @param obj
+ @param {String} path
+ @param {Object|Function} target
+ @param {Function|String} [method]
+ */
+ function removeBeforeObserver(obj, path, target, method) {
+ unwatch(obj, path);
+ removeListener(obj, beforeEvent(path), target, method);
+
+ return this;
+ }
+
+ __exports__.removeBeforeObserver = removeBeforeObserver;
+ });
+enifed("ember-metal/observer_set",
+ ["ember-metal/utils","ember-metal/events","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var guidFor = __dependency1__.guidFor;
+ var sendEvent = __dependency2__.sendEvent;
+
+ /*
+ this.observerSet = {
+ [senderGuid]: { // variable name: `keySet`
+ [keyName]: listIndex
+ }
+ },
+ this.observers = [
+ {
+ sender: obj,
+ keyName: keyName,
+ eventName: eventName,
+ listeners: [
+ [target, method, flags]
+ ]
+ },
+ ...
+ ]
+ */
+ __exports__["default"] = ObserverSet;
+ function ObserverSet() {
+ this.clear();
+ }
+
+
+ ObserverSet.prototype.add = function(sender, keyName, eventName) {
+ var observerSet = this.observerSet;
+ var observers = this.observers;
+ var senderGuid = guidFor(sender);
+ var keySet = observerSet[senderGuid];
+ var index;
+
+ if (!keySet) {
+ observerSet[senderGuid] = keySet = {};
+ }
+ index = keySet[keyName];
+ if (index === undefined) {
+ index = observers.push({
+ sender: sender,
+ keyName: keyName,
+ eventName: eventName,
+ listeners: []
+ }) - 1;
+ keySet[keyName] = index;
+ }
+ return observers[index].listeners;
+ };
+
+ ObserverSet.prototype.flush = function() {
+ var observers = this.observers;
+ var i, len, observer, sender;
+ this.clear();
+ for (i=0, len=observers.length; i < len; ++i) {
+ observer = observers[i];
+ sender = observer.sender;
+ if (sender.isDestroying || sender.isDestroyed) { continue; }
+ sendEvent(sender, observer.eventName, [sender, observer.keyName], observer.listeners);
+ }
+ };
+
+ ObserverSet.prototype.clear = function() {
+ this.observerSet = {};
+ this.observers = [];
+ };
+ });
+enifed("ember-metal/path_cache",
+ ["ember-metal/cache","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var Cache = __dependency1__["default"];
+
+ var IS_GLOBAL = /^([A-Z$]|([0-9][A-Z$]))/;
+ var IS_GLOBAL_PATH = /^([A-Z$]|([0-9][A-Z$])).*[\.]/;
+ var HAS_THIS = 'this.';
+
+ var isGlobalCache = new Cache(1000, function(key) { return IS_GLOBAL.test(key); });
+ var isGlobalPathCache = new Cache(1000, function(key) { return IS_GLOBAL_PATH.test(key); });
+ var hasThisCache = new Cache(1000, function(key) { return key.lastIndexOf(HAS_THIS, 0) === 0; });
+ var firstDotIndexCache = new Cache(1000, function(key) { return key.indexOf('.'); });
+
+ var firstKeyCache = new Cache(1000, function(path) {
+ var index = firstDotIndexCache.get(path);
+ if (index === -1) {
+ return path;
+ } else {
+ return path.slice(0, index);
+ }
+ });
+
+ var tailPathCache = new Cache(1000, function(path) {
+ var index = firstDotIndexCache.get(path);
+ if (index !== -1) {
+ return path.slice(index + 1);
+ }
+ });
+
+ var caches = {
+ isGlobalCache: isGlobalCache,
+ isGlobalPathCache: isGlobalPathCache,
+ hasThisCache: hasThisCache,
+ firstDotIndexCache: firstDotIndexCache,
+ firstKeyCache: firstKeyCache,
+ tailPathCache: tailPathCache
+ };
+ __exports__.caches = caches;
+ function isGlobal(path) {
+ return isGlobalCache.get(path);
+ }
+
+ __exports__.isGlobal = isGlobal;function isGlobalPath(path) {
+ return isGlobalPathCache.get(path);
+ }
+
+ __exports__.isGlobalPath = isGlobalPath;function hasThis(path) {
+ return hasThisCache.get(path);
+ }
+
+ __exports__.hasThis = hasThis;function isPath(path) {
+ return firstDotIndexCache.get(path) !== -1;
+ }
+
+ __exports__.isPath = isPath;function getFirstKey(path) {
+ return firstKeyCache.get(path);
+ }
+
+ __exports__.getFirstKey = getFirstKey;function getTailPath(path) {
+ return tailPathCache.get(path);
+ }
+
+ __exports__.getTailPath = getTailPath;
+ });
+enifed("ember-metal/platform",
+ ["ember-metal/platform/define_property","ember-metal/platform/define_properties","ember-metal/platform/create","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var hasES5CompliantDefineProperty = __dependency1__.hasES5CompliantDefineProperty;
+ var defineProperty = __dependency1__.defineProperty;
+ var defineProperties = __dependency2__["default"];
+ var create = __dependency3__["default"];
+
+ /**
+ @module ember-metal
+ */
+
+ var hasPropertyAccessors = hasES5CompliantDefineProperty;
+ var canDefineNonEnumerableProperties = hasES5CompliantDefineProperty;
+
+ /**
+ Platform specific methods and feature detectors needed by the framework.
+
+ @class platform
+ @namespace Ember
+ @static
+ */
+
+ __exports__.create = create;
+ __exports__.defineProperty = defineProperty;
+ __exports__.defineProperties = defineProperties;
+ __exports__.hasPropertyAccessors = hasPropertyAccessors;
+ __exports__.canDefineNonEnumerableProperties = canDefineNonEnumerableProperties;
+ });
+enifed("ember-metal/platform/create",
+ ["ember-metal/platform/define_properties","exports"],
+ function(__dependency1__, __exports__) {
+ // Remove "use strict"; from transpiled module until
+ // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
+ //
+ // REMOVE_USE_STRICT: true
+ //
+
+ var defineProperties = __dependency1__["default"];
+
+ /**
+ @class platform
+ @namespace Ember
+ @static
+ */
+
+ /**
+ Identical to `Object.create()`. Implements if not available natively.
+
+ @since 1.8.0
+ @method create
+ @for Ember
+ */
+ var create;
+ // ES5 15.2.3.5
+ // http://es5.github.com/#x15.2.3.5
+ if (!(Object.create && !Object.create(null).hasOwnProperty)) {
+ /* jshint scripturl:true, proto:true */
+ // Contributed by Brandon Benvie, October, 2012
+ var createEmpty;
+ var supportsProto = !({'__proto__':null} instanceof Object);
+ // the following produces false positives
+ // in Opera Mini => not a reliable check
+ // Object.prototype.__proto__ === null
+ if (supportsProto || typeof document === 'undefined') {
+ createEmpty = function () {
+ return { "__proto__": null };
+ };
+ } else {
+ // In old IE __proto__ can't be used to manually set `null`, nor does
+ // any other method exist to make an object that inherits from nothing,
+ // aside from Object.prototype itself. Instead, create a new global
+ // object and *steal* its Object.prototype and strip it bare. This is
+ // used as the prototype to create nullary objects.
+ createEmpty = function () {
+ var iframe = document.createElement('iframe');
+ var parent = document.body || document.documentElement;
+ iframe.style.display = 'none';
+ parent.appendChild(iframe);
+ iframe.src = 'javascript:';
+ var empty = iframe.contentWindow.Object.prototype;
+ parent.removeChild(iframe);
+ iframe = null;
+ delete empty.constructor;
+ delete empty.hasOwnProperty;
+ delete empty.propertyIsEnumerable;
+ delete empty.isPrototypeOf;
+ delete empty.toLocaleString;
+ delete empty.toString;
+ delete empty.valueOf;
+
+ function Empty() {}
+ Empty.prototype = empty;
+ // short-circuit future calls
+ createEmpty = function () {
+ return new Empty();
+ };
+ return new Empty();
+ };
+ }
+
+ create = Object.create = function create(prototype, properties) {
+
+ var object;
+ function Type() {} // An empty constructor.
+
+ if (prototype === null) {
+ object = createEmpty();
+ } else {
+ if (typeof prototype !== "object" && typeof prototype !== "function") {
+ // In the native implementation `parent` can be `null`
+ // OR *any* `instanceof Object` (Object|Function|Array|RegExp|etc)
+ // Use `typeof` tho, b/c in old IE, DOM elements are not `instanceof Object`
+ // like they are in modern browsers. Using `Object.create` on DOM elements
+ // is...err...probably inappropriate, but the native version allows for it.
+ throw new TypeError("Object prototype may only be an Object or null"); // same msg as Chrome
+ }
+
+ Type.prototype = prototype;
+
+ object = new Type();
+ }
+
+ if (properties !== undefined) {
+ defineProperties(object, properties);
+ }
+
+ return object;
+ };
+ } else {
+ create = Object.create;
+ }
+
+ __exports__["default"] = create;
+ });
+enifed("ember-metal/platform/define_properties",
+ ["ember-metal/platform/define_property","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var defineProperty = __dependency1__.defineProperty;
+
+ var defineProperties = Object.defineProperties;
+
+ // ES5 15.2.3.7
+ // http://es5.github.com/#x15.2.3.7
+ if (!defineProperties) {
+ defineProperties = function defineProperties(object, properties) {
+ for (var property in properties) {
+ if (properties.hasOwnProperty(property) && property !== "__proto__") {
+ defineProperty(object, property, properties[property]);
+ }
+ }
+ return object;
+ };
+
+ Object.defineProperties = defineProperties;
+ }
+
+ __exports__["default"] = defineProperties;
+ });
+enifed("ember-metal/platform/define_property",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ /*globals Node */
+
+ /**
+ @class platform
+ @namespace Ember
+ @static
+ */
+
+ /**
+ Set to true if the platform supports native getters and setters.
+
+ @property hasPropertyAccessors
+ @final
+ */
+
+ /**
+ Identical to `Object.defineProperty()`. Implements as much functionality
+ as possible if not available natively.
+
+ @method defineProperty
+ @param {Object} obj The object to modify
+ @param {String} keyName property name to modify
+ @param {Object} desc descriptor hash
+ @return {void}
+ */
+ var defineProperty = (function checkCompliance(defineProperty) {
+ if (!defineProperty) return;
+ try {
+ var a = 5;
+ var obj = {};
+ defineProperty(obj, 'a', {
+ configurable: true,
+ enumerable: true,
+ get: function () {
+ return a;
+ },
+ set: function (v) {
+ a = v;
+ }
+ });
+ if (obj.a !== 5) return;
+ obj.a = 10;
+ if (a !== 10) return;
+
+ // check non-enumerability
+ defineProperty(obj, 'a', {
+ configurable: true,
+ enumerable: false,
+ writable: true,
+ value: true
+ });
+ for (var key in obj) {
+ if (key === 'a') return;
+ }
+
+ // Detects a bug in Android <3.2 where you cannot redefine a property using
+ // Object.defineProperty once accessors have already been set.
+ if (obj.a !== true) return;
+
+ // Detects a bug in Android <3 where redefining a property without a value changes the value
+ // Object.defineProperty once accessors have already been set.
+ defineProperty(obj, 'a', {
+ enumerable: false
+ });
+ if (obj.a !== true) return;
+
+ // defineProperty is compliant
+ return defineProperty;
+ } catch (e) {
+ // IE8 defines Object.defineProperty but calling it on an Object throws
+ return;
+ }
+ })(Object.defineProperty);
+
+ var hasES5CompliantDefineProperty = !!defineProperty;
+
+ if (hasES5CompliantDefineProperty && typeof document !== 'undefined') {
+ // This is for Safari 5.0, which supports Object.defineProperty, but not
+ // on DOM nodes.
+ var canDefinePropertyOnDOM = (function() {
+ try {
+ defineProperty(document.createElement('div'), 'definePropertyOnDOM', {});
+ return true;
+ } catch(e) { }
+
+ return false;
+ })();
+
+ if (!canDefinePropertyOnDOM) {
+ defineProperty = function(obj, keyName, desc) {
+ var isNode;
+
+ if (typeof Node === "object") {
+ isNode = obj instanceof Node;
+ } else {
+ isNode = typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string";
+ }
+
+ if (isNode) {
+ // TODO: Should we have a warning here?
+ return (obj[keyName] = desc.value);
+ } else {
+ return Object.defineProperty(obj, keyName, desc);
+ }
+ };
+ }
+ }
+
+ if (!hasES5CompliantDefineProperty) {
+ defineProperty = function defineProperty(obj, keyName, desc) {
+ if (!desc.get) { obj[keyName] = desc.value; }
+ };
+ }
+
+ __exports__.hasES5CompliantDefineProperty = hasES5CompliantDefineProperty;
+ __exports__.defineProperty = defineProperty;
+ });
+enifed("ember-metal/properties",
+ ["ember-metal/core","ember-metal/utils","ember-metal/platform","ember-metal/property_events","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ /**
+ @module ember-metal
+ */
+
+ var Ember = __dependency1__["default"];
+ var metaFor = __dependency2__.meta;
+ var objectDefineProperty = __dependency3__.defineProperty;
+ var hasPropertyAccessors = __dependency3__.hasPropertyAccessors;
+ var overrideChains = __dependency4__.overrideChains;
+ // ..........................................................
+ // DESCRIPTOR
+ //
+
+ /**
+ Objects of this type can implement an interface to respond to requests to
+ get and set. The default implementation handles simple properties.
+
+ You generally won't need to create or subclass this directly.
+
+ @class Descriptor
+ @namespace Ember
+ @private
+ @constructor
+ */
+ function Descriptor() {}
+
+ __exports__.Descriptor = Descriptor;// ..........................................................
+ // DEFINING PROPERTIES API
+ //
+
+ function MANDATORY_SETTER_FUNCTION(name) {
+ return function SETTER_FUNCTION(value) {
+ Ember.assert("You must use Ember.set() to set the `" + name + "` property (of " + this + ") to `" + value + "`.", false);
+ };
+ }
+
+ __exports__.MANDATORY_SETTER_FUNCTION = MANDATORY_SETTER_FUNCTION;function DEFAULT_GETTER_FUNCTION(name) {
+ return function GETTER_FUNCTION() {
+ var meta = this['__ember_meta__'];
+ return meta && meta.values[name];
+ };
+ }
+
+ __exports__.DEFAULT_GETTER_FUNCTION = DEFAULT_GETTER_FUNCTION;/**
+ NOTE: This is a low-level method used by other parts of the API. You almost
+ never want to call this method directly. Instead you should use
+ `Ember.mixin()` to define new properties.
+
+ Defines a property on an object. This method works much like the ES5
+ `Object.defineProperty()` method except that it can also accept computed
+ properties and other special descriptors.
+
+ Normally this method takes only three parameters. However if you pass an
+ instance of `Ember.Descriptor` as the third param then you can pass an
+ optional value as the fourth parameter. This is often more efficient than
+ creating new descriptor hashes for each property.
+
+ ## Examples
+
+ ```javascript
+ // ES5 compatible mode
+ Ember.defineProperty(contact, 'firstName', {
+ writable: true,
+ configurable: false,
+ enumerable: true,
+ value: 'Charles'
+ });
+
+ // define a simple property
+ Ember.defineProperty(contact, 'lastName', undefined, 'Jolley');
+
+ // define a computed property
+ Ember.defineProperty(contact, 'fullName', Ember.computed(function() {
+ return this.firstName+' '+this.lastName;
+ }).property('firstName', 'lastName'));
+ ```
+
+ @private
+ @method defineProperty
+ @for Ember
+ @param {Object} obj the object to define this property on. This may be a prototype.
+ @param {String} keyName the name of the property
+ @param {Ember.Descriptor} [desc] an instance of `Ember.Descriptor` (typically a
+ computed property) or an ES5 descriptor.
+ You must provide this or `data` but not both.
+ @param {*} [data] something other than a descriptor, that will
+ become the explicit value of this property.
+ */
+ function defineProperty(obj, keyName, desc, data, meta) {
+ var descs, existingDesc, watching, value;
+
+ if (!meta) meta = metaFor(obj);
+ descs = meta.descs;
+ existingDesc = meta.descs[keyName];
+ var watchEntry = meta.watching[keyName];
+
+ watching = watchEntry !== undefined && watchEntry > 0;
+
+ if (existingDesc instanceof Descriptor) {
+ existingDesc.teardown(obj, keyName);
+ }
+
+ if (desc instanceof Descriptor) {
+ value = desc;
+
+ descs[keyName] = desc;
+
+ if (watching && hasPropertyAccessors) {
+ objectDefineProperty(obj, keyName, {
+ configurable: true,
+ enumerable: true,
+ writable: true,
+ value: undefined // make enumerable
+ });
+ } else {
+ obj[keyName] = undefined; // make enumerable
+ }
+ if (desc.setup) { desc.setup(obj, keyName); }
+ } else {
+ descs[keyName] = undefined; // shadow descriptor in proto
+ if (desc == null) {
+ value = data;
+
+
+ if (watching && hasPropertyAccessors) {
+ meta.values[keyName] = data;
+ objectDefineProperty(obj, keyName, {
+ configurable: true,
+ enumerable: true,
+ set: MANDATORY_SETTER_FUNCTION(keyName),
+ get: DEFAULT_GETTER_FUNCTION(keyName)
+ });
+ } else {
+ obj[keyName] = data;
+ }
+ } else {
+ value = desc;
+
+ // compatibility with ES5
+ objectDefineProperty(obj, keyName, desc);
+ }
+ }
+
+ // if key is being watched, override chains that
+ // were initialized with the prototype
+ if (watching) { overrideChains(obj, keyName, meta); }
+
+ // The `value` passed to the `didDefineProperty` hook is
+ // either the descriptor or data, whichever was passed.
+ if (obj.didDefineProperty) { obj.didDefineProperty(obj, keyName, value); }
+
+ return this;
+ }
+
+ __exports__.defineProperty = defineProperty;
+ });
+enifed("ember-metal/property_events",
+ ["ember-metal/utils","ember-metal/events","ember-metal/observer_set","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var guidFor = __dependency1__.guidFor;
+ var tryFinally = __dependency1__.tryFinally;
+ var sendEvent = __dependency2__.sendEvent;
+ var accumulateListeners = __dependency2__.accumulateListeners;
+ var ObserverSet = __dependency3__["default"];
+
+ var beforeObserverSet = new ObserverSet();
+ var observerSet = new ObserverSet();
+ var deferred = 0;
+
+ // ..........................................................
+ // PROPERTY CHANGES
+ //
+
+ /**
+ This function is called just before an object property is about to change.
+ It will notify any before observers and prepare caches among other things.
+
+ Normally you will not need to call this method directly but if for some
+ reason you can't directly watch a property you can invoke this method
+ manually along with `Ember.propertyDidChange()` which you should call just
+ after the property value changes.
+
+ @method propertyWillChange
+ @for Ember
+ @param {Object} obj The object with the property that will change
+ @param {String} keyName The property key (or path) that will change.
+ @return {void}
+ */
+ function propertyWillChange(obj, keyName) {
+ var m = obj['__ember_meta__'];
+ var watching = (m && m.watching[keyName] > 0) || keyName === 'length';
+ var proto = m && m.proto;
+ var desc = m && m.descs[keyName];
+
+ if (!watching) {
+ return;
+ }
+
+ if (proto === obj) {
+ return;
+ }
+
+ if (desc && desc.willChange) {
+ desc.willChange(obj, keyName);
+ }
+
+ dependentKeysWillChange(obj, keyName, m);
+ chainsWillChange(obj, keyName, m);
+ notifyBeforeObservers(obj, keyName);
+ }
+
+ /**
+ This function is called just after an object property has changed.
+ It will notify any observers and clear caches among other things.
+
+ Normally you will not need to call this method directly but if for some
+ reason you can't directly watch a property you can invoke this method
+ manually along with `Ember.propertyWillChange()` which you should call just
+ before the property value changes.
+
+ @method propertyDidChange
+ @for Ember
+ @param {Object} obj The object with the property that will change
+ @param {String} keyName The property key (or path) that will change.
+ @return {void}
+ */
+ function propertyDidChange(obj, keyName) {
+ var m = obj['__ember_meta__'];
+ var watching = (m && m.watching[keyName] > 0) || keyName === 'length';
+ var proto = m && m.proto;
+ var desc = m && m.descs[keyName];
+
+ if (proto === obj) {
+ return;
+ }
+
+ // shouldn't this mean that we're watching this key?
+ if (desc && desc.didChange) {
+ desc.didChange(obj, keyName);
+ }
+
+ if (!watching && keyName !== 'length') {
+ return;
+ }
+
+ if (m && m.deps && m.deps[keyName]) {
+ dependentKeysDidChange(obj, keyName, m);
+ }
+
+ chainsDidChange(obj, keyName, m, false);
+ notifyObservers(obj, keyName);
+ }
+
+ var WILL_SEEN, DID_SEEN;
+ // called whenever a property is about to change to clear the cache of any dependent keys (and notify those properties of changes, etc...)
+ function dependentKeysWillChange(obj, depKey, meta) {
+ if (obj.isDestroying) { return; }
+
+ var deps;
+ if (meta && meta.deps && (deps = meta.deps[depKey])) {
+ var seen = WILL_SEEN;
+ var top = !seen;
+
+ if (top) {
+ seen = WILL_SEEN = {};
+ }
+
+ iterDeps(propertyWillChange, obj, deps, depKey, seen, meta);
+
+ if (top) {
+ WILL_SEEN = null;
+ }
+ }
+ }
+
+ // called whenever a property has just changed to update dependent keys
+ function dependentKeysDidChange(obj, depKey, meta) {
+ if (obj.isDestroying) { return; }
+
+ var deps;
+ if (meta && meta.deps && (deps = meta.deps[depKey])) {
+ var seen = DID_SEEN;
+ var top = !seen;
+
+ if (top) {
+ seen = DID_SEEN = {};
+ }
+
+ iterDeps(propertyDidChange, obj, deps, depKey, seen, meta);
+
+ if (top) {
+ DID_SEEN = null;
+ }
+ }
+ }
+
+ function keysOf(obj) {
+ var keys = [];
+
+ for (var key in obj) {
+ keys.push(key);
+ }
+
+ return keys;
+ }
+
+ function iterDeps(method, obj, deps, depKey, seen, meta) {
+ var keys, key, i, desc;
+ var guid = guidFor(obj);
+ var current = seen[guid];
+
+ if (!current) {
+ current = seen[guid] = {};
+ }
+
+ if (current[depKey]) {
+ return;
+ }
+
+ current[depKey] = true;
+
+ if (deps) {
+ keys = keysOf(deps);
+ var descs = meta.descs;
+ for (i=0; i 0) {
+ ret = meta.values[keyName];
+ } else {
+ ret = obj[keyName];
+ }
+
+ if (ret === undefined &&
+ 'object' === typeof obj && !(keyName in obj) && 'function' === typeof obj.unknownProperty) {
+ return obj.unknownProperty(keyName);
+ }
+
+ return ret;
+ }
+ };
+
+ /**
+ Normalizes a target/path pair to reflect that actual target/path that should
+ be observed, etc. This takes into account passing in global property
+ paths (i.e. a path beginning with a capital letter not defined on the
+ target).
+
+ @private
+ @method normalizeTuple
+ @for Ember
+ @param {Object} target The current target. May be `null`.
+ @param {String} path A path on the target or a global property path.
+ @return {Array} a temporary array with the normalized target/path pair.
+ */
+ function normalizeTuple(target, path) {
+ var hasThis = pathHasThis(path);
+ var isGlobal = !hasThis && isGlobalPath(path);
+ var key;
+
+ if (!target || isGlobal) target = Ember.lookup;
+ if (hasThis) path = path.slice(5);
+
+ Ember.deprecate(
+ "normalizeTuple will return '"+path+"' as a non-global. This behavior will change in the future (issue #3852)",
+ target === Ember.lookup || !target || hasThis || isGlobal || !isGlobalPath(path+'.')
+ );
+
+ if (target === Ember.lookup) {
+ key = path.match(FIRST_KEY)[0];
+ target = get(target, key);
+ path = path.slice(key.length+1);
+ }
+
+ // must return some kind of path to be valid else other things will break.
+ if (!path || path.length===0) throw new EmberError('Path cannot be empty');
+
+ return [ target, path ];
+ }
+
+ function _getPath(root, path) {
+ var hasThis, parts, tuple, idx, len;
+
+ // If there is no root and path is a key name, return that
+ // property from the global object.
+ // E.g. get('Ember') -> Ember
+ if (root === null && !isPath(path)) {
+ return get(Ember.lookup, path);
+ }
+
+ // detect complicated paths and normalize them
+ hasThis = pathHasThis(path);
+
+ if (!root || hasThis) {
+ tuple = normalizeTuple(root, path);
+ root = tuple[0];
+ path = tuple[1];
+ tuple.length = 0;
+ }
+
+ parts = path.split(".");
+ len = parts.length;
+ for (idx = 0; root != null && idx < len; idx++) {
+ root = get(root, parts[idx], true);
+ if (root && root.isDestroyed) { return undefined; }
+ }
+ return root;
+ }
+
+ function getWithDefault(root, key, defaultValue) {
+ var value = get(root, key);
+
+ if (value === undefined) { return defaultValue; }
+ return value;
+ }
+
+ __exports__.getWithDefault = getWithDefault;__exports__["default"] = get;
+ __exports__.get = get;
+ __exports__.normalizeTuple = normalizeTuple;
+ __exports__._getPath = _getPath;
+ });
+enifed("ember-metal/property_set",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/property_events","ember-metal/properties","ember-metal/error","ember-metal/path_cache","ember-metal/platform","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ var getPath = __dependency2__._getPath;
+ var propertyWillChange = __dependency3__.propertyWillChange;
+ var propertyDidChange = __dependency3__.propertyDidChange;
+ var defineProperty = __dependency4__.defineProperty;
+ var EmberError = __dependency5__["default"];
+ var isPath = __dependency6__.isPath;
+ var hasPropertyAccessors = __dependency7__.hasPropertyAccessors;
+
+ var IS_GLOBAL = /^([A-Z$]|([0-9][A-Z$]))/;
+
+ /**
+ Sets the value of a property on an object, respecting computed properties
+ and notifying observers and other listeners of the change. If the
+ property is not defined but the object implements the `setUnknownProperty`
+ method then that will be invoked as well.
+
+ @method set
+ @for Ember
+ @param {Object} obj The object to modify.
+ @param {String} keyName The property key to set
+ @param {Object} value The value to set
+ @return {Object} the passed value.
+ */
+ var set = function set(obj, keyName, value, tolerant) {
+ if (typeof obj === 'string') {
+ Ember.assert("Path '" + obj + "' must be global if no obj is given.", IS_GLOBAL.test(obj));
+ value = keyName;
+ keyName = obj;
+ obj = null;
+ }
+
+ Ember.assert("Cannot call set with "+ keyName +" key.", !!keyName);
+
+ if (!obj) {
+ return setPath(obj, keyName, value, tolerant);
+ }
+
+ var meta = obj['__ember_meta__'];
+ var desc = meta && meta.descs[keyName];
+ var isUnknown, currentValue;
+
+ if (desc === undefined && isPath(keyName)) {
+ return setPath(obj, keyName, value, tolerant);
+ }
+
+ Ember.assert("You need to provide an object and key to `set`.", !!obj && keyName !== undefined);
+ Ember.assert('calling set on destroyed object', !obj.isDestroyed);
+
+ if (desc !== undefined) {
+ desc.set(obj, keyName, value);
+ } else {
+
+ if (typeof obj === 'object' && obj !== null && value !== undefined && obj[keyName] === value) {
+ return value;
+ }
+
+ isUnknown = 'object' === typeof obj && !(keyName in obj);
+
+ // setUnknownProperty is called if `obj` is an object,
+ // the property does not already exist, and the
+ // `setUnknownProperty` method exists on the object
+ if (isUnknown && 'function' === typeof obj.setUnknownProperty) {
+ obj.setUnknownProperty(keyName, value);
+ } else if (meta && meta.watching[keyName] > 0) {
+ if (meta.proto !== obj) {
+
+ if (hasPropertyAccessors) {
+ currentValue = meta.values[keyName];
+ } else {
+ currentValue = obj[keyName];
+ }
+ }
+ // only trigger a change if the value has changed
+ if (value !== currentValue) {
+ propertyWillChange(obj, keyName);
+
+ if (hasPropertyAccessors) {
+ if (
+ (currentValue === undefined && !(keyName in obj)) ||
+ !Object.prototype.propertyIsEnumerable.call(obj, keyName)
+ ) {
+ defineProperty(obj, keyName, null, value); // setup mandatory setter
+ } else {
+ meta.values[keyName] = value;
+ }
+ } else {
+ obj[keyName] = value;
+ }
+ propertyDidChange(obj, keyName);
+ }
+ } else {
+ obj[keyName] = value;
+ }
+ }
+ return value;
+ };
+
+ function setPath(root, path, value, tolerant) {
+ var keyName;
+
+ // get the last part of the path
+ keyName = path.slice(path.lastIndexOf('.') + 1);
+
+ // get the first part of the part
+ path = (path === keyName) ? keyName : path.slice(0, path.length-(keyName.length+1));
+
+ // unless the path is this, look up the first part to
+ // get the root
+ if (path !== 'this') {
+ root = getPath(root, path);
+ }
+
+ if (!keyName || keyName.length === 0) {
+ throw new EmberError('Property set failed: You passed an empty path');
+ }
+
+ if (!root) {
+ if (tolerant) { return; }
+ else { throw new EmberError('Property set failed: object in path "'+path+'" could not be found or was destroyed.'); }
+ }
+
+ return set(root, keyName, value);
+ }
+
+ /**
+ Error-tolerant form of `Ember.set`. Will not blow up if any part of the
+ chain is `undefined`, `null`, or destroyed.
+
+ This is primarily used when syncing bindings, which may try to update after
+ an object has been destroyed.
+
+ @method trySet
+ @for Ember
+ @param {Object} obj The object to modify.
+ @param {String} path The property path to set
+ @param {Object} value The value to set
+ */
+ function trySet(root, path, value) {
+ return set(root, path, value, true);
+ }
+
+ __exports__.trySet = trySet;__exports__.set = set;
+ });
+enifed("ember-metal/run_loop",
+ ["ember-metal/core","ember-metal/utils","ember-metal/array","ember-metal/property_events","backburner","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ var apply = __dependency2__.apply;
+ var GUID_KEY = __dependency2__.GUID_KEY;
+ var indexOf = __dependency3__.indexOf;
+ var beginPropertyChanges = __dependency4__.beginPropertyChanges;
+ var endPropertyChanges = __dependency4__.endPropertyChanges;
+ var Backburner = __dependency5__["default"];
+
+ function onBegin(current) {
+ run.currentRunLoop = current;
+ }
+
+ function onEnd(current, next) {
+ run.currentRunLoop = next;
+ }
+
+ // ES6TODO: should Backburner become es6?
+ var backburner = new Backburner(['sync', 'actions', 'destroy'], {
+ GUID_KEY: GUID_KEY,
+ sync: {
+ before: beginPropertyChanges,
+ after: endPropertyChanges
+ },
+ defaultQueue: 'actions',
+ onBegin: onBegin,
+ onEnd: onEnd,
+ onErrorTarget: Ember,
+ onErrorMethod: 'onerror'
+ });
+ var slice = [].slice;
+
+ // ..........................................................
+ // run - this is ideally the only public API the dev sees
+ //
+
+ /**
+ Runs the passed target and method inside of a RunLoop, ensuring any
+ deferred actions including bindings and views updates are flushed at the
+ end.
+
+ Normally you should not need to invoke this method yourself. However if
+ you are implementing raw event handlers when interfacing with other
+ libraries or plugins, you should probably wrap all of your code inside this
+ call.
+
+ ```javascript
+ run(function() {
+ // code to be executed within a RunLoop
+ });
+ ```
+
+ @class run
+ @namespace Ember
+ @static
+ @constructor
+ @param {Object} [target] target of method to call
+ @param {Function|String} method Method to invoke.
+ May be a function or a string. If you pass a string
+ then it will be looked up on the passed target.
+ @param {Object} [args*] Any additional arguments you wish to pass to the method.
+ @return {Object} return value from invoking the passed function.
+ */
+ __exports__["default"] = run;
+ function run() {
+ return backburner.run.apply(backburner, arguments);
+ }
+
+ /**
+ If no run-loop is present, it creates a new one. If a run loop is
+ present it will queue itself to run on the existing run-loops action
+ queue.
+
+ Please note: This is not for normal usage, and should be used sparingly.
+
+ If invoked when not within a run loop:
+
+ ```javascript
+ run.join(function() {
+ // creates a new run-loop
+ });
+ ```
+
+ Alternatively, if called within an existing run loop:
+
+ ```javascript
+ run(function() {
+ // creates a new run-loop
+ run.join(function() {
+ // joins with the existing run-loop, and queues for invocation on
+ // the existing run-loops action queue.
+ });
+ });
+ ```
+
+ @method join
+ @namespace Ember
+ @param {Object} [target] target of method to call
+ @param {Function|String} method Method to invoke.
+ May be a function or a string. If you pass a string
+ then it will be looked up on the passed target.
+ @param {Object} [args*] Any additional arguments you wish to pass to the method.
+ @return {Object} Return value from invoking the passed function. Please note,
+ when called within an existing loop, no return value is possible.
+ */
+ run.join = function() {
+ return backburner.join.apply(backburner, arguments);
+ };
+
+ /**
+ Allows you to specify which context to call the specified function in while
+ adding the execution of that function to the Ember run loop. This ability
+ makes this method a great way to asynchronusly integrate third-party libraries
+ into your Ember application.
+
+ `run.bind` takes two main arguments, the desired context and the function to
+ invoke in that context. Any additional arguments will be supplied as arguments
+ to the function that is passed in.
+
+ Let's use the creation of a TinyMCE component as an example. Currently,
+ TinyMCE provides a setup configuration option we can use to do some processing
+ after the TinyMCE instance is initialized but before it is actually rendered.
+ We can use that setup option to do some additional setup for our component.
+ The component itself could look something like the following:
+
+ ```javascript
+ App.RichTextEditorComponent = Ember.Component.extend({
+ initializeTinyMCE: function(){
+ tinymce.init({
+ selector: '#' + this.$().prop('id'),
+ setup: Ember.run.bind(this, this.setupEditor)
+ });
+ }.on('didInsertElement'),
+
+ setupEditor: function(editor) {
+ this.set('editor', editor);
+ editor.on('change', function(){ console.log('content changed!')} );
+ }
+ });
+ ```
+
+ In this example, we use Ember.run.bind to bind the setupEditor message to the
+ context of the App.RichTextEditorComponent and to have the invocation of that
+ method be safely handled and excuted by the Ember run loop.
+
+ @method bind
+ @namespace Ember
+ @param {Object} [target] target of method to call
+ @param {Function|String} method Method to invoke.
+ May be a function or a string. If you pass a string
+ then it will be looked up on the passed target.
+ @param {Object} [args*] Any additional arguments you wish to pass to the method.
+ @return {Function} returns a new function that will always have a particular context
+ @since 1.4.0
+ */
+ run.bind = function(target, method /* args */) {
+ var args = slice.call(arguments);
+ return function() {
+ return run.join.apply(run, args.concat(slice.call(arguments)));
+ };
+ };
+
+ run.backburner = backburner;
+ run.currentRunLoop = null;
+ run.queues = backburner.queueNames;
+
+ /**
+ Begins a new RunLoop. Any deferred actions invoked after the begin will
+ be buffered until you invoke a matching call to `run.end()`. This is
+ a lower-level way to use a RunLoop instead of using `run()`.
+
+ ```javascript
+ run.begin();
+ // code to be executed within a RunLoop
+ run.end();
+ ```
+
+ @method begin
+ @return {void}
+ */
+ run.begin = function() {
+ backburner.begin();
+ };
+
+ /**
+ Ends a RunLoop. This must be called sometime after you call
+ `run.begin()` to flush any deferred actions. This is a lower-level way
+ to use a RunLoop instead of using `run()`.
+
+ ```javascript
+ run.begin();
+ // code to be executed within a RunLoop
+ run.end();
+ ```
+
+ @method end
+ @return {void}
+ */
+ run.end = function() {
+ backburner.end();
+ };
+
+ /**
+ Array of named queues. This array determines the order in which queues
+ are flushed at the end of the RunLoop. You can define your own queues by
+ simply adding the queue name to this array. Normally you should not need
+ to inspect or modify this property.
+
+ @property queues
+ @type Array
+ @default ['sync', 'actions', 'destroy']
+ */
+
+ /**
+ Adds the passed target/method and any optional arguments to the named
+ queue to be executed at the end of the RunLoop. If you have not already
+ started a RunLoop when calling this method one will be started for you
+ automatically.
+
+ At the end of a RunLoop, any methods scheduled in this way will be invoked.
+ Methods will be invoked in an order matching the named queues defined in
+ the `run.queues` property.
+
+ ```javascript
+ run.schedule('sync', this, function() {
+ // this will be executed in the first RunLoop queue, when bindings are synced
+ console.log("scheduled on sync queue");
+ });
+
+ run.schedule('actions', this, function() {
+ // this will be executed in the 'actions' queue, after bindings have synced.
+ console.log("scheduled on actions queue");
+ });
+
+ // Note the functions will be run in order based on the run queues order.
+ // Output would be:
+ // scheduled on sync queue
+ // scheduled on actions queue
+ ```
+
+ @method schedule
+ @param {String} queue The name of the queue to schedule against.
+ Default queues are 'sync' and 'actions'
+ @param {Object} [target] target object to use as the context when invoking a method.
+ @param {String|Function} method The method to invoke. If you pass a string it
+ will be resolved on the target object at the time the scheduled item is
+ invoked allowing you to change the target function.
+ @param {Object} [arguments*] Optional arguments to be passed to the queued method.
+ @return {void}
+ */
+ run.schedule = function(queue, target, method) {
+ checkAutoRun();
+ backburner.schedule.apply(backburner, arguments);
+ };
+
+ // Used by global test teardown
+ run.hasScheduledTimers = function() {
+ return backburner.hasTimers();
+ };
+
+ // Used by global test teardown
+ run.cancelTimers = function () {
+ backburner.cancelTimers();
+ };
+
+ /**
+ Immediately flushes any events scheduled in the 'sync' queue. Bindings
+ use this queue so this method is a useful way to immediately force all
+ bindings in the application to sync.
+
+ You should call this method anytime you need any changed state to propagate
+ throughout the app immediately without repainting the UI (which happens
+ in the later 'render' queue added by the `ember-views` package).
+
+ ```javascript
+ run.sync();
+ ```
+
+ @method sync
+ @return {void}
+ */
+ run.sync = function() {
+ if (backburner.currentInstance) {
+ backburner.currentInstance.queues.sync.flush();
+ }
+ };
+
+ /**
+ Invokes the passed target/method and optional arguments after a specified
+ period of time. The last parameter of this method must always be a number
+ of milliseconds.
+
+ You should use this method whenever you need to run some action after a
+ period of time instead of using `setTimeout()`. This method will ensure that
+ items that expire during the same script execution cycle all execute
+ together, which is often more efficient than using a real setTimeout.
+
+ ```javascript
+ run.later(myContext, function() {
+ // code here will execute within a RunLoop in about 500ms with this == myContext
+ }, 500);
+ ```
+
+ @method later
+ @param {Object} [target] target of method to invoke
+ @param {Function|String} method The method to invoke.
+ If you pass a string it will be resolved on the
+ target at the time the method is invoked.
+ @param {Object} [args*] Optional arguments to pass to the timeout.
+ @param {Number} wait Number of milliseconds to wait.
+ @return {Object} Timer information for use in cancelling, see `run.cancel`.
+ */
+ run.later = function(/*target, method*/) {
+ return backburner.later.apply(backburner, arguments);
+ };
+
+ /**
+ Schedule a function to run one time during the current RunLoop. This is equivalent
+ to calling `scheduleOnce` with the "actions" queue.
+
+ @method once
+ @param {Object} [target] The target of the method to invoke.
+ @param {Function|String} method The method to invoke.
+ If you pass a string it will be resolved on the
+ target at the time the method is invoked.
+ @param {Object} [args*] Optional arguments to pass to the timeout.
+ @return {Object} Timer information for use in cancelling, see `run.cancel`.
+ */
+ run.once = function(/*target, method */) {
+ checkAutoRun();
+ var length = arguments.length;
+ var args = new Array(length);
+ args[0] = 'actions';
+ for (var i = 0; i < length; i++) {
+ args[i + 1] = arguments[i];
+ }
+ return apply(backburner, backburner.scheduleOnce, args);
+ };
+
+ /**
+ Schedules a function to run one time in a given queue of the current RunLoop.
+ Calling this method with the same queue/target/method combination will have
+ no effect (past the initial call).
+
+ Note that although you can pass optional arguments these will not be
+ considered when looking for duplicates. New arguments will replace previous
+ calls.
+
+ ```javascript
+ run(function() {
+ var sayHi = function() { console.log('hi'); }
+ run.scheduleOnce('afterRender', myContext, sayHi);
+ run.scheduleOnce('afterRender', myContext, sayHi);
+ // sayHi will only be executed once, in the afterRender queue of the RunLoop
+ });
+ ```
+
+ Also note that passing an anonymous function to `run.scheduleOnce` will
+ not prevent additional calls with an identical anonymous function from
+ scheduling the items multiple times, e.g.:
+
+ ```javascript
+ function scheduleIt() {
+ run.scheduleOnce('actions', myContext, function() { console.log("Closure"); });
+ }
+ scheduleIt();
+ scheduleIt();
+ // "Closure" will print twice, even though we're using `run.scheduleOnce`,
+ // because the function we pass to it is anonymous and won't match the
+ // previously scheduled operation.
+ ```
+
+ Available queues, and their order, can be found at `run.queues`
+
+ @method scheduleOnce
+ @param {String} [queue] The name of the queue to schedule against. Default queues are 'sync' and 'actions'.
+ @param {Object} [target] The target of the method to invoke.
+ @param {Function|String} method The method to invoke.
+ If you pass a string it will be resolved on the
+ target at the time the method is invoked.
+ @param {Object} [args*] Optional arguments to pass to the timeout.
+ @return {Object} Timer information for use in cancelling, see `run.cancel`.
+ */
+ run.scheduleOnce = function(/*queue, target, method*/) {
+ checkAutoRun();
+ return backburner.scheduleOnce.apply(backburner, arguments);
+ };
+
+ /**
+ Schedules an item to run from within a separate run loop, after
+ control has been returned to the system. This is equivalent to calling
+ `run.later` with a wait time of 1ms.
+
+ ```javascript
+ run.next(myContext, function() {
+ // code to be executed in the next run loop,
+ // which will be scheduled after the current one
+ });
+ ```
+
+ Multiple operations scheduled with `run.next` will coalesce
+ into the same later run loop, along with any other operations
+ scheduled by `run.later` that expire right around the same
+ time that `run.next` operations will fire.
+
+ Note that there are often alternatives to using `run.next`.
+ For instance, if you'd like to schedule an operation to happen
+ after all DOM element operations have completed within the current
+ run loop, you can make use of the `afterRender` run loop queue (added
+ by the `ember-views` package, along with the preceding `render` queue
+ where all the DOM element operations happen). Example:
+
+ ```javascript
+ App.MyCollectionView = Ember.CollectionView.extend({
+ didInsertElement: function() {
+ run.scheduleOnce('afterRender', this, 'processChildElements');
+ },
+ processChildElements: function() {
+ // ... do something with collectionView's child view
+ // elements after they've finished rendering, which
+ // can't be done within the CollectionView's
+ // `didInsertElement` hook because that gets run
+ // before the child elements have been added to the DOM.
+ }
+ });
+ ```
+
+ One benefit of the above approach compared to using `run.next` is
+ that you will be able to perform DOM/CSS operations before unprocessed
+ elements are rendered to the screen, which may prevent flickering or
+ other artifacts caused by delaying processing until after rendering.
+
+ The other major benefit to the above approach is that `run.next`
+ introduces an element of non-determinism, which can make things much
+ harder to test, due to its reliance on `setTimeout`; it's much harder
+ to guarantee the order of scheduled operations when they are scheduled
+ outside of the current run loop, i.e. with `run.next`.
+
+ @method next
+ @param {Object} [target] target of method to invoke
+ @param {Function|String} method The method to invoke.
+ If you pass a string it will be resolved on the
+ target at the time the method is invoked.
+ @param {Object} [args*] Optional arguments to pass to the timeout.
+ @return {Object} Timer information for use in cancelling, see `run.cancel`.
+ */
+ run.next = function() {
+ var args = slice.call(arguments);
+ args.push(1);
+ return apply(backburner, backburner.later, args);
+ };
+
+ /**
+ Cancels a scheduled item. Must be a value returned by `run.later()`,
+ `run.once()`, `run.next()`, `run.debounce()`, or
+ `run.throttle()`.
+
+ ```javascript
+ var runNext = run.next(myContext, function() {
+ // will not be executed
+ });
+ run.cancel(runNext);
+
+ var runLater = run.later(myContext, function() {
+ // will not be executed
+ }, 500);
+ run.cancel(runLater);
+
+ var runOnce = run.once(myContext, function() {
+ // will not be executed
+ });
+ run.cancel(runOnce);
+
+ var throttle = run.throttle(myContext, function() {
+ // will not be executed
+ }, 1, false);
+ run.cancel(throttle);
+
+ var debounce = run.debounce(myContext, function() {
+ // will not be executed
+ }, 1);
+ run.cancel(debounce);
+
+ var debounceImmediate = run.debounce(myContext, function() {
+ // will be executed since we passed in true (immediate)
+ }, 100, true);
+ // the 100ms delay until this method can be called again will be cancelled
+ run.cancel(debounceImmediate);
+ ```
+
+ @method cancel
+ @param {Object} timer Timer object to cancel
+ @return {Boolean} true if cancelled or false/undefined if it wasn't found
+ */
+ run.cancel = function(timer) {
+ return backburner.cancel(timer);
+ };
+
+ /**
+ Delay calling the target method until the debounce period has elapsed
+ with no additional debounce calls. If `debounce` is called again before
+ the specified time has elapsed, the timer is reset and the entire period
+ must pass again before the target method is called.
+
+ This method should be used when an event may be called multiple times
+ but the action should only be called once when the event is done firing.
+ A common example is for scroll events where you only want updates to
+ happen once scrolling has ceased.
+
+ ```javascript
+ var myFunc = function() { console.log(this.name + ' ran.'); };
+ var myContext = {name: 'debounce'};
+
+ run.debounce(myContext, myFunc, 150);
+
+ // less than 150ms passes
+
+ run.debounce(myContext, myFunc, 150);
+
+ // 150ms passes
+ // myFunc is invoked with context myContext
+ // console logs 'debounce ran.' one time.
+ ```
+
+ Immediate allows you to run the function immediately, but debounce
+ other calls for this function until the wait time has elapsed. If
+ `debounce` is called again before the specified time has elapsed,
+ the timer is reset and the entire period must pass again before
+ the method can be called again.
+
+ ```javascript
+ var myFunc = function() { console.log(this.name + ' ran.'); };
+ var myContext = {name: 'debounce'};
+
+ run.debounce(myContext, myFunc, 150, true);
+
+ // console logs 'debounce ran.' one time immediately.
+ // 100ms passes
+
+ run.debounce(myContext, myFunc, 150, true);
+
+ // 150ms passes and nothing else is logged to the console and
+ // the debouncee is no longer being watched
+
+ run.debounce(myContext, myFunc, 150, true);
+
+ // console logs 'debounce ran.' one time immediately.
+ // 150ms passes and nothing else is logged to the console and
+ // the debouncee is no longer being watched
+
+ ```
+
+ @method debounce
+ @param {Object} [target] target of method to invoke
+ @param {Function|String} method The method to invoke.
+ May be a function or a string. If you pass a string
+ then it will be looked up on the passed target.
+ @param {Object} [args*] Optional arguments to pass to the timeout.
+ @param {Number} wait Number of milliseconds to wait.
+ @param {Boolean} immediate Trigger the function on the leading instead
+ of the trailing edge of the wait interval. Defaults to false.
+ @return {Array} Timer information for use in cancelling, see `run.cancel`.
+ */
+ run.debounce = function() {
+ return backburner.debounce.apply(backburner, arguments);
+ };
+
+ /**
+ Ensure that the target method is never called more frequently than
+ the specified spacing period. The target method is called immediately.
+
+ ```javascript
+ var myFunc = function() { console.log(this.name + ' ran.'); };
+ var myContext = {name: 'throttle'};
+
+ run.throttle(myContext, myFunc, 150);
+ // myFunc is invoked with context myContext
+ // console logs 'throttle ran.'
+
+ // 50ms passes
+ run.throttle(myContext, myFunc, 150);
+
+ // 50ms passes
+ run.throttle(myContext, myFunc, 150);
+
+ // 150ms passes
+ run.throttle(myContext, myFunc, 150);
+ // myFunc is invoked with context myContext
+ // console logs 'throttle ran.'
+ ```
+
+ @method throttle
+ @param {Object} [target] target of method to invoke
+ @param {Function|String} method The method to invoke.
+ May be a function or a string. If you pass a string
+ then it will be looked up on the passed target.
+ @param {Object} [args*] Optional arguments to pass to the timeout.
+ @param {Number} spacing Number of milliseconds to space out requests.
+ @param {Boolean} immediate Trigger the function on the leading instead
+ of the trailing edge of the wait interval. Defaults to true.
+ @return {Array} Timer information for use in cancelling, see `run.cancel`.
+ */
+ run.throttle = function() {
+ return backburner.throttle.apply(backburner, arguments);
+ };
+
+ // Make sure it's not an autorun during testing
+ function checkAutoRun() {
+ if (!run.currentRunLoop) {
+ Ember.assert("You have turned on testing mode, which disabled the run-loop's autorun." +
+ " You will need to wrap any code with asynchronous side-effects in a run", !Ember.testing);
+ }
+ }
+
+ /**
+ Add a new named queue after the specified queue.
+
+ The queue to add will only be added once.
+
+ @method _addQueue
+ @param {String} name the name of the queue to add.
+ @param {String} after the name of the queue to add after.
+ @private
+ */
+ run._addQueue = function(name, after) {
+ if (indexOf.call(run.queues, name) === -1) {
+ run.queues.splice(indexOf.call(run.queues, after)+1, 0, name);
+ }
+ };
+ });
+enifed("ember-metal/set_properties",
+ ["ember-metal/property_events","ember-metal/property_set","ember-metal/keys","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var changeProperties = __dependency1__.changeProperties;
+ var set = __dependency2__.set;
+ var keys = __dependency3__["default"];
+
+ /**
+ Set a list of properties on an object. These properties are set inside
+ a single `beginPropertyChanges` and `endPropertyChanges` batch, so
+ observers will be buffered.
+
+ ```javascript
+ var anObject = Ember.Object.create();
+
+ anObject.setProperties({
+ firstName: 'Stanley',
+ lastName: 'Stuart',
+ age: 21
+ });
+ ```
+
+ @method setProperties
+ @param obj
+ @param {Object} properties
+ @return obj
+ */
+ __exports__["default"] = function setProperties(obj, properties) {
+ if (!properties || typeof properties !== "object") { return obj; }
+ changeProperties(function() {
+ var props = keys(properties);
+ var propertyName;
+
+ for (var i = 0, l = props.length; i < l; i++) {
+ propertyName = props[i];
+
+ set(obj, propertyName, properties[propertyName]);
+ }
+ });
+ return obj;
+ }
+ });
+enifed("ember-metal/streams/simple",
+ ["ember-metal/merge","ember-metal/streams/stream","ember-metal/platform","ember-metal/streams/utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ var merge = __dependency1__["default"];
+ var Stream = __dependency2__["default"];
+ var create = __dependency3__.create;
+ var read = __dependency4__.read;
+ var isStream = __dependency4__.isStream;
+
+ function SimpleStream(source) {
+ this.init();
+ this.source = source;
+
+ if (isStream(source)) {
+ source.subscribe(this._didChange, this);
+ }
+ }
+
+ SimpleStream.prototype = create(Stream.prototype);
+
+ merge(SimpleStream.prototype, {
+ valueFn: function() {
+ return read(this.source);
+ },
+
+ setValue: function(value) {
+ var source = this.source;
+
+ if (isStream(source)) {
+ source.setValue(value);
+ }
+ },
+
+ setSource: function(nextSource) {
+ var prevSource = this.source;
+ if (nextSource !== prevSource) {
+ if (isStream(prevSource)) {
+ prevSource.unsubscribe(this._didChange, this);
+ }
+
+ if (isStream(nextSource)) {
+ nextSource.subscribe(this._didChange, this);
+ }
+
+ this.source = nextSource;
+ this.notify();
+ }
+ },
+
+ _didChange: function() {
+ this.notify();
+ },
+
+ _super$destroy: Stream.prototype.destroy,
+
+ destroy: function() {
+ if (this._super$destroy()) {
+ if (isStream(this.source)) {
+ this.source.unsubscribe(this._didChange, this);
+ }
+ this.source = undefined;
+ return true;
+ }
+ }
+ });
+
+ __exports__["default"] = SimpleStream;
+ });
+enifed("ember-metal/streams/stream",
+ ["ember-metal/platform","ember-metal/path_cache","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var create = __dependency1__.create;
+ var getFirstKey = __dependency2__.getFirstKey;
+ var getTailPath = __dependency2__.getTailPath;
+
+ function Stream(fn) {
+ this.init();
+ this.valueFn = fn;
+ }
+
+ Stream.prototype = {
+ isStream: true,
+
+ init: function() {
+ this.state = 'dirty';
+ this.cache = undefined;
+ this.subscribers = undefined;
+ this.children = undefined;
+ this._label = undefined;
+ },
+
+ get: function(path) {
+ var firstKey = getFirstKey(path);
+ var tailPath = getTailPath(path);
+
+ if (this.children === undefined) {
+ this.children = create(null);
+ }
+
+ var keyStream = this.children[firstKey];
+
+ if (keyStream === undefined) {
+ keyStream = this._makeChildStream(firstKey, path);
+ this.children[firstKey] = keyStream;
+ }
+
+ if (tailPath === undefined) {
+ return keyStream;
+ } else {
+ return keyStream.get(tailPath);
+ }
+ },
+
+ value: function() {
+ if (this.state === 'clean') {
+ return this.cache;
+ } else if (this.state === 'dirty') {
+ this.state = 'clean';
+ return this.cache = this.valueFn();
+ }
+ // TODO: Ensure value is never called on a destroyed stream
+ // so that we can uncomment this assertion.
+ //
+ // Ember.assert("Stream error: value was called in an invalid state: " + this.state);
+ },
+
+ valueFn: function() {
+ throw new Error("Stream error: valueFn not implemented");
+ },
+
+ setValue: function() {
+ throw new Error("Stream error: setValue not implemented");
+ },
+
+ notify: function() {
+ this.notifyExcept();
+ },
+
+ notifyExcept: function(callbackToSkip, contextToSkip) {
+ if (this.state === 'clean') {
+ this.state = 'dirty';
+ this._notifySubscribers(callbackToSkip, contextToSkip);
+ }
+ },
+
+ subscribe: function(callback, context) {
+ if (this.subscribers === undefined) {
+ this.subscribers = [callback, context];
+ } else {
+ this.subscribers.push(callback, context);
+ }
+ },
+
+ unsubscribe: function(callback, context) {
+ var subscribers = this.subscribers;
+
+ if (subscribers !== undefined) {
+ for (var i = 0, l = subscribers.length; i < l; i += 2) {
+ if (subscribers[i] === callback && subscribers[i+1] === context) {
+ subscribers.splice(i, 2);
+ return;
+ }
+ }
+ }
+ },
+
+ _notifySubscribers: function(callbackToSkip, contextToSkip) {
+ var subscribers = this.subscribers;
+
+ if (subscribers !== undefined) {
+ for (var i = 0, l = subscribers.length; i < l; i += 2) {
+ var callback = subscribers[i];
+ var context = subscribers[i+1];
+
+ if (callback === callbackToSkip && context === contextToSkip) {
+ continue;
+ }
+
+ if (context === undefined) {
+ callback(this);
+ } else {
+ callback.call(context, this);
+ }
+ }
+ }
+ },
+
+ destroy: function() {
+ if (this.state !== 'destroyed') {
+ this.state = 'destroyed';
+
+ var children = this.children;
+ for (var key in children) {
+ children[key].destroy();
+ }
+
+ return true;
+ }
+ },
+
+ isGlobal: function() {
+ var stream = this;
+ while (stream !== undefined) {
+ if (stream._isRoot) {
+ return stream._isGlobal;
+ }
+ stream = stream.source;
+ }
+ }
+ };
+
+ __exports__["default"] = Stream;
+ });
+enifed("ember-metal/streams/stream_binding",
+ ["ember-metal/platform","ember-metal/merge","ember-metal/run_loop","ember-metal/streams/stream","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ var create = __dependency1__.create;
+ var merge = __dependency2__["default"];
+ var run = __dependency3__["default"];
+ var Stream = __dependency4__["default"];
+
+ function StreamBinding(stream) {
+ Ember.assert("StreamBinding error: tried to bind to object that is not a stream", stream && stream.isStream);
+
+ this.init();
+ this.stream = stream;
+ this.senderCallback = undefined;
+ this.senderContext = undefined;
+ this.senderValue = undefined;
+
+ stream.subscribe(this._onNotify, this);
+ }
+
+ StreamBinding.prototype = create(Stream.prototype);
+
+ merge(StreamBinding.prototype, {
+ valueFn: function() {
+ return this.stream.value();
+ },
+
+ _onNotify: function() {
+ this._scheduleSync(undefined, undefined, this);
+ },
+
+ setValue: function(value, callback, context) {
+ this._scheduleSync(value, callback, context);
+ },
+
+ _scheduleSync: function(value, callback, context) {
+ if (this.senderCallback === undefined && this.senderContext === undefined) {
+ this.senderCallback = callback;
+ this.senderContext = context;
+ this.senderValue = value;
+ run.schedule('sync', this, this._sync);
+ } else if (this.senderContext !== this) {
+ this.senderCallback = callback;
+ this.senderContext = context;
+ this.senderValue = value;
+ }
+ },
+
+ _sync: function() {
+ if (this.state === 'destroyed') {
+ return;
+ }
+
+ if (this.senderContext !== this) {
+ this.stream.setValue(this.senderValue);
+ }
+
+ var senderCallback = this.senderCallback;
+ var senderContext = this.senderContext;
+ this.senderCallback = undefined;
+ this.senderContext = undefined;
+ this.senderValue = undefined;
+
+ // Force StreamBindings to always notify
+ this.state = 'clean';
+
+ this.notifyExcept(senderCallback, senderContext);
+ },
+
+ _super$destroy: Stream.prototype.destroy,
+
+ destroy: function() {
+ if (this._super$destroy()) {
+ this.stream.unsubscribe(this._onNotify, this);
+ return true;
+ }
+ }
+ });
+
+ __exports__["default"] = StreamBinding;
+ });
+enifed("ember-metal/streams/utils",
+ ["./stream","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var Stream = __dependency1__["default"];
+
+ /**
+ Check whether an object is a stream or not
+
+ @private
+ @function isStream
+ @param {Object|Stream} object object to check whether it is a stream
+ @return {Boolean} `true` if the object is a stream, `false` otherwise
+ */
+ function isStream(object) {
+ return object && object.isStream;
+ }
+
+ __exports__.isStream = isStream;/**
+ A method of subscribing to a stream which is safe for use with a non-stream
+ object. If a non-stream object is passed, the function does nothing.
+
+ @private
+ @function subscribe
+ @param {Object|Stream} object object or stream to potentially subscribe to
+ @param {Function} callback function to run when stream value changes
+ @param {Object} [context] the callback will be executed with this context if it
+ is provided
+ */
+ function subscribe(object, callback, context) {
+ if (object && object.isStream) {
+ object.subscribe(callback, context);
+ }
+ }
+
+ __exports__.subscribe = subscribe;/**
+ A method of unsubscribing from a stream which is safe for use with a non-stream
+ object. If a non-stream object is passed, the function does nothing.
+
+ @private
+ @function unsubscribe
+ @param {Object|Stream} object object or stream to potentially unsubscribe from
+ @param {Function} callback function originally passed to `subscribe()`
+ @param {Object} [context] object originally passed to `subscribe()`
+ */
+ function unsubscribe(object, callback, context) {
+ if (object && object.isStream) {
+ object.unsubscribe(callback, context);
+ }
+ }
+
+ __exports__.unsubscribe = unsubscribe;/**
+ Retrieve the value of a stream, or in the case a non-stream object is passed,
+ return the object itself.
+
+ @private
+ @function read
+ @param {Object|Stream} object object to return the value of
+ @return the stream's current value, or the non-stream object itself
+ */
+ function read(object) {
+ if (object && object.isStream) {
+ return object.value();
+ } else {
+ return object;
+ }
+ }
+
+ __exports__.read = read;/**
+ Map an array, replacing any streams with their values.
+
+ @private
+ @function readArray
+ @param {Array} array The array to read values from
+ @return {Array} a new array of the same length with the values of non-stream
+ objects mapped from their original positions untouched, and
+ the values of stream objects retaining their original position
+ and replaced with the stream's current value.
+ */
+ function readArray(array) {
+ var length = array.length;
+ var ret = new Array(length);
+ for (var i = 0; i < length; i++) {
+ ret[i] = read(array[i]);
+ }
+ return ret;
+ }
+
+ __exports__.readArray = readArray;/**
+ Map a hash, replacing any stream property values with the current value of that
+ stream.
+
+ @private
+ @function readHash
+ @param {Object} object The hash to read keys and values from
+ @return {Object} a new object with the same keys as the passed object. The
+ property values in the new object are the original values in
+ the case of non-stream objects, and the streams' current
+ values in the case of stream objects.
+ */
+ function readHash(object) {
+ var ret = {};
+ for (var key in object) {
+ ret[key] = read(object[key]);
+ }
+ return ret;
+ }
+
+ __exports__.readHash = readHash;/**
+ Check whether an array contains any stream values
+
+ @private
+ @function scanArray
+ @param {Array} array array given to a handlebars helper
+ @return {Boolean} `true` if the array contains a stream/bound value, `false`
+ otherwise
+ */
+ function scanArray(array) {
+ var length = array.length;
+ var containsStream = false;
+
+ for (var i = 0; i < length; i++){
+ if (isStream(array[i])) {
+ containsStream = true;
+ break;
+ }
+ }
+
+ return containsStream;
+ }
+
+ __exports__.scanArray = scanArray;/**
+ Check whether a hash has any stream property values
+
+ @private
+ @function scanHash
+ @param {Object} hash "hash" argument given to a handlebars helper
+ @return {Boolean} `true` if the object contains a stream/bound value, `false`
+ otherwise
+ */
+ function scanHash(hash) {
+ var containsStream = false;
+
+ for (var prop in hash) {
+ if (isStream(hash[prop])) {
+ containsStream = true;
+ break;
+ }
+ }
+
+ return containsStream;
+ }
+
+ __exports__.scanHash = scanHash;/**
+ Join an array, with any streams replaced by their current values
+
+ @private
+ @function concat
+ @param {Array} array An array containing zero or more stream objects and
+ zero or more non-stream objects
+ @param {String} separator string to be used to join array elements
+ @return {String} String with array elements concatenated and joined by the
+ provided separator, and any stream array members having been
+ replaced by the current value of the stream
+ */
+ function concat(array, separator) {
+ // TODO: Create subclass ConcatStream < Stream. Defer
+ // subscribing to streams until the value() is called.
+ var hasStream = scanArray(array);
+ if (hasStream) {
+ var i, l;
+ var stream = new Stream(function() {
+ return readArray(array).join(separator);
+ });
+
+ for (i = 0, l=array.length; i < l; i++) {
+ subscribe(array[i], stream.notify, stream);
+ }
+
+ return stream;
+ } else {
+ return array.join(separator);
+ }
+ }
+
+ __exports__.concat = concat;/**
+ Generate a new stream by providing a source stream and a function that can
+ be used to transform the stream's value. In the case of a non-stream object,
+ returns the result of the function.
+
+ The value to transform would typically be available to the function you pass
+ to `chain()` via scope. For example:
+
+ ```javascript
+ var source = ...; // stream returning a number
+ // or a numeric (non-stream) object
+ var result = chain(source, function(){
+ var currentValue = read(source);
+ return currentValue + 1;
+ });
+ ```
+
+ In the example, result is a stream if source is a stream, or a number of
+ source was numeric.
+
+ @private
+ @function chain
+ @param {Object|Stream} value A stream or non-stream object
+ @param {Function} fn function to be run when the stream value changes, or to
+ be run once in the case of a non-stream object
+ @return {Object|Stream} In the case of a stream `value` parameter, a new
+ stream that will be updated with the return value of
+ the provided function `fn`. In the case of a
+ non-stream object, the return value of the provided
+ function `fn`.
+ */
+ function chain(value, fn) {
+ if (isStream(value)) {
+ var stream = new Stream(fn);
+ subscribe(value, stream.notify, stream);
+ return stream;
+ } else {
+ return fn();
+ }
+ }
+
+ __exports__.chain = chain;
+ });
+enifed("ember-metal/utils",
+ ["ember-metal/core","ember-metal/platform","ember-metal/array","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ // Remove "use strict"; from transpiled module until
+ // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
+ //
+ // REMOVE_USE_STRICT: true
+
+ var Ember = __dependency1__["default"];
+ var o_defineProperty = __dependency2__.defineProperty;
+ var canDefineNonEnumerableProperties = __dependency2__.canDefineNonEnumerableProperties;
+ var hasPropertyAccessors = __dependency2__.hasPropertyAccessors;
+ var o_create = __dependency2__.create;
+
+ var forEach = __dependency3__.forEach;
+
+ /**
+ @module ember-metal
+ */
+
+ /**
+ Previously we used `Ember.$.uuid`, however `$.uuid` has been removed from
+ jQuery master. We'll just bootstrap our own uuid now.
+
+ @private
+ @return {Number} the uuid
+ */
+ var _uuid = 0;
+
+ /**
+ Generates a universally unique identifier. This method
+ is used internally by Ember for assisting with
+ the generation of GUID's and other unique identifiers
+ such as `bind-attr` data attributes.
+
+ @public
+ @return {Number} [description]
+ */
+ function uuid() {
+ return ++_uuid;
+ }
+
+ __exports__.uuid = uuid;/**
+ Prefix used for guids through out Ember.
+ @private
+ @property GUID_PREFIX
+ @for Ember
+ @type String
+ @final
+ */
+ var GUID_PREFIX = 'ember';
+
+ // Used for guid generation...
+ var numberCache = [];
+ var stringCache = {};
+
+ /**
+ Strongly hint runtimes to intern the provided string.
+
+ When do I need to use this function?
+
+ For the most part, never. Pre-mature optimization is bad, and often the
+ runtime does exactly what you need it to, and more often the trade-off isn't
+ worth it.
+
+ Why?
+
+ Runtimes store strings in at least 2 different representations:
+ Ropes and Symbols (interned strings). The Rope provides a memory efficient
+ data-structure for strings created from concatenation or some other string
+ manipulation like splitting.
+
+ Unfortunately checking equality of different ropes can be quite costly as
+ runtimes must resort to clever string comparison algorithims. These
+ algorithims typically cost in proportion to the length of the string.
+ Luckily, this is where the Symbols (interned strings) shine. As Symbols are
+ unique by their string content, equality checks can be done by pointer
+ comparison.
+
+ How do I know if my string is a rope or symbol?
+
+ Typically (warning general sweeping statement, but truthy in runtimes at
+ present) static strings created as part of the JS source are interned.
+ Strings often used for comparisons can be interned at runtime if some
+ criteria are met. One of these criteria can be the size of the entire rope.
+ For example, in chrome 38 a rope longer then 12 characters will not
+ intern, nor will segments of that rope.
+
+ Some numbers: http://jsperf.com/eval-vs-keys/8
+
+ Known Trickâ„¢
+
+ @private
+ @return {String} interned version of the provided string
+ */
+ function intern(str) {
+ var obj = {};
+ obj[str] = 1;
+ for (var key in obj) {
+ if (key === str) return key;
+ }
+ return str;
+ }
+
+ /**
+ A unique key used to assign guids and other private metadata to objects.
+ If you inspect an object in your browser debugger you will often see these.
+ They can be safely ignored.
+
+ On browsers that support it, these properties are added with enumeration
+ disabled so they won't show up when you iterate over your properties.
+
+ @private
+ @property GUID_KEY
+ @for Ember
+ @type String
+ @final
+ */
+ var GUID_KEY = intern('__ember' + (+ new Date()));
+
+ var GUID_DESC = {
+ writable: false,
+ configurable: false,
+ enumerable: false,
+ value: null
+ };
+
+ /**
+ Generates a new guid, optionally saving the guid to the object that you
+ pass in. You will rarely need to use this method. Instead you should
+ call `Ember.guidFor(obj)`, which return an existing guid if available.
+
+ @private
+ @method generateGuid
+ @for Ember
+ @param {Object} [obj] Object the guid will be used for. If passed in, the guid will
+ be saved on the object and reused whenever you pass the same object
+ again.
+
+ If no object is passed, just generate a new guid.
+ @param {String} [prefix] Prefix to place in front of the guid. Useful when you want to
+ separate the guid into separate namespaces.
+ @return {String} the guid
+ */
+ function generateGuid(obj, prefix) {
+ if (!prefix) prefix = GUID_PREFIX;
+ var ret = (prefix + uuid());
+ if (obj) {
+ if (obj[GUID_KEY] === null) {
+ obj[GUID_KEY] = ret;
+ } else {
+ GUID_DESC.value = ret;
+ o_defineProperty(obj, GUID_KEY, GUID_DESC);
+ }
+ }
+ return ret;
+ }
+
+ __exports__.generateGuid = generateGuid;/**
+ Returns a unique id for the object. If the object does not yet have a guid,
+ one will be assigned to it. You can call this on any object,
+ `Ember.Object`-based or not, but be aware that it will add a `_guid`
+ property.
+
+ You can also use this method on DOM Element objects.
+
+ @private
+ @method guidFor
+ @for Ember
+ @param {Object} obj any object, string, number, Element, or primitive
+ @return {String} the unique guid for this instance.
+ */
+ function guidFor(obj) {
+
+ // special cases where we don't want to add a key to object
+ if (obj === undefined) return "(undefined)";
+ if (obj === null) return "(null)";
+
+ var ret;
+ var type = typeof obj;
+
+ // Don't allow prototype changes to String etc. to change the guidFor
+ switch(type) {
+ case 'number':
+ ret = numberCache[obj];
+ if (!ret) ret = numberCache[obj] = 'nu'+obj;
+ return ret;
+
+ case 'string':
+ ret = stringCache[obj];
+ if (!ret) ret = stringCache[obj] = 'st' + uuid();
+ return ret;
+
+ case 'boolean':
+ return obj ? '(true)' : '(false)';
+
+ default:
+ if (obj[GUID_KEY]) return obj[GUID_KEY];
+ if (obj === Object) return '(Object)';
+ if (obj === Array) return '(Array)';
+ ret = GUID_PREFIX + uuid();
+
+ if (obj[GUID_KEY] === null) {
+ obj[GUID_KEY] = ret;
+ } else {
+ GUID_DESC.value = ret;
+ o_defineProperty(obj, GUID_KEY, GUID_DESC);
+ }
+ return ret;
+ }
+ }
+
+ __exports__.guidFor = guidFor;// ..........................................................
+ // META
+ //
+
+ var META_DESC = {
+ writable: true,
+ configurable: false,
+ enumerable: false,
+ value: null
+ };
+
+ function Meta(obj) {
+ this.descs = {};
+ this.watching = {};
+ this.cache = {};
+ this.cacheMeta = {};
+ this.source = obj;
+ this.deps = undefined;
+ this.listeners = undefined;
+ this.mixins = undefined;
+ this.bindings = undefined;
+ this.chains = undefined;
+ this.values = undefined;
+ this.proto = undefined;
+ }
+
+ Meta.prototype = {
+ chainWatchers: null
+ };
+
+ if (!canDefineNonEnumerableProperties) {
+ // on platforms that don't support enumerable false
+ // make meta fail jQuery.isPlainObject() to hide from
+ // jQuery.extend() by having a property that fails
+ // hasOwnProperty check.
+ Meta.prototype.__preventPlainObject__ = true;
+
+ // Without non-enumerable properties, meta objects will be output in JSON
+ // unless explicitly suppressed
+ Meta.prototype.toJSON = function () { };
+ }
+
+ // Placeholder for non-writable metas.
+ var EMPTY_META = new Meta(null);
+
+
+ if (hasPropertyAccessors) {
+ EMPTY_META.values = {};
+ }
+
+
+ /**
+ Retrieves the meta hash for an object. If `writable` is true ensures the
+ hash is writable for this object as well.
+
+ The meta object contains information about computed property descriptors as
+ well as any watched properties and other information. You generally will
+ not access this information directly but instead work with higher level
+ methods that manipulate this hash indirectly.
+
+ @method meta
+ @for Ember
+ @private
+
+ @param {Object} obj The object to retrieve meta for
+ @param {Boolean} [writable=true] Pass `false` if you do not intend to modify
+ the meta hash, allowing the method to avoid making an unnecessary copy.
+ @return {Object} the meta hash for an object
+ */
+ function meta(obj, writable) {
+ var ret = obj['__ember_meta__'];
+ if (writable===false) return ret || EMPTY_META;
+
+ if (!ret) {
+ if (canDefineNonEnumerableProperties) o_defineProperty(obj, '__ember_meta__', META_DESC);
+
+ ret = new Meta(obj);
+
+
+ if (hasPropertyAccessors) {
+ ret.values = {};
+ }
+
+
+ obj['__ember_meta__'] = ret;
+
+ // make sure we don't accidentally try to create constructor like desc
+ ret.descs.constructor = null;
+
+ } else if (ret.source !== obj) {
+ if (canDefineNonEnumerableProperties) o_defineProperty(obj, '__ember_meta__', META_DESC);
+
+ ret = o_create(ret);
+ ret.descs = o_create(ret.descs);
+ ret.watching = o_create(ret.watching);
+ ret.cache = {};
+ ret.cacheMeta = {};
+ ret.source = obj;
+
+
+ if (hasPropertyAccessors) {
+ ret.values = o_create(ret.values);
+ }
+
+
+ obj['__ember_meta__'] = ret;
+ }
+ return ret;
+ }
+
+ function getMeta(obj, property) {
+ var _meta = meta(obj, false);
+ return _meta[property];
+ }
+
+ __exports__.getMeta = getMeta;function setMeta(obj, property, value) {
+ var _meta = meta(obj, true);
+ _meta[property] = value;
+ return value;
+ }
+
+ __exports__.setMeta = setMeta;/**
+ @deprecated
+ @private
+
+ In order to store defaults for a class, a prototype may need to create
+ a default meta object, which will be inherited by any objects instantiated
+ from the class's constructor.
+
+ However, the properties of that meta object are only shallow-cloned,
+ so if a property is a hash (like the event system's `listeners` hash),
+ it will by default be shared across all instances of that class.
+
+ This method allows extensions to deeply clone a series of nested hashes or
+ other complex objects. For instance, the event system might pass
+ `['listeners', 'foo:change', 'ember157']` to `prepareMetaPath`, which will
+ walk down the keys provided.
+
+ For each key, if the key does not exist, it is created. If it already
+ exists and it was inherited from its constructor, the constructor's
+ key is cloned.
+
+ You can also pass false for `writable`, which will simply return
+ undefined if `prepareMetaPath` discovers any part of the path that
+ shared or undefined.
+
+ @method metaPath
+ @for Ember
+ @param {Object} obj The object whose meta we are examining
+ @param {Array} path An array of keys to walk down
+ @param {Boolean} writable whether or not to create a new meta
+ (or meta property) if one does not already exist or if it's
+ shared with its constructor
+ */
+ function metaPath(obj, path, writable) {
+ Ember.deprecate("Ember.metaPath is deprecated and will be removed from future releases.");
+ var _meta = meta(obj, writable);
+ var keyName, value;
+
+ for (var i=0, l=path.length; i 1) {
+ watching[keyName]--;
+ }
+ }
+
+ __exports__.unwatchKey = unwatchKey;
+ });
+enifed("ember-metal/watch_path",
+ ["ember-metal/utils","ember-metal/chains","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var metaFor = __dependency1__.meta;
+ var typeOf = __dependency1__.typeOf;
+ var ChainNode = __dependency2__.ChainNode;
+
+ // get the chains for the current object. If the current object has
+ // chains inherited from the proto they will be cloned and reconfigured for
+ // the current object.
+ function chainsFor(obj, meta) {
+ var m = meta || metaFor(obj);
+ var ret = m.chains;
+ if (!ret) {
+ ret = m.chains = new ChainNode(null, null, obj);
+ } else if (ret.value() !== obj) {
+ ret = m.chains = ret.copy(obj);
+ }
+ return ret;
+ }
+
+ function watchPath(obj, keyPath, meta) {
+ // can't watch length on Array - it is special...
+ if (keyPath === 'length' && typeOf(obj) === 'array') { return; }
+
+ var m = meta || metaFor(obj);
+ var watching = m.watching;
+
+ if (!watching[keyPath]) { // activate watching first time
+ watching[keyPath] = 1;
+ chainsFor(obj, m).add(keyPath);
+ } else {
+ watching[keyPath] = (watching[keyPath] || 0) + 1;
+ }
+ }
+
+ __exports__.watchPath = watchPath;function unwatchPath(obj, keyPath, meta) {
+ var m = meta || metaFor(obj);
+ var watching = m.watching;
+
+ if (watching[keyPath] === 1) {
+ watching[keyPath] = 0;
+ chainsFor(obj, m).remove(keyPath);
+ } else if (watching[keyPath] > 1) {
+ watching[keyPath]--;
+ }
+ }
+
+ __exports__.unwatchPath = unwatchPath;
+ });
+enifed("ember-metal/watching",
+ ["ember-metal/utils","ember-metal/chains","ember-metal/watch_key","ember-metal/watch_path","ember-metal/path_cache","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+ "use strict";
+ /**
+ @module ember-metal
+ */
+
+ var typeOf = __dependency1__.typeOf;
+ var removeChainWatcher = __dependency2__.removeChainWatcher;
+ var flushPendingChains = __dependency2__.flushPendingChains;
+ var watchKey = __dependency3__.watchKey;
+ var unwatchKey = __dependency3__.unwatchKey;
+ var watchPath = __dependency4__.watchPath;
+ var unwatchPath = __dependency4__.unwatchPath;
+
+ var isPath = __dependency5__.isPath;
+
+ /**
+ Starts watching a property on an object. Whenever the property changes,
+ invokes `Ember.propertyWillChange` and `Ember.propertyDidChange`. This is the
+ primitive used by observers and dependent keys; usually you will never call
+ this method directly but instead use higher level methods like
+ `Ember.addObserver()`
+
+ @private
+ @method watch
+ @for Ember
+ @param obj
+ @param {String} keyName
+ */
+ function watch(obj, _keyPath, m) {
+ // can't watch length on Array - it is special...
+ if (_keyPath === 'length' && typeOf(obj) === 'array') { return; }
+
+ if (!isPath(_keyPath)) {
+ watchKey(obj, _keyPath, m);
+ } else {
+ watchPath(obj, _keyPath, m);
+ }
+ }
+
+ __exports__.watch = watch;
+
+ function isWatching(obj, key) {
+ var meta = obj['__ember_meta__'];
+ return (meta && meta.watching[key]) > 0;
+ }
+
+ __exports__.isWatching = isWatching;watch.flushPending = flushPendingChains;
+
+ function unwatch(obj, _keyPath, m) {
+ // can't watch length on Array - it is special...
+ if (_keyPath === 'length' && typeOf(obj) === 'array') { return; }
+
+ if (!isPath(_keyPath)) {
+ unwatchKey(obj, _keyPath, m);
+ } else {
+ unwatchPath(obj, _keyPath, m);
+ }
+ }
+
+ __exports__.unwatch = unwatch;var NODE_STACK = [];
+
+ /**
+ Tears down the meta on an object so that it can be garbage collected.
+ Multiple calls will have no effect.
+
+ @method destroy
+ @for Ember
+ @param {Object} obj the object to destroy
+ @return {void}
+ */
+ function destroy(obj) {
+ var meta = obj['__ember_meta__'], node, nodes, key, nodeObject;
+ if (meta) {
+ obj['__ember_meta__'] = null;
+ // remove chainWatchers to remove circular references that would prevent GC
+ node = meta.chains;
+ if (node) {
+ NODE_STACK.push(node);
+ // process tree
+ while (NODE_STACK.length > 0) {
+ node = NODE_STACK.pop();
+ // push children
+ nodes = node._chains;
+ if (nodes) {
+ for (key in nodes) {
+ if (nodes.hasOwnProperty(key)) {
+ NODE_STACK.push(nodes[key]);
+ }
+ }
+ }
+ // remove chainWatcher in node object
+ if (node._watching) {
+ nodeObject = node._object;
+ if (nodeObject) {
+ removeChainWatcher(nodeObject, node._key, node);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ __exports__.destroy = destroy;
+ });
+enifed("ember-routing-htmlbars",
+ ["ember-metal/core","ember-htmlbars/helpers","ember-routing-htmlbars/helpers/outlet","ember-routing-htmlbars/helpers/render","ember-routing-htmlbars/helpers/link-to","ember-routing-htmlbars/helpers/action","ember-routing-htmlbars/helpers/query-params","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
+ "use strict";
+ /**
+ Ember Routing HTMLBars Helpers
+
+ @module ember
+ @submodule ember-routing-htmlbars
+ @requires ember-routing
+ */
+
+ var Ember = __dependency1__["default"];
+
+ var registerHelper = __dependency2__.registerHelper;
+
+ var outletHelper = __dependency3__.outletHelper;
+ var renderHelper = __dependency4__.renderHelper;
+ var linkToHelper = __dependency5__.linkToHelper;
+ var deprecatedLinkToHelper = __dependency5__.deprecatedLinkToHelper;
+ var actionHelper = __dependency6__.actionHelper;
+ var queryParamsHelper = __dependency7__.queryParamsHelper;
+
+ registerHelper('outlet', outletHelper);
+ registerHelper('render', renderHelper);
+ registerHelper('link-to', linkToHelper);
+ registerHelper('linkTo', deprecatedLinkToHelper);
+ registerHelper('action', actionHelper);
+ registerHelper('query-params', queryParamsHelper);
+
+ __exports__["default"] = Ember;
+ });
+enifed("ember-routing-htmlbars/helpers/action",
+ ["ember-metal/core","ember-metal/utils","ember-metal/run_loop","ember-views/streams/utils","ember-views/system/utils","ember-views/system/action_manager","ember-metal/array","ember-metal/streams/utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-routing-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ // Handlebars, uuid, FEATURES, assert, deprecate
+ var uuid = __dependency2__.uuid;
+ var run = __dependency3__["default"];
+ var readUnwrappedModel = __dependency4__.readUnwrappedModel;
+ var isSimpleClick = __dependency5__.isSimpleClick;
+ var ActionManager = __dependency6__["default"];
+ var indexOf = __dependency7__.indexOf;
+ var isStream = __dependency8__.isStream;
+
+ function actionArgs(parameters, actionName) {
+ var ret, i, l;
+
+ if (actionName === undefined) {
+ ret = new Array(parameters.length);
+ for (i=0, l=parameters.length;i= 0) {
+ return true;
+ }
+
+ for (var i=0, l=keys.length;i
+ click me
+
+ ```
+
+ And application code
+
+ ```javascript
+ App.ApplicationController = Ember.Controller.extend({
+ actions: {
+ anActionName: function() {
+ }
+ }
+ });
+ ```
+
+ Will result in the following rendered HTML
+
+ ```html
+
+
+ click me
+
+
+ ```
+
+ Clicking "click me" will trigger the `anActionName` action of the
+ `App.ApplicationController`. In this case, no additional parameters will be passed.
+
+ If you provide additional parameters to the helper:
+
+ ```handlebars
+
+ ```
+
+ Those parameters will be passed along as arguments to the JavaScript
+ function implementing the action.
+
+ ### Event Propagation
+
+ Events triggered through the action helper will automatically have
+ `.preventDefault()` called on them. You do not need to do so in your event
+ handlers. If you need to allow event propagation (to handle file inputs for
+ example) you can supply the `preventDefault=false` option to the `{{action}}` helper:
+
+ ```handlebars
+
+
+
+
+ ```
+
+ To disable bubbling, pass `bubbles=false` to the helper:
+
+ ```handlebars
+
+ ```
+
+ If you need the default handler to trigger you should either register your
+ own event handler, or use event methods on your view class. See [Ember.View](/api/classes/Ember.View.html)
+ 'Responding to Browser Events' for more information.
+
+ ### Specifying DOM 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
+
+ click me
+
+ ```
+
+ See `Ember.View` 'Responding to Browser Events' for a list of
+ acceptable DOM event names.
+
+ ### Specifying whitelisted 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.
+
+ ```handlebars
+
+ click me
+
+ ```
+
+ This way the `{{action}}` will fire when clicking with the alt key pressed down.
+
+ Alternatively, supply "any" to the `allowedKeys` option to accept any combination of modifier keys.
+
+ ```handlebars
+
+ click me with any key pressed
+
+ ```
+
+ ### 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
+ 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 }}
+
+ click me
+
+ ```
+
+ ```javascript
+ App.ApplicationView = Ember.View.extend({
+ actions: {
+ anActionName: function(){}
+ }
+ });
+
+ ```
+
+ ### 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 person in people}}
+
+ click me
+
+ {{/each}}
+ ```
+
+ Clicking "click me" will trigger the `edit` method on the current controller
+ with the value of `person` as a parameter.
+
+ @method action
+ @for Ember.Handlebars.helpers
+ @param {String} actionName
+ @param {Object} [context]*
+ @param {Hash} options
+ */
+ function actionHelper(params, hash, options, env) {
+
+ var target;
+ if (!hash.target) {
+ target = this.getStream('controller');
+ } else if (isStream(hash.target)) {
+ target = hash.target;
+ } else {
+ target = this.getStream(hash.target);
+ }
+
+ // Ember.assert("You specified a quoteless path to the {{action}} helper which did not resolve to an action name (a string). Perhaps you meant to use a quoted actionName? (e.g. {{action 'save'}}).", !params[0].isStream);
+ // Ember.deprecate("You specified a quoteless path to the {{action}} helper which did not resolve to an action name (a string). Perhaps you meant to use a quoted actionName? (e.g. {{action 'save'}}).", params[0].isStream);
+
+ var actionOptions = {
+ eventName: hash.on || "click",
+ parameters: params.slice(1),
+ view: this,
+ bubbles: hash.bubbles,
+ preventDefault: hash.preventDefault,
+ target: target,
+ withKeyCode: hash.withKeyCode
+ };
+
+ var actionId = ActionHelper.registerAction(params[0], actionOptions, hash.allowedKeys);
+ env.dom.setAttribute(options.element, 'data-ember-action', actionId);
+ }
+
+ __exports__.actionHelper = actionHelper;
+ });
+enifed("ember-routing-htmlbars/helpers/link-to",
+ ["ember-metal/core","ember-routing-views/views/link","ember-metal/streams/utils","ember-runtime/mixins/controller","ember-htmlbars/utils/string","ember-htmlbars","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-routing-handlebars
+ */
+
+ var Ember = __dependency1__["default"];
+ // assert
+ var LinkView = __dependency2__.LinkView;
+ var read = __dependency3__.read;
+ var isStream = __dependency3__.isStream;
+ var ControllerMixin = __dependency4__["default"];
+ var escapeExpression = __dependency5__.escapeExpression;
+
+ // We need the HTMLBars view helper from ensure ember-htmlbars.
+ // This ensures it is loaded first:
+
+ /**
+ The `{{link-to}}` helper renders a link to the supplied
+ `routeName` passing an optionally supplied model to the
+ route as its `model` context of the route. The block
+ for `{{link-to}}` becomes the innerHTML of the rendered
+ element:
+
+ ```handlebars
+ {{#link-to 'photoGallery'}}
+ Great Hamster Photos
+ {{/link-to}}
+ ```
+
+ You can also use an inline form of `{{link-to}}` helper by
+ passing the link text as the first argument
+ to the helper:
+
+ ```handlebars
+ {{link-to 'Great Hamster Photos' 'photoGallery'}}
+ ```
+
+ Both will result in:
+
+ ```html
+
+ Great Hamster Photos
+
+ ```
+
+ ### Supplying a tagName
+ By default `{{link-to}}` renders an `` element. This can
+ be overridden for a single use of `{{link-to}}` by supplying
+ a `tagName` option:
+
+ ```handlebars
+ {{#link-to 'photoGallery' tagName="li"}}
+ Great Hamster Photos
+ {{/link-to}}
+ ```
+
+ ```html
+
+ ```
+
+ To override this option for your entire application, see
+ "Overriding Application-wide Defaults".
+
+ ### Disabling the `link-to` helper
+ By default `{{link-to}}` is enabled.
+ any passed value to `disabled` helper property will disable the `link-to` helper.
+
+ static use: the `disabled` option:
+
+ ```handlebars
+ {{#link-to 'photoGallery' disabled=true}}
+ Great Hamster Photos
+ {{/link-to}}
+ ```
+
+ dynamic use: the `disabledWhen` option:
+
+ ```handlebars
+ {{#link-to 'photoGallery' disabledWhen=controller.someProperty}}
+ Great Hamster Photos
+ {{/link-to}}
+ ```
+
+ any passed value to `disabled` will disable it except `undefined`.
+ to ensure that only `true` disable the `link-to` helper you can
+ override the global behaviour of `Ember.LinkView`.
+
+ ```javascript
+ Ember.LinkView.reopen({
+ disabled: Ember.computed(function(key, value) {
+ if (value !== undefined) {
+ this.set('_isDisabled', value === true);
+ }
+ return value === true ? get(this, 'disabledClass') : false;
+ })
+ });
+ ```
+
+ see "Overriding Application-wide Defaults" for more.
+
+ ### Handling `href`
+ `{{link-to}}` will use your application's Router to
+ fill the element's `href` property with a url that
+ matches the path to the supplied `routeName` for your
+ routers's configured `Location` scheme, which defaults
+ to Ember.HashLocation.
+
+ ### Handling current route
+ `{{link-to}}` will apply a CSS class name of 'active'
+ when the application's current route matches
+ the supplied routeName. For example, if the application's
+ current route is 'photoGallery.recent' the following
+ use of `{{link-to}}`:
+
+ ```handlebars
+ {{#link-to 'photoGallery.recent'}}
+ Great Hamster Photos from the last week
+ {{/link-to}}
+ ```
+
+ will result in
+
+ ```html
+
+ Great Hamster Photos
+
+ ```
+
+ The CSS class name used for active classes can be customized
+ for a single use of `{{link-to}}` by passing an `activeClass`
+ option:
+
+ ```handlebars
+ {{#link-to 'photoGallery.recent' activeClass="current-url"}}
+ Great Hamster Photos from the last week
+ {{/link-to}}
+ ```
+
+ ```html
+
+ Great Hamster Photos
+
+ ```
+
+ To override this option for your entire application, see
+ "Overriding Application-wide Defaults".
+
+ ### Supplying a model
+ An optional model argument can be used for routes whose
+ paths contain dynamic segments. This argument will become
+ the model context of the linked route:
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource("photoGallery", {path: "hamster-photos/:photo_id"});
+ });
+ ```
+
+ ```handlebars
+ {{#link-to 'photoGallery' aPhoto}}
+ {{aPhoto.title}}
+ {{/link-to}}
+ ```
+
+ ```html
+
+ Tomster
+
+ ```
+
+ ### Supplying multiple models
+ For deep-linking to route paths that contain multiple
+ dynamic segments, multiple model arguments can be used.
+ As the router transitions through the route path, each
+ supplied model argument will become the context for the
+ route with the dynamic segments:
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource("photoGallery", {path: "hamster-photos/:photo_id"}, function() {
+ this.route("comment", {path: "comments/:comment_id"});
+ });
+ });
+ ```
+ This argument will become the model context of the linked route:
+
+ ```handlebars
+ {{#link-to 'photoGallery.comment' aPhoto comment}}
+ {{comment.body}}
+ {{/link-to}}
+ ```
+
+ ```html
+
+ A+++ would snuggle again.
+
+ ```
+
+ ### Supplying an explicit dynamic segment value
+ If you don't have a model object available to pass to `{{link-to}}`,
+ an optional string or integer argument can be passed for routes whose
+ paths contain dynamic segments. This argument will become the value
+ of the dynamic segment:
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource("photoGallery", {path: "hamster-photos/:photo_id"});
+ });
+ ```
+
+ ```handlebars
+ {{#link-to 'photoGallery' aPhotoId}}
+ {{aPhoto.title}}
+ {{/link-to}}
+ ```
+
+ ```html
+
+ Tomster
+
+ ```
+
+ When transitioning into the linked route, the `model` hook will
+ be triggered with parameters including this passed identifier.
+
+ ### Allowing Default Action
+
+ By default the `{{link-to}}` helper prevents the default browser action
+ by calling `preventDefault()` as this sort of action bubbling is normally
+ handled internally and we do not want to take the browser to a new URL (for
+ example).
+
+ If you need to override this behavior specify `preventDefault=false` in
+ your template:
+
+ ```handlebars
+ {{#link-to 'photoGallery' aPhotoId preventDefault=false}}
+ {{aPhotoId.title}}
+ {{/link-to}}
+ ```
+
+ ### Overriding attributes
+ You can override any given property of the Ember.LinkView
+ that is generated by the `{{link-to}}` helper by passing
+ key/value pairs, like so:
+
+ ```handlebars
+ {{#link-to aPhoto tagName='li' title='Following this link will change your life' classNames='pic sweet'}}
+ Uh-mazing!
+ {{/link-to}}
+ ```
+
+ See [Ember.LinkView](/api/classes/Ember.LinkView.html) for a
+ complete list of overrideable properties. Be sure to also
+ check out inherited properties of `LinkView`.
+
+ ### Overriding Application-wide Defaults
+ ``{{link-to}}`` creates an instance of Ember.LinkView
+ for rendering. To override options for your entire
+ application, reopen Ember.LinkView and supply the
+ desired values:
+
+ ``` javascript
+ Ember.LinkView.reopen({
+ activeClass: "is-active",
+ tagName: 'li'
+ })
+ ```
+
+ It is also possible to override the default event in
+ this manner:
+
+ ``` javascript
+ Ember.LinkView.reopen({
+ eventName: 'customEventName'
+ });
+ ```
+
+ @method link-to
+ @for Ember.Handlebars.helpers
+ @param {String} routeName
+ @param {Object} [context]*
+ @param [options] {Object} Handlebars key/value pairs of options, you can override any property of Ember.LinkView
+ @return {String} HTML string
+ @see {Ember.LinkView}
+ */
+ function linkToHelper(params, hash, options, env) {
+ var shouldEscape = !hash.unescaped;
+ var queryParamsObject;
+
+ Ember.assert("You must provide one or more parameters to the link-to helper.", params.length);
+
+ var lastParam = params[params.length - 1];
+
+ if (lastParam && lastParam.isQueryParams) {
+ hash.queryParamsObject = queryParamsObject = params.pop();
+ }
+
+ if (hash.disabledWhen) {
+ hash.disabled = hash.disabledWhen;
+ delete hash.disabledWhen;
+ }
+
+ if (!options.template) {
+ var linkTitle = params.shift();
+
+ if (isStream(linkTitle)) {
+ hash.linkTitle = { stream: linkTitle };
+ }
+
+ options.template = {
+ isHTMLBars: true,
+ render: function() {
+ var value = read(linkTitle);
+ if (value) {
+ return shouldEscape ? escapeExpression(value) : value;
+ } else {
+ return "";
+ }
+ }
+ };
+ }
+
+ for (var i = 0; i < params.length; i++) {
+ if (isStream(params[i])) {
+ var lazyValue = params[i];
+
+ if (!lazyValue._isController) {
+ while (ControllerMixin.detect(lazyValue.value())) {
+ lazyValue = lazyValue.get('model');
+ }
+ }
+
+ params[i] = lazyValue;
+ }
+ }
+
+ hash.params = params;
+
+ options.helperName = options.helperName || 'link-to';
+
+ return env.helpers.view.helperFunction.call(this, [LinkView], hash, options, env);
+ }
+
+ /**
+ See [link-to](/api/classes/Ember.Handlebars.helpers.html#method_link-to)
+
+ @method linkTo
+ @for Ember.Handlebars.helpers
+ @deprecated
+ @param {String} routeName
+ @param {Object} [context]*
+ @return {String} HTML string
+ */
+ function deprecatedLinkToHelper(params, hash, options, env) {
+ Ember.deprecate("The 'linkTo' view helper is deprecated in favor of 'link-to'");
+
+ return env.helpers['link-to'].helperFunction.call(this, params, hash, options, env);
+ }
+
+ __exports__.deprecatedLinkToHelper = deprecatedLinkToHelper;
+ __exports__.linkToHelper = linkToHelper;
+ });
+enifed("ember-routing-htmlbars/helpers/outlet",
+ ["ember-metal/core","ember-metal/property_set","ember-routing-views/views/outlet","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-routing-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ // assert
+ var set = __dependency2__.set;
+ var OutletView = __dependency3__.OutletView;
+
+ /**
+ The `outlet` helper is a placeholder that the router will fill in with
+ the appropriate template based on the current state of the application.
+
+ ``` handlebars
+ {{outlet}}
+ ```
+
+ By default, a template based on Ember's naming conventions will be rendered
+ into the `outlet` (e.g. `App.PostsRoute` will render the `posts` template).
+
+ You can render a different template by using the `render()` method in the
+ route's `renderTemplate` hook. The following will render the `favoritePost`
+ template into the `outlet`.
+
+ ``` javascript
+ App.PostsRoute = Ember.Route.extend({
+ renderTemplate: function() {
+ this.render('favoritePost');
+ }
+ });
+ ```
+
+ You can create custom named outlets for more control.
+
+ ``` handlebars
+ {{outlet 'favoritePost'}}
+ {{outlet 'posts'}}
+ ```
+
+ Then you can define what template is rendered into each outlet in your
+ route.
+
+
+ ``` javascript
+ App.PostsRoute = Ember.Route.extend({
+ renderTemplate: function() {
+ this.render('favoritePost', { outlet: 'favoritePost' });
+ this.render('posts', { outlet: 'posts' });
+ }
+ });
+ ```
+
+ You can specify the view that the outlet uses to contain and manage the
+ templates rendered into it.
+
+ ``` handlebars
+ {{outlet view='sectionContainer'}}
+ ```
+
+ ``` javascript
+ App.SectionContainer = Ember.ContainerView.extend({
+ tagName: 'section',
+ classNames: ['special']
+ });
+ ```
+
+ @method outlet
+ @for Ember.Handlebars.helpers
+ @param {String} property the property on the controller
+ that holds the view for this outlet
+ @return {String} HTML string
+ */
+ function outletHelper(params, hash, options, env) {
+ var outletSource;
+ var viewName;
+ var viewClass;
+ var viewFullName;
+
+ Ember.assert(
+ "Using {{outlet}} with an unquoted name is not supported.",
+ params.length === 0 || typeof params[0] === 'string'
+ );
+
+ var property = params[0] || 'main';
+
+ outletSource = this;
+ while (!outletSource.get('template.isTop')) {
+ outletSource = outletSource.get('_parentView');
+ }
+ set(this, 'outletSource', outletSource);
+
+ // provide controller override
+ viewName = hash.view;
+
+ if (viewName) {
+ viewFullName = 'view:' + viewName;
+ Ember.assert(
+ "Using a quoteless view parameter with {{outlet}} is not supported." +
+ " Please update to quoted usage '{{outlet ... view=\"" + viewName + "\"}}.",
+ typeof hash.view === 'string'
+ );
+ Ember.assert(
+ "The view name you supplied '" + viewName + "' did not resolve to a view.",
+ this.container.has(viewFullName)
+ );
+ }
+
+ viewClass = viewName ? this.container.lookupFactory(viewFullName) : hash.viewClass || OutletView;
+
+ hash.currentViewBinding = '_view.outletSource._outlets.' + property;
+
+ options.helperName = options.helperName || 'outlet';
+
+ return env.helpers.view.helperFunction.call(this, [viewClass], hash, options, env);
+ }
+
+ __exports__.outletHelper = outletHelper;
+ });
+enifed("ember-routing-htmlbars/helpers/query-params",
+ ["ember-metal/core","ember-routing/system/query_params","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-routing-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ // assert
+ var QueryParams = __dependency2__["default"];
+
+ /**
+ This is a sub-expression to be used in conjunction with the link-to helper.
+ It will supply url query parameters to the target route.
+
+ Example
+
+ {{#link-to 'posts' (query-params direction="asc")}}Sort{{/link-to}}
+
+ @method query-params
+ @for Ember.Handlebars.helpers
+ @param {Object} hash takes a hash of query parameters
+ @return {String} HTML string
+ */
+ function queryParamsHelper(params, hash) {
+ Ember.assert("The `query-params` helper only accepts hash parameters, e.g. (query-params queryParamPropertyName='foo') as opposed to just (query-params 'foo')", params.length === 0);
+
+ return QueryParams.create({
+ values: hash
+ });
+ }
+
+ __exports__.queryParamsHelper = queryParamsHelper;
+ });
+enifed("ember-routing-htmlbars/helpers/render",
+ ["ember-metal/core","ember-metal/error","ember-runtime/system/string","ember-routing/system/generate_controller","ember-htmlbars/helpers/view","ember-metal/streams/utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-routing-htmlbars
+ */
+
+ var Ember = __dependency1__["default"];
+ // assert, deprecate
+ var EmberError = __dependency2__["default"];
+ var camelize = __dependency3__.camelize;
+ var generateControllerFactory = __dependency4__.generateControllerFactory;
+ var generateController = __dependency4__["default"];
+ var ViewHelper = __dependency5__.ViewHelper;
+ var isStream = __dependency6__.isStream;
+
+ /**
+ Calling ``{{render}}`` from within a template will insert another
+ template that matches the provided name. The inserted template will
+ access its properties on its own controller (rather than the controller
+ of the parent template).
+
+ If a view class with the same name exists, the view class also will be used.
+
+ Note: A given controller may only be used *once* in your app in this manner.
+ A singleton instance of the controller will be created for you.
+
+ Example:
+
+ ```javascript
+ App.NavigationController = Ember.Controller.extend({
+ who: "world"
+ });
+ ```
+
+ ```handlebars
+
+ Hello, {{who}}.
+ ```
+
+ ```handlebars
+
+
My great app
+ {{render "navigation"}}
+ ```
+
+ ```html
+
My great app
+
+ Hello, world.
+
+ ```
+
+ Optionally you may provide a second argument: a property path
+ that will be bound to the `model` property of the controller.
+
+ If a `model` property path is specified, then a new instance of the
+ controller will be created and `{{render}}` can be used multiple times
+ with the same name.
+
+ For example if you had this `author` template.
+
+ ```handlebars
+
+ Written by {{firstName}} {{lastName}}.
+ Total Posts: {{postCount}}
+
+ ```
+
+ You could render it inside the `post` template using the `render` helper.
+
+ ```handlebars
+
+
{{title}}
+
{{body}}
+ {{render "author" author}}
+
+ ```
+
+ @method render
+ @for Ember.Handlebars.helpers
+ @param {String} name
+ @param {Object?} context
+ @param {Hash} options
+ @return {String} HTML string
+ */
+ function renderHelper(params, hash, options, env) {
+ var container, router, controller, view, initialContext;
+
+ var name = params[0];
+ var context = params[1];
+
+ container = this._keywords.controller.value().container;
+ router = container.lookup('router:main');
+
+ Ember.assert(
+ "The first argument of {{render}} must be quoted, e.g. {{render \"sidebar\"}}.",
+ typeof name === 'string'
+ );
+
+ Ember.assert(
+ "The second argument of {{render}} must be a path, e.g. {{render \"post\" post}}.",
+ params.length < 2 || isStream(params[1])
+ );
+
+
+ if (params.length === 1) {
+ // use the singleton controller
+ Ember.assert("You can only use the {{render}} helper once without a model object as its" +
+ " second argument, as in {{render \"post\" post}}.", !router || !router._lookupActiveView(name));
+ } else if (params.length === 2) {
+ // create a new controller
+ initialContext = context.value();
+ } else {
+ throw new EmberError("You must pass a templateName to render");
+ }
+
+ // # legacy namespace
+ name = name.replace(/\//g, '.');
+ // \ legacy slash as namespace support
+
+
+ view = container.lookup('view:' + name) || container.lookup('view:default');
+
+ // provide controller override
+ var controllerName = hash.controller || name;
+ var controllerFullName = 'controller:' + controllerName;
+
+ Ember.assert("The controller name you supplied '" + controllerName +
+ "' did not resolve to a controller.", !hash.controller || container.has(controllerFullName));
+
+ var parentController = this._keywords.controller.value();
+
+ // choose name
+ if (params.length > 1) {
+ var factory = container.lookupFactory(controllerFullName) ||
+ generateControllerFactory(container, controllerName, initialContext);
+
+ controller = factory.create({
+ modelBinding: context, // TODO: Use a StreamBinding
+ parentController: parentController,
+ target: parentController
+ });
+
+ view.one('willDestroyElement', function() {
+ controller.destroy();
+ });
+ } else {
+ controller = container.lookup(controllerFullName) ||
+ generateController(container, controllerName);
+
+ controller.setProperties({
+ target: parentController,
+ parentController: parentController
+ });
+ }
+
+ hash.viewName = camelize(name);
+
+ var templateName = 'template:' + name;
+ Ember.assert("You used `{{render '" + name + "'}}`, but '" + name + "' can not be found as either" +
+ " a template or a view.", container.has("view:" + name) || container.has(templateName) || !!options.template);
+ hash.template = container.lookup(templateName);
+
+ hash.controller = controller;
+
+ if (router && !initialContext) {
+ router._connectActiveView(name, view);
+ }
+
+ options.helperName = options.helperName || ('render "' + name + '"');
+
+ ViewHelper.instanceHelper(view, hash, options, env);
+ }
+
+ __exports__.renderHelper = renderHelper;
+ });
+enifed("ember-routing-views",
+ ["ember-metal/core","ember-routing-views/views/link","ember-routing-views/views/outlet","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ /**
+ Ember Routing Views
+
+ @module ember
+ @submodule ember-routing-views
+ @requires ember-routing
+ */
+
+ var Ember = __dependency1__["default"];
+
+ var LinkView = __dependency2__.LinkView;
+ var OutletView = __dependency3__.OutletView;
+
+ Ember.LinkView = LinkView;
+ Ember.OutletView = OutletView;
+
+ __exports__["default"] = Ember;
+ });
+enifed("ember-routing-views/views/link",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/merge","ember-metal/run_loop","ember-metal/computed","ember-runtime/system/string","ember-metal/keys","ember-views/system/utils","ember-views/views/component","ember-routing/utils","ember-metal/streams/utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-routing-views
+ */
+
+ var Ember = __dependency1__["default"];
+ // FEATURES, Logger, assert
+
+ var get = __dependency2__.get;
+ var merge = __dependency3__["default"];
+ var run = __dependency4__["default"];
+ var computed = __dependency5__.computed;
+ var fmt = __dependency6__.fmt;
+ var keys = __dependency7__["default"];
+ var isSimpleClick = __dependency8__.isSimpleClick;
+ var EmberComponent = __dependency9__["default"];
+ var routeArgs = __dependency10__.routeArgs;
+ var read = __dependency11__.read;
+ var subscribe = __dependency11__.subscribe;
+
+ var numberOfContextsAcceptedByHandler = function(handler, handlerInfos) {
+ var req = 0;
+ for (var i = 0, l = handlerInfos.length; i < l; i++) {
+ req = req + handlerInfos[i].names.length;
+ if (handlerInfos[i].handler === handler)
+ break;
+ }
+
+ return req;
+ };
+
+ /**
+ `Ember.LinkView` renders an element whose `click` event triggers a
+ transition of the application's instance of `Ember.Router` to
+ a supplied route by name.
+
+ Instances of `LinkView` will most likely be created through
+ the `link-to` Handlebars helper, but properties of this class
+ can be overridden to customize application-wide behavior.
+
+ @class LinkView
+ @namespace Ember
+ @extends Ember.View
+ @see {Handlebars.helpers.link-to}
+ **/
+ var LinkView = Ember.LinkView = EmberComponent.extend({
+ tagName: 'a',
+
+ /**
+ @deprecated Use current-when instead.
+ @property currentWhen
+ */
+ currentWhen: null,
+
+ /**
+ Used to determine when this LinkView is active.
+
+ @property currentWhen
+ */
+ 'current-when': null,
+
+ /**
+ Sets the `title` attribute of the `LinkView`'s HTML element.
+
+ @property title
+ @default null
+ **/
+ title: null,
+
+ /**
+ Sets the `rel` attribute of the `LinkView`'s HTML element.
+
+ @property rel
+ @default null
+ **/
+ rel: null,
+
+ /**
+ Sets the `tabindex` attribute of the `LinkView`'s HTML element.
+
+ @property tabindex
+ @default null
+ **/
+ tabindex: null,
+
+ /**
+ Sets the `target` attribute of the `LinkView`'s HTML element.
+
+ @since 1.8.0
+ @property target
+ @default null
+ **/
+ target: null,
+
+ /**
+ The CSS class to apply to `LinkView`'s element when its `active`
+ property is `true`.
+
+ @property activeClass
+ @type String
+ @default active
+ **/
+ activeClass: 'active',
+
+ /**
+ The CSS class to apply to `LinkView`'s element when its `loading`
+ property is `true`.
+
+ @property loadingClass
+ @type String
+ @default loading
+ **/
+ loadingClass: 'loading',
+
+ /**
+ The CSS class to apply to a `LinkView`'s element when its `disabled`
+ property is `true`.
+
+ @property disabledClass
+ @type String
+ @default disabled
+ **/
+ disabledClass: 'disabled',
+ _isDisabled: false,
+
+ /**
+ Determines whether the `LinkView` will trigger routing via
+ the `replaceWith` routing strategy.
+
+ @property replace
+ @type Boolean
+ @default false
+ **/
+ replace: false,
+
+ /**
+ By default the `{{link-to}}` helper will bind to the `href` and
+ `title` attributes. It's discouraged that you override these defaults,
+ however you can push onto the array if needed.
+
+ @property attributeBindings
+ @type Array | String
+ @default ['href', 'title', 'rel', 'tabindex', 'target']
+ **/
+ attributeBindings: ['href', 'title', 'rel', 'tabindex'],
+
+ /**
+ By default the `{{link-to}}` helper will bind to the `active`, `loading`, and
+ `disabled` classes. It is discouraged to override these directly.
+
+ @property classNameBindings
+ @type Array
+ @default ['active', 'loading', 'disabled']
+ **/
+ classNameBindings: ['active', 'loading', 'disabled'],
+
+ /**
+ By default the `{{link-to}}` helper responds to the `click` event. You
+ can override this globally by setting this property to your custom
+ event name.
+
+ This is particularly useful on mobile when one wants to avoid the 300ms
+ click delay using some sort of custom `tap` event.
+
+ @property eventName
+ @type String
+ @default click
+ */
+ eventName: 'click',
+
+ // this is doc'ed here so it shows up in the events
+ // section of the API documentation, which is where
+ // people will likely go looking for it.
+ /**
+ Triggers the `LinkView`'s routing behavior. If
+ `eventName` is changed to a value other than `click`
+ the routing behavior will trigger on that custom event
+ instead.
+
+ @event click
+ **/
+
+ /**
+ An overridable method called when LinkView objects are instantiated.
+
+ Example:
+
+ ```javascript
+ App.MyLinkView = Ember.LinkView.extend({
+ init: function() {
+ this._super();
+ Ember.Logger.log('Event is ' + this.get('eventName'));
+ }
+ });
+ ```
+
+ NOTE: If you do override `init` for a framework class like `Ember.View` or
+ `Ember.ArrayController`, be sure to call `this._super()` in your
+ `init` declaration! If you don't, Ember may not have an opportunity to
+ do important setup work, and you'll see strange behavior in your
+ application.
+
+ @method init
+ */
+ init: function() {
+ this._super.apply(this, arguments);
+
+ Ember.deprecate('Using currentWhen with {{link-to}} is deprecated in favor of `current-when`.', !this.currentWhen);
+
+ // Map desired event name to invoke function
+ var eventName = get(this, 'eventName');
+ this.on(eventName, this, this._invoke);
+ },
+
+ /**
+ This method is invoked by observers installed during `init` that fire
+ whenever the params change
+
+ @private
+ @method _paramsChanged
+ @since 1.3.0
+ */
+ _paramsChanged: function() {
+ this.notifyPropertyChange('resolvedParams');
+ },
+
+ /**
+ This is called to setup observers that will trigger a rerender.
+
+ @private
+ @method _setupPathObservers
+ @since 1.3.0
+ **/
+ _setupPathObservers: function(){
+ var params = this.params;
+
+ var scheduledRerender = this._wrapAsScheduled(this.rerender);
+ var scheduledParamsChanged = this._wrapAsScheduled(this._paramsChanged);
+
+ if (this.linkTitle) {
+ var linkTitle = this.linkTitle.stream || this.linkTitle;
+ subscribe(linkTitle, scheduledRerender, this);
+ }
+
+ for (var i = 0; i < params.length; i++) {
+ subscribe(params[i], scheduledParamsChanged, this);
+ }
+
+ var queryParamsObject = this.queryParamsObject;
+ if (queryParamsObject) {
+ var values = queryParamsObject.values;
+ for (var k in values) {
+ if (!values.hasOwnProperty(k)) {
+ continue;
+ }
+
+ subscribe(values[k], scheduledParamsChanged, this);
+ }
+ }
+ },
+
+ afterRender: function(){
+ this._super.apply(this, arguments);
+ this._setupPathObservers();
+ },
+
+ /**
+
+ Accessed as a classname binding to apply the `LinkView`'s `disabledClass`
+ CSS `class` to the element when the link is disabled.
+
+ When `true` interactions with the element will not trigger route changes.
+ @property disabled
+ */
+ disabled: computed(function computeLinkViewDisabled(key, value) {
+ if (value !== undefined) { this.set('_isDisabled', value); }
+
+ return value ? get(this, 'disabledClass') : false;
+ }),
+
+ /**
+ Accessed as a classname binding to apply the `LinkView`'s `activeClass`
+ CSS `class` to the element when the link is active.
+
+ A `LinkView` is considered active when its `currentWhen` property is `true`
+ or the application's current route is the route the `LinkView` would trigger
+ transitions into.
+
+ The `currentWhen` property can match against multiple routes by separating
+ route names using the ` ` (space) character.
+
+ @property active
+ **/
+ active: computed('loadedParams', function computeLinkViewActive() {
+ if (get(this, 'loading')) { return false; }
+
+ var router = get(this, 'router');
+ var loadedParams = get(this, 'loadedParams');
+ var contexts = loadedParams.models;
+ var currentWhen = this['current-when'] || this.currentWhen;
+ var isCurrentWhenSpecified = Boolean(currentWhen);
+ currentWhen = currentWhen || loadedParams.targetRouteName;
+
+ function isActiveForRoute(routeName) {
+ var handlers = router.router.recognizer.handlersFor(routeName);
+ var leafName = handlers[handlers.length-1].handler;
+ var maximumContexts = numberOfContextsAcceptedByHandler(routeName, handlers);
+
+ // NOTE: any ugliness in the calculation of activeness is largely
+ // due to the fact that we support automatic normalizing of
+ // `resource` -> `resource.index`, even though there might be
+ // dynamic segments / query params defined on `resource.index`
+ // which complicates (and makes somewhat ambiguous) the calculation
+ // of activeness for links that link to `resource` instead of
+ // directly to `resource.index`.
+
+ // if we don't have enough contexts revert back to full route name
+ // this is because the leaf route will use one of the contexts
+ if (contexts.length > maximumContexts) {
+ routeName = leafName;
+ }
+
+ var args = routeArgs(routeName, contexts, null);
+ var isActive = router.isActive.apply(router, args);
+ if (!isActive) { return false; }
+
+ var emptyQueryParams = Ember.isEmpty(Ember.keys(loadedParams.queryParams));
+
+ if (!isCurrentWhenSpecified && !emptyQueryParams && isActive) {
+ var visibleQueryParams = {};
+ merge(visibleQueryParams, loadedParams.queryParams);
+ router._prepareQueryParams(loadedParams.targetRouteName, loadedParams.models, visibleQueryParams);
+ isActive = shallowEqual(visibleQueryParams, router.router.state.queryParams);
+ }
+
+ return isActive;
+ }
+
+
+ currentWhen = currentWhen.split(' ');
+ for (var i = 0, len = currentWhen.length; i < len; i++) {
+ if (isActiveForRoute(currentWhen[i])) {
+ return get(this, 'activeClass');
+ }
+ }
+ }),
+
+ /**
+ Accessed as a classname binding to apply the `LinkView`'s `loadingClass`
+ CSS `class` to the element when the link is loading.
+
+ A `LinkView` is considered loading when it has at least one
+ parameter whose value is currently null or undefined. During
+ this time, clicking the link will perform no transition and
+ emit a warning that the link is still in a loading state.
+
+ @property loading
+ **/
+ loading: computed('loadedParams', function computeLinkViewLoading() {
+ if (!get(this, 'loadedParams')) { return get(this, 'loadingClass'); }
+ }),
+
+ /**
+ Returns the application's main router from the container.
+
+ @private
+ @property router
+ **/
+ router: computed(function() {
+ var controller = get(this, 'controller');
+ if (controller && controller.container) {
+ return controller.container.lookup('router:main');
+ }
+ }),
+
+ /**
+ Event handler that invokes the link, activating the associated route.
+
+ @private
+ @method _invoke
+ @param {Event} event
+ */
+ _invoke: function(event) {
+ if (!isSimpleClick(event)) { return true; }
+
+ if (this.preventDefault !== false) {
+
+ var targetAttribute = get(this, 'target');
+ if (!targetAttribute || targetAttribute === '_self') {
+ event.preventDefault();
+ }
+ }
+
+ if (this.bubbles === false) { event.stopPropagation(); }
+
+ if (get(this, '_isDisabled')) { return false; }
+
+ if (get(this, 'loading')) {
+ Ember.Logger.warn("This link-to is in an inactive loading state because at least one of its parameters presently has a null/undefined value, or the provided route name is invalid.");
+ return false;
+ }
+
+
+ var targetAttribute2 = get(this, 'target');
+ if (targetAttribute2 && targetAttribute2 !== '_self') {
+ return false;
+ }
+
+
+ var router = get(this, 'router');
+ var loadedParams = get(this, 'loadedParams');
+
+ var transition = router._doTransition(loadedParams.targetRouteName, loadedParams.models, loadedParams.queryParams);
+ if (get(this, 'replace')) {
+ transition.method('replace');
+ }
+
+ // Schedule eager URL update, but after we've given the transition
+ // a chance to synchronously redirect.
+ // We need to always generate the URL instead of using the href because
+ // the href will include any rootURL set, but the router expects a URL
+ // without it! Note that we don't use the first level router because it
+ // calls location.formatURL(), which also would add the rootURL!
+ var args = routeArgs(loadedParams.targetRouteName, loadedParams.models, transition.state.queryParams);
+ var url = router.router.generate.apply(router.router, args);
+
+ run.scheduleOnce('routerTransitions', this, this._eagerUpdateUrl, transition, url);
+ },
+
+ /**
+ @private
+ @method _eagerUpdateUrl
+ @param transition
+ @param href
+ */
+ _eagerUpdateUrl: function(transition, href) {
+ if (!transition.isActive || !transition.urlMethod) {
+ // transition was aborted, already ran to completion,
+ // or it has a null url-updated method.
+ return;
+ }
+
+ if (href.indexOf('#') === 0) {
+ href = href.slice(1);
+ }
+
+ // Re-use the routerjs hooks set up by the Ember router.
+ var routerjs = get(this, 'router.router');
+ if (transition.urlMethod === 'update') {
+ routerjs.updateURL(href);
+ } else if (transition.urlMethod === 'replace') {
+ routerjs.replaceURL(href);
+ }
+
+ // Prevent later update url refire.
+ transition.method(null);
+ },
+
+ /**
+ Computed property that returns an array of the
+ resolved parameters passed to the `link-to` helper,
+ e.g.:
+
+ ```hbs
+ {{link-to a b '123' c}}
+ ```
+
+ will generate a `resolvedParams` of:
+
+ ```js
+ [aObject, bObject, '123', cObject]
+ ```
+
+ @private
+ @property
+ @return {Array}
+ */
+ resolvedParams: computed('router.url', function() {
+ var params = this.params;
+ var targetRouteName;
+ var models = [];
+ var onlyQueryParamsSupplied = (params.length === 0);
+
+ if (onlyQueryParamsSupplied) {
+ var appController = this.container.lookup('controller:application');
+ targetRouteName = get(appController, 'currentRouteName');
+ } else {
+ targetRouteName = read(params[0]);
+
+ for (var i = 1; i < params.length; i++) {
+ models.push(read(params[i]));
+ }
+ }
+
+ var suppliedQueryParams = getResolvedQueryParams(this, targetRouteName);
+
+ return {
+ targetRouteName: targetRouteName,
+ models: models,
+ queryParams: suppliedQueryParams
+ };
+ }),
+
+ /**
+ Computed property that returns the current route name,
+ dynamic segments, and query params. Returns falsy if
+ for null/undefined params to indicate that the link view
+ is still in a loading state.
+
+ @private
+ @property
+ @return {Array} An array with the route name and any dynamic segments
+ **/
+ loadedParams: computed('resolvedParams', function computeLinkViewRouteArgs() {
+ var router = get(this, 'router');
+ if (!router) { return; }
+
+ var resolvedParams = get(this, 'resolvedParams');
+ var namedRoute = resolvedParams.targetRouteName;
+
+ if (!namedRoute) { return; }
+
+ Ember.assert(fmt("The attempt to link-to route '%@' failed. " +
+ "The router did not find '%@' in its possible routes: '%@'",
+ [namedRoute, namedRoute, keys(router.router.recognizer.names).join("', '")]),
+ router.hasRoute(namedRoute));
+
+ if (!paramsAreLoaded(resolvedParams.models)) { return; }
+
+ return resolvedParams;
+ }),
+
+ queryParamsObject: null,
+
+ /**
+ Sets the element's `href` attribute to the url for
+ the `LinkView`'s targeted route.
+
+ If the `LinkView`'s `tagName` is changed to a value other
+ than `a`, this property will be ignored.
+
+ @property href
+ **/
+ href: computed('loadedParams', function computeLinkViewHref() {
+ if (get(this, 'tagName') !== 'a') { return; }
+
+ var router = get(this, 'router');
+ var loadedParams = get(this, 'loadedParams');
+
+ if (!loadedParams) {
+ return get(this, 'loadingHref');
+ }
+
+ var visibleQueryParams = {};
+ merge(visibleQueryParams, loadedParams.queryParams);
+ router._prepareQueryParams(loadedParams.targetRouteName, loadedParams.models, visibleQueryParams);
+
+ var args = routeArgs(loadedParams.targetRouteName, loadedParams.models, visibleQueryParams);
+ var result = router.generate.apply(router, args);
+ return result;
+ }),
+
+ /**
+ The default href value to use while a link-to is loading.
+ Only applies when tagName is 'a'
+
+ @property loadingHref
+ @type String
+ @default #
+ */
+ loadingHref: '#'
+ });
+
+ LinkView.toString = function() { return "LinkView"; };
+
+
+ LinkView.reopen({
+ attributeBindings: ['target'],
+
+ /**
+ Sets the `target` attribute of the `LinkView`'s anchor element.
+
+ @property target
+ @default null
+ **/
+ target: null
+ });
+
+
+ function getResolvedQueryParams(linkView, targetRouteName) {
+ var queryParamsObject = linkView.queryParamsObject;
+ var resolvedQueryParams = {};
+
+ if (!queryParamsObject) { return resolvedQueryParams; }
+
+ var values = queryParamsObject.values;
+ for (var key in values) {
+ if (!values.hasOwnProperty(key)) { continue; }
+ resolvedQueryParams[key] = read(values[key]);
+ }
+
+ return resolvedQueryParams;
+ }
+
+ function paramsAreLoaded(params) {
+ for (var i = 0, len = params.length; i < len; ++i) {
+ var param = params[i];
+ if (param === null || typeof param === 'undefined') {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ function shallowEqual(a, b) {
+ var k;
+ for (k in a) {
+ if (a.hasOwnProperty(k) && a[k] !== b[k]) { return false; }
+ }
+ for (k in b) {
+ if (b.hasOwnProperty(k) && a[k] !== b[k]) { return false; }
+ }
+ return true;
+ }
+
+ __exports__.LinkView = LinkView;
+ });
+enifed("ember-routing-views/views/outlet",
+ ["ember-views/views/container_view","ember-views/views/metamorph_view","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-routing-views
+ */
+
+ var ContainerView = __dependency1__["default"];
+ var _Metamorph = __dependency2__._Metamorph;
+
+ var OutletView = ContainerView.extend(_Metamorph);
+ __exports__.OutletView = OutletView;
+ });
+enifed("ember-routing",
+ ["ember-metal/core","ember-routing/ext/run_loop","ember-routing/ext/controller","ember-routing/ext/view","ember-routing/location/api","ember-routing/location/none_location","ember-routing/location/hash_location","ember-routing/location/history_location","ember-routing/location/auto_location","ember-routing/system/generate_controller","ember-routing/system/controller_for","ember-routing/system/dsl","ember-routing/system/router","ember-routing/system/route","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __exports__) {
+ "use strict";
+ /**
+ Ember Routing
+
+ @module ember
+ @submodule ember-routing
+ @requires ember-views
+ */
+
+ var Ember = __dependency1__["default"];
+
+ // ES6TODO: Cleanup modules with side-effects below
+
+ var EmberLocation = __dependency5__["default"];
+ var NoneLocation = __dependency6__["default"];
+ var HashLocation = __dependency7__["default"];
+ var HistoryLocation = __dependency8__["default"];
+ var AutoLocation = __dependency9__["default"];
+
+ var generateControllerFactory = __dependency10__.generateControllerFactory;
+ var generateController = __dependency10__["default"];
+ var controllerFor = __dependency11__["default"];
+ var RouterDSL = __dependency12__["default"];
+ var Router = __dependency13__["default"];
+ var Route = __dependency14__["default"];
+
+ Ember.Location = EmberLocation;
+ Ember.AutoLocation = AutoLocation;
+ Ember.HashLocation = HashLocation;
+ Ember.HistoryLocation = HistoryLocation;
+ Ember.NoneLocation = NoneLocation;
+
+ Ember.controllerFor = controllerFor;
+ Ember.generateControllerFactory = generateControllerFactory;
+ Ember.generateController = generateController;
+ Ember.RouterDSL = RouterDSL;
+ Ember.Router = Router;
+ Ember.Route = Route;
+
+ __exports__["default"] = Ember;
+ });
+enifed("ember-routing/ext/controller",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/computed","ember-metal/utils","ember-metal/merge","ember-runtime/mixins/controller","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // FEATURES, deprecate
+ var get = __dependency2__.get;
+ var set = __dependency3__.set;
+ var computed = __dependency4__.computed;
+ var typeOf = __dependency5__.typeOf;
+ var meta = __dependency5__.meta;
+ var merge = __dependency6__["default"];
+
+ var ControllerMixin = __dependency7__["default"];
+
+ /**
+ @module ember
+ @submodule ember-routing
+ */
+
+ ControllerMixin.reopen({
+ concatenatedProperties: ['queryParams', '_pCacheMeta'],
+
+ init: function() {
+ this._super.apply(this, arguments);
+ listenForQueryParamChanges(this);
+ },
+
+ /**
+ Defines which query parameters the controller accepts.
+ If you give the names ['category','page'] it will bind
+ the values of these query parameters to the variables
+ `this.category` and `this.page`
+
+ @property queryParams
+ @public
+ */
+ queryParams: null,
+
+ /**
+ @property _qpDelegate
+ @private
+ */
+ _qpDelegate: null,
+
+ /**
+ @property _normalizedQueryParams
+ @private
+ */
+ _normalizedQueryParams: computed(function() {
+ var m = meta(this);
+ if (m.proto !== this) {
+ return get(m.proto, '_normalizedQueryParams');
+ }
+
+ var queryParams = get(this, 'queryParams');
+ if (queryParams._qpMap) {
+ return queryParams._qpMap;
+ }
+
+ var qpMap = queryParams._qpMap = {};
+
+ for (var i = 0, len = queryParams.length; i < len; ++i) {
+ accumulateQueryParamDescriptors(queryParams[i], qpMap);
+ }
+
+ return qpMap;
+ }),
+
+ /**
+ @property _cacheMeta
+ @private
+ */
+ _cacheMeta: computed(function() {
+ var m = meta(this);
+ if (m.proto !== this) {
+ return get(m.proto, '_cacheMeta');
+ }
+
+ var cacheMeta = {};
+ var qpMap = get(this, '_normalizedQueryParams');
+ for (var prop in qpMap) {
+ if (!qpMap.hasOwnProperty(prop)) { continue; }
+
+ var qp = qpMap[prop];
+ var scope = qp.scope;
+ var parts;
+
+ if (scope === 'controller') {
+ parts = [];
+ }
+
+ cacheMeta[prop] = {
+ parts: parts, // provided by route if 'model' scope
+ values: null, // provided by route
+ scope: scope,
+ prefix: "",
+ def: get(this, prop)
+ };
+ }
+
+ return cacheMeta;
+ }),
+
+ /**
+ @method _updateCacheParams
+ @private
+ */
+ _updateCacheParams: function(params) {
+ var cacheMeta = get(this, '_cacheMeta');
+ for (var prop in cacheMeta) {
+ if (!cacheMeta.hasOwnProperty(prop)) { continue; }
+ var propMeta = cacheMeta[prop];
+ propMeta.values = params;
+
+ var cacheKey = this._calculateCacheKey(propMeta.prefix, propMeta.parts, propMeta.values);
+ var cache = this._bucketCache;
+
+ if (cache) {
+ var value = cache.lookup(cacheKey, prop, propMeta.def);
+ set(this, prop, value);
+ }
+ }
+ },
+
+ /**
+ @method _qpChanged
+ @private
+ */
+ _qpChanged: function(controller, _prop) {
+ var prop = _prop.substr(0, _prop.length-3);
+ var cacheMeta = get(controller, '_cacheMeta');
+ var propCache = cacheMeta[prop];
+ var cacheKey = controller._calculateCacheKey(propCache.prefix || "", propCache.parts, propCache.values);
+ var value = get(controller, prop);
+
+ // 1. Update model-dep cache
+ var cache = this._bucketCache;
+ if (cache) {
+ controller._bucketCache.stash(cacheKey, prop, value);
+ }
+
+ // 2. Notify a delegate (e.g. to fire a qp transition)
+ var delegate = controller._qpDelegate;
+ if (delegate) {
+ delegate(controller, prop);
+ }
+ },
+
+ /**
+ @method _calculateCacheKey
+ @private
+ */
+ _calculateCacheKey: function(prefix, _parts, values) {
+ var parts = _parts || [], suffixes = "";
+ for (var i = 0, len = parts.length; i < len; ++i) {
+ var part = parts[i];
+ var value = get(values, part);
+ suffixes += "::" + part + ":" + value;
+ }
+ return prefix + suffixes.replace(ALL_PERIODS_REGEX, '-');
+ },
+
+ /**
+ Transition the application into another route. The route may
+ be either a single route or route path:
+
+ ```javascript
+ aController.transitionToRoute('blogPosts');
+ aController.transitionToRoute('blogPosts.recentEntries');
+ ```
+
+ Optionally supply a model for the route in question. The model
+ will be serialized into the URL using the `serialize` hook of
+ the route:
+
+ ```javascript
+ aController.transitionToRoute('blogPost', aPost);
+ ```
+
+ If a literal is passed (such as a number or a string), it will
+ be treated as an identifier instead. In this case, the `model`
+ hook of the route will be triggered:
+
+ ```javascript
+ aController.transitionToRoute('blogPost', 1);
+ ```
+
+ Multiple models will be applied last to first recursively up the
+ resource tree.
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource('blogPost', {path:':blogPostId'}, function(){
+ this.resource('blogComment', {path: ':blogCommentId'});
+ });
+ });
+
+ aController.transitionToRoute('blogComment', aPost, aComment);
+ aController.transitionToRoute('blogComment', 1, 13);
+ ```
+
+ It is also possible to pass a URL (a string that starts with a
+ `/`). This is intended for testing and debugging purposes and
+ should rarely be used in production code.
+
+ ```javascript
+ aController.transitionToRoute('/');
+ aController.transitionToRoute('/blog/post/1/comment/13');
+ aController.transitionToRoute('/blog/posts?sort=title');
+ ```
+
+ An options hash with a `queryParams` property may be provided as
+ the final argument to add query parameters to the destination URL.
+
+ ```javascript
+ aController.transitionToRoute('blogPost', 1, {
+ queryParams: {showComments: 'true'}
+ });
+
+ // if you just want to transition the query parameters without changing the route
+ aController.transitionToRoute({queryParams: {sort: 'date'}});
+ ```
+
+ See also [replaceRoute](/api/classes/Ember.ControllerMixin.html#method_replaceRoute).
+
+ @param {String} name the name of the route or a URL
+ @param {...Object} models the model(s) or identifier(s) to be used
+ while transitioning to the route.
+ @param {Object} [options] optional hash with a queryParams property
+ containing a mapping of query parameters
+ @for Ember.ControllerMixin
+ @method transitionToRoute
+ */
+ transitionToRoute: function() {
+ // target may be either another controller or a router
+ var target = get(this, 'target');
+ var method = target.transitionToRoute || target.transitionTo;
+ return method.apply(target, arguments);
+ },
+
+ /**
+ @deprecated
+ @for Ember.ControllerMixin
+ @method transitionTo
+ */
+ transitionTo: function() {
+ Ember.deprecate("transitionTo is deprecated. Please use transitionToRoute.");
+ return this.transitionToRoute.apply(this, arguments);
+ },
+
+ /**
+ Transition into another route while replacing the current URL, if possible.
+ This will replace the current history entry instead of adding a new one.
+ Beside that, it is identical to `transitionToRoute` in all other respects.
+
+ ```javascript
+ aController.replaceRoute('blogPosts');
+ aController.replaceRoute('blogPosts.recentEntries');
+ ```
+
+ Optionally supply a model for the route in question. The model
+ will be serialized into the URL using the `serialize` hook of
+ the route:
+
+ ```javascript
+ aController.replaceRoute('blogPost', aPost);
+ ```
+
+ If a literal is passed (such as a number or a string), it will
+ be treated as an identifier instead. In this case, the `model`
+ hook of the route will be triggered:
+
+ ```javascript
+ aController.replaceRoute('blogPost', 1);
+ ```
+
+ Multiple models will be applied last to first recursively up the
+ resource tree.
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource('blogPost', {path:':blogPostId'}, function(){
+ this.resource('blogComment', {path: ':blogCommentId'});
+ });
+ });
+
+ aController.replaceRoute('blogComment', aPost, aComment);
+ aController.replaceRoute('blogComment', 1, 13);
+ ```
+
+ It is also possible to pass a URL (a string that starts with a
+ `/`). This is intended for testing and debugging purposes and
+ should rarely be used in production code.
+
+ ```javascript
+ aController.replaceRoute('/');
+ aController.replaceRoute('/blog/post/1/comment/13');
+ ```
+
+ @param {String} name the name of the route or a URL
+ @param {...Object} models the model(s) or identifier(s) to be used
+ while transitioning to the route.
+ @for Ember.ControllerMixin
+ @method replaceRoute
+ */
+ replaceRoute: function() {
+ // target may be either another controller or a router
+ var target = get(this, 'target');
+ var method = target.replaceRoute || target.replaceWith;
+ return method.apply(target, arguments);
+ },
+
+ /**
+ @deprecated
+ @for Ember.ControllerMixin
+ @method replaceWith
+ */
+ replaceWith: function() {
+ Ember.deprecate("replaceWith is deprecated. Please use replaceRoute.");
+ return this.replaceRoute.apply(this, arguments);
+ }
+ });
+
+ var ALL_PERIODS_REGEX = /\./g;
+
+ function accumulateQueryParamDescriptors(_desc, accum) {
+ var desc = _desc;
+ var tmp;
+ if (typeOf(desc) === 'string') {
+ tmp = {};
+ tmp[desc] = { as: null };
+ desc = tmp;
+ }
+
+ for (var key in desc) {
+ if (!desc.hasOwnProperty(key)) { return; }
+
+ var singleDesc = desc[key];
+ if (typeOf(singleDesc) === 'string') {
+ singleDesc = { as: singleDesc };
+ }
+
+ tmp = accum[key] || { as: null, scope: 'model' };
+ merge(tmp, singleDesc);
+
+ accum[key] = tmp;
+ }
+ }
+
+ function listenForQueryParamChanges(controller) {
+ var qpMap = get(controller, '_normalizedQueryParams');
+ for (var prop in qpMap) {
+ if (!qpMap.hasOwnProperty(prop)) { continue; }
+ controller.addObserver(prop + '.[]', controller, controller._qpChanged);
+ }
+ }
+
+
+ __exports__["default"] = ControllerMixin;
+ });
+enifed("ember-routing/ext/run_loop",
+ ["ember-metal/run_loop"],
+ function(__dependency1__) {
+ "use strict";
+ var run = __dependency1__["default"];
+
+ /**
+ @module ember
+ @submodule ember-views
+ */
+
+ // Add a new named queue after the 'actions' queue (where RSVP promises
+ // resolve), which is used in router transitions to prevent unnecessary
+ // loading state entry if all context promises resolve on the
+ // 'actions' queue first.
+ run._addQueue('routerTransitions', 'actions');
+ });
+enifed("ember-routing/ext/view",
+ ["ember-metal/property_get","ember-metal/property_set","ember-metal/run_loop","ember-views/views/view","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ var get = __dependency1__.get;
+ var set = __dependency2__.set;
+ var run = __dependency3__["default"];
+ var EmberView = __dependency4__["default"];
+
+ /**
+ @module ember
+ @submodule ember-routing
+ */
+
+ EmberView.reopen({
+
+ /**
+ Sets the private `_outlets` object on the view.
+
+ @method init
+ */
+ init: function() {
+ this._outlets = {};
+ this._super();
+ },
+
+ /**
+ Manually fill any of a view's `{{outlet}}` areas with the
+ supplied view.
+
+ Example
+
+ ```javascript
+ var MyView = Ember.View.extend({
+ template: Ember.Handlebars.compile('Child view: {{outlet "main"}} ')
+ });
+ var myView = MyView.create();
+ myView.appendTo('body');
+ // The html for myView now looks like:
+ //
Child view:
+
+ var FooView = Ember.View.extend({
+ template: Ember.Handlebars.compile('
Foo
')
+ });
+ var fooView = FooView.create();
+ myView.connectOutlet('main', fooView);
+ // The html for myView now looks like:
+ //
Child view:
+ //
Foo
+ //
+ ```
+ @method connectOutlet
+ @param {String} outletName A unique name for the outlet
+ @param {Object} view An Ember.View
+ */
+ connectOutlet: function(outletName, view) {
+ if (this._pendingDisconnections) {
+ delete this._pendingDisconnections[outletName];
+ }
+
+ if (this._hasEquivalentView(outletName, view)) {
+ view.destroy();
+ return;
+ }
+
+ var outlets = get(this, '_outlets');
+ var container = get(this, 'container');
+ var router = container && container.lookup('router:main');
+ var renderedName = get(view, 'renderedName');
+
+ set(outlets, outletName, view);
+
+ if (router && renderedName) {
+ router._connectActiveView(renderedName, view);
+ }
+ },
+
+ /**
+ Determines if the view has already been created by checking if
+ the view has the same constructor, template, and context as the
+ view in the `_outlets` object.
+
+ @private
+ @method _hasEquivalentView
+ @param {String} outletName The name of the outlet we are checking
+ @param {Object} view An Ember.View
+ @return {Boolean}
+ */
+ _hasEquivalentView: function(outletName, view) {
+ var existingView = get(this, '_outlets.'+outletName);
+ return existingView &&
+ existingView.constructor === view.constructor &&
+ existingView.get('template') === view.get('template') &&
+ existingView.get('context') === view.get('context');
+ },
+
+ /**
+ Removes an outlet from the view.
+
+ Example
+
+ ```javascript
+ var MyView = Ember.View.extend({
+ template: Ember.Handlebars.compile('Child view: {{outlet "main"}} ')
+ });
+ var myView = MyView.create();
+ myView.appendTo('body');
+ // myView's html:
+ //
Child view:
+
+ var FooView = Ember.View.extend({
+ template: Ember.Handlebars.compile('
+ ```
+
+ @method disconnectOutlet
+ @param {String} outletName The name of the outlet to be removed
+ */
+ disconnectOutlet: function(outletName) {
+ if (!this._pendingDisconnections) {
+ this._pendingDisconnections = {};
+ }
+ this._pendingDisconnections[outletName] = true;
+ run.once(this, '_finishDisconnections');
+ },
+
+ /**
+ Gets an outlet that is pending disconnection and then
+ nullifys the object on the `_outlet` object.
+
+ @private
+ @method _finishDisconnections
+ */
+ _finishDisconnections: function() {
+ if (this.isDestroyed) return; // _outlets will be gone anyway
+ var outlets = get(this, '_outlets');
+ var pendingDisconnections = this._pendingDisconnections;
+ this._pendingDisconnections = null;
+
+ for (var outletName in pendingDisconnections) {
+ set(outlets, outletName, null);
+ }
+ }
+ });
+
+ __exports__["default"] = EmberView;
+ });
+enifed("ember-routing/location/api",
+ ["ember-metal/core","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // deprecate, assert
+
+ /**
+ @module ember
+ @submodule ember-routing
+ */
+
+ /**
+ Ember.Location returns an instance of the correct implementation of
+ the `location` API.
+
+ ## Implementations
+
+ You can pass an implementation name (`hash`, `history`, `none`) to force a
+ particular implementation to be used in your application.
+
+ ### HashLocation
+
+ Using `HashLocation` results in URLs with a `#` (hash sign) separating the
+ server side URL portion of the URL from the portion that is used by Ember.
+ This relies upon the `hashchange` event existing in the browser.
+
+ Example:
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource('posts', function() {
+ this.route('new');
+ });
+ });
+
+ App.Router.reopen({
+ location: 'hash'
+ });
+ ```
+
+ This will result in a posts.new url of `/#/posts/new`.
+
+ ### HistoryLocation
+
+ Using `HistoryLocation` results in URLs that are indistinguishable from a
+ standard URL. This relies upon the browser's `history` API.
+
+ Example:
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource('posts', function() {
+ this.route('new');
+ });
+ });
+
+ App.Router.reopen({
+ location: 'history'
+ });
+ ```
+
+ This will result in a posts.new url of `/posts/new`.
+
+ Keep in mind that your server must serve the Ember app at all the routes you
+ define.
+
+ ### AutoLocation
+
+ Using `AutoLocation`, the router will use the best Location class supported by
+ the browser it is running in.
+
+ Browsers that support the `history` API will use `HistoryLocation`, those that
+ do not, but still support the `hashchange` event will use `HashLocation`, and
+ in the rare case neither is supported will use `NoneLocation`.
+
+ Example:
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource('posts', function() {
+ this.route('new');
+ });
+ });
+
+ App.Router.reopen({
+ location: 'auto'
+ });
+ ```
+
+ This will result in a posts.new url of `/posts/new` for modern browsers that
+ support the `history` api or `/#/posts/new` for older ones, like Internet
+ Explorer 9 and below.
+
+ When a user visits a link to your application, they will be automatically
+ upgraded or downgraded to the appropriate `Location` class, with the URL
+ transformed accordingly, if needed.
+
+ Keep in mind that since some of your users will use `HistoryLocation`, your
+ server must serve the Ember app at all the routes you define.
+
+ ### NoneLocation
+
+ Using `NoneLocation` causes Ember to not store the applications URL state
+ in the actual URL. This is generally used for testing purposes, and is one
+ of the changes made when calling `App.setupForTesting()`.
+
+ ## Location API
+
+ Each location implementation must provide the following methods:
+
+ * implementation: returns the string name used to reference the implementation.
+ * getURL: returns the current URL.
+ * setURL(path): sets the current URL.
+ * replaceURL(path): replace the current URL (optional).
+ * onUpdateURL(callback): triggers the callback when the URL changes.
+ * formatURL(url): formats `url` to be placed into `href` attribute.
+
+ Calling setURL or replaceURL will not trigger onUpdateURL callbacks.
+
+ @class Location
+ @namespace Ember
+ @static
+ */
+ __exports__["default"] = {
+ /**
+ This is deprecated in favor of using the container to lookup the location
+ implementation as desired.
+
+ For example:
+
+ ```javascript
+ // Given a location registered as follows:
+ container.register('location:history-test', HistoryTestLocation);
+
+ // You could create a new instance via:
+ container.lookup('location:history-test');
+ ```
+
+ @method create
+ @param {Object} options
+ @return {Object} an instance of an implementation of the `location` API
+ @deprecated Use the container to lookup the location implementation that you
+ need.
+ */
+ create: function(options) {
+ var implementation = options && options.implementation;
+ Ember.assert("Ember.Location.create: you must specify a 'implementation' option", !!implementation);
+
+ var implementationClass = this.implementations[implementation];
+ Ember.assert("Ember.Location.create: " + implementation + " is not a valid implementation", !!implementationClass);
+
+ return implementationClass.create.apply(implementationClass, arguments);
+ },
+
+ /**
+ This is deprecated in favor of using the container to register the
+ location implementation as desired.
+
+ Example:
+
+ ```javascript
+ Application.initializer({
+ name: "history-test-location",
+
+ initialize: function(container, application) {
+ application.register('location:history-test', HistoryTestLocation);
+ }
+ });
+ ```
+
+ @method registerImplementation
+ @param {String} name
+ @param {Object} implementation of the `location` API
+ @deprecated Register your custom location implementation with the
+ container directly.
+ */
+ registerImplementation: function(name, implementation) {
+ Ember.deprecate('Using the Ember.Location.registerImplementation is no longer supported.' +
+ ' Register your custom location implementation with the container instead.', false);
+
+ this.implementations[name] = implementation;
+ },
+
+ implementations: {},
+ _location: window.location,
+
+ /**
+ Returns the current `location.hash` by parsing location.href since browsers
+ inconsistently URL-decode `location.hash`.
+
+ https://bugzilla.mozilla.org/show_bug.cgi?id=483304
+
+ @private
+ @method getHash
+ @since 1.4.0
+ */
+ _getHash: function () {
+ // AutoLocation has it at _location, HashLocation at .location.
+ // Being nice and not changing
+ var href = (this._location || this.location).href;
+ var hashIndex = href.indexOf('#');
+
+ if (hashIndex === -1) {
+ return '';
+ } else {
+ return href.substr(hashIndex);
+ }
+ }
+ };
+ });
+enifed("ember-routing/location/auto_location",
+ ["ember-metal/core","ember-metal/property_set","ember-routing/location/api","ember-routing/location/history_location","ember-routing/location/hash_location","ember-routing/location/none_location","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // FEATURES
+ var set = __dependency2__.set;
+
+ var EmberLocation = __dependency3__["default"];
+ var HistoryLocation = __dependency4__["default"];
+ var HashLocation = __dependency5__["default"];
+ var NoneLocation = __dependency6__["default"];
+
+ /**
+ @module ember
+ @submodule ember-routing
+ */
+
+ /**
+ Ember.AutoLocation will select the best location option based off browser
+ support with the priority order: history, hash, none.
+
+ Clean pushState paths accessed by hashchange-only browsers will be redirected
+ to the hash-equivalent and vice versa so future transitions are consistent.
+
+ Keep in mind that since some of your users will use `HistoryLocation`, your
+ server must serve the Ember app at all the routes you define.
+
+ @class AutoLocation
+ @namespace Ember
+ @static
+ */
+ __exports__["default"] = {
+
+ /**
+ @private
+
+ This property is used by router:main to know whether to cancel the routing
+ setup process, which is needed while we redirect the browser.
+
+ @since 1.5.1
+ @property cancelRouterSetup
+ @default false
+ */
+ cancelRouterSetup: false,
+
+ /**
+ @private
+
+ Will be pre-pended to path upon state change.
+
+ @since 1.5.1
+ @property rootURL
+ @default '/'
+ */
+ rootURL: '/',
+
+ /**
+ @private
+
+ Attached for mocking in tests
+
+ @since 1.5.1
+ @property _window
+ @default window
+ */
+ _window: window,
+
+ /**
+ @private
+
+ Attached for mocking in tests
+
+ @property location
+ @default window.location
+ */
+ _location: window.location,
+
+ /**
+ @private
+
+ Attached for mocking in tests
+
+ @since 1.5.1
+ @property _history
+ @default window.history
+ */
+ _history: window.history,
+
+ /**
+ @private
+
+ Attached for mocking in tests
+
+ @since 1.5.1
+ @property _HistoryLocation
+ @default Ember.HistoryLocation
+ */
+ _HistoryLocation: HistoryLocation,
+
+ /**
+ @private
+
+ Attached for mocking in tests
+
+ @since 1.5.1
+ @property _HashLocation
+ @default Ember.HashLocation
+ */
+ _HashLocation: HashLocation,
+
+ /**
+ @private
+
+ Attached for mocking in tests
+
+ @since 1.5.1
+ @property _NoneLocation
+ @default Ember.NoneLocation
+ */
+ _NoneLocation: NoneLocation,
+
+ /**
+ @private
+
+ Returns location.origin or builds it if device doesn't support it.
+
+ @method _getOrigin
+ */
+ _getOrigin: function () {
+ var location = this._location;
+ var origin = location.origin;
+
+ // Older browsers, especially IE, don't have origin
+ if (!origin) {
+ origin = location.protocol + '//' + location.hostname;
+
+ if (location.port) {
+ origin += ':' + location.port;
+ }
+ }
+
+ return origin;
+ },
+
+ /**
+ @private
+
+ We assume that if the history object has a pushState method, the host should
+ support HistoryLocation.
+
+ @method _getSupportsHistory
+ */
+ _getSupportsHistory: function () {
+ // Boosted from Modernizr: https://github.com/Modernizr/Modernizr/blob/master/feature-detects/history.js
+ // The stock browser on Android 2.2 & 2.3 returns positive on history support
+ // Unfortunately support is really buggy and there is no clean way to detect
+ // these bugs, so we fall back to a user agent sniff :(
+ var userAgent = this._window.navigator.userAgent;
+
+ // We only want Android 2, stock browser, and not Chrome which identifies
+ // itself as 'Mobile Safari' as well
+ if (userAgent.indexOf('Android 2') !== -1 &&
+ userAgent.indexOf('Mobile Safari') !== -1 &&
+ userAgent.indexOf('Chrome') === -1) {
+ return false;
+ }
+
+ return !!(this._history && 'pushState' in this._history);
+ },
+
+ /**
+ @private
+
+ IE8 running in IE7 compatibility mode gives false positive, so we must also
+ check documentMode.
+
+ @method _getSupportsHashChange
+ */
+ _getSupportsHashChange: function () {
+ var _window = this._window;
+ var documentMode = _window.document.documentMode;
+
+ return ('onhashchange' in _window && (documentMode === undefined || documentMode > 7 ));
+ },
+
+ /**
+ @private
+
+ Redirects the browser using location.replace, prepending the locatin.origin
+ to prevent phishing attempts
+
+ @method _replacePath
+ */
+ _replacePath: function (path) {
+ this._location.replace(this._getOrigin() + path);
+ },
+
+ /**
+ @since 1.5.1
+ @private
+ @method _getRootURL
+ */
+ _getRootURL: function () {
+ return this.rootURL;
+ },
+
+ /**
+ @private
+
+ Returns the current `location.pathname`, normalized for IE inconsistencies.
+
+ @method _getPath
+ */
+ _getPath: function () {
+ var pathname = this._location.pathname;
+ // Various versions of IE/Opera don't always return a leading slash
+ if (pathname.charAt(0) !== '/') {
+ pathname = '/' + pathname;
+ }
+
+ return pathname;
+ },
+
+ /**
+ @private
+
+ Returns normalized location.hash as an alias to Ember.Location._getHash
+
+ @since 1.5.1
+ @method _getHash
+ */
+ _getHash: EmberLocation._getHash,
+
+ /**
+ @private
+
+ Returns location.search
+
+ @since 1.5.1
+ @method _getQuery
+ */
+ _getQuery: function () {
+ return this._location.search;
+ },
+
+ /**
+ @private
+
+ Returns the full pathname including query and hash
+
+ @method _getFullPath
+ */
+ _getFullPath: function () {
+ return this._getPath() + this._getQuery() + this._getHash();
+ },
+
+ /**
+ @private
+
+ Returns the current path as it should appear for HistoryLocation supported
+ browsers. This may very well differ from the real current path (e.g. if it
+ starts off as a hashed URL)
+
+ @method _getHistoryPath
+ */
+ _getHistoryPath: function () {
+ var rootURL = this._getRootURL();
+ var path = this._getPath();
+ var hash = this._getHash();
+ var query = this._getQuery();
+ var rootURLIndex = path.indexOf(rootURL);
+ var routeHash, hashParts;
+
+ Ember.assert('Path ' + path + ' does not start with the provided rootURL ' + rootURL, rootURLIndex === 0);
+
+ // By convention, Ember.js routes using HashLocation are required to start
+ // with `#/`. Anything else should NOT be considered a route and should
+ // be passed straight through, without transformation.
+ if (hash.substr(0, 2) === '#/') {
+ // There could be extra hash segments after the route
+ hashParts = hash.substr(1).split('#');
+ // The first one is always the route url
+ routeHash = hashParts.shift();
+
+ // If the path already has a trailing slash, remove the one
+ // from the hashed route so we don't double up.
+ if (path.slice(-1) === '/') {
+ routeHash = routeHash.substr(1);
+ }
+
+ // This is the "expected" final order
+ path += routeHash;
+ path += query;
+
+ if (hashParts.length) {
+ path += '#' + hashParts.join('#');
+ }
+ } else {
+ path += query;
+ path += hash;
+ }
+
+ return path;
+ },
+
+ /**
+ @private
+
+ Returns the current path as it should appear for HashLocation supported
+ browsers. This may very well differ from the real current path.
+
+ @method _getHashPath
+ */
+ _getHashPath: function () {
+ var rootURL = this._getRootURL();
+ var path = rootURL;
+ var historyPath = this._getHistoryPath();
+ var routePath = historyPath.substr(rootURL.length);
+
+ if (routePath !== '') {
+ if (routePath.charAt(0) !== '/') {
+ routePath = '/' + routePath;
+ }
+
+ path += '#' + routePath;
+ }
+
+ return path;
+ },
+
+ /**
+ Selects the best location option based off browser support and returns an
+ instance of that Location class.
+
+ @see Ember.AutoLocation
+ @method create
+ */
+ create: function (options) {
+ if (options && options.rootURL) {
+ Ember.assert('rootURL must end with a trailing forward slash e.g. "/app/"',
+ options.rootURL.charAt(options.rootURL.length-1) === '/');
+ this.rootURL = options.rootURL;
+ }
+
+ var historyPath, hashPath;
+ var cancelRouterSetup = false;
+ var implementationClass = this._NoneLocation;
+ var currentPath = this._getFullPath();
+
+ if (this._getSupportsHistory()) {
+ historyPath = this._getHistoryPath();
+
+ // Since we support history paths, let's be sure we're using them else
+ // switch the location over to it.
+ if (currentPath === historyPath) {
+ implementationClass = this._HistoryLocation;
+ } else {
+
+ if (currentPath.substr(0, 2) === '/#') {
+ this._history.replaceState({ path: historyPath }, null, historyPath);
+ implementationClass = this._HistoryLocation;
+ } else {
+ cancelRouterSetup = true;
+ this._replacePath(historyPath);
+ }
+ }
+
+ } else if (this._getSupportsHashChange()) {
+ hashPath = this._getHashPath();
+
+ // Be sure we're using a hashed path, otherwise let's switch over it to so
+ // we start off clean and consistent. We'll count an index path with no
+ // hash as "good enough" as well.
+ if (currentPath === hashPath || (currentPath === '/' && hashPath === '/#/')) {
+ implementationClass = this._HashLocation;
+ } else {
+ // Our URL isn't in the expected hash-supported format, so we want to
+ // cancel the router setup and replace the URL to start off clean
+ cancelRouterSetup = true;
+ this._replacePath(hashPath);
+ }
+ }
+
+ var implementation = implementationClass.create.apply(implementationClass, arguments);
+
+ if (cancelRouterSetup) {
+ set(implementation, 'cancelRouterSetup', true);
+ }
+
+ return implementation;
+ }
+ };
+ });
+enifed("ember-routing/location/hash_location",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/run_loop","ember-metal/utils","ember-runtime/system/object","ember-routing/location/api","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ var get = __dependency2__.get;
+ var set = __dependency3__.set;
+ var run = __dependency4__["default"];
+ var guidFor = __dependency5__.guidFor;
+
+ var EmberObject = __dependency6__["default"];
+ var EmberLocation = __dependency7__["default"];
+
+ /**
+ @module ember
+ @submodule ember-routing
+ */
+
+ /**
+ `Ember.HashLocation` implements the location API using the browser's
+ hash. At present, it relies on a `hashchange` event existing in the
+ browser.
+
+ @class HashLocation
+ @namespace Ember
+ @extends Ember.Object
+ */
+ __exports__["default"] = EmberObject.extend({
+ implementation: 'hash',
+
+ init: function() {
+ set(this, 'location', get(this, '_location') || window.location);
+ },
+
+ /**
+ @private
+
+ Returns normalized location.hash
+
+ @since 1.5.1
+ @method getHash
+ */
+ getHash: EmberLocation._getHash,
+
+ /**
+ Returns the normalized URL, constructed from `location.hash`.
+
+ e.g. `#/foo` => `/foo` as well as `#/foo#bar` => `/foo#bar`.
+
+ By convention, hashed paths must begin with a forward slash, otherwise they
+ are not treated as a path so we can distinguish intent.
+
+ @private
+ @method getURL
+ */
+ getURL: function() {
+ var originalPath = this.getHash().substr(1);
+ var outPath = originalPath;
+
+ if (outPath.charAt(0) !== '/') {
+ outPath = '/';
+
+ // Only add the # if the path isn't empty.
+ // We do NOT want `/#` since the ampersand
+ // is only included (conventionally) when
+ // the location.hash has a value
+ if (originalPath) {
+ outPath += '#' + originalPath;
+ }
+ }
+
+ return outPath;
+ },
+
+ /**
+ Set the `location.hash` and remembers what was set. This prevents
+ `onUpdateURL` callbacks from triggering when the hash was set by
+ `HashLocation`.
+
+ @private
+ @method setURL
+ @param path {String}
+ */
+ setURL: function(path) {
+ get(this, 'location').hash = path;
+ set(this, 'lastSetURL', path);
+ },
+
+ /**
+ Uses location.replace to update the url without a page reload
+ or history modification.
+
+ @private
+ @method replaceURL
+ @param path {String}
+ */
+ replaceURL: function(path) {
+ get(this, 'location').replace('#' + path);
+ set(this, 'lastSetURL', path);
+ },
+
+ /**
+ Register a callback to be invoked when the hash changes. These
+ callbacks will execute when the user presses the back or forward
+ button, but not after `setURL` is invoked.
+
+ @private
+ @method onUpdateURL
+ @param callback {Function}
+ */
+ onUpdateURL: function(callback) {
+ var self = this;
+ var guid = guidFor(this);
+
+ Ember.$(window).on('hashchange.ember-location-'+guid, function() {
+ run(function() {
+ var path = self.getURL();
+ if (get(self, 'lastSetURL') === path) { return; }
+
+ set(self, 'lastSetURL', null);
+
+ callback(path);
+ });
+ });
+ },
+
+ /**
+ Given a URL, formats it to be placed into the page as part
+ of an element's `href` attribute.
+
+ This is used, for example, when using the {{action}} helper
+ to generate a URL based on an event.
+
+ @private
+ @method formatURL
+ @param url {String}
+ */
+ formatURL: function(url) {
+ return '#' + url;
+ },
+
+ /**
+ Cleans up the HashLocation event listener.
+
+ @private
+ @method willDestroy
+ */
+ willDestroy: function() {
+ var guid = guidFor(this);
+
+ Ember.$(window).off('hashchange.ember-location-'+guid);
+ }
+ });
+ });
+enifed("ember-routing/location/history_location",
+ ["ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-runtime/system/object","ember-routing/location/api","ember-views/system/jquery","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
+ "use strict";
+ var get = __dependency1__.get;
+ var set = __dependency2__.set;
+ var guidFor = __dependency3__.guidFor;
+
+ var EmberObject = __dependency4__["default"];
+ var EmberLocation = __dependency5__["default"];
+ var jQuery = __dependency6__["default"];
+
+ /**
+ @module ember
+ @submodule ember-routing
+ */
+
+ var popstateFired = false;
+ var supportsHistoryState = window.history && 'state' in window.history;
+
+ /**
+ Ember.HistoryLocation implements the location API using the browser's
+ history.pushState API.
+
+ @class HistoryLocation
+ @namespace Ember
+ @extends Ember.Object
+ */
+ __exports__["default"] = EmberObject.extend({
+ implementation: 'history',
+
+ init: function() {
+ set(this, 'location', get(this, 'location') || window.location);
+ set(this, 'baseURL', jQuery('base').attr('href') || '');
+ },
+
+ /**
+ Used to set state on first call to setURL
+
+ @private
+ @method initState
+ */
+ initState: function() {
+ set(this, 'history', get(this, 'history') || window.history);
+ this.replaceState(this.formatURL(this.getURL()));
+ },
+
+ /**
+ Will be pre-pended to path upon state change
+
+ @property rootURL
+ @default '/'
+ */
+ rootURL: '/',
+
+ /**
+ Returns the current `location.pathname` without `rootURL` or `baseURL`
+
+ @private
+ @method getURL
+ @return url {String}
+ */
+ getURL: function() {
+ var rootURL = get(this, 'rootURL');
+ var location = get(this, 'location');
+ var path = location.pathname;
+ var baseURL = get(this, 'baseURL');
+
+ rootURL = rootURL.replace(/\/$/, '');
+ baseURL = baseURL.replace(/\/$/, '');
+
+ var url = path.replace(baseURL, '').replace(rootURL, '');
+ var search = location.search || '';
+
+ url += search;
+ url += this.getHash();
+
+ return url;
+ },
+
+ /**
+ Uses `history.pushState` to update the url without a page reload.
+
+ @private
+ @method setURL
+ @param path {String}
+ */
+ setURL: function(path) {
+ var state = this.getState();
+ path = this.formatURL(path);
+
+ if (!state || state.path !== path) {
+ this.pushState(path);
+ }
+ },
+
+ /**
+ Uses `history.replaceState` to update the url without a page reload
+ or history modification.
+
+ @private
+ @method replaceURL
+ @param path {String}
+ */
+ replaceURL: function(path) {
+ var state = this.getState();
+ path = this.formatURL(path);
+
+ if (!state || state.path !== path) {
+ this.replaceState(path);
+ }
+ },
+
+ /**
+ Get the current `history.state`. Checks for if a polyfill is
+ required and if so fetches this._historyState. The state returned
+ from getState may be null if an iframe has changed a window's
+ history.
+
+ @private
+ @method getState
+ @return state {Object}
+ */
+ getState: function() {
+ return supportsHistoryState ? get(this, 'history').state : this._historyState;
+ },
+
+ /**
+ Pushes a new state.
+
+ @private
+ @method pushState
+ @param path {String}
+ */
+ pushState: function(path) {
+ var state = { path: path };
+
+ get(this, 'history').pushState(state, null, path);
+
+ // store state if browser doesn't support `history.state`
+ if (!supportsHistoryState) {
+ this._historyState = state;
+ }
+
+ // used for webkit workaround
+ this._previousURL = this.getURL();
+ },
+
+ /**
+ Replaces the current state.
+
+ @private
+ @method replaceState
+ @param path {String}
+ */
+ replaceState: function(path) {
+ var state = { path: path };
+ get(this, 'history').replaceState(state, null, path);
+
+ // store state if browser doesn't support `history.state`
+ if (!supportsHistoryState) {
+ this._historyState = state;
+ }
+
+ // used for webkit workaround
+ this._previousURL = this.getURL();
+ },
+
+ /**
+ Register a callback to be invoked whenever the browser
+ history changes, including using forward and back buttons.
+
+ @private
+ @method onUpdateURL
+ @param callback {Function}
+ */
+ onUpdateURL: function(callback) {
+ var guid = guidFor(this);
+ var self = this;
+
+ jQuery(window).on('popstate.ember-location-'+guid, function(e) {
+ // Ignore initial page load popstate event in Chrome
+ if (!popstateFired) {
+ popstateFired = true;
+ if (self.getURL() === self._previousURL) { return; }
+ }
+ callback(self.getURL());
+ });
+ },
+
+ /**
+ Used when using `{{action}}` helper. The url is always appended to the rootURL.
+
+ @private
+ @method formatURL
+ @param url {String}
+ @return formatted url {String}
+ */
+ formatURL: function(url) {
+ var rootURL = get(this, 'rootURL');
+ var baseURL = get(this, 'baseURL');
+
+ if (url !== '') {
+ rootURL = rootURL.replace(/\/$/, '');
+ baseURL = baseURL.replace(/\/$/, '');
+ } else if(baseURL.match(/^\//) && rootURL.match(/^\//)) {
+ baseURL = baseURL.replace(/\/$/, '');
+ }
+
+ return baseURL + rootURL + url;
+ },
+
+ /**
+ Cleans up the HistoryLocation event listener.
+
+ @private
+ @method willDestroy
+ */
+ willDestroy: function() {
+ var guid = guidFor(this);
+
+ jQuery(window).off('popstate.ember-location-'+guid);
+ },
+
+ /**
+ @private
+
+ Returns normalized location.hash
+
+ @method getHash
+ */
+ getHash: EmberLocation._getHash
+ });
+ });
+enifed("ember-routing/location/none_location",
+ ["ember-metal/property_get","ember-metal/property_set","ember-runtime/system/object","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var get = __dependency1__.get;
+ var set = __dependency2__.set;
+ var EmberObject = __dependency3__["default"];
+
+ /**
+ @module ember
+ @submodule ember-routing
+ */
+
+ /**
+ Ember.NoneLocation does not interact with the browser. It is useful for
+ testing, or when you need to manage state with your Router, but temporarily
+ don't want it to muck with the URL (for example when you embed your
+ application in a larger page).
+
+ @class NoneLocation
+ @namespace Ember
+ @extends Ember.Object
+ */
+ __exports__["default"] = EmberObject.extend({
+ implementation: 'none',
+ path: '',
+
+ /**
+ Returns the current path.
+
+ @private
+ @method getURL
+ @return {String} path
+ */
+ getURL: function() {
+ return get(this, 'path');
+ },
+
+ /**
+ Set the path and remembers what was set. Using this method
+ to change the path will not invoke the `updateURL` callback.
+
+ @private
+ @method setURL
+ @param path {String}
+ */
+ setURL: function(path) {
+ set(this, 'path', path);
+ },
+
+ /**
+ Register a callback to be invoked when the path changes. These
+ callbacks will execute when the user presses the back or forward
+ button, but not after `setURL` is invoked.
+
+ @private
+ @method onUpdateURL
+ @param callback {Function}
+ */
+ onUpdateURL: function(callback) {
+ this.updateCallback = callback;
+ },
+
+ /**
+ Sets the path and calls the `updateURL` callback.
+
+ @private
+ @method handleURL
+ @param callback {Function}
+ */
+ handleURL: function(url) {
+ set(this, 'path', url);
+ this.updateCallback(url);
+ },
+
+ /**
+ Given a URL, formats it to be placed into the page as part
+ of an element's `href` attribute.
+
+ This is used, for example, when using the {{action}} helper
+ to generate a URL based on an event.
+
+ @private
+ @method formatURL
+ @param url {String}
+ @return {String} url
+ */
+ formatURL: function(url) {
+ // The return value is not overly meaningful, but we do not want to throw
+ // errors when test code renders templates containing {{action href=true}}
+ // helpers.
+ return url;
+ }
+ });
+ });
+enifed("ember-routing/system/cache",
+ ["ember-runtime/system/object","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var EmberObject = __dependency1__["default"];
+
+ __exports__["default"] = EmberObject.extend({
+ init: function() {
+ this.cache = {};
+ },
+ has: function(bucketKey) {
+ return bucketKey in this.cache;
+ },
+ stash: function(bucketKey, key, value) {
+ var bucket = this.cache[bucketKey];
+ if (!bucket) {
+ bucket = this.cache[bucketKey] = {};
+ }
+ bucket[key] = value;
+ },
+ lookup: function(bucketKey, prop, defaultValue) {
+ var cache = this.cache;
+ if (!(bucketKey in cache)) {
+ return defaultValue;
+ }
+ var bucket = cache[bucketKey];
+ if (prop in bucket) {
+ return bucket[prop];
+ } else {
+ return defaultValue;
+ }
+ },
+ cache: null
+ });
+ });
+enifed("ember-routing/system/controller_for",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-routing
+ */
+
+ /**
+
+ Finds a controller instance.
+
+ @for Ember
+ @method controllerFor
+ @private
+ */
+ __exports__["default"] = function controllerFor(container, controllerName, lookupOptions) {
+ return container.lookup('controller:' + controllerName, lookupOptions);
+ }
+ });
+enifed("ember-routing/system/dsl",
+ ["ember-metal/core","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // FEATURES, assert
+
+ /**
+ @module ember
+ @submodule ember-routing
+ */
+
+ function DSL(name) {
+ this.parent = name;
+ this.matches = [];
+ }
+ __exports__["default"] = DSL;
+
+ DSL.prototype = {
+ route: function(name, options, callback) {
+ if (arguments.length === 2 && typeof options === 'function') {
+ callback = options;
+ options = {};
+ }
+
+ if (arguments.length === 1) {
+ options = {};
+ }
+
+ var type = options.resetNamespace === true ? 'resource' : 'route';
+ Ember.assert("'basic' cannot be used as a " + type + " name.", name !== 'basic');
+
+
+ if (callback) {
+ var fullName = getFullName(this, name, options.resetNamespace);
+ var dsl = new DSL(fullName);
+ createRoute(dsl, 'loading');
+ createRoute(dsl, 'error', { path: "/_unused_dummy_error_path_route_" + name + "/:error" });
+
+ callback.call(dsl);
+
+ createRoute(this, name, options, dsl.generate());
+ } else {
+ createRoute(this, name, options);
+ }
+ },
+
+ push: function(url, name, callback) {
+ var parts = name.split('.');
+ if (url === "" || url === "/" || parts[parts.length-1] === "index") { this.explicitIndex = true; }
+
+ this.matches.push([url, name, callback]);
+ },
+
+ resource: function(name, options, callback) {
+ if (arguments.length === 2 && typeof options === 'function') {
+ callback = options;
+ options = {};
+ }
+
+ if (arguments.length === 1) {
+ options = {};
+ }
+
+ options.resetNamespace = true;
+ this.route(name, options, callback);
+ },
+
+ generate: function() {
+ var dslMatches = this.matches;
+
+ if (!this.explicitIndex) {
+ this.route("index", { path: "/" });
+ }
+
+ return function(match) {
+ for (var i=0, l=dslMatches.length; i " + fullName, { fullName: fullName });
+ }
+
+ return instance;
+ }
+ });
+enifed("ember-routing/system/query_params",
+ ["ember-runtime/system/object","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var EmberObject = __dependency1__["default"];
+
+ __exports__["default"] = EmberObject.extend({
+ isQueryParams: true,
+ values: null
+ });
+ });
+enifed("ember-routing/system/route",
+ ["ember-metal/core","ember-metal/error","ember-metal/property_get","ember-metal/property_set","ember-metal/get_properties","ember-metal/enumerable_utils","ember-metal/is_none","ember-metal/computed","ember-metal/merge","ember-metal/utils","ember-metal/run_loop","ember-metal/keys","ember-runtime/copy","ember-runtime/system/string","ember-runtime/system/object","ember-runtime/mixins/evented","ember-runtime/mixins/action_handler","ember-routing/system/generate_controller","ember-routing/utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // FEATURES, A, deprecate, assert, Logger
+ var EmberError = __dependency2__["default"];
+ var get = __dependency3__.get;
+ var set = __dependency4__.set;
+ var getProperties = __dependency5__["default"];
+ var forEach = __dependency6__.forEach;
+ var replace = __dependency6__.replace;
+ var isNone = __dependency7__["default"];
+ var computed = __dependency8__.computed;
+ var merge = __dependency9__["default"];
+ var isArray = __dependency10__.isArray;
+ var typeOf = __dependency10__.typeOf;
+ var run = __dependency11__["default"];
+ var keys = __dependency12__["default"];
+ var copy = __dependency13__["default"];
+ var classify = __dependency14__.classify;
+ var EmberObject = __dependency15__["default"];
+ var Evented = __dependency16__["default"];
+ var ActionHandler = __dependency17__["default"];
+ var generateController = __dependency18__["default"];
+ var stashParamNames = __dependency19__.stashParamNames;
+
+ var slice = Array.prototype.slice;
+
+ function K() { return this; }
+
+ /**
+ @module ember
+ @submodule ember-routing
+ */
+
+ /**
+ The `Ember.Route` class is used to define individual routes. Refer to
+ the [routing guide](http://emberjs.com/guides/routing/) for documentation.
+
+ @class Route
+ @namespace Ember
+ @extends Ember.Object
+ @uses Ember.ActionHandler
+ */
+ var Route = EmberObject.extend(ActionHandler, {
+ /**
+ Configuration hash for this route's queryParams. The possible
+ configuration options and their defaults are as follows
+ (assuming a query param whose URL key is `page`):
+
+ ```javascript
+ queryParams: {
+ page: {
+ // By default, controller query param properties don't
+ // cause a full transition when they are changed, but
+ // rather only cause the URL to update. Setting
+ // `refreshModel` to true will cause an "in-place"
+ // transition to occur, whereby the model hooks for
+ // this route (and any child routes) will re-fire, allowing
+ // you to reload models (e.g., from the server) using the
+ // updated query param values.
+ refreshModel: false,
+
+ // By default, changes to controller query param properties
+ // cause the URL to update via `pushState`, which means an
+ // item will be added to the browser's history, allowing
+ // you to use the back button to restore the app to the
+ // previous state before the query param property was changed.
+ // Setting `replace` to true will use `replaceState` (or its
+ // hash location equivalent), which causes no browser history
+ // item to be added. This options name and default value are
+ // the same as the `link-to` helper's `replace` option.
+ replace: false
+ }
+ }
+ ```
+
+ @property queryParams
+ @for Ember.Route
+ @type Hash
+ */
+ queryParams: {},
+
+ /**
+ @private
+
+ @property _qp
+ */
+ _qp: computed(function() {
+ var controllerName = this.controllerName || this.routeName;
+ var controllerClass = this.container.lookupFactory('controller:' + controllerName);
+
+ if (!controllerClass) {
+ return defaultQPMeta;
+ }
+
+ var controllerProto = controllerClass.proto();
+ var qpProps = get(controllerProto, '_normalizedQueryParams');
+ var cacheMeta = get(controllerProto, '_cacheMeta');
+
+ var qps = [], map = {}, self = this;
+ for (var propName in qpProps) {
+ if (!qpProps.hasOwnProperty(propName)) { continue; }
+
+ var desc = qpProps[propName];
+ var urlKey = desc.as || this.serializeQueryParamKey(propName);
+ var defaultValue = get(controllerProto, propName);
+
+ if (isArray(defaultValue)) {
+ defaultValue = Ember.A(defaultValue.slice());
+ }
+
+ var type = typeOf(defaultValue);
+ var defaultValueSerialized = this.serializeQueryParam(defaultValue, urlKey, type);
+ var fprop = controllerName + ':' + propName;
+ var qp = {
+ def: defaultValue,
+ sdef: defaultValueSerialized,
+ type: type,
+ urlKey: urlKey,
+ prop: propName,
+ fprop: fprop,
+ ctrl: controllerName,
+ cProto: controllerProto,
+ svalue: defaultValueSerialized,
+ cacheType: desc.scope,
+ route: this,
+ cacheMeta: cacheMeta[propName]
+ };
+
+ map[propName] = map[urlKey] = map[fprop] = qp;
+ qps.push(qp);
+ }
+
+ return {
+ qps: qps,
+ map: map,
+ states: {
+ active: function(controller, prop) {
+ return self._activeQPChanged(controller, map[prop]);
+ },
+ allowOverrides: function(controller, prop) {
+ return self._updatingQPChanged(controller, map[prop]);
+ },
+ changingKeys: function(controller, prop) {
+ return self._updateSerializedQPValue(controller, map[prop]);
+ }
+ }
+ };
+ }),
+
+ /**
+ @private
+
+ @property _names
+ */
+ _names: null,
+
+ /**
+ @private
+
+ @method _stashNames
+ */
+ _stashNames: function(_handlerInfo, dynamicParent) {
+ var handlerInfo = _handlerInfo;
+ if (this._names) { return; }
+ var names = this._names = handlerInfo._names;
+
+ if (!names.length) {
+ handlerInfo = dynamicParent;
+ names = handlerInfo && handlerInfo._names || [];
+ }
+
+ var qps = get(this, '_qp.qps');
+ var len = qps.length;
+
+ var namePaths = new Array(names.length);
+ for (var a = 0, nlen = names.length; a < nlen; ++a) {
+ namePaths[a] = handlerInfo.name + '.' + names[a];
+ }
+
+ for (var i = 0; i < len; ++i) {
+ var qp = qps[i];
+ var cacheMeta = qp.cacheMeta;
+ if (cacheMeta.scope === 'model') {
+ cacheMeta.parts = namePaths;
+ }
+ cacheMeta.prefix = qp.ctrl;
+ }
+ },
+
+ /**
+ @private
+
+ @property _updateSerializedQPValue
+ */
+ _updateSerializedQPValue: function(controller, qp) {
+ var value = get(controller, qp.prop);
+ qp.svalue = this.serializeQueryParam(value, qp.urlKey, qp.type);
+ },
+
+ /**
+ @private
+
+ @property _activeQPChanged
+ */
+ _activeQPChanged: function(controller, qp) {
+ var value = get(controller, qp.prop);
+ this.router._queuedQPChanges[qp.fprop] = value;
+ run.once(this, this._fireQueryParamTransition);
+ },
+
+ /**
+ @private
+ @method _updatingQPChanged
+ */
+ _updatingQPChanged: function(controller, qp) {
+ var router = this.router;
+ if (!router._qpUpdates) {
+ router._qpUpdates = {};
+ }
+ router._qpUpdates[qp.urlKey] = true;
+ },
+
+ mergedProperties: ['events', 'queryParams'],
+
+ /**
+ Retrieves parameters, for current route using the state.params
+ variable and getQueryParamsFor, using the supplied routeName.
+
+ @method paramsFor
+ @param {String} routename
+
+ */
+ paramsFor: function(name) {
+ var route = this.container.lookup('route:' + name);
+
+ if (!route) {
+ return {};
+ }
+
+ var transition = this.router.router.activeTransition;
+ var state = transition ? transition.state : this.router.router.state;
+
+ var params = {};
+ merge(params, state.params[name]);
+ merge(params, getQueryParamsFor(route, state));
+
+ return params;
+ },
+
+ /**
+ Serializes the query parameter key
+
+ @method serializeQueryParamKey
+ @param {String} controllerPropertyName
+ */
+ serializeQueryParamKey: function(controllerPropertyName) {
+ return controllerPropertyName;
+ },
+
+ /**
+ Serializes value of the query parameter based on defaultValueType
+
+ @method serializeQueryParam
+ @param {Object} value
+ @param {String} urlKey
+ @param {String} defaultValueType
+ */
+ serializeQueryParam: function(value, urlKey, defaultValueType) {
+ // urlKey isn't used here, but anyone overriding
+ // can use it to provide serialization specific
+ // to a certain query param.
+ if (defaultValueType === 'array') {
+ return JSON.stringify(value);
+ }
+ return '' + value;
+ },
+
+ /**
+ Deserializes value of the query parameter based on defaultValueType
+
+ @method deserializeQueryParam
+ @param {Object} value
+ @param {String} urlKey
+ @param {String} defaultValueType
+ */
+ deserializeQueryParam: function(value, urlKey, defaultValueType) {
+ // urlKey isn't used here, but anyone overriding
+ // can use it to provide deserialization specific
+ // to a certain query param.
+
+ // Use the defaultValueType of the default value (the initial value assigned to a
+ // controller query param property), to intelligently deserialize and cast.
+ if (defaultValueType === 'boolean') {
+ return (value === 'true') ? true : false;
+ } else if (defaultValueType === 'number') {
+ return (Number(value)).valueOf();
+ } else if (defaultValueType === 'array') {
+ return Ember.A(JSON.parse(value));
+ }
+ return value;
+ },
+
+
+ /**
+ @private
+ @property _fireQueryParamTransition
+ */
+ _fireQueryParamTransition: function() {
+ this.transitionTo({ queryParams: this.router._queuedQPChanges });
+ this.router._queuedQPChanges = {};
+ },
+
+ /**
+ @private
+
+ @property _optionsForQueryParam
+ */
+ _optionsForQueryParam: function(qp) {
+ return get(this, 'queryParams.' + qp.urlKey) || get(this, 'queryParams.' + qp.prop) || {};
+ },
+
+ /**
+ A hook you can use to reset controller values either when the model
+ changes or the route is exiting.
+
+ ```javascript
+ App.ArticlesRoute = Ember.Route.extend({
+ // ...
+
+ resetController: function (controller, isExiting, transition) {
+ if (isExiting) {
+ controller.set('page', 1);
+ }
+ }
+ });
+ ```
+
+ @method resetController
+ @param {Controller} controller instance
+ @param {Boolean} isExiting
+ @param {Object} transition
+ @since 1.7.0
+ */
+ resetController: K,
+
+ /**
+ @private
+
+ @method exit
+ */
+ exit: function() {
+ this.deactivate();
+
+ this.trigger('deactivate');
+
+ this.teardownViews();
+ },
+
+ /**
+ @private
+
+ @method _reset
+ @since 1.7.0
+ */
+ _reset: function(isExiting, transition) {
+ var controller = this.controller;
+
+ controller._qpDelegate = get(this, '_qp.states.inactive');
+
+ this.resetController(controller, isExiting, transition);
+ },
+
+ /**
+ @private
+
+ @method enter
+ */
+ enter: function() {
+ this.activate();
+
+ this.trigger('activate');
+
+ },
+
+ /**
+ The name of the view to use by default when rendering this routes template.
+
+ When rendering a template, the route will, by default, determine the
+ template and view to use from the name of the route itself. If you need to
+ define a specific view, set this property.
+
+ This is useful when multiple routes would benefit from using the same view
+ because it doesn't require a custom `renderTemplate` method. For example,
+ the following routes will all render using the `App.PostsListView` view:
+
+ ```javascript
+ var PostsList = Ember.Route.extend({
+ viewName: 'postsList'
+ });
+
+ App.PostsIndexRoute = PostsList.extend();
+ App.PostsArchivedRoute = PostsList.extend();
+ ```
+
+ @property viewName
+ @type String
+ @default null
+ @since 1.4.0
+ */
+ viewName: null,
+
+ /**
+ The name of the template to use by default when rendering this routes
+ template.
+
+ This is similar with `viewName`, but is useful when you just want a custom
+ template without a view.
+
+ ```javascript
+ var PostsList = Ember.Route.extend({
+ templateName: 'posts/list'
+ });
+
+ App.PostsIndexRoute = PostsList.extend();
+ App.PostsArchivedRoute = PostsList.extend();
+ ```
+
+ @property templateName
+ @type String
+ @default null
+ @since 1.4.0
+ */
+ templateName: null,
+
+ /**
+ The name of the controller to associate with this route.
+
+ By default, Ember will lookup a route's controller that matches the name
+ of the route (i.e. `App.PostController` for `App.PostRoute`). However,
+ if you would like to define a specific controller to use, you can do so
+ using this property.
+
+ This is useful in many ways, as the controller specified will be:
+
+ * passed to the `setupController` method.
+ * used as the controller for the view being rendered by the route.
+ * returned from a call to `controllerFor` for the route.
+
+ @property controllerName
+ @type String
+ @default null
+ @since 1.4.0
+ */
+ controllerName: null,
+
+ /**
+ The `willTransition` action is fired at the beginning of any
+ attempted transition with a `Transition` object as the sole
+ argument. This action can be used for aborting, redirecting,
+ or decorating the transition from the currently active routes.
+
+ A good example is preventing navigation when a form is
+ half-filled out:
+
+ ```javascript
+ App.ContactFormRoute = Ember.Route.extend({
+ actions: {
+ willTransition: function(transition) {
+ if (this.controller.get('userHasEnteredData')) {
+ this.controller.displayNavigationConfirm();
+ transition.abort();
+ }
+ }
+ }
+ });
+ ```
+
+ You can also redirect elsewhere by calling
+ `this.transitionTo('elsewhere')` from within `willTransition`.
+ Note that `willTransition` will not be fired for the
+ redirecting `transitionTo`, since `willTransition` doesn't
+ fire when there is already a transition underway. If you want
+ subsequent `willTransition` actions to fire for the redirecting
+ transition, you must first explicitly call
+ `transition.abort()`.
+
+ @event willTransition
+ @param {Transition} transition
+ */
+
+ /**
+ The `didTransition` action is fired after a transition has
+ successfully been completed. This occurs after the normal model
+ hooks (`beforeModel`, `model`, `afterModel`, `setupController`)
+ have resolved. The `didTransition` action has no arguments,
+ however, it can be useful for tracking page views or resetting
+ state on the controller.
+
+ ```javascript
+ App.LoginRoute = Ember.Route.extend({
+ actions: {
+ didTransition: function() {
+ this.controller.get('errors.base').clear();
+ return true; // Bubble the didTransition event
+ }
+ }
+ });
+ ```
+
+ @event didTransition
+ @since 1.2.0
+ */
+
+ /**
+ The `loading` action is fired on the route when a route's `model`
+ hook returns a promise that is not already resolved. The current
+ `Transition` object is the first parameter and the route that
+ triggered the loading event is the second parameter.
+
+ ```javascript
+ App.ApplicationRoute = Ember.Route.extend({
+ actions: {
+ loading: function(transition, route) {
+ var view = Ember.View.create({
+ classNames: ['app-loading']
+ })
+ .append();
+
+ this.router.one('didTransition', function() {
+ view.destroy();
+ });
+
+ return true; // Bubble the loading event
+ }
+ }
+ });
+ ```
+
+ @event loading
+ @param {Transition} transition
+ @param {Ember.Route} route The route that triggered the loading event
+ @since 1.2.0
+ */
+
+ /**
+ When attempting to transition into a route, any of the hooks
+ may return a promise that rejects, at which point an `error`
+ action will be fired on the partially-entered routes, allowing
+ for per-route error handling logic, or shared error handling
+ logic defined on a parent route.
+
+ Here is an example of an error handler that will be invoked
+ for rejected promises from the various hooks on the route,
+ as well as any unhandled errors from child routes:
+
+ ```javascript
+ App.AdminRoute = Ember.Route.extend({
+ beforeModel: function() {
+ return Ember.RSVP.reject('bad things!');
+ },
+
+ actions: {
+ error: function(error, transition) {
+ // Assuming we got here due to the error in `beforeModel`,
+ // we can expect that error === "bad things!",
+ // but a promise model rejecting would also
+ // call this hook, as would any errors encountered
+ // in `afterModel`.
+
+ // The `error` hook is also provided the failed
+ // `transition`, which can be stored and later
+ // `.retry()`d if desired.
+
+ this.transitionTo('login');
+ }
+ }
+ });
+ ```
+
+ `error` actions that bubble up all the way to `ApplicationRoute`
+ will fire a default error handler that logs the error. You can
+ specify your own global default error handler by overriding the
+ `error` handler on `ApplicationRoute`:
+
+ ```javascript
+ App.ApplicationRoute = Ember.Route.extend({
+ actions: {
+ error: function(error, transition) {
+ this.controllerFor('banner').displayError(error.message);
+ }
+ }
+ });
+ ```
+ @event error
+ @param {Error} error
+ @param {Transition} transition
+ */
+
+ /**
+ The controller associated with this route.
+
+ Example
+
+ ```javascript
+ App.FormRoute = Ember.Route.extend({
+ actions: {
+ willTransition: function(transition) {
+ if (this.controller.get('userHasEnteredData') &&
+ !confirm('Are you sure you want to abandon progress?')) {
+ transition.abort();
+ } else {
+ // Bubble the `willTransition` action so that
+ // parent routes can decide whether or not to abort.
+ return true;
+ }
+ }
+ }
+ });
+ ```
+
+ @property controller
+ @type Ember.Controller
+ @since 1.6.0
+ */
+
+ _actions: {
+
+ queryParamsDidChange: function(changed, totalPresent, removed) {
+ var qpMap = get(this, '_qp').map;
+
+ var totalChanged = keys(changed).concat(keys(removed));
+ for (var i = 0, len = totalChanged.length; i < len; ++i) {
+ var qp = qpMap[totalChanged[i]];
+ if (qp && get(this._optionsForQueryParam(qp), 'refreshModel')) {
+ this.refresh();
+ }
+ }
+
+ return true;
+ },
+
+ finalizeQueryParamChange: function(params, finalParams, transition) {
+ if (this.routeName !== 'application') { return true; }
+
+ // Transition object is absent for intermediate transitions.
+ if (!transition) { return; }
+
+ var handlerInfos = transition.state.handlerInfos;
+ var router = this.router;
+ var qpMeta = router._queryParamsFor(handlerInfos[handlerInfos.length-1].name);
+ var changes = router._qpUpdates;
+ var replaceUrl;
+
+ stashParamNames(router, handlerInfos);
+
+ for (var i = 0, len = qpMeta.qps.length; i < len; ++i) {
+ var qp = qpMeta.qps[i];
+ var route = qp.route;
+ var controller = route.controller;
+ var presentKey = qp.urlKey in params && qp.urlKey;
+
+ // Do a reverse lookup to see if the changed query
+ // param URL key corresponds to a QP property on
+ // this controller.
+ var value, svalue;
+ if (changes && qp.urlKey in changes) {
+ // Value updated in/before setupController
+ value = get(controller, qp.prop);
+ svalue = route.serializeQueryParam(value, qp.urlKey, qp.type);
+ } else {
+ if (presentKey) {
+ svalue = params[presentKey];
+ value = route.deserializeQueryParam(svalue, qp.urlKey, qp.type);
+ } else {
+ // No QP provided; use default value.
+ svalue = qp.sdef;
+ value = copyDefaultValue(qp.def);
+ }
+ }
+
+ controller._qpDelegate = get(this, '_qp.states.inactive');
+
+ var thisQueryParamChanged = (svalue !== qp.svalue);
+ if (thisQueryParamChanged) {
+ if (transition.queryParamsOnly && replaceUrl !== false) {
+ var options = route._optionsForQueryParam(qp);
+ var replaceConfigValue = get(options, 'replace');
+ if (replaceConfigValue) {
+ replaceUrl = true;
+ } else if (replaceConfigValue === false) {
+ // Explicit pushState wins over any other replaceStates.
+ replaceUrl = false;
+ }
+ }
+
+ set(controller, qp.prop, value);
+ }
+
+ // Stash current serialized value of controller.
+ qp.svalue = svalue;
+
+ var thisQueryParamHasDefaultValue = (qp.sdef === svalue);
+ if (!thisQueryParamHasDefaultValue) {
+ finalParams.push({
+ value: svalue,
+ visible: true,
+ key: presentKey || qp.urlKey
+ });
+ }
+ }
+
+ if (replaceUrl) {
+ transition.method('replace');
+ }
+
+ forEach(qpMeta.qps, function(qp) {
+ var routeQpMeta = get(qp.route, '_qp');
+ var finalizedController = qp.route.controller;
+ finalizedController._qpDelegate = get(routeQpMeta, 'states.active');
+ });
+
+ router._qpUpdates = null;
+ }
+ },
+
+ /**
+ @deprecated
+
+ Please use `actions` instead.
+ @method events
+ */
+ events: null,
+
+ /**
+ This hook is executed when the router completely exits this route. It is
+ not executed when the model for the route changes.
+
+ @method deactivate
+ */
+ deactivate: K,
+
+ /**
+ This hook is executed when the router enters the route. It is not executed
+ when the model for the route changes.
+
+ @method activate
+ */
+ activate: K,
+
+ /**
+ Transition the application into another route. The route may
+ be either a single route or route path:
+
+ ```javascript
+ this.transitionTo('blogPosts');
+ this.transitionTo('blogPosts.recentEntries');
+ ```
+
+ Optionally supply a model for the route in question. The model
+ will be serialized into the URL using the `serialize` hook of
+ the route:
+
+ ```javascript
+ this.transitionTo('blogPost', aPost);
+ ```
+
+ If a literal is passed (such as a number or a string), it will
+ be treated as an identifier instead. In this case, the `model`
+ hook of the route will be triggered:
+
+ ```javascript
+ this.transitionTo('blogPost', 1);
+ ```
+
+ Multiple models will be applied last to first recursively up the
+ resource tree.
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource('blogPost', { path:':blogPostId' }, function() {
+ this.resource('blogComment', { path: ':blogCommentId' });
+ });
+ });
+
+ this.transitionTo('blogComment', aPost, aComment);
+ this.transitionTo('blogComment', 1, 13);
+ ```
+
+ It is also possible to pass a URL (a string that starts with a
+ `/`). This is intended for testing and debugging purposes and
+ should rarely be used in production code.
+
+ ```javascript
+ this.transitionTo('/');
+ this.transitionTo('/blog/post/1/comment/13');
+ this.transitionTo('/blog/posts?sort=title');
+ ```
+
+ An options hash with a `queryParams` property may be provided as
+ the final argument to add query parameters to the destination URL.
+
+ ```javascript
+ this.transitionTo('blogPost', 1, {
+ queryParams: {showComments: 'true'}
+ });
+
+ // if you just want to transition the query parameters without changing the route
+ this.transitionTo({queryParams: {sort: 'date'}});
+ ```
+
+ See also 'replaceWith'.
+
+ Simple Transition Example
+
+ ```javascript
+ App.Router.map(function() {
+ this.route('index');
+ this.route('secret');
+ this.route('fourOhFour', { path: '*:' });
+ });
+
+ App.IndexRoute = Ember.Route.extend({
+ actions: {
+ moveToSecret: function(context) {
+ if (authorized()) {
+ this.transitionTo('secret', context);
+ } else {
+ this.transitionTo('fourOhFour');
+ }
+ }
+ }
+ });
+ ```
+
+ Transition to a nested route
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource('articles', { path: '/articles' }, function() {
+ this.route('new');
+ });
+ });
+
+ App.IndexRoute = Ember.Route.extend({
+ actions: {
+ transitionToNewArticle: function() {
+ this.transitionTo('articles.new');
+ }
+ }
+ });
+ ```
+
+ Multiple Models Example
+
+ ```javascript
+ App.Router.map(function() {
+ this.route('index');
+
+ this.resource('breakfast', { path: ':breakfastId' }, function() {
+ this.resource('cereal', { path: ':cerealId' });
+ });
+ });
+
+ App.IndexRoute = Ember.Route.extend({
+ actions: {
+ moveToChocolateCereal: function() {
+ var cereal = { cerealId: 'ChocolateYumminess' };
+ var breakfast = { breakfastId: 'CerealAndMilk' };
+
+ this.transitionTo('cereal', breakfast, cereal);
+ }
+ }
+ });
+ ```
+
+ Nested Route with Query String Example
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource('fruits', function() {
+ this.route('apples');
+ });
+ });
+
+ App.IndexRoute = Ember.Route.extend({
+ actions: {
+ transitionToApples: function() {
+ this.transitionTo('fruits.apples', {queryParams: {color: 'red'}});
+ }
+ }
+ });
+ ```
+
+ @method transitionTo
+ @param {String} name the name of the route or a URL
+ @param {...Object} models the model(s) or identifier(s) to be used while
+ transitioning to the route.
+ @param {Object} [options] optional hash with a queryParams property
+ containing a mapping of query parameters
+ @return {Transition} the transition object associated with this
+ attempted transition
+ */
+ transitionTo: function(name, context) {
+ var router = this.router;
+ return router.transitionTo.apply(router, arguments);
+ },
+
+ /**
+ Perform a synchronous transition into another route without attempting
+ to resolve promises, update the URL, or abort any currently active
+ asynchronous transitions (i.e. regular transitions caused by
+ `transitionTo` or URL changes).
+
+ This method is handy for performing intermediate transitions on the
+ way to a final destination route, and is called internally by the
+ default implementations of the `error` and `loading` handlers.
+
+ @method intermediateTransitionTo
+ @param {String} name the name of the route
+ @param {...Object} models the model(s) to be used while transitioning
+ to the route.
+ @since 1.2.0
+ */
+ intermediateTransitionTo: function() {
+ var router = this.router;
+ router.intermediateTransitionTo.apply(router, arguments);
+ },
+
+ /**
+ Refresh the model on this route and any child routes, firing the
+ `beforeModel`, `model`, and `afterModel` hooks in a similar fashion
+ to how routes are entered when transitioning in from other route.
+ The current route params (e.g. `article_id`) will be passed in
+ to the respective model hooks, and if a different model is returned,
+ `setupController` and associated route hooks will re-fire as well.
+
+ An example usage of this method is re-querying the server for the
+ latest information using the same parameters as when the route
+ was first entered.
+
+ Note that this will cause `model` hooks to fire even on routes
+ that were provided a model object when the route was initially
+ entered.
+
+ @method refresh
+ @return {Transition} the transition object associated with this
+ attempted transition
+ @since 1.4.0
+ */
+ refresh: function() {
+ return this.router.router.refresh(this);
+ },
+
+ /**
+ Transition into another route while replacing the current URL, if possible.
+ This will replace the current history entry instead of adding a new one.
+ Beside that, it is identical to `transitionTo` in all other respects. See
+ 'transitionTo' for additional information regarding multiple models.
+
+ Example
+
+ ```javascript
+ App.Router.map(function() {
+ this.route('index');
+ this.route('secret');
+ });
+
+ App.SecretRoute = Ember.Route.extend({
+ afterModel: function() {
+ if (!authorized()){
+ this.replaceWith('index');
+ }
+ }
+ });
+ ```
+
+ @method replaceWith
+ @param {String} name the name of the route or a URL
+ @param {...Object} models the model(s) or identifier(s) to be used while
+ transitioning to the route.
+ @return {Transition} the transition object associated with this
+ attempted transition
+ */
+ replaceWith: function() {
+ var router = this.router;
+ return router.replaceWith.apply(router, arguments);
+ },
+
+ /**
+ Sends an action to the router, which will delegate it to the currently
+ active route hierarchy per the bubbling rules explained under `actions`.
+
+ Example
+
+ ```javascript
+ App.Router.map(function() {
+ this.route('index');
+ });
+
+ App.ApplicationRoute = Ember.Route.extend({
+ actions: {
+ track: function(arg) {
+ console.log(arg, 'was clicked');
+ }
+ }
+ });
+
+ App.IndexRoute = Ember.Route.extend({
+ actions: {
+ trackIfDebug: function(arg) {
+ if (debug) {
+ this.send('track', arg);
+ }
+ }
+ }
+ });
+ ```
+
+ @method send
+ @param {String} name the name of the action to trigger
+ @param {...*} args
+ */
+ send: function() {
+ if (this.router || !Ember.testing) {
+ this.router.send.apply(this.router, arguments);
+ } else {
+ var name = arguments[0];
+ var args = slice.call(arguments, 1);
+ var action = this._actions[name];
+ if (action) {
+ return this._actions[name].apply(this, args);
+ }
+ }
+ },
+
+ /**
+ This hook is the entry point for router.js
+
+ @private
+ @method setup
+ */
+ setup: function(context, transition) {
+ var controllerName = this.controllerName || this.routeName;
+ var controller = this.controllerFor(controllerName, true);
+
+ if (!controller) {
+ controller = this.generateController(controllerName, context);
+ }
+
+ // Assign the route's controller so that it can more easily be
+ // referenced in action handlers
+ this.controller = controller;
+
+ if (this.setupControllers) {
+ Ember.deprecate("Ember.Route.setupControllers is deprecated. Please use Ember.Route.setupController(controller, model) instead.");
+ this.setupControllers(controller, context);
+ } else {
+ var states = get(this, '_qp.states');
+ if (transition) {
+ // Update the model dep values used to calculate cache keys.
+ stashParamNames(this.router, transition.state.handlerInfos);
+ controller._qpDelegate = states.changingKeys;
+ controller._updateCacheParams(transition.params);
+ }
+ controller._qpDelegate = states.allowOverrides;
+
+ if (transition) {
+ var qpValues = getQueryParamsFor(this, transition.state);
+ controller.setProperties(qpValues);
+ }
+
+ this.setupController(controller, context, transition);
+ }
+
+ if (this.renderTemplates) {
+ Ember.deprecate("Ember.Route.renderTemplates is deprecated. Please use Ember.Route.renderTemplate(controller, model) instead.");
+ this.renderTemplates(context);
+ } else {
+ this.renderTemplate(controller, context);
+ }
+ },
+
+ /**
+ This hook is the first of the route entry validation hooks
+ called when an attempt is made to transition into a route
+ or one of its children. It is called before `model` and
+ `afterModel`, and is appropriate for cases when:
+
+ 1) A decision can be made to redirect elsewhere without
+ needing to resolve the model first.
+ 2) Any async operations need to occur first before the
+ model is attempted to be resolved.
+
+ This hook is provided the current `transition` attempt
+ as a parameter, which can be used to `.abort()` the transition,
+ save it for a later `.retry()`, or retrieve values set
+ on it from a previous hook. You can also just call
+ `this.transitionTo` to another route to implicitly
+ abort the `transition`.
+
+ You can return a promise from this hook to pause the
+ transition until the promise resolves (or rejects). This could
+ be useful, for instance, for retrieving async code from
+ the server that is required to enter a route.
+
+ ```javascript
+ App.PostRoute = Ember.Route.extend({
+ beforeModel: function(transition) {
+ if (!App.Post) {
+ return Ember.$.getScript('/models/post.js');
+ }
+ }
+ });
+ ```
+
+ If `App.Post` doesn't exist in the above example,
+ `beforeModel` will use jQuery's `getScript`, which
+ returns a promise that resolves after the server has
+ successfully retrieved and executed the code from the
+ server. Note that if an error were to occur, it would
+ be passed to the `error` hook on `Ember.Route`, but
+ it's also possible to handle errors specific to
+ `beforeModel` right from within the hook (to distinguish
+ from the shared error handling behavior of the `error`
+ hook):
+
+ ```javascript
+ App.PostRoute = Ember.Route.extend({
+ beforeModel: function(transition) {
+ if (!App.Post) {
+ var self = this;
+ return Ember.$.getScript('post.js').then(null, function(e) {
+ self.transitionTo('help');
+
+ // Note that the above transitionTo will implicitly
+ // halt the transition. If you were to return
+ // nothing from this promise reject handler,
+ // according to promise semantics, that would
+ // convert the reject into a resolve and the
+ // transition would continue. To propagate the
+ // error so that it'd be handled by the `error`
+ // hook, you would have to
+ return Ember.RSVP.reject(e);
+ });
+ }
+ }
+ });
+ ```
+
+ @method beforeModel
+ @param {Transition} transition
+ @return {Promise} if the value returned from this hook is
+ a promise, the transition will pause until the transition
+ resolves. Otherwise, non-promise return values are not
+ utilized in any way.
+ */
+ beforeModel: K,
+
+ /**
+ This hook is called after this route's model has resolved.
+ It follows identical async/promise semantics to `beforeModel`
+ but is provided the route's resolved model in addition to
+ the `transition`, and is therefore suited to performing
+ logic that can only take place after the model has already
+ resolved.
+
+ ```javascript
+ App.PostsRoute = Ember.Route.extend({
+ afterModel: function(posts, transition) {
+ if (posts.get('length') === 1) {
+ this.transitionTo('post.show', posts.get('firstObject'));
+ }
+ }
+ });
+ ```
+
+ Refer to documentation for `beforeModel` for a description
+ of transition-pausing semantics when a promise is returned
+ from this hook.
+
+ @method afterModel
+ @param {Object} resolvedModel the value returned from `model`,
+ or its resolved value if it was a promise
+ @param {Transition} transition
+ @return {Promise} if the value returned from this hook is
+ a promise, the transition will pause until the transition
+ resolves. Otherwise, non-promise return values are not
+ utilized in any way.
+ */
+ afterModel: K,
+
+ /**
+ A hook you can implement to optionally redirect to another route.
+
+ If you call `this.transitionTo` from inside of this hook, this route
+ will not be entered in favor of the other hook.
+
+ `redirect` and `afterModel` behave very similarly and are
+ called almost at the same time, but they have an important
+ distinction in the case that, from one of these hooks, a
+ redirect into a child route of this route occurs: redirects
+ from `afterModel` essentially invalidate the current attempt
+ to enter this route, and will result in this route's `beforeModel`,
+ `model`, and `afterModel` hooks being fired again within
+ the new, redirecting transition. Redirects that occur within
+ the `redirect` hook, on the other hand, will _not_ cause
+ these hooks to be fired again the second time around; in
+ other words, by the time the `redirect` hook has been called,
+ both the resolved model and attempted entry into this route
+ are considered to be fully validated.
+
+ @method redirect
+ @param {Object} model the model for this route
+ @param {Transition} transition the transition object associated with the current transition
+ */
+ redirect: K,
+
+ /**
+ Called when the context is changed by router.js.
+
+ @private
+ @method contextDidChange
+ */
+ contextDidChange: function() {
+ this.currentModel = this.context;
+ },
+
+ /**
+ A hook you can implement to convert the URL into the model for
+ this route.
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource('post', { path: '/posts/:post_id' });
+ });
+ ```
+
+ The model for the `post` route is `store.find('post', params.post_id)`.
+
+ By default, if your route has a dynamic segment ending in `_id`:
+
+ * The model class is determined from the segment (`post_id`'s
+ class is `App.Post`)
+ * The find method is called on the model class with the value of
+ the dynamic segment.
+
+ Note that for routes with dynamic segments, this hook is not always
+ executed. If the route is entered through a transition (e.g. when
+ using the `link-to` Handlebars helper or the `transitionTo` method
+ of routes), and a model context is already provided this hook
+ is not called.
+
+ A model context does not include a primitive string or number,
+ which does cause the model hook to be called.
+
+ Routes without dynamic segments will always execute the model hook.
+
+ ```javascript
+ // no dynamic segment, model hook always called
+ this.transitionTo('posts');
+
+ // model passed in, so model hook not called
+ thePost = store.find('post', 1);
+ this.transitionTo('post', thePost);
+
+ // integer passed in, model hook is called
+ this.transitionTo('post', 1);
+ ```
+
+
+ This hook follows the asynchronous/promise semantics
+ described in the documentation for `beforeModel`. In particular,
+ if a promise returned from `model` fails, the error will be
+ handled by the `error` hook on `Ember.Route`.
+
+ Example
+
+ ```javascript
+ App.PostRoute = Ember.Route.extend({
+ model: function(params) {
+ return this.store.find('post', params.post_id);
+ }
+ });
+ ```
+
+ @method model
+ @param {Object} params the parameters extracted from the URL
+ @param {Transition} transition
+ @return {Object|Promise} the model for this route. If
+ a promise is returned, the transition will pause until
+ the promise resolves, and the resolved value of the promise
+ will be used as the model for this route.
+ */
+ model: function(params, transition) {
+ var match, name, sawParams, value;
+
+ var queryParams = get(this, '_qp.map');
+
+ for (var prop in params) {
+ if (prop === 'queryParams' || (queryParams && prop in queryParams)) {
+ continue;
+ }
+
+ if (match = prop.match(/^(.*)_id$/)) {
+ name = match[1];
+ value = params[prop];
+ }
+ sawParams = true;
+ }
+
+ if (!name && sawParams) { return copy(params); }
+ else if (!name) {
+ if (transition.resolveIndex < 1) { return; }
+
+ var parentModel = transition.state.handlerInfos[transition.resolveIndex-1].context;
+
+ return parentModel;
+ }
+
+ return this.findModel(name, value);
+ },
+
+ /**
+ @private
+ @method deserialize
+ @param {Object} params the parameters extracted from the URL
+ @param {Transition} transition
+ @return {Object|Promise} the model for this route.
+
+ Router.js hook.
+ */
+ deserialize: function(params, transition) {
+ return this.model(this.paramsFor(this.routeName), transition);
+ },
+
+ /**
+
+ @method findModel
+ @param {String} type the model type
+ @param {Object} value the value passed to find
+ */
+ findModel: function(){
+ var store = get(this, 'store');
+ return store.find.apply(store, arguments);
+ },
+
+ /**
+ Store property provides a hook for data persistence libraries to inject themselves.
+
+ By default, this store property provides the exact same functionality previously
+ in the model hook.
+
+ Currently, the required interface is:
+
+ `store.find(modelName, findArguments)`
+
+ @method store
+ @param {Object} store
+ */
+ store: computed(function(){
+ var container = this.container;
+ var routeName = this.routeName;
+ var namespace = get(this, 'router.namespace');
+
+ return {
+ find: function(name, value) {
+ var modelClass = container.lookupFactory('model:' + name);
+
+ Ember.assert("You used the dynamic segment " + name + "_id in your route " +
+ routeName + ", but " + namespace + "." + classify(name) +
+ " did not exist and you did not override your route's `model` " +
+ "hook.", !!modelClass);
+
+ if (!modelClass) { return; }
+
+ Ember.assert(classify(name) + ' has no method `find`.', typeof modelClass.find === 'function');
+
+ return modelClass.find(value);
+ }
+ };
+ }),
+
+ /**
+ A hook you can implement to convert the route's model into parameters
+ for the URL.
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource('post', { path: '/posts/:post_id' });
+ });
+
+ App.PostRoute = Ember.Route.extend({
+ model: function(params) {
+ // the server returns `{ id: 12 }`
+ return Ember.$.getJSON('/posts/' + params.post_id);
+ },
+
+ serialize: function(model) {
+ // this will make the URL `/posts/12`
+ return { post_id: model.id };
+ }
+ });
+ ```
+
+ The default `serialize` method will insert the model's `id` into the
+ route's dynamic segment (in this case, `:post_id`) if the segment contains '_id'.
+ If the route has multiple dynamic segments or does not contain '_id', `serialize`
+ will return `Ember.getProperties(model, params)`
+
+ This method is called when `transitionTo` is called with a context
+ in order to populate the URL.
+
+ @method serialize
+ @param {Object} model the route's model
+ @param {Array} params an Array of parameter names for the current
+ route (in the example, `['post_id']`.
+ @return {Object} the serialized parameters
+ */
+ serialize: function(model, params) {
+ if (params.length < 1) { return; }
+ if (!model) { return; }
+
+ var name = params[0], object = {};
+
+ if (params.length === 1) {
+ if (name in model) {
+ object[name] = get(model, name);
+ } else if (/_id$/.test(name)) {
+ object[name] = get(model, "id");
+ }
+ } else {
+ object = getProperties(model, params);
+ }
+
+ return object;
+ },
+
+ /**
+ A hook you can use to setup the controller for the current route.
+
+ This method is called with the controller for the current route and the
+ model supplied by the `model` hook.
+
+ By default, the `setupController` hook sets the `model` property of
+ the controller to the `model`.
+
+ If you implement the `setupController` hook in your Route, it will
+ prevent this default behavior. If you want to preserve that behavior
+ when implementing your `setupController` function, make sure to call
+ `_super`:
+
+ ```javascript
+ App.PhotosRoute = Ember.Route.extend({
+ model: function() {
+ return this.store.find('photo');
+ },
+
+ setupController: function (controller, model) {
+ // Call _super for default behavior
+ this._super(controller, model);
+ // Implement your custom setup after
+ this.controllerFor('application').set('showingPhotos', true);
+ }
+ });
+ ```
+
+ This means that your template will get a proxy for the model as its
+ context, and you can act as though the model itself was the context.
+
+ The provided controller will be one resolved based on the name
+ of this route.
+
+ If no explicit controller is defined, Ember will automatically create
+ an appropriate controller for the model.
+
+ * if the model is an `Ember.Array` (including record arrays from Ember
+ Data), the controller is an `Ember.ArrayController`.
+ * otherwise, the controller is an `Ember.ObjectController`.
+
+ As an example, consider the router:
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource('post', { path: '/posts/:post_id' });
+ });
+ ```
+
+ For the `post` route, a controller named `App.PostController` would
+ be used if it is defined. If it is not defined, an `Ember.ObjectController`
+ instance would be used.
+
+ Example
+
+ ```javascript
+ App.PostRoute = Ember.Route.extend({
+ setupController: function(controller, model) {
+ controller.set('model', model);
+ }
+ });
+ ```
+
+ @method setupController
+ @param {Controller} controller instance
+ @param {Object} model
+ */
+ setupController: function(controller, context, transition) {
+ if (controller && (context !== undefined)) {
+ set(controller, 'model', context);
+ }
+ },
+
+ /**
+ Returns the controller for a particular route or name.
+
+ The controller instance must already have been created, either through entering the
+ associated route or using `generateController`.
+
+ ```javascript
+ App.PostRoute = Ember.Route.extend({
+ setupController: function(controller, post) {
+ this._super(controller, post);
+ this.controllerFor('posts').set('currentPost', post);
+ }
+ });
+ ```
+
+ @method controllerFor
+ @param {String} name the name of the route or controller
+ @return {Ember.Controller}
+ */
+ controllerFor: function(name, _skipAssert) {
+ var container = this.container;
+ var route = container.lookup('route:'+name);
+ var controller;
+
+ if (route && route.controllerName) {
+ name = route.controllerName;
+ }
+
+ controller = container.lookup('controller:' + name);
+
+ // NOTE: We're specifically checking that skipAssert is true, because according
+ // to the old API the second parameter was model. We do not want people who
+ // passed a model to skip the assertion.
+ Ember.assert("The controller named '"+name+"' could not be found. Make sure " +
+ "that this route exists and has already been entered at least " +
+ "once. If you are accessing a controller not associated with a " +
+ "route, make sure the controller class is explicitly defined.",
+ controller || _skipAssert === true);
+
+ return controller;
+ },
+
+ /**
+ Generates a controller for a route.
+
+ If the optional model is passed then the controller type is determined automatically,
+ e.g., an ArrayController for arrays.
+
+ Example
+
+ ```javascript
+ App.PostRoute = Ember.Route.extend({
+ setupController: function(controller, post) {
+ this._super(controller, post);
+ this.generateController('posts', post);
+ }
+ });
+ ```
+
+ @method generateController
+ @param {String} name the name of the controller
+ @param {Object} model the model to infer the type of the controller (optional)
+ */
+ generateController: function(name, model) {
+ var container = this.container;
+
+ model = model || this.modelFor(name);
+
+ return generateController(container, name, model);
+ },
+
+ /**
+ Returns the model of a parent (or any ancestor) route
+ in a route hierarchy. During a transition, all routes
+ must resolve a model object, and if a route
+ needs access to a parent route's model in order to
+ resolve a model (or just reuse the model from a parent),
+ it can call `this.modelFor(theNameOfParentRoute)` to
+ retrieve it.
+
+ Example
+
+ ```javascript
+ App.Router.map(function() {
+ this.resource('post', { path: '/post/:post_id' }, function() {
+ this.resource('comments');
+ });
+ });
+
+ App.CommentsRoute = Ember.Route.extend({
+ afterModel: function() {
+ this.set('post', this.modelFor('post'));
+ }
+ });
+ ```
+
+ @method modelFor
+ @param {String} name the name of the route
+ @return {Object} the model object
+ */
+ modelFor: function(name) {
+ var route = this.container.lookup('route:' + name);
+ var transition = this.router ? this.router.router.activeTransition : null;
+
+ // If we are mid-transition, we want to try and look up
+ // resolved parent contexts on the current transitionEvent.
+ if (transition) {
+ var modelLookupName = (route && route.routeName) || name;
+ if (transition.resolvedModels.hasOwnProperty(modelLookupName)) {
+ return transition.resolvedModels[modelLookupName];
+ }
+ }
+
+ return route && route.currentModel;
+ },
+
+ /**
+ A hook you can use to render the template for the current route.
+
+ This method is called with the controller for the current route and the
+ model supplied by the `model` hook. By default, it renders the route's
+ template, configured with the controller for the route.
+
+ This method can be overridden to set up and render additional or
+ alternative templates.
+
+ ```javascript
+ App.PostsRoute = Ember.Route.extend({
+ renderTemplate: function(controller, model) {
+ var favController = this.controllerFor('favoritePost');
+
+ // Render the `favoritePost` template into
+ // the outlet `posts`, and display the `favoritePost`
+ // controller.
+ this.render('favoritePost', {
+ outlet: 'posts',
+ controller: favController
+ });
+ }
+ });
+ ```
+
+ @method renderTemplate
+ @param {Object} controller the route's controller
+ @param {Object} model the route's model
+ */
+ renderTemplate: function(controller, model) {
+ this.render();
+ },
+
+ /**
+ `render` is used to render a template into a region of another template
+ (indicated by an `{{outlet}}`). `render` is used both during the entry
+ phase of routing (via the `renderTemplate` hook) and later in response to
+ user interaction.
+
+ For example, given the following minimal router and templates:
+
+ ```javascript
+ Router.map(function() {
+ this.resource('photos');
+ });
+ ```
+
+ ```handlebars
+
+
+ {{outlet "anOutletName"}}
+
+ ```
+
+ ```handlebars
+
+
Photos
+ ```
+
+ You can render `photos.hbs` into the `"anOutletName"` outlet of
+ `application.hbs` by calling `render`:
+
+ ```javascript
+ // posts route
+ Ember.Route.extend({
+ renderTemplate: function(){
+ this.render('photos', {
+ into: 'application',
+ outlet: 'anOutletName'
+ })
+ }
+ });
+ ```
+
+ `render` additionally allows you to supply which `view`, `controller`, and
+ `model` objects should be loaded and associated with the rendered template.
+
+
+ ```javascript
+ // posts route
+ Ember.Route.extend({
+ renderTemplate: function(controller, model){
+ this.render('posts', { // the template to render, referenced by name
+ into: 'application', // the template to render into, referenced by name
+ outlet: 'anOutletName', // the outlet inside `options.template` to render into.
+ view: 'aViewName', // the view to use for this template, referenced by name
+ controller: 'someControllerName', // the controller to use for this template, referenced by name
+ model: model // the model to set on `options.controller`.
+ })
+ }
+ });
+ ```
+
+ The string values provided for the template name, view, and controller
+ will eventually pass through to the resolver for lookup. See
+ Ember.Resolver for how these are mapped to JavaScript objects in your
+ application.
+
+ Not all options need to be passed to `render`. Default values will be used
+ based on the name of the route specified in the router or the Route's
+ `controllerName`, `viewName` and `templateName` properties.
+
+ For example:
+
+ ```javascript
+ // router
+ Router.map(function() {
+ this.route('index');
+ this.resource('post', { path: '/posts/:post_id' });
+ });
+ ```
+
+ ```javascript
+ // post route
+ PostRoute = App.Route.extend({
+ renderTemplate: function() {
+ this.render(); // all defaults apply
+ }
+ });
+ ```
+
+ The name of the `PostRoute`, defined by the router, is `post`.
+
+ The following equivalent default options will be applied when
+ the Route calls `render`:
+
+ ```javascript
+ //
+ this.render('post', { // the template name associated with 'post' Route
+ into: 'application', // the parent route to 'post' Route
+ outlet: 'main', // {{outlet}} and {{outlet 'main' are synonymous}},
+ view: 'post', // the view associated with the 'post' Route
+ controller: 'post', // the controller associated with the 'post' Route
+ })
+ ```
+
+ By default the controller's `model` will be the route's model, so it does not
+ need to be passed unless you wish to change which model is being used.
+
+ @method render
+ @param {String} name the name of the template to render
+ @param {Object} [options] the options
+ @param {String} [options.into] the template to render into,
+ referenced by name. Defaults to the parent template
+ @param {String} [options.outlet] the outlet inside `options.template` to render into.
+ Defaults to 'main'
+ @param {String} [options.controller] the controller to use for this template,
+ referenced by name. Defaults to the Route's paired controller
+ @param {String} [options.model] the model object to set on `options.controller`
+ Defaults to the return value of the Route's model hook
+ */
+ render: function(_name, options) {
+ Ember.assert("The name in the given arguments is undefined", arguments.length > 0 ? !isNone(arguments[0]) : true);
+
+ var namePassed = typeof _name === 'string' && !!_name;
+ var name;
+
+ if (typeof _name === 'object' && !options) {
+ name = this.routeName;
+ options = _name;
+ } else {
+ name = _name;
+ }
+
+ var templateName;
+
+ if (name) {
+ name = name.replace(/\//g, '.');
+ templateName = name;
+ } else {
+ name = this.routeName;
+ templateName = this.templateName || name;
+ }
+
+ var renderOptions = buildRenderOptions(this, namePassed, name, options);
+
+ var LOG_VIEW_LOOKUPS = get(this.router, 'namespace.LOG_VIEW_LOOKUPS');
+ var viewName = options && options.view || namePassed && name || this.viewName || name;
+ var view, template;
+
+ var ViewClass = this.container.lookupFactory('view:' + viewName);
+ if (ViewClass) {
+ view = setupView(ViewClass, renderOptions);
+ if (!get(view, 'template')) {
+ view.set('template', this.container.lookup('template:' + templateName));
+ }
+ if (LOG_VIEW_LOOKUPS) {
+ Ember.Logger.info("Rendering " + renderOptions.name + " with " + view, { fullName: 'view:' + renderOptions.name });
+ }
+ } else {
+ template = this.container.lookup('template:' + templateName);
+ if (!template) {
+ Ember.assert("Could not find \"" + name + "\" template or view.", arguments.length === 0 || Ember.isEmpty(arguments[0]));
+ if (LOG_VIEW_LOOKUPS) {
+ Ember.Logger.info("Could not find \"" + name + "\" template or view. Nothing will be rendered", { fullName: 'template:' + name });
+ }
+ return;
+ }
+ var defaultView = renderOptions.into ? 'view:default' : 'view:toplevel';
+ ViewClass = this.container.lookupFactory(defaultView);
+ view = setupView(ViewClass, renderOptions);
+ if (!get(view, 'template')) {
+ view.set('template', template);
+ }
+ if (LOG_VIEW_LOOKUPS) {
+ Ember.Logger.info("Rendering " + renderOptions.name + " with default view " + view, { fullName: 'view:' + renderOptions.name });
+ }
+ }
+
+ if (renderOptions.outlet === 'main') { this.lastRenderedTemplate = name; }
+ appendView(this, view, renderOptions);
+ },
+
+ /**
+ Disconnects a view that has been rendered into an outlet.
+
+ You may pass any or all of the following options to `disconnectOutlet`:
+
+ * `outlet`: the name of the outlet to clear (default: 'main')
+ * `parentView`: the name of the view containing the outlet to clear
+ (default: the view rendered by the parent route)
+
+ Example:
+
+ ```javascript
+ App.ApplicationRoute = App.Route.extend({
+ actions: {
+ showModal: function(evt) {
+ this.render(evt.modalName, {
+ outlet: 'modal',
+ into: 'application'
+ });
+ },
+ hideModal: function(evt) {
+ this.disconnectOutlet({
+ outlet: 'modal',
+ parentView: 'application'
+ });
+ }
+ }
+ });
+ ```
+
+ Alternatively, you can pass the `outlet` name directly as a string.
+
+ Example:
+
+ ```javascript
+ hideModal: function(evt) {
+ this.disconnectOutlet('modal');
+ }
+ ```
+
+ @method disconnectOutlet
+ @param {Object|String} options the options hash or outlet name
+ */
+ disconnectOutlet: function(options) {
+ if (!options || typeof options === "string") {
+ var outletName = options;
+ options = {};
+ options.outlet = outletName;
+ }
+ options.parentView = options.parentView ? options.parentView.replace(/\//g, '.') : parentTemplate(this);
+ options.outlet = options.outlet || 'main';
+
+ var parentView = this.router._lookupActiveView(options.parentView);
+ if (parentView) { parentView.disconnectOutlet(options.outlet); }
+ },
+
+ willDestroy: function() {
+ this.teardownViews();
+ },
+
+ /**
+ @private
+
+ @method teardownViews
+ */
+ teardownViews: function() {
+ // Tear down the top level view
+ if (this.teardownTopLevelView) { this.teardownTopLevelView(); }
+
+ // Tear down any outlets rendered with 'into'
+ var teardownOutletViews = this.teardownOutletViews || [];
+ forEach(teardownOutletViews, function(teardownOutletView) {
+ teardownOutletView();
+ });
+
+ delete this.teardownTopLevelView;
+ delete this.teardownOutletViews;
+ delete this.lastRenderedTemplate;
+ }
+ });
+
+
+ // TODO add mixin directly to `Route` class definition above, once this
+ // feature is merged:
+ Route.reopen(Evented);
+
+
+ var defaultQPMeta = {
+ qps: [],
+ map: {},
+ states: {}
+ };
+
+ function parentRoute(route) {
+ var handlerInfo = handlerInfoFor(route, route.router.router.state.handlerInfos, -1);
+ return handlerInfo && handlerInfo.handler;
+ }
+
+ function handlerInfoFor(route, handlerInfos, _offset) {
+ if (!handlerInfos) { return; }
+
+ var offset = _offset || 0;
+ var current;
+ for (var i=0, l=handlerInfos.length; i " + routeName, { fullName: routeName });
+ }
+ }
+
+ handler.routeName = name;
+ return handler;
+ };
+ },
+
+ _setupRouter: function(router, location) {
+ var lastURL, emberRouter = this;
+
+ router.getHandler = this._getHandlerFunction();
+
+ var doUpdateURL = function() {
+ location.setURL(lastURL);
+ };
+
+ router.updateURL = function(path) {
+ lastURL = path;
+ run.once(doUpdateURL);
+ };
+
+ if (location.replaceURL) {
+ var doReplaceURL = function() {
+ location.replaceURL(lastURL);
+ };
+
+ router.replaceURL = function(path) {
+ lastURL = path;
+ run.once(doReplaceURL);
+ };
+ }
+
+ router.didTransition = function(infos) {
+ emberRouter.didTransition(infos);
+ };
+ },
+
+ _serializeQueryParams: function(targetRouteName, queryParams) {
+ var groupedByUrlKey = {};
+
+ forEachQueryParam(this, targetRouteName, queryParams, function(key, value, qp) {
+ var urlKey = qp.urlKey;
+ if (!groupedByUrlKey[urlKey]) {
+ groupedByUrlKey[urlKey] = [];
+ }
+ groupedByUrlKey[urlKey].push({
+ qp: qp,
+ value: value
+ });
+ delete queryParams[key];
+ });
+
+ for (var key in groupedByUrlKey) {
+ var qps = groupedByUrlKey[key];
+ Ember.assert(fmt("You're not allowed to have more than one controller " +
+ "property map to the same query param key, but both " +
+ "`%@` and `%@` map to `%@`. You can fix this by mapping " +
+ "one of the controller properties to a different query " +
+ "param key via the `as` config option, e.g. `%@: { as: 'other-%@' }`",
+ [qps[0].qp.fprop, qps[1] ? qps[1].qp.fprop : "", qps[0].qp.urlKey, qps[0].qp.prop, qps[0].qp.prop]), qps.length <= 1);
+ var qp = qps[0].qp;
+ queryParams[qp.urlKey] = qp.route.serializeQueryParam(qps[0].value, qp.urlKey, qp.type);
+ }
+ },
+
+ _deserializeQueryParams: function(targetRouteName, queryParams) {
+ forEachQueryParam(this, targetRouteName, queryParams, function(key, value, qp) {
+ delete queryParams[key];
+ queryParams[qp.prop] = qp.route.deserializeQueryParam(value, qp.urlKey, qp.type);
+ });
+ },
+
+ _pruneDefaultQueryParamValues: function(targetRouteName, queryParams) {
+ var qps = this._queryParamsFor(targetRouteName);
+ for (var key in queryParams) {
+ var qp = qps.map[key];
+ if (qp && qp.sdef === queryParams[key]) {
+ delete queryParams[key];
+ }
+ }
+ },
+
+ _doTransition: function(_targetRouteName, models, _queryParams) {
+ var targetRouteName = _targetRouteName || getActiveTargetName(this.router);
+ Ember.assert("The route " + targetRouteName + " was not found", targetRouteName && this.router.hasRoute(targetRouteName));
+
+ var queryParams = {};
+ merge(queryParams, _queryParams);
+ this._prepareQueryParams(targetRouteName, models, queryParams);
+
+ var transitionArgs = routeArgs(targetRouteName, models, queryParams);
+ var transitionPromise = this.router.transitionTo.apply(this.router, transitionArgs);
+
+ listenForTransitionErrors(transitionPromise);
+
+ return transitionPromise;
+ },
+
+ _prepareQueryParams: function(targetRouteName, models, queryParams) {
+ this._hydrateUnsuppliedQueryParams(targetRouteName, models, queryParams);
+ this._serializeQueryParams(targetRouteName, queryParams);
+ this._pruneDefaultQueryParamValues(targetRouteName, queryParams);
+ },
+
+ /**
+ Returns a merged query params meta object for a given route.
+ Useful for asking a route what its known query params are.
+ */
+ _queryParamsFor: function(leafRouteName) {
+ if (this._qpCache[leafRouteName]) {
+ return this._qpCache[leafRouteName];
+ }
+
+ var map = {}, qps = [];
+ this._qpCache[leafRouteName] = {
+ map: map,
+ qps: qps
+ };
+
+ var routerjs = this.router;
+ var recogHandlerInfos = routerjs.recognizer.handlersFor(leafRouteName);
+
+ for (var i = 0, len = recogHandlerInfos.length; i < len; ++i) {
+ var recogHandler = recogHandlerInfos[i];
+ var route = routerjs.getHandler(recogHandler.handler);
+ var qpMeta = get(route, '_qp');
+
+ if (!qpMeta) { continue; }
+
+ merge(map, qpMeta.map);
+ qps.push.apply(qps, qpMeta.qps);
+ }
+
+ return {
+ qps: qps,
+ map: map
+ };
+ },
+
+ /*
+ becomeResolved: function(payload, resolvedContext) {
+ var params = this.serialize(resolvedContext);
+
+ if (payload) {
+ this.stashResolvedModel(payload, resolvedContext);
+ payload.params = payload.params || {};
+ payload.params[this.name] = params;
+ }
+
+ return this.factory('resolved', {
+ context: resolvedContext,
+ name: this.name,
+ handler: this.handler,
+ params: params
+ });
+ },
+ */
+
+ _hydrateUnsuppliedQueryParams: function(leafRouteName, contexts, queryParams) {
+ var state = calculatePostTransitionState(this, leafRouteName, contexts);
+ var handlerInfos = state.handlerInfos;
+ var appCache = this._bucketCache;
+
+ stashParamNames(this, handlerInfos);
+
+ for (var i = 0, len = handlerInfos.length; i < len; ++i) {
+ var route = handlerInfos[i].handler;
+ var qpMeta = get(route, '_qp');
+
+ for (var j = 0, qpLen = qpMeta.qps.length; j < qpLen; ++j) {
+ var qp = qpMeta.qps[j];
+ var presentProp = qp.prop in queryParams && qp.prop ||
+ qp.fprop in queryParams && qp.fprop;
+
+ if (presentProp) {
+ if (presentProp !== qp.fprop) {
+ queryParams[qp.fprop] = queryParams[presentProp];
+ delete queryParams[presentProp];
+ }
+ } else {
+ var controllerProto = qp.cProto;
+ var cacheMeta = get(controllerProto, '_cacheMeta');
+
+ var cacheKey = controllerProto._calculateCacheKey(qp.ctrl, cacheMeta[qp.prop].parts, state.params);
+ queryParams[qp.fprop] = appCache.lookup(cacheKey, qp.prop, qp.def);
+ }
+ }
+ }
+ },
+
+ _scheduleLoadingEvent: function(transition, originRoute) {
+ this._cancelLoadingEvent();
+ this._loadingStateTimer = run.scheduleOnce('routerTransitions', this, '_fireLoadingEvent', transition, originRoute);
+ },
+
+ _fireLoadingEvent: function(transition, originRoute) {
+ if (!this.router.activeTransition) {
+ // Don't fire an event if we've since moved on from
+ // the transition that put us in a loading state.
+ return;
+ }
+
+ transition.trigger(true, 'loading', transition, originRoute);
+ },
+
+ _cancelLoadingEvent: function () {
+ if (this._loadingStateTimer) {
+ run.cancel(this._loadingStateTimer);
+ }
+ this._loadingStateTimer = null;
+ }
+ });
+
+ /*
+ Helper function for iterating root-ward, starting
+ from (but not including) the provided `originRoute`.
+
+ Returns true if the last callback fired requested
+ to bubble upward.
+
+ @private
+ */
+ function forEachRouteAbove(originRoute, transition, callback) {
+ var handlerInfos = transition.state.handlerInfos;
+ var originRouteFound = false;
+ var handlerInfo, route;
+
+ for (var i = handlerInfos.length - 1; i >= 0; --i) {
+ handlerInfo = handlerInfos[i];
+ route = handlerInfo.handler;
+
+ if (!originRouteFound) {
+ if (originRoute === route) {
+ originRouteFound = true;
+ }
+ continue;
+ }
+
+ if (callback(route, handlerInfos[i + 1].handler) !== true) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ // These get invoked when an action bubbles above ApplicationRoute
+ // and are not meant to be overridable.
+ var defaultActionHandlers = {
+
+ willResolveModel: function(transition, originRoute) {
+ originRoute.router._scheduleLoadingEvent(transition, originRoute);
+ },
+
+ error: function(error, transition, originRoute) {
+ // Attempt to find an appropriate error substate to enter.
+ var router = originRoute.router;
+
+ var tryTopLevel = forEachRouteAbove(originRoute, transition, function(route, childRoute) {
+ var childErrorRouteName = findChildRouteName(route, childRoute, 'error');
+ if (childErrorRouteName) {
+ router.intermediateTransitionTo(childErrorRouteName, error);
+ return;
+ }
+ return true;
+ });
+
+ if (tryTopLevel) {
+ // Check for top-level error state to enter.
+ if (routeHasBeenDefined(originRoute.router, 'application_error')) {
+ router.intermediateTransitionTo('application_error', error);
+ return;
+ }
+ }
+
+ logError(error, 'Error while processing route: ' + transition.targetName);
+ },
+
+ loading: function(transition, originRoute) {
+ // Attempt to find an appropriate loading substate to enter.
+ var router = originRoute.router;
+
+ var tryTopLevel = forEachRouteAbove(originRoute, transition, function(route, childRoute) {
+ var childLoadingRouteName = findChildRouteName(route, childRoute, 'loading');
+
+ if (childLoadingRouteName) {
+ router.intermediateTransitionTo(childLoadingRouteName);
+ return;
+ }
+
+ // Don't bubble above pivot route.
+ if (transition.pivotHandler !== route) {
+ return true;
+ }
+ });
+
+ if (tryTopLevel) {
+ // Check for top-level loading state to enter.
+ if (routeHasBeenDefined(originRoute.router, 'application_loading')) {
+ router.intermediateTransitionTo('application_loading');
+ return;
+ }
+ }
+ }
+ };
+
+ function logError(error, initialMessage) {
+ var errorArgs = [];
+
+ if (initialMessage) { errorArgs.push(initialMessage); }
+
+ if (error) {
+ if (error.message) { errorArgs.push(error.message); }
+ if (error.stack) { errorArgs.push(error.stack); }
+
+ if (typeof error === "string") { errorArgs.push(error); }
+ }
+
+ Ember.Logger.error.apply(this, errorArgs);
+ }
+
+ function findChildRouteName(parentRoute, originatingChildRoute, name) {
+ var router = parentRoute.router;
+ var childName;
+ var targetChildRouteName = originatingChildRoute.routeName.split('.').pop();
+ var namespace = parentRoute.routeName === 'application' ? '' : parentRoute.routeName + '.';
+
+
+ // Second, try general loading state, e.g. 'loading'
+ childName = namespace + name;
+ if (routeHasBeenDefined(router, childName)) {
+ return childName;
+ }
+ }
+
+ function routeHasBeenDefined(router, name) {
+ var container = router.container;
+ return router.hasRoute(name) &&
+ (container.has('template:' + name) || container.has('route:' + name));
+ }
+
+ function triggerEvent(handlerInfos, ignoreFailure, args) {
+ var name = args.shift();
+
+ if (!handlerInfos) {
+ if (ignoreFailure) { return; }
+ throw new EmberError("Can't trigger action '" + name + "' because your app hasn't finished transitioning into its first route. To trigger an action on destination routes during a transition, you can call `.send()` on the `Transition` object passed to the `model/beforeModel/afterModel` hooks.");
+ }
+
+ var eventWasHandled = false;
+ var handlerInfo, handler;
+
+ for (var i = handlerInfos.length - 1; i >= 0; i--) {
+ handlerInfo = handlerInfos[i];
+ handler = handlerInfo.handler;
+
+ if (handler._actions && handler._actions[name]) {
+ if (handler._actions[name].apply(handler, args) === true) {
+ eventWasHandled = true;
+ } else {
+ return;
+ }
+ }
+ }
+
+ if (defaultActionHandlers[name]) {
+ defaultActionHandlers[name].apply(null, args);
+ return;
+ }
+
+ if (!eventWasHandled && !ignoreFailure) {
+ throw new EmberError("Nothing handled the action '" + name + "'. If you did handle the action, this error can be caused by returning true from an action handler in a controller, causing the action to bubble.");
+ }
+ }
+
+ function calculatePostTransitionState(emberRouter, leafRouteName, contexts) {
+ var routerjs = emberRouter.router;
+ var state = routerjs.applyIntent(leafRouteName, contexts);
+ var handlerInfos = state.handlerInfos;
+ var params = state.params;
+
+ for (var i = 0, len = handlerInfos.length; i < len; ++i) {
+ var handlerInfo = handlerInfos[i];
+ if (!handlerInfo.isResolved) {
+ handlerInfo = handlerInfo.becomeResolved(null, handlerInfo.context);
+ }
+ params[handlerInfo.name] = handlerInfo.params;
+ }
+ return state;
+ }
+
+ function updatePaths(router) {
+ var appController = router.container.lookup('controller:application');
+
+ if (!appController) {
+ // appController might not exist when top-level loading/error
+ // substates have been entered since ApplicationRoute hasn't
+ // actually been entered at that point.
+ return;
+ }
+
+ var infos = router.router.currentHandlerInfos;
+ var path = EmberRouter._routePath(infos);
+
+ if (!('currentPath' in appController)) {
+ defineProperty(appController, 'currentPath');
+ }
+
+ set(appController, 'currentPath', path);
+
+ if (!('currentRouteName' in appController)) {
+ defineProperty(appController, 'currentRouteName');
+ }
+
+ set(appController, 'currentRouteName', infos[infos.length - 1].name);
+ }
+
+ EmberRouter.reopenClass({
+ router: null,
+
+ /**
+ The `Router.map` function allows you to define mappings from URLs to routes
+ and resources in your application. These mappings are defined within the
+ supplied callback function using `this.resource` and `this.route`.
+
+ ```javascript
+ App.Router.map(function({
+ this.route('about');
+ this.resource('article');
+ }));
+ ```
+
+ For more detailed examples please see
+ [the guides](http://emberjs.com/guides/routing/defining-your-routes/).
+
+ @method map
+ @param callback
+ */
+ map: function(callback) {
+ var router = this.router;
+ if (!router) {
+ router = new Router();
+
+
+ router._triggerWillChangeContext = K;
+ router._triggerWillLeave = K;
+
+
+ router.callbacks = [];
+ router.triggerEvent = triggerEvent;
+ this.reopenClass({ router: router });
+ }
+
+ var dsl = EmberRouterDSL.map(function() {
+ this.resource('application', { path: "/" }, function() {
+ for (var i=0; i < router.callbacks.length; i++) {
+ router.callbacks[i].call(this);
+ }
+ callback.call(this);
+ });
+ });
+
+ router.callbacks.push(callback);
+ router.map(dsl.generate());
+ return router;
+ },
+
+ _routePath: function(handlerInfos) {
+ var path = [];
+
+ // We have to handle coalescing resource names that
+ // are prefixed with their parent's names, e.g.
+ // ['foo', 'foo.bar.baz'] => 'foo.bar.baz', not 'foo.foo.bar.baz'
+
+ function intersectionMatches(a1, a2) {
+ for (var i = 0, len = a1.length; i < len; ++i) {
+ if (a1[i] !== a2[i]) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ var name, nameParts, oldNameParts;
+ for (var i=1, l=handlerInfos.length; i 0) - (diff < 0);
+ }
+
+ /**
+ This will compare two javascript values of possibly different types.
+ It will tell you which one is greater than the other by returning:
+
+ - -1 if the first is smaller than the second,
+ - 0 if both are equal,
+ - 1 if the first is greater than the second.
+
+ The order is calculated based on `Ember.ORDER_DEFINITION`, if types are different.
+ In case they have the same type an appropriate comparison for this type is made.
+
+ ```javascript
+ Ember.compare('hello', 'hello'); // 0
+ Ember.compare('abc', 'dfg'); // -1
+ Ember.compare(2, 1); // 1
+ ```
+
+ @method compare
+ @for Ember
+ @param {Object} v First value to compare
+ @param {Object} w Second value to compare
+ @return {Number} -1 if v < w, 0 if v = w and 1 if v > w.
+ */
+ __exports__["default"] = function compare(v, w) {
+ if (v === w) {
+ return 0;
+ }
+
+ var type1 = typeOf(v);
+ var type2 = typeOf(w);
+
+ if (Comparable) {
+ if (type1 === 'instance' && Comparable.detect(v) && v.constructor.compare) {
+ return v.constructor.compare(v, w);
+ }
+
+ if (type2 === 'instance' && Comparable.detect(w) && w.constructor.compare) {
+ return w.constructor.compare(w, v) * -1;
+ }
+ }
+
+ var res = spaceship(TYPE_ORDER[type1], TYPE_ORDER[type2]);
+
+ if (res !== 0) {
+ return res;
+ }
+
+ // types are equal - so we have to check values now
+ switch (type1) {
+ case 'boolean':
+ case 'number':
+ return spaceship(v,w);
+
+ case 'string':
+ return spaceship(v.localeCompare(w), 0);
+
+ case 'array':
+ var vLen = v.length;
+ var wLen = w.length;
+ var len = Math.min(vLen, wLen);
+
+ for (var i = 0; i < len; i++) {
+ var r = compare(v[i], w[i]);
+ if (r !== 0) {
+ return r;
+ }
+ }
+
+ // all elements are equal now
+ // shorter array should be ordered first
+ return spaceship(vLen, wLen);
+
+ case 'instance':
+ if (Comparable && Comparable.detect(v)) {
+ return v.compare(v, w);
+ }
+ return 0;
+
+ case 'date':
+ return spaceship(v.getTime(), w.getTime());
+
+ default:
+ return 0;
+ }
+ }
+ });
+enifed("ember-runtime/computed/array_computed",
+ ["ember-metal/core","ember-runtime/computed/reduce_computed","ember-metal/enumerable_utils","ember-metal/platform","ember-metal/observer","ember-metal/error","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ var ReduceComputedProperty = __dependency2__.ReduceComputedProperty;
+ var forEach = __dependency3__.forEach;
+ var o_create = __dependency4__.create;
+ var addObserver = __dependency5__.addObserver;
+ var EmberError = __dependency6__["default"];
+
+ var a_slice = [].slice;
+
+ function ArrayComputedProperty() {
+ var cp = this;
+
+ ReduceComputedProperty.apply(this, arguments);
+
+ this.func = (function(reduceFunc) {
+ return function (propertyName) {
+ if (!cp._hasInstanceMeta(this, propertyName)) {
+ // When we recompute an array computed property, we need already
+ // retrieved arrays to be updated; we can't simply empty the cache and
+ // hope the array is re-retrieved.
+ forEach(cp._dependentKeys, function(dependentKey) {
+ addObserver(this, dependentKey, function() {
+ cp.recomputeOnce.call(this, propertyName);
+ });
+ }, this);
+ }
+
+ return reduceFunc.apply(this, arguments);
+ };
+ })(this.func);
+
+ return this;
+ }
+
+ ArrayComputedProperty.prototype = o_create(ReduceComputedProperty.prototype);
+
+ ArrayComputedProperty.prototype.initialValue = function () {
+ return Ember.A();
+ };
+
+ ArrayComputedProperty.prototype.resetValue = function (array) {
+ array.clear();
+ return array;
+ };
+
+ // This is a stopgap to keep the reference counts correct with lazy CPs.
+ ArrayComputedProperty.prototype.didChange = function (obj, keyName) {
+ return;
+ };
+
+ /**
+ Creates a computed property which operates on dependent arrays and
+ is updated with "one at a time" semantics. When items are added or
+ removed from the dependent array(s) an array computed only operates
+ on the change instead of re-evaluating the entire array. This should
+ return an array, if you'd like to use "one at a time" semantics and
+ compute some value other then an array look at
+ `Ember.reduceComputed`.
+
+ If there are more than one arguments the first arguments are
+ considered to be dependent property keys. The last argument is
+ required to be an options object. The options object can have the
+ following three properties.
+
+ `initialize` - An optional initialize function. Typically this will be used
+ to set up state on the instanceMeta object.
+
+ `removedItem` - A function that is called each time an element is
+ removed from the array.
+
+ `addedItem` - A function that is called each time an element is
+ added to the array.
+
+
+ The `initialize` function has the following signature:
+
+ ```javascript
+ function(array, changeMeta, instanceMeta)
+ ```
+
+ `array` - The initial value of the arrayComputed, an empty array.
+
+ `changeMeta` - An object which contains meta information about the
+ computed. It contains the following properties:
+
+ - `property` the computed property
+ - `propertyName` the name of the property on the object
+
+ `instanceMeta` - An object that can be used to store meta
+ information needed for calculating your computed. For example a
+ unique computed might use this to store the number of times a given
+ element is found in the dependent array.
+
+
+ The `removedItem` and `addedItem` functions both have the following signature:
+
+ ```javascript
+ function(accumulatedValue, item, changeMeta, instanceMeta)
+ ```
+
+ `accumulatedValue` - The value returned from the last time
+ `removedItem` or `addedItem` was called or an empty array.
+
+ `item` - the element added or removed from the array
+
+ `changeMeta` - An object which contains meta information about the
+ change. It contains the following properties:
+
+ - `property` the computed property
+ - `propertyName` the name of the property on the object
+ - `index` the index of the added or removed item
+ - `item` the added or removed item: this is exactly the same as
+ the second arg
+ - `arrayChanged` the array that triggered the change. Can be
+ useful when depending on multiple arrays.
+
+ For property changes triggered on an item property change (when
+ depKey is something like `someArray.@each.someProperty`),
+ `changeMeta` will also contain the following property:
+
+ - `previousValues` an object whose keys are the properties that changed on
+ the item, and whose values are the item's previous values.
+
+ `previousValues` is important Ember coalesces item property changes via
+ Ember.run.once. This means that by the time removedItem gets called, item has
+ the new values, but you may need the previous value (eg for sorting &
+ filtering).
+
+ `instanceMeta` - An object that can be used to store meta
+ information needed for calculating your computed. For example a
+ unique computed might use this to store the number of times a given
+ element is found in the dependent array.
+
+ The `removedItem` and `addedItem` functions should return the accumulated
+ value. It is acceptable to not return anything (ie return undefined)
+ to invalidate the computation. This is generally not a good idea for
+ arrayComputed but it's used in eg max and min.
+
+ Example
+
+ ```javascript
+ Ember.computed.map = function(dependentKey, callback) {
+ var options = {
+ addedItem: function(array, item, changeMeta, instanceMeta) {
+ var mapped = callback(item);
+ array.insertAt(changeMeta.index, mapped);
+ return array;
+ },
+ removedItem: function(array, item, changeMeta, instanceMeta) {
+ array.removeAt(changeMeta.index, 1);
+ return array;
+ }
+ };
+
+ return Ember.arrayComputed(dependentKey, options);
+ };
+ ```
+
+ @method arrayComputed
+ @for Ember
+ @param {String} [dependentKeys*]
+ @param {Object} options
+ @return {Ember.ComputedProperty}
+ */
+ function arrayComputed (options) {
+ var args;
+
+ if (arguments.length > 1) {
+ args = a_slice.call(arguments, 0, -1);
+ options = a_slice.call(arguments, -1)[0];
+ }
+
+ if (typeof options !== 'object') {
+ throw new EmberError('Array Computed Property declared without an options hash');
+ }
+
+ var cp = new ArrayComputedProperty(options);
+
+ if (args) {
+ cp.property.apply(cp, args);
+ }
+
+ return cp;
+ }
+
+ __exports__.arrayComputed = arrayComputed;
+ __exports__.ArrayComputedProperty = ArrayComputedProperty;
+ });
+enifed("ember-runtime/computed/reduce_computed",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/error","ember-metal/property_events","ember-metal/expand_properties","ember-metal/observer","ember-metal/computed","ember-metal/platform","ember-metal/enumerable_utils","ember-runtime/system/tracked_array","ember-runtime/mixins/array","ember-metal/run_loop","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+ var e_get = __dependency2__.get;
+ var guidFor = __dependency3__.guidFor;
+ var metaFor = __dependency3__.meta;
+ var EmberError = __dependency4__["default"];
+ var propertyWillChange = __dependency5__.propertyWillChange;
+ var propertyDidChange = __dependency5__.propertyDidChange;
+ var expandProperties = __dependency6__["default"];
+ var addObserver = __dependency7__.addObserver;
+ var removeObserver = __dependency7__.removeObserver;
+ var addBeforeObserver = __dependency7__.addBeforeObserver;
+ var removeBeforeObserver = __dependency7__.removeBeforeObserver;
+ var ComputedProperty = __dependency8__.ComputedProperty;
+ var cacheFor = __dependency8__.cacheFor;
+ var o_create = __dependency9__.create;
+ var forEach = __dependency10__.forEach;
+ var TrackedArray = __dependency11__["default"];
+ var EmberArray = __dependency12__["default"];
+ var run = __dependency13__["default"];
+ var isArray = __dependency3__.isArray;
+
+ var cacheSet = cacheFor.set;
+ var cacheGet = cacheFor.get;
+ var cacheRemove = cacheFor.remove;
+ var a_slice = [].slice;
+ // Here we explicitly don't allow `@each.foo`; it would require some special
+ // testing, but there's no particular reason why it should be disallowed.
+ var eachPropertyPattern = /^(.*)\.@each\.(.*)/;
+ var doubleEachPropertyPattern = /(.*\.@each){2,}/;
+ var arrayBracketPattern = /\.\[\]$/;
+
+ function get(obj, key) {
+ if (key === '@this') {
+ return obj;
+ }
+
+ return e_get(obj, key);
+ }
+
+ /*
+ Tracks changes to dependent arrays, as well as to properties of items in
+ dependent arrays.
+
+ @class DependentArraysObserver
+ */
+ function DependentArraysObserver(callbacks, cp, instanceMeta, context, propertyName, sugarMeta) {
+ // user specified callbacks for `addedItem` and `removedItem`
+ this.callbacks = callbacks;
+
+ // the computed property: remember these are shared across instances
+ this.cp = cp;
+
+ // the ReduceComputedPropertyInstanceMeta this DependentArraysObserver is
+ // associated with
+ this.instanceMeta = instanceMeta;
+
+ // A map of array guids to dependentKeys, for the given context. We track
+ // this because we want to set up the computed property potentially before the
+ // dependent array even exists, but when the array observer fires, we lack
+ // enough context to know what to update: we can recover that context by
+ // getting the dependentKey.
+ this.dependentKeysByGuid = {};
+
+ // a map of dependent array guids -> TrackedArray instances. We use
+ // this to lazily recompute indexes for item property observers.
+ this.trackedArraysByGuid = {};
+
+ // We suspend observers to ignore replacements from `reset` when totally
+ // recomputing. Unfortunately we cannot properly suspend the observers
+ // because we only have the key; instead we make the observers no-ops
+ this.suspended = false;
+
+ // This is used to coalesce item changes from property observers within a
+ // single item.
+ this.changedItems = {};
+ // This is used to coalesce item changes for multiple items that depend on
+ // some shared state.
+ this.changedItemCount = 0;
+ }
+
+ function ItemPropertyObserverContext (dependentArray, index, trackedArray) {
+ Ember.assert('Internal error: trackedArray is null or undefined', trackedArray);
+
+ this.dependentArray = dependentArray;
+ this.index = index;
+ this.item = dependentArray.objectAt(index);
+ this.trackedArray = trackedArray;
+ this.beforeObserver = null;
+ this.observer = null;
+ this.destroyed = false;
+ }
+
+ DependentArraysObserver.prototype = {
+ setValue: function (newValue) {
+ this.instanceMeta.setValue(newValue, true);
+ },
+
+ getValue: function () {
+ return this.instanceMeta.getValue();
+ },
+
+ setupObservers: function (dependentArray, dependentKey) {
+ this.dependentKeysByGuid[guidFor(dependentArray)] = dependentKey;
+
+ dependentArray.addArrayObserver(this, {
+ willChange: 'dependentArrayWillChange',
+ didChange: 'dependentArrayDidChange'
+ });
+
+ if (this.cp._itemPropertyKeys[dependentKey]) {
+ this.setupPropertyObservers(dependentKey, this.cp._itemPropertyKeys[dependentKey]);
+ }
+ },
+
+ teardownObservers: function (dependentArray, dependentKey) {
+ var itemPropertyKeys = this.cp._itemPropertyKeys[dependentKey] || [];
+
+ delete this.dependentKeysByGuid[guidFor(dependentArray)];
+
+ this.teardownPropertyObservers(dependentKey, itemPropertyKeys);
+
+ dependentArray.removeArrayObserver(this, {
+ willChange: 'dependentArrayWillChange',
+ didChange: 'dependentArrayDidChange'
+ });
+ },
+
+ suspendArrayObservers: function (callback, binding) {
+ var oldSuspended = this.suspended;
+ this.suspended = true;
+ callback.call(binding);
+ this.suspended = oldSuspended;
+ },
+
+ setupPropertyObservers: function (dependentKey, itemPropertyKeys) {
+ var dependentArray = get(this.instanceMeta.context, dependentKey);
+ var length = get(dependentArray, 'length');
+ var observerContexts = new Array(length);
+
+ this.resetTransformations(dependentKey, observerContexts);
+
+ forEach(dependentArray, function (item, index) {
+ var observerContext = this.createPropertyObserverContext(dependentArray, index, this.trackedArraysByGuid[dependentKey]);
+ observerContexts[index] = observerContext;
+
+ forEach(itemPropertyKeys, function (propertyKey) {
+ addBeforeObserver(item, propertyKey, this, observerContext.beforeObserver);
+ addObserver(item, propertyKey, this, observerContext.observer);
+ }, this);
+ }, this);
+ },
+
+ teardownPropertyObservers: function (dependentKey, itemPropertyKeys) {
+ var dependentArrayObserver = this;
+ var trackedArray = this.trackedArraysByGuid[dependentKey];
+ var beforeObserver, observer, item;
+
+ if (!trackedArray) { return; }
+
+ trackedArray.apply(function (observerContexts, offset, operation) {
+ if (operation === TrackedArray.DELETE) { return; }
+
+ forEach(observerContexts, function (observerContext) {
+ observerContext.destroyed = true;
+ beforeObserver = observerContext.beforeObserver;
+ observer = observerContext.observer;
+ item = observerContext.item;
+
+ forEach(itemPropertyKeys, function (propertyKey) {
+ removeBeforeObserver(item, propertyKey, dependentArrayObserver, beforeObserver);
+ removeObserver(item, propertyKey, dependentArrayObserver, observer);
+ });
+ });
+ });
+ },
+
+ createPropertyObserverContext: function (dependentArray, index, trackedArray) {
+ var observerContext = new ItemPropertyObserverContext(dependentArray, index, trackedArray);
+
+ this.createPropertyObserver(observerContext);
+
+ return observerContext;
+ },
+
+ createPropertyObserver: function (observerContext) {
+ var dependentArrayObserver = this;
+
+ observerContext.beforeObserver = function (obj, keyName) {
+ return dependentArrayObserver.itemPropertyWillChange(obj, keyName, observerContext.dependentArray, observerContext);
+ };
+
+ observerContext.observer = function (obj, keyName) {
+ return dependentArrayObserver.itemPropertyDidChange(obj, keyName, observerContext.dependentArray, observerContext);
+ };
+ },
+
+ resetTransformations: function (dependentKey, observerContexts) {
+ this.trackedArraysByGuid[dependentKey] = new TrackedArray(observerContexts);
+ },
+
+ trackAdd: function (dependentKey, index, newItems) {
+ var trackedArray = this.trackedArraysByGuid[dependentKey];
+
+ if (trackedArray) {
+ trackedArray.addItems(index, newItems);
+ }
+ },
+
+ trackRemove: function (dependentKey, index, removedCount) {
+ var trackedArray = this.trackedArraysByGuid[dependentKey];
+
+ if (trackedArray) {
+ return trackedArray.removeItems(index, removedCount);
+ }
+
+ return [];
+ },
+
+ updateIndexes: function (trackedArray, array) {
+ var length = get(array, 'length');
+ // OPTIMIZE: we could stop updating once we hit the object whose observer
+ // fired; ie partially apply the transformations
+ trackedArray.apply(function (observerContexts, offset, operation, operationIndex) {
+ // we don't even have observer contexts for removed items, even if we did,
+ // they no longer have any index in the array
+ if (operation === TrackedArray.DELETE) { return; }
+ if (operationIndex === 0 && operation === TrackedArray.RETAIN && observerContexts.length === length && offset === 0) {
+ // If we update many items we don't want to walk the array each time: we
+ // only need to update the indexes at most once per run loop.
+ return;
+ }
+
+ forEach(observerContexts, function (context, index) {
+ context.index = index + offset;
+ });
+ });
+ },
+
+ dependentArrayWillChange: function (dependentArray, index, removedCount, addedCount) {
+ if (this.suspended) { return; }
+
+ var removedItem = this.callbacks.removedItem;
+ var changeMeta;
+ var guid = guidFor(dependentArray);
+ var dependentKey = this.dependentKeysByGuid[guid];
+ var itemPropertyKeys = this.cp._itemPropertyKeys[dependentKey] || [];
+ var length = get(dependentArray, 'length');
+ var normalizedIndex = normalizeIndex(index, length, 0);
+ var normalizedRemoveCount = normalizeRemoveCount(normalizedIndex, length, removedCount);
+ var item, itemIndex, sliceIndex, observerContexts;
+
+ observerContexts = this.trackRemove(dependentKey, normalizedIndex, normalizedRemoveCount);
+
+ function removeObservers(propertyKey) {
+ observerContexts[sliceIndex].destroyed = true;
+ removeBeforeObserver(item, propertyKey, this, observerContexts[sliceIndex].beforeObserver);
+ removeObserver(item, propertyKey, this, observerContexts[sliceIndex].observer);
+ }
+
+ for (sliceIndex = normalizedRemoveCount - 1; sliceIndex >= 0; --sliceIndex) {
+ itemIndex = normalizedIndex + sliceIndex;
+ if (itemIndex >= length) { break; }
+
+ item = dependentArray.objectAt(itemIndex);
+
+ forEach(itemPropertyKeys, removeObservers, this);
+
+ changeMeta = new ChangeMeta(dependentArray, item, itemIndex, this.instanceMeta.propertyName, this.cp, normalizedRemoveCount);
+ this.setValue(removedItem.call(
+ this.instanceMeta.context, this.getValue(), item, changeMeta, this.instanceMeta.sugarMeta));
+ }
+ this.callbacks.flushedChanges.call(this.instanceMeta.context, this.getValue(), this.instanceMeta.sugarMeta);
+ },
+
+ dependentArrayDidChange: function (dependentArray, index, removedCount, addedCount) {
+ if (this.suspended) { return; }
+
+ var addedItem = this.callbacks.addedItem;
+ var guid = guidFor(dependentArray);
+ var dependentKey = this.dependentKeysByGuid[guid];
+ var observerContexts = new Array(addedCount);
+ var itemPropertyKeys = this.cp._itemPropertyKeys[dependentKey];
+ var length = get(dependentArray, 'length');
+ var normalizedIndex = normalizeIndex(index, length, addedCount);
+ var endIndex = normalizedIndex + addedCount;
+ var changeMeta, observerContext;
+
+ forEach(dependentArray.slice(normalizedIndex, endIndex), function (item, sliceIndex) {
+ if (itemPropertyKeys) {
+ observerContext = this.createPropertyObserverContext(dependentArray, normalizedIndex + sliceIndex,
+ this.trackedArraysByGuid[dependentKey]);
+ observerContexts[sliceIndex] = observerContext;
+
+ forEach(itemPropertyKeys, function (propertyKey) {
+ addBeforeObserver(item, propertyKey, this, observerContext.beforeObserver);
+ addObserver(item, propertyKey, this, observerContext.observer);
+ }, this);
+ }
+
+ changeMeta = new ChangeMeta(dependentArray, item, normalizedIndex + sliceIndex, this.instanceMeta.propertyName, this.cp, addedCount);
+ this.setValue(addedItem.call(
+ this.instanceMeta.context, this.getValue(), item, changeMeta, this.instanceMeta.sugarMeta));
+ }, this);
+ this.callbacks.flushedChanges.call(this.instanceMeta.context, this.getValue(), this.instanceMeta.sugarMeta);
+ this.trackAdd(dependentKey, normalizedIndex, observerContexts);
+ },
+
+ itemPropertyWillChange: function (obj, keyName, array, observerContext) {
+ var guid = guidFor(obj);
+
+ if (!this.changedItems[guid]) {
+ this.changedItems[guid] = {
+ array: array,
+ observerContext: observerContext,
+ obj: obj,
+ previousValues: {}
+ };
+ }
+
+ ++this.changedItemCount;
+ this.changedItems[guid].previousValues[keyName] = get(obj, keyName);
+ },
+
+ itemPropertyDidChange: function (obj, keyName, array, observerContext) {
+ if (--this.changedItemCount === 0) {
+ this.flushChanges();
+ }
+ },
+
+ flushChanges: function () {
+ var changedItems = this.changedItems;
+ var key, c, changeMeta;
+
+ for (key in changedItems) {
+ c = changedItems[key];
+ if (c.observerContext.destroyed) { continue; }
+
+ this.updateIndexes(c.observerContext.trackedArray, c.observerContext.dependentArray);
+
+ changeMeta = new ChangeMeta(c.array, c.obj, c.observerContext.index, this.instanceMeta.propertyName, this.cp, changedItems.length, c.previousValues);
+ this.setValue(
+ this.callbacks.removedItem.call(this.instanceMeta.context, this.getValue(), c.obj, changeMeta, this.instanceMeta.sugarMeta));
+ this.setValue(
+ this.callbacks.addedItem.call(this.instanceMeta.context, this.getValue(), c.obj, changeMeta, this.instanceMeta.sugarMeta));
+ }
+
+ this.changedItems = {};
+ this.callbacks.flushedChanges.call(this.instanceMeta.context, this.getValue(), this.instanceMeta.sugarMeta);
+ }
+ };
+
+ function normalizeIndex(index, length, newItemsOffset) {
+ if (index < 0) {
+ return Math.max(0, length + index);
+ } else if (index < length) {
+ return index;
+ } else /* index > length */ {
+ return Math.min(length - newItemsOffset, index);
+ }
+ }
+
+ function normalizeRemoveCount(index, length, removedCount) {
+ return Math.min(removedCount, length - index);
+ }
+
+ function ChangeMeta(dependentArray, item, index, propertyName, property, changedCount, previousValues){
+ this.arrayChanged = dependentArray;
+ this.index = index;
+ this.item = item;
+ this.propertyName = propertyName;
+ this.property = property;
+ this.changedCount = changedCount;
+
+ if (previousValues) {
+ // previous values only available for item property changes
+ this.previousValues = previousValues;
+ }
+ }
+
+ function addItems(dependentArray, callbacks, cp, propertyName, meta) {
+ forEach(dependentArray, function (item, index) {
+ meta.setValue( callbacks.addedItem.call(
+ this, meta.getValue(), item, new ChangeMeta(dependentArray, item, index, propertyName, cp, dependentArray.length), meta.sugarMeta));
+ }, this);
+ callbacks.flushedChanges.call(this, meta.getValue(), meta.sugarMeta);
+ }
+
+ function reset(cp, propertyName) {
+ var hadMeta = cp._hasInstanceMeta(this, propertyName);
+ var meta = cp._instanceMeta(this, propertyName);
+
+ if (hadMeta) { meta.setValue(cp.resetValue(meta.getValue())); }
+
+ if (cp.options.initialize) {
+ cp.options.initialize.call(this, meta.getValue(), {
+ property: cp,
+ propertyName: propertyName
+ }, meta.sugarMeta);
+ }
+ }
+
+ function partiallyRecomputeFor(obj, dependentKey) {
+ if (arrayBracketPattern.test(dependentKey)) {
+ return false;
+ }
+
+ var value = get(obj, dependentKey);
+ return EmberArray.detect(value);
+ }
+
+ function ReduceComputedPropertyInstanceMeta(context, propertyName, initialValue) {
+ this.context = context;
+ this.propertyName = propertyName;
+ this.cache = metaFor(context).cache;
+ this.dependentArrays = {};
+ this.sugarMeta = {};
+ this.initialValue = initialValue;
+ }
+
+ ReduceComputedPropertyInstanceMeta.prototype = {
+ getValue: function () {
+ var value = cacheGet(this.cache, this.propertyName);
+
+ if (value !== undefined) {
+ return value;
+ } else {
+ return this.initialValue;
+ }
+ },
+
+ setValue: function(newValue, triggerObservers) {
+ // This lets sugars force a recomputation, handy for very simple
+ // implementations of eg max.
+ if (newValue === cacheGet(this.cache, this.propertyName)) {
+ return;
+ }
+
+ if (triggerObservers) {
+ propertyWillChange(this.context, this.propertyName);
+ }
+
+ if (newValue === undefined) {
+ cacheRemove(this.cache, this.propertyName);
+ } else {
+ cacheSet(this.cache, this.propertyName, newValue);
+ }
+
+ if (triggerObservers) {
+ propertyDidChange(this.context, this.propertyName);
+ }
+ }
+ };
+
+ /**
+ A computed property whose dependent keys are arrays and which is updated with
+ "one at a time" semantics.
+
+ @class ReduceComputedProperty
+ @namespace Ember
+ @extends Ember.ComputedProperty
+ @constructor
+ */
+
+ __exports__.ReduceComputedProperty = ReduceComputedProperty;
+ // TODO: default export
+
+ function ReduceComputedProperty(options) {
+ var cp = this;
+
+ this.options = options;
+ this._dependentKeys = null;
+ this._cacheable = true;
+ // A map of dependentKey -> [itemProperty, ...] that tracks what properties of
+ // items in the array we must track to update this property.
+ this._itemPropertyKeys = {};
+ this._previousItemPropertyKeys = {};
+
+ this.readOnly();
+
+ this.recomputeOnce = function(propertyName) {
+ // What we really want to do is coalesce by .
+ // We need a form of `scheduleOnce` that accepts an arbitrary token to
+ // coalesce by, in addition to the target and method.
+ run.once(this, recompute, propertyName);
+ };
+
+ var recompute = function(propertyName) {
+ var meta = cp._instanceMeta(this, propertyName);
+ var callbacks = cp._callbacks();
+
+ reset.call(this, cp, propertyName);
+
+ meta.dependentArraysObserver.suspendArrayObservers(function () {
+ forEach(cp._dependentKeys, function (dependentKey) {
+ Ember.assert(
+ 'dependent array ' + dependentKey + ' must be an `Ember.Array`. ' +
+ 'If you are not extending arrays, you will need to wrap native arrays with `Ember.A`',
+ !(isArray(get(this, dependentKey)) && !EmberArray.detect(get(this, dependentKey))));
+
+ if (!partiallyRecomputeFor(this, dependentKey)) { return; }
+
+ var dependentArray = get(this, dependentKey);
+ var previousDependentArray = meta.dependentArrays[dependentKey];
+
+ if (dependentArray === previousDependentArray) {
+ // The array may be the same, but our item property keys may have
+ // changed, so we set them up again. We can't easily tell if they've
+ // changed: the array may be the same object, but with different
+ // contents.
+ if (cp._previousItemPropertyKeys[dependentKey]) {
+ delete cp._previousItemPropertyKeys[dependentKey];
+ meta.dependentArraysObserver.setupPropertyObservers(dependentKey, cp._itemPropertyKeys[dependentKey]);
+ }
+ } else {
+ meta.dependentArrays[dependentKey] = dependentArray;
+
+ if (previousDependentArray) {
+ meta.dependentArraysObserver.teardownObservers(previousDependentArray, dependentKey);
+ }
+
+ if (dependentArray) {
+ meta.dependentArraysObserver.setupObservers(dependentArray, dependentKey);
+ }
+ }
+ }, this);
+ }, this);
+
+ forEach(cp._dependentKeys, function(dependentKey) {
+ if (!partiallyRecomputeFor(this, dependentKey)) { return; }
+
+ var dependentArray = get(this, dependentKey);
+
+ if (dependentArray) {
+ addItems.call(this, dependentArray, callbacks, cp, propertyName, meta);
+ }
+ }, this);
+ };
+
+
+ this.func = function (propertyName) {
+ Ember.assert('Computed reduce values require at least one dependent key', cp._dependentKeys);
+
+ recompute.call(this, propertyName);
+
+ return cp._instanceMeta(this, propertyName).getValue();
+ };
+ }
+
+ ReduceComputedProperty.prototype = o_create(ComputedProperty.prototype);
+
+ function defaultCallback(computedValue) {
+ return computedValue;
+ }
+
+ ReduceComputedProperty.prototype._callbacks = function () {
+ if (!this.callbacks) {
+ var options = this.options;
+
+ this.callbacks = {
+ removedItem: options.removedItem || defaultCallback,
+ addedItem: options.addedItem || defaultCallback,
+ flushedChanges: options.flushedChanges || defaultCallback
+ };
+ }
+
+ return this.callbacks;
+ };
+
+ ReduceComputedProperty.prototype._hasInstanceMeta = function (context, propertyName) {
+ return !!metaFor(context).cacheMeta[propertyName];
+ };
+
+ ReduceComputedProperty.prototype._instanceMeta = function (context, propertyName) {
+ var cacheMeta = metaFor(context).cacheMeta;
+ var meta = cacheMeta[propertyName];
+
+ if (!meta) {
+ meta = cacheMeta[propertyName] = new ReduceComputedPropertyInstanceMeta(context, propertyName, this.initialValue());
+ meta.dependentArraysObserver = new DependentArraysObserver(this._callbacks(), this, meta, context, propertyName, meta.sugarMeta);
+ }
+
+ return meta;
+ };
+
+ ReduceComputedProperty.prototype.initialValue = function () {
+ if (typeof this.options.initialValue === 'function') {
+ return this.options.initialValue();
+ }
+ else {
+ return this.options.initialValue;
+ }
+ };
+
+ ReduceComputedProperty.prototype.resetValue = function (value) {
+ return this.initialValue();
+ };
+
+ ReduceComputedProperty.prototype.itemPropertyKey = function (dependentArrayKey, itemPropertyKey) {
+ this._itemPropertyKeys[dependentArrayKey] = this._itemPropertyKeys[dependentArrayKey] || [];
+ this._itemPropertyKeys[dependentArrayKey].push(itemPropertyKey);
+ };
+
+ ReduceComputedProperty.prototype.clearItemPropertyKeys = function (dependentArrayKey) {
+ if (this._itemPropertyKeys[dependentArrayKey]) {
+ this._previousItemPropertyKeys[dependentArrayKey] = this._itemPropertyKeys[dependentArrayKey];
+ this._itemPropertyKeys[dependentArrayKey] = [];
+ }
+ };
+
+ ReduceComputedProperty.prototype.property = function () {
+ var cp = this;
+ var args = a_slice.call(arguments);
+ var propertyArgs = {};
+ var match, dependentArrayKey;
+
+ forEach(args, function (dependentKey) {
+ if (doubleEachPropertyPattern.test(dependentKey)) {
+ throw new EmberError('Nested @each properties not supported: ' + dependentKey);
+ } else if (match = eachPropertyPattern.exec(dependentKey)) {
+ dependentArrayKey = match[1];
+
+ var itemPropertyKeyPattern = match[2];
+ var addItemPropertyKey = function (itemPropertyKey) {
+ cp.itemPropertyKey(dependentArrayKey, itemPropertyKey);
+ };
+
+ expandProperties(itemPropertyKeyPattern, addItemPropertyKey);
+ propertyArgs[guidFor(dependentArrayKey)] = dependentArrayKey;
+ } else {
+ propertyArgs[guidFor(dependentKey)] = dependentKey;
+ }
+ });
+
+ var propertyArgsToArray = [];
+ for (var guid in propertyArgs) {
+ propertyArgsToArray.push(propertyArgs[guid]);
+ }
+
+ return ComputedProperty.prototype.property.apply(this, propertyArgsToArray);
+ };
+
+ /**
+ Creates a computed property which operates on dependent arrays and
+ is updated with "one at a time" semantics. When items are added or
+ removed from the dependent array(s) a reduce computed only operates
+ on the change instead of re-evaluating the entire array.
+
+ If there are more than one arguments the first arguments are
+ considered to be dependent property keys. The last argument is
+ required to be an options object. The options object can have the
+ following four properties:
+
+ `initialValue` - A value or function that will be used as the initial
+ value for the computed. If this property is a function the result of calling
+ the function will be used as the initial value. This property is required.
+
+ `initialize` - An optional initialize function. Typically this will be used
+ to set up state on the instanceMeta object.
+
+ `removedItem` - A function that is called each time an element is removed
+ from the array.
+
+ `addedItem` - A function that is called each time an element is added to
+ the array.
+
+
+ The `initialize` function has the following signature:
+
+ ```javascript
+ function(initialValue, changeMeta, instanceMeta)
+ ```
+
+ `initialValue` - The value of the `initialValue` property from the
+ options object.
+
+ `changeMeta` - An object which contains meta information about the
+ computed. It contains the following properties:
+
+ - `property` the computed property
+ - `propertyName` the name of the property on the object
+
+ `instanceMeta` - An object that can be used to store meta
+ information needed for calculating your computed. For example a
+ unique computed might use this to store the number of times a given
+ element is found in the dependent array.
+
+
+ The `removedItem` and `addedItem` functions both have the following signature:
+
+ ```javascript
+ function(accumulatedValue, item, changeMeta, instanceMeta)
+ ```
+
+ `accumulatedValue` - The value returned from the last time
+ `removedItem` or `addedItem` was called or `initialValue`.
+
+ `item` - the element added or removed from the array
+
+ `changeMeta` - An object which contains meta information about the
+ change. It contains the following properties:
+
+ - `property` the computed property
+ - `propertyName` the name of the property on the object
+ - `index` the index of the added or removed item
+ - `item` the added or removed item: this is exactly the same as
+ the second arg
+ - `arrayChanged` the array that triggered the change. Can be
+ useful when depending on multiple arrays.
+
+ For property changes triggered on an item property change (when
+ depKey is something like `someArray.@each.someProperty`),
+ `changeMeta` will also contain the following property:
+
+ - `previousValues` an object whose keys are the properties that changed on
+ the item, and whose values are the item's previous values.
+
+ `previousValues` is important Ember coalesces item property changes via
+ Ember.run.once. This means that by the time removedItem gets called, item has
+ the new values, but you may need the previous value (eg for sorting &
+ filtering).
+
+ `instanceMeta` - An object that can be used to store meta
+ information needed for calculating your computed. For example a
+ unique computed might use this to store the number of times a given
+ element is found in the dependent array.
+
+ The `removedItem` and `addedItem` functions should return the accumulated
+ value. It is acceptable to not return anything (ie return undefined)
+ to invalidate the computation. This is generally not a good idea for
+ arrayComputed but it's used in eg max and min.
+
+ Note that observers will be fired if either of these functions return a value
+ that differs from the accumulated value. When returning an object that
+ mutates in response to array changes, for example an array that maps
+ everything from some other array (see `Ember.computed.map`), it is usually
+ important that the *same* array be returned to avoid accidentally triggering observers.
+
+ Example
+
+ ```javascript
+ Ember.computed.max = function(dependentKey) {
+ return Ember.reduceComputed(dependentKey, {
+ initialValue: -Infinity,
+
+ addedItem: function(accumulatedValue, item, changeMeta, instanceMeta) {
+ return Math.max(accumulatedValue, item);
+ },
+
+ removedItem: function(accumulatedValue, item, changeMeta, instanceMeta) {
+ if (item < accumulatedValue) {
+ return accumulatedValue;
+ }
+ }
+ });
+ };
+ ```
+
+ Dependent keys may refer to `@this` to observe changes to the object itself,
+ which must be array-like, rather than a property of the object. This is
+ mostly useful for array proxies, to ensure objects are retrieved via
+ `objectAtContent`. This is how you could sort items by properties defined on an item controller.
+
+ Example
+
+ ```javascript
+ App.PeopleController = Ember.ArrayController.extend({
+ itemController: 'person',
+
+ sortedPeople: Ember.computed.sort('@this.@each.reversedName', function(personA, personB) {
+ // `reversedName` isn't defined on Person, but we have access to it via
+ // the item controller App.PersonController. If we'd used
+ // `content.@each.reversedName` above, we would be getting the objects
+ // directly and not have access to `reversedName`.
+ //
+ var reversedNameA = get(personA, 'reversedName');
+ var reversedNameB = get(personB, 'reversedName');
+
+ return Ember.compare(reversedNameA, reversedNameB);
+ })
+ });
+
+ App.PersonController = Ember.ObjectController.extend({
+ reversedName: function() {
+ return reverse(get(this, 'name'));
+ }.property('name')
+ });
+ ```
+
+ Dependent keys whose values are not arrays are treated as regular
+ dependencies: when they change, the computed property is completely
+ recalculated. It is sometimes useful to have dependent arrays with similar
+ semantics. Dependent keys which end in `.[]` do not use "one at a time"
+ semantics. When an item is added or removed from such a dependency, the
+ computed property is completely recomputed.
+
+ When the computed property is completely recomputed, the `accumulatedValue`
+ is discarded, it starts with `initialValue` again, and each item is passed
+ to `addedItem` in turn.
+
+ Example
+
+ ```javascript
+ Ember.Object.extend({
+ // When `string` is changed, `computed` is completely recomputed.
+ string: 'a string',
+
+ // When an item is added to `array`, `addedItem` is called.
+ array: [],
+
+ // When an item is added to `anotherArray`, `computed` is completely
+ // recomputed.
+ anotherArray: [],
+
+ computed: Ember.reduceComputed('string', 'array', 'anotherArray.[]', {
+ addedItem: addedItemCallback,
+ removedItem: removedItemCallback
+ })
+ });
+ ```
+
+ @method reduceComputed
+ @for Ember
+ @param {String} [dependentKeys*]
+ @param {Object} options
+ @return {Ember.ComputedProperty}
+ */
+ function reduceComputed(options) {
+ var args;
+
+ if (arguments.length > 1) {
+ args = a_slice.call(arguments, 0, -1);
+ options = a_slice.call(arguments, -1)[0];
+ }
+
+ if (typeof options !== 'object') {
+ throw new EmberError('Reduce Computed Property declared without an options hash');
+ }
+
+ if (!('initialValue' in options)) {
+ throw new EmberError('Reduce Computed Property declared without an initial value');
+ }
+
+ var cp = new ReduceComputedProperty(options);
+
+ if (args) {
+ cp.property.apply(cp, args);
+ }
+
+ return cp;
+ }
+
+ __exports__.reduceComputed = reduceComputed;
+ });
+enifed("ember-runtime/computed/reduce_computed_macros",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/error","ember-metal/enumerable_utils","ember-metal/run_loop","ember-metal/observer","ember-runtime/computed/array_computed","ember-runtime/computed/reduce_computed","ember-runtime/system/subarray","ember-metal/keys","ember-runtime/compare","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+ var get = __dependency2__.get;
+ var isArray = __dependency3__.isArray;
+ var guidFor = __dependency3__.guidFor;
+ var EmberError = __dependency4__["default"];
+ var forEach = __dependency5__.forEach;
+ var run = __dependency6__["default"];
+ var addObserver = __dependency7__.addObserver;
+ var arrayComputed = __dependency8__.arrayComputed;
+ var reduceComputed = __dependency9__.reduceComputed;
+ var SubArray = __dependency10__["default"];
+ var keys = __dependency11__["default"];
+ var compare = __dependency12__["default"];
+
+ var a_slice = [].slice;
+
+ /**
+ A computed property that returns the sum of the value
+ in the dependent array.
+
+ @method computed.sum
+ @for Ember
+ @param {String} dependentKey
+ @return {Ember.ComputedProperty} computes the sum of all values in the dependentKey's array
+ @since 1.4.0
+ */
+
+ function sum(dependentKey){
+ return reduceComputed(dependentKey, {
+ initialValue: 0,
+
+ addedItem: function(accumulatedValue, item, changeMeta, instanceMeta){
+ return accumulatedValue + item;
+ },
+
+ removedItem: function(accumulatedValue, item, changeMeta, instanceMeta){
+ return accumulatedValue - item;
+ }
+ });
+ }
+
+ __exports__.sum = sum;/**
+ A computed property that calculates the maximum value in the
+ dependent array. This will return `-Infinity` when the dependent
+ array is empty.
+
+ ```javascript
+ var Person = Ember.Object.extend({
+ childAges: Ember.computed.mapBy('children', 'age'),
+ maxChildAge: Ember.computed.max('childAges')
+ });
+
+ var lordByron = Person.create({ children: [] });
+
+ lordByron.get('maxChildAge'); // -Infinity
+ lordByron.get('children').pushObject({
+ name: 'Augusta Ada Byron', age: 7
+ });
+ lordByron.get('maxChildAge'); // 7
+ lordByron.get('children').pushObjects([{
+ name: 'Allegra Byron',
+ age: 5
+ }, {
+ name: 'Elizabeth Medora Leigh',
+ age: 8
+ }]);
+ lordByron.get('maxChildAge'); // 8
+ ```
+
+ @method computed.max
+ @for Ember
+ @param {String} dependentKey
+ @return {Ember.ComputedProperty} computes the largest value in the dependentKey's array
+ */
+ function max(dependentKey) {
+ return reduceComputed(dependentKey, {
+ initialValue: -Infinity,
+
+ addedItem: function (accumulatedValue, item, changeMeta, instanceMeta) {
+ return Math.max(accumulatedValue, item);
+ },
+
+ removedItem: function (accumulatedValue, item, changeMeta, instanceMeta) {
+ if (item < accumulatedValue) {
+ return accumulatedValue;
+ }
+ }
+ });
+ }
+
+ __exports__.max = max;/**
+ A computed property that calculates the minimum value in the
+ dependent array. This will return `Infinity` when the dependent
+ array is empty.
+
+ ```javascript
+ var Person = Ember.Object.extend({
+ childAges: Ember.computed.mapBy('children', 'age'),
+ minChildAge: Ember.computed.min('childAges')
+ });
+
+ var lordByron = Person.create({ children: [] });
+
+ lordByron.get('minChildAge'); // Infinity
+ lordByron.get('children').pushObject({
+ name: 'Augusta Ada Byron', age: 7
+ });
+ lordByron.get('minChildAge'); // 7
+ lordByron.get('children').pushObjects([{
+ name: 'Allegra Byron',
+ age: 5
+ }, {
+ name: 'Elizabeth Medora Leigh',
+ age: 8
+ }]);
+ lordByron.get('minChildAge'); // 5
+ ```
+
+ @method computed.min
+ @for Ember
+ @param {String} dependentKey
+ @return {Ember.ComputedProperty} computes the smallest value in the dependentKey's array
+ */
+ function min(dependentKey) {
+ return reduceComputed(dependentKey, {
+ initialValue: Infinity,
+
+ addedItem: function (accumulatedValue, item, changeMeta, instanceMeta) {
+ return Math.min(accumulatedValue, item);
+ },
+
+ removedItem: function (accumulatedValue, item, changeMeta, instanceMeta) {
+ if (item > accumulatedValue) {
+ return accumulatedValue;
+ }
+ }
+ });
+ }
+
+ __exports__.min = min;/**
+ Returns an array mapped via the callback
+
+ The callback method you provide should have the following signature.
+ `item` is the current item in the iteration.
+ `index` is the integer index of the current item in the iteration.
+
+ ```javascript
+ function(item, index);
+ ```
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ excitingChores: Ember.computed.map('chores', function(chore, index) {
+ return chore.toUpperCase() + '!';
+ })
+ });
+
+ var hamster = Hamster.create({
+ chores: ['clean', 'write more unit tests']
+ });
+
+ hamster.get('excitingChores'); // ['CLEAN!', 'WRITE MORE UNIT TESTS!']
+ ```
+
+ @method computed.map
+ @for Ember
+ @param {String} dependentKey
+ @param {Function} callback
+ @return {Ember.ComputedProperty} an array mapped via the callback
+ */
+ function map(dependentKey, callback) {
+ var options = {
+ addedItem: function(array, item, changeMeta, instanceMeta) {
+ var mapped = callback.call(this, item, changeMeta.index);
+ array.insertAt(changeMeta.index, mapped);
+ return array;
+ },
+ removedItem: function(array, item, changeMeta, instanceMeta) {
+ array.removeAt(changeMeta.index, 1);
+ return array;
+ }
+ };
+
+ return arrayComputed(dependentKey, options);
+ }
+
+ __exports__.map = map;/**
+ Returns an array mapped to the specified key.
+
+ ```javascript
+ var Person = Ember.Object.extend({
+ childAges: Ember.computed.mapBy('children', 'age')
+ });
+
+ var lordByron = Person.create({ children: [] });
+
+ lordByron.get('childAges'); // []
+ lordByron.get('children').pushObject({ name: 'Augusta Ada Byron', age: 7 });
+ lordByron.get('childAges'); // [7]
+ lordByron.get('children').pushObjects([{
+ name: 'Allegra Byron',
+ age: 5
+ }, {
+ name: 'Elizabeth Medora Leigh',
+ age: 8
+ }]);
+ lordByron.get('childAges'); // [7, 5, 8]
+ ```
+
+ @method computed.mapBy
+ @for Ember
+ @param {String} dependentKey
+ @param {String} propertyKey
+ @return {Ember.ComputedProperty} an array mapped to the specified key
+ */
+ function mapBy (dependentKey, propertyKey) {
+ var callback = function(item) { return get(item, propertyKey); };
+ return map(dependentKey + '.@each.' + propertyKey, callback);
+ }
+
+ __exports__.mapBy = mapBy;/**
+ @method computed.mapProperty
+ @for Ember
+ @deprecated Use `Ember.computed.mapBy` instead
+ @param dependentKey
+ @param propertyKey
+ */
+ var mapProperty = mapBy;
+ __exports__.mapProperty = mapProperty;
+ /**
+ Filters the array by the callback.
+
+ The callback method you provide should have the following signature.
+ `item` is the current item in the iteration.
+ `index` is the integer index of the current item in the iteration.
+ `array` is the dependant array itself.
+
+ ```javascript
+ function(item, index, array);
+ ```
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ remainingChores: Ember.computed.filter('chores', function(chore, index, array) {
+ return !chore.done;
+ })
+ });
+
+ var hamster = Hamster.create({
+ chores: [
+ { name: 'cook', done: true },
+ { name: 'clean', done: true },
+ { name: 'write more unit tests', done: false }
+ ]
+ });
+
+ hamster.get('remainingChores'); // [{name: 'write more unit tests', done: false}]
+ ```
+
+ @method computed.filter
+ @for Ember
+ @param {String} dependentKey
+ @param {Function} callback
+ @return {Ember.ComputedProperty} the filtered array
+ */
+ function filter(dependentKey, callback) {
+ var options = {
+ initialize: function (array, changeMeta, instanceMeta) {
+ instanceMeta.filteredArrayIndexes = new SubArray();
+ },
+
+ addedItem: function (array, item, changeMeta, instanceMeta) {
+ var match = !!callback.call(this, item, changeMeta.index, changeMeta.arrayChanged);
+ var filterIndex = instanceMeta.filteredArrayIndexes.addItem(changeMeta.index, match);
+
+ if (match) {
+ array.insertAt(filterIndex, item);
+ }
+
+ return array;
+ },
+
+ removedItem: function(array, item, changeMeta, instanceMeta) {
+ var filterIndex = instanceMeta.filteredArrayIndexes.removeItem(changeMeta.index);
+
+ if (filterIndex > -1) {
+ array.removeAt(filterIndex);
+ }
+
+ return array;
+ }
+ };
+
+ return arrayComputed(dependentKey, options);
+ }
+
+ __exports__.filter = filter;/**
+ Filters the array by the property and value
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ remainingChores: Ember.computed.filterBy('chores', 'done', false)
+ });
+
+ var hamster = Hamster.create({
+ chores: [
+ { name: 'cook', done: true },
+ { name: 'clean', done: true },
+ { name: 'write more unit tests', done: false }
+ ]
+ });
+
+ hamster.get('remainingChores'); // [{ name: 'write more unit tests', done: false }]
+ ```
+
+ @method computed.filterBy
+ @for Ember
+ @param {String} dependentKey
+ @param {String} propertyKey
+ @param {*} value
+ @return {Ember.ComputedProperty} the filtered array
+ */
+ function filterBy (dependentKey, propertyKey, value) {
+ var callback;
+
+ if (arguments.length === 2) {
+ callback = function(item) {
+ return get(item, propertyKey);
+ };
+ } else {
+ callback = function(item) {
+ return get(item, propertyKey) === value;
+ };
+ }
+
+ return filter(dependentKey + '.@each.' + propertyKey, callback);
+ }
+
+ __exports__.filterBy = filterBy;/**
+ @method computed.filterProperty
+ @for Ember
+ @param dependentKey
+ @param propertyKey
+ @param value
+ @deprecated Use `Ember.computed.filterBy` instead
+ */
+ var filterProperty = filterBy;
+ __exports__.filterProperty = filterProperty;
+ /**
+ A computed property which returns a new array with all the unique
+ elements from one or more dependent arrays.
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ uniqueFruits: Ember.computed.uniq('fruits')
+ });
+
+ var hamster = Hamster.create({
+ fruits: [
+ 'banana',
+ 'grape',
+ 'kale',
+ 'banana'
+ ]
+ });
+
+ hamster.get('uniqueFruits'); // ['banana', 'grape', 'kale']
+ ```
+
+ @method computed.uniq
+ @for Ember
+ @param {String} propertyKey*
+ @return {Ember.ComputedProperty} computes a new array with all the
+ unique elements from the dependent array
+ */
+ function uniq() {
+ var args = a_slice.call(arguments);
+
+ args.push({
+ initialize: function(array, changeMeta, instanceMeta) {
+ instanceMeta.itemCounts = {};
+ },
+
+ addedItem: function(array, item, changeMeta, instanceMeta) {
+ var guid = guidFor(item);
+
+ if (!instanceMeta.itemCounts[guid]) {
+ instanceMeta.itemCounts[guid] = 1;
+ array.pushObject(item);
+ } else {
+ ++instanceMeta.itemCounts[guid];
+ }
+ return array;
+ },
+
+ removedItem: function(array, item, _, instanceMeta) {
+ var guid = guidFor(item);
+ var itemCounts = instanceMeta.itemCounts;
+
+ if (--itemCounts[guid] === 0) {
+ array.removeObject(item);
+ }
+
+ return array;
+ }
+ });
+
+ return arrayComputed.apply(null, args);
+ }
+
+ __exports__.uniq = uniq;/**
+ Alias for [Ember.computed.uniq](/api/#method_computed_uniq).
+
+ @method computed.union
+ @for Ember
+ @param {String} propertyKey*
+ @return {Ember.ComputedProperty} computes a new array with all the
+ unique elements from the dependent array
+ */
+ var union = uniq;
+ __exports__.union = union;
+ /**
+ A computed property which returns a new array with all the duplicated
+ elements from two or more dependent arrays.
+
+ Example
+
+ ```javascript
+ var obj = Ember.Object.createWithMixins({
+ adaFriends: ['Charles Babbage', 'John Hobhouse', 'William King', 'Mary Somerville'],
+ charlesFriends: ['William King', 'Mary Somerville', 'Ada Lovelace', 'George Peacock'],
+ friendsInCommon: Ember.computed.intersect('adaFriends', 'charlesFriends')
+ });
+
+ obj.get('friendsInCommon'); // ['William King', 'Mary Somerville']
+ ```
+
+ @method computed.intersect
+ @for Ember
+ @param {String} propertyKey*
+ @return {Ember.ComputedProperty} computes a new array with all the
+ duplicated elements from the dependent arrays
+ */
+ function intersect() {
+ var args = a_slice.call(arguments);
+
+ args.push({
+ initialize: function (array, changeMeta, instanceMeta) {
+ instanceMeta.itemCounts = {};
+ },
+
+ addedItem: function(array, item, changeMeta, instanceMeta) {
+ var itemGuid = guidFor(item);
+ var dependentGuid = guidFor(changeMeta.arrayChanged);
+ var numberOfDependentArrays = changeMeta.property._dependentKeys.length;
+ var itemCounts = instanceMeta.itemCounts;
+
+ if (!itemCounts[itemGuid]) {
+ itemCounts[itemGuid] = {};
+ }
+
+ if (itemCounts[itemGuid][dependentGuid] === undefined) {
+ itemCounts[itemGuid][dependentGuid] = 0;
+ }
+
+ if (++itemCounts[itemGuid][dependentGuid] === 1 &&
+ numberOfDependentArrays === keys(itemCounts[itemGuid]).length) {
+ array.addObject(item);
+ }
+
+ return array;
+ },
+
+ removedItem: function(array, item, changeMeta, instanceMeta) {
+ var itemGuid = guidFor(item);
+ var dependentGuid = guidFor(changeMeta.arrayChanged);
+ var numberOfArraysItemAppearsIn;
+ var itemCounts = instanceMeta.itemCounts;
+
+ if (itemCounts[itemGuid][dependentGuid] === undefined) {
+ itemCounts[itemGuid][dependentGuid] = 0;
+ }
+
+ if (--itemCounts[itemGuid][dependentGuid] === 0) {
+ delete itemCounts[itemGuid][dependentGuid];
+ numberOfArraysItemAppearsIn = keys(itemCounts[itemGuid]).length;
+
+ if (numberOfArraysItemAppearsIn === 0) {
+ delete itemCounts[itemGuid];
+ }
+
+ array.removeObject(item);
+ }
+
+ return array;
+ }
+ });
+
+ return arrayComputed.apply(null, args);
+ }
+
+ __exports__.intersect = intersect;/**
+ A computed property which returns a new array with all the
+ properties from the first dependent array that are not in the second
+ dependent array.
+
+ Example
+
+ ```javascript
+ var Hamster = Ember.Object.extend({
+ likes: ['banana', 'grape', 'kale'],
+ wants: Ember.computed.setDiff('likes', 'fruits')
+ });
+
+ var hamster = Hamster.create({
+ fruits: [
+ 'grape',
+ 'kale',
+ ]
+ });
+
+ hamster.get('wants'); // ['banana']
+ ```
+
+ @method computed.setDiff
+ @for Ember
+ @param {String} setAProperty
+ @param {String} setBProperty
+ @return {Ember.ComputedProperty} computes a new array with all the
+ items from the first dependent array that are not in the second
+ dependent array
+ */
+ function setDiff(setAProperty, setBProperty) {
+ if (arguments.length !== 2) {
+ throw new EmberError('setDiff requires exactly two dependent arrays.');
+ }
+
+ return arrayComputed(setAProperty, setBProperty, {
+ addedItem: function (array, item, changeMeta, instanceMeta) {
+ var setA = get(this, setAProperty);
+ var setB = get(this, setBProperty);
+
+ if (changeMeta.arrayChanged === setA) {
+ if (!setB.contains(item)) {
+ array.addObject(item);
+ }
+ } else {
+ array.removeObject(item);
+ }
+
+ return array;
+ },
+
+ removedItem: function (array, item, changeMeta, instanceMeta) {
+ var setA = get(this, setAProperty);
+ var setB = get(this, setBProperty);
+
+ if (changeMeta.arrayChanged === setB) {
+ if (setA.contains(item)) {
+ array.addObject(item);
+ }
+ } else {
+ array.removeObject(item);
+ }
+
+ return array;
+ }
+ });
+ }
+
+ __exports__.setDiff = setDiff;function binarySearch(array, item, low, high) {
+ var mid, midItem, res, guidMid, guidItem;
+
+ if (arguments.length < 4) {
+ high = get(array, 'length');
+ }
+
+ if (arguments.length < 3) {
+ low = 0;
+ }
+
+ if (low === high) {
+ return low;
+ }
+
+ mid = low + Math.floor((high - low) / 2);
+ midItem = array.objectAt(mid);
+
+ guidMid = guidFor(midItem);
+ guidItem = guidFor(item);
+
+ if (guidMid === guidItem) {
+ return mid;
+ }
+
+ res = this.order(midItem, item);
+
+ if (res === 0) {
+ res = guidMid < guidItem ? -1 : 1;
+ }
+
+
+ if (res < 0) {
+ return this.binarySearch(array, item, mid+1, high);
+ } else if (res > 0) {
+ return this.binarySearch(array, item, low, mid);
+ }
+
+ return mid;
+ }
+
+
+ /**
+ A computed property which returns a new array with all the
+ properties from the first dependent array sorted based on a property
+ or sort function.
+
+ The callback method you provide should have the following signature:
+
+ ```javascript
+ function(itemA, itemB);
+ ```
+
+ - `itemA` the first item to compare.
+ - `itemB` the second item to compare.
+
+ This function should return negative number (e.g. `-1`) when `itemA` should come before
+ `itemB`. It should return positive number (e.g. `1`) when `itemA` should come after
+ `itemB`. If the `itemA` and `itemB` are equal this function should return `0`.
+
+ Therefore, if this function is comparing some numeric values, simple `itemA - itemB` or
+ `itemA.get( 'foo' ) - itemB.get( 'foo' )` can be used instead of series of `if`.
+
+ Example
+
+ ```javascript
+ var ToDoList = Ember.Object.extend({
+ // using standard ascending sort
+ todosSorting: ['name'],
+ sortedTodos: Ember.computed.sort('todos', 'todosSorting'),
+
+ // using descending sort
+ todosSortingDesc: ['name:desc'],
+ sortedTodosDesc: Ember.computed.sort('todos', 'todosSortingDesc'),
+
+ // using a custom sort function
+ priorityTodos: Ember.computed.sort('todos', function(a, b){
+ if (a.priority > b.priority) {
+ return 1;
+ } else if (a.priority < b.priority) {
+ return -1;
+ }
+
+ return 0;
+ })
+ });
+
+ var todoList = ToDoList.create({todos: [
+ { name: 'Unit Test', priority: 2 },
+ { name: 'Documentation', priority: 3 },
+ { name: 'Release', priority: 1 }
+ ]});
+
+ todoList.get('sortedTodos'); // [{ name:'Documentation', priority:3 }, { name:'Release', priority:1 }, { name:'Unit Test', priority:2 }]
+ todoList.get('sortedTodosDesc'); // [{ name:'Unit Test', priority:2 }, { name:'Release', priority:1 }, { name:'Documentation', priority:3 }]
+ todoList.get('priorityTodos'); // [{ name:'Release', priority:1 }, { name:'Unit Test', priority:2 }, { name:'Documentation', priority:3 }]
+ ```
+
+ @method computed.sort
+ @for Ember
+ @param {String} dependentKey
+ @param {String or Function} sortDefinition a dependent key to an
+ array of sort properties (add `:desc` to the arrays sort properties to sort descending) or a function to use when sorting
+ @return {Ember.ComputedProperty} computes a new sorted array based
+ on the sort property array or callback function
+ */
+ function sort(itemsKey, sortDefinition) {
+ Ember.assert('Ember.computed.sort requires two arguments: an array key to sort and ' +
+ 'either a sort properties key or sort function', arguments.length === 2);
+
+ if (typeof sortDefinition === 'function') {
+ return customSort(itemsKey, sortDefinition);
+ } else {
+ return propertySort(itemsKey, sortDefinition);
+ }
+ }
+
+ __exports__.sort = sort;function customSort(itemsKey, comparator) {
+ return arrayComputed(itemsKey, {
+ initialize: function (array, changeMeta, instanceMeta) {
+ instanceMeta.order = comparator;
+ instanceMeta.binarySearch = binarySearch;
+ instanceMeta.waitingInsertions = [];
+ instanceMeta.insertWaiting = function() {
+ var index, item;
+ var waiting = instanceMeta.waitingInsertions;
+ instanceMeta.waitingInsertions = [];
+ for (var i=0; i{{post.title}} ({{post.titleLength}} characters)
+ {{/each}}
+ ```
+
+ ```javascript
+ App.PostsController = Ember.ArrayController.extend({
+ itemController: 'post'
+ });
+
+ App.PostController = Ember.ObjectController.extend({
+ // the `title` property will be proxied to the underlying post.
+ titleLength: function() {
+ return this.get('title').length;
+ }.property('title')
+ });
+ ```
+
+ In some cases it is helpful to return a different `itemController` depending
+ on the particular item. Subclasses can do this by overriding
+ `lookupItemController`.
+
+ For example:
+
+ ```javascript
+ App.MyArrayController = Ember.ArrayController.extend({
+ lookupItemController: function( object ) {
+ if (object.get('isSpecial')) {
+ return "special"; // use App.SpecialController
+ } else {
+ return "regular"; // use App.RegularController
+ }
+ }
+ });
+ ```
+
+ The itemController instances will have a `parentController` property set to
+ the `ArrayController` instance.
+
+ @class ArrayController
+ @namespace Ember
+ @extends Ember.ArrayProxy
+ @uses Ember.SortableMixin
+ @uses Ember.ControllerMixin
+ */
+
+ __exports__["default"] = ArrayProxy.extend(ControllerMixin, SortableMixin, {
+
+ /**
+ A string containing the controller name used to wrap items.
+
+ For example:
+
+ ```javascript
+ App.MyArrayController = Ember.ArrayController.extend({
+ itemController: 'myItem' // use App.MyItemController
+ });
+ ```
+
+ @property itemController
+ @type String
+ @default null
+ */
+ itemController: null,
+
+ /**
+ Return the name of the controller to wrap items, or `null` if items should
+ be returned directly. The default implementation simply returns the
+ `itemController` property, but subclasses can override this method to return
+ different controllers for different objects.
+
+ For example:
+
+ ```javascript
+ App.MyArrayController = Ember.ArrayController.extend({
+ lookupItemController: function( object ) {
+ if (object.get('isSpecial')) {
+ return "special"; // use App.SpecialController
+ } else {
+ return "regular"; // use App.RegularController
+ }
+ }
+ });
+ ```
+
+ @method lookupItemController
+ @param {Object} object
+ @return {String}
+ */
+ lookupItemController: function(object) {
+ return get(this, 'itemController');
+ },
+
+ objectAtContent: function(idx) {
+ var length = get(this, 'length');
+ var arrangedContent = get(this, 'arrangedContent');
+ var object = arrangedContent && arrangedContent.objectAt(idx);
+ var controllerClass;
+
+ if (idx >= 0 && idx < length) {
+ controllerClass = this.lookupItemController(object);
+
+ if (controllerClass) {
+ return this.controllerAt(idx, object, controllerClass);
+ }
+ }
+
+ // When `controllerClass` is falsy, we have not opted in to using item
+ // controllers, so return the object directly.
+
+ // When the index is out of range, we want to return the "out of range"
+ // value, whatever that might be. Rather than make assumptions
+ // (e.g. guessing `null` or `undefined`) we defer this to `arrangedContent`.
+ return object;
+ },
+
+ arrangedContentDidChange: function() {
+ this._super();
+ this._resetSubControllers();
+ },
+
+ arrayContentDidChange: function(idx, removedCnt, addedCnt) {
+ var subControllers = this._subControllers;
+
+ if (subControllers.length) {
+ var subControllersToRemove = subControllers.slice(idx, idx + removedCnt);
+
+ forEach(subControllersToRemove, function(subController) {
+ if (subController) {
+ subController.destroy();
+ }
+ });
+
+ replace(subControllers, idx, removedCnt, new Array(addedCnt));
+ }
+
+ // The shadow array of subcontrollers must be updated before we trigger
+ // observers, otherwise observers will get the wrong subcontainer when
+ // calling `objectAt`
+ this._super(idx, removedCnt, addedCnt);
+ },
+
+ init: function() {
+ this._super();
+ this._subControllers = [];
+ },
+
+ model: computed(function () {
+ return Ember.A();
+ }),
+
+ /**
+ * Flag to mark as being "virtual". Used to keep this instance
+ * from participating in the parentController hierarchy.
+ *
+ * @private
+ * @property _isVirtual
+ * @type Boolean
+ */
+ _isVirtual: false,
+
+ controllerAt: function(idx, object, controllerClass) {
+ var container = get(this, 'container');
+ var subControllers = this._subControllers;
+ var fullName, subController, subControllerFactory, parentController, options;
+
+ if (subControllers.length > idx) {
+ subController = subControllers[idx];
+
+ if (subController) {
+ return subController;
+ }
+ }
+
+ if (this._isVirtual) {
+ parentController = get(this, 'parentController');
+ } else {
+ parentController = this;
+ }
+
+
+ fullName = 'controller:' + controllerClass;
+
+ if (!container.has(fullName)) {
+ throw new EmberError('Could not resolve itemController: "' + controllerClass + '"');
+ }
+
+ subController = container.lookupFactory(fullName).create({
+ target: parentController,
+ parentController: parentController,
+ model: object
+ });
+
+
+ subControllers[idx] = subController;
+
+ return subController;
+ },
+
+ _subControllers: null,
+
+ _resetSubControllers: function() {
+ var controller;
+ var subControllers = this._subControllers;
+
+ if (subControllers.length) {
+ for (var i = 0, length = subControllers.length; length > i; i++) {
+ controller = subControllers[i];
+
+ if (controller) {
+ controller.destroy();
+ }
+ }
+
+ subControllers.length = 0;
+ }
+ },
+
+ willDestroy: function() {
+ this._resetSubControllers();
+ this._super();
+ }
+ });
+ });
+enifed("ember-runtime/controllers/controller",
+ ["ember-metal/core","ember-runtime/system/object","ember-runtime/mixins/controller","ember-runtime/inject","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+ var EmberObject = __dependency2__["default"];
+ var Mixin = __dependency3__["default"];
+ var createInjectionHelper = __dependency4__.createInjectionHelper;
+
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ /**
+ @class Controller
+ @namespace Ember
+ @extends Ember.Object
+ @uses Ember.ControllerMixin
+ */
+ var Controller = EmberObject.extend(Mixin);
+
+ function controllerInjectionHelper(factory) {
+ Ember.assert("Defining an injected controller property on a " +
+ "non-controller is not allowed.", Controller.detect(factory));
+ }
+
+
+ /**
+ Creates a property that lazily looks up another controller in the container.
+ Can only be used when defining another controller.
+
+ Example:
+
+ ```javascript
+ App.PostController = Ember.Controller.extend({
+ posts: Ember.inject.controller()
+ });
+ ```
+
+ This example will create a `posts` property on the `post` controller that
+ looks up the `posts` controller in the container, making it easy to
+ reference other controllers. This is functionally equivalent to:
+
+ ```javascript
+ App.PostController = Ember.Controller.extend({
+ needs: 'posts',
+ posts: Ember.computed.alias('controllers.posts')
+ });
+ ```
+
+ @method inject.controller
+ @for Ember
+ @param {String} name (optional) name of the controller to inject, defaults
+ to the property's name
+ @return {Ember.InjectedProperty} injection descriptor instance
+ */
+ createInjectionHelper('controller', controllerInjectionHelper);
+
+
+ __exports__["default"] = Controller;
+ });
+enifed("ember-runtime/controllers/object_controller",
+ ["ember-runtime/mixins/controller","ember-runtime/system/object_proxy","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var ControllerMixin = __dependency1__["default"];
+ var ObjectProxy = __dependency2__["default"];
+
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ /**
+ `Ember.ObjectController` is part of Ember's Controller layer. It is intended
+ to wrap a single object, proxying unhandled attempts to `get` and `set` to the underlying
+ model object, and to forward unhandled action attempts to its `target`.
+
+ `Ember.ObjectController` derives this functionality from its superclass
+ `Ember.ObjectProxy` and the `Ember.ControllerMixin` mixin.
+
+ @class ObjectController
+ @namespace Ember
+ @extends Ember.ObjectProxy
+ @uses Ember.ControllerMixin
+ **/
+ __exports__["default"] = ObjectProxy.extend(ControllerMixin);
+ });
+enifed("ember-runtime/copy",
+ ["ember-metal/enumerable_utils","ember-metal/utils","ember-runtime/system/object","ember-runtime/mixins/copyable","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ var indexOf = __dependency1__.indexOf;
+ var typeOf = __dependency2__.typeOf;
+ var EmberObject = __dependency3__["default"];
+ var Copyable = __dependency4__["default"];
+
+ function _copy(obj, deep, seen, copies) {
+ var ret, loc, key;
+
+ // primitive data types are immutable, just return them.
+ if (typeof obj !== 'object' || obj === null) {
+ return obj;
+ }
+
+ // avoid cyclical loops
+ if (deep && (loc = indexOf(seen, obj)) >= 0) {
+ return copies[loc];
+ }
+
+ Ember.assert('Cannot clone an Ember.Object that does not implement Ember.Copyable',
+ !(obj instanceof EmberObject) || (Copyable && Copyable.detect(obj)));
+
+ // IMPORTANT: this specific test will detect a native array only. Any other
+ // object will need to implement Copyable.
+ if (typeOf(obj) === 'array') {
+ ret = obj.slice();
+
+ if (deep) {
+ loc = ret.length;
+
+ while (--loc >= 0) {
+ ret[loc] = _copy(ret[loc], deep, seen, copies);
+ }
+ }
+ } else if (Copyable && Copyable.detect(obj)) {
+ ret = obj.copy(deep, seen, copies);
+ } else if (obj instanceof Date) {
+ ret = new Date(obj.getTime());
+ } else {
+ ret = {};
+
+ for (key in obj) {
+ // support Null prototype
+ if (!Object.prototype.hasOwnProperty.call(obj, key)) {
+ continue;
+ }
+
+ // Prevents browsers that don't respect non-enumerability from
+ // copying internal Ember properties
+ if (key.substring(0, 2) === '__') {
+ continue;
+ }
+
+ ret[key] = deep ? _copy(obj[key], deep, seen, copies) : obj[key];
+ }
+ }
+
+ if (deep) {
+ seen.push(obj);
+ copies.push(ret);
+ }
+
+ return ret;
+ }
+
+ /**
+ Creates a clone of the passed object. This function can take just about
+ any type of object and create a clone of it, including primitive values
+ (which are not actually cloned because they are immutable).
+
+ If the passed object implements the `copy()` method, then this function
+ will simply call that method and return the result. Please see
+ `Ember.Copyable` for further details.
+
+ @method copy
+ @for Ember
+ @param {Object} obj The object to clone
+ @param {Boolean} deep If true, a deep copy of the object is made
+ @return {Object} The cloned object
+ */
+ __exports__["default"] = function copy(obj, deep) {
+ // fast paths
+ if ('object' !== typeof obj || obj === null) {
+ return obj; // can't copy primitives
+ }
+
+ if (Copyable && Copyable.detect(obj)) {
+ return obj.copy(deep);
+ }
+
+ return _copy(obj, deep, deep ? [] : null, deep ? [] : null);
+ }
+ });
+enifed("ember-runtime/core",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ /**
+ Compares two objects, returning true if they are logically equal. This is
+ a deeper comparison than a simple triple equal. For sets it will compare the
+ internal objects. For any other object that implements `isEqual()` it will
+ respect that method.
+
+ ```javascript
+ Ember.isEqual('hello', 'hello'); // true
+ Ember.isEqual(1, 2); // false
+ Ember.isEqual([4, 2], [4, 2]); // false
+ ```
+
+ @method isEqual
+ @for Ember
+ @param {Object} a first object to compare
+ @param {Object} b second object to compare
+ @return {Boolean}
+ */
+ var isEqual = function isEqual(a, b) {
+ if (a && typeof a.isEqual === 'function') {
+ return a.isEqual(b);
+ }
+
+ if (a instanceof Date && b instanceof Date) {
+ return a.getTime() === b.getTime();
+ }
+
+ return a === b;
+ };
+ __exports__.isEqual = isEqual;
+ });
+enifed("ember-runtime/ext/function",
+ ["ember-metal/core","ember-metal/expand_properties","ember-metal/computed","ember-metal/mixin"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ var Ember = __dependency1__["default"];
+ // Ember.EXTEND_PROTOTYPES, Ember.assert
+ var expandProperties = __dependency2__["default"];
+ var computed = __dependency3__.computed;
+ var observer = __dependency4__.observer;
+
+ var a_slice = Array.prototype.slice;
+ var FunctionPrototype = Function.prototype;
+
+ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Function) {
+
+ /**
+ The `property` extension of Javascript's Function prototype is available
+ when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is
+ `true`, which is the default.
+
+ Computed properties allow you to treat a function like a property:
+
+ ```javascript
+ MyApp.President = Ember.Object.extend({
+ firstName: '',
+ lastName: '',
+
+ fullName: function() {
+ return this.get('firstName') + ' ' + this.get('lastName');
+ }.property() // Call this flag to mark the function as a property
+ });
+
+ var president = MyApp.President.create({
+ firstName: 'Barack',
+ lastName: 'Obama'
+ });
+
+ president.get('fullName'); // 'Barack Obama'
+ ```
+
+ Treating a function like a property is useful because they can work with
+ bindings, just like any other property.
+
+ Many computed properties have dependencies on other properties. For
+ example, in the above example, the `fullName` property depends on
+ `firstName` and `lastName` to determine its value. You can tell Ember
+ about these dependencies like this:
+
+ ```javascript
+ MyApp.President = Ember.Object.extend({
+ firstName: '',
+ lastName: '',
+
+ fullName: function() {
+ return this.get('firstName') + ' ' + this.get('lastName');
+
+ // Tell Ember.js that this computed property depends on firstName
+ // and lastName
+ }.property('firstName', 'lastName')
+ });
+ ```
+
+ Make sure you list these dependencies so Ember knows when to update
+ bindings that connect to a computed property. Changing a dependency
+ will not immediately trigger an update of the computed property, but
+ will instead clear the cache so that it is updated when the next `get`
+ is called on the property.
+
+ See [Ember.ComputedProperty](/api/classes/Ember.ComputedProperty.html), [Ember.computed](/api/#method_computed).
+
+ @method property
+ @for Function
+ */
+ FunctionPrototype.property = function () {
+ var ret = computed(this);
+ // ComputedProperty.prototype.property expands properties; no need for us to
+ // do so here.
+ return ret.property.apply(ret, arguments);
+ };
+
+ /**
+ The `observes` extension of Javascript's Function prototype is available
+ when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is
+ true, which is the default.
+
+ You can observe property changes simply by adding the `observes`
+ call to the end of your method declarations in classes that you write.
+ For example:
+
+ ```javascript
+ Ember.Object.extend({
+ valueObserver: function() {
+ // Executes whenever the "value" property changes
+ }.observes('value')
+ });
+ ```
+
+ In the future this method may become asynchronous. If you want to ensure
+ synchronous behavior, use `observesImmediately`.
+
+ See `Ember.observer`.
+
+ @method observes
+ @for Function
+ */
+ FunctionPrototype.observes = function() {
+ var length = arguments.length;
+ var args = new Array(length);
+ for (var x = 0; x < length; x++) {
+ args[x] = arguments[x];
+ }
+ return observer.apply(this, args.concat(this));
+ };
+
+ /**
+ The `observesImmediately` extension of Javascript's Function prototype is
+ available when `Ember.EXTEND_PROTOTYPES` or
+ `Ember.EXTEND_PROTOTYPES.Function` is true, which is the default.
+
+ You can observe property changes simply by adding the `observesImmediately`
+ call to the end of your method declarations in classes that you write.
+ For example:
+
+ ```javascript
+ Ember.Object.extend({
+ valueObserver: function() {
+ // Executes immediately after the "value" property changes
+ }.observesImmediately('value')
+ });
+ ```
+
+ In the future, `observes` may become asynchronous. In this event,
+ `observesImmediately` will maintain the synchronous behavior.
+
+ See `Ember.immediateObserver`.
+
+ @method observesImmediately
+ @for Function
+ */
+ FunctionPrototype.observesImmediately = function () {
+ Ember.assert('Immediate observers must observe internal properties only, ' +
+ 'not properties on other objects.', function checkIsInternalProperty() {
+ for(var i = 0, l = arguments.length; i < l; i++) {
+ if(arguments[i].indexOf('.') !== -1) {
+ return false;
+ }
+ }
+ return true;
+ });
+
+ // observes handles property expansion
+ return this.observes.apply(this, arguments);
+ };
+
+ /**
+ The `observesBefore` extension of Javascript's Function prototype is
+ available when `Ember.EXTEND_PROTOTYPES` or
+ `Ember.EXTEND_PROTOTYPES.Function` is true, which is the default.
+
+ You can get notified when a property change is about to happen by
+ by adding the `observesBefore` call to the end of your method
+ declarations in classes that you write. For example:
+
+ ```javascript
+ Ember.Object.extend({
+ valueObserver: function() {
+ // Executes whenever the "value" property is about to change
+ }.observesBefore('value')
+ });
+ ```
+
+ See `Ember.beforeObserver`.
+
+ @method observesBefore
+ @for Function
+ */
+ FunctionPrototype.observesBefore = function () {
+ var watched = [];
+ var addWatchedProperty = function (obs) {
+ watched.push(obs);
+ };
+
+ for (var i = 0, l = arguments.length; i < l; ++i) {
+ expandProperties(arguments[i], addWatchedProperty);
+ }
+
+ this.__ember_observesBefore__ = watched;
+
+ return this;
+ };
+
+ /**
+ The `on` extension of Javascript's Function prototype is available
+ when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is
+ true, which is the default.
+
+ You can listen for events simply by adding the `on` call to the end of
+ your method declarations in classes or mixins that you write. For example:
+
+ ```javascript
+ Ember.Mixin.create({
+ doSomethingWithElement: function() {
+ // Executes whenever the "didInsertElement" event fires
+ }.on('didInsertElement')
+ });
+ ```
+
+ See `Ember.on`.
+
+ @method on
+ @for Function
+ */
+ FunctionPrototype.on = function () {
+ var events = a_slice.call(arguments);
+ this.__ember_listens__ = events;
+
+ return this;
+ };
+ }
+ });
+enifed("ember-runtime/ext/rsvp",
+ ["ember-metal/core","ember-metal/logger","ember-metal/run_loop","rsvp","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ /* globals RSVP:true */
+
+ var Ember = __dependency1__["default"];
+ var Logger = __dependency2__["default"];
+ var run = __dependency3__["default"];
+
+ // this is technically incorrect (per @wycats)
+ // it should be `import * as RSVP from 'rsvp';` but
+ // Esprima does not support this syntax yet (and neither does
+ // es6-module-transpiler 0.4.0 - 0.6.2).
+ var RSVP = __dependency4__;
+
+ var testModuleName = 'ember-testing/test';
+ var Test;
+
+ var asyncStart = function() {
+ if (Ember.Test && Ember.Test.adapter) {
+ Ember.Test.adapter.asyncStart();
+ }
+ };
+
+ var asyncEnd = function() {
+ if (Ember.Test && Ember.Test.adapter) {
+ Ember.Test.adapter.asyncEnd();
+ }
+ };
+
+ RSVP.configure('async', function(callback, promise) {
+ var async = !run.currentRunLoop;
+
+ if (Ember.testing && async) { asyncStart(); }
+
+ run.backburner.schedule('actions', function(){
+ if (Ember.testing && async) { asyncEnd(); }
+ callback(promise);
+ });
+ });
+
+ RSVP.Promise.prototype.fail = function(callback, label){
+ Ember.deprecate('RSVP.Promise.fail has been renamed as RSVP.Promise.catch');
+ return this['catch'](callback, label);
+ };
+
+ RSVP.onerrorDefault = function (e) {
+ var error;
+
+ if (e && e.errorThrown) {
+ // jqXHR provides this
+ error = e.errorThrown;
+ if (typeof error === 'string') {
+ error = new Error(error);
+ }
+ error.__reason_with_error_thrown__ = e;
+ } else {
+ error = e;
+ }
+
+ if (error && error.name !== 'TransitionAborted') {
+ if (Ember.testing) {
+ // ES6TODO: remove when possible
+ if (!Test && Ember.__loader.registry[testModuleName]) {
+ Test = requireModule(testModuleName)['default'];
+ }
+
+ if (Test && Test.adapter) {
+ Test.adapter.exception(error);
+ Logger.error(error.stack);
+ } else {
+ throw error;
+ }
+ } else if (Ember.onerror) {
+ Ember.onerror(error);
+ } else {
+ Logger.error(error.stack);
+ }
+ }
+ };
+
+ RSVP.on('error', RSVP.onerrorDefault);
+
+ __exports__["default"] = RSVP;
+ });
+enifed("ember-runtime/ext/string",
+ ["ember-metal/core","ember-runtime/system/string"],
+ function(__dependency1__, __dependency2__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ var Ember = __dependency1__["default"];
+ // Ember.EXTEND_PROTOTYPES, Ember.assert, Ember.FEATURES
+ var fmt = __dependency2__.fmt;
+ var w = __dependency2__.w;
+ var loc = __dependency2__.loc;
+ var camelize = __dependency2__.camelize;
+ var decamelize = __dependency2__.decamelize;
+ var dasherize = __dependency2__.dasherize;
+ var underscore = __dependency2__.underscore;
+ var capitalize = __dependency2__.capitalize;
+ var classify = __dependency2__.classify;
+
+ var StringPrototype = String.prototype;
+
+ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) {
+
+ /**
+ See [Ember.String.fmt](/api/classes/Ember.String.html#method_fmt).
+
+ @method fmt
+ @for String
+ */
+ StringPrototype.fmt = function () {
+ return fmt(this, arguments);
+ };
+
+ /**
+ See [Ember.String.w](/api/classes/Ember.String.html#method_w).
+
+ @method w
+ @for String
+ */
+ StringPrototype.w = function () {
+ return w(this);
+ };
+
+ /**
+ See [Ember.String.loc](/api/classes/Ember.String.html#method_loc).
+
+ @method loc
+ @for String
+ */
+ StringPrototype.loc = function () {
+ return loc(this, arguments);
+ };
+
+ /**
+ See [Ember.String.camelize](/api/classes/Ember.String.html#method_camelize).
+
+ @method camelize
+ @for String
+ */
+ StringPrototype.camelize = function () {
+ return camelize(this);
+ };
+
+ /**
+ See [Ember.String.decamelize](/api/classes/Ember.String.html#method_decamelize).
+
+ @method decamelize
+ @for String
+ */
+ StringPrototype.decamelize = function () {
+ return decamelize(this);
+ };
+
+ /**
+ See [Ember.String.dasherize](/api/classes/Ember.String.html#method_dasherize).
+
+ @method dasherize
+ @for String
+ */
+ StringPrototype.dasherize = function () {
+ return dasherize(this);
+ };
+
+ /**
+ See [Ember.String.underscore](/api/classes/Ember.String.html#method_underscore).
+
+ @method underscore
+ @for String
+ */
+ StringPrototype.underscore = function () {
+ return underscore(this);
+ };
+
+ /**
+ See [Ember.String.classify](/api/classes/Ember.String.html#method_classify).
+
+ @method classify
+ @for String
+ */
+ StringPrototype.classify = function () {
+ return classify(this);
+ };
+
+ /**
+ See [Ember.String.capitalize](/api/classes/Ember.String.html#method_capitalize).
+
+ @method capitalize
+ @for String
+ */
+ StringPrototype.capitalize = function () {
+ return capitalize(this);
+ };
+ }
+ });
+enifed("ember-runtime/inject",
+ ["ember-metal/core","ember-metal/enumerable_utils","ember-metal/utils","ember-metal/injected_property","ember-metal/keys","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+ var indexOf = __dependency2__.indexOf;
+ var meta = __dependency3__.meta;
+ var InjectedProperty = __dependency4__["default"];
+ var keys = __dependency5__["default"];
+
+ /**
+ Namespace for injection helper methods.
+
+ @class inject
+ @namespace Ember
+ */
+ function inject() {
+ Ember.assert("Injected properties must be created through helpers, see `" +
+ keys(inject).join("`, `") + "`");
+ }
+
+ // Dictionary of injection validations by type, added to by `createInjectionHelper`
+ var typeValidators = {};
+
+ /**
+ This method allows other Ember modules to register injection helpers for a
+ given container type. Helpers are exported to the `inject` namespace as the
+ container type itself.
+
+ @private
+ @method createInjectionHelper
+ @namespace Ember
+ @param {String} type The container type the helper will inject
+ @param {Function} validator A validation callback that is executed at mixin-time
+ */
+ function createInjectionHelper(type, validator) {
+ typeValidators[type] = validator;
+
+ inject[type] = function(name) {
+ return new InjectedProperty(type, name);
+ };
+ }
+
+ __exports__.createInjectionHelper = createInjectionHelper;/**
+ Validation function that runs per-type validation functions once for each
+ injected type encountered.
+
+ @private
+ @method validatePropertyInjections
+ @namespace Ember
+ @param {Object} factory The factory object
+ */
+ function validatePropertyInjections(factory) {
+ var proto = factory.proto();
+ var descs = meta(proto).descs;
+ var types = [];
+ var key, desc, validator, i, l;
+
+ for (key in descs) {
+ desc = descs[key];
+ if (desc instanceof InjectedProperty && indexOf(types, desc.type) === -1) {
+ types.push(desc.type);
+ }
+ }
+
+ if (types.length) {
+ for (i = 0, l = types.length; i < l; i++) {
+ validator = typeValidators[types[i]];
+
+ if (typeof validator === 'function') {
+ validator(factory);
+ }
+ }
+ }
+
+ return true;
+ }
+
+ __exports__.validatePropertyInjections = validatePropertyInjections;__exports__["default"] = inject;
+ });
+enifed("ember-runtime/mixins/-proxy",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/observer","ember-metal/property_events","ember-metal/computed","ember-metal/properties","ember-metal/mixin","ember-runtime/system/string","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+ var get = __dependency2__.get;
+ var set = __dependency3__.set;
+ var meta = __dependency4__.meta;
+ var addObserver = __dependency5__.addObserver;
+ var removeObserver = __dependency5__.removeObserver;
+ var addBeforeObserver = __dependency5__.addBeforeObserver;
+ var removeBeforeObserver = __dependency5__.removeBeforeObserver;
+ var propertyWillChange = __dependency6__.propertyWillChange;
+ var propertyDidChange = __dependency6__.propertyDidChange;
+ var computed = __dependency7__.computed;
+ var defineProperty = __dependency8__.defineProperty;
+ var Mixin = __dependency9__.Mixin;
+ var observer = __dependency9__.observer;
+ var fmt = __dependency10__.fmt;
+
+ function contentPropertyWillChange(content, contentKey) {
+ var key = contentKey.slice(8); // remove "content."
+ if (key in this) { return; } // if shadowed in proxy
+ propertyWillChange(this, key);
+ }
+
+ function contentPropertyDidChange(content, contentKey) {
+ var key = contentKey.slice(8); // remove "content."
+ if (key in this) { return; } // if shadowed in proxy
+ propertyDidChange(this, key);
+ }
+
+ /**
+ `Ember.ProxyMixin` forwards all properties not defined by the proxy itself
+ to a proxied `content` object. See Ember.ObjectProxy for more details.
+
+ @class ProxyMixin
+ @namespace Ember
+ */
+ __exports__["default"] = Mixin.create({
+ /**
+ The object whose properties will be forwarded.
+
+ @property content
+ @type Ember.Object
+ @default null
+ */
+ content: null,
+ _contentDidChange: observer('content', function() {
+ Ember.assert("Can't set Proxy's content to itself", get(this, 'content') !== this);
+ }),
+
+ isTruthy: computed.bool('content'),
+
+ _debugContainerKey: null,
+
+ willWatchProperty: function (key) {
+ var contentKey = 'content.' + key;
+ addBeforeObserver(this, contentKey, null, contentPropertyWillChange);
+ addObserver(this, contentKey, null, contentPropertyDidChange);
+ },
+
+ didUnwatchProperty: function (key) {
+ var contentKey = 'content.' + key;
+ removeBeforeObserver(this, contentKey, null, contentPropertyWillChange);
+ removeObserver(this, contentKey, null, contentPropertyDidChange);
+ },
+
+ unknownProperty: function (key) {
+ var content = get(this, 'content');
+ if (content) {
+ return get(content, key);
+ }
+ },
+
+ setUnknownProperty: function (key, value) {
+ var m = meta(this);
+ if (m.proto === this) {
+ // if marked as prototype then just defineProperty
+ // rather than delegate
+ defineProperty(this, key, null, value);
+ return value;
+ }
+
+ var content = get(this, 'content');
+ Ember.assert(fmt("Cannot delegate set('%@', %@) to the 'content' property of" +
+ " object proxy %@: its 'content' is undefined.", [key, value, this]), content);
+ return set(content, key, value);
+ }
+
+ });
+ });
+enifed("ember-runtime/mixins/action_handler",
+ ["ember-metal/merge","ember-metal/mixin","ember-metal/property_get","ember-metal/utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+ var merge = __dependency1__["default"];
+ var Mixin = __dependency2__.Mixin;
+ var get = __dependency3__.get;
+ var typeOf = __dependency4__.typeOf;
+
+ /**
+ The `Ember.ActionHandler` mixin implements support for moving an `actions`
+ property to an `_actions` property at extend time, and adding `_actions`
+ to the object's mergedProperties list.
+
+ `Ember.ActionHandler` is available on some familiar classes including
+ `Ember.Route`, `Ember.View`, `Ember.Component`, and controllers such as
+ `Ember.Controller` and `Ember.ObjectController`.
+ (Internally the mixin is used by `Ember.CoreView`, `Ember.ControllerMixin`,
+ and `Ember.Route` and available to the above classes through
+ inheritance.)
+
+ @class ActionHandler
+ @namespace Ember
+ */
+ var ActionHandler = Mixin.create({
+ mergedProperties: ['_actions'],
+
+ /**
+ The collection of functions, keyed by name, available on this
+ `ActionHandler` as action targets.
+
+ These functions will be invoked when a matching `{{action}}` is triggered
+ from within a template and the application's current route is this route.
+
+ Actions can also be invoked from other parts of your application
+ via `ActionHandler#send`.
+
+ The `actions` hash will inherit action handlers from
+ the `actions` hash defined on extended parent classes
+ or mixins rather than just replace the entire hash, e.g.:
+
+ ```js
+ App.CanDisplayBanner = Ember.Mixin.create({
+ actions: {
+ displayBanner: function(msg) {
+ // ...
+ }
+ }
+ });
+
+ App.WelcomeRoute = Ember.Route.extend(App.CanDisplayBanner, {
+ actions: {
+ playMusic: function() {
+ // ...
+ }
+ }
+ });
+
+ // `WelcomeRoute`, when active, will be able to respond
+ // to both actions, since the actions hash is merged rather
+ // then replaced when extending mixins / parent classes.
+ this.send('displayBanner');
+ this.send('playMusic');
+ ```
+
+ Within a Controller, Route, View or Component's action handler,
+ the value of the `this` context is the Controller, Route, View or
+ Component object:
+
+ ```js
+ App.SongRoute = Ember.Route.extend({
+ actions: {
+ myAction: function() {
+ this.controllerFor("song");
+ this.transitionTo("other.route");
+ ...
+ }
+ }
+ });
+ ```
+
+ It is also possible to call `this._super()` from within an
+ action handler if it overrides a handler defined on a parent
+ class or mixin:
+
+ Take for example the following routes:
+
+ ```js
+ App.DebugRoute = Ember.Mixin.create({
+ actions: {
+ debugRouteInformation: function() {
+ console.debug("trololo");
+ }
+ }
+ });
+
+ App.AnnoyingDebugRoute = Ember.Route.extend(App.DebugRoute, {
+ actions: {
+ debugRouteInformation: function() {
+ // also call the debugRouteInformation of mixed in App.DebugRoute
+ this._super();
+
+ // show additional annoyance
+ window.alert(...);
+ }
+ }
+ });
+ ```
+
+ ## Bubbling
+
+ By default, an action will stop bubbling once a handler defined
+ on the `actions` hash handles it. To continue bubbling the action,
+ you must return `true` from the handler:
+
+ ```js
+ App.Router.map(function() {
+ this.resource("album", function() {
+ this.route("song");
+ });
+ });
+
+ App.AlbumRoute = Ember.Route.extend({
+ actions: {
+ startPlaying: function() {
+ }
+ }
+ });
+
+ App.AlbumSongRoute = Ember.Route.extend({
+ actions: {
+ startPlaying: function() {
+ // ...
+
+ if (actionShouldAlsoBeTriggeredOnParentRoute) {
+ return true;
+ }
+ }
+ }
+ });
+ ```
+
+ @property actions
+ @type Hash
+ @default null
+ */
+
+ /**
+ Moves `actions` to `_actions` at extend time. Note that this currently
+ modifies the mixin themselves, which is technically dubious but
+ is practically of little consequence. This may change in the future.
+
+ @private
+ @method willMergeMixin
+ */
+ willMergeMixin: function(props) {
+ var hashName;
+
+ if (!props._actions) {
+ Ember.assert("'actions' should not be a function", typeof(props.actions) !== 'function');
+
+ if (typeOf(props.actions) === 'object') {
+ hashName = 'actions';
+ } else if (typeOf(props.events) === 'object') {
+ Ember.deprecate('Action handlers contained in an `events` object are deprecated in favor' +
+ ' of putting them in an `actions` object', false);
+ hashName = 'events';
+ }
+
+ if (hashName) {
+ props._actions = merge(props._actions || {}, props[hashName]);
+ }
+
+ delete props[hashName];
+ }
+ },
+
+ /**
+ Triggers a named action on the `ActionHandler`. Any parameters
+ supplied after the `actionName` string will be passed as arguments
+ to the action target function.
+
+ If the `ActionHandler` has its `target` property set, actions may
+ bubble to the `target`. Bubbling happens when an `actionName` can
+ not be found in the `ActionHandler`'s `actions` hash or if the
+ action target function returns `true`.
+
+ Example
+
+ ```js
+ App.WelcomeRoute = Ember.Route.extend({
+ actions: {
+ playTheme: function() {
+ this.send('playMusic', 'theme.mp3');
+ },
+ playMusic: function(track) {
+ // ...
+ }
+ }
+ });
+ ```
+
+ @method send
+ @param {String} actionName The action to trigger
+ @param {*} context a context to send with the action
+ */
+ send: function(actionName) {
+ var args = [].slice.call(arguments, 1);
+ var target;
+
+ if (this._actions && this._actions[actionName]) {
+ if (this._actions[actionName].apply(this, args) === true) {
+ // handler returned true, so this action will bubble
+ } else {
+ return;
+ }
+ }
+
+ if (target = get(this, 'target')) {
+ Ember.assert("The `target` for " + this + " (" + target +
+ ") does not have a `send` method", typeof target.send === 'function');
+ target.send.apply(target, arguments);
+ }
+ }
+ });
+
+ __exports__["default"] = ActionHandler;
+ });
+enifed("ember-runtime/mixins/array",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/computed","ember-metal/is_none","ember-runtime/mixins/enumerable","ember-metal/enumerable_utils","ember-metal/mixin","ember-metal/property_events","ember-metal/events","ember-metal/watching","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ // ..........................................................
+ // HELPERS
+ //
+ var Ember = __dependency1__["default"];
+ // ES6TODO: Ember.A
+
+ var get = __dependency2__.get;
+ var computed = __dependency3__.computed;
+ var cacheFor = __dependency3__.cacheFor;
+ var isNone = __dependency4__["default"];
+ var Enumerable = __dependency5__["default"];
+ var map = __dependency6__.map;
+ var Mixin = __dependency7__.Mixin;
+ var required = __dependency7__.required;
+ var propertyWillChange = __dependency8__.propertyWillChange;
+ var propertyDidChange = __dependency8__.propertyDidChange;
+ var addListener = __dependency9__.addListener;
+ var removeListener = __dependency9__.removeListener;
+ var sendEvent = __dependency9__.sendEvent;
+ var hasListeners = __dependency9__.hasListeners;
+ var isWatching = __dependency10__.isWatching;
+
+ function arrayObserversHelper(obj, target, opts, operation, notify) {
+ var willChange = (opts && opts.willChange) || 'arrayWillChange';
+ var didChange = (opts && opts.didChange) || 'arrayDidChange';
+ var hasObservers = get(obj, 'hasArrayObservers');
+
+ if (hasObservers === notify) {
+ propertyWillChange(obj, 'hasArrayObservers');
+ }
+
+ operation(obj, '@array:before', target, willChange);
+ operation(obj, '@array:change', target, didChange);
+
+ if (hasObservers === notify) {
+ propertyDidChange(obj, 'hasArrayObservers');
+ }
+
+ return obj;
+ }
+
+ // ..........................................................
+ // ARRAY
+ //
+ /**
+ This mixin implements Observer-friendly Array-like behavior. It is not a
+ concrete implementation, but it can be used up by other classes that want
+ to appear like arrays.
+
+ For example, ArrayProxy and ArrayController are both concrete classes that can
+ be instantiated to implement array-like behavior. Both of these classes use
+ the Array Mixin by way of the MutableArray mixin, which allows observable
+ changes to be made to the underlying array.
+
+ Unlike `Ember.Enumerable,` this mixin defines methods specifically for
+ collections that provide index-ordered access to their contents. When you
+ are designing code that needs to accept any kind of Array-like object, you
+ should use these methods instead of Array primitives because these will
+ properly notify observers of changes to the array.
+
+ Although these methods are efficient, they do add a layer of indirection to
+ your application so it is a good idea to use them only when you need the
+ flexibility of using both true JavaScript arrays and "virtual" arrays such
+ as controllers and collections.
+
+ You can use the methods defined in this module to access and modify array
+ contents in a KVO-friendly way. You can also be notified whenever the
+ membership of an array changes by using `.observes('myArray.[]')`.
+
+ To support `Ember.Array` in your own class, you must override two
+ primitives to use it: `replace()` and `objectAt()`.
+
+ Note that the Ember.Array mixin also incorporates the `Ember.Enumerable`
+ mixin. All `Ember.Array`-like objects are also enumerable.
+
+ @class Array
+ @namespace Ember
+ @uses Ember.Enumerable
+ @since Ember 0.9.0
+ */
+ __exports__["default"] = Mixin.create(Enumerable, {
+
+ /**
+ Your array must support the `length` property. Your replace methods should
+ set this property whenever it changes.
+
+ @property {Number} length
+ */
+ length: required(),
+
+ /**
+ Returns the object at the given `index`. If the given `index` is negative
+ or is greater or equal than the array length, returns `undefined`.
+
+ This is one of the primitives you must implement to support `Ember.Array`.
+ If your object supports retrieving the value of an array item using `get()`
+ (i.e. `myArray.get(0)`), then you do not need to implement this method
+ yourself.
+
+ ```javascript
+ var arr = ['a', 'b', 'c', 'd'];
+
+ arr.objectAt(0); // 'a'
+ arr.objectAt(3); // 'd'
+ arr.objectAt(-1); // undefined
+ arr.objectAt(4); // undefined
+ arr.objectAt(5); // undefined
+ ```
+
+ @method objectAt
+ @param {Number} idx The index of the item to return.
+ @return {*} item at index or undefined
+ */
+ objectAt: function(idx) {
+ if (idx < 0 || idx >= get(this, 'length')) {
+ return undefined;
+ }
+
+ return get(this, idx);
+ },
+
+ /**
+ This returns the objects at the specified indexes, using `objectAt`.
+
+ ```javascript
+ var arr =Â ['a', 'b', 'c', 'd'];
+
+ arr.objectsAt([0, 1, 2]); // ['a', 'b', 'c']
+ arr.objectsAt([2, 3, 4]); // ['c', 'd', undefined]
+ ```
+
+ @method objectsAt
+ @param {Array} indexes An array of indexes of items to return.
+ @return {Array}
+ */
+ objectsAt: function(indexes) {
+ var self = this;
+
+ return map(indexes, function(idx) {
+ return self.objectAt(idx);
+ });
+ },
+
+ // overrides Ember.Enumerable version
+ nextObject: function(idx) {
+ return this.objectAt(idx);
+ },
+
+ /**
+ This is the handler for the special array content property. If you get
+ this property, it will return this. If you set this property to a new
+ array, it will replace the current content.
+
+ This property overrides the default property defined in `Ember.Enumerable`.
+
+ @property []
+ @return this
+ */
+ '[]': computed(function(key, value) {
+ if (value !== undefined) {
+ this.replace(0, get(this, 'length'), value);
+ }
+
+ return this;
+ }),
+
+ firstObject: computed(function() {
+ return this.objectAt(0);
+ }),
+
+ lastObject: computed(function() {
+ return this.objectAt(get(this, 'length') - 1);
+ }),
+
+ // optimized version from Enumerable
+ contains: function(obj) {
+ return this.indexOf(obj) >= 0;
+ },
+
+ // Add any extra methods to Ember.Array that are native to the built-in Array.
+ /**
+ Returns a new array that is a slice of the receiver. This implementation
+ uses the observable array methods to retrieve the objects for the new
+ slice.
+
+ ```javascript
+ var arr = ['red', 'green', 'blue'];
+
+ arr.slice(0); // ['red', 'green', 'blue']
+ arr.slice(0, 2); // ['red', 'green']
+ arr.slice(1, 100); // ['green', 'blue']
+ ```
+
+ @method slice
+ @param {Integer} beginIndex (Optional) index to begin slicing from.
+ @param {Integer} endIndex (Optional) index to end the slice at (but not included).
+ @return {Array} New array with specified slice
+ */
+ slice: function(beginIndex, endIndex) {
+ var ret = Ember.A();
+ var length = get(this, 'length');
+
+ if (isNone(beginIndex)) {
+ beginIndex = 0;
+ }
+
+ if (isNone(endIndex) || (endIndex > length)) {
+ endIndex = length;
+ }
+
+ if (beginIndex < 0) {
+ beginIndex = length + beginIndex;
+ }
+
+ if (endIndex < 0) {
+ endIndex = length + endIndex;
+ }
+
+ while (beginIndex < endIndex) {
+ ret[ret.length] = this.objectAt(beginIndex++);
+ }
+
+ return ret;
+ },
+
+ /**
+ Returns the index of the given object's first occurrence.
+ If no `startAt` argument is given, the starting location to
+ search is 0. If it's negative, will count backward from
+ the end of the array. Returns -1 if no match is found.
+
+ ```javascript
+ var arr = ['a', 'b', 'c', 'd', 'a'];
+
+ arr.indexOf('a'); // 0
+ arr.indexOf('z'); // -1
+ arr.indexOf('a', 2); // 4
+ arr.indexOf('a', -1); // 4
+ arr.indexOf('b', 3); // -1
+ arr.indexOf('a', 100); // -1
+ ```
+
+ @method indexOf
+ @param {Object} object the item to search for
+ @param {Number} startAt optional starting location to search, default 0
+ @return {Number} index or -1 if not found
+ */
+ indexOf: function(object, startAt) {
+ var len = get(this, 'length');
+ var idx;
+
+ if (startAt === undefined) {
+ startAt = 0;
+ }
+
+ if (startAt < 0) {
+ startAt += len;
+ }
+
+ for (idx = startAt; idx < len; idx++) {
+ if (this.objectAt(idx) === object) {
+ return idx;
+ }
+ }
+
+ return -1;
+ },
+
+ /**
+ Returns the index of the given object's last occurrence.
+ If no `startAt` argument is given, the search starts from
+ the last position. If it's negative, will count backward
+ from the end of the array. Returns -1 if no match is found.
+
+ ```javascript
+ var arr = ['a', 'b', 'c', 'd', 'a'];
+
+ arr.lastIndexOf('a'); // 4
+ arr.lastIndexOf('z'); // -1
+ arr.lastIndexOf('a', 2); // 0
+ arr.lastIndexOf('a', -1); // 4
+ arr.lastIndexOf('b', 3); // 1
+ arr.lastIndexOf('a', 100); // 4
+ ```
+
+ @method lastIndexOf
+ @param {Object} object the item to search for
+ @param {Number} startAt optional starting location to search, default 0
+ @return {Number} index or -1 if not found
+ */
+ lastIndexOf: function(object, startAt) {
+ var len = get(this, 'length');
+ var idx;
+
+ if (startAt === undefined || startAt >= len) {
+ startAt = len-1;
+ }
+
+ if (startAt < 0) {
+ startAt += len;
+ }
+
+ for (idx = startAt; idx >= 0; idx--) {
+ if (this.objectAt(idx) === object) {
+ return idx;
+ }
+ }
+
+ return -1;
+ },
+
+ // ..........................................................
+ // ARRAY OBSERVERS
+ //
+
+ /**
+ Adds an array observer to the receiving array. The array observer object
+ normally must implement two methods:
+
+ * `arrayWillChange(observedObj, start, removeCount, addCount)` - This method will be
+ called just before the array is modified.
+ * `arrayDidChange(observedObj, start, removeCount, addCount)` - This method will be
+ called just after the array is modified.
+
+ Both callbacks will be passed the observed object, starting index of the
+ change as well a a count of the items to be removed and added. You can use
+ these callbacks to optionally inspect the array during the change, clear
+ caches, or do any other bookkeeping necessary.
+
+ In addition to passing a target, you can also include an options hash
+ which you can use to override the method names that will be invoked on the
+ target.
+
+ @method addArrayObserver
+ @param {Object} target The observer object.
+ @param {Hash} opts Optional hash of configuration options including
+ `willChange` and `didChange` option.
+ @return {Ember.Array} receiver
+ */
+
+ addArrayObserver: function(target, opts) {
+ return arrayObserversHelper(this, target, opts, addListener, false);
+ },
+
+ /**
+ Removes an array observer from the object if the observer is current
+ registered. Calling this method multiple times with the same object will
+ have no effect.
+
+ @method removeArrayObserver
+ @param {Object} target The object observing the array.
+ @param {Hash} opts Optional hash of configuration options including
+ `willChange` and `didChange` option.
+ @return {Ember.Array} receiver
+ */
+ removeArrayObserver: function(target, opts) {
+ return arrayObserversHelper(this, target, opts, removeListener, true);
+ },
+
+ /**
+ Becomes true whenever the array currently has observers watching changes
+ on the array.
+
+ @property {Boolean} hasArrayObservers
+ */
+ hasArrayObservers: computed(function() {
+ return hasListeners(this, '@array:change') || hasListeners(this, '@array:before');
+ }),
+
+ /**
+ If you are implementing an object that supports `Ember.Array`, call this
+ method just before the array content changes to notify any observers and
+ invalidate any related properties. Pass the starting index of the change
+ as well as a delta of the amounts to change.
+
+ @method arrayContentWillChange
+ @param {Number} startIdx The starting index in the array that will change.
+ @param {Number} removeAmt The number of items that will be removed. If you
+ pass `null` assumes 0
+ @param {Number} addAmt The number of items that will be added. If you
+ pass `null` assumes 0.
+ @return {Ember.Array} receiver
+ */
+ arrayContentWillChange: function(startIdx, removeAmt, addAmt) {
+ var removing, lim;
+
+ // if no args are passed assume everything changes
+ if (startIdx === undefined) {
+ startIdx = 0;
+ removeAmt = addAmt = -1;
+ } else {
+ if (removeAmt === undefined) {
+ removeAmt = -1;
+ }
+
+ if (addAmt === undefined) {
+ addAmt = -1;
+ }
+ }
+
+ // Make sure the @each proxy is set up if anyone is observing @each
+ if (isWatching(this, '@each')) {
+ get(this, '@each');
+ }
+
+ sendEvent(this, '@array:before', [this, startIdx, removeAmt, addAmt]);
+
+ if (startIdx >= 0 && removeAmt >= 0 && get(this, 'hasEnumerableObservers')) {
+ removing = [];
+ lim = startIdx + removeAmt;
+
+ for (var idx = startIdx; idx < lim; idx++) {
+ removing.push(this.objectAt(idx));
+ }
+ } else {
+ removing = removeAmt;
+ }
+
+ this.enumerableContentWillChange(removing, addAmt);
+
+ return this;
+ },
+
+ /**
+ If you are implementing an object that supports `Ember.Array`, call this
+ method just after the array content changes to notify any observers and
+ invalidate any related properties. Pass the starting index of the change
+ as well as a delta of the amounts to change.
+
+ @method arrayContentDidChange
+ @param {Number} startIdx The starting index in the array that did change.
+ @param {Number} removeAmt The number of items that were removed. If you
+ pass `null` assumes 0
+ @param {Number} addAmt The number of items that were added. If you
+ pass `null` assumes 0.
+ @return {Ember.Array} receiver
+ */
+ arrayContentDidChange: function(startIdx, removeAmt, addAmt) {
+ var adding, lim;
+
+ // if no args are passed assume everything changes
+ if (startIdx === undefined) {
+ startIdx = 0;
+ removeAmt = addAmt = -1;
+ } else {
+ if (removeAmt === undefined) {
+ removeAmt = -1;
+ }
+
+ if (addAmt === undefined) {
+ addAmt = -1;
+ }
+ }
+
+ if (startIdx >= 0 && addAmt >= 0 && get(this, 'hasEnumerableObservers')) {
+ adding = [];
+ lim = startIdx + addAmt;
+
+ for (var idx = startIdx; idx < lim; idx++) {
+ adding.push(this.objectAt(idx));
+ }
+ } else {
+ adding = addAmt;
+ }
+
+ this.enumerableContentDidChange(removeAmt, adding);
+ sendEvent(this, '@array:change', [this, startIdx, removeAmt, addAmt]);
+
+ var length = get(this, 'length');
+ var cachedFirst = cacheFor(this, 'firstObject');
+ var cachedLast = cacheFor(this, 'lastObject');
+
+ if (this.objectAt(0) !== cachedFirst) {
+ propertyWillChange(this, 'firstObject');
+ propertyDidChange(this, 'firstObject');
+ }
+
+ if (this.objectAt(length-1) !== cachedLast) {
+ propertyWillChange(this, 'lastObject');
+ propertyDidChange(this, 'lastObject');
+ }
+
+ return this;
+ },
+
+ // ..........................................................
+ // ENUMERATED PROPERTIES
+ //
+
+ /**
+ Returns a special object that can be used to observe individual properties
+ on the array. Just get an equivalent property on this object and it will
+ return an enumerable that maps automatically to the named key on the
+ member objects.
+
+ If you merely want to watch for any items being added or removed to the array,
+ use the `[]` property instead of `@each`.
+
+ @property @each
+ */
+ '@each': computed(function() {
+ if (!this.__each) {
+ // ES6TODO: GRRRRR
+ var EachProxy = requireModule('ember-runtime/system/each_proxy')['EachProxy'];
+
+ this.__each = new EachProxy(this);
+ }
+
+ return this.__each;
+ })
+ });
+ });
+enifed("ember-runtime/mixins/comparable",
+ ["ember-metal/mixin","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var Mixin = __dependency1__.Mixin;
+ var required = __dependency1__.required;
+
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ /**
+ Implements some standard methods for comparing objects. Add this mixin to
+ any class you create that can compare its instances.
+
+ You should implement the `compare()` method.
+
+ @class Comparable
+ @namespace Ember
+ @since Ember 0.9
+ */
+ __exports__["default"] = Mixin.create({
+
+ /**
+ Override to return the result of the comparison of the two parameters. The
+ compare method should return:
+
+ - `-1` if `a < b`
+ - `0` if `a == b`
+ - `1` if `a > b`
+
+ Default implementation raises an exception.
+
+ @method compare
+ @param a {Object} the first object to compare
+ @param b {Object} the second object to compare
+ @return {Integer} the result of the comparison
+ */
+ compare: required(Function)
+ });
+ });
+enifed("ember-runtime/mixins/controller",
+ ["ember-metal/mixin","ember-metal/computed","ember-runtime/mixins/action_handler","ember-runtime/mixins/controller_content_model_alias_deprecation","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ var Mixin = __dependency1__.Mixin;
+ var computed = __dependency2__.computed;
+ var ActionHandler = __dependency3__["default"];
+ var ControllerContentModelAliasDeprecation = __dependency4__["default"];
+
+ /**
+ `Ember.ControllerMixin` provides a standard interface for all classes that
+ compose Ember's controller layer: `Ember.Controller`,
+ `Ember.ArrayController`, and `Ember.ObjectController`.
+
+ @class ControllerMixin
+ @namespace Ember
+ @uses Ember.ActionHandler
+ */
+ __exports__["default"] = Mixin.create(ActionHandler, ControllerContentModelAliasDeprecation, {
+ /* ducktype as a controller */
+ isController: true,
+
+ /**
+ The object to which actions from the view should be sent.
+
+ For example, when a Handlebars template uses the `{{action}}` helper,
+ it will attempt to send the action to the view's controller's `target`.
+
+ By default, the value of the target property is set to the router, and
+ is injected when a controller is instantiated. This injection is defined
+ in Ember.Application#buildContainer, and is applied as part of the
+ applications initialization process. It can also be set after a controller
+ has been instantiated, for instance when using the render helper in a
+ template, or when a controller is used as an `itemController`. In most
+ cases the `target` property will automatically be set to the logical
+ consumer of actions for the controller.
+
+ @property target
+ @default null
+ */
+ target: null,
+
+ container: null,
+
+ parentController: null,
+
+ store: null,
+
+ /**
+ The controller's current model. When retrieving or modifying a controller's
+ model, this property should be used instead of the `content` property.
+
+ @property model
+ @public
+ */
+ model: null,
+
+ /**
+ @private
+ */
+ content: computed.alias('model')
+
+ });
+ });
+enifed("ember-runtime/mixins/controller_content_model_alias_deprecation",
+ ["ember-metal/core","ember-metal/mixin","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // Ember.deprecate
+ var Mixin = __dependency2__.Mixin;
+
+ /**
+ The ControllerContentModelAliasDeprecation mixin is used to provide a useful
+ deprecation warning when specifying `content` directly on a `Ember.Controller`
+ (without also specifying `model`).
+
+ Ember versions prior to 1.7 used `model` as an alias of `content`, but due to
+ much confusion this alias was reversed (so `content` is now an alias of `model).
+
+ This change reduces many caveats with model/content, and also sets a
+ simple ground rule: Never set a controllers content, rather always set
+ its model and ember will do the right thing.
+
+
+ `Ember.ControllerContentModelAliasDeprecation` is used internally by Ember in
+ `Ember.Controller`.
+
+ @class ControllerContentModelAliasDeprecation
+ @namespace Ember
+ @private
+ @since 1.7.0
+ */
+ __exports__["default"] = Mixin.create({
+ /**
+ @private
+
+ Moves `content` to `model` at extend time if a `model` is not also specified.
+
+ Note that this currently modifies the mixin themselves, which is technically
+ dubious but is practically of little consequence. This may change in the
+ future.
+
+ @method willMergeMixin
+ @since 1.4.0
+ */
+ willMergeMixin: function(props) {
+ // Calling super is only OK here since we KNOW that
+ // there is another Mixin loaded first.
+ this._super.apply(this, arguments);
+
+ var modelSpecified = !!props.model;
+
+ if (props.content && !modelSpecified) {
+ props.model = props.content;
+ delete props['content'];
+
+ Ember.deprecate('Do not specify `content` on a Controller, use `model` instead.', false);
+ }
+ }
+ });
+ });
+enifed("ember-runtime/mixins/copyable",
+ ["ember-metal/property_get","ember-metal/mixin","ember-runtime/mixins/freezable","ember-runtime/system/string","ember-metal/error","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+
+ var get = __dependency1__.get;
+ var required = __dependency2__.required;
+ var Freezable = __dependency3__.Freezable;
+ var Mixin = __dependency2__.Mixin;
+ var fmt = __dependency4__.fmt;
+ var EmberError = __dependency5__["default"];
+
+
+ /**
+ Implements some standard methods for copying an object. Add this mixin to
+ any object you create that can create a copy of itself. This mixin is
+ added automatically to the built-in array.
+
+ You should generally implement the `copy()` method to return a copy of the
+ receiver.
+
+ Note that `frozenCopy()` will only work if you also implement
+ `Ember.Freezable`.
+
+ @class Copyable
+ @namespace Ember
+ @since Ember 0.9
+ */
+ __exports__["default"] = Mixin.create({
+ /**
+ Override to return a copy of the receiver. Default implementation raises
+ an exception.
+
+ @method copy
+ @param {Boolean} deep if `true`, a deep copy of the object should be made
+ @return {Object} copy of receiver
+ */
+ copy: required(Function),
+
+ /**
+ If the object implements `Ember.Freezable`, then this will return a new
+ copy if the object is not frozen and the receiver if the object is frozen.
+
+ Raises an exception if you try to call this method on a object that does
+ not support freezing.
+
+ You should use this method whenever you want a copy of a freezable object
+ since a freezable object can simply return itself without actually
+ consuming more memory.
+
+ @method frozenCopy
+ @return {Object} copy of receiver or receiver
+ */
+ frozenCopy: function() {
+ if (Freezable && Freezable.detect(this)) {
+ return get(this, 'isFrozen') ? this : this.copy().freeze();
+ } else {
+ throw new EmberError(fmt("%@ does not support freezing", [this]));
+ }
+ }
+ });
+ });
+enifed("ember-runtime/mixins/deferred",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/mixin","ember-metal/computed","ember-runtime/ext/rsvp","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // Ember.FEATURES, Ember.Test
+ var get = __dependency2__.get;
+ var Mixin = __dependency3__.Mixin;
+ var computed = __dependency4__.computed;
+ var RSVP = __dependency5__["default"];
+
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+
+ /**
+ @class Deferred
+ @namespace Ember
+ */
+ __exports__["default"] = Mixin.create({
+ /**
+ Add handlers to be called when the Deferred object is resolved or rejected.
+
+ @method then
+ @param {Function} resolve a callback function to be called when done
+ @param {Function} reject a callback function to be called when failed
+ */
+ then: function(resolve, reject, label) {
+ var deferred, promise, entity;
+
+ entity = this;
+ deferred = get(this, '_deferred');
+ promise = deferred.promise;
+
+ function fulfillmentHandler(fulfillment) {
+ if (fulfillment === promise) {
+ return resolve(entity);
+ } else {
+ return resolve(fulfillment);
+ }
+ }
+
+ return promise.then(resolve && fulfillmentHandler, reject, label);
+ },
+
+ /**
+ Resolve a Deferred object and call any `doneCallbacks` with the given args.
+
+ @method resolve
+ */
+ resolve: function(value) {
+ var deferred, promise;
+
+ deferred = get(this, '_deferred');
+ promise = deferred.promise;
+
+ if (value === this) {
+ deferred.resolve(promise);
+ } else {
+ deferred.resolve(value);
+ }
+ },
+
+ /**
+ Reject a Deferred object and call any `failCallbacks` with the given args.
+
+ @method reject
+ */
+ reject: function(value) {
+ get(this, '_deferred').reject(value);
+ },
+
+ _deferred: computed(function() {
+ Ember.deprecate('Usage of Ember.DeferredMixin or Ember.Deferred is deprecated.', this._suppressDeferredDeprecation, { url: 'http://emberjs.com/guides/deprecations/#toc_deprecate-ember-deferredmixin-and-ember-deferred' });
+
+ return RSVP.defer('Ember: DeferredMixin - ' + this);
+ })
+ });
+ });
+enifed("ember-runtime/mixins/enumerable",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/mixin","ember-metal/enumerable_utils","ember-metal/computed","ember-metal/property_events","ember-metal/events","ember-runtime/compare","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ // ..........................................................
+ // HELPERS
+ //
+
+ var Ember = __dependency1__["default"];
+ var get = __dependency2__.get;
+ var set = __dependency3__.set;
+ var apply = __dependency4__.apply;
+ var Mixin = __dependency5__.Mixin;
+ var required = __dependency5__.required;
+ var aliasMethod = __dependency5__.aliasMethod;
+ var indexOf = __dependency6__.indexOf;
+ var computed = __dependency7__.computed;
+ var propertyWillChange = __dependency8__.propertyWillChange;
+ var propertyDidChange = __dependency8__.propertyDidChange;
+ var addListener = __dependency9__.addListener;
+ var removeListener = __dependency9__.removeListener;
+ var sendEvent = __dependency9__.sendEvent;
+ var hasListeners = __dependency9__.hasListeners;
+ var compare = __dependency10__["default"];
+
+ var a_slice = Array.prototype.slice;
+
+ var contexts = [];
+
+ function popCtx() {
+ return contexts.length === 0 ? {} : contexts.pop();
+ }
+
+ function pushCtx(ctx) {
+ contexts.push(ctx);
+ return null;
+ }
+
+ function iter(key, value) {
+ var valueProvided = arguments.length === 2;
+
+ function i(item) {
+ var cur = get(item, key);
+ return valueProvided ? value === cur : !!cur;
+ }
+
+ return i;
+ }
+
+ /**
+ This mixin defines the common interface implemented by enumerable objects
+ in Ember. Most of these methods follow the standard Array iteration
+ API defined up to JavaScript 1.8 (excluding language-specific features that
+ cannot be emulated in older versions of JavaScript).
+
+ This mixin is applied automatically to the Array class on page load, so you
+ can use any of these methods on simple arrays. If Array already implements
+ one of these methods, the mixin will not override them.
+
+ ## Writing Your Own Enumerable
+
+ To make your own custom class enumerable, you need two items:
+
+ 1. You must have a length property. This property should change whenever
+ the number of items in your enumerable object changes. If you use this
+ with an `Ember.Object` subclass, you should be sure to change the length
+ property using `set().`
+
+ 2. You must implement `nextObject().` See documentation.
+
+ Once you have these two methods implemented, apply the `Ember.Enumerable` mixin
+ to your class and you will be able to enumerate the contents of your object
+ like any other collection.
+
+ ## Using Ember Enumeration with Other Libraries
+
+ Many other libraries provide some kind of iterator or enumeration like
+ facility. This is often where the most common API conflicts occur.
+ Ember's API is designed to be as friendly as possible with other
+ libraries by implementing only methods that mostly correspond to the
+ JavaScript 1.8 API.
+
+ @class Enumerable
+ @namespace Ember
+ @since Ember 0.9
+ */
+ __exports__["default"] = Mixin.create({
+
+ /**
+ Implement this method to make your class enumerable.
+
+ This method will be call repeatedly during enumeration. The index value
+ will always begin with 0 and increment monotonically. You don't have to
+ rely on the index value to determine what object to return, but you should
+ always check the value and start from the beginning when you see the
+ requested index is 0.
+
+ The `previousObject` is the object that was returned from the last call
+ to `nextObject` for the current iteration. This is a useful way to
+ manage iteration if you are tracing a linked list, for example.
+
+ Finally the context parameter will always contain a hash you can use as
+ a "scratchpad" to maintain any other state you need in order to iterate
+ properly. The context object is reused and is not reset between
+ iterations so make sure you setup the context with a fresh state whenever
+ the index parameter is 0.
+
+ Generally iterators will continue to call `nextObject` until the index
+ reaches the your current length-1. If you run out of data before this
+ time for some reason, you should simply return undefined.
+
+ The default implementation of this method simply looks up the index.
+ This works great on any Array-like objects.
+
+ @method nextObject
+ @param {Number} index the current index of the iteration
+ @param {Object} previousObject the value returned by the last call to
+ `nextObject`.
+ @param {Object} context a context object you can use to maintain state.
+ @return {Object} the next object in the iteration or undefined
+ */
+ nextObject: required(Function),
+
+ /**
+ Helper method returns the first object from a collection. This is usually
+ used by bindings and other parts of the framework to extract a single
+ object if the enumerable contains only one item.
+
+ If you override this method, you should implement it so that it will
+ always return the same value each time it is called. If your enumerable
+ contains only one object, this method should always return that object.
+ If your enumerable is empty, this method should return `undefined`.
+
+ ```javascript
+ var arr = ['a', 'b', 'c'];
+ arr.get('firstObject'); // 'a'
+
+ var arr = [];
+ arr.get('firstObject'); // undefined
+ ```
+
+ @property firstObject
+ @return {Object} the object or undefined
+ */
+ firstObject: computed('[]', function() {
+ if (get(this, 'length') === 0) {
+ return undefined;
+ }
+
+ // handle generic enumerables
+ var context = popCtx();
+ var ret = this.nextObject(0, null, context);
+
+ pushCtx(context);
+
+ return ret;
+ }),
+
+ /**
+ Helper method returns the last object from a collection. If your enumerable
+ contains only one object, this method should always return that object.
+ If your enumerable is empty, this method should return `undefined`.
+
+ ```javascript
+ var arr = ['a', 'b', 'c'];
+ arr.get('lastObject'); // 'c'
+
+ var arr = [];
+ arr.get('lastObject'); // undefined
+ ```
+
+ @property lastObject
+ @return {Object} the last object or undefined
+ */
+ lastObject: computed('[]', function() {
+ var len = get(this, 'length');
+
+ if (len === 0) {
+ return undefined;
+ }
+
+ var context = popCtx();
+ var idx = 0;
+ var last = null;
+ var cur;
+
+ do {
+ last = cur;
+ cur = this.nextObject(idx++, last, context);
+ } while (cur !== undefined);
+
+ pushCtx(context);
+
+ return last;
+ }),
+
+ /**
+ Returns `true` if the passed object can be found in the receiver. The
+ default version will iterate through the enumerable until the object
+ is found. You may want to override this with a more efficient version.
+
+ ```javascript
+ var arr = ['a', 'b', 'c'];
+
+ arr.contains('a'); // true
+ arr.contains('z'); // false
+ ```
+
+ @method contains
+ @param {Object} obj The object to search for.
+ @return {Boolean} `true` if object is found in enumerable.
+ */
+ contains: function(obj) {
+ var found = this.find(function(item) {
+ return item === obj;
+ });
+
+ return found !== undefined;
+ },
+
+ /**
+ Iterates through the enumerable, calling the passed function on each
+ item. This method corresponds to the `forEach()` method defined in
+ JavaScript 1.6.
+
+ The callback method you provide should have the following signature (all
+ parameters are optional):
+
+ ```javascript
+ function(item, index, enumerable);
+ ```
+
+ - `item` is the current item in the iteration.
+ - `index` is the current index in the iteration.
+ - `enumerable` is the enumerable object itself.
+
+ Note that in addition to a callback, you can also pass an optional target
+ object that will be set as `this` on the context. This is a good way
+ to give your iterator function access to the current object.
+
+ @method forEach
+ @param {Function} callback The callback to execute
+ @param {Object} [target] The target object to use
+ @return {Object} receiver
+ */
+ forEach: function(callback, target) {
+ if (typeof callback !== 'function') {
+ throw new TypeError();
+ }
+
+ var context = popCtx();
+ var len = get(this, 'length');
+ var last = null;
+
+ if (target === undefined) {
+ target = null;
+ }
+
+ for(var idx = 0; idx < len; idx++) {
+ var next = this.nextObject(idx, last, context) ;
+ callback.call(target, next, idx, this);
+ last = next ;
+ }
+
+ last = null ;
+ context = pushCtx(context);
+
+ return this ;
+ },
+
+ /**
+ Alias for `mapBy`
+
+ @method getEach
+ @param {String} key name of the property
+ @return {Array} The mapped array.
+ */
+ getEach: function(key) {
+ return this.mapBy(key);
+ },
+
+ /**
+ Sets the value on the named property for each member. This is more
+ efficient than using other methods defined on this helper. If the object
+ implements Ember.Observable, the value will be changed to `set(),` otherwise
+ it will be set directly. `null` objects are skipped.
+
+ @method setEach
+ @param {String} key The key to set
+ @param {Object} value The object to set
+ @return {Object} receiver
+ */
+ setEach: function(key, value) {
+ return this.forEach(function(item) {
+ set(item, key, value);
+ });
+ },
+
+ /**
+ Maps all of the items in the enumeration to another value, returning
+ a new array. This method corresponds to `map()` defined in JavaScript 1.6.
+
+ The callback method you provide should have the following signature (all
+ parameters are optional):
+
+ ```javascript
+ function(item, index, enumerable);
+ ```
+
+ - `item` is the current item in the iteration.
+ - `index` is the current index in the iteration.
+ - `enumerable` is the enumerable object itself.
+
+ It should return the mapped value.
+
+ Note that in addition to a callback, you can also pass an optional target
+ object that will be set as `this` on the context. This is a good way
+ to give your iterator function access to the current object.
+
+ @method map
+ @param {Function} callback The callback to execute
+ @param {Object} [target] The target object to use
+ @return {Array} The mapped array.
+ */
+ map: function(callback, target) {
+ var ret = Ember.A();
+
+ this.forEach(function(x, idx, i) {
+ ret[idx] = callback.call(target, x, idx,i);
+ });
+
+ return ret ;
+ },
+
+ /**
+ Similar to map, this specialized function returns the value of the named
+ property on all items in the enumeration.
+
+ @method mapBy
+ @param {String} key name of the property
+ @return {Array} The mapped array.
+ */
+ mapBy: function(key) {
+ return this.map(function(next) {
+ return get(next, key);
+ });
+ },
+
+ /**
+ Similar to map, this specialized function returns the value of the named
+ property on all items in the enumeration.
+
+ @method mapProperty
+ @param {String} key name of the property
+ @return {Array} The mapped array.
+ @deprecated Use `mapBy` instead
+ */
+
+ mapProperty: aliasMethod('mapBy'),
+
+ /**
+ Returns an array with all of the items in the enumeration that the passed
+ function returns true for. This method corresponds to `filter()` defined in
+ JavaScript 1.6.
+
+ The callback method you provide should have the following signature (all
+ parameters are optional):
+
+ ```javascript
+ function(item, index, enumerable);
+ ```
+
+ - `item` is the current item in the iteration.
+ - `index` is the current index in the iteration.
+ - `enumerable` is the enumerable object itself.
+
+ It should return `true` to include the item in the results, `false`
+ otherwise.
+
+ Note that in addition to a callback, you can also pass an optional target
+ object that will be set as `this` on the context. This is a good way
+ to give your iterator function access to the current object.
+
+ @method filter
+ @param {Function} callback The callback to execute
+ @param {Object} [target] The target object to use
+ @return {Array} A filtered array.
+ */
+ filter: function(callback, target) {
+ var ret = Ember.A();
+
+ this.forEach(function(x, idx, i) {
+ if (callback.call(target, x, idx, i)) {
+ ret.push(x);
+ }
+ });
+
+ return ret ;
+ },
+
+ /**
+ Returns an array with all of the items in the enumeration where the passed
+ function returns false for. This method is the inverse of filter().
+
+ The callback method you provide should have the following signature (all
+ parameters are optional):
+
+ ```javascript
+ function(item, index, enumerable);
+ ```
+
+ - *item* is the current item in the iteration.
+ - *index* is the current index in the iteration
+ - *enumerable* is the enumerable object itself.
+
+ It should return the a falsey value to include the item in the results.
+
+ Note that in addition to a callback, you can also pass an optional target
+ object that will be set as "this" on the context. This is a good way
+ to give your iterator function access to the current object.
+
+ @method reject
+ @param {Function} callback The callback to execute
+ @param {Object} [target] The target object to use
+ @return {Array} A rejected array.
+ */
+ reject: function(callback, target) {
+ return this.filter(function() {
+ return !(apply(target, callback, arguments));
+ });
+ },
+
+ /**
+ Returns an array with just the items with the matched property. You
+ can pass an optional second argument with the target value. Otherwise
+ this will match any property that evaluates to `true`.
+
+ @method filterBy
+ @param {String} key the property to test
+ @param {*} [value] optional value to test against.
+ @return {Array} filtered array
+ */
+ filterBy: function(key, value) {
+ return this.filter(apply(this, iter, arguments));
+ },
+
+ /**
+ Returns an array with just the items with the matched property. You
+ can pass an optional second argument with the target value. Otherwise
+ this will match any property that evaluates to `true`.
+
+ @method filterProperty
+ @param {String} key the property to test
+ @param {String} [value] optional value to test against.
+ @return {Array} filtered array
+ @deprecated Use `filterBy` instead
+ */
+ filterProperty: aliasMethod('filterBy'),
+
+ /**
+ Returns an array with the items that do not have truthy values for
+ key. You can pass an optional second argument with the target value. Otherwise
+ this will match any property that evaluates to false.
+
+ @method rejectBy
+ @param {String} key the property to test
+ @param {String} [value] optional value to test against.
+ @return {Array} rejected array
+ */
+ rejectBy: function(key, value) {
+ var exactValue = function(item) {
+ return get(item, key) === value;
+ };
+
+ var hasValue = function(item) {
+ return !!get(item, key);
+ };
+
+ var use = (arguments.length === 2 ? exactValue : hasValue);
+
+ return this.reject(use);
+ },
+
+ /**
+ Returns an array with the items that do not have truthy values for
+ key. You can pass an optional second argument with the target value. Otherwise
+ this will match any property that evaluates to false.
+
+ @method rejectProperty
+ @param {String} key the property to test
+ @param {String} [value] optional value to test against.
+ @return {Array} rejected array
+ @deprecated Use `rejectBy` instead
+ */
+ rejectProperty: aliasMethod('rejectBy'),
+
+ /**
+ Returns the first item in the array for which the callback returns true.
+ This method works similar to the `filter()` method defined in JavaScript 1.6
+ except that it will stop working on the array once a match is found.
+
+ The callback method you provide should have the following signature (all
+ parameters are optional):
+
+ ```javascript
+ function(item, index, enumerable);
+ ```
+
+ - `item` is the current item in the iteration.
+ - `index` is the current index in the iteration.
+ - `enumerable` is the enumerable object itself.
+
+ It should return the `true` to include the item in the results, `false`
+ otherwise.
+
+ Note that in addition to a callback, you can also pass an optional target
+ object that will be set as `this` on the context. This is a good way
+ to give your iterator function access to the current object.
+
+ @method find
+ @param {Function} callback The callback to execute
+ @param {Object} [target] The target object to use
+ @return {Object} Found item or `undefined`.
+ */
+ find: function(callback, target) {
+ var len = get(this, 'length');
+
+ if (target === undefined) {
+ target = null;
+ }
+
+ var context = popCtx();
+ var found = false;
+ var last = null;
+ var next, ret;
+
+ for(var idx = 0; idx < len && !found; idx++) {
+ next = this.nextObject(idx, last, context);
+
+ if (found = callback.call(target, next, idx, this)) {
+ ret = next;
+ }
+
+ last = next;
+ }
+
+ next = last = null;
+ context = pushCtx(context);
+
+ return ret;
+ },
+
+ /**
+ Returns the first item with a property matching the passed value. You
+ can pass an optional second argument with the target value. Otherwise
+ this will match any property that evaluates to `true`.
+
+ This method works much like the more generic `find()` method.
+
+ @method findBy
+ @param {String} key the property to test
+ @param {String} [value] optional value to test against.
+ @return {Object} found item or `undefined`
+ */
+ findBy: function(key, value) {
+ return this.find(apply(this, iter, arguments));
+ },
+
+ /**
+ Returns the first item with a property matching the passed value. You
+ can pass an optional second argument with the target value. Otherwise
+ this will match any property that evaluates to `true`.
+
+ This method works much like the more generic `find()` method.
+
+ @method findProperty
+ @param {String} key the property to test
+ @param {String} [value] optional value to test against.
+ @return {Object} found item or `undefined`
+ @deprecated Use `findBy` instead
+ */
+ findProperty: aliasMethod('findBy'),
+
+ /**
+ Returns `true` if the passed function returns true for every item in the
+ enumeration. This corresponds with the `every()` method in JavaScript 1.6.
+
+ The callback method you provide should have the following signature (all
+ parameters are optional):
+
+ ```javascript
+ function(item, index, enumerable);
+ ```
+
+ - `item` is the current item in the iteration.
+ - `index` is the current index in the iteration.
+ - `enumerable` is the enumerable object itself.
+
+ It should return the `true` or `false`.
+
+ Note that in addition to a callback, you can also pass an optional target
+ object that will be set as `this` on the context. This is a good way
+ to give your iterator function access to the current object.
+
+ Example Usage:
+
+ ```javascript
+ if (people.every(isEngineer)) {
+ Paychecks.addBigBonus();
+ }
+ ```
+
+ @method every
+ @param {Function} callback The callback to execute
+ @param {Object} [target] The target object to use
+ @return {Boolean}
+ */
+ every: function(callback, target) {
+ return !this.find(function(x, idx, i) {
+ return !callback.call(target, x, idx, i);
+ });
+ },
+
+ /**
+ @method everyBy
+ @param {String} key the property to test
+ @param {String} [value] optional value to test against.
+ @deprecated Use `isEvery` instead
+ @return {Boolean}
+ */
+ everyBy: aliasMethod('isEvery'),
+
+ /**
+ @method everyProperty
+ @param {String} key the property to test
+ @param {String} [value] optional value to test against.
+ @deprecated Use `isEvery` instead
+ @return {Boolean}
+ */
+ everyProperty: aliasMethod('isEvery'),
+
+ /**
+ Returns `true` if the passed property resolves to `true` for all items in
+ the enumerable. This method is often simpler/faster than using a callback.
+
+ @method isEvery
+ @param {String} key the property to test
+ @param {String} [value] optional value to test against.
+ @return {Boolean}
+ @since 1.3.0
+ */
+ isEvery: function(key, value) {
+ return this.every(apply(this, iter, arguments));
+ },
+
+ /**
+ Returns `true` if the passed function returns true for any item in the
+ enumeration. This corresponds with the `some()` method in JavaScript 1.6.
+
+ The callback method you provide should have the following signature (all
+ parameters are optional):
+
+ ```javascript
+ function(item, index, enumerable);
+ ```
+
+ - `item` is the current item in the iteration.
+ - `index` is the current index in the iteration.
+ - `enumerable` is the enumerable object itself.
+
+ It should return the `true` to include the item in the results, `false`
+ otherwise.
+
+ Note that in addition to a callback, you can also pass an optional target
+ object that will be set as `this` on the context. This is a good way
+ to give your iterator function access to the current object.
+
+ Usage Example:
+
+ ```javascript
+ if (people.any(isManager)) {
+ Paychecks.addBiggerBonus();
+ }
+ ```
+
+ @method any
+ @param {Function} callback The callback to execute
+ @param {Object} [target] The target object to use
+ @return {Boolean} `true` if the passed function returns `true` for any item
+ */
+ any: function(callback, target) {
+ var len = get(this, 'length');
+ var context = popCtx();
+ var found = false;
+ var last = null;
+ var next, idx;
+
+ if (target === undefined) {
+ target = null;
+ }
+
+ for (idx = 0; idx < len && !found; idx++) {
+ next = this.nextObject(idx, last, context);
+ found = callback.call(target, next, idx, this);
+ last = next;
+ }
+
+ next = last = null;
+ context = pushCtx(context);
+ return found;
+ },
+
+ /**
+ Returns `true` if the passed function returns true for any item in the
+ enumeration. This corresponds with the `some()` method in JavaScript 1.6.
+
+ The callback method you provide should have the following signature (all
+ parameters are optional):
+
+ ```javascript
+ function(item, index, enumerable);
+ ```
+
+ - `item` is the current item in the iteration.
+ - `index` is the current index in the iteration.
+ - `enumerable` is the enumerable object itself.
+
+ It should return the `true` to include the item in the results, `false`
+ otherwise.
+
+ Note that in addition to a callback, you can also pass an optional target
+ object that will be set as `this` on the context. This is a good way
+ to give your iterator function access to the current object.
+
+ Usage Example:
+
+ ```javascript
+ if (people.some(isManager)) {
+ Paychecks.addBiggerBonus();
+ }
+ ```
+
+ @method some
+ @param {Function} callback The callback to execute
+ @param {Object} [target] The target object to use
+ @return {Boolean} `true` if the passed function returns `true` for any item
+ @deprecated Use `any` instead
+ */
+ some: aliasMethod('any'),
+
+ /**
+ Returns `true` if the passed property resolves to `true` for any item in
+ the enumerable. This method is often simpler/faster than using a callback.
+
+ @method isAny
+ @param {String} key the property to test
+ @param {String} [value] optional value to test against.
+ @return {Boolean}
+ @since 1.3.0
+ */
+ isAny: function(key, value) {
+ return this.any(apply(this, iter, arguments));
+ },
+
+ /**
+ @method anyBy
+ @param {String} key the property to test
+ @param {String} [value] optional value to test against.
+ @return {Boolean}
+ @deprecated Use `isAny` instead
+ */
+ anyBy: aliasMethod('isAny'),
+
+ /**
+ @method someProperty
+ @param {String} key the property to test
+ @param {String} [value] optional value to test against.
+ @return {Boolean}
+ @deprecated Use `isAny` instead
+ */
+ someProperty: aliasMethod('isAny'),
+
+ /**
+ This will combine the values of the enumerator into a single value. It
+ is a useful way to collect a summary value from an enumeration. This
+ corresponds to the `reduce()` method defined in JavaScript 1.8.
+
+ The callback method you provide should have the following signature (all
+ parameters are optional):
+
+ ```javascript
+ function(previousValue, item, index, enumerable);
+ ```
+
+ - `previousValue` is the value returned by the last call to the iterator.
+ - `item` is the current item in the iteration.
+ - `index` is the current index in the iteration.
+ - `enumerable` is the enumerable object itself.
+
+ Return the new cumulative value.
+
+ In addition to the callback you can also pass an `initialValue`. An error
+ will be raised if you do not pass an initial value and the enumerator is
+ empty.
+
+ Note that unlike the other methods, this method does not allow you to
+ pass a target object to set as this for the callback. It's part of the
+ spec. Sorry.
+
+ @method reduce
+ @param {Function} callback The callback to execute
+ @param {Object} initialValue Initial value for the reduce
+ @param {String} reducerProperty internal use only.
+ @return {Object} The reduced value.
+ */
+ reduce: function(callback, initialValue, reducerProperty) {
+ if (typeof callback !== 'function') {
+ throw new TypeError();
+ }
+
+ var ret = initialValue;
+
+ this.forEach(function(item, i) {
+ ret = callback(ret, item, i, this, reducerProperty);
+ }, this);
+
+ return ret;
+ },
+
+ /**
+ Invokes the named method on every object in the receiver that
+ implements it. This method corresponds to the implementation in
+ Prototype 1.6.
+
+ @method invoke
+ @param {String} methodName the name of the method
+ @param {Object...} args optional arguments to pass as well.
+ @return {Array} return values from calling invoke.
+ */
+ invoke: function(methodName) {
+ var ret = Ember.A();
+ var args;
+
+ if (arguments.length > 1) {
+ args = a_slice.call(arguments, 1);
+ }
+
+ this.forEach(function(x, idx) {
+ var method = x && x[methodName];
+
+ if ('function' === typeof method) {
+ ret[idx] = args ? apply(x, method, args) : x[methodName]();
+ }
+ }, this);
+
+ return ret;
+ },
+
+ /**
+ Simply converts the enumerable into a genuine array. The order is not
+ guaranteed. Corresponds to the method implemented by Prototype.
+
+ @method toArray
+ @return {Array} the enumerable as an array.
+ */
+ toArray: function() {
+ var ret = Ember.A();
+
+ this.forEach(function(o, idx) {
+ ret[idx] = o;
+ });
+
+ return ret;
+ },
+
+ /**
+ Returns a copy of the array with all `null` and `undefined` elements removed.
+
+ ```javascript
+ var arr = ['a', null, 'c', undefined];
+ arr.compact(); // ['a', 'c']
+ ```
+
+ @method compact
+ @return {Array} the array without null and undefined elements.
+ */
+ compact: function() {
+ return this.filter(function(value) {
+ return value != null;
+ });
+ },
+
+ /**
+ Returns a new enumerable that excludes the passed value. The default
+ implementation returns an array regardless of the receiver type unless
+ the receiver does not contain the value.
+
+ ```javascript
+ var arr = ['a', 'b', 'a', 'c'];
+ arr.without('a'); // ['b', 'c']
+ ```
+
+ @method without
+ @param {Object} value
+ @return {Ember.Enumerable}
+ */
+ without: function(value) {
+ if (!this.contains(value)) {
+ return this; // nothing to do
+ }
+
+ var ret = Ember.A();
+
+ this.forEach(function(k) {
+ if (k !== value) {
+ ret[ret.length] = k;
+ }
+ });
+
+ return ret;
+ },
+
+ /**
+ Returns a new enumerable that contains only unique values. The default
+ implementation returns an array regardless of the receiver type.
+
+ ```javascript
+ var arr = ['a', 'a', 'b', 'b'];
+ arr.uniq(); // ['a', 'b']
+ ```
+
+ This only works on primitive data types, e.g. Strings, Numbers, etc.
+
+ @method uniq
+ @return {Ember.Enumerable}
+ */
+ uniq: function() {
+ var ret = Ember.A();
+
+ this.forEach(function(k) {
+ if (indexOf(ret, k) < 0) {
+ ret.push(k);
+ }
+ });
+
+ return ret;
+ },
+
+ /**
+ This property will trigger anytime the enumerable's content changes.
+ You can observe this property to be notified of changes to the enumerables
+ content.
+
+ For plain enumerables, this property is read only. `Array` overrides
+ this method.
+
+ @property []
+ @type Array
+ @return this
+ */
+ '[]': computed(function(key, value) {
+ return this;
+ }),
+
+ // ..........................................................
+ // ENUMERABLE OBSERVERS
+ //
+
+ /**
+ Registers an enumerable observer. Must implement `Ember.EnumerableObserver`
+ mixin.
+
+ @method addEnumerableObserver
+ @param {Object} target
+ @param {Hash} [opts]
+ @return this
+ */
+ addEnumerableObserver: function(target, opts) {
+ var willChange = (opts && opts.willChange) || 'enumerableWillChange';
+ var didChange = (opts && opts.didChange) || 'enumerableDidChange';
+ var hasObservers = get(this, 'hasEnumerableObservers');
+
+ if (!hasObservers) {
+ propertyWillChange(this, 'hasEnumerableObservers');
+ }
+
+ addListener(this, '@enumerable:before', target, willChange);
+ addListener(this, '@enumerable:change', target, didChange);
+
+ if (!hasObservers) {
+ propertyDidChange(this, 'hasEnumerableObservers');
+ }
+
+ return this;
+ },
+
+ /**
+ Removes a registered enumerable observer.
+
+ @method removeEnumerableObserver
+ @param {Object} target
+ @param {Hash} [opts]
+ @return this
+ */
+ removeEnumerableObserver: function(target, opts) {
+ var willChange = (opts && opts.willChange) || 'enumerableWillChange';
+ var didChange = (opts && opts.didChange) || 'enumerableDidChange';
+ var hasObservers = get(this, 'hasEnumerableObservers');
+
+ if (hasObservers) {
+ propertyWillChange(this, 'hasEnumerableObservers');
+ }
+
+ removeListener(this, '@enumerable:before', target, willChange);
+ removeListener(this, '@enumerable:change', target, didChange);
+
+ if (hasObservers) {
+ propertyDidChange(this, 'hasEnumerableObservers');
+ }
+
+ return this;
+ },
+
+ /**
+ Becomes true whenever the array currently has observers watching changes
+ on the array.
+
+ @property hasEnumerableObservers
+ @type Boolean
+ */
+ hasEnumerableObservers: computed(function() {
+ return hasListeners(this, '@enumerable:change') || hasListeners(this, '@enumerable:before');
+ }),
+
+
+ /**
+ Invoke this method just before the contents of your enumerable will
+ change. You can either omit the parameters completely or pass the objects
+ to be removed or added if available or just a count.
+
+ @method enumerableContentWillChange
+ @param {Ember.Enumerable|Number} removing An enumerable of the objects to
+ be removed or the number of items to be removed.
+ @param {Ember.Enumerable|Number} adding An enumerable of the objects to be
+ added or the number of items to be added.
+ @chainable
+ */
+ enumerableContentWillChange: function(removing, adding) {
+ var removeCnt, addCnt, hasDelta;
+
+ if ('number' === typeof removing) {
+ removeCnt = removing;
+ } else if (removing) {
+ removeCnt = get(removing, 'length');
+ } else {
+ removeCnt = removing = -1;
+ }
+
+ if ('number' === typeof adding) {
+ addCnt = adding;
+ } else if (adding) {
+ addCnt = get(adding,'length');
+ } else {
+ addCnt = adding = -1;
+ }
+
+ hasDelta = addCnt < 0 || removeCnt < 0 || addCnt - removeCnt !== 0;
+
+ if (removing === -1) {
+ removing = null;
+ }
+
+ if (adding === -1) {
+ adding = null;
+ }
+
+ propertyWillChange(this, '[]');
+
+ if (hasDelta) {
+ propertyWillChange(this, 'length');
+ }
+
+ sendEvent(this, '@enumerable:before', [this, removing, adding]);
+
+ return this;
+ },
+
+ /**
+ Invoke this method when the contents of your enumerable has changed.
+ This will notify any observers watching for content changes. If you are
+ implementing an ordered enumerable (such as an array), also pass the
+ start and end values where the content changed so that it can be used to
+ notify range observers.
+
+ @method enumerableContentDidChange
+ @param {Ember.Enumerable|Number} removing An enumerable of the objects to
+ be removed or the number of items to be removed.
+ @param {Ember.Enumerable|Number} adding An enumerable of the objects to
+ be added or the number of items to be added.
+ @chainable
+ */
+ enumerableContentDidChange: function(removing, adding) {
+ var removeCnt, addCnt, hasDelta;
+
+ if ('number' === typeof removing) {
+ removeCnt = removing;
+ } else if (removing) {
+ removeCnt = get(removing, 'length');
+ } else {
+ removeCnt = removing = -1;
+ }
+
+ if ('number' === typeof adding) {
+ addCnt = adding;
+ } else if (adding) {
+ addCnt = get(adding, 'length');
+ } else {
+ addCnt = adding = -1;
+ }
+
+ hasDelta = addCnt < 0 || removeCnt < 0 || addCnt - removeCnt !== 0;
+
+ if (removing === -1) {
+ removing = null;
+ }
+
+ if (adding === -1) {
+ adding = null;
+ }
+
+ sendEvent(this, '@enumerable:change', [this, removing, adding]);
+
+ if (hasDelta) {
+ propertyDidChange(this, 'length');
+ }
+
+ propertyDidChange(this, '[]');
+
+ return this ;
+ },
+
+ /**
+ Converts the enumerable into an array and sorts by the keys
+ specified in the argument.
+
+ You may provide multiple arguments to sort by multiple properties.
+
+ @method sortBy
+ @param {String} property name(s) to sort on
+ @return {Array} The sorted array.
+ @since 1.2.0
+ */
+ sortBy: function() {
+ var sortKeys = arguments;
+
+ return this.toArray().sort(function(a, b) {
+ for(var i = 0; i < sortKeys.length; i++) {
+ var key = sortKeys[i];
+ var propA = get(a, key);
+ var propB = get(b, key);
+ // return 1 or -1 else continue to the next sortKey
+ var compareValue = compare(propA, propB);
+
+ if (compareValue) {
+ return compareValue;
+ }
+ }
+ return 0;
+ });
+ }
+ });
+ });
+enifed("ember-runtime/mixins/evented",
+ ["ember-metal/mixin","ember-metal/events","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var Mixin = __dependency1__.Mixin;
+ var addListener = __dependency2__.addListener;
+ var removeListener = __dependency2__.removeListener;
+ var hasListeners = __dependency2__.hasListeners;
+ var sendEvent = __dependency2__.sendEvent;
+
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ /**
+ This mixin allows for Ember objects to subscribe to and emit events.
+
+ ```javascript
+ App.Person = Ember.Object.extend(Ember.Evented, {
+ greet: function() {
+ // ...
+ this.trigger('greet');
+ }
+ });
+
+ var person = App.Person.create();
+
+ person.on('greet', function() {
+ console.log('Our person has greeted');
+ });
+
+ person.greet();
+
+ // outputs: 'Our person has greeted'
+ ```
+
+ You can also chain multiple event subscriptions:
+
+ ```javascript
+ person.on('greet', function() {
+ console.log('Our person has greeted');
+ }).one('greet', function() {
+ console.log('Offer one-time special');
+ }).off('event', this, forgetThis);
+ ```
+
+ @class Evented
+ @namespace Ember
+ */
+ __exports__["default"] = Mixin.create({
+
+ /**
+ Subscribes to a named event with given function.
+
+ ```javascript
+ person.on('didLoad', function() {
+ // fired once the person has loaded
+ });
+ ```
+
+ An optional target can be passed in as the 2nd argument that will
+ be set as the "this" for the callback. This is a good way to give your
+ function access to the object triggering the event. When the target
+ parameter is used the callback becomes the third argument.
+
+ @method on
+ @param {String} name The name of the event
+ @param {Object} [target] The "this" binding for the callback
+ @param {Function} method The callback to execute
+ @return this
+ */
+ on: function(name, target, method) {
+ addListener(this, name, target, method);
+ return this;
+ },
+
+ /**
+ Subscribes a function to a named event and then cancels the subscription
+ after the first time the event is triggered. It is good to use ``one`` when
+ you only care about the first time an event has taken place.
+
+ This function takes an optional 2nd argument that will become the "this"
+ value for the callback. If this argument is passed then the 3rd argument
+ becomes the function.
+
+ @method one
+ @param {String} name The name of the event
+ @param {Object} [target] The "this" binding for the callback
+ @param {Function} method The callback to execute
+ @return this
+ */
+ one: function(name, target, method) {
+ if (!method) {
+ method = target;
+ target = null;
+ }
+
+ addListener(this, name, target, method, true);
+ return this;
+ },
+
+ /**
+ Triggers a named event for the object. Any additional arguments
+ will be passed as parameters to the functions that are subscribed to the
+ event.
+
+ ```javascript
+ person.on('didEat', function(food) {
+ console.log('person ate some ' + food);
+ });
+
+ person.trigger('didEat', 'broccoli');
+
+ // outputs: person ate some broccoli
+ ```
+ @method trigger
+ @param {String} name The name of the event
+ @param {Object...} args Optional arguments to pass on
+ */
+ trigger: function(name) {
+ var length = arguments.length;
+ var args = new Array(length - 1);
+
+ for (var i = 1; i < length; i++) {
+ args[i - 1] = arguments[i];
+ }
+
+ sendEvent(this, name, args);
+ },
+
+ /**
+ Cancels subscription for given name, target, and method.
+
+ @method off
+ @param {String} name The name of the event
+ @param {Object} target The target of the subscription
+ @param {Function} method The function of the subscription
+ @return this
+ */
+ off: function(name, target, method) {
+ removeListener(this, name, target, method);
+ return this;
+ },
+
+ /**
+ Checks to see if object has any subscriptions for named event.
+
+ @method has
+ @param {String} name The name of the event
+ @return {Boolean} does the object have a subscription for event
+ */
+ has: function(name) {
+ return hasListeners(this, name);
+ }
+ });
+ });
+enifed("ember-runtime/mixins/freezable",
+ ["ember-metal/mixin","ember-metal/property_get","ember-metal/property_set","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ var Mixin = __dependency1__.Mixin;
+ var get = __dependency2__.get;
+ var set = __dependency3__.set;
+
+ /**
+ The `Ember.Freezable` mixin implements some basic methods for marking an
+ object as frozen. Once an object is frozen it should be read only. No changes
+ may be made the internal state of the object.
+
+ ## Enforcement
+
+ To fully support freezing in your subclass, you must include this mixin and
+ override any method that might alter any property on the object to instead
+ raise an exception. You can check the state of an object by checking the
+ `isFrozen` property.
+
+ Although future versions of JavaScript may support language-level freezing
+ object objects, that is not the case today. Even if an object is freezable,
+ it is still technically possible to modify the object, even though it could
+ break other parts of your application that do not expect a frozen object to
+ change. It is, therefore, very important that you always respect the
+ `isFrozen` property on all freezable objects.
+
+ ## Example Usage
+
+ The example below shows a simple object that implement the `Ember.Freezable`
+ protocol.
+
+ ```javascript
+ Contact = Ember.Object.extend(Ember.Freezable, {
+ firstName: null,
+ lastName: null,
+
+ // swaps the names
+ swapNames: function() {
+ if (this.get('isFrozen')) throw Ember.FROZEN_ERROR;
+ var tmp = this.get('firstName');
+ this.set('firstName', this.get('lastName'));
+ this.set('lastName', tmp);
+ return this;
+ }
+
+ });
+
+ c = Contact.create({ firstName: "John", lastName: "Doe" });
+ c.swapNames(); // returns c
+ c.freeze();
+ c.swapNames(); // EXCEPTION
+ ```
+
+ ## Copying
+
+ Usually the `Ember.Freezable` protocol is implemented in cooperation with the
+ `Ember.Copyable` protocol, which defines a `frozenCopy()` method that will
+ return a frozen object, if the object implements this method as well.
+
+ @class Freezable
+ @namespace Ember
+ @since Ember 0.9
+ */
+ var Freezable = Mixin.create({
+
+ /**
+ Set to `true` when the object is frozen. Use this property to detect
+ whether your object is frozen or not.
+
+ @property isFrozen
+ @type Boolean
+ */
+ isFrozen: false,
+
+ /**
+ Freezes the object. Once this method has been called the object should
+ no longer allow any properties to be edited.
+
+ @method freeze
+ @return {Object} receiver
+ */
+ freeze: function() {
+ if (get(this, 'isFrozen')) return this;
+ set(this, 'isFrozen', true);
+ return this;
+ }
+
+ });
+ __exports__.Freezable = Freezable;
+ var FROZEN_ERROR = "Frozen object cannot be modified.";
+ __exports__.FROZEN_ERROR = FROZEN_ERROR;
+ });
+enifed("ember-runtime/mixins/mutable_array",
+ ["ember-metal/property_get","ember-metal/utils","ember-metal/error","ember-metal/mixin","ember-runtime/mixins/array","ember-runtime/mixins/mutable_enumerable","ember-runtime/mixins/enumerable","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+
+ // require('ember-runtime/mixins/array');
+ // require('ember-runtime/mixins/mutable_enumerable');
+
+ // ..........................................................
+ // CONSTANTS
+ //
+
+ var OUT_OF_RANGE_EXCEPTION = "Index out of range";
+ var EMPTY = [];
+
+ // ..........................................................
+ // HELPERS
+ //
+
+ var get = __dependency1__.get;
+ var isArray = __dependency2__.isArray;
+ var EmberError = __dependency3__["default"];
+ var Mixin = __dependency4__.Mixin;
+ var required = __dependency4__.required;
+ var EmberArray = __dependency5__["default"];
+ var MutableEnumerable = __dependency6__["default"];
+ var Enumerable = __dependency7__["default"];
+ /**
+ This mixin defines the API for modifying array-like objects. These methods
+ can be applied only to a collection that keeps its items in an ordered set.
+ It builds upon the Array mixin and adds methods to modify the array.
+ Concrete implementations of this class include ArrayProxy and ArrayController.
+
+ It is important to use the methods in this class to modify arrays so that
+ changes are observable. This allows the binding system in Ember to function
+ correctly.
+
+
+ Note that an Array can change even if it does not implement this mixin.
+ For example, one might implement a SparseArray that cannot be directly
+ modified, but if its underlying enumerable changes, it will change also.
+
+ @class MutableArray
+ @namespace Ember
+ @uses Ember.Array
+ @uses Ember.MutableEnumerable
+ */
+ __exports__["default"] = Mixin.create(EmberArray, MutableEnumerable, {
+
+ /**
+ __Required.__ You must implement this method to apply this mixin.
+
+ This is one of the primitives you must implement to support `Ember.Array`.
+ You should replace amt objects started at idx with the objects in the
+ passed array. You should also call `this.enumerableContentDidChange()`
+
+ @method replace
+ @param {Number} idx Starting index in the array to replace. If
+ idx >= length, then append to the end of the array.
+ @param {Number} amt Number of elements that should be removed from
+ the array, starting at *idx*.
+ @param {Array} objects An array of zero or more objects that should be
+ inserted into the array at *idx*
+ */
+ replace: required(),
+
+ /**
+ Remove all elements from the array. This is useful if you
+ want to reuse an existing array without having to recreate it.
+
+ ```javascript
+ var colors = ["red", "green", "blue"];
+ color.length(); // 3
+ colors.clear(); // []
+ colors.length(); // 0
+ ```
+
+ @method clear
+ @return {Ember.Array} An empty Array.
+ */
+ clear: function () {
+ var len = get(this, 'length');
+ if (len === 0) return this;
+ this.replace(0, len, EMPTY);
+ return this;
+ },
+
+ /**
+ This will use the primitive `replace()` method to insert an object at the
+ specified index.
+
+ ```javascript
+ var colors = ["red", "green", "blue"];
+ colors.insertAt(2, "yellow"); // ["red", "green", "yellow", "blue"]
+ colors.insertAt(5, "orange"); // Error: Index out of range
+ ```
+
+ @method insertAt
+ @param {Number} idx index of insert the object at.
+ @param {Object} object object to insert
+ @return {Ember.Array} receiver
+ */
+ insertAt: function(idx, object) {
+ if (idx > get(this, 'length')) throw new EmberError(OUT_OF_RANGE_EXCEPTION);
+ this.replace(idx, 0, [object]);
+ return this;
+ },
+
+ /**
+ Remove an object at the specified index using the `replace()` primitive
+ method. You can pass either a single index, or a start and a length.
+
+ If you pass a start and length that is beyond the
+ length this method will throw an `OUT_OF_RANGE_EXCEPTION`.
+
+ ```javascript
+ var colors = ["red", "green", "blue", "yellow", "orange"];
+ colors.removeAt(0); // ["green", "blue", "yellow", "orange"]
+ colors.removeAt(2, 2); // ["green", "blue"]
+ colors.removeAt(4, 2); // Error: Index out of range
+ ```
+
+ @method removeAt
+ @param {Number} start index, start of range
+ @param {Number} len length of passing range
+ @return {Ember.Array} receiver
+ */
+ removeAt: function(start, len) {
+ if ('number' === typeof start) {
+
+ if ((start < 0) || (start >= get(this, 'length'))) {
+ throw new EmberError(OUT_OF_RANGE_EXCEPTION);
+ }
+
+ // fast case
+ if (len === undefined) len = 1;
+ this.replace(start, len, EMPTY);
+ }
+
+ return this;
+ },
+
+ /**
+ Push the object onto the end of the array. Works just like `push()` but it
+ is KVO-compliant.
+
+ ```javascript
+ var colors = ["red", "green"];
+ colors.pushObject("black"); // ["red", "green", "black"]
+ colors.pushObject(["yellow"]); // ["red", "green", ["yellow"]]
+ ```
+
+ @method pushObject
+ @param {*} obj object to push
+ @return object same object passed as a param
+ */
+ pushObject: function(obj) {
+ this.insertAt(get(this, 'length'), obj);
+ return obj;
+ },
+
+ /**
+ Add the objects in the passed numerable to the end of the array. Defers
+ notifying observers of the change until all objects are added.
+
+ ```javascript
+ var colors = ["red"];
+ colors.pushObjects(["yellow", "orange"]); // ["red", "yellow", "orange"]
+ ```
+
+ @method pushObjects
+ @param {Ember.Enumerable} objects the objects to add
+ @return {Ember.Array} receiver
+ */
+ pushObjects: function(objects) {
+ if (!(Enumerable.detect(objects) || isArray(objects))) {
+ throw new TypeError("Must pass Ember.Enumerable to Ember.MutableArray#pushObjects");
+ }
+ this.replace(get(this, 'length'), 0, objects);
+ return this;
+ },
+
+ /**
+ Pop object from array or nil if none are left. Works just like `pop()` but
+ it is KVO-compliant.
+
+ ```javascript
+ var colors = ["red", "green", "blue"];
+ colors.popObject(); // "blue"
+ console.log(colors); // ["red", "green"]
+ ```
+
+ @method popObject
+ @return object
+ */
+ popObject: function() {
+ var len = get(this, 'length');
+ if (len === 0) return null;
+
+ var ret = this.objectAt(len-1);
+ this.removeAt(len-1, 1);
+ return ret;
+ },
+
+ /**
+ Shift an object from start of array or nil if none are left. Works just
+ like `shift()` but it is KVO-compliant.
+
+ ```javascript
+ var colors = ["red", "green", "blue"];
+ colors.shiftObject(); // "red"
+ console.log(colors); // ["green", "blue"]
+ ```
+
+ @method shiftObject
+ @return object
+ */
+ shiftObject: function() {
+ if (get(this, 'length') === 0) return null;
+ var ret = this.objectAt(0);
+ this.removeAt(0);
+ return ret;
+ },
+
+ /**
+ Unshift an object to start of array. Works just like `unshift()` but it is
+ KVO-compliant.
+
+ ```javascript
+ var colors = ["red"];
+ colors.unshiftObject("yellow"); // ["yellow", "red"]
+ colors.unshiftObject(["black"]); // [["black"], "yellow", "red"]
+ ```
+
+ @method unshiftObject
+ @param {*} obj object to unshift
+ @return object same object passed as a param
+ */
+ unshiftObject: function(obj) {
+ this.insertAt(0, obj);
+ return obj;
+ },
+
+ /**
+ Adds the named objects to the beginning of the array. Defers notifying
+ observers until all objects have been added.
+
+ ```javascript
+ var colors = ["red"];
+ colors.unshiftObjects(["black", "white"]); // ["black", "white", "red"]
+ colors.unshiftObjects("yellow"); // Type Error: 'undefined' is not a function
+ ```
+
+ @method unshiftObjects
+ @param {Ember.Enumerable} objects the objects to add
+ @return {Ember.Array} receiver
+ */
+ unshiftObjects: function(objects) {
+ this.replace(0, 0, objects);
+ return this;
+ },
+
+ /**
+ Reverse objects in the array. Works just like `reverse()` but it is
+ KVO-compliant.
+
+ @method reverseObjects
+ @return {Ember.Array} receiver
+ */
+ reverseObjects: function() {
+ var len = get(this, 'length');
+ if (len === 0) return this;
+ var objects = this.toArray().reverse();
+ this.replace(0, len, objects);
+ return this;
+ },
+
+ /**
+ Replace all the receiver's content with content of the argument.
+ If argument is an empty array receiver will be cleared.
+
+ ```javascript
+ var colors = ["red", "green", "blue"];
+ colors.setObjects(["black", "white"]); // ["black", "white"]
+ colors.setObjects([]); // []
+ ```
+
+ @method setObjects
+ @param {Ember.Array} objects array whose content will be used for replacing
+ the content of the receiver
+ @return {Ember.Array} receiver with the new content
+ */
+ setObjects: function(objects) {
+ if (objects.length === 0) return this.clear();
+
+ var len = get(this, 'length');
+ this.replace(0, len, objects);
+ return this;
+ },
+
+ // ..........................................................
+ // IMPLEMENT Ember.MutableEnumerable
+ //
+
+ /**
+ Remove all occurrences of an object in the array.
+
+ ```javascript
+ var cities = ["Chicago", "Berlin", "Lima", "Chicago"];
+ cities.removeObject("Chicago"); // ["Berlin", "Lima"]
+ cities.removeObject("Lima"); // ["Berlin"]
+ cities.removeObject("Tokyo") // ["Berlin"]
+ ```
+
+ @method removeObject
+ @param {*} obj object to remove
+ @return {Ember.Array} receiver
+ */
+ removeObject: function(obj) {
+ var loc = get(this, 'length') || 0;
+ while(--loc >= 0) {
+ var curObject = this.objectAt(loc);
+ if (curObject === obj) this.removeAt(loc);
+ }
+ return this;
+ },
+
+ /**
+ Push the object onto the end of the array if it is not already
+ present in the array.
+
+ ```javascript
+ var cities = ["Chicago", "Berlin"];
+ cities.addObject("Lima"); // ["Chicago", "Berlin", "Lima"]
+ cities.addObject("Berlin"); // ["Chicago", "Berlin", "Lima"]
+ ```
+
+ @method addObject
+ @param {*} obj object to add, if not already present
+ @return {Ember.Array} receiver
+ */
+ addObject: function(obj) {
+ if (!this.contains(obj)) this.pushObject(obj);
+ return this;
+ }
+
+ });
+ });
+enifed("ember-runtime/mixins/mutable_enumerable",
+ ["ember-metal/enumerable_utils","ember-runtime/mixins/enumerable","ember-metal/mixin","ember-metal/property_events","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ var forEach = __dependency1__.forEach;
+ var Enumerable = __dependency2__["default"];
+ var Mixin = __dependency3__.Mixin;
+ var required = __dependency3__.required;
+ var beginPropertyChanges = __dependency4__.beginPropertyChanges;
+ var endPropertyChanges = __dependency4__.endPropertyChanges;
+
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ /**
+ This mixin defines the API for modifying generic enumerables. These methods
+ can be applied to an object regardless of whether it is ordered or
+ unordered.
+
+ Note that an Enumerable can change even if it does not implement this mixin.
+ For example, a MappedEnumerable cannot be directly modified but if its
+ underlying enumerable changes, it will change also.
+
+ ## Adding Objects
+
+ To add an object to an enumerable, use the `addObject()` method. This
+ method will only add the object to the enumerable if the object is not
+ already present and is of a type supported by the enumerable.
+
+ ```javascript
+ set.addObject(contact);
+ ```
+
+ ## Removing Objects
+
+ To remove an object from an enumerable, use the `removeObject()` method. This
+ will only remove the object if it is present in the enumerable, otherwise
+ this method has no effect.
+
+ ```javascript
+ set.removeObject(contact);
+ ```
+
+ ## Implementing In Your Own Code
+
+ If you are implementing an object and want to support this API, just include
+ this mixin in your class and implement the required methods. In your unit
+ tests, be sure to apply the Ember.MutableEnumerableTests to your object.
+
+ @class MutableEnumerable
+ @namespace Ember
+ @uses Ember.Enumerable
+ */
+ __exports__["default"] = Mixin.create(Enumerable, {
+
+ /**
+ __Required.__ You must implement this method to apply this mixin.
+
+ Attempts to add the passed object to the receiver if the object is not
+ already present in the collection. If the object is present, this method
+ has no effect.
+
+ If the passed object is of a type not supported by the receiver,
+ then this method should raise an exception.
+
+ @method addObject
+ @param {Object} object The object to add to the enumerable.
+ @return {Object} the passed object
+ */
+ addObject: required(Function),
+
+ /**
+ Adds each object in the passed enumerable to the receiver.
+
+ @method addObjects
+ @param {Ember.Enumerable} objects the objects to add.
+ @return {Object} receiver
+ */
+ addObjects: function(objects) {
+ beginPropertyChanges(this);
+ forEach(objects, function(obj) { this.addObject(obj); }, this);
+ endPropertyChanges(this);
+ return this;
+ },
+
+ /**
+ __Required.__ You must implement this method to apply this mixin.
+
+ Attempts to remove the passed object from the receiver collection if the
+ object is present in the collection. If the object is not present,
+ this method has no effect.
+
+ If the passed object is of a type not supported by the receiver,
+ then this method should raise an exception.
+
+ @method removeObject
+ @param {Object} object The object to remove from the enumerable.
+ @return {Object} the passed object
+ */
+ removeObject: required(Function),
+
+
+ /**
+ Removes each object in the passed enumerable from the receiver.
+
+ @method removeObjects
+ @param {Ember.Enumerable} objects the objects to remove
+ @return {Object} receiver
+ */
+ removeObjects: function(objects) {
+ beginPropertyChanges(this);
+ for (var i = objects.length - 1; i >= 0; i--) {
+ this.removeObject(objects[i]);
+ }
+ endPropertyChanges(this);
+ return this;
+ }
+ });
+ });
+enifed("ember-runtime/mixins/observable",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/get_properties","ember-metal/set_properties","ember-metal/mixin","ember-metal/events","ember-metal/property_events","ember-metal/observer","ember-metal/computed","ember-metal/is_none","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+
+ var get = __dependency2__.get;
+ var getWithDefault = __dependency2__.getWithDefault;
+ var set = __dependency3__.set;
+ var apply = __dependency4__.apply;
+ var getProperties = __dependency5__["default"];
+ var setProperties = __dependency6__["default"];
+ var Mixin = __dependency7__.Mixin;
+ var hasListeners = __dependency8__.hasListeners;
+ var beginPropertyChanges = __dependency9__.beginPropertyChanges;
+ var propertyWillChange = __dependency9__.propertyWillChange;
+ var propertyDidChange = __dependency9__.propertyDidChange;
+ var endPropertyChanges = __dependency9__.endPropertyChanges;
+ var addObserver = __dependency10__.addObserver;
+ var addBeforeObserver = __dependency10__.addBeforeObserver;
+ var removeObserver = __dependency10__.removeObserver;
+ var observersFor = __dependency10__.observersFor;
+ var cacheFor = __dependency11__.cacheFor;
+ var isNone = __dependency12__["default"];
+
+
+ var slice = Array.prototype.slice;
+ /**
+ ## Overview
+
+ This mixin provides properties and property observing functionality, core
+ features of the Ember object model.
+
+ Properties and observers allow one object to observe changes to a
+ property on another object. This is one of the fundamental ways that
+ models, controllers and views communicate with each other in an Ember
+ application.
+
+ Any object that has this mixin applied can be used in observer
+ operations. That includes `Ember.Object` and most objects you will
+ interact with as you write your Ember application.
+
+ Note that you will not generally apply this mixin to classes yourself,
+ but you will use the features provided by this module frequently, so it
+ is important to understand how to use it.
+
+ ## Using `get()` and `set()`
+
+ Because of Ember's support for bindings and observers, you will always
+ access properties using the get method, and set properties using the
+ set method. This allows the observing objects to be notified and
+ computed properties to be handled properly.
+
+ More documentation about `get` and `set` are below.
+
+ ## Observing Property Changes
+
+ You typically observe property changes simply by adding the `observes`
+ call to the end of your method declarations in classes that you write.
+ For example:
+
+ ```javascript
+ Ember.Object.extend({
+ valueObserver: function() {
+ // Executes whenever the "value" property changes
+ }.observes('value')
+ });
+ ```
+
+ Although this is the most common way to add an observer, this capability
+ is actually built into the `Ember.Object` class on top of two methods
+ defined in this mixin: `addObserver` and `removeObserver`. You can use
+ these two methods to add and remove observers yourself if you need to
+ do so at runtime.
+
+ To add an observer for a property, call:
+
+ ```javascript
+ object.addObserver('propertyKey', targetObject, targetAction)
+ ```
+
+ This will call the `targetAction` method on the `targetObject` whenever
+ the value of the `propertyKey` changes.
+
+ Note that if `propertyKey` is a computed property, the observer will be
+ called when any of the property dependencies are changed, even if the
+ resulting value of the computed property is unchanged. This is necessary
+ because computed properties are not computed until `get` is called.
+
+ @class Observable
+ @namespace Ember
+ */
+ __exports__["default"] = Mixin.create({
+
+ /**
+ Retrieves the value of a property from the object.
+
+ This method is usually similar to using `object[keyName]` or `object.keyName`,
+ however it supports both computed properties and the unknownProperty
+ handler.
+
+ Because `get` unifies the syntax for accessing all these kinds
+ of properties, it can make many refactorings easier, such as replacing a
+ simple property with a computed property, or vice versa.
+
+ ### Computed Properties
+
+ Computed properties are methods defined with the `property` modifier
+ declared at the end, such as:
+
+ ```javascript
+ fullName: function() {
+ return this.get('firstName') + ' ' + this.get('lastName');
+ }.property('firstName', 'lastName')
+ ```
+
+ When you call `get` on a computed property, the function will be
+ called and the return value will be returned instead of the function
+ itself.
+
+ ### Unknown Properties
+
+ Likewise, if you try to call `get` on a property whose value is
+ `undefined`, the `unknownProperty()` method will be called on the object.
+ If this method returns any value other than `undefined`, it will be returned
+ instead. This allows you to implement "virtual" properties that are
+ not defined upfront.
+
+ @method get
+ @param {String} keyName The property to retrieve
+ @return {Object} The property value or undefined.
+ */
+ get: function(keyName) {
+ return get(this, keyName);
+ },
+
+ /**
+ To get the values of multiple properties at once, call `getProperties`
+ with a list of strings or an array:
+
+ ```javascript
+ record.getProperties('firstName', 'lastName', 'zipCode');
+ // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+ ```
+
+ is equivalent to:
+
+ ```javascript
+ record.getProperties(['firstName', 'lastName', 'zipCode']);
+ // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+ ```
+
+ @method getProperties
+ @param {String...|Array} list of keys to get
+ @return {Hash}
+ */
+ getProperties: function() {
+ return apply(null, getProperties, [this].concat(slice.call(arguments)));
+ },
+
+ /**
+ Sets the provided key or path to the value.
+
+ This method is generally very similar to calling `object[key] = value` or
+ `object.key = value`, except that it provides support for computed
+ properties, the `setUnknownProperty()` method and property observers.
+
+ ### Computed Properties
+
+ If you try to set a value on a key that has a computed property handler
+ defined (see the `get()` method for an example), then `set()` will call
+ that method, passing both the value and key instead of simply changing
+ the value itself. This is useful for those times when you need to
+ implement a property that is composed of one or more member
+ properties.
+
+ ### Unknown Properties
+
+ If you try to set a value on a key that is undefined in the target
+ object, then the `setUnknownProperty()` handler will be called instead. This
+ gives you an opportunity to implement complex "virtual" properties that
+ are not predefined on the object. If `setUnknownProperty()` returns
+ undefined, then `set()` will simply set the value on the object.
+
+ ### Property Observers
+
+ In addition to changing the property, `set()` will also register a property
+ change with the object. Unless you have placed this call inside of a
+ `beginPropertyChanges()` and `endPropertyChanges(),` any "local" observers
+ (i.e. observer methods declared on the same object), will be called
+ immediately. Any "remote" observers (i.e. observer methods declared on
+ another object) will be placed in a queue and called at a later time in a
+ coalesced manner.
+
+ ### Chaining
+
+ In addition to property changes, `set()` returns the value of the object
+ itself so you can do chaining like this:
+
+ ```javascript
+ record.set('firstName', 'Charles').set('lastName', 'Jolley');
+ ```
+
+ @method set
+ @param {String} keyName The property to set
+ @param {Object} value The value to set or `null`.
+ @return {Ember.Observable}
+ */
+ set: function(keyName, value) {
+ set(this, keyName, value);
+ return this;
+ },
+
+
+ /**
+ Sets a list of properties at once. These properties are set inside
+ a single `beginPropertyChanges` and `endPropertyChanges` batch, so
+ observers will be buffered.
+
+ ```javascript
+ record.setProperties({ firstName: 'Charles', lastName: 'Jolley' });
+ ```
+
+ @method setProperties
+ @param {Hash} hash the hash of keys and values to set
+ @return {Ember.Observable}
+ */
+ setProperties: function(hash) {
+ return setProperties(this, hash);
+ },
+
+ /**
+ Begins a grouping of property changes.
+
+ You can use this method to group property changes so that notifications
+ will not be sent until the changes are finished. If you plan to make a
+ large number of changes to an object at one time, you should call this
+ method at the beginning of the changes to begin deferring change
+ notifications. When you are done making changes, call
+ `endPropertyChanges()` to deliver the deferred change notifications and end
+ deferring.
+
+ @method beginPropertyChanges
+ @return {Ember.Observable}
+ */
+ beginPropertyChanges: function() {
+ beginPropertyChanges();
+ return this;
+ },
+
+ /**
+ Ends a grouping of property changes.
+
+ You can use this method to group property changes so that notifications
+ will not be sent until the changes are finished. If you plan to make a
+ large number of changes to an object at one time, you should call
+ `beginPropertyChanges()` at the beginning of the changes to defer change
+ notifications. When you are done making changes, call this method to
+ deliver the deferred change notifications and end deferring.
+
+ @method endPropertyChanges
+ @return {Ember.Observable}
+ */
+ endPropertyChanges: function() {
+ endPropertyChanges();
+ return this;
+ },
+
+ /**
+ Notify the observer system that a property is about to change.
+
+ Sometimes you need to change a value directly or indirectly without
+ actually calling `get()` or `set()` on it. In this case, you can use this
+ method and `propertyDidChange()` instead. Calling these two methods
+ together will notify all observers that the property has potentially
+ changed value.
+
+ Note that you must always call `propertyWillChange` and `propertyDidChange`
+ as a pair. If you do not, it may get the property change groups out of
+ order and cause notifications to be delivered more often than you would
+ like.
+
+ @method propertyWillChange
+ @param {String} keyName The property key that is about to change.
+ @return {Ember.Observable}
+ */
+ propertyWillChange: function(keyName) {
+ propertyWillChange(this, keyName);
+ return this;
+ },
+
+ /**
+ Notify the observer system that a property has just changed.
+
+ Sometimes you need to change a value directly or indirectly without
+ actually calling `get()` or `set()` on it. In this case, you can use this
+ method and `propertyWillChange()` instead. Calling these two methods
+ together will notify all observers that the property has potentially
+ changed value.
+
+ Note that you must always call `propertyWillChange` and `propertyDidChange`
+ as a pair. If you do not, it may get the property change groups out of
+ order and cause notifications to be delivered more often than you would
+ like.
+
+ @method propertyDidChange
+ @param {String} keyName The property key that has just changed.
+ @return {Ember.Observable}
+ */
+ propertyDidChange: function(keyName) {
+ propertyDidChange(this, keyName);
+ return this;
+ },
+
+ /**
+ Convenience method to call `propertyWillChange` and `propertyDidChange` in
+ succession.
+
+ @method notifyPropertyChange
+ @param {String} keyName The property key to be notified about.
+ @return {Ember.Observable}
+ */
+ notifyPropertyChange: function(keyName) {
+ this.propertyWillChange(keyName);
+ this.propertyDidChange(keyName);
+ return this;
+ },
+
+ addBeforeObserver: function(key, target, method) {
+ Ember.deprecate('Before observers are deprecated and will be removed in a future release. If you want to keep track of previous values you have to implement it yourself.', false, { url: 'http://emberjs.com/guides/deprecations/#toc_deprecate-beforeobservers' });
+ addBeforeObserver(this, key, target, method);
+ },
+
+ /**
+ Adds an observer on a property.
+
+ This is the core method used to register an observer for a property.
+
+ Once you call this method, any time the key's value is set, your observer
+ will be notified. Note that the observers are triggered any time the
+ value is set, regardless of whether it has actually changed. Your
+ observer should be prepared to handle that.
+
+ You can also pass an optional context parameter to this method. The
+ context will be passed to your observer method whenever it is triggered.
+ Note that if you add the same target/method pair on a key multiple times
+ with different context parameters, your observer will only be called once
+ with the last context you passed.
+
+ ### Observer Methods
+
+ Observer methods you pass should generally have the following signature if
+ you do not pass a `context` parameter:
+
+ ```javascript
+ fooDidChange: function(sender, key, value, rev) { };
+ ```
+
+ The sender is the object that changed. The key is the property that
+ changes. The value property is currently reserved and unused. The rev
+ is the last property revision of the object when it changed, which you can
+ use to detect if the key value has really changed or not.
+
+ If you pass a `context` parameter, the context will be passed before the
+ revision like so:
+
+ ```javascript
+ fooDidChange: function(sender, key, value, context, rev) { };
+ ```
+
+ Usually you will not need the value, context or revision parameters at
+ the end. In this case, it is common to write observer methods that take
+ only a sender and key value as parameters or, if you aren't interested in
+ any of these values, to write an observer that has no parameters at all.
+
+ @method addObserver
+ @param {String} key The key to observer
+ @param {Object} target The target object to invoke
+ @param {String|Function} method The method to invoke.
+ */
+ addObserver: function(key, target, method) {
+ addObserver(this, key, target, method);
+ },
+
+ /**
+ Remove an observer you have previously registered on this object. Pass
+ the same key, target, and method you passed to `addObserver()` and your
+ target will no longer receive notifications.
+
+ @method removeObserver
+ @param {String} key The key to observer
+ @param {Object} target The target object to invoke
+ @param {String|Function} method The method to invoke.
+ */
+ removeObserver: function(key, target, method) {
+ removeObserver(this, key, target, method);
+ },
+
+ /**
+ Returns `true` if the object currently has observers registered for a
+ particular key. You can use this method to potentially defer performing
+ an expensive action until someone begins observing a particular property
+ on the object.
+
+ @method hasObserverFor
+ @param {String} key Key to check
+ @return {Boolean}
+ */
+ hasObserverFor: function(key) {
+ return hasListeners(this, key+':change');
+ },
+
+ /**
+ Retrieves the value of a property, or a default value in the case that the
+ property returns `undefined`.
+
+ ```javascript
+ person.getWithDefault('lastName', 'Doe');
+ ```
+
+ @method getWithDefault
+ @param {String} keyName The name of the property to retrieve
+ @param {Object} defaultValue The value to return if the property value is undefined
+ @return {Object} The property value or the defaultValue.
+ */
+ getWithDefault: function(keyName, defaultValue) {
+ return getWithDefault(this, keyName, defaultValue);
+ },
+
+ /**
+ Set the value of a property to the current value plus some amount.
+
+ ```javascript
+ person.incrementProperty('age');
+ team.incrementProperty('score', 2);
+ ```
+
+ @method incrementProperty
+ @param {String} keyName The name of the property to increment
+ @param {Number} increment The amount to increment by. Defaults to 1
+ @return {Number} The new property value
+ */
+ incrementProperty: function(keyName, increment) {
+ if (isNone(increment)) { increment = 1; }
+ Ember.assert("Must pass a numeric value to incrementProperty", (!isNaN(parseFloat(increment)) && isFinite(increment)));
+ set(this, keyName, (parseFloat(get(this, keyName)) || 0) + increment);
+ return get(this, keyName);
+ },
+
+ /**
+ Set the value of a property to the current value minus some amount.
+
+ ```javascript
+ player.decrementProperty('lives');
+ orc.decrementProperty('health', 5);
+ ```
+
+ @method decrementProperty
+ @param {String} keyName The name of the property to decrement
+ @param {Number} decrement The amount to decrement by. Defaults to 1
+ @return {Number} The new property value
+ */
+ decrementProperty: function(keyName, decrement) {
+ if (isNone(decrement)) { decrement = 1; }
+ Ember.assert("Must pass a numeric value to decrementProperty", (!isNaN(parseFloat(decrement)) && isFinite(decrement)));
+ set(this, keyName, (get(this, keyName) || 0) - decrement);
+ return get(this, keyName);
+ },
+
+ /**
+ Set the value of a boolean property to the opposite of its
+ current value.
+
+ ```javascript
+ starship.toggleProperty('warpDriveEngaged');
+ ```
+
+ @method toggleProperty
+ @param {String} keyName The name of the property to toggle
+ @return {Object} The new property value
+ */
+ toggleProperty: function(keyName) {
+ set(this, keyName, !get(this, keyName));
+ return get(this, keyName);
+ },
+
+ /**
+ Returns the cached value of a computed property, if it exists.
+ This allows you to inspect the value of a computed property
+ without accidentally invoking it if it is intended to be
+ generated lazily.
+
+ @method cacheFor
+ @param {String} keyName
+ @return {Object} The cached value of the computed property, if any
+ */
+ cacheFor: function(keyName) {
+ return cacheFor(this, keyName);
+ },
+
+ // intended for debugging purposes
+ observersForKey: function(keyName) {
+ return observersFor(this, keyName);
+ }
+ });
+ });
+enifed("ember-runtime/mixins/promise_proxy",
+ ["ember-metal/property_get","ember-metal/set_properties","ember-metal/computed","ember-metal/mixin","ember-metal/error","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+ "use strict";
+ var get = __dependency1__.get;
+ var setProperties = __dependency2__["default"];
+ var computed = __dependency3__.computed;
+ var Mixin = __dependency4__.Mixin;
+ var EmberError = __dependency5__["default"];
+
+ var not = computed.not;
+ var or = computed.or;
+
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ function tap(proxy, promise) {
+ setProperties(proxy, {
+ isFulfilled: false,
+ isRejected: false
+ });
+
+ return promise.then(function(value) {
+ setProperties(proxy, {
+ content: value,
+ isFulfilled: true
+ });
+ return value;
+ }, function(reason) {
+ setProperties(proxy, {
+ reason: reason,
+ isRejected: true
+ });
+ throw reason;
+ }, "Ember: PromiseProxy");
+ }
+
+ /**
+ A low level mixin making ObjectProxy, ObjectController or ArrayController's promise aware.
+
+ ```javascript
+ var ObjectPromiseController = Ember.ObjectController.extend(Ember.PromiseProxyMixin);
+
+ var controller = ObjectPromiseController.create({
+ promise: $.getJSON('/some/remote/data.json')
+ });
+
+ controller.then(function(json){
+ // the json
+ }, function(reason) {
+ // the reason why you have no json
+ });
+ ```
+
+ the controller has bindable attributes which
+ track the promises life cycle
+
+ ```javascript
+ controller.get('isPending') //=> true
+ controller.get('isSettled') //=> false
+ controller.get('isRejected') //=> false
+ controller.get('isFulfilled') //=> false
+ ```
+
+ When the the $.getJSON completes, and the promise is fulfilled
+ with json, the life cycle attributes will update accordingly.
+
+ ```javascript
+ controller.get('isPending') //=> false
+ controller.get('isSettled') //=> true
+ controller.get('isRejected') //=> false
+ controller.get('isFulfilled') //=> true
+ ```
+
+ As the controller is an ObjectController, and the json now its content,
+ all the json properties will be available directly from the controller.
+
+ ```javascript
+ // Assuming the following json:
+ {
+ firstName: 'Stefan',
+ lastName: 'Penner'
+ }
+
+ // both properties will accessible on the controller
+ controller.get('firstName') //=> 'Stefan'
+ controller.get('lastName') //=> 'Penner'
+ ```
+
+ If the controller is backing a template, the attributes are
+ bindable from within that template
+
+ ```handlebars
+ {{#if isPending}}
+ loading...
+ {{else}}
+ firstName: {{firstName}}
+ lastName: {{lastName}}
+ {{/if}}
+ ```
+ @class Ember.PromiseProxyMixin
+ */
+ __exports__["default"] = Mixin.create({
+ /**
+ If the proxied promise is rejected this will contain the reason
+ provided.
+
+ @property reason
+ @default null
+ */
+ reason: null,
+
+ /**
+ Once the proxied promise has settled this will become `false`.
+
+ @property isPending
+ @default true
+ */
+ isPending: not('isSettled').readOnly(),
+
+ /**
+ Once the proxied promise has settled this will become `true`.
+
+ @property isSettled
+ @default false
+ */
+ isSettled: or('isRejected', 'isFulfilled').readOnly(),
+
+ /**
+ Will become `true` if the proxied promise is rejected.
+
+ @property isRejected
+ @default false
+ */
+ isRejected: false,
+
+ /**
+ Will become `true` if the proxied promise is fulfilled.
+
+ @property isFulfilled
+ @default false
+ */
+ isFulfilled: false,
+
+ /**
+ The promise whose fulfillment value is being proxied by this object.
+
+ This property must be specified upon creation, and should not be
+ changed once created.
+
+ Example:
+
+ ```javascript
+ Ember.ObjectController.extend(Ember.PromiseProxyMixin).create({
+ promise:
+ });
+ ```
+
+ @property promise
+ */
+ promise: computed(function(key, promise) {
+ if (arguments.length === 2) {
+ return tap(this, promise);
+ } else {
+ throw new EmberError("PromiseProxy's promise must be set");
+ }
+ }),
+
+ /**
+ An alias to the proxied promise's `then`.
+
+ See RSVP.Promise.then.
+
+ @method then
+ @param {Function} callback
+ @return {RSVP.Promise}
+ */
+ then: promiseAlias('then'),
+
+ /**
+ An alias to the proxied promise's `catch`.
+
+ See RSVP.Promise.catch.
+
+ @method catch
+ @param {Function} callback
+ @return {RSVP.Promise}
+ @since 1.3.0
+ */
+ 'catch': promiseAlias('catch'),
+
+ /**
+ An alias to the proxied promise's `finally`.
+
+ See RSVP.Promise.finally.
+
+ @method finally
+ @param {Function} callback
+ @return {RSVP.Promise}
+ @since 1.3.0
+ */
+ 'finally': promiseAlias('finally')
+
+ });
+
+ function promiseAlias(name) {
+ return function () {
+ var promise = get(this, 'promise');
+ return promise[name].apply(promise, arguments);
+ };
+ }
+ });
+enifed("ember-runtime/mixins/sortable",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/enumerable_utils","ember-metal/mixin","ember-runtime/mixins/mutable_enumerable","ember-runtime/compare","ember-metal/observer","ember-metal/computed","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ var Ember = __dependency1__["default"];
+ // Ember.assert, Ember.A
+
+ var get = __dependency2__.get;
+ var forEach = __dependency3__.forEach;
+ var Mixin = __dependency4__.Mixin;
+ var MutableEnumerable = __dependency5__["default"];
+ var compare = __dependency6__["default"];
+ var addObserver = __dependency7__.addObserver;
+ var removeObserver = __dependency7__.removeObserver;
+ var computed = __dependency8__.computed;
+ var beforeObserver = __dependency4__.beforeObserver;
+ var observer = __dependency4__.observer;
+ //ES6TODO: should we access these directly from their package or from how their exposed in ember-metal?
+
+ /**
+ `Ember.SortableMixin` provides a standard interface for array proxies
+ to specify a sort order and maintain this sorting when objects are added,
+ removed, or updated without changing the implicit order of their underlying
+ model array:
+
+ ```javascript
+ songs = [
+ {trackNumber: 4, title: 'Ob-La-Di, Ob-La-Da'},
+ {trackNumber: 2, title: 'Back in the U.S.S.R.'},
+ {trackNumber: 3, title: 'Glass Onion'},
+ ];
+
+ songsController = Ember.ArrayController.create({
+ model: songs,
+ sortProperties: ['trackNumber'],
+ sortAscending: true
+ });
+
+ songsController.get('firstObject'); // {trackNumber: 2, title: 'Back in the U.S.S.R.'}
+
+ songsController.addObject({trackNumber: 1, title: 'Dear Prudence'});
+ songsController.get('firstObject'); // {trackNumber: 1, title: 'Dear Prudence'}
+ ```
+
+ If you add or remove the properties to sort by or change the sort direction the model
+ sort order will be automatically updated.
+
+ ```javascript
+ songsController.set('sortProperties', ['title']);
+ songsController.get('firstObject'); // {trackNumber: 2, title: 'Back in the U.S.S.R.'}
+
+ songsController.toggleProperty('sortAscending');
+ songsController.get('firstObject'); // {trackNumber: 4, title: 'Ob-La-Di, Ob-La-Da'}
+ ```
+
+ `SortableMixin` works by sorting the `arrangedContent` array, which is the array that
+ `ArrayProxy` displays. Due to the fact that the underlying 'content' array is not changed, that
+ array will not display the sorted list:
+
+ ```javascript
+ songsController.get('content').get('firstObject'); // Returns the unsorted original content
+ songsController.get('firstObject'); // Returns the sorted content.
+ ```
+
+ Although the sorted content can also be accessed through the `arrangedContent` property,
+ it is preferable to use the proxied class and not the `arrangedContent` array directly.
+
+ @class SortableMixin
+ @namespace Ember
+ @uses Ember.MutableEnumerable
+ */
+ __exports__["default"] = Mixin.create(MutableEnumerable, {
+
+ /**
+ Specifies which properties dictate the `arrangedContent`'s sort order.
+
+ When specifying multiple properties the sorting will use properties
+ from the `sortProperties` array prioritized from first to last.
+
+ @property {Array} sortProperties
+ */
+ sortProperties: null,
+
+ /**
+ Specifies the `arrangedContent`'s sort direction.
+ Sorts the content in ascending order by default. Set to `false` to
+ use descending order.
+
+ @property {Boolean} sortAscending
+ @default true
+ */
+ sortAscending: true,
+
+ /**
+ The function used to compare two values. You can override this if you
+ want to do custom comparisons. Functions must be of the type expected by
+ Array#sort, i.e.,
+
+ * return 0 if the two parameters are equal,
+ * return a negative value if the first parameter is smaller than the second or
+ * return a positive value otherwise:
+
+ ```javascript
+ function(x, y) { // These are assumed to be integers
+ if (x === y)
+ return 0;
+ return x < y ? -1 : 1;
+ }
+ ```
+
+ @property sortFunction
+ @type {Function}
+ @default Ember.compare
+ */
+ sortFunction: compare,
+
+ orderBy: function(item1, item2) {
+ var result = 0;
+ var sortProperties = get(this, 'sortProperties');
+ var sortAscending = get(this, 'sortAscending');
+ var sortFunction = get(this, 'sortFunction');
+
+ Ember.assert("you need to define `sortProperties`", !!sortProperties);
+
+ forEach(sortProperties, function(propertyName) {
+ if (result === 0) {
+ result = sortFunction.call(this, get(item1, propertyName), get(item2, propertyName));
+ if ((result !== 0) && !sortAscending) {
+ result = (-1) * result;
+ }
+ }
+ }, this);
+
+ return result;
+ },
+
+ destroy: function() {
+ var content = get(this, 'content');
+ var sortProperties = get(this, 'sortProperties');
+
+ if (content && sortProperties) {
+ forEach(content, function(item) {
+ forEach(sortProperties, function(sortProperty) {
+ removeObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
+ }, this);
+ }, this);
+ }
+
+ return this._super();
+ },
+
+ isSorted: computed.notEmpty('sortProperties'),
+
+ /**
+ Overrides the default `arrangedContent` from `ArrayProxy` in order to sort by `sortFunction`.
+ Also sets up observers for each `sortProperty` on each item in the content Array.
+
+ @property arrangedContent
+ */
+ arrangedContent: computed('content', 'sortProperties.@each', function(key, value) {
+ var content = get(this, 'content');
+ var isSorted = get(this, 'isSorted');
+ var sortProperties = get(this, 'sortProperties');
+ var self = this;
+
+ if (content && isSorted) {
+ content = content.slice();
+ content.sort(function(item1, item2) {
+ return self.orderBy(item1, item2);
+ });
+ forEach(content, function(item) {
+ forEach(sortProperties, function(sortProperty) {
+ addObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
+ }, this);
+ }, this);
+ return Ember.A(content);
+ }
+
+ return content;
+ }),
+
+ _contentWillChange: beforeObserver('content', function() {
+ var content = get(this, 'content');
+ var sortProperties = get(this, 'sortProperties');
+
+ if (content && sortProperties) {
+ forEach(content, function(item) {
+ forEach(sortProperties, function(sortProperty) {
+ removeObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
+ }, this);
+ }, this);
+ }
+
+ this._super();
+ }),
+
+ sortPropertiesWillChange: beforeObserver('sortProperties', function() {
+ this._lastSortAscending = undefined;
+ }),
+
+ sortPropertiesDidChange: observer('sortProperties', function() {
+ this._lastSortAscending = undefined;
+ }),
+
+ sortAscendingWillChange: beforeObserver('sortAscending', function() {
+ this._lastSortAscending = get(this, 'sortAscending');
+ }),
+
+ sortAscendingDidChange: observer('sortAscending', function() {
+ if (this._lastSortAscending !== undefined && get(this, 'sortAscending') !== this._lastSortAscending) {
+ var arrangedContent = get(this, 'arrangedContent');
+ arrangedContent.reverseObjects();
+ }
+ }),
+
+ contentArrayWillChange: function(array, idx, removedCount, addedCount) {
+ var isSorted = get(this, 'isSorted');
+
+ if (isSorted) {
+ var arrangedContent = get(this, 'arrangedContent');
+ var removedObjects = array.slice(idx, idx+removedCount);
+ var sortProperties = get(this, 'sortProperties');
+
+ forEach(removedObjects, function(item) {
+ arrangedContent.removeObject(item);
+
+ forEach(sortProperties, function(sortProperty) {
+ removeObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
+ }, this);
+ }, this);
+ }
+
+ return this._super(array, idx, removedCount, addedCount);
+ },
+
+ contentArrayDidChange: function(array, idx, removedCount, addedCount) {
+ var isSorted = get(this, 'isSorted');
+ var sortProperties = get(this, 'sortProperties');
+
+ if (isSorted) {
+ var addedObjects = array.slice(idx, idx+addedCount);
+
+ forEach(addedObjects, function(item) {
+ this.insertItemSorted(item);
+
+ forEach(sortProperties, function(sortProperty) {
+ addObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange');
+ }, this);
+ }, this);
+ }
+
+ return this._super(array, idx, removedCount, addedCount);
+ },
+
+ insertItemSorted: function(item) {
+ var arrangedContent = get(this, 'arrangedContent');
+ var length = get(arrangedContent, 'length');
+
+ var idx = this._binarySearch(item, 0, length);
+ arrangedContent.insertAt(idx, item);
+ },
+
+ contentItemSortPropertyDidChange: function(item) {
+ var arrangedContent = get(this, 'arrangedContent');
+ var oldIndex = arrangedContent.indexOf(item);
+ var leftItem = arrangedContent.objectAt(oldIndex - 1);
+ var rightItem = arrangedContent.objectAt(oldIndex + 1);
+ var leftResult = leftItem && this.orderBy(item, leftItem);
+ var rightResult = rightItem && this.orderBy(item, rightItem);
+
+ if (leftResult < 0 || rightResult > 0) {
+ arrangedContent.removeObject(item);
+ this.insertItemSorted(item);
+ }
+ },
+
+ _binarySearch: function(item, low, high) {
+ var mid, midItem, res, arrangedContent;
+
+ if (low === high) {
+ return low;
+ }
+
+ arrangedContent = get(this, 'arrangedContent');
+
+ mid = low + Math.floor((high - low) / 2);
+ midItem = arrangedContent.objectAt(mid);
+
+ res = this.orderBy(midItem, item);
+
+ if (res < 0) {
+ return this._binarySearch(item, mid+1, high);
+ } else if (res > 0) {
+ return this._binarySearch(item, low, mid);
+ }
+
+ return mid;
+ }
+ });
+ });
+enifed("ember-runtime/mixins/target_action_support",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/mixin","ember-metal/computed","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+ var Ember = __dependency1__["default"];
+ // Ember.lookup, Ember.assert
+
+ var get = __dependency2__.get;
+ var typeOf = __dependency3__.typeOf;
+ var Mixin = __dependency4__.Mixin;
+ var computed = __dependency5__.computed;
+
+ /**
+ `Ember.TargetActionSupport` is a mixin that can be included in a class
+ to add a `triggerAction` method with semantics similar to the Handlebars
+ `{{action}}` helper. In normal Ember usage, the `{{action}}` helper is
+ usually the best choice. This mixin is most often useful when you are
+ doing more complex event handling in View objects.
+
+ See also `Ember.ViewTargetActionSupport`, which has
+ view-aware defaults for target and actionContext.
+
+ @class TargetActionSupport
+ @namespace Ember
+ @extends Ember.Mixin
+ */
+ var TargetActionSupport = Mixin.create({
+ target: null,
+ action: null,
+ actionContext: null,
+
+ targetObject: computed(function() {
+ var target = get(this, 'target');
+
+ if (typeOf(target) === "string") {
+ var value = get(this, target);
+ if (value === undefined) { value = get(Ember.lookup, target); }
+ return value;
+ } else {
+ return target;
+ }
+ }).property('target'),
+
+ actionContextObject: computed(function() {
+ var actionContext = get(this, 'actionContext');
+
+ if (typeOf(actionContext) === "string") {
+ var value = get(this, actionContext);
+ if (value === undefined) { value = get(Ember.lookup, actionContext); }
+ return value;
+ } else {
+ return actionContext;
+ }
+ }).property('actionContext'),
+
+ /**
+ Send an `action` with an `actionContext` to a `target`. The action, actionContext
+ and target will be retrieved from properties of the object. For example:
+
+ ```javascript
+ App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+ target: Ember.computed.alias('controller'),
+ action: 'save',
+ actionContext: Ember.computed.alias('context'),
+ click: function() {
+ this.triggerAction(); // Sends the `save` action, along with the current context
+ // to the current controller
+ }
+ });
+ ```
+
+ The `target`, `action`, and `actionContext` can be provided as properties of
+ an optional object argument to `triggerAction` as well.
+
+ ```javascript
+ App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+ click: function() {
+ this.triggerAction({
+ action: 'save',
+ target: this.get('controller'),
+ actionContext: this.get('context')
+ }); // Sends the `save` action, along with the current context
+ // to the current controller
+ }
+ });
+ ```
+
+ The `actionContext` defaults to the object you are mixing `TargetActionSupport` into.
+ But `target` and `action` must be specified either as properties or with the argument
+ to `triggerAction`, or a combination:
+
+ ```javascript
+ App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+ target: Ember.computed.alias('controller'),
+ click: function() {
+ this.triggerAction({
+ action: 'save'
+ }); // Sends the `save` action, along with a reference to `this`,
+ // to the current controller
+ }
+ });
+ ```
+
+ @method triggerAction
+ @param opts {Hash} (optional, with the optional keys action, target and/or actionContext)
+ @return {Boolean} true if the action was sent successfully and did not return false
+ */
+ triggerAction: function(opts) {
+ opts = opts || {};
+ var action = opts.action || get(this, 'action');
+ var target = opts.target || get(this, 'targetObject');
+ var actionContext = opts.actionContext;
+
+ function args(options, actionName) {
+ var ret = [];
+ if (actionName) { ret.push(actionName); }
+
+ return ret.concat(options);
+ }
+
+ if (typeof actionContext === 'undefined') {
+ actionContext = get(this, 'actionContextObject') || this;
+ }
+
+ if (target && action) {
+ var ret;
+
+ if (target.send) {
+ ret = target.send.apply(target, args(actionContext, action));
+ } else {
+ Ember.assert("The action '" + action + "' did not exist on " + target, typeof target[action] === 'function');
+ ret = target[action].apply(target, args(actionContext));
+ }
+
+ if (ret !== false) ret = true;
+
+ return ret;
+ } else {
+ return false;
+ }
+ }
+ });
+
+ __exports__["default"] = TargetActionSupport;
+ });
+enifed("ember-runtime/system/application",
+ ["ember-runtime/system/namespace","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var Namespace = __dependency1__["default"];
+
+ __exports__["default"] = Namespace.extend();
+ });
+enifed("ember-runtime/system/array_proxy",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/computed","ember-metal/mixin","ember-metal/property_events","ember-metal/error","ember-runtime/system/object","ember-runtime/mixins/mutable_array","ember-runtime/mixins/enumerable","ember-runtime/system/string","ember-metal/alias","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+ var get = __dependency2__.get;
+ var isArray = __dependency3__.isArray;
+ var apply = __dependency3__.apply;
+ var computed = __dependency4__.computed;
+ var beforeObserver = __dependency5__.beforeObserver;
+ var observer = __dependency5__.observer;
+ var beginPropertyChanges = __dependency6__.beginPropertyChanges;
+ var endPropertyChanges = __dependency6__.endPropertyChanges;
+ var EmberError = __dependency7__["default"];
+ var EmberObject = __dependency8__["default"];
+ var MutableArray = __dependency9__["default"];
+ var Enumerable = __dependency10__["default"];
+ var fmt = __dependency11__.fmt;
+ var alias = __dependency12__["default"];
+
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ var OUT_OF_RANGE_EXCEPTION = "Index out of range";
+ var EMPTY = [];
+
+ function K() { return this; }
+
+ /**
+ An ArrayProxy wraps any other object that implements `Ember.Array` and/or
+ `Ember.MutableArray,` forwarding all requests. This makes it very useful for
+ a number of binding use cases or other cases where being able to swap
+ out the underlying array is useful.
+
+ A simple example of usage:
+
+ ```javascript
+ var pets = ['dog', 'cat', 'fish'];
+ var ap = Ember.ArrayProxy.create({ content: Ember.A(pets) });
+
+ ap.get('firstObject'); // 'dog'
+ ap.set('content', ['amoeba', 'paramecium']);
+ ap.get('firstObject'); // 'amoeba'
+ ```
+
+ This class can also be useful as a layer to transform the contents of
+ an array, as they are accessed. This can be done by overriding
+ `objectAtContent`:
+
+ ```javascript
+ var pets = ['dog', 'cat', 'fish'];
+ var ap = Ember.ArrayProxy.create({
+ content: Ember.A(pets),
+ objectAtContent: function(idx) {
+ return this.get('content').objectAt(idx).toUpperCase();
+ }
+ });
+
+ ap.get('firstObject'); // . 'DOG'
+ ```
+
+ @class ArrayProxy
+ @namespace Ember
+ @extends Ember.Object
+ @uses Ember.MutableArray
+ */
+ var ArrayProxy = EmberObject.extend(MutableArray, {
+
+ /**
+ The content array. Must be an object that implements `Ember.Array` and/or
+ `Ember.MutableArray.`
+
+ @property content
+ @type Ember.Array
+ */
+ content: null,
+
+ /**
+ The array that the proxy pretends to be. In the default `ArrayProxy`
+ implementation, this and `content` are the same. Subclasses of `ArrayProxy`
+ can override this property to provide things like sorting and filtering.
+
+ @property arrangedContent
+ */
+ arrangedContent: alias('content'),
+
+ /**
+ Should actually retrieve the object at the specified index from the
+ content. You can override this method in subclasses to transform the
+ content item to something new.
+
+ This method will only be called if content is non-`null`.
+
+ @method objectAtContent
+ @param {Number} idx The index to retrieve.
+ @return {Object} the value or undefined if none found
+ */
+ objectAtContent: function(idx) {
+ return get(this, 'arrangedContent').objectAt(idx);
+ },
+
+ /**
+ Should actually replace the specified objects on the content array.
+ You can override this method in subclasses to transform the content item
+ into something new.
+
+ This method will only be called if content is non-`null`.
+
+ @method replaceContent
+ @param {Number} idx The starting index
+ @param {Number} amt The number of items to remove from the content.
+ @param {Array} objects Optional array of objects to insert or null if no
+ objects.
+ @return {void}
+ */
+ replaceContent: function(idx, amt, objects) {
+ get(this, 'content').replace(idx, amt, objects);
+ },
+
+ /**
+ Invoked when the content property is about to change. Notifies observers that the
+ entire array content will change.
+
+ @private
+ @method _contentWillChange
+ */
+ _contentWillChange: beforeObserver('content', function() {
+ this._teardownContent();
+ }),
+
+ _teardownContent: function() {
+ var content = get(this, 'content');
+
+ if (content) {
+ content.removeArrayObserver(this, {
+ willChange: 'contentArrayWillChange',
+ didChange: 'contentArrayDidChange'
+ });
+ }
+ },
+
+ /**
+ Override to implement content array `willChange` observer.
+
+ @method contentArrayWillChange
+
+ @param {Ember.Array} contentArray the content array
+ @param {Number} start starting index of the change
+ @param {Number} removeCount count of items removed
+ @param {Number} addCount count of items added
+
+ */
+ contentArrayWillChange: K,
+ /**
+ Override to implement content array `didChange` observer.
+
+ @method contentArrayDidChange
+
+ @param {Ember.Array} contentArray the content array
+ @param {Number} start starting index of the change
+ @param {Number} removeCount count of items removed
+ @param {Number} addCount count of items added
+ */
+ contentArrayDidChange: K,
+
+ /**
+ Invoked when the content property changes. Notifies observers that the
+ entire array content has changed.
+
+ @private
+ @method _contentDidChange
+ */
+ _contentDidChange: observer('content', function() {
+ var content = get(this, 'content');
+
+ Ember.assert("Can't set ArrayProxy's content to itself", content !== this);
+
+ this._setupContent();
+ }),
+
+ _setupContent: function() {
+ var content = get(this, 'content');
+
+ if (content) {
+ Ember.assert(fmt('ArrayProxy expects an Array or ' +
+ 'Ember.ArrayProxy, but you passed %@', [typeof content]),
+ isArray(content) || content.isDestroyed);
+
+ content.addArrayObserver(this, {
+ willChange: 'contentArrayWillChange',
+ didChange: 'contentArrayDidChange'
+ });
+ }
+ },
+
+ _arrangedContentWillChange: beforeObserver('arrangedContent', function() {
+ var arrangedContent = get(this, 'arrangedContent');
+ var len = arrangedContent ? get(arrangedContent, 'length') : 0;
+
+ this.arrangedContentArrayWillChange(this, 0, len, undefined);
+ this.arrangedContentWillChange(this);
+
+ this._teardownArrangedContent(arrangedContent);
+ }),
+
+ _arrangedContentDidChange: observer('arrangedContent', function() {
+ var arrangedContent = get(this, 'arrangedContent');
+ var len = arrangedContent ? get(arrangedContent, 'length') : 0;
+
+ Ember.assert("Can't set ArrayProxy's content to itself", arrangedContent !== this);
+
+ this._setupArrangedContent();
+
+ this.arrangedContentDidChange(this);
+ this.arrangedContentArrayDidChange(this, 0, undefined, len);
+ }),
+
+ _setupArrangedContent: function() {
+ var arrangedContent = get(this, 'arrangedContent');
+
+ if (arrangedContent) {
+ Ember.assert(fmt('ArrayProxy expects an Array or ' +
+ 'Ember.ArrayProxy, but you passed %@', [typeof arrangedContent]),
+ isArray(arrangedContent) || arrangedContent.isDestroyed);
+
+ arrangedContent.addArrayObserver(this, {
+ willChange: 'arrangedContentArrayWillChange',
+ didChange: 'arrangedContentArrayDidChange'
+ });
+ }
+ },
+
+ _teardownArrangedContent: function() {
+ var arrangedContent = get(this, 'arrangedContent');
+
+ if (arrangedContent) {
+ arrangedContent.removeArrayObserver(this, {
+ willChange: 'arrangedContentArrayWillChange',
+ didChange: 'arrangedContentArrayDidChange'
+ });
+ }
+ },
+
+ arrangedContentWillChange: K,
+ arrangedContentDidChange: K,
+
+ objectAt: function(idx) {
+ return get(this, 'content') && this.objectAtContent(idx);
+ },
+
+ length: computed(function() {
+ var arrangedContent = get(this, 'arrangedContent');
+ return arrangedContent ? get(arrangedContent, 'length') : 0;
+ // No dependencies since Enumerable notifies length of change
+ }),
+
+ _replace: function(idx, amt, objects) {
+ var content = get(this, 'content');
+ Ember.assert('The content property of '+ this.constructor + ' should be set before modifying it', content);
+ if (content) this.replaceContent(idx, amt, objects);
+ return this;
+ },
+
+ replace: function() {
+ if (get(this, 'arrangedContent') === get(this, 'content')) {
+ apply(this, this._replace, arguments);
+ } else {
+ throw new EmberError("Using replace on an arranged ArrayProxy is not allowed.");
+ }
+ },
+
+ _insertAt: function(idx, object) {
+ if (idx > get(this, 'content.length')) throw new EmberError(OUT_OF_RANGE_EXCEPTION);
+ this._replace(idx, 0, [object]);
+ return this;
+ },
+
+ insertAt: function(idx, object) {
+ if (get(this, 'arrangedContent') === get(this, 'content')) {
+ return this._insertAt(idx, object);
+ } else {
+ throw new EmberError("Using insertAt on an arranged ArrayProxy is not allowed.");
+ }
+ },
+
+ removeAt: function(start, len) {
+ if ('number' === typeof start) {
+ var content = get(this, 'content');
+ var arrangedContent = get(this, 'arrangedContent');
+ var indices = [];
+ var i;
+
+ if ((start < 0) || (start >= get(this, 'length'))) {
+ throw new EmberError(OUT_OF_RANGE_EXCEPTION);
+ }
+
+ if (len === undefined) len = 1;
+
+ // Get a list of indices in original content to remove
+ for (i=start; i 0 &&
+ indexOf(concatenatedProperties, keyName) >= 0) {
+ var baseValue = this[keyName];
+
+ if (baseValue) {
+ if ('function' === typeof baseValue.concat) {
+ value = baseValue.concat(value);
+ } else {
+ value = makeArray(baseValue).concat(value);
+ }
+ } else {
+ value = makeArray(value);
+ }
+ }
+
+ if (mergedProperties &&
+ mergedProperties.length &&
+ indexOf(mergedProperties, keyName) >= 0) {
+ var originalValue = this[keyName];
+
+ value = merge(originalValue, value);
+ }
+
+ if (desc) {
+ desc.set(this, keyName, value);
+ } else {
+ if (typeof this.setUnknownProperty === 'function' && !(keyName in this)) {
+ this.setUnknownProperty(keyName, value);
+ } else {
+
+ if (hasPropertyAccessors) {
+ defineProperty(this, keyName, null, value); // setup mandatory setter
+ } else {
+ this[keyName] = value;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ finishPartial(this, m);
+
+ var length = arguments.length;
+
+ if (length === 0) {
+ this.init();
+ } else if (length === 1) {
+ this.init(arguments[0]);
+ } else {
+ // v8 bug potentially incorrectly deopts this function: https://code.google.com/p/v8/issues/detail?id=3709
+ // we may want to keep this around till this ages out on mobile
+ var args = new Array(length);
+ for (var x = 0; x < length; x++) {
+ args[x] = arguments[x];
+ }
+ this.init.apply(this, args);
+ }
+
+ m.proto = proto;
+ finishChains(this);
+ sendEvent(this, 'init');
+ };
+
+ Class.toString = Mixin.prototype.toString;
+ Class.willReopen = function() {
+ if (wasApplied) {
+ Class.PrototypeMixin = Mixin.create(Class.PrototypeMixin);
+ }
+
+ wasApplied = false;
+ };
+ Class._initMixins = function(args) { initMixins = args; };
+ Class._initProperties = function(args) { initProperties = args; };
+
+ Class.proto = function() {
+ var superclass = Class.superclass;
+ if (superclass) { superclass.proto(); }
+
+ if (!wasApplied) {
+ wasApplied = true;
+ Class.PrototypeMixin.applyPartial(Class.prototype);
+ }
+
+ return this.prototype;
+ };
+
+ return Class;
+
+ }
+
+ /**
+ @class CoreObject
+ @namespace Ember
+ */
+ var CoreObject = makeCtor();
+ CoreObject.toString = function() { return "Ember.CoreObject"; };
+ CoreObject.PrototypeMixin = Mixin.create({
+ reopen: function() {
+ var length = arguments.length;
+ var args = new Array(length);
+ for (var i = 0; i < length; i++) {
+ args[i] = arguments[i];
+ }
+ applyMixin(this, args, true);
+ return this;
+ },
+
+ /**
+ An overridable method called when objects are instantiated. By default,
+ does nothing unless it is overridden during class definition.
+
+ Example:
+
+ ```javascript
+ App.Person = Ember.Object.extend({
+ init: function() {
+ alert('Name is ' + this.get('name'));
+ }
+ });
+
+ var steve = App.Person.create({
+ name: "Steve"
+ });
+
+ // alerts 'Name is Steve'.
+ ```
+
+ NOTE: If you do override `init` for a framework class like `Ember.View` or
+ `Ember.ArrayController`, be sure to call `this._super()` in your
+ `init` declaration! If you don't, Ember may not have an opportunity to
+ do important setup work, and you'll see strange behavior in your
+ application.
+
+ @method init
+ */
+ init: function() {},
+
+ /**
+ Defines the properties that will be concatenated from the superclass
+ (instead of overridden).
+
+ By default, when you extend an Ember class a property defined in
+ the subclass overrides a property with the same name that is defined
+ in the superclass. However, there are some cases where it is preferable
+ to build up a property's value by combining the superclass' property
+ value with the subclass' value. An example of this in use within Ember
+ is the `classNames` property of `Ember.View`.
+
+ Here is some sample code showing the difference between a concatenated
+ property and a normal one:
+
+ ```javascript
+ App.BarView = Ember.View.extend({
+ someNonConcatenatedProperty: ['bar'],
+ classNames: ['bar']
+ });
+
+ App.FooBarView = App.BarView.extend({
+ someNonConcatenatedProperty: ['foo'],
+ classNames: ['foo']
+ });
+
+ var fooBarView = App.FooBarView.create();
+ fooBarView.get('someNonConcatenatedProperty'); // ['foo']
+ fooBarView.get('classNames'); // ['ember-view', 'bar', 'foo']
+ ```
+
+ This behavior extends to object creation as well. Continuing the
+ above example:
+
+ ```javascript
+ var view = App.FooBarView.create({
+ someNonConcatenatedProperty: ['baz'],
+ classNames: ['baz']
+ })
+ view.get('someNonConcatenatedProperty'); // ['baz']
+ view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz']
+ ```
+ Adding a single property that is not an array will just add it in the array:
+
+ ```javascript
+ var view = App.FooBarView.create({
+ classNames: 'baz'
+ })
+ view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz']
+ ```
+
+ Using the `concatenatedProperties` property, we can tell Ember to mix the
+ content of the properties.
+
+ In `Ember.View` the `classNameBindings` and `attributeBindings` properties
+ are also concatenated, in addition to `classNames`.
+
+ This feature is available for you to use throughout the Ember object model,
+ although typical app developers are likely to use it infrequently. Since
+ it changes expectations about behavior of properties, you should properly
+ document its usage in each individual concatenated property (to not
+ mislead your users to think they can override the property in a subclass).
+
+ @property concatenatedProperties
+ @type Array
+ @default null
+ */
+ concatenatedProperties: null,
+
+ /**
+ Destroyed object property flag.
+
+ if this property is `true` the observers and bindings were already
+ removed by the effect of calling the `destroy()` method.
+
+ @property isDestroyed
+ @default false
+ */
+ isDestroyed: false,
+
+ /**
+ Destruction scheduled flag. The `destroy()` method has been called.
+
+ The object stays intact until the end of the run loop at which point
+ the `isDestroyed` flag is set.
+
+ @property isDestroying
+ @default false
+ */
+ isDestroying: false,
+
+ /**
+ Destroys an object by setting the `isDestroyed` flag and removing its
+ metadata, which effectively destroys observers and bindings.
+
+ If you try to set a property on a destroyed object, an exception will be
+ raised.
+
+ Note that destruction is scheduled for the end of the run loop and does not
+ happen immediately. It will set an isDestroying flag immediately.
+
+ @method destroy
+ @return {Ember.Object} receiver
+ */
+ destroy: function() {
+ if (this.isDestroying) { return; }
+ this.isDestroying = true;
+
+ schedule('actions', this, this.willDestroy);
+ schedule('destroy', this, this._scheduledDestroy);
+ return this;
+ },
+
+ /**
+ Override to implement teardown.
+
+ @method willDestroy
+ */
+ willDestroy: K,
+
+ /**
+ Invoked by the run loop to actually destroy the object. This is
+ scheduled for execution by the `destroy` method.
+
+ @private
+ @method _scheduledDestroy
+ */
+ _scheduledDestroy: function() {
+ if (this.isDestroyed) { return; }
+ destroy(this);
+ this.isDestroyed = true;
+ },
+
+ bind: function(to, from) {
+ if (!(from instanceof Binding)) { from = Binding.from(from); }
+ from.to(to).connect(this);
+ return from;
+ },
+
+ /**
+ Returns a string representation which attempts to provide more information
+ than Javascript's `toString` typically does, in a generic way for all Ember
+ objects.
+
+ ```javascript
+ App.Person = Em.Object.extend()
+ person = App.Person.create()
+ person.toString() //=> ""
+ ```
+
+ If the object's class is not defined on an Ember namespace, it will
+ indicate it is a subclass of the registered superclass:
+
+ ```javascript
+ Student = App.Person.extend()
+ student = Student.create()
+ student.toString() //=> "<(subclass of App.Person):ember1025>"
+ ```
+
+ If the method `toStringExtension` is defined, its return value will be
+ included in the output.
+
+ ```javascript
+ App.Teacher = App.Person.extend({
+ toStringExtension: function() {
+ return this.get('fullName');
+ }
+ });
+ teacher = App.Teacher.create()
+ teacher.toString(); //=> ""
+ ```
+
+ @method toString
+ @return {String} string representation
+ */
+ toString: function toString() {
+ var hasToStringExtension = typeof this.toStringExtension === 'function';
+ var extension = hasToStringExtension ? ":" + this.toStringExtension() : '';
+ var ret = '<'+this.constructor.toString()+':'+guidFor(this)+extension+'>';
+
+ this.toString = makeToString(ret);
+ return ret;
+ }
+ });
+
+ CoreObject.PrototypeMixin.ownerConstructor = CoreObject;
+
+ function makeToString(ret) {
+ return function() { return ret; };
+ }
+
+ CoreObject.__super__ = null;
+
+ var ClassMixinProps = {
+
+ ClassMixin: required(),
+
+ PrototypeMixin: required(),
+
+ isClass: true,
+
+ isMethod: false,
+
+ /**
+ Creates a new subclass.
+
+ ```javascript
+ App.Person = Ember.Object.extend({
+ say: function(thing) {
+ alert(thing);
+ }
+ });
+ ```
+
+ This defines a new subclass of Ember.Object: `App.Person`. It contains one method: `say()`.
+
+ You can also create a subclass from any existing class by calling its `extend()` method. For example, you might want to create a subclass of Ember's built-in `Ember.View` class:
+
+ ```javascript
+ App.PersonView = Ember.View.extend({
+ tagName: 'li',
+ classNameBindings: ['isAdministrator']
+ });
+ ```
+
+ When defining a subclass, you can override methods but still access the implementation of your parent class by calling the special `_super()` method:
+
+ ```javascript
+ App.Person = Ember.Object.extend({
+ say: function(thing) {
+ var name = this.get('name');
+ alert(name + ' says: ' + thing);
+ }
+ });
+
+ App.Soldier = App.Person.extend({
+ say: function(thing) {
+ this._super(thing + ", sir!");
+ },
+ march: function(numberOfHours) {
+ alert(this.get('name') + ' marches for ' + numberOfHours + ' hours.')
+ }
+ });
+
+ var yehuda = App.Soldier.create({
+ name: "Yehuda Katz"
+ });
+
+ yehuda.say("Yes"); // alerts "Yehuda Katz says: Yes, sir!"
+ ```
+
+ The `create()` on line #17 creates an *instance* of the `App.Soldier` class. The `extend()` on line #8 creates a *subclass* of `App.Person`. Any instance of the `App.Person` class will *not* have the `march()` method.
+
+ You can also pass `Mixin` classes to add additional properties to the subclass.
+
+ ```javascript
+ App.Person = Ember.Object.extend({
+ say: function(thing) {
+ alert(this.get('name') + ' says: ' + thing);
+ }
+ });
+
+ App.SingingMixin = Mixin.create({
+ sing: function(thing){
+ alert(this.get('name') + ' sings: la la la ' + thing);
+ }
+ });
+
+ App.BroadwayStar = App.Person.extend(App.SingingMixin, {
+ dance: function() {
+ alert(this.get('name') + ' dances: tap tap tap tap ');
+ }
+ });
+ ```
+
+ The `App.BroadwayStar` class contains three methods: `say()`, `sing()`, and `dance()`.
+
+ @method extend
+ @static
+
+ @param {Mixin} [mixins]* One or more Mixin classes
+ @param {Object} [arguments]* Object containing values to use within the new class
+ */
+ extend: function extend() {
+ var Class = makeCtor();
+ var proto;
+ Class.ClassMixin = Mixin.create(this.ClassMixin);
+ Class.PrototypeMixin = Mixin.create(this.PrototypeMixin);
+
+ Class.ClassMixin.ownerConstructor = Class;
+ Class.PrototypeMixin.ownerConstructor = Class;
+
+ reopen.apply(Class.PrototypeMixin, arguments);
+
+ Class.superclass = this;
+ Class.__super__ = this.prototype;
+
+ proto = Class.prototype = o_create(this.prototype);
+ proto.constructor = Class;
+ generateGuid(proto);
+ meta(proto).proto = proto; // this will disable observers on prototype
+
+ Class.ClassMixin.apply(Class);
+ return Class;
+ },
+
+ /**
+ Equivalent to doing `extend(arguments).create()`.
+ If possible use the normal `create` method instead.
+
+ @method createWithMixins
+ @static
+ @param [arguments]*
+ */
+ createWithMixins: function() {
+ var C = this;
+ var l= arguments.length;
+ if (l > 0) {
+ var args = new Array(l);
+ for (var i = 0; i < l; i++) {
+ args[i] = arguments[i];
+ }
+ this._initMixins(args);
+ }
+ return new C();
+ },
+
+ /**
+ Creates an instance of a class. Accepts either no arguments, or an object
+ containing values to initialize the newly instantiated object with.
+
+ ```javascript
+ App.Person = Ember.Object.extend({
+ helloWorld: function() {
+ alert("Hi, my name is " + this.get('name'));
+ }
+ });
+
+ var tom = App.Person.create({
+ name: 'Tom Dale'
+ });
+
+ tom.helloWorld(); // alerts "Hi, my name is Tom Dale".
+ ```
+
+ `create` will call the `init` function if defined during
+ `Ember.AnyObject.extend`
+
+ If no arguments are passed to `create`, it will not set values to the new
+ instance during initialization:
+
+ ```javascript
+ var noName = App.Person.create();
+ noName.helloWorld(); // alerts undefined
+ ```
+
+ NOTE: For performance reasons, you cannot declare methods or computed
+ properties during `create`. You should instead declare methods and computed
+ properties when using `extend` or use the `createWithMixins` shorthand.
+
+ @method create
+ @static
+ @param [arguments]*
+ */
+ create: function() {
+ var C = this;
+ var l = arguments.length;
+ if (l > 0) {
+ var args = new Array(l);
+ for (var i = 0; i < l; i++) {
+ args[i] = arguments[i];
+ }
+ this._initProperties(args);
+ }
+ return new C();
+ },
+
+ /**
+ Augments a constructor's prototype with additional
+ properties and functions:
+
+ ```javascript
+ MyObject = Ember.Object.extend({
+ name: 'an object'
+ });
+
+ o = MyObject.create();
+ o.get('name'); // 'an object'
+
+ MyObject.reopen({
+ say: function(msg){
+ console.log(msg);
+ }
+ })
+
+ o2 = MyObject.create();
+ o2.say("hello"); // logs "hello"
+
+ o.say("goodbye"); // logs "goodbye"
+ ```
+
+ To add functions and properties to the constructor itself,
+ see `reopenClass`
+
+ @method reopen
+ */
+ reopen: function() {
+ this.willReopen();
+
+ var l = arguments.length;
+ var args = new Array(l);
+ if (l > 0) {
+ for (var i = 0; i < l; i++) {
+ args[i] = arguments[i];
+ }
+ }
+
+ apply(this.PrototypeMixin, reopen, args);
+ return this;
+ },
+
+ /**
+ Augments a constructor's own properties and functions:
+
+ ```javascript
+ MyObject = Ember.Object.extend({
+ name: 'an object'
+ });
+
+ MyObject.reopenClass({
+ canBuild: false
+ });
+
+ MyObject.canBuild; // false
+ o = MyObject.create();
+ ```
+
+ In other words, this creates static properties and functions for the class. These are only available on the class
+ and not on any instance of that class.
+
+ ```javascript
+ App.Person = Ember.Object.extend({
+ name : "",
+ sayHello : function(){
+ alert("Hello. My name is " + this.get('name'));
+ }
+ });
+
+ App.Person.reopenClass({
+ species : "Homo sapiens",
+ createPerson: function(newPersonsName){
+ return App.Person.create({
+ name:newPersonsName
+ });
+ }
+ });
+
+ var tom = App.Person.create({
+ name : "Tom Dale"
+ });
+ var yehuda = App.Person.createPerson("Yehuda Katz");
+
+ tom.sayHello(); // "Hello. My name is Tom Dale"
+ yehuda.sayHello(); // "Hello. My name is Yehuda Katz"
+ alert(App.Person.species); // "Homo sapiens"
+ ```
+
+ Note that `species` and `createPerson` are *not* valid on the `tom` and `yehuda`
+ variables. They are only valid on `App.Person`.
+
+ To add functions and properties to instances of
+ a constructor by extending the constructor's prototype
+ see `reopen`
+
+ @method reopenClass
+ */
+ reopenClass: function() {
+ var l = arguments.length;
+ var args = new Array(l);
+ if (l > 0) {
+ for (var i = 0; i < l; i++) {
+ args[i] = arguments[i];
+ }
+ }
+
+ apply(this.ClassMixin, reopen, args);
+ applyMixin(this, arguments, false);
+ return this;
+ },
+
+ detect: function(obj) {
+ if ('function' !== typeof obj) { return false; }
+ while(obj) {
+ if (obj===this) { return true; }
+ obj = obj.superclass;
+ }
+ return false;
+ },
+
+ detectInstance: function(obj) {
+ return obj instanceof this;
+ },
+
+ /**
+ In some cases, you may want to annotate computed properties with additional
+ metadata about how they function or what values they operate on. For
+ example, computed property functions may close over variables that are then
+ no longer available for introspection.
+
+ You can pass a hash of these values to a computed property like this:
+
+ ```javascript
+ person: function() {
+ var personId = this.get('personId');
+ return App.Person.create({ id: personId });
+ }.property().meta({ type: App.Person })
+ ```
+
+ Once you've done this, you can retrieve the values saved to the computed
+ property from your class like this:
+
+ ```javascript
+ MyClass.metaForProperty('person');
+ ```
+
+ This will return the original hash that was passed to `meta()`.
+
+ @static
+ @method metaForProperty
+ @param key {String} property name
+ */
+ metaForProperty: function(key) {
+ var meta = this.proto()['__ember_meta__'];
+ var desc = meta && meta.descs[key];
+
+ Ember.assert("metaForProperty() could not find a computed property with key '"+key+"'.", !!desc && desc instanceof ComputedProperty);
+ return desc._meta || {};
+ },
+
+ _computedProperties: computed(function() {
+ hasCachedComputedProperties = true;
+ var proto = this.proto();
+ var descs = meta(proto).descs;
+ var property;
+ var properties = [];
+
+ for (var name in descs) {
+ property = descs[name];
+
+ if (property instanceof ComputedProperty) {
+ properties.push({
+ name: name,
+ meta: property._meta
+ });
+ }
+ }
+ return properties;
+ }).readOnly(),
+
+ /**
+ Iterate over each computed property for the class, passing its name
+ and any associated metadata (see `metaForProperty`) to the callback.
+
+ @static
+ @method eachComputedProperty
+ @param {Function} callback
+ @param {Object} binding
+ */
+ eachComputedProperty: function(callback, binding) {
+ var property, name;
+ var empty = {};
+
+ var properties = get(this, '_computedProperties');
+
+ for (var i = 0, length = properties.length; i < length; i++) {
+ property = properties[i];
+ name = property.name;
+ callback.call(binding || this, property.name, property.meta || empty);
+ }
+ }
+ };
+
+ function injectedPropertyAssertion() {
+ Ember.assert("Injected properties are invalid", validatePropertyInjections(this));
+ }
+
+ function addOnLookupHandler() {
+ Ember.runInDebug(function() {
+ /**
+ Provides lookup-time type validation for injected properties.
+
+ @private
+ @method _onLookup
+ */
+ ClassMixinProps._onLookup = injectedPropertyAssertion;
+ });
+ }
+
+
+ addOnLookupHandler();
+
+ /**
+ Returns a hash of property names and container names that injected
+ properties will lookup on the container lazily.
+
+ @method _lazyInjections
+ @return {Object} Hash of all lazy injected property keys to container names
+ */
+ ClassMixinProps._lazyInjections = function() {
+ var injections = {};
+ var proto = this.proto();
+ var descs = meta(proto).descs;
+ var key, desc;
+
+ for (key in descs) {
+ desc = descs[key];
+ if (desc instanceof InjectedProperty) {
+ injections[key] = desc.type + ':' + (desc.name || key);
+ }
+ }
+
+ return injections;
+ };
+
+
+ var ClassMixin = Mixin.create(ClassMixinProps);
+
+ ClassMixin.ownerConstructor = CoreObject;
+
+ CoreObject.ClassMixin = ClassMixin;
+
+ ClassMixin.apply(CoreObject);
+
+ CoreObject.reopen({
+ didDefineProperty: function(proto, key, value) {
+ if (hasCachedComputedProperties === false) { return; }
+ if (value instanceof Ember.ComputedProperty) {
+ var cache = Ember.meta(this.constructor).cache;
+
+ if (cache._computedProperties !== undefined) {
+ cache._computedProperties = undefined;
+ }
+ }
+ }
+ });
+
+ __exports__["default"] = CoreObject;
+ });
+enifed("ember-runtime/system/deferred",
+ ["ember-metal/core","ember-runtime/mixins/deferred","ember-runtime/system/object","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ var DeferredMixin = __dependency2__["default"];
+ var EmberObject = __dependency3__["default"];
+
+ var Deferred = EmberObject.extend(DeferredMixin, {
+ init: function() {
+ Ember.deprecate('Usage of Ember.Deferred is deprecated.', false, { url: 'http://emberjs.com/guides/deprecations/#toc_deprecate-ember-deferredmixin-and-ember-deferred' });
+ this._super();
+ }
+ });
+
+ Deferred.reopenClass({
+ promise: function(callback, binding) {
+ var deferred = Deferred.create();
+ callback.call(binding, deferred);
+ return deferred;
+ }
+ });
+
+ __exports__["default"] = Deferred;
+ });
+enifed("ember-runtime/system/each_proxy",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/enumerable_utils","ember-metal/array","ember-runtime/mixins/array","ember-runtime/system/object","ember-metal/computed","ember-metal/observer","ember-metal/events","ember-metal/properties","ember-metal/property_events","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+
+ var get = __dependency2__.get;
+ var guidFor = __dependency3__.guidFor;
+ var forEach = __dependency4__.forEach;
+ var indexOf = __dependency5__.indexOf;
+ var EmberArray = __dependency6__["default"];
+ // ES6TODO: WAT? Circular dep?
+ var EmberObject = __dependency7__["default"];
+ var computed = __dependency8__.computed;
+ var addObserver = __dependency9__.addObserver;
+ var addBeforeObserver = __dependency9__.addBeforeObserver;
+ var removeBeforeObserver = __dependency9__.removeBeforeObserver;
+ var removeObserver = __dependency9__.removeObserver;
+ var typeOf = __dependency3__.typeOf;
+ var watchedEvents = __dependency10__.watchedEvents;
+ var defineProperty = __dependency11__.defineProperty;
+ var beginPropertyChanges = __dependency12__.beginPropertyChanges;
+ var propertyDidChange = __dependency12__.propertyDidChange;
+ var propertyWillChange = __dependency12__.propertyWillChange;
+ var endPropertyChanges = __dependency12__.endPropertyChanges;
+ var changeProperties = __dependency12__.changeProperties;
+
+ var EachArray = EmberObject.extend(EmberArray, {
+
+ init: function(content, keyName, owner) {
+ this._super();
+ this._keyName = keyName;
+ this._owner = owner;
+ this._content = content;
+ },
+
+ objectAt: function(idx) {
+ var item = this._content.objectAt(idx);
+ return item && get(item, this._keyName);
+ },
+
+ length: computed(function() {
+ var content = this._content;
+ return content ? get(content, 'length') : 0;
+ })
+
+ });
+
+ var IS_OBSERVER = /^.+:(before|change)$/;
+
+ function addObserverForContentKey(content, keyName, proxy, idx, loc) {
+ var objects = proxy._objects;
+ var guid;
+ if (!objects) objects = proxy._objects = {};
+
+ while(--loc>=idx) {
+ var item = content.objectAt(loc);
+ if (item) {
+ Ember.assert('When using @each to observe the array ' + content + ', the array must return an object', typeOf(item) === 'instance' || typeOf(item) === 'object');
+ addBeforeObserver(item, keyName, proxy, 'contentKeyWillChange');
+ addObserver(item, keyName, proxy, 'contentKeyDidChange');
+
+ // keep track of the index each item was found at so we can map
+ // it back when the obj changes.
+ guid = guidFor(item);
+ if (!objects[guid]) objects[guid] = [];
+ objects[guid].push(loc);
+ }
+ }
+ }
+
+ function removeObserverForContentKey(content, keyName, proxy, idx, loc) {
+ var objects = proxy._objects;
+ if (!objects) objects = proxy._objects = {};
+ var indicies, guid;
+
+ while(--loc>=idx) {
+ var item = content.objectAt(loc);
+ if (item) {
+ removeBeforeObserver(item, keyName, proxy, 'contentKeyWillChange');
+ removeObserver(item, keyName, proxy, 'contentKeyDidChange');
+
+ guid = guidFor(item);
+ indicies = objects[guid];
+ indicies[indexOf.call(indicies, loc)] = null;
+ }
+ }
+ }
+
+ /**
+ This is the object instance returned when you get the `@each` property on an
+ array. It uses the unknownProperty handler to automatically create
+ EachArray instances for property names.
+
+ @private
+ @class EachProxy
+ @namespace Ember
+ @extends Ember.Object
+ */
+ var EachProxy = EmberObject.extend({
+
+ init: function(content) {
+ this._super();
+ this._content = content;
+ content.addArrayObserver(this);
+
+ // in case someone is already observing some keys make sure they are
+ // added
+ forEach(watchedEvents(this), function(eventName) {
+ this.didAddListener(eventName);
+ }, this);
+ },
+
+ /**
+ You can directly access mapped properties by simply requesting them.
+ The `unknownProperty` handler will generate an EachArray of each item.
+
+ @method unknownProperty
+ @param keyName {String}
+ @param value {*}
+ */
+ unknownProperty: function(keyName, value) {
+ var ret;
+ ret = new EachArray(this._content, keyName, this);
+ defineProperty(this, keyName, null, ret);
+ this.beginObservingContentKey(keyName);
+ return ret;
+ },
+
+ // ..........................................................
+ // ARRAY CHANGES
+ // Invokes whenever the content array itself changes.
+
+ arrayWillChange: function(content, idx, removedCnt, addedCnt) {
+ var keys = this._keys;
+ var key, lim;
+
+ lim = removedCnt>0 ? idx+removedCnt : -1;
+ beginPropertyChanges(this);
+
+ for(key in keys) {
+ if (!keys.hasOwnProperty(key)) { continue; }
+
+ if (lim>0) { removeObserverForContentKey(content, key, this, idx, lim); }
+
+ propertyWillChange(this, key);
+ }
+
+ propertyWillChange(this._content, '@each');
+ endPropertyChanges(this);
+ },
+
+ arrayDidChange: function(content, idx, removedCnt, addedCnt) {
+ var keys = this._keys;
+ var lim;
+
+ lim = addedCnt>0 ? idx+addedCnt : -1;
+ changeProperties(function() {
+ for(var key in keys) {
+ if (!keys.hasOwnProperty(key)) { continue; }
+
+ if (lim>0) { addObserverForContentKey(content, key, this, idx, lim); }
+
+ propertyDidChange(this, key);
+ }
+
+ propertyDidChange(this._content, '@each');
+ }, this);
+ },
+
+ // ..........................................................
+ // LISTEN FOR NEW OBSERVERS AND OTHER EVENT LISTENERS
+ // Start monitoring keys based on who is listening...
+
+ didAddListener: function(eventName) {
+ if (IS_OBSERVER.test(eventName)) {
+ this.beginObservingContentKey(eventName.slice(0, -7));
+ }
+ },
+
+ didRemoveListener: function(eventName) {
+ if (IS_OBSERVER.test(eventName)) {
+ this.stopObservingContentKey(eventName.slice(0, -7));
+ }
+ },
+
+ // ..........................................................
+ // CONTENT KEY OBSERVING
+ // Actual watch keys on the source content.
+
+ beginObservingContentKey: function(keyName) {
+ var keys = this._keys;
+ if (!keys) keys = this._keys = {};
+ if (!keys[keyName]) {
+ keys[keyName] = 1;
+ var content = this._content;
+ var len = get(content, 'length');
+
+ addObserverForContentKey(content, keyName, this, 0, len);
+ } else {
+ keys[keyName]++;
+ }
+ },
+
+ stopObservingContentKey: function(keyName) {
+ var keys = this._keys;
+ if (keys && (keys[keyName]>0) && (--keys[keyName]<=0)) {
+ var content = this._content;
+ var len = get(content, 'length');
+
+ removeObserverForContentKey(content, keyName, this, 0, len);
+ }
+ },
+
+ contentKeyWillChange: function(obj, keyName) {
+ propertyWillChange(this, keyName);
+ },
+
+ contentKeyDidChange: function(obj, keyName) {
+ propertyDidChange(this, keyName);
+ }
+ });
+
+ __exports__.EachArray = EachArray;
+ __exports__.EachProxy = EachProxy;
+ });
+enifed("ember-runtime/system/lazy_load",
+ ["ember-metal/core","ember-metal/array","ember-runtime/system/native_array","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ /*globals CustomEvent */
+
+ var Ember = __dependency1__["default"];
+ // Ember.ENV.EMBER_LOAD_HOOKS
+ var forEach = __dependency2__.forEach;
+ // make sure Ember.A is setup.
+
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ var loadHooks = Ember.ENV.EMBER_LOAD_HOOKS || {};
+ var loaded = {};
+
+ /**
+ Detects when a specific package of Ember (e.g. 'Ember.Handlebars')
+ 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) {
+ hbars.registerHelper(...);
+ });
+ ```
+
+ @method onLoad
+ @for Ember
+ @param name {String} name of hook
+ @param callback {Function} callback to be called
+ */
+ function onLoad(name, callback) {
+ var object;
+
+ loadHooks[name] = loadHooks[name] || Ember.A();
+ loadHooks[name].pushObject(callback);
+
+ if (object = loaded[name]) {
+ callback(object);
+ }
+ }
+
+ __exports__.onLoad = onLoad;/**
+ Called when an Ember.js package (e.g Ember.Handlebars) has finished
+ loading. Triggers any callbacks registered for this event.
+
+ @method runLoadHooks
+ @for Ember
+ @param name {String} name of hook
+ @param object {Object} object to pass to callbacks
+ */
+ function runLoadHooks(name, object) {
+ loaded[name] = object;
+
+ if (typeof window === 'object' && typeof window.dispatchEvent === 'function' && typeof CustomEvent === "function") {
+ var event = new CustomEvent(name, {detail: object, name: name});
+ window.dispatchEvent(event);
+ }
+
+ if (loadHooks[name]) {
+ forEach.call(loadHooks[name], function(callback) {
+ callback(object);
+ });
+ }
+ }
+
+ __exports__.runLoadHooks = runLoadHooks;
+ });
+enifed("ember-runtime/system/namespace",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/array","ember-metal/utils","ember-metal/mixin","ember-runtime/system/object","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ // Ember.lookup, Ember.BOOTED, Ember.deprecate, Ember.NAME_KEY, Ember.anyUnprocessedMixins
+ var Ember = __dependency1__["default"];
+ var get = __dependency2__.get;
+ var indexOf = __dependency3__.indexOf;
+ var GUID_KEY = __dependency4__.GUID_KEY;
+ var guidFor = __dependency4__.guidFor;
+ var Mixin = __dependency5__.Mixin;
+
+ var EmberObject = __dependency6__["default"];
+
+ /**
+ A Namespace is an object usually used to contain other objects or methods
+ such as an application or framework. Create a namespace anytime you want
+ to define one of these new containers.
+
+ # Example Usage
+
+ ```javascript
+ MyFramework = Ember.Namespace.create({
+ VERSION: '1.0.0'
+ });
+ ```
+
+ @class Namespace
+ @namespace Ember
+ @extends Ember.Object
+ */
+ var Namespace = EmberObject.extend({
+ isNamespace: true,
+
+ init: function() {
+ Namespace.NAMESPACES.push(this);
+ Namespace.PROCESSED = false;
+ },
+
+ toString: function() {
+ var name = get(this, 'name') || get(this, 'modulePrefix');
+ if (name) { return name; }
+
+ findNamespaces();
+ return this[NAME_KEY];
+ },
+
+ nameClasses: function() {
+ processNamespace([this.toString()], this, {});
+ },
+
+ destroy: function() {
+ var namespaces = Namespace.NAMESPACES;
+ var toString = this.toString();
+
+ if (toString) {
+ Ember.lookup[toString] = undefined;
+ delete Namespace.NAMESPACES_BY_ID[toString];
+ }
+ namespaces.splice(indexOf.call(namespaces, this), 1);
+ this._super();
+ }
+ });
+
+ Namespace.reopenClass({
+ NAMESPACES: [Ember],
+ NAMESPACES_BY_ID: {},
+ PROCESSED: false,
+ processAll: processAllNamespaces,
+ byName: function(name) {
+ if (!Ember.BOOTED) {
+ processAllNamespaces();
+ }
+
+ return NAMESPACES_BY_ID[name];
+ }
+ });
+
+ var NAMESPACES_BY_ID = Namespace.NAMESPACES_BY_ID;
+
+ var hasOwnProp = ({}).hasOwnProperty;
+
+ function processNamespace(paths, root, seen) {
+ var idx = paths.length;
+
+ NAMESPACES_BY_ID[paths.join('.')] = root;
+
+ // Loop over all of the keys in the namespace, looking for classes
+ for(var key in root) {
+ if (!hasOwnProp.call(root, key)) { continue; }
+ var obj = root[key];
+
+ // If we are processing the `Ember` namespace, for example, the
+ // `paths` will start with `["Ember"]`. Every iteration through
+ // the loop will update the **second** element of this list with
+ // the key, so processing `Ember.View` will make the Array
+ // `['Ember', 'View']`.
+ paths[idx] = key;
+
+ // If we have found an unprocessed class
+ if (obj && obj.toString === classToString) {
+ // Replace the class' `toString` with the dot-separated path
+ // and set its `NAME_KEY`
+ obj.toString = makeToString(paths.join('.'));
+ obj[NAME_KEY] = paths.join('.');
+
+ // Support nested namespaces
+ } else if (obj && obj.isNamespace) {
+ // Skip aliased namespaces
+ if (seen[guidFor(obj)]) { continue; }
+ seen[guidFor(obj)] = true;
+
+ // Process the child namespace
+ processNamespace(paths, obj, seen);
+ }
+ }
+
+ paths.length = idx; // cut out last item
+ }
+
+ var STARTS_WITH_UPPERCASE = /^[A-Z]/;
+
+ function tryIsNamespace(lookup, prop) {
+ try {
+ var obj = lookup[prop];
+ return obj && obj.isNamespace && obj;
+ } catch (e) {
+ // continue
+ }
+ }
+
+ function findNamespaces() {
+ var lookup = Ember.lookup;
+ var obj;
+
+ if (Namespace.PROCESSED) { return; }
+
+ for (var prop in lookup) {
+ // Only process entities that start with uppercase A-Z
+ if (!STARTS_WITH_UPPERCASE.test(prop)) { continue; }
+
+ // Unfortunately, some versions of IE don't support window.hasOwnProperty
+ if (lookup.hasOwnProperty && !lookup.hasOwnProperty(prop)) { continue; }
+
+ // At times we are not allowed to access certain properties for security reasons.
+ // There are also times where even if we can access them, we are not allowed to access their properties.
+ obj = tryIsNamespace(lookup, prop);
+ if (obj) {
+ obj[NAME_KEY] = prop;
+ }
+ }
+ }
+
+ var NAME_KEY = Ember.NAME_KEY = GUID_KEY + '_name';
+
+ function superClassString(mixin) {
+ var superclass = mixin.superclass;
+ if (superclass) {
+ if (superclass[NAME_KEY]) { return superclass[NAME_KEY]; }
+ else { return superClassString(superclass); }
+ } else {
+ return;
+ }
+ }
+
+ function classToString() {
+ if (!Ember.BOOTED && !this[NAME_KEY]) {
+ processAllNamespaces();
+ }
+
+ var ret;
+
+ if (this[NAME_KEY]) {
+ ret = this[NAME_KEY];
+ } else if (this._toString) {
+ ret = this._toString;
+ } else {
+ var str = superClassString(this);
+ if (str) {
+ ret = "(subclass of " + str + ")";
+ } else {
+ ret = "(unknown mixin)";
+ }
+ this.toString = makeToString(ret);
+ }
+
+ return ret;
+ }
+
+ function processAllNamespaces() {
+ var unprocessedNamespaces = !Namespace.PROCESSED;
+ var unprocessedMixins = Ember.anyUnprocessedMixins;
+
+ if (unprocessedNamespaces) {
+ findNamespaces();
+ Namespace.PROCESSED = true;
+ }
+
+ if (unprocessedNamespaces || unprocessedMixins) {
+ var namespaces = Namespace.NAMESPACES;
+ var namespace;
+
+ for (var i=0, l=namespaces.length; i 0) {
+ NativeArray = NativeArray.without.apply(NativeArray, ignore);
+ }
+
+ /**
+ Creates an `Ember.NativeArray` from an Array like object.
+ Does not modify the original object. Ember.A is not needed if
+ `Ember.EXTEND_PROTOTYPES` is `true` (the default value). However,
+ it is recommended that you use Ember.A when creating addons for
+ ember or when you can not guarantee that `Ember.EXTEND_PROTOTYPES`
+ will be `true`.
+
+ Example
+
+ ```js
+ var Pagination = Ember.CollectionView.extend({
+ tagName: 'ul',
+ classNames: ['pagination'],
+
+ init: function() {
+ this._super();
+ if (!this.get('content')) {
+ this.set('content', Ember.A());
+ }
+ }
+ });
+ ```
+
+ @method A
+ @for Ember
+ @return {Ember.NativeArray}
+ */
+ var A = function(arr) {
+ if (arr === undefined) { arr = []; }
+ return EmberArray.detect(arr) ? arr : NativeArray.apply(arr);
+ };
+
+ /**
+ Activates the mixin on the Array.prototype if not already applied. Calling
+ this method more than once is safe. This will be called when ember is loaded
+ unless you have `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Array`
+ set to `false`.
+
+ Example
+
+ ```js
+ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Array) {
+ Ember.NativeArray.activate();
+ }
+ ```
+
+ @method activate
+ @for Ember.NativeArray
+ @static
+ @return {void}
+ */
+ NativeArray.activate = function() {
+ NativeArray.apply(Array.prototype);
+
+ A = function(arr) { return arr || []; };
+ };
+
+ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Array) {
+ NativeArray.activate();
+ }
+
+ Ember.A = A; // ES6TODO: Setting A onto the object returned by ember-metal/core to avoid circles
+ __exports__.A = A;
+ __exports__.NativeArray = NativeArray;
+ __exports__["default"] = NativeArray;
+ });
+enifed("ember-runtime/system/object",
+ ["ember-runtime/system/core_object","ember-runtime/mixins/observable","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+
+ var CoreObject = __dependency1__["default"];
+ var Observable = __dependency2__["default"];
+
+ /**
+ `Ember.Object` is the main base class for all Ember objects. It is a subclass
+ of `Ember.CoreObject` with the `Ember.Observable` mixin applied. For details,
+ see the documentation for each of these.
+
+ @class Object
+ @namespace Ember
+ @extends Ember.CoreObject
+ @uses Ember.Observable
+ */
+ var EmberObject = CoreObject.extend(Observable);
+ EmberObject.toString = function() {
+ return "Ember.Object";
+ };
+
+ __exports__["default"] = EmberObject;
+ });
+enifed("ember-runtime/system/object_proxy",
+ ["ember-runtime/system/object","ember-runtime/mixins/-proxy","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var EmberObject = __dependency1__["default"];
+ var _ProxyMixin = __dependency2__["default"];
+
+ /**
+ `Ember.ObjectProxy` forwards all properties not defined by the proxy itself
+ to a proxied `content` object.
+
+ ```javascript
+ object = Ember.Object.create({
+ name: 'Foo'
+ });
+
+ proxy = Ember.ObjectProxy.create({
+ content: object
+ });
+
+ // Access and change existing properties
+ proxy.get('name') // 'Foo'
+ proxy.set('name', 'Bar');
+ object.get('name') // 'Bar'
+
+ // Create new 'description' property on `object`
+ proxy.set('description', 'Foo is a whizboo baz');
+ object.get('description') // 'Foo is a whizboo baz'
+ ```
+
+ While `content` is unset, setting a property to be delegated will throw an
+ Error.
+
+ ```javascript
+ proxy = Ember.ObjectProxy.create({
+ content: null,
+ flag: null
+ });
+ proxy.set('flag', true);
+ proxy.get('flag'); // true
+ proxy.get('foo'); // undefined
+ proxy.set('foo', 'data'); // throws Error
+ ```
+
+ Delegated properties can be bound to and will change when content is updated.
+
+ Computed properties on the proxy itself can depend on delegated properties.
+
+ ```javascript
+ ProxyWithComputedProperty = Ember.ObjectProxy.extend({
+ fullName: function () {
+ var firstName = this.get('firstName'),
+ lastName = this.get('lastName');
+ if (firstName && lastName) {
+ return firstName + ' ' + lastName;
+ }
+ return firstName || lastName;
+ }.property('firstName', 'lastName')
+ });
+
+ proxy = ProxyWithComputedProperty.create();
+
+ proxy.get('fullName'); // undefined
+ proxy.set('content', {
+ firstName: 'Tom', lastName: 'Dale'
+ }); // triggers property change for fullName on proxy
+
+ proxy.get('fullName'); // 'Tom Dale'
+ ```
+
+ @class ObjectProxy
+ @namespace Ember
+ @extends Ember.Object
+ @extends Ember._ProxyMixin
+ */
+
+ __exports__["default"] = EmberObject.extend(_ProxyMixin);
+ });
+enifed("ember-runtime/system/service",
+ ["ember-runtime/system/object","ember-runtime/inject","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var Object = __dependency1__["default"];
+ var createInjectionHelper = __dependency2__.createInjectionHelper;
+
+ var Service;
+
+
+ /**
+ @class Service
+ @namespace Ember
+ @extends Ember.Object
+ */
+ Service = Object.extend();
+
+ /**
+ Creates a property that lazily looks up a service in the container. There
+ are no restrictions as to what objects a service can be injected into.
+
+ Example:
+
+ ```javascript
+ App.ApplicationRoute = Ember.Route.extend({
+ authManager: Ember.inject.service('auth'),
+
+ model: function() {
+ return this.get('authManager').findCurrentUser();
+ }
+ });
+ ```
+
+ This example will create an `authManager` property on the application route
+ that looks up the `auth` service in the container, making it easily
+ accessible in the `model` hook.
+
+ @method inject.service
+ @for Ember
+ @param {String} name (optional) name of the service to inject, defaults to
+ the property's name
+ @return {Ember.InjectedProperty} injection descriptor instance
+ */
+ createInjectionHelper('service');
+
+
+ __exports__["default"] = Service;
+ });
+enifed("ember-runtime/system/set",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/is_none","ember-runtime/system/string","ember-runtime/system/core_object","ember-runtime/mixins/mutable_enumerable","ember-runtime/mixins/enumerable","ember-runtime/mixins/copyable","ember-runtime/mixins/freezable","ember-metal/error","ember-metal/property_events","ember-metal/mixin","ember-metal/computed","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+ var Ember = __dependency1__["default"];
+ // Ember.isNone, Ember.A
+
+ var get = __dependency2__.get;
+ var set = __dependency3__.set;
+ var guidFor = __dependency4__.guidFor;
+ var isNone = __dependency5__["default"];
+ var fmt = __dependency6__.fmt;
+ var CoreObject = __dependency7__["default"];
+ var MutableEnumerable = __dependency8__["default"];
+ var Enumerable = __dependency9__["default"];
+ var Copyable = __dependency10__["default"];
+ var Freezable = __dependency11__.Freezable;
+ var FROZEN_ERROR = __dependency11__.FROZEN_ERROR;
+ var EmberError = __dependency12__["default"];
+ var propertyWillChange = __dependency13__.propertyWillChange;
+ var propertyDidChange = __dependency13__.propertyDidChange;
+ var aliasMethod = __dependency14__.aliasMethod;
+ var computed = __dependency15__.computed;
+
+ /**
+ An unordered collection of objects.
+
+ A Set works a bit like an array except that its items are not ordered. You
+ can create a set to efficiently test for membership for an object. You can
+ also iterate through a set just like an array, even accessing objects by
+ index, however there is no guarantee as to their order.
+
+ All Sets are observable via the Enumerable Observer API - which works
+ on any enumerable object including both Sets and Arrays.
+
+ ## Creating a Set
+
+ You can create a set like you would most objects using
+ `new Ember.Set()`. Most new sets you create will be empty, but you can
+ also initialize the set with some content by passing an array or other
+ enumerable of objects to the constructor.
+
+ Finally, you can pass in an existing set and the set will be copied. You
+ can also create a copy of a set by calling `Ember.Set#copy()`.
+
+ ```javascript
+ // creates a new empty set
+ var foundNames = new Ember.Set();
+
+ // creates a set with four names in it.
+ var names = new Ember.Set(["Charles", "Tom", "Juan", "Alex"]); // :P
+
+ // creates a copy of the names set.
+ var namesCopy = new Ember.Set(names);
+
+ // same as above.
+ var anotherNamesCopy = names.copy();
+ ```
+
+ ## Adding/Removing Objects
+
+ You generally add or remove objects from a set using `add()` or
+ `remove()`. You can add any type of object including primitives such as
+ numbers, strings, and booleans.
+
+ Unlike arrays, objects can only exist one time in a set. If you call `add()`
+ on a set with the same object multiple times, the object will only be added
+ once. Likewise, calling `remove()` with the same object multiple times will
+ remove the object the first time and have no effect on future calls until
+ you add the object to the set again.
+
+ NOTE: You cannot add/remove `null` or `undefined` to a set. Any attempt to do
+ so will be ignored.
+
+ In addition to add/remove you can also call `push()`/`pop()`. Push behaves
+ just like `add()` but `pop()`, unlike `remove()` will pick an arbitrary
+ object, remove it and return it. This is a good way to use a set as a job
+ queue when you don't care which order the jobs are executed in.
+
+ ## Testing for an Object
+
+ To test for an object's presence in a set you simply call
+ `Ember.Set#contains()`.
+
+ ## Observing changes
+
+ When using `Ember.Set`, you can observe the `"[]"` property to be
+ alerted whenever the content changes. You can also add an enumerable
+ observer to the set to be notified of specific objects that are added and
+ removed from the set. See [Ember.Enumerable](/api/classes/Ember.Enumerable.html)
+ for more information on enumerables.
+
+ This is often unhelpful. If you are filtering sets of objects, for instance,
+ it is very inefficient to re-filter all of the items each time the set
+ changes. It would be better if you could just adjust the filtered set based
+ on what was changed on the original set. The same issue applies to merging
+ sets, as well.
+
+ ## Other Methods
+
+ `Ember.Set` primary implements other mixin APIs. For a complete reference
+ on the methods you will use with `Ember.Set`, please consult these mixins.
+ The most useful ones will be `Ember.Enumerable` and
+ `Ember.MutableEnumerable` which implement most of the common iterator
+ methods you are used to on Array.
+
+ Note that you can also use the `Ember.Copyable` and `Ember.Freezable`
+ APIs on `Ember.Set` as well. Once a set is frozen it can no longer be
+ modified. The benefit of this is that when you call `frozenCopy()` on it,
+ Ember will avoid making copies of the set. This allows you to write
+ code that can know with certainty when the underlying set data will or
+ will not be modified.
+
+ @class Set
+ @namespace Ember
+ @extends Ember.CoreObject
+ @uses Ember.MutableEnumerable
+ @uses Ember.Copyable
+ @uses Ember.Freezable
+ @since Ember 0.9
+ @deprecated
+ */
+ __exports__["default"] = CoreObject.extend(MutableEnumerable, Copyable, Freezable, {
+
+ // ..........................................................
+ // IMPLEMENT ENUMERABLE APIS
+ //
+
+ /**
+ This property will change as the number of objects in the set changes.
+
+ @property length
+ @type number
+ @default 0
+ */
+ length: 0,
+
+ /**
+ Clears the set. This is useful if you want to reuse an existing set
+ without having to recreate it.
+
+ ```javascript
+ var colors = new Ember.Set(["red", "green", "blue"]);
+ colors.length; // 3
+ colors.clear();
+ colors.length; // 0
+ ```
+
+ @method clear
+ @return {Ember.Set} An empty Set
+ */
+ clear: function() {
+ if (this.isFrozen) { throw new EmberError(FROZEN_ERROR); }
+
+ var len = get(this, 'length');
+ if (len === 0) { return this; }
+
+ var guid;
+
+ this.enumerableContentWillChange(len, 0);
+ propertyWillChange(this, 'firstObject');
+ propertyWillChange(this, 'lastObject');
+
+ for (var i=0; i < len; i++) {
+ guid = guidFor(this[i]);
+ delete this[guid];
+ delete this[i];
+ }
+
+ set(this, 'length', 0);
+
+ propertyDidChange(this, 'firstObject');
+ propertyDidChange(this, 'lastObject');
+ this.enumerableContentDidChange(len, 0);
+
+ return this;
+ },
+
+ /**
+ Returns true if the passed object is also an enumerable that contains the
+ same objects as the receiver.
+
+ ```javascript
+ var colors = ["red", "green", "blue"],
+ same_colors = new Ember.Set(colors);
+
+ same_colors.isEqual(colors); // true
+ same_colors.isEqual(["purple", "brown"]); // false
+ ```
+
+ @method isEqual
+ @param {Ember.Set} obj the other object.
+ @return {Boolean}
+ */
+ isEqual: function(obj) {
+ // fail fast
+ if (!Enumerable.detect(obj)) return false;
+
+ var loc = get(this, 'length');
+ if (get(obj, 'length') !== loc) return false;
+
+ while(--loc >= 0) {
+ if (!obj.contains(this[loc])) return false;
+ }
+
+ return true;
+ },
+
+ /**
+ Adds an object to the set. Only non-`null` objects can be added to a set
+ and those can only be added once. If the object is already in the set or
+ the passed value is null this method will have no effect.
+
+ This is an alias for `Ember.MutableEnumerable.addObject()`.
+
+ ```javascript
+ var colors = new Ember.Set();
+ colors.add("blue"); // ["blue"]
+ colors.add("blue"); // ["blue"]
+ colors.add("red"); // ["blue", "red"]
+ colors.add(null); // ["blue", "red"]
+ colors.add(undefined); // ["blue", "red"]
+ ```
+
+ @method add
+ @param {Object} obj The object to add.
+ @return {Ember.Set} The set itself.
+ */
+ add: aliasMethod('addObject'),
+
+ /**
+ Removes the object from the set if it is found. If you pass a `null` value
+ or an object that is already not in the set, this method will have no
+ effect. This is an alias for `Ember.MutableEnumerable.removeObject()`.
+
+ ```javascript
+ var colors = new Ember.Set(["red", "green", "blue"]);
+ colors.remove("red"); // ["blue", "green"]
+ colors.remove("purple"); // ["blue", "green"]
+ colors.remove(null); // ["blue", "green"]
+ ```
+
+ @method remove
+ @param {Object} obj The object to remove
+ @return {Ember.Set} The set itself.
+ */
+ remove: aliasMethod('removeObject'),
+
+ /**
+ Removes the last element from the set and returns it, or `null` if it's empty.
+
+ ```javascript
+ var colors = new Ember.Set(["green", "blue"]);
+ colors.pop(); // "blue"
+ colors.pop(); // "green"
+ colors.pop(); // null
+ ```
+
+ @method pop
+ @return {Object} The removed object from the set or null.
+ */
+ pop: function() {
+ if (get(this, 'isFrozen')) throw new EmberError(FROZEN_ERROR);
+ var obj = this.length > 0 ? this[this.length-1] : null;
+ this.remove(obj);
+ return obj;
+ },
+
+ /**
+ Inserts the given object on to the end of the set. It returns
+ the set itself.
+
+ This is an alias for `Ember.MutableEnumerable.addObject()`.
+
+ ```javascript
+ var colors = new Ember.Set();
+ colors.push("red"); // ["red"]
+ colors.push("green"); // ["red", "green"]
+ colors.push("blue"); // ["red", "green", "blue"]
+ ```
+
+ @method push
+ @return {Ember.Set} The set itself.
+ */
+ push: aliasMethod('addObject'),
+
+ /**
+ Removes the last element from the set and returns it, or `null` if it's empty.
+
+ This is an alias for `Ember.Set.pop()`.
+
+ ```javascript
+ var colors = new Ember.Set(["green", "blue"]);
+ colors.shift(); // "blue"
+ colors.shift(); // "green"
+ colors.shift(); // null
+ ```
+
+ @method shift
+ @return {Object} The removed object from the set or null.
+ */
+ shift: aliasMethod('pop'),
+
+ /**
+ Inserts the given object on to the end of the set. It returns
+ the set itself.
+
+ This is an alias of `Ember.Set.push()`
+
+ ```javascript
+ var colors = new Ember.Set();
+ colors.unshift("red"); // ["red"]
+ colors.unshift("green"); // ["red", "green"]
+ colors.unshift("blue"); // ["red", "green", "blue"]
+ ```
+
+ @method unshift
+ @return {Ember.Set} The set itself.
+ */
+ unshift: aliasMethod('push'),
+
+ /**
+ Adds each object in the passed enumerable to the set.
+
+ This is an alias of `Ember.MutableEnumerable.addObjects()`
+
+ ```javascript
+ var colors = new Ember.Set();
+ colors.addEach(["red", "green", "blue"]); // ["red", "green", "blue"]
+ ```
+
+ @method addEach
+ @param {Ember.Enumerable} objects the objects to add.
+ @return {Ember.Set} The set itself.
+ */
+ addEach: aliasMethod('addObjects'),
+
+ /**
+ Removes each object in the passed enumerable to the set.
+
+ This is an alias of `Ember.MutableEnumerable.removeObjects()`
+
+ ```javascript
+ var colors = new Ember.Set(["red", "green", "blue"]);
+ colors.removeEach(["red", "blue"]); // ["green"]
+ ```
+
+ @method removeEach
+ @param {Ember.Enumerable} objects the objects to remove.
+ @return {Ember.Set} The set itself.
+ */
+ removeEach: aliasMethod('removeObjects'),
+
+ // ..........................................................
+ // PRIVATE ENUMERABLE SUPPORT
+ //
+
+ init: function(items) {
+ Ember.deprecate('Ember.Set is deprecated and will be removed in a future release.');
+ this._super();
+ if (items) this.addObjects(items);
+ },
+
+ // implement Ember.Enumerable
+ nextObject: function(idx) {
+ return this[idx];
+ },
+
+ // more optimized version
+ firstObject: computed(function() {
+ return this.length > 0 ? this[0] : undefined;
+ }),
+
+ // more optimized version
+ lastObject: computed(function() {
+ return this.length > 0 ? this[this.length-1] : undefined;
+ }),
+
+ // implements Ember.MutableEnumerable
+ addObject: function(obj) {
+ if (get(this, 'isFrozen')) throw new EmberError(FROZEN_ERROR);
+ if (isNone(obj)) return this; // nothing to do
+
+ var guid = guidFor(obj);
+ var idx = this[guid];
+ var len = get(this, 'length');
+ var added;
+
+ if (idx>=0 && idx=0 && idx=0;
+ },
+
+ copy: function() {
+ var C = this.constructor, ret = new C(), loc = get(this, 'length');
+ set(ret, 'length', loc);
+ while(--loc>=0) {
+ ret[loc] = this[loc];
+ ret[guidFor(this[loc])] = loc;
+ }
+ return ret;
+ },
+
+ toString: function() {
+ var len = this.length, idx, array = [];
+ for(idx = 0; idx < len; idx++) {
+ array[idx] = this[idx];
+ }
+ return fmt("Ember.Set<%@>", [array.join(',')]);
+ }
+ });
+ });
+enifed("ember-runtime/system/string",
+ ["ember-metal/core","ember-metal/utils","ember-metal/cache","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-runtime
+ */
+ var Ember = __dependency1__["default"];
+ // Ember.STRINGS, Ember.FEATURES
+ var isArray = __dependency2__.isArray;
+ var emberInspect = __dependency2__.inspect;
+
+ var Cache = __dependency3__["default"];
+
+ var STRING_DASHERIZE_REGEXP = (/[ _]/g);
+
+ var STRING_DASHERIZE_CACHE = new Cache(1000, function(key) {
+ return decamelize(key).replace(STRING_DASHERIZE_REGEXP, '-');
+ });
+
+ var CAMELIZE_CACHE = new Cache(1000, function(key) {
+ return key.replace(STRING_CAMELIZE_REGEXP, function(match, separator, chr) {
+ return chr ? chr.toUpperCase() : '';
+ }).replace(/^([A-Z])/, function(match, separator, chr) {
+ return match.toLowerCase();
+ });
+ });
+
+ var CLASSIFY_CACHE = new Cache(1000, function(str) {
+ var parts = str.split(".");
+ var out = [];
+
+ for (var i=0, l=parts.length; i 2) {
+ cachedFormats = new Array(arguments.length - 1);
+
+ for (var i = 1, l = arguments.length; i < l; i++) {
+ cachedFormats[i - 1] = arguments[i];
+ }
+ }
+
+ // first, replace any ORDERED replacements.
+ var idx = 0; // the current index for non-numerical replacements
+ return str.replace(/%@([0-9]+)?/g, function(s, argIndex) {
+ argIndex = (argIndex) ? parseInt(argIndex, 10) - 1 : idx++;
+ s = cachedFormats[argIndex];
+ return (s === null) ? '(null)' : (s === undefined) ? '' : emberInspect(s);
+ });
+ }
+
+ function loc(str, formats) {
+ if (!isArray(formats) || arguments.length > 2) {
+ formats = Array.prototype.slice.call(arguments, 1);
+ }
+
+ str = Ember.STRINGS[str] || str;
+ return fmt(str, formats);
+ }
+
+ function w(str) {
+ return str.split(/\s+/);
+ }
+
+ function decamelize(str) {
+ return DECAMELIZE_CACHE.get(str);
+ }
+
+ function dasherize(str) {
+ return STRING_DASHERIZE_CACHE.get(str);
+ }
+
+ function camelize(str) {
+ return CAMELIZE_CACHE.get(str);
+ }
+
+ function classify(str) {
+ return CLASSIFY_CACHE.get(str);
+ }
+
+ function underscore(str) {
+ return UNDERSCORE_CACHE.get(str);
+ }
+
+ function capitalize(str) {
+ return CAPITALIZE_CACHE.get(str);
+ }
+
+ /**
+ Defines the hash of localized strings for the current language. Used by
+ the `Ember.String.loc()` helper. To localize, add string values to this
+ hash.
+
+ @property STRINGS
+ @for Ember
+ @type Hash
+ */
+ Ember.STRINGS = {};
+
+ /**
+ Defines string helper methods including string formatting and localization.
+ Unless `Ember.EXTEND_PROTOTYPES.String` is `false` these methods will also be
+ added to the `String.prototype` as well.
+
+ @class String
+ @namespace Ember
+ @static
+ */
+ __exports__["default"] = {
+ /**
+ Apply formatting options to the string. This will look for occurrences
+ of "%@" in your string and substitute them with the arguments you pass into
+ this method. If you want to control the specific order of replacement,
+ you can add a number after the key as well to indicate which argument
+ you want to insert.
+
+ Ordered insertions are most useful when building loc strings where values
+ you need to insert may appear in different orders.
+
+ ```javascript
+ "Hello %@ %@".fmt('John', 'Doe'); // "Hello John Doe"
+ "Hello %@2, %@1".fmt('John', 'Doe'); // "Hello Doe, John"
+ ```
+
+ @method fmt
+ @param {String} str The string to format
+ @param {Array} formats An array of parameters to interpolate into string.
+ @return {String} formatted string
+ */
+ fmt: fmt,
+
+ /**
+ Formats the passed string, but first looks up the string in the localized
+ strings hash. This is a convenient way to localize text. See
+ `Ember.String.fmt()` for more information on formatting.
+
+ Note that it is traditional but not required to prefix localized string
+ keys with an underscore or other character so you can easily identify
+ localized strings.
+
+ ```javascript
+ Ember.STRINGS = {
+ '_Hello World': 'Bonjour le monde',
+ '_Hello %@ %@': 'Bonjour %@ %@'
+ };
+
+ Ember.String.loc("_Hello World"); // 'Bonjour le monde';
+ Ember.String.loc("_Hello %@ %@", ["John", "Smith"]); // "Bonjour John Smith";
+ ```
+
+ @method loc
+ @param {String} str The string to format
+ @param {Array} formats Optional array of parameters to interpolate into string.
+ @return {String} formatted string
+ */
+ loc: loc,
+
+ /**
+ Splits a string into separate units separated by spaces, eliminating any
+ empty strings in the process. This is a convenience method for split that
+ is mostly useful when applied to the `String.prototype`.
+
+ ```javascript
+ Ember.String.w("alpha beta gamma").forEach(function(key) {
+ console.log(key);
+ });
+
+ // > alpha
+ // > beta
+ // > gamma
+ ```
+
+ @method w
+ @param {String} str The string to split
+ @return {Array} array containing the split strings
+ */
+ w: w,
+
+ /**
+ Converts a camelized string into all lower case separated by underscores.
+
+ ```javascript
+ 'innerHTML'.decamelize(); // 'inner_html'
+ 'action_name'.decamelize(); // 'action_name'
+ 'css-class-name'.decamelize(); // 'css-class-name'
+ 'my favorite items'.decamelize(); // 'my favorite items'
+ ```
+
+ @method decamelize
+ @param {String} str The string to decamelize.
+ @return {String} the decamelized string.
+ */
+ decamelize: decamelize,
+
+ /**
+ Replaces underscores, spaces, or camelCase with dashes.
+
+ ```javascript
+ 'innerHTML'.dasherize(); // 'inner-html'
+ 'action_name'.dasherize(); // 'action-name'
+ 'css-class-name'.dasherize(); // 'css-class-name'
+ 'my favorite items'.dasherize(); // 'my-favorite-items'
+ ```
+
+ @method dasherize
+ @param {String} str The string to dasherize.
+ @return {String} the dasherized string.
+ */
+ dasherize: dasherize,
+
+ /**
+ Returns the lowerCamelCase form of a string.
+
+ ```javascript
+ 'innerHTML'.camelize(); // 'innerHTML'
+ 'action_name'.camelize(); // 'actionName'
+ 'css-class-name'.camelize(); // 'cssClassName'
+ 'my favorite items'.camelize(); // 'myFavoriteItems'
+ 'My Favorite Items'.camelize(); // 'myFavoriteItems'
+ ```
+
+ @method camelize
+ @param {String} str The string to camelize.
+ @return {String} the camelized string.
+ */
+ camelize: camelize,
+
+ /**
+ Returns the UpperCamelCase form of a string.
+
+ ```javascript
+ 'innerHTML'.classify(); // 'InnerHTML'
+ 'action_name'.classify(); // 'ActionName'
+ 'css-class-name'.classify(); // 'CssClassName'
+ 'my favorite items'.classify(); // 'MyFavoriteItems'
+ ```
+
+ @method classify
+ @param {String} str the string to classify
+ @return {String} the classified string
+ */
+ classify: classify,
+
+ /**
+ More general than decamelize. Returns the lower\_case\_and\_underscored
+ form of a string.
+
+ ```javascript
+ 'innerHTML'.underscore(); // 'inner_html'
+ 'action_name'.underscore(); // 'action_name'
+ 'css-class-name'.underscore(); // 'css_class_name'
+ 'my favorite items'.underscore(); // 'my_favorite_items'
+ ```
+
+ @method underscore
+ @param {String} str The string to underscore.
+ @return {String} the underscored string.
+ */
+ underscore: underscore,
+
+ /**
+ Returns the Capitalized form of a string
+
+ ```javascript
+ 'innerHTML'.capitalize() // 'InnerHTML'
+ 'action_name'.capitalize() // 'Action_name'
+ 'css-class-name'.capitalize() // 'Css-class-name'
+ 'my favorite items'.capitalize() // 'My favorite items'
+ ```
+
+ @method capitalize
+ @param {String} str The string to capitalize.
+ @return {String} The capitalized string.
+ */
+ capitalize: capitalize
+ };
+
+ __exports__.fmt = fmt;
+ __exports__.loc = loc;
+ __exports__.w = w;
+ __exports__.decamelize = decamelize;
+ __exports__.dasherize = dasherize;
+ __exports__.camelize = camelize;
+ __exports__.classify = classify;
+ __exports__.underscore = underscore;
+ __exports__.capitalize = capitalize;
+ });
+enifed("ember-runtime/system/subarray",
+ ["ember-metal/error","ember-metal/enumerable_utils","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var EmberError = __dependency1__["default"];
+ var EnumerableUtils = __dependency2__["default"];
+
+ var RETAIN = 'r';
+ var FILTER = 'f';
+
+ function Operation(type, count) {
+ this.type = type;
+ this.count = count;
+ }
+
+ __exports__["default"] = SubArray;
+
+ /**
+ An `Ember.SubArray` tracks an array in a way similar to, but more specialized
+ than, `Ember.TrackedArray`. It is useful for keeping track of the indexes of
+ items within a filtered array.
+
+ @class SubArray
+ @namespace Ember
+ */
+ function SubArray (length) {
+ if (arguments.length < 1) { length = 0; }
+
+ if (length > 0) {
+ this._operations = [new Operation(RETAIN, length)];
+ } else {
+ this._operations = [];
+ }
+ }
+
+
+ SubArray.prototype = {
+ /**
+ Track that an item was added to the tracked array.
+
+ @method addItem
+
+ @param {Number} index The index of the item in the tracked array.
+ @param {Boolean} match `true` iff the item is included in the subarray.
+
+ @return {number} The index of the item in the subarray.
+ */
+ addItem: function(index, match) {
+ var returnValue = -1;
+ var itemType = match ? RETAIN : FILTER;
+ var self = this;
+
+ this._findOperation(index, function(operation, operationIndex, rangeStart, rangeEnd, seenInSubArray) {
+ var newOperation, splitOperation;
+
+ if (itemType === operation.type) {
+ ++operation.count;
+ } else if (index === rangeStart) {
+ // insert to the left of `operation`
+ self._operations.splice(operationIndex, 0, new Operation(itemType, 1));
+ } else {
+ newOperation = new Operation(itemType, 1);
+ splitOperation = new Operation(operation.type, rangeEnd - index + 1);
+ operation.count = index - rangeStart;
+
+ self._operations.splice(operationIndex + 1, 0, newOperation, splitOperation);
+ }
+
+ if (match) {
+ if (operation.type === RETAIN) {
+ returnValue = seenInSubArray + (index - rangeStart);
+ } else {
+ returnValue = seenInSubArray;
+ }
+ }
+
+ self._composeAt(operationIndex);
+ }, function(seenInSubArray) {
+ self._operations.push(new Operation(itemType, 1));
+
+ if (match) {
+ returnValue = seenInSubArray;
+ }
+
+ self._composeAt(self._operations.length-1);
+ });
+
+ return returnValue;
+ },
+
+ /**
+ Track that an item was removed from the tracked array.
+
+ @method removeItem
+
+ @param {Number} index The index of the item in the tracked array.
+
+ @return {number} The index of the item in the subarray, or `-1` if the item
+ was not in the subarray.
+ */
+ removeItem: function(index) {
+ var returnValue = -1;
+ var self = this;
+
+ this._findOperation(index, function (operation, operationIndex, rangeStart, rangeEnd, seenInSubArray) {
+ if (operation.type === RETAIN) {
+ returnValue = seenInSubArray + (index - rangeStart);
+ }
+
+ if (operation.count > 1) {
+ --operation.count;
+ } else {
+ self._operations.splice(operationIndex, 1);
+ self._composeAt(operationIndex);
+ }
+ }, function() {
+ throw new EmberError("Can't remove an item that has never been added.");
+ });
+
+ return returnValue;
+ },
+
+
+ _findOperation: function (index, foundCallback, notFoundCallback) {
+ var seenInSubArray = 0;
+ var operationIndex, len, operation, rangeStart, rangeEnd;
+
+ // OPTIMIZE: change to balanced tree
+ // find leftmost operation to the right of `index`
+ for (operationIndex = rangeStart = 0, len = this._operations.length; operationIndex < len; rangeStart = rangeEnd + 1, ++operationIndex) {
+ operation = this._operations[operationIndex];
+ rangeEnd = rangeStart + operation.count - 1;
+
+ if (index >= rangeStart && index <= rangeEnd) {
+ foundCallback(operation, operationIndex, rangeStart, rangeEnd, seenInSubArray);
+ return;
+ } else if (operation.type === RETAIN) {
+ seenInSubArray += operation.count;
+ }
+ }
+
+ notFoundCallback(seenInSubArray);
+ },
+
+ _composeAt: function(index) {
+ var op = this._operations[index];
+ var otherOp;
+
+ if (!op) {
+ // Composing out of bounds is a no-op, as when removing the last operation
+ // in the list.
+ return;
+ }
+
+ if (index > 0) {
+ otherOp = this._operations[index-1];
+ if (otherOp.type === op.type) {
+ op.count += otherOp.count;
+ this._operations.splice(index-1, 1);
+ --index;
+ }
+ }
+
+ if (index < this._operations.length-1) {
+ otherOp = this._operations[index+1];
+ if (otherOp.type === op.type) {
+ op.count += otherOp.count;
+ this._operations.splice(index+1, 1);
+ }
+ }
+ },
+
+ toString: function () {
+ var str = "";
+ EnumerableUtils.forEach(this._operations, function (operation) {
+ str += " " + operation.type + ":" + operation.count;
+ });
+ return str.substring(1);
+ }
+ };
+ });
+enifed("ember-runtime/system/tracked_array",
+ ["ember-metal/property_get","ember-metal/enumerable_utils","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var get = __dependency1__.get;
+ var forEach = __dependency2__.forEach;
+
+ var RETAIN = 'r';
+ var INSERT = 'i';
+ var DELETE = 'd';
+
+ __exports__["default"] = TrackedArray;
+
+ /**
+ An `Ember.TrackedArray` tracks array operations. It's useful when you want to
+ lazily compute the indexes of items in an array after they've been shifted by
+ subsequent operations.
+
+ @class TrackedArray
+ @namespace Ember
+ @param {Array} [items=[]] The array to be tracked. This is used just to get
+ the initial items for the starting state of retain:n.
+ */
+ function TrackedArray(items) {
+ if (arguments.length < 1) { items = []; }
+
+ var length = get(items, 'length');
+
+ if (length) {
+ this._operations = [new ArrayOperation(RETAIN, length, items)];
+ } else {
+ this._operations = [];
+ }
+ }
+
+ TrackedArray.RETAIN = RETAIN;
+ TrackedArray.INSERT = INSERT;
+ TrackedArray.DELETE = DELETE;
+
+ TrackedArray.prototype = {
+
+ /**
+ Track that `newItems` were added to the tracked array at `index`.
+
+ @method addItems
+ @param index
+ @param newItems
+ */
+ addItems: function (index, newItems) {
+ var count = get(newItems, 'length');
+ if (count < 1) { return; }
+
+ var match = this._findArrayOperation(index);
+ var arrayOperation = match.operation;
+ var arrayOperationIndex = match.index;
+ var arrayOperationRangeStart = match.rangeStart;
+ var composeIndex, newArrayOperation;
+
+ newArrayOperation = new ArrayOperation(INSERT, count, newItems);
+
+ if (arrayOperation) {
+ if (!match.split) {
+ // insert left of arrayOperation
+ this._operations.splice(arrayOperationIndex, 0, newArrayOperation);
+ composeIndex = arrayOperationIndex;
+ } else {
+ this._split(arrayOperationIndex, index - arrayOperationRangeStart, newArrayOperation);
+ composeIndex = arrayOperationIndex + 1;
+ }
+ } else {
+ // insert at end
+ this._operations.push(newArrayOperation);
+ composeIndex = arrayOperationIndex;
+ }
+
+ this._composeInsert(composeIndex);
+ },
+
+ /**
+ Track that `count` items were removed at `index`.
+
+ @method removeItems
+ @param index
+ @param count
+ */
+ removeItems: function (index, count) {
+ if (count < 1) { return; }
+
+ var match = this._findArrayOperation(index);
+ var arrayOperationIndex = match.index;
+ var arrayOperationRangeStart = match.rangeStart;
+ var newArrayOperation, composeIndex;
+
+ newArrayOperation = new ArrayOperation(DELETE, count);
+ if (!match.split) {
+ // insert left of arrayOperation
+ this._operations.splice(arrayOperationIndex, 0, newArrayOperation);
+ composeIndex = arrayOperationIndex;
+ } else {
+ this._split(arrayOperationIndex, index - arrayOperationRangeStart, newArrayOperation);
+ composeIndex = arrayOperationIndex + 1;
+ }
+
+ return this._composeDelete(composeIndex);
+ },
+
+ /**
+ Apply all operations, reducing them to retain:n, for `n`, the number of
+ items in the array.
+
+ `callback` will be called for each operation and will be passed the following arguments:
+
+ * {array} items The items for the given operation
+ * {number} offset The computed offset of the items, ie the index in the
+ array of the first item for this operation.
+ * {string} operation The type of the operation. One of
+ `Ember.TrackedArray.{RETAIN, DELETE, INSERT}`
+
+ @method apply
+ @param {Function} callback
+ */
+ apply: function (callback) {
+ var items = [];
+ var offset = 0;
+
+ forEach(this._operations, function (arrayOperation, operationIndex) {
+ callback(arrayOperation.items, offset, arrayOperation.type, operationIndex);
+
+ if (arrayOperation.type !== DELETE) {
+ offset += arrayOperation.count;
+ items = items.concat(arrayOperation.items);
+ }
+ });
+
+ this._operations = [new ArrayOperation(RETAIN, items.length, items)];
+ },
+
+ /**
+ Return an `ArrayOperationMatch` for the operation that contains the item at `index`.
+
+ @method _findArrayOperation
+
+ @param {Number} index the index of the item whose operation information
+ should be returned.
+ @private
+ */
+ _findArrayOperation: function (index) {
+ var split = false;
+ var arrayOperationIndex, arrayOperation,
+ arrayOperationRangeStart, arrayOperationRangeEnd,
+ len;
+
+ // OPTIMIZE: we could search these faster if we kept a balanced tree.
+ // find leftmost arrayOperation to the right of `index`
+ for (arrayOperationIndex = arrayOperationRangeStart = 0, len = this._operations.length; arrayOperationIndex < len; ++arrayOperationIndex) {
+ arrayOperation = this._operations[arrayOperationIndex];
+
+ if (arrayOperation.type === DELETE) { continue; }
+
+ arrayOperationRangeEnd = arrayOperationRangeStart + arrayOperation.count - 1;
+
+ if (index === arrayOperationRangeStart) {
+ break;
+ } else if (index > arrayOperationRangeStart && index <= arrayOperationRangeEnd) {
+ split = true;
+ break;
+ } else {
+ arrayOperationRangeStart = arrayOperationRangeEnd + 1;
+ }
+ }
+
+ return new ArrayOperationMatch(arrayOperation, arrayOperationIndex, split, arrayOperationRangeStart);
+ },
+
+ _split: function (arrayOperationIndex, splitIndex, newArrayOperation) {
+ var arrayOperation = this._operations[arrayOperationIndex];
+ var splitItems = arrayOperation.items.slice(splitIndex);
+ var splitArrayOperation = new ArrayOperation(arrayOperation.type, splitItems.length, splitItems);
+
+ // truncate LHS
+ arrayOperation.count = splitIndex;
+ arrayOperation.items = arrayOperation.items.slice(0, splitIndex);
+
+ this._operations.splice(arrayOperationIndex + 1, 0, newArrayOperation, splitArrayOperation);
+ },
+
+ // see SubArray for a better implementation.
+ _composeInsert: function (index) {
+ var newArrayOperation = this._operations[index];
+ var leftArrayOperation = this._operations[index-1]; // may be undefined
+ var rightArrayOperation = this._operations[index+1]; // may be undefined
+ var leftOp = leftArrayOperation && leftArrayOperation.type;
+ var rightOp = rightArrayOperation && rightArrayOperation.type;
+
+ if (leftOp === INSERT) {
+ // merge left
+ leftArrayOperation.count += newArrayOperation.count;
+ leftArrayOperation.items = leftArrayOperation.items.concat(newArrayOperation.items);
+
+ if (rightOp === INSERT) {
+ // also merge right (we have split an insert with an insert)
+ leftArrayOperation.count += rightArrayOperation.count;
+ leftArrayOperation.items = leftArrayOperation.items.concat(rightArrayOperation.items);
+ this._operations.splice(index, 2);
+ } else {
+ // only merge left
+ this._operations.splice(index, 1);
+ }
+ } else if (rightOp === INSERT) {
+ // merge right
+ newArrayOperation.count += rightArrayOperation.count;
+ newArrayOperation.items = newArrayOperation.items.concat(rightArrayOperation.items);
+ this._operations.splice(index + 1, 1);
+ }
+ },
+
+ _composeDelete: function (index) {
+ var arrayOperation = this._operations[index];
+ var deletesToGo = arrayOperation.count;
+ var leftArrayOperation = this._operations[index-1]; // may be undefined
+ var leftOp = leftArrayOperation && leftArrayOperation.type;
+ var nextArrayOperation;
+ var nextOp;
+ var nextCount;
+ var removeNewAndNextOp = false;
+ var removedItems = [];
+
+ if (leftOp === DELETE) {
+ arrayOperation = leftArrayOperation;
+ index -= 1;
+ }
+
+ for (var i = index + 1; deletesToGo > 0; ++i) {
+ nextArrayOperation = this._operations[i];
+ nextOp = nextArrayOperation.type;
+ nextCount = nextArrayOperation.count;
+
+ if (nextOp === DELETE) {
+ arrayOperation.count += nextCount;
+ continue;
+ }
+
+ if (nextCount > deletesToGo) {
+ // d:2 {r,i}:5 we reduce the retain or insert, but it stays
+ removedItems = removedItems.concat(nextArrayOperation.items.splice(0, deletesToGo));
+ nextArrayOperation.count -= deletesToGo;
+
+ // In the case where we truncate the last arrayOperation, we don't need to
+ // remove it; also the deletesToGo reduction is not the entirety of
+ // nextCount
+ i -= 1;
+ nextCount = deletesToGo;
+
+ deletesToGo = 0;
+ } else {
+ if (nextCount === deletesToGo) {
+ // Handle edge case of d:2 i:2 in which case both operations go away
+ // during composition.
+ removeNewAndNextOp = true;
+ }
+ removedItems = removedItems.concat(nextArrayOperation.items);
+ deletesToGo -= nextCount;
+ }
+
+ if (nextOp === INSERT) {
+ // d:2 i:3 will result in delete going away
+ arrayOperation.count -= nextCount;
+ }
+ }
+
+ if (arrayOperation.count > 0) {
+ // compose our new delete with possibly several operations to the right of
+ // disparate types
+ this._operations.splice(index+1, i-1-index);
+ } else {
+ // The delete operation can go away; it has merely reduced some other
+ // operation, as in d:3 i:4; it may also have eliminated that operation,
+ // as in d:3 i:3.
+ this._operations.splice(index, removeNewAndNextOp ? 2 : 1);
+ }
+
+ return removedItems;
+ },
+
+ toString: function () {
+ var str = "";
+ forEach(this._operations, function (operation) {
+ str += " " + operation.type + ":" + operation.count;
+ });
+ return str.substring(1);
+ }
+ };
+
+ /**
+ Internal data structure to represent an array operation.
+
+ @method ArrayOperation
+ @private
+ @param {String} type The type of the operation. One of
+ `Ember.TrackedArray.{RETAIN, INSERT, DELETE}`
+ @param {Number} count The number of items in this operation.
+ @param {Array} items The items of the operation, if included. RETAIN and
+ INSERT include their items, DELETE does not.
+ */
+ function ArrayOperation (operation, count, items) {
+ this.type = operation; // RETAIN | INSERT | DELETE
+ this.count = count;
+ this.items = items;
+ }
+
+ /**
+ Internal data structure used to include information when looking up operations
+ by item index.
+
+ @method ArrayOperationMatch
+ @private
+ @param {ArrayOperation} operation
+ @param {Number} index The index of `operation` in the array of operations.
+ @param {Boolean} split Whether or not the item index searched for would
+ require a split for a new operation type.
+ @param {Number} rangeStart The index of the first item in the operation,
+ with respect to the tracked array. The index of the last item can be computed
+ from `rangeStart` and `operation.count`.
+ */
+ function ArrayOperationMatch(operation, index, split, rangeStart) {
+ this.operation = operation;
+ this.index = index;
+ this.split = split;
+ this.rangeStart = rangeStart;
+ }
+ });
+enifed("ember-template-compiler",
+ ["ember-metal/core","ember-template-compiler/system/precompile","ember-template-compiler/system/compile","ember-template-compiler/system/template","ember-template-compiler/plugins","ember-template-compiler/plugins/transform-each-in-to-hash","ember-template-compiler/plugins/transform-with-as-to-hash","ember-template-compiler/compat","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
+ "use strict";
+ var _Ember = __dependency1__["default"];
+ var precompile = __dependency2__["default"];
+ var compile = __dependency3__["default"];
+ var template = __dependency4__["default"];
+ var registerPlugin = __dependency5__.registerPlugin;
+
+ var TransformEachInToHash = __dependency6__["default"];
+ var TransformWithAsToHash = __dependency7__["default"];
+
+ // used for adding Ember.Handlebars.compile for backwards compat
+
+ registerPlugin('ast', TransformWithAsToHash);
+ registerPlugin('ast', TransformEachInToHash);
+
+ __exports__._Ember = _Ember;
+ __exports__.precompile = precompile;
+ __exports__.compile = compile;
+ __exports__.template = template;
+ __exports__.registerPlugin = registerPlugin;
+ });
+enifed("ember-template-compiler/compat",
+ ["ember-metal/core","ember-template-compiler/compat/precompile","ember-template-compiler/system/compile","ember-template-compiler/system/template"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ var precompile = __dependency2__["default"];
+ var compile = __dependency3__["default"];
+ var template = __dependency4__["default"];
+
+ var EmberHandlebars = Ember.Handlebars = Ember.Handlebars || {};
+
+ EmberHandlebars.precompile = precompile;
+ EmberHandlebars.compile = compile;
+ EmberHandlebars.template = template;
+ });
+enifed("ember-template-compiler/compat/precompile",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-template-compiler
+ */
+
+ var compile, compileSpec;
+
+ __exports__["default"] = function(string) {
+ if ((!compile || !compileSpec) && Ember.__loader.registry['htmlbars-compiler/compiler']) {
+ var Compiler = requireModule('htmlbars-compiler/compiler');
+
+ compile = Compiler.compile;
+ compileSpec = Compiler.compileSpec;
+ }
+
+ if (!compile || !compileSpec) {
+ throw new Error('Cannot call `precompile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `precompile`.');
+ }
+
+ var asObject = arguments[1] === undefined ? true : arguments[1];
+ var compileFunc = asObject ? compile : compileSpec;
+
+ return compileFunc(string);
+ }
+ });
+enifed("ember-template-compiler/plugins",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-template-compiler
+ */
+
+ /**
+ @private
+ @property helpers
+ */
+ var plugins = {
+ ast: [ ]
+ };
+
+ /**
+ Adds an AST plugin to be used by Ember.HTMLBars.compile.
+
+ @private
+ @method registerASTPlugin
+ */
+ function registerPlugin(type, Plugin) {
+ if (!plugins[type]) {
+ throw new Error('Attempting to register "' + Plugin + '" as "' + type + '" which is not a valid HTMLBars plugin type.');
+ }
+
+ plugins[type].push(Plugin);
+ }
+
+ __exports__.registerPlugin = registerPlugin;__exports__["default"] = plugins;
+ });
+enifed("ember-template-compiler/plugins/transform-each-in-to-hash",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+
+ /**
+ An HTMLBars AST transformation that replaces all instances of
+
+ ```handlebars
+ {{#each item in items}}
+ {{/each}}
+ ```
+
+ with
+
+ ```handlebars
+ {{#each items keyword="item"}}
+ {{/each}}
+ ```
+
+ @class TransformEachInToHash
+ @private
+ */
+ function TransformEachInToHash() {
+ // set later within HTMLBars to the syntax package
+ this.syntax = null;
+ }
+
+ /**
+ @private
+ @method transform
+ @param {AST} The AST to be transformed.
+ */
+ TransformEachInToHash.prototype.transform = function TransformEachInToHash_transform(ast) {
+ var pluginContext = this;
+ var walker = new pluginContext.syntax.Walker();
+ var b = pluginContext.syntax.builders;
+
+ walker.visit(ast, function(node) {
+ if (pluginContext.validate(node)) {
+
+ if (node.program && node.program.blockParams.length) {
+ throw new Error('You cannot use keyword (`{{each foo in bar}}`) and block params (`{{each bar as |foo|}}`) at the same time.');
+ }
+
+ var removedParams = node.sexpr.params.splice(0, 2);
+ var keyword = removedParams[0].original;
+
+ // TODO: This may not be necessary.
+ if (!node.sexpr.hash) {
+ node.sexpr.hash = b.hash();
+ }
+
+ node.sexpr.hash.pairs.push(b.pair(
+ 'keyword',
+ b.string(keyword)
+ ));
+ }
+ });
+
+ return ast;
+ };
+
+ TransformEachInToHash.prototype.validate = function TransformEachInToHash_validate(node) {
+ return (node.type === 'BlockStatement' || node.type === 'MustacheStatement') &&
+ node.sexpr.path.original === 'each' &&
+ node.sexpr.params.length === 3 &&
+ node.sexpr.params[1].type === 'PathExpression' &&
+ node.sexpr.params[1].original === 'in';
+ };
+
+ __exports__["default"] = TransformEachInToHash;
+ });
+enifed("ember-template-compiler/plugins/transform-with-as-to-hash",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ /**
+ An HTMLBars AST transformation that replaces all instances of
+
+ ```handlebars
+ {{#with foo.bar as bar}}
+ {{/with}}
+ ```
+
+ with
+
+ ```handlebars
+ {{#with foo.bar as |bar|}}
+ {{/with}}
+ ```
+
+ @private
+ @class TransformWithAsToHash
+ */
+ function TransformWithAsToHash() {
+ // set later within HTMLBars to the syntax package
+ this.syntax = null;
+ }
+
+ /**
+ @private
+ @method transform
+ @param {AST} The AST to be transformed.
+ */
+ TransformWithAsToHash.prototype.transform = function TransformWithAsToHash_transform(ast) {
+ var pluginContext = this;
+ var walker = new pluginContext.syntax.Walker();
+
+ walker.visit(ast, function(node) {
+ if (pluginContext.validate(node)) {
+
+ if (node.program && node.program.blockParams.length) {
+ throw new Error('You cannot use keyword (`{{with foo as bar}}`) and block params (`{{with foo as |bar|}}`) at the same time.');
+ }
+
+ var removedParams = node.sexpr.params.splice(1, 2);
+ var keyword = removedParams[1].original;
+ node.program.blockParams = [ keyword ];
+ }
+ });
+
+ return ast;
+ };
+
+ TransformWithAsToHash.prototype.validate = function TransformWithAsToHash_validate(node) {
+ return node.type === 'BlockStatement' &&
+ node.sexpr.path.original === 'with' &&
+ node.sexpr.params.length === 3 &&
+ node.sexpr.params[1].type === 'PathExpression' &&
+ node.sexpr.params[1].original === 'as';
+ };
+
+ __exports__["default"] = TransformWithAsToHash;
+ });
+enifed("ember-template-compiler/system/compile",
+ ["ember-template-compiler/system/compile_options","ember-template-compiler/system/template","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-template-compiler
+ */
+
+ var compile;
+ var compileOptions = __dependency1__["default"];
+ var template = __dependency2__["default"];
+
+ /**
+ Uses HTMLBars `compile` function to process a string into a compiled template.
+
+ This is not present in production builds.
+
+ @private
+ @method compile
+ @param {String} templateString This is the string to be compiled by HTMLBars.
+ */
+ __exports__["default"] = function(templateString) {
+ if (!compile && Ember.__loader.registry['htmlbars-compiler/compiler']) {
+ compile = requireModule('htmlbars-compiler/compiler').compile;
+ }
+
+ if (!compile) {
+ throw new Error('Cannot call `compile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compile`.');
+ }
+
+ var templateSpec = compile(templateString, compileOptions());
+
+ return template(templateSpec);
+ }
+ });
+enifed("ember-template-compiler/system/compile_options",
+ ["ember-metal/core","ember-template-compiler/plugins","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-template-compiler
+ */
+
+ var Ember = __dependency1__["default"];
+ var plugins = __dependency2__["default"];
+
+ /**
+ @private
+ @property compileOptions
+ */
+ __exports__["default"] = function() {
+ var disableComponentGeneration = true;
+
+ return {
+ disableComponentGeneration: disableComponentGeneration,
+
+ plugins: plugins
+ };
+ }
+ });
+enifed("ember-template-compiler/system/precompile",
+ ["ember-template-compiler/system/compile_options","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-template-compiler
+ */
+
+ var compileOptions = __dependency1__["default"];
+ var compileSpec;
+
+ /**
+ Uses HTMLBars `compile` function to process a string into a compiled template string.
+ The returned string must be passed through `Ember.HTMLBars.template`.
+
+ This is not present in production builds.
+
+ @private
+ @method precompile
+ @param {String} templateString This is the string to be compiled by HTMLBars.
+ */
+ __exports__["default"] = function(templateString) {
+ if (!compileSpec && Ember.__loader.registry['htmlbars-compiler/compiler']) {
+ compileSpec = requireModule('htmlbars-compiler/compiler').compileSpec;
+ }
+
+ if (!compileSpec) {
+ throw new Error('Cannot call `compileSpec` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compileSpec`.');
+ }
+
+ return compileSpec(templateString, compileOptions());
+ }
+ });
+enifed("ember-template-compiler/system/template",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-template-compiler
+ */
+
+ /**
+ Augments the detault precompiled output of an HTMLBars template with
+ additional information needed by Ember.
+
+ @private
+ @method template
+ @param {Function} templateSpec This is the compiled HTMLBars template spec.
+ */
+
+ __exports__["default"] = function(templateSpec) {
+ templateSpec.isTop = true;
+ templateSpec.isMethod = false;
+
+ return templateSpec;
+ }
+ });
+enifed("ember-testing",
+ ["ember-metal/core","ember-testing/initializers","ember-testing/support","ember-testing/setup_for_testing","ember-testing/test","ember-testing/adapters/adapter","ember-testing/adapters/qunit","ember-testing/helpers"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+
+ // to setup initializer
+ // to handle various edge cases
+
+ var setupForTesting = __dependency4__["default"];
+ var Test = __dependency5__["default"];
+ var Adapter = __dependency6__["default"];
+ var QUnitAdapter = __dependency7__["default"];
+ // adds helpers to helpers object in Test
+
+ /**
+ Ember Testing
+
+ @module ember
+ @submodule ember-testing
+ @requires ember-application
+ */
+
+ Ember.Test = Test;
+ Ember.Test.Adapter = Adapter;
+ Ember.Test.QUnitAdapter = QUnitAdapter;
+ Ember.setupForTesting = setupForTesting;
+ });
+enifed("ember-testing/adapters/adapter",
+ ["ember-runtime/system/object","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var EmberObject = __dependency1__["default"];
+
+ function K() { return this; }
+
+ /**
+ @module ember
+ @submodule ember-testing
+ */
+
+ /**
+ The primary purpose of this class is to create hooks that can be implemented
+ by an adapter for various test frameworks.
+
+ @class Adapter
+ @namespace Ember.Test
+ */
+ var Adapter = EmberObject.extend({
+ /**
+ This callback will be called whenever an async operation is about to start.
+
+ Override this to call your framework's methods that handle async
+ operations.
+
+ @public
+ @method asyncStart
+ */
+ asyncStart: K,
+
+ /**
+ This callback will be called whenever an async operation has completed.
+
+ @public
+ @method asyncEnd
+ */
+ asyncEnd: K,
+
+ /**
+ Override this method with your testing framework's false assertion.
+ This function is called whenever an exception occurs causing the testing
+ promise to fail.
+
+ QUnit example:
+
+ ```javascript
+ exception: function(error) {
+ ok(false, error);
+ };
+ ```
+
+ @public
+ @method exception
+ @param {String} error The exception to be raised.
+ */
+ exception: function(error) {
+ throw error;
+ }
+ });
+
+ __exports__["default"] = Adapter;
+ });
+enifed("ember-testing/adapters/qunit",
+ ["ember-testing/adapters/adapter","ember-metal/utils","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var Adapter = __dependency1__["default"];
+ var inspect = __dependency2__.inspect;
+
+ /**
+ This class implements the methods defined by Ember.Test.Adapter for the
+ QUnit testing framework.
+
+ @class QUnitAdapter
+ @namespace Ember.Test
+ @extends Ember.Test.Adapter
+ */
+ __exports__["default"] = Adapter.extend({
+ asyncStart: function() {
+ QUnit.stop();
+ },
+ asyncEnd: function() {
+ QUnit.start();
+ },
+ exception: function(error) {
+ ok(false, inspect(error));
+ }
+ });
+ });
+enifed("ember-testing/helpers",
+ ["ember-metal/property_get","ember-metal/error","ember-metal/run_loop","ember-views/system/jquery","ember-testing/test"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) {
+ "use strict";
+ var get = __dependency1__.get;
+ var EmberError = __dependency2__["default"];
+ var run = __dependency3__["default"];
+ var jQuery = __dependency4__["default"];
+ var Test = __dependency5__["default"];
+
+ /**
+ * @module ember
+ * @submodule ember-testing
+ */
+
+ var helper = Test.registerHelper;
+ var asyncHelper = Test.registerAsyncHelper;
+ var countAsync = 0;
+
+ function currentRouteName(app){
+ var appController = app.__container__.lookup('controller:application');
+
+ return get(appController, 'currentRouteName');
+ }
+
+ function currentPath(app){
+ var appController = app.__container__.lookup('controller:application');
+
+ return get(appController, 'currentPath');
+ }
+
+ function currentURL(app){
+ var router = app.__container__.lookup('router:main');
+
+ return get(router, 'location').getURL();
+ }
+
+ function pauseTest(){
+ Test.adapter.asyncStart();
+ return new Ember.RSVP.Promise(function(){ }, 'TestAdapter paused promise');
+ }
+
+ function visit(app, url) {
+ var router = app.__container__.lookup('router:main');
+ router.location.setURL(url);
+
+ if (app._readinessDeferrals > 0) {
+ router['initialURL'] = url;
+ run(app, 'advanceReadiness');
+ delete router['initialURL'];
+ } else {
+ run(app, app.handleURL, url);
+ }
+
+ return app.testHelpers.wait();
+ }
+
+ function click(app, selector, context) {
+ var $el = app.testHelpers.findWithAssert(selector, context);
+ run($el, 'mousedown');
+
+ if ($el.is(':input, [contenteditable=true]')) {
+ var type = $el.prop('type');
+ if (type !== 'checkbox' && type !== 'radio' && type !== 'hidden') {
+ run($el, function(){
+ // Firefox does not trigger the `focusin` event if the window
+ // does not have focus. If the document doesn't have focus just
+ // use trigger('focusin') instead.
+ if (!document.hasFocus || document.hasFocus()) {
+ this.focus();
+ } else {
+ this.trigger('focusin');
+ }
+ });
+ }
+ }
+
+ run($el, 'mouseup');
+ run($el, 'click');
+
+ return app.testHelpers.wait();
+ }
+
+ function triggerEvent(app, selector, contextOrType, typeOrOptions, possibleOptions){
+ var arity = arguments.length;
+ var context, type, options;
+
+ if (arity === 3) {
+ // context and options are optional, so this is
+ // app, selector, type
+ context = null;
+ type = contextOrType;
+ options = {};
+ } else if (arity === 4) {
+ // context and options are optional, so this is
+ if (typeof typeOrOptions === "object") { // either
+ // app, selector, type, options
+ context = null;
+ type = contextOrType;
+ options = typeOrOptions;
+ } else { // or
+ // app, selector, context, type
+ context = contextOrType;
+ type = typeOrOptions;
+ options = {};
+ }
+ } else {
+ context = contextOrType;
+ type = typeOrOptions;
+ options = possibleOptions;
+ }
+
+ var $el = app.testHelpers.findWithAssert(selector, context);
+
+ var event = jQuery.Event(type, options);
+
+ run($el, 'trigger', event);
+
+ return app.testHelpers.wait();
+ }
+
+ function keyEvent(app, selector, contextOrType, typeOrKeyCode, keyCode) {
+ var context, type;
+
+ if (typeof keyCode === 'undefined') {
+ context = null;
+ keyCode = typeOrKeyCode;
+ type = contextOrType;
+ } else {
+ context = contextOrType;
+ type = typeOrKeyCode;
+ }
+
+ return app.testHelpers.triggerEvent(selector, context, type, { keyCode: keyCode, which: keyCode });
+ }
+
+ function fillIn(app, selector, contextOrText, text) {
+ var $el, context;
+ if (typeof text === 'undefined') {
+ text = contextOrText;
+ } else {
+ context = contextOrText;
+ }
+ $el = app.testHelpers.findWithAssert(selector, context);
+ run(function() {
+ $el.val(text).change();
+ });
+ return app.testHelpers.wait();
+ }
+
+ function findWithAssert(app, selector, context) {
+ var $el = app.testHelpers.find(selector, context);
+ if ($el.length === 0) {
+ throw new EmberError("Element " + selector + " not found.");
+ }
+ return $el;
+ }
+
+ function find(app, selector, context) {
+ var $el;
+ context = context || get(app, 'rootElement');
+ $el = app.$(selector, context);
+
+ return $el;
+ }
+
+ function andThen(app, callback) {
+ return app.testHelpers.wait(callback(app));
+ }
+
+ function wait(app, value) {
+ return Test.promise(function(resolve) {
+ // If this is the first async promise, kick off the async test
+ if (++countAsync === 1) {
+ Test.adapter.asyncStart();
+ }
+
+ // Every 10ms, poll for the async thing to have finished
+ var watcher = setInterval(function() {
+ var router = app.__container__.lookup('router:main');
+
+ // 1. If the router is loading, keep polling
+ var routerIsLoading = router.router && !!router.router.activeTransition;
+ if (routerIsLoading) { return; }
+
+ // 2. If there are pending Ajax requests, keep polling
+ if (Test.pendingAjaxRequests) { return; }
+
+ // 3. If there are scheduled timers or we are inside of a run loop, keep polling
+ if (run.hasScheduledTimers() || run.currentRunLoop) { return; }
+ if (Test.waiters && Test.waiters.any(function(waiter) {
+ var context = waiter[0];
+ var callback = waiter[1];
+ return !callback.call(context);
+ })) { return; }
+ // Stop polling
+ clearInterval(watcher);
+
+ // If this is the last async promise, end the async test
+ if (--countAsync === 0) {
+ Test.adapter.asyncEnd();
+ }
+
+ // Synchronously resolve the promise
+ run(null, resolve, value);
+ }, 10);
+ });
+
+ }
+
+
+ /**
+ * Loads a route, sets up any controllers, and renders any templates associated
+ * with the route as though a real user had triggered the route change while
+ * using your app.
+ *
+ * Example:
+ *
+ * ```javascript
+ * visit('posts/index').then(function() {
+ * // assert something
+ * });
+ * ```
+ *
+ * @method visit
+ * @param {String} url the name of the route
+ * @return {RSVP.Promise}
+ */
+ asyncHelper('visit', visit);
+
+ /**
+ * Clicks an element and triggers any actions triggered by the element's `click`
+ * event.
+ *
+ * Example:
+ *
+ * ```javascript
+ * click('.some-jQuery-selector').then(function() {
+ * // assert something
+ * });
+ * ```
+ *
+ * @method click
+ * @param {String} selector jQuery selector for finding element on the DOM
+ * @return {RSVP.Promise}
+ */
+ asyncHelper('click', click);
+
+ /**
+ * Simulates a key event, e.g. `keypress`, `keydown`, `keyup` with the desired keyCode
+ *
+ * Example:
+ *
+ * ```javascript
+ * keyEvent('.some-jQuery-selector', 'keypress', 13).then(function() {
+ * // assert something
+ * });
+ * ```
+ *
+ * @method keyEvent
+ * @param {String} selector jQuery selector for finding element on the DOM
+ * @param {String} type the type of key event, e.g. `keypress`, `keydown`, `keyup`
+ * @param {Number} keyCode the keyCode of the simulated key event
+ * @return {RSVP.Promise}
+ * @since 1.5.0
+ */
+ asyncHelper('keyEvent', keyEvent);
+
+ /**
+ * Fills in an input element with some text.
+ *
+ * Example:
+ *
+ * ```javascript
+ * fillIn('#email', 'you@example.com').then(function() {
+ * // assert something
+ * });
+ * ```
+ *
+ * @method fillIn
+ * @param {String} selector jQuery selector finding an input element on the DOM
+ * to fill text with
+ * @param {String} text text to place inside the input element
+ * @return {RSVP.Promise}
+ */
+ asyncHelper('fillIn', fillIn);
+
+ /**
+ * Finds an element in the context of the app's container element. A simple alias
+ * for `app.$(selector)`.
+ *
+ * Example:
+ *
+ * ```javascript
+ * var $el = find('.my-selector');
+ * ```
+ *
+ * @method find
+ * @param {String} selector jQuery string selector for element lookup
+ * @return {Object} jQuery object representing the results of the query
+ */
+ helper('find', find);
+
+ /**
+ * Like `find`, but throws an error if the element selector returns no results.
+ *
+ * Example:
+ *
+ * ```javascript
+ * var $el = findWithAssert('.doesnt-exist'); // throws error
+ * ```
+ *
+ * @method findWithAssert
+ * @param {String} selector jQuery selector string for finding an element within
+ * the DOM
+ * @return {Object} jQuery object representing the results of the query
+ * @throws {Error} throws error if jQuery object returned has a length of 0
+ */
+ helper('findWithAssert', findWithAssert);
+
+ /**
+ Causes the run loop to process any pending events. This is used to ensure that
+ any async operations from other helpers (or your assertions) have been processed.
+
+ This is most often used as the return value for the helper functions (see 'click',
+ 'fillIn','visit',etc).
+
+ Example:
+
+ ```javascript
+ Ember.Test.registerAsyncHelper('loginUser', function(app, username, password) {
+ visit('secured/path/here')
+ .fillIn('#username', username)
+ .fillIn('#password', password)
+ .click('.submit')
+
+ return app.testHelpers.wait();
+ });
+
+ @method wait
+ @param {Object} value The value to be returned.
+ @return {RSVP.Promise}
+ */
+ asyncHelper('wait', wait);
+ asyncHelper('andThen', andThen);
+
+
+ /**
+ Returns the currently active route name.
+
+ Example:
+
+ ```javascript
+ function validateRouteName(){
+ equal(currentRouteName(), 'some.path', "correct route was transitioned into.");
+ }
+
+ visit('/some/path').then(validateRouteName)
+ ```
+
+ @method currentRouteName
+ @return {Object} The name of the currently active route.
+ @since 1.5.0
+ */
+ helper('currentRouteName', currentRouteName);
+
+ /**
+ Returns the current path.
+
+ Example:
+
+ ```javascript
+ function validateURL(){
+ equal(currentPath(), 'some.path.index', "correct path was transitioned into.");
+ }
+
+ click('#some-link-id').then(validateURL);
+ ```
+
+ @method currentPath
+ @return {Object} The currently active path.
+ @since 1.5.0
+ */
+ helper('currentPath', currentPath);
+
+ /**
+ Returns the current URL.
+
+ Example:
+
+ ```javascript
+ function validateURL(){
+ equal(currentURL(), '/some/path', "correct URL was transitioned into.");
+ }
+
+ click('#some-link-id').then(validateURL);
+ ```
+
+ @method currentURL
+ @return {Object} The currently active URL.
+ @since 1.5.0
+ */
+ helper('currentURL', currentURL);
+
+
+ /**
+ Pauses the current test - this is useful for debugging while testing or for test-driving.
+ It allows you to inspect the state of your application at any point.
+
+ Example (The test will pause before clicking the button):
+
+ ```javascript
+ visit('/')
+ return pauseTest();
+
+ click('.btn');
+ ```
+
+ @since 1.9.0
+ @method pauseTest
+ @return {Object} A promise that will never resolve
+ */
+ helper('pauseTest', pauseTest);
+
+
+ /**
+ Triggers the given DOM event on the element identified by the provided selector.
+
+ Example:
+
+ ```javascript
+ triggerEvent('#some-elem-id', 'blur');
+ ```
+
+ This is actually used internally by the `keyEvent` helper like so:
+
+ ```javascript
+ triggerEvent('#some-elem-id', 'keypress', { keyCode: 13 });
+ ```
+
+ @method triggerEvent
+ @param {String} selector jQuery selector for finding element on the DOM
+ @param {String} [context] jQuery selector that will limit the selector
+ argument to find only within the context's children
+ @param {String} type The event type to be triggered.
+ @param {Object} [options] The options to be passed to jQuery.Event.
+ @return {RSVP.Promise}
+ @since 1.5.0
+ */
+ asyncHelper('triggerEvent', triggerEvent);
+ });
+enifed("ember-testing/initializers",
+ ["ember-runtime/system/lazy_load"],
+ function(__dependency1__) {
+ "use strict";
+ var onLoad = __dependency1__.onLoad;
+
+ var name = 'deferReadiness in `testing` mode';
+
+ onLoad('Ember.Application', function(Application) {
+ if (!Application.initializers[name]) {
+ Application.initializer({
+ name: name,
+
+ initialize: function(container, application){
+ if (application.testing) {
+ application.deferReadiness();
+ }
+ }
+ });
+ }
+ });
+ });
+enifed("ember-testing/setup_for_testing",
+ ["ember-metal/core","ember-testing/adapters/qunit","ember-views/system/jquery","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // import Test from "ember-testing/test"; // ES6TODO: fix when cycles are supported
+ var QUnitAdapter = __dependency2__["default"];
+ var jQuery = __dependency3__["default"];
+
+ var Test, requests;
+
+ function incrementAjaxPendingRequests(_, xhr){
+ requests.push(xhr);
+ Test.pendingAjaxRequests = requests.length;
+ }
+
+ function decrementAjaxPendingRequests(_, xhr){
+ for (var i=0;i')
+ .css({ position: 'absolute', left: '-1000px', top: '-1000px' })
+ .appendTo('body')
+ .on('click', handler)
+ .trigger('click')
+ .remove();
+ }
+
+ $(function() {
+ /*
+ Determine whether a checkbox checked using jQuery's "click" method will have
+ the correct value for its checked property.
+
+ If we determine that the current jQuery version exhibits this behavior,
+ patch it to work correctly as in the commit for the actual fix:
+ https://github.com/jquery/jquery/commit/1fb2f92.
+ */
+ testCheckboxClick(function() {
+ if (!this.checked && !$.event.special.click) {
+ $.event.special.click = {
+ // For checkbox, fire native event so checked state will be right
+ trigger: function() {
+ if ($.nodeName( this, "input" ) && this.type === "checkbox" && this.click) {
+ this.click();
+ return false;
+ }
+ }
+ };
+ }
+ });
+
+ // Try again to verify that the patch took effect or blow up.
+ testCheckboxClick(function() {
+ Ember.warn("clicked checkboxes should be checked! the jQuery patch didn't work", this.checked);
+ });
+ });
+ });
+enifed("ember-testing/test",
+ ["ember-metal/core","ember-metal/run_loop","ember-metal/platform","ember-runtime/ext/rsvp","ember-testing/setup_for_testing","ember-application/system/application","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ var emberRun = __dependency2__["default"];
+ var create = __dependency3__.create;
+ var RSVP = __dependency4__["default"];
+ var setupForTesting = __dependency5__["default"];
+ var EmberApplication = __dependency6__["default"];
+
+ /**
+ @module ember
+ @submodule ember-testing
+ */
+ var slice = [].slice;
+ var helpers = {};
+ var injectHelpersCallbacks = [];
+
+ /**
+ This is a container for an assortment of testing related functionality:
+
+ * Choose your default test adapter (for your framework of choice).
+ * Register/Unregister additional test helpers.
+ * Setup callbacks to be fired when the test helpers are injected into
+ your application.
+
+ @class Test
+ @namespace Ember
+ */
+ var Test = {
+ /**
+ Hash containing all known test helpers.
+
+ @property _helpers
+ @private
+ @since 1.7.0
+ */
+ _helpers: helpers,
+
+ /**
+ `registerHelper` is used to register a test helper that will be injected
+ when `App.injectTestHelpers` is called.
+
+ The helper method will always be called with the current Application as
+ the first parameter.
+
+ For example:
+
+ ```javascript
+ Ember.Test.registerHelper('boot', function(app) {
+ Ember.run(app, app.advanceReadiness);
+ });
+ ```
+
+ This helper can later be called without arguments because it will be
+ called with `app` as the first parameter.
+
+ ```javascript
+ App = Ember.Application.create();
+ App.injectTestHelpers();
+ boot();
+ ```
+
+ @public
+ @method registerHelper
+ @param {String} name The name of the helper method to add.
+ @param {Function} helperMethod
+ @param options {Object}
+ */
+ registerHelper: function(name, helperMethod) {
+ helpers[name] = {
+ method: helperMethod,
+ meta: { wait: false }
+ };
+ },
+
+ /**
+ `registerAsyncHelper` is used to register an async test helper that will be injected
+ when `App.injectTestHelpers` is called.
+
+ The helper method will always be called with the current Application as
+ the first parameter.
+
+ For example:
+
+ ```javascript
+ Ember.Test.registerAsyncHelper('boot', function(app) {
+ Ember.run(app, app.advanceReadiness);
+ });
+ ```
+
+ The advantage of an async helper is that it will not run
+ until the last async helper has completed. All async helpers
+ after it will wait for it complete before running.
+
+
+ For example:
+
+ ```javascript
+ Ember.Test.registerAsyncHelper('deletePost', function(app, postId) {
+ click('.delete-' + postId);
+ });
+
+ // ... in your test
+ visit('/post/2');
+ deletePost(2);
+ visit('/post/3');
+ deletePost(3);
+ ```
+
+ @public
+ @method registerAsyncHelper
+ @param {String} name The name of the helper method to add.
+ @param {Function} helperMethod
+ @since 1.2.0
+ */
+ registerAsyncHelper: function(name, helperMethod) {
+ helpers[name] = {
+ method: helperMethod,
+ meta: { wait: true }
+ };
+ },
+
+ /**
+ Remove a previously added helper method.
+
+ Example:
+
+ ```javascript
+ Ember.Test.unregisterHelper('wait');
+ ```
+
+ @public
+ @method unregisterHelper
+ @param {String} name The helper to remove.
+ */
+ unregisterHelper: function(name) {
+ delete helpers[name];
+ delete Test.Promise.prototype[name];
+ },
+
+ /**
+ Used to register callbacks to be fired whenever `App.injectTestHelpers`
+ is called.
+
+ The callback will receive the current application as an argument.
+
+ Example:
+
+ ```javascript
+ Ember.Test.onInjectHelpers(function() {
+ Ember.$(document).ajaxSend(function() {
+ Test.pendingAjaxRequests++;
+ });
+
+ Ember.$(document).ajaxComplete(function() {
+ Test.pendingAjaxRequests--;
+ });
+ });
+ ```
+
+ @public
+ @method onInjectHelpers
+ @param {Function} callback The function to be called.
+ */
+ onInjectHelpers: function(callback) {
+ injectHelpersCallbacks.push(callback);
+ },
+
+ /**
+ This returns a thenable tailored for testing. It catches failed
+ `onSuccess` callbacks and invokes the `Ember.Test.adapter.exception`
+ callback in the last chained then.
+
+ This method should be returned by async helpers such as `wait`.
+
+ @public
+ @method promise
+ @param {Function} resolver The function used to resolve the promise.
+ */
+ promise: function(resolver) {
+ return new Test.Promise(resolver);
+ },
+
+ /**
+ Used to allow ember-testing to communicate with a specific testing
+ framework.
+
+ You can manually set it before calling `App.setupForTesting()`.
+
+ Example:
+
+ ```javascript
+ Ember.Test.adapter = MyCustomAdapter.create()
+ ```
+
+ If you do not set it, ember-testing will default to `Ember.Test.QUnitAdapter`.
+
+ @public
+ @property adapter
+ @type {Class} The adapter to be used.
+ @default Ember.Test.QUnitAdapter
+ */
+ adapter: null,
+
+ /**
+ Replacement for `Ember.RSVP.resolve`
+ The only difference is this uses
+ an instance of `Ember.Test.Promise`
+
+ @public
+ @method resolve
+ @param {Mixed} The value to resolve
+ @since 1.2.0
+ */
+ resolve: function(val) {
+ return Test.promise(function(resolve) {
+ return resolve(val);
+ });
+ },
+
+ /**
+ This allows ember-testing to play nicely with other asynchronous
+ events, such as an application that is waiting for a CSS3
+ transition or an IndexDB transaction.
+
+ For example:
+
+ ```javascript
+ Ember.Test.registerWaiter(function() {
+ return myPendingTransactions() == 0;
+ });
+ ```
+ The `context` argument allows you to optionally specify the `this`
+ with which your callback will be invoked.
+
+ For example:
+
+ ```javascript
+ Ember.Test.registerWaiter(MyDB, MyDB.hasPendingTransactions);
+ ```
+
+ @public
+ @method registerWaiter
+ @param {Object} context (optional)
+ @param {Function} callback
+ @since 1.2.0
+ */
+ registerWaiter: function(context, callback) {
+ if (arguments.length === 1) {
+ callback = context;
+ context = null;
+ }
+ if (!this.waiters) {
+ this.waiters = Ember.A();
+ }
+ this.waiters.push([context, callback]);
+ },
+ /**
+ `unregisterWaiter` is used to unregister a callback that was
+ registered with `registerWaiter`.
+
+ @public
+ @method unregisterWaiter
+ @param {Object} context (optional)
+ @param {Function} callback
+ @since 1.2.0
+ */
+ unregisterWaiter: function(context, callback) {
+ if (!this.waiters) { return; }
+ if (arguments.length === 1) {
+ callback = context;
+ context = null;
+ }
+ this.waiters = Ember.A(this.waiters.filter(function(elt) {
+ return !(elt[0] === context && elt[1] === callback);
+ }));
+ }
+ };
+
+ function helper(app, name) {
+ var fn = helpers[name].method;
+ var meta = helpers[name].meta;
+
+ return function() {
+ var args = slice.call(arguments);
+ var lastPromise = Test.lastPromise;
+
+ args.unshift(app);
+
+ // some helpers are not async and
+ // need to return a value immediately.
+ // example: `find`
+ if (!meta.wait) {
+ return fn.apply(app, args);
+ }
+
+ if (!lastPromise) {
+ // It's the first async helper in current context
+ lastPromise = fn.apply(app, args);
+ } else {
+ // wait for last helper's promise to resolve
+ // and then execute
+ run(function() {
+ lastPromise = Test.resolve(lastPromise).then(function() {
+ return fn.apply(app, args);
+ });
+ });
+ }
+
+ return lastPromise;
+ };
+ }
+
+ function run(fn) {
+ if (!emberRun.currentRunLoop) {
+ emberRun(fn);
+ } else {
+ fn();
+ }
+ }
+
+ EmberApplication.reopen({
+ /**
+ This property contains the testing helpers for the current application. These
+ are created once you call `injectTestHelpers` on your `Ember.Application`
+ instance. The included helpers are also available on the `window` object by
+ default, but can be used from this object on the individual application also.
+
+ @property testHelpers
+ @type {Object}
+ @default {}
+ */
+ testHelpers: {},
+
+ /**
+ This property will contain the original methods that were registered
+ on the `helperContainer` before `injectTestHelpers` is called.
+
+ When `removeTestHelpers` is called, these methods are restored to the
+ `helperContainer`.
+
+ @property originalMethods
+ @type {Object}
+ @default {}
+ @private
+ @since 1.3.0
+ */
+ originalMethods: {},
+
+
+ /**
+ This property indicates whether or not this application is currently in
+ testing mode. This is set when `setupForTesting` is called on the current
+ application.
+
+ @property testing
+ @type {Boolean}
+ @default false
+ @since 1.3.0
+ */
+ testing: false,
+
+ /**
+ This hook defers the readiness of the application, so that you can start
+ the app when your tests are ready to run. It also sets the router's
+ location to 'none', so that the window's location will not be modified
+ (preventing both accidental leaking of state between tests and interference
+ with your testing framework).
+
+ Example:
+
+ ```
+ App.setupForTesting();
+ ```
+
+ @method setupForTesting
+ */
+ setupForTesting: function() {
+ setupForTesting();
+
+ this.testing = true;
+
+ this.Router.reopen({
+ location: 'none'
+ });
+ },
+
+ /**
+ This will be used as the container to inject the test helpers into. By
+ default the helpers are injected into `window`.
+
+ @property helperContainer
+ @type {Object} The object to be used for test helpers.
+ @default window
+ @since 1.2.0
+ */
+ helperContainer: window,
+
+ /**
+ This injects the test helpers into the `helperContainer` object. If an object is provided
+ it will be used as the helperContainer. If `helperContainer` is not set it will default
+ to `window`. If a function of the same name has already been defined it will be cached
+ (so that it can be reset if the helper is removed with `unregisterHelper` or
+ `removeTestHelpers`).
+
+ Any callbacks registered with `onInjectHelpers` will be called once the
+ helpers have been injected.
+
+ Example:
+ ```
+ App.injectTestHelpers();
+ ```
+
+ @method injectTestHelpers
+ */
+ injectTestHelpers: function(helperContainer) {
+ if (helperContainer) { this.helperContainer = helperContainer; }
+
+ this.testHelpers = {};
+ for (var name in helpers) {
+ this.originalMethods[name] = this.helperContainer[name];
+ this.testHelpers[name] = this.helperContainer[name] = helper(this, name);
+ protoWrap(Test.Promise.prototype, name, helper(this, name), helpers[name].meta.wait);
+ }
+
+ for(var i = 0, l = injectHelpersCallbacks.length; i < l; i++) {
+ injectHelpersCallbacks[i](this);
+ }
+ },
+
+ /**
+ This removes all helpers that have been registered, and resets and functions
+ that were overridden by the helpers.
+
+ Example:
+
+ ```javascript
+ App.removeTestHelpers();
+ ```
+
+ @public
+ @method removeTestHelpers
+ */
+ removeTestHelpers: function() {
+ for (var name in helpers) {
+ this.helperContainer[name] = this.originalMethods[name];
+ delete this.testHelpers[name];
+ delete this.originalMethods[name];
+ }
+ }
+ });
+
+ // This method is no longer needed
+ // But still here for backwards compatibility
+ // of helper chaining
+ function protoWrap(proto, name, callback, isAsync) {
+ proto[name] = function() {
+ var args = arguments;
+ if (isAsync) {
+ return callback.apply(this, args);
+ } else {
+ return this.then(function() {
+ return callback.apply(this, args);
+ });
+ }
+ };
+ }
+
+ Test.Promise = function() {
+ RSVP.Promise.apply(this, arguments);
+ Test.lastPromise = this;
+ };
+
+ Test.Promise.prototype = create(RSVP.Promise.prototype);
+ Test.Promise.prototype.constructor = Test.Promise;
+
+ // Patch `then` to isolate async methods
+ // specifically `Ember.Test.lastPromise`
+ var originalThen = RSVP.Promise.prototype.then;
+ Test.Promise.prototype.then = function(onSuccess, onFailure) {
+ return originalThen.call(this, function(val) {
+ return isolate(onSuccess, val);
+ }, onFailure);
+ };
+
+ // This method isolates nested async methods
+ // so that they don't conflict with other last promises.
+ //
+ // 1. Set `Ember.Test.lastPromise` to null
+ // 2. Invoke method
+ // 3. Return the last promise created during method
+ // 4. Restore `Ember.Test.lastPromise` to original value
+ function isolate(fn, val) {
+ var value, lastPromise;
+
+ // Reset lastPromise for nested helpers
+ Test.lastPromise = null;
+
+ value = fn(val);
+
+ lastPromise = Test.lastPromise;
+
+ // If the method returned a promise
+ // return that promise. If not,
+ // return the last async helper's promise
+ if ((value && (value instanceof Test.Promise)) || !lastPromise) {
+ return value;
+ } else {
+ run(function() {
+ lastPromise = Test.resolve(lastPromise).then(function() {
+ return value;
+ });
+ });
+ return lastPromise;
+ }
+ }
+
+ __exports__["default"] = Test;
+ });
+enifed("ember-views",
+ ["ember-runtime","ember-views/system/jquery","ember-views/system/utils","ember-views/system/render_buffer","ember-views/system/ext","ember-views/views/states","ember-views/views/core_view","ember-views/views/view","ember-views/views/container_view","ember-views/views/collection_view","ember-views/views/component","ember-views/system/event_dispatcher","ember-views/mixins/view_target_action_support","ember-views/component_lookup","ember-views/views/checkbox","ember-views/mixins/text_support","ember-views/views/text_field","ember-views/views/text_area","ember-views/views/bound_view","ember-views/views/simple_bound_view","ember-views/views/metamorph_view","ember-views/views/select","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __dependency21__, __dependency22__, __exports__) {
+ "use strict";
+ /**
+ Ember Views
+
+ @module ember
+ @submodule ember-views
+ @requires ember-runtime
+ @main ember-views
+ */
+
+ // BEGIN IMPORTS
+ var Ember = __dependency1__["default"];
+ var jQuery = __dependency2__["default"];
+ var isSimpleClick = __dependency3__.isSimpleClick;
+ var getViewClientRects = __dependency3__.getViewClientRects;
+ var getViewBoundingClientRect = __dependency3__.getViewBoundingClientRect;
+ var RenderBuffer = __dependency4__["default"];
+ // for the side effect of extending Ember.run.queues
+ var cloneStates = __dependency6__.cloneStates;
+ var states = __dependency6__.states;
+
+ var CoreView = __dependency7__["default"];
+ var View = __dependency8__["default"];
+ var ContainerView = __dependency9__["default"];
+ var CollectionView = __dependency10__["default"];
+ var Component = __dependency11__["default"];
+
+ var EventDispatcher = __dependency12__["default"];
+ var ViewTargetActionSupport = __dependency13__["default"];
+ var ComponentLookup = __dependency14__["default"];
+ var Checkbox = __dependency15__["default"];
+ var TextSupport = __dependency16__["default"];
+ var TextField = __dependency17__["default"];
+ var TextArea = __dependency18__["default"];
+
+ var BoundView = __dependency19__["default"];
+ var SimpleBoundView = __dependency20__["default"];
+ var _MetamorphView = __dependency21__["default"];
+ var _SimpleMetamorphView = __dependency21__._SimpleMetamorphView;
+ var _Metamorph = __dependency21__._Metamorph;
+ var Select = __dependency22__.Select;
+ var SelectOption = __dependency22__.SelectOption;
+ var SelectOptgroup = __dependency22__.SelectOptgroup;
+ // END IMPORTS
+
+ /**
+ Alias for jQuery
+
+ @method $
+ @for Ember
+ */
+
+ // BEGIN EXPORTS
+ Ember.$ = jQuery;
+
+ Ember.ViewTargetActionSupport = ViewTargetActionSupport;
+ Ember.RenderBuffer = RenderBuffer;
+
+ var ViewUtils = Ember.ViewUtils = {};
+ ViewUtils.isSimpleClick = isSimpleClick;
+ ViewUtils.getViewClientRects = getViewClientRects;
+ ViewUtils.getViewBoundingClientRect = getViewBoundingClientRect;
+
+ Ember.CoreView = CoreView;
+ Ember.View = View;
+ Ember.View.states = states;
+ Ember.View.cloneStates = cloneStates;
+ Ember.Checkbox = Checkbox;
+ Ember.TextField = TextField;
+ Ember.TextArea = TextArea;
+
+ Ember._SimpleBoundView = SimpleBoundView;
+ Ember._BoundView = BoundView;
+ Ember._SimpleMetamorphView = _SimpleMetamorphView;
+ Ember._MetamorphView = _MetamorphView;
+ Ember._Metamorph = _Metamorph;
+ Ember.Select = Select;
+ Ember.SelectOption = SelectOption;
+ Ember.SelectOptgroup = SelectOptgroup;
+
+ Ember.TextSupport = TextSupport;
+ Ember.ComponentLookup = ComponentLookup;
+ Ember.ContainerView = ContainerView;
+ Ember.CollectionView = CollectionView;
+ Ember.Component = Component;
+ Ember.EventDispatcher = EventDispatcher;
+ // END EXPORTS
+
+ __exports__["default"] = Ember;
+ });
+enifed("ember-views/attr_nodes/attr_node",
+ ["ember-metal/streams/utils","ember-metal/run_loop","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var read = __dependency1__.read;
+ var subscribe = __dependency1__.subscribe;
+ var unsubscribe = __dependency1__.unsubscribe;
+ var run = __dependency2__["default"];
+
+ function AttrNode(attrName, attrValue) {
+ this.init(attrName, attrValue);
+ }
+
+ AttrNode.prototype.init = function init(attrName, simpleAttrValue){
+ this.isView = true;
+
+ // That these semantics are used is very unfortunate.
+ this.tagName = '';
+ this.classNameBindings = [];
+
+ this.attrName = attrName;
+ this.attrValue = simpleAttrValue;
+ this.isDirty = true;
+ this.lastValue = null;
+
+ subscribe(this.attrValue, this.rerender, this);
+ };
+
+ AttrNode.prototype.renderIfDirty = function renderIfDirty(){
+ if (this.isDirty) {
+ var value = read(this.attrValue);
+ if (value !== this.lastValue) {
+ this._renderer.renderTree(this, this._parentView);
+ } else {
+ this.isDirty = false;
+ }
+ }
+ };
+
+ AttrNode.prototype.render = function render(buffer) {
+ this.isDirty = false;
+ var value = read(this.attrValue);
+
+ this._morph.setContent(value);
+
+ this.lastValue = value;
+ };
+
+ AttrNode.prototype.rerender = function render() {
+ this.isDirty = true;
+ run.schedule('render', this, this.renderIfDirty);
+ };
+
+ AttrNode.prototype.destroy = function render() {
+ this.isDirty = false;
+ unsubscribe(this.attrValue, this.rerender, this);
+
+ var parent = this._parentView;
+ if (parent) { parent.removeChild(this); }
+ };
+
+ __exports__["default"] = AttrNode;
+ });
+enifed("ember-views/attr_nodes/legacy_bind",
+ ["./attr_node","ember-runtime/system/string","ember-metal/utils","ember-metal/streams/utils","ember-metal/platform/create","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-htmlbars
+ */
+
+ var AttrNode = __dependency1__["default"];
+ var fmt = __dependency2__.fmt;
+ var typeOf = __dependency3__.typeOf;
+ var read = __dependency4__.read;
+ var create = __dependency5__["default"];
+
+ function LegacyBindAttrNode(attrName, attrValue) {
+ this.init(attrName, attrValue);
+ }
+
+ LegacyBindAttrNode.prototype = create(AttrNode.prototype);
+
+ LegacyBindAttrNode.prototype.render = function render(buffer) {
+ this.isDirty = false;
+ var value = read(this.attrValue);
+ var type = typeOf(value);
+
+ Ember.assert(fmt("Attributes must be numbers, strings or booleans, not %@", [value]),
+ value === null || value === undefined || type === 'number' || type === 'string' || type === 'boolean');
+
+ this._morph.setContent(value);
+
+ this.lastValue = value;
+ };
+
+ __exports__["default"] = LegacyBindAttrNode;
+ });
+enifed("ember-views/component_lookup",
+ ["ember-runtime/system/object","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var EmberObject = __dependency1__["default"];
+
+ __exports__["default"] = EmberObject.extend({
+ lookupFactory: function(name, container) {
+
+ container = container || this.container;
+
+ var fullName = 'component:' + name;
+ var templateFullName = 'template:components/' + name;
+ var templateRegistered = container && container.has(templateFullName);
+
+ if (templateRegistered) {
+ container.injection(fullName, 'layout', templateFullName);
+ }
+
+ var Component = container.lookupFactory(fullName);
+
+ // Only treat as a component if either the component
+ // or a template has been registered.
+ if (templateRegistered || Component) {
+ if (!Component) {
+ container.register(fullName, Ember.Component);
+ Component = container.lookupFactory(fullName);
+ }
+ return Component;
+ }
+ }
+ });
+ });
+enifed("ember-views/mixins/component_template_deprecation",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/mixin","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // Ember.deprecate
+ var get = __dependency2__.get;
+ var Mixin = __dependency3__.Mixin;
+
+ /**
+ The ComponentTemplateDeprecation mixin is used to provide a useful
+ deprecation warning when using either `template` or `templateName` with
+ a component. The `template` and `templateName` properties specified at
+ extend time are moved to `layout` and `layoutName` respectively.
+
+ `Ember.ComponentTemplateDeprecation` is used internally by Ember in
+ `Ember.Component`.
+
+ @class ComponentTemplateDeprecation
+ @namespace Ember
+ */
+ __exports__["default"] = Mixin.create({
+ /**
+ @private
+
+ Moves `templateName` to `layoutName` and `template` to `layout` at extend
+ time if a layout is not also specified.
+
+ Note that this currently modifies the mixin themselves, which is technically
+ dubious but is practically of little consequence. This may change in the
+ future.
+
+ @method willMergeMixin
+ @since 1.4.0
+ */
+ willMergeMixin: function(props) {
+ // must call _super here to ensure that the ActionHandler
+ // mixin is setup properly (moves actions -> _actions)
+ //
+ // Calling super is only OK here since we KNOW that
+ // there is another Mixin loaded first.
+ this._super.apply(this, arguments);
+
+ var deprecatedProperty, replacementProperty;
+ var layoutSpecified = (props.layoutName || props.layout || get(this, 'layoutName'));
+
+ if (props.templateName && !layoutSpecified) {
+ deprecatedProperty = 'templateName';
+ replacementProperty = 'layoutName';
+
+ props.layoutName = props.templateName;
+ delete props['templateName'];
+ }
+
+ if (props.template && !layoutSpecified) {
+ deprecatedProperty = 'template';
+ replacementProperty = 'layout';
+
+ props.layout = props.template;
+ delete props['template'];
+ }
+
+ Ember.deprecate('Do not specify ' + deprecatedProperty + ' on a Component, use ' + replacementProperty + ' instead.', !deprecatedProperty);
+ }
+ });
+ });
+enifed("ember-views/mixins/text_support",
+ ["ember-metal/property_get","ember-metal/property_set","ember-metal/mixin","ember-runtime/mixins/target_action_support","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-views
+ */
+
+ var get = __dependency1__.get;
+ var set = __dependency2__.set;
+ var Mixin = __dependency3__.Mixin;
+ var TargetActionSupport = __dependency4__["default"];
+
+ /**
+ `TextSupport` is a shared mixin used by both `Ember.TextField` and
+ `Ember.TextArea`. `TextSupport` adds a number of methods that allow you to
+ specify a controller action to invoke when a certain event is fired on your
+ text field or textarea. The specifed controller action would get the current
+ value of the field passed in as the only argument unless the value of
+ the field is empty. In that case, the instance of the field itself is passed
+ in as the only argument.
+
+ Let's use the pressing of the escape key as an example. If you wanted to
+ invoke a controller action when a user presses the escape key while on your
+ field, you would use the `escape-press` attribute on your field like so:
+
+ ```handlebars
+ {{! application.hbs}}
+
+ {{input escape-press='alertUser'}}
+ ```
+
+ ```javascript
+ App = Ember.Application.create();
+
+ App.ApplicationController = Ember.Controller.extend({
+ actions: {
+ alertUser: function ( currentValue ) {
+ alert( 'escape pressed, current value: ' + currentValue );
+ }
+ }
+ });
+ ```
+
+ The following chart is a visual representation of what takes place when the
+ escape key is pressed in this scenario:
+
+ The Template
+ +---------------------------+
+ | |
+ | escape-press='alertUser' |
+ | | TextSupport Mixin
+ +----+----------------------+ +-------------------------------+
+ | | cancel method |
+ | escape button pressed | |
+ +-------------------------------> | checks for the `escape-press` |
+ | attribute and pulls out the |
+ +-------------------------------+ | `alertUser` value |
+ | action name 'alertUser' +-------------------------------+
+ | sent to controller
+ v
+ Controller
+ +------------------------------------------ +
+ | |
+ | actions: { |
+ | alertUser: function( currentValue ){ |
+ | alert( 'the esc key was pressed!' ) |
+ | } |
+ | } |
+ | |
+ +-------------------------------------------+
+
+ Here are the events that we currently support along with the name of the
+ attribute you would need to use on your field. To reiterate, you would use the
+ attribute name like so:
+
+ ```handlebars
+ {{input attribute-name='controllerAction'}}
+ ```
+
+ +--------------------+----------------+
+ | | |
+ | event | attribute name |
+ +--------------------+----------------+
+ | new line inserted | insert-newline |
+ | | |
+ | enter key pressed | insert-newline |
+ | | |
+ | cancel key pressed | escape-press |
+ | | |
+ | focusin | focus-in |
+ | | |
+ | focusout | focus-out |
+ | | |
+ | keypress | key-press |
+ | | |
+ | keyup | key-up |
+ | | |
+ | keydown | key-down |
+ +--------------------+----------------+
+
+ @class TextSupport
+ @namespace Ember
+ @uses Ember.TargetActionSupport
+ @extends Ember.Mixin
+ @private
+ */
+ var TextSupport = Mixin.create(TargetActionSupport, {
+ value: "",
+
+ attributeBindings: [
+ 'autocapitalize',
+ 'autocorrect',
+ 'autofocus',
+ 'disabled',
+ 'form',
+ 'maxlength',
+ 'placeholder',
+ 'readonly',
+ 'required',
+ 'selectionDirection',
+ 'spellcheck',
+ 'tabindex',
+ 'title'
+ ],
+ placeholder: null,
+ disabled: false,
+ maxlength: null,
+
+ init: function() {
+ this._super();
+ this.on("paste", this, this._elementValueDidChange);
+ this.on("cut", this, this._elementValueDidChange);
+ this.on("input", this, this._elementValueDidChange);
+ },
+
+ /**
+ The action to be sent when the user presses the return key.
+
+ This is similar to the `{{action}}` helper, but is fired when
+ the user presses the return key when editing a text field, and sends
+ the value of the field as the context.
+
+ @property action
+ @type String
+ @default null
+ */
+ action: null,
+
+ /**
+ The event that should send the action.
+
+ Options are:
+
+ * `enter`: the user pressed enter
+ * `keyPress`: the user pressed a key
+
+ @property onEvent
+ @type String
+ @default enter
+ */
+ onEvent: 'enter',
+
+ /**
+ Whether the `keyUp` event that triggers an `action` to be sent continues
+ propagating to other views.
+
+ By default, when the user presses the return key on their keyboard and
+ the text field has an `action` set, the action will be sent to the view's
+ controller and the key event will stop propagating.
+
+ If you would like parent views to receive the `keyUp` event even after an
+ action has been dispatched, set `bubbles` to true.
+
+ @property bubbles
+ @type Boolean
+ @default false
+ */
+ bubbles: false,
+
+ interpretKeyEvents: function(event) {
+ var map = TextSupport.KEY_EVENTS;
+ var method = map[event.keyCode];
+
+ this._elementValueDidChange();
+ if (method) { return this[method](event); }
+ },
+
+ _elementValueDidChange: function() {
+ set(this, 'value', this.$().val());
+ },
+
+ change: function(event) {
+ this._elementValueDidChange(event);
+ },
+
+ /**
+ Allows you to specify a controller action to invoke when either the `enter`
+ key is pressed or, in the case of the field being a textarea, when a newline
+ is inserted. To use this method, give your field an `insert-newline`
+ attribute. The value of that attribute should be the name of the action
+ in your controller that you wish to invoke.
+
+ For an example on how to use the `insert-newline` attribute, please
+ reference the example near the top of this file.
+
+ @method insertNewline
+ @param {Event} event
+ */
+ insertNewline: function(event) {
+ sendAction('enter', this, event);
+ sendAction('insert-newline', this, event);
+ },
+
+ /**
+ Allows you to specify a controller action to invoke when the escape button
+ is pressed. To use this method, give your field an `escape-press`
+ attribute. The value of that attribute should be the name of the action
+ in your controller that you wish to invoke.
+
+ For an example on how to use the `escape-press` attribute, please reference
+ the example near the top of this file.
+
+ @method cancel
+ @param {Event} event
+ */
+ cancel: function(event) {
+ sendAction('escape-press', this, event);
+ },
+
+ /**
+ Allows you to specify a controller action to invoke when a field receives
+ focus. To use this method, give your field a `focus-in` attribute. The value
+ of that attribute should be the name of the action in your controller
+ that you wish to invoke.
+
+ For an example on how to use the `focus-in` attribute, please reference the
+ example near the top of this file.
+
+ @method focusIn
+ @param {Event} event
+ */
+ focusIn: function(event) {
+ sendAction('focus-in', this, event);
+ },
+
+ /**
+ Allows you to specify a controller action to invoke when a field loses
+ focus. To use this method, give your field a `focus-out` attribute. The value
+ of that attribute should be the name of the action in your controller
+ that you wish to invoke.
+
+ For an example on how to use the `focus-out` attribute, please reference the
+ example near the top of this file.
+
+ @method focusOut
+ @param {Event} event
+ */
+ focusOut: function(event) {
+ this._elementValueDidChange(event);
+ sendAction('focus-out', this, event);
+ },
+
+ /**
+ Allows you to specify a controller action to invoke when a key is pressed.
+ To use this method, give your field a `key-press` attribute. The value of
+ that attribute should be the name of the action in your controller you
+ that wish to invoke.
+
+ For an example on how to use the `key-press` attribute, please reference the
+ example near the top of this file.
+
+ @method keyPress
+ @param {Event} event
+ */
+ keyPress: function(event) {
+ sendAction('key-press', this, event);
+ },
+
+ /**
+ Allows you to specify a controller action to invoke when a key-up event is
+ fired. To use this method, give your field a `key-up` attribute. The value
+ of that attribute should be the name of the action in your controller
+ that you wish to invoke.
+
+ For an example on how to use the `key-up` attribute, please reference the
+ example near the top of this file.
+
+ @method keyUp
+ @param {Event} event
+ */
+ keyUp: function(event) {
+ this.interpretKeyEvents(event);
+
+ this.sendAction('key-up', get(this, 'value'), event);
+ },
+
+ /**
+ Allows you to specify a controller action to invoke when a key-down event is
+ fired. To use this method, give your field a `key-down` attribute. The value
+ of that attribute should be the name of the action in your controller that
+ you wish to invoke.
+
+ For an example on how to use the `key-down` attribute, please reference the
+ example near the top of this file.
+
+ @method keyDown
+ @param {Event} event
+ */
+ keyDown: function(event) {
+ this.sendAction('key-down', get(this, 'value'), event);
+ }
+ });
+
+ TextSupport.KEY_EVENTS = {
+ 13: 'insertNewline',
+ 27: 'cancel'
+ };
+
+ // In principle, this shouldn't be necessary, but the legacy
+ // sendAction semantics for TextField are different from
+ // the component semantics so this method normalizes them.
+ function sendAction(eventName, view, event) {
+ var action = get(view, eventName);
+ var on = get(view, 'onEvent');
+ var value = get(view, 'value');
+
+ // back-compat support for keyPress as an event name even though
+ // it's also a method name that consumes the event (and therefore
+ // incompatible with sendAction semantics).
+ if (on === eventName || (on === 'keyPress' && eventName === 'key-press')) {
+ view.sendAction('action', value);
+ }
+
+ view.sendAction(eventName, value);
+
+ if (action || on === eventName) {
+ if(!get(view, 'bubbles')) {
+ event.stopPropagation();
+ }
+ }
+ }
+
+ __exports__["default"] = TextSupport;
+ });
+enifed("ember-views/mixins/view_target_action_support",
+ ["ember-metal/mixin","ember-runtime/mixins/target_action_support","ember-metal/alias","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var Mixin = __dependency1__.Mixin;
+ var TargetActionSupport = __dependency2__["default"];
+ var alias = __dependency3__["default"];
+
+ /**
+ `Ember.ViewTargetActionSupport` is a mixin that can be included in a
+ view class to add a `triggerAction` method with semantics similar to
+ the Handlebars `{{action}}` helper. It provides intelligent defaults
+ for the action's target: the view's controller; and the context that is
+ sent with the action: the view's context.
+
+ Note: In normal Ember usage, the `{{action}}` helper is usually the best
+ choice. This mixin is most often useful when you are doing more complex
+ event handling in custom View subclasses.
+
+ For example:
+
+ ```javascript
+ App.SaveButtonView = Ember.View.extend(Ember.ViewTargetActionSupport, {
+ action: 'save',
+ click: function() {
+ this.triggerAction(); // Sends the `save` action, along with the current context
+ // to the current controller
+ }
+ });
+ ```
+
+ The `action` can be provided as properties of an optional object argument
+ to `triggerAction` as well.
+
+ ```javascript
+ App.SaveButtonView = Ember.View.extend(Ember.ViewTargetActionSupport, {
+ click: function() {
+ this.triggerAction({
+ action: 'save'
+ }); // Sends the `save` action, along with the current context
+ // to the current controller
+ }
+ });
+ ```
+
+ @class ViewTargetActionSupport
+ @namespace Ember
+ @extends Ember.TargetActionSupport
+ */
+ __exports__["default"] = Mixin.create(TargetActionSupport, {
+ /**
+ @property target
+ */
+ target: alias('controller'),
+ /**
+ @property actionContext
+ */
+ actionContext: alias('context')
+ });
+ });
+enifed("ember-views/streams/class_name_binding",
+ ["ember-metal/streams/utils","ember-metal/property_get","ember-runtime/system/string","ember-metal/utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ var chain = __dependency1__.chain;
+ var read = __dependency1__.read;
+ var get = __dependency2__.get;
+ var dasherize = __dependency3__.dasherize;
+ var isArray = __dependency4__.isArray;
+
+ /**
+ Parse a path and return an object which holds the parsed properties.
+
+ For example a path like "content.isEnabled:enabled:disabled" will return the
+ following object:
+
+ ```javascript
+ {
+ path: "content.isEnabled",
+ className: "enabled",
+ falsyClassName: "disabled",
+ classNames: ":enabled:disabled"
+ }
+ ```
+
+ @method parsePropertyPath
+ @static
+ @private
+ */
+ function parsePropertyPath(path) {
+ var split = path.split(':');
+ var propertyPath = split[0];
+ var classNames = "";
+ var className, falsyClassName;
+
+ // check if the property is defined as prop:class or prop:trueClass:falseClass
+ if (split.length > 1) {
+ className = split[1];
+ if (split.length === 3) {
+ falsyClassName = split[2];
+ }
+
+ classNames = ':' + className;
+ if (falsyClassName) {
+ classNames += ":" + falsyClassName;
+ }
+ }
+
+ return {
+ path: propertyPath,
+ classNames: classNames,
+ className: (className === '') ? undefined : className,
+ falsyClassName: falsyClassName
+ };
+ }
+
+ __exports__.parsePropertyPath = parsePropertyPath;/**
+ Get the class name for a given value, based on the path, optional
+ `className` and optional `falsyClassName`.
+
+ - if a `className` or `falsyClassName` has been specified:
+ - if the value is truthy and `className` has been specified,
+ `className` is returned
+ - if the value is falsy and `falsyClassName` has been specified,
+ `falsyClassName` is returned
+ - otherwise `null` is returned
+ - if the value is `true`, the dasherized last part of the supplied path
+ is returned
+ - if the value is not `false`, `undefined` or `null`, the `value`
+ is returned
+ - if none of the above rules apply, `null` is returned
+
+ @method classStringForValue
+ @param path
+ @param val
+ @param className
+ @param falsyClassName
+ @static
+ @private
+ */
+ function classStringForValue(path, val, className, falsyClassName) {
+ if(isArray(val)) {
+ val = get(val, 'length') !== 0;
+ }
+
+ // When using the colon syntax, evaluate the truthiness or falsiness
+ // of the value to determine which className to return
+ if (className || falsyClassName) {
+ if (className && !!val) {
+ return className;
+
+ } else if (falsyClassName && !val) {
+ return falsyClassName;
+
+ } else {
+ return null;
+ }
+
+ // If value is a Boolean and true, return the dasherized property
+ // name.
+ } else if (val === true) {
+ // Normalize property path to be suitable for use
+ // as a class name. For exaple, content.foo.barBaz
+ // becomes bar-baz.
+ var parts = path.split('.');
+ return dasherize(parts[parts.length-1]);
+
+ // If the value is not false, undefined, or null, return the current
+ // value of the property.
+ } else if (val !== false && val != null) {
+ return val;
+
+ // Nothing to display. Return null so that the old class is removed
+ // but no new class is added.
+ } else {
+ return null;
+ }
+ }
+
+ __exports__.classStringForValue = classStringForValue;function streamifyClassNameBinding(view, classNameBinding, prefix){
+ prefix = prefix || '';
+ Ember.assert("classNameBindings must not have spaces in them. Multiple class name bindings can be provided as elements of an array, e.g. ['foo', ':bar']", classNameBinding.indexOf(' ') === -1);
+ var parsedPath = parsePropertyPath(classNameBinding);
+ if (parsedPath.path === '') {
+ return classStringForValue(
+ parsedPath.path,
+ true,
+ parsedPath.className,
+ parsedPath.falsyClassName
+ );
+ } else {
+ var pathValue = view.getStream(prefix+parsedPath.path);
+ return chain(pathValue, function() {
+ return classStringForValue(
+ parsedPath.path,
+ read(pathValue),
+ parsedPath.className,
+ parsedPath.falsyClassName
+ );
+ });
+ }
+ }
+
+ __exports__.streamifyClassNameBinding = streamifyClassNameBinding;
+ });
+enifed("ember-views/streams/conditional_stream",
+ ["ember-metal/streams/stream","ember-metal/streams/utils","ember-metal/platform","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var Stream = __dependency1__["default"];
+ var read = __dependency2__.read;
+ var subscribe = __dependency2__.subscribe;
+ var unsubscribe = __dependency2__.unsubscribe;
+ var create = __dependency3__.create;
+
+ function ConditionalStream(test, consequent, alternate) {
+ this.init();
+
+ this.oldTestResult = undefined;
+ this.test = test;
+ this.consequent = consequent;
+ this.alternate = alternate;
+ }
+
+ ConditionalStream.prototype = create(Stream.prototype);
+
+ ConditionalStream.prototype.valueFn = function() {
+ var oldTestResult = this.oldTestResult;
+ var newTestResult = !!read(this.test);
+
+ if (newTestResult !== oldTestResult) {
+ switch (oldTestResult) {
+ case true: unsubscribe(this.consequent, this.notify, this); break;
+ case false: unsubscribe(this.alternate, this.notify, this); break;
+ case undefined: subscribe(this.test, this.notify, this);
+ }
+
+ switch (newTestResult) {
+ case true: subscribe(this.consequent, this.notify, this); break;
+ case false: subscribe(this.alternate, this.notify, this);
+ }
+
+ this.oldTestResult = newTestResult;
+ }
+
+ return newTestResult ? read(this.consequent) : read(this.alternate);
+ };
+
+ __exports__["default"] = ConditionalStream;
+ });
+enifed("ember-views/streams/context_stream",
+ ["ember-metal/core","ember-metal/merge","ember-metal/platform","ember-metal/path_cache","ember-metal/streams/stream","ember-metal/streams/simple","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+
+ var merge = __dependency2__["default"];
+ var create = __dependency3__.create;
+ var isGlobal = __dependency4__.isGlobal;
+ var Stream = __dependency5__["default"];
+ var SimpleStream = __dependency6__["default"];
+
+ function ContextStream(view) {
+ Ember.assert("ContextStream error: the argument is not a view", view && view.isView);
+
+ this.init();
+ this.view = view;
+ }
+
+ ContextStream.prototype = create(Stream.prototype);
+
+ merge(ContextStream.prototype, {
+ value: function() {},
+
+ _makeChildStream: function(key, _fullPath) {
+ var stream;
+
+ if (key === '' || key === 'this') {
+ stream = this.view._baseContext;
+ } else if (isGlobal(key) && Ember.lookup[key]) {
+ Ember.deprecate("Global lookup of " + _fullPath + " from a Handlebars template is deprecated.");
+ stream = new SimpleStream(Ember.lookup[key]);
+ stream._isGlobal = true;
+ } else if (key in this.view._keywords) {
+ stream = new SimpleStream(this.view._keywords[key]);
+ } else {
+ stream = new SimpleStream(this.view._baseContext.get(key));
+ }
+
+ stream._isRoot = true;
+
+ if (key === 'controller') {
+ stream._isController = true;
+ }
+
+ return stream;
+ }
+ });
+
+ __exports__["default"] = ContextStream;
+ });
+enifed("ember-views/streams/key_stream",
+ ["ember-metal/core","ember-metal/merge","ember-metal/platform","ember-metal/property_get","ember-metal/property_set","ember-metal/observer","ember-metal/streams/stream","ember-metal/streams/utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+
+ var merge = __dependency2__["default"];
+ var create = __dependency3__.create;
+ var get = __dependency4__.get;
+ var set = __dependency5__.set;
+ var addObserver = __dependency6__.addObserver;
+ var removeObserver = __dependency6__.removeObserver;
+ var Stream = __dependency7__["default"];
+ var read = __dependency8__.read;
+ var isStream = __dependency8__.isStream;
+
+ function KeyStream(source, key) {
+ Ember.assert("KeyStream error: key must be a non-empty string", typeof key === 'string' && key.length > 0);
+ Ember.assert("KeyStream error: key must not have a '.'", key.indexOf('.') === -1);
+
+ this.init();
+ this.source = source;
+ this.obj = undefined;
+ this.key = key;
+
+ if (isStream(source)) {
+ source.subscribe(this._didChange, this);
+ }
+ }
+
+ KeyStream.prototype = create(Stream.prototype);
+
+ merge(KeyStream.prototype, {
+ valueFn: function() {
+ var prevObj = this.obj;
+ var nextObj = read(this.source);
+
+ if (nextObj !== prevObj) {
+ if (prevObj && typeof prevObj === 'object') {
+ removeObserver(prevObj, this.key, this, this._didChange);
+ }
+
+ if (nextObj && typeof nextObj === 'object') {
+ addObserver(nextObj, this.key, this, this._didChange);
+ }
+
+ this.obj = nextObj;
+ }
+
+ if (nextObj) {
+ return get(nextObj, this.key);
+ }
+ },
+
+ setValue: function(value) {
+ if (this.obj) {
+ set(this.obj, this.key, value);
+ }
+ },
+
+ setSource: function(nextSource) {
+ Ember.assert("KeyStream error: source must be an object", typeof nextSource === 'object');
+
+ var prevSource = this.source;
+
+ if (nextSource !== prevSource) {
+ if (isStream(prevSource)) {
+ prevSource.unsubscribe(this._didChange, this);
+ }
+
+ if (isStream(nextSource)) {
+ nextSource.subscribe(this._didChange, this);
+ }
+
+ this.source = nextSource;
+ this.notify();
+ }
+ },
+
+ _didChange: function() {
+ this.notify();
+ },
+
+ _super$destroy: Stream.prototype.destroy,
+
+ destroy: function() {
+ if (this._super$destroy()) {
+ if (isStream(this.source)) {
+ this.source.unsubscribe(this._didChange, this);
+ }
+
+ if (this.obj && typeof this.obj === 'object') {
+ removeObserver(this.obj, this.key, this, this._didChange);
+ }
+
+ this.source = undefined;
+ this.obj = undefined;
+ return true;
+ }
+ }
+ });
+
+ __exports__["default"] = KeyStream;
+
+ // The transpiler does not resolve cycles, so we export
+ // the `_makeChildStream` method onto `Stream` here.
+
+ Stream.prototype._makeChildStream = function(key) {
+ return new KeyStream(this, key);
+ };
+ });
+enifed("ember-views/streams/utils",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/path_cache","ember-runtime/system/string","ember-metal/streams/utils","ember-views/views/view","ember-runtime/mixins/controller","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ var get = __dependency2__.get;
+ var isGlobal = __dependency3__.isGlobal;
+ var fmt = __dependency4__.fmt;
+ var read = __dependency5__.read;
+ var isStream = __dependency5__.isStream;
+ var View = __dependency6__["default"];
+ var ControllerMixin = __dependency7__["default"];
+
+ function readViewFactory(object, container) {
+ var value = read(object);
+ var viewClass;
+
+ if (typeof value === 'string') {
+ if (isGlobal(value)) {
+ viewClass = get(null, value);
+ Ember.deprecate('Resolved the view "'+value+'" on the global context. Pass a view name to be looked up on the container instead, such as {{view "select"}}.', !viewClass, { url: 'http://emberjs.com/guides/deprecations/#toc_global-lookup-of-views' });
+ } else {
+ Ember.assert("View requires a container to resolve views not passed in through the context", !!container);
+ viewClass = container.lookupFactory('view:'+value);
+ }
+ } else {
+ viewClass = value;
+ }
+
+ Ember.assert(fmt(value+" must be a subclass or an instance of Ember.View, not %@", [viewClass]), View.detect(viewClass) || View.detectInstance(viewClass));
+
+ return viewClass;
+ }
+
+ __exports__.readViewFactory = readViewFactory;function readUnwrappedModel(object) {
+ if (isStream(object)) {
+ var result = object.value();
+
+ // If the path is exactly `controller` then we don't unwrap it.
+ if (!object._isController) {
+ while (ControllerMixin.detect(result)) {
+ result = get(result, 'model');
+ }
+ }
+
+ return result;
+ } else {
+ return object;
+ }
+ }
+
+ __exports__.readUnwrappedModel = readUnwrappedModel;
+ });
+enifed("ember-views/system/action_manager",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-views
+ */
+
+ function ActionManager() {}
+
+ /**
+ Global action id hash.
+
+ @private
+ @property registeredActions
+ @type Object
+ */
+ ActionManager.registeredActions = {};
+
+ __exports__["default"] = ActionManager;
+ });
+enifed("ember-views/system/event_dispatcher",
+ ["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/is_none","ember-metal/run_loop","ember-metal/utils","ember-runtime/system/string","ember-runtime/system/object","ember-views/system/jquery","ember-views/system/action_manager","ember-views/views/view","ember-metal/merge","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-views
+ */
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+
+ var get = __dependency2__.get;
+ var set = __dependency3__.set;
+ var isNone = __dependency4__["default"];
+ var run = __dependency5__["default"];
+ var typeOf = __dependency6__.typeOf;
+ var fmt = __dependency7__.fmt;
+ var EmberObject = __dependency8__["default"];
+ var jQuery = __dependency9__["default"];
+ var ActionManager = __dependency10__["default"];
+ var View = __dependency11__["default"];
+ var merge = __dependency12__["default"];
+
+ //ES6TODO:
+ // find a better way to do Ember.View.views without global state
+
+ /**
+ `Ember.EventDispatcher` handles delegating browser events to their
+ corresponding `Ember.Views.` For example, when you click on a view,
+ `Ember.EventDispatcher` ensures that that view's `mouseDown` method gets
+ called.
+
+ @class EventDispatcher
+ @namespace Ember
+ @private
+ @extends Ember.Object
+ */
+ __exports__["default"] = EmberObject.extend({
+
+ /**
+ The set of events names (and associated handler function names) to be setup
+ and dispatched by the `EventDispatcher`. Custom events can added to this list at setup
+ time, generally via the `Ember.Application.customEvents` hash. Only override this
+ default set to prevent the EventDispatcher from listening on some events all together.
+
+ This set will be modified by `setup` to also include any events added at that time.
+
+ @property events
+ @type Object
+ */
+ events: {
+ touchstart : 'touchStart',
+ touchmove : 'touchMove',
+ touchend : 'touchEnd',
+ touchcancel : 'touchCancel',
+ keydown : 'keyDown',
+ keyup : 'keyUp',
+ keypress : 'keyPress',
+ mousedown : 'mouseDown',
+ mouseup : 'mouseUp',
+ contextmenu : 'contextMenu',
+ click : 'click',
+ dblclick : 'doubleClick',
+ mousemove : 'mouseMove',
+ focusin : 'focusIn',
+ focusout : 'focusOut',
+ mouseenter : 'mouseEnter',
+ mouseleave : 'mouseLeave',
+ submit : 'submit',
+ input : 'input',
+ change : 'change',
+ dragstart : 'dragStart',
+ drag : 'drag',
+ dragenter : 'dragEnter',
+ dragleave : 'dragLeave',
+ dragover : 'dragOver',
+ drop : 'drop',
+ dragend : 'dragEnd'
+ },
+
+ /**
+ The root DOM element to which event listeners should be attached. Event
+ listeners will be attached to the document unless this is overridden.
+
+ Can be specified as a DOMElement or a selector string.
+
+ The default body is a string since this may be evaluated before document.body
+ exists in the DOM.
+
+ @private
+ @property rootElement
+ @type DOMElement
+ @default 'body'
+ */
+ rootElement: 'body',
+
+ /**
+ It enables events to be dispatched to the view's `eventManager.` When present,
+ this object takes precedence over handling of events on the view itself.
+
+ Note that most Ember applications do not use this feature. If your app also
+ does not use it, consider setting this property to false to gain some performance
+ improvement by allowing the EventDispatcher to skip the search for the
+ `eventManager` on the view tree.
+
+ ```javascript
+ var EventDispatcher = Em.EventDispatcher.extend({
+ events: {
+ click : 'click',
+ focusin : 'focusIn',
+ focusout : 'focusOut',
+ change : 'change'
+ },
+ canDispatchToEventManager: false
+ });
+ container.register('event_dispatcher:main', EventDispatcher);
+ ```
+
+ @property canDispatchToEventManager
+ @type boolean
+ @default 'true'
+ @since 1.7.0
+ */
+ canDispatchToEventManager: true,
+
+ /**
+ Sets up event listeners for standard browser events.
+
+ This will be called after the browser sends a `DOMContentReady` event. By
+ default, it will set up all of the listeners on the document body. If you
+ would like to register the listeners on a different element, set the event
+ dispatcher's `root` property.
+
+ @private
+ @method setup
+ @param addedEvents {Hash}
+ */
+ setup: function(addedEvents, rootElement) {
+ var event, events = get(this, 'events');
+
+ merge(events, addedEvents || {});
+
+ if (!isNone(rootElement)) {
+ set(this, 'rootElement', rootElement);
+ }
+
+ rootElement = jQuery(get(this, 'rootElement'));
+
+ Ember.assert(fmt('You cannot use the same root element (%@) multiple times in an Ember.Application', [rootElement.selector || rootElement[0].tagName]), !rootElement.is('.ember-application'));
+ Ember.assert('You cannot make a new Ember.Application using a root element that is a descendent of an existing Ember.Application', !rootElement.closest('.ember-application').length);
+ Ember.assert('You cannot make a new Ember.Application using a root element that is an ancestor of an existing Ember.Application', !rootElement.find('.ember-application').length);
+
+ rootElement.addClass('ember-application');
+
+ Ember.assert('Unable to add "ember-application" class to rootElement. Make sure you set rootElement to the body or an element in the body.', rootElement.is('.ember-application'));
+
+ for (event in events) {
+ if (events.hasOwnProperty(event)) {
+ this.setupHandler(rootElement, event, events[event]);
+ }
+ }
+ },
+
+ /**
+ Registers an event listener on the rootElement. If the given event is
+ triggered, the provided event handler will be triggered on the target view.
+
+ If the target view does not implement the event handler, or if the handler
+ returns `false`, the parent view will be called. The event will continue to
+ bubble to each successive parent view until it reaches the top.
+
+ @private
+ @method setupHandler
+ @param {Element} rootElement
+ @param {String} event the browser-originated event to listen to
+ @param {String} eventName the name of the method to call on the view
+ */
+ setupHandler: function(rootElement, event, eventName) {
+ var self = this;
+
+ rootElement.on(event + '.ember', '.ember-view', function(evt, triggeringManager) {
+ var view = View.views[this.id];
+ var result = true;
+
+ var manager = self.canDispatchToEventManager ? self._findNearestEventManager(view, eventName) : null;
+
+ if (manager && manager !== triggeringManager) {
+ result = self._dispatchEvent(manager, evt, eventName, view);
+ } else if (view) {
+ result = self._bubbleEvent(view, evt, eventName);
+ }
+
+ return result;
+ });
+
+ rootElement.on(event + '.ember', '[data-ember-action]', function(evt) {
+ var actionId = jQuery(evt.currentTarget).attr('data-ember-action');
+ var action = ActionManager.registeredActions[actionId];
+
+ // We have to check for action here since in some cases, jQuery will trigger
+ // an event on `removeChild` (i.e. focusout) after we've already torn down the
+ // action handlers for the view.
+ if (action && action.eventName === eventName) {
+ return action.handler(evt);
+ }
+ });
+ },
+
+ _findNearestEventManager: function(view, eventName) {
+ var manager = null;
+
+ while (view) {
+ manager = get(view, 'eventManager');
+ if (manager && manager[eventName]) { break; }
+
+ view = get(view, 'parentView');
+ }
+
+ return manager;
+ },
+
+ _dispatchEvent: function(object, evt, eventName, view) {
+ var result = true;
+
+ var handler = object[eventName];
+ if (typeOf(handler) === 'function') {
+ result = run(object, handler, evt, view);
+ // Do not preventDefault in eventManagers.
+ evt.stopPropagation();
+ }
+ else {
+ result = this._bubbleEvent(view, evt, eventName);
+ }
+
+ return result;
+ },
+
+ _bubbleEvent: function(view, evt, eventName) {
+ return run.join(view, view.handleEvent, eventName, evt);
+ },
+
+ destroy: function() {
+ var rootElement = get(this, 'rootElement');
+ jQuery(rootElement).off('.ember', '**').removeClass('ember-application');
+ return this._super();
+ },
+
+ toString: function() {
+ return '(EventDispatcher)';
+ }
+ });
+ });
+enifed("ember-views/system/ext",
+ ["ember-metal/run_loop"],
+ function(__dependency1__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-views
+ */
+
+ var run = __dependency1__["default"];
+
+ // Add a new named queue for rendering views that happens
+ // after bindings have synced, and a queue for scheduling actions
+ // that that should occur after view rendering.
+ run._addQueue('render', 'actions');
+ run._addQueue('afterRender', 'render');
+ });
+enifed("ember-views/system/jquery",
+ ["ember-metal/core","ember-metal/enumerable_utils","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var Ember = __dependency1__["default"];
+ // Ember.assert
+
+ // ES6TODO: the functions on EnumerableUtils need their own exports
+ var forEach = __dependency2__.forEach;
+
+ /**
+ Ember Views
+
+ @module ember
+ @submodule ember-views
+ @requires ember-runtime
+ @main ember-views
+ */
+
+ var jQuery = (Ember.imports && Ember.imports.jQuery) || (this && this.jQuery);
+ if (!jQuery && typeof eriuqer === 'function') {
+ jQuery = eriuqer('jquery');
+ }
+
+ Ember.assert("Ember Views require jQuery between 1.7 and 2.1", jQuery &&
+ (jQuery().jquery.match(/^((1\.(7|8|9|10|11))|(2\.(0|1)))(\.\d+)?(pre|rc\d?)?/) ||
+ Ember.ENV.FORCE_JQUERY));
+
+ /**
+ @module ember
+ @submodule ember-views
+ */
+ if (jQuery) {
+ // http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html#dndevents
+ var dragEvents = [
+ 'dragstart',
+ 'drag',
+ 'dragenter',
+ 'dragleave',
+ 'dragover',
+ 'drop',
+ 'dragend'
+ ];
+
+ // Copies the `dataTransfer` property from a browser event object onto the
+ // jQuery event object for the specified events
+ forEach(dragEvents, function(eventName) {
+ jQuery.event.fixHooks[eventName] = {
+ props: ['dataTransfer']
+ };
+ });
+ }
+
+ __exports__["default"] = jQuery;
+ });
+enifed("ember-views/system/render_buffer",
+ ["ember-views/system/jquery","morph","ember-metal/core","ember-metal/platform","morph/dom-helper/prop","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+ "use strict";
+ /**
+ @module ember
+ @submodule ember-views
+ */
+
+ var jQuery = __dependency1__["default"];
+ var DOMHelper = __dependency2__.DOMHelper;
+ var Ember = __dependency3__["default"];
+ var create = __dependency4__.create;
+ var normalizeProperty = __dependency5__.normalizeProperty;
+
+ // The HTML spec allows for "omitted start tags". These tags are optional
+ // when their intended child is the first thing in the parent tag. For
+ // example, this is a tbody start tag:
+ //
+ //
+ //
+ //
+ //
+ // The tbody may be omitted, and the browser will accept and render:
+ //
+ //
+ //
+ //
+ // However, the omitted start tag will still be added to the DOM. Here
+ // we test the string and context to see if the browser is about to
+ // perform this cleanup, but with a special allowance for disregarding
+ //
+ ```
+
+ And associate it by name using a view's `templateName` property:
+
+ ```javascript
+ AView = Ember.View.extend({
+ templateName: 'some-template'
+ });
+ ```
+
+ If you have nested resources, your Handlebars template will look like this:
+
+ ```html
+
+ ```
+
+ And `templateName` property:
+
+ ```javascript
+ AView = Ember.View.extend({
+ templateName: 'posts/new'
+ });
+ ```
+
+ Using a value for `templateName` that does not have a Handlebars 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
+ 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'),
+ template: null,
+ templateName: null
+ });
+ ```
+
+ Will result in instances with an HTML representation of:
+
+ ```html
+
I was the default
+ ```
+
+ If a `template` or `templateName` is provided it will take precedence over
+ `defaultTemplate`:
+
+ ```javascript
+ AView = Ember.View.extend({
+ defaultTemplate: Ember.Handlebars.compile('I was the default')
+ });
+
+ aView = AView.create({
+ template: Ember.Handlebars.compile('I was the template, not default')
+ });
+ ```
+
+ Will result in the following HTML representation when rendered:
+
+ ```html
+
I was the template, not default
+ ```
+
+ ## View Context
+
+ The default context of the compiled template is the view's controller:
+
+ ```javascript
+ AView = Ember.View.extend({
+ template: Ember.Handlebars.compile('Hello {{excitedGreeting}}')
+ });
+
+ aController = Ember.Object.create({
+ firstName: 'Barry',
+ excitedGreeting: function() {
+ return this.get("content.firstName") + "!!!"
+ }.property()
+ });
+
+ aView = AView.create({
+ controller: aController
+ });
+ ```
+
+ Will result in an HTML representation of:
+
+ ```html
+
Hello Barry!!!
+ ```
+
+ A context can also be explicitly supplied through the view's `context`
+ property. If the view has neither `context` nor `controller` properties, the
+ `parentView`'s context will be used.
+
+ ## Layouts
+
+ Views can have a secondary template that wraps their main template. Like
+ primary templates, layouts can be any function that accepts an optional
+ context parameter and returns a string of HTML that will be inserted inside
+ view's tag. Views whose HTML element is self closing (e.g. ``)
+ cannot have a layout and this property will be ignored.
+
+ Most typically in Ember a layout will be a compiled `Ember.Handlebars`
+ 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.
+
+ A template used as a layout must contain a single use of the Handlebars
+ `{{yield}}` helper. The HTML contents of a view's rendered `template` will be
+ inserted at this location:
+
+ ```javascript
+ AViewWithLayout = Ember.View.extend({
+ layout: Ember.Handlebars.compile("
{{yield}}
"),
+ template: Ember.Handlebars.compile("I got wrapped")
+ });
+ ```
+
+ Will result in view instances with an HTML representation of:
+
+ ```html
+
+
+ I got wrapped
+
+
+ ```
+
+ See [Ember.Handlebars.helpers.yield](/api/classes/Ember.Handlebars.helpers.html#method_yield)
+ for more information.
+
+ ## Responding to Browser Events
+
+ Views can respond to user-initiated events in one of three ways: method
+ implementation, through an event manager, and through `{{action}}` helper use
+ in their template or layout.
+
+ ### Method Implementation
+
+ Views can respond to user-initiated events by implementing a method that
+ matches the event name. A `jQuery.Event` object will be passed as the
+ argument to this method.
+
+ ```javascript
+ AView = Ember.View.extend({
+ click: function(event) {
+ // will be called when when an instance's
+ // rendered element is clicked
+ }
+ });
+ ```
+
+ ### Event Managers
+
+ Views can define an object as their `eventManager` property. This object can
+ then implement methods that match the desired event names. Matching events
+ that occur on the view's rendered HTML or the rendered HTML of any of its DOM
+ descendants will trigger this method. A `jQuery.Event` object will be passed
+ as the first argument to the method and an `Ember.View` object as the
+ second. The `Ember.View` will be the view whose rendered HTML was interacted
+ with. This may be the view with the `eventManager` property or one of its
+ descendent views.
+
+ ```javascript
+ AView = Ember.View.extend({
+ eventManager: Ember.Object.create({
+ doubleClick: function(event, view) {
+ // will be called when when an instance's
+ // rendered element or any rendering
+ // of this views's descendent
+ // elements is clicked
+ }
+ })
+ });
+ ```
+
+ An event defined for an event manager takes precedence over events of the
+ same name handled through methods on the view.
+
+ ```javascript
+ AView = Ember.View.extend({
+ mouseEnter: function(event) {
+ // will never trigger.
+ },
+ eventManager: Ember.Object.create({
+ mouseEnter: function(event, view) {
+ // takes precedence over AView#mouseEnter
+ }
+ })
+ });
+ ```
+
+ Similarly a view's event manager will take precedence for events of any views
+ rendered as a descendent. A method name that matches an event name will not
+ be called if the view instance was rendered inside the HTML representation of
+ a view that has an `eventManager` property defined that handles events of the
+ name. Events not handled by the event manager will still trigger method calls
+ on the descendent.
+
+ ```javascript
+ var App = Ember.Application.create();
+ App.OuterView = Ember.View.extend({
+ template: Ember.Handlebars.compile("outer {{#view 'inner'}}inner{{/view}} outer"),
+ eventManager: Ember.Object.create({
+ mouseEnter: function(event, view) {
+ // view might be instance of either
+ // OuterView or InnerView depending on
+ // where on the page the user interaction occurred
+ }
+ })
+ });
+
+ App.InnerView = Ember.View.extend({
+ click: function(event) {
+ // will be called if rendered inside
+ // an OuterView because OuterView's
+ // eventManager doesn't handle click events
+ },
+ mouseEnter: function(event) {
+ // will never be called if rendered inside
+ // an OuterView.
+ }
+ });
+ ```
+
+ ### Handlebars `{{action}}` Helper
+
+ See [Handlebars.helpers.action](/api/classes/Ember.Handlebars.helpers.html#method_action).
+
+ ### Event Names
+
+ All of the event handling approaches described above respond to the same set
+ of events. The names of the built-in events are listed below. (The hash of
+ built-in events exists in `Ember.EventDispatcher`.) Additional, custom events
+ can be registered by using `Ember.Application.customEvents`.
+
+ Touch events:
+
+ * `touchStart`
+ * `touchMove`
+ * `touchEnd`
+ * `touchCancel`
+
+ Keyboard events
+
+ * `keyDown`
+ * `keyUp`
+ * `keyPress`
+
+ Mouse events
+
+ * `mouseDown`
+ * `mouseUp`
+ * `contextMenu`
+ * `click`
+ * `doubleClick`
+ * `mouseMove`
+ * `focusIn`
+ * `focusOut`
+ * `mouseEnter`
+ * `mouseLeave`
+
+ Form events:
+
+ * `submit`
+ * `change`
+ * `focusIn`
+ * `focusOut`
+ * `input`
+
+ HTML5 drag and drop events:
+
+ * `dragStart`
+ * `drag`
+ * `dragEnter`
+ * `dragLeave`
+ * `dragOver`
+ * `dragEnd`
+ * `drop`
+
+ ## Handlebars `{{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)
+ for additional information.
+
+ @class View
+ @namespace Ember
+ @extends Ember.CoreView
+ */
+ var View = CoreView.extend({
+
+ concatenatedProperties: ['classNames', 'classNameBindings', 'attributeBindings'],
+
+ /**
+ @property isView
+ @type Boolean
+ @default true
+ @static
+ */
+ isView: true,
+
+ // ..........................................................
+ // TEMPLATE SUPPORT
+ //
+
+ /**
+ The name of the template to lookup if no template is provided.
+
+ By default `Ember.View` will lookup a template with this name in
+ `Ember.TEMPLATES` (a shared global object).
+
+ @property templateName
+ @type String
+ @default null
+ */
+ templateName: null,
+
+ /**
+ The name of the layout to lookup if no layout is provided.
+
+ By default `Ember.View` will lookup a template with this name in
+ `Ember.TEMPLATES` (a shared global object).
+
+ @property layoutName
+ @type String
+ @default null
+ */
+ layoutName: null,
+
+ /**
+ Used to identify this view during debugging
+
+ @property instrumentDisplay
+ @type String
+ */
+ instrumentDisplay: computed(function() {
+ if (this.helperName) {
+ return '{{' + this.helperName + '}}';
+ }
+ }),
+
+ /**
+ The template used to render the view. This should be a function that
+ accepts an optional context parameter and returns a string of HTML that
+ will be inserted into the DOM relative to its parent view.
+
+ In general, you should set the `templateName` property instead of setting
+ the template yourself.
+
+ @property template
+ @type Function
+ */
+ template: computed('templateName', function(key, value) {
+ if (value !== undefined) { return value; }
+
+ var templateName = get(this, 'templateName');
+ var template = this.templateForName(templateName, 'template');
+
+ Ember.assert("You specified the templateName " + templateName + " for " + this + ", but it did not exist.", !templateName || !!template);
+
+ return template || get(this, 'defaultTemplate');
+ }),
+
+ _controller: null,
+
+ /**
+ The controller managing this view. If this property is set, it will be
+ made available for use by the template.
+
+ @property controller
+ @type Object
+ */
+ controller: computed(function(key, value) {
+ if (arguments.length === 2) {
+ this._controller = value;
+ return value;
+ }
+
+ if (this._controller) {
+ return this._controller;
+ }
+
+ var parentView = get(this, '_parentView');
+ return parentView ? get(parentView, 'controller') : null;
+ }),
+
+ /**
+ A view may contain a layout. A layout is a regular template but
+ supersedes the `template` property during rendering. It is the
+ responsibility of the layout template to retrieve the `template`
+ property from the view (or alternatively, call `Handlebars.helpers.yield`,
+ `{{yield}}`) to render it in the correct location.
+
+ This is useful for a view that has a shared wrapper, but which delegates
+ the rendering of the contents of the wrapper to the `template` property
+ on a subclass.
+
+ @property layout
+ @type Function
+ */
+ layout: computed(function(key) {
+ var layoutName = get(this, 'layoutName');
+ var layout = this.templateForName(layoutName, 'layout');
+
+ Ember.assert("You specified the layoutName " + layoutName + " for " + this + ", but it did not exist.", !layoutName || !!layout);
+
+ return layout || get(this, 'defaultLayout');
+ }).property('layoutName'),
+
+ _yield: function(context, options, morph) {
+ var template = get(this, 'template');
+
+ if (template) {
+ var useHTMLBars = false;
+
+ useHTMLBars = template.isHTMLBars;
+
+
+ if (useHTMLBars) {
+ return template.render(this, options, morph.contextualElement);
+ } else {
+ return template(context, options);
+ }
+ }
+ },
+
+ _blockArguments: EMPTY_ARRAY,
+
+ templateForName: function(name, type) {
+ if (!name) { return; }
+ Ember.assert("templateNames are not allowed to contain periods: "+name, name.indexOf('.') === -1);
+
+ if (!this.container) {
+ throw new EmberError('Container was not found when looking up a views template. ' +
+ 'This is most likely due to manually instantiating an Ember.View. ' +
+ 'See: http://git.io/EKPpnA');
+ }
+
+ return this.container.lookup('template:' + name);
+ },
+
+ /**
+ The object from which templates should access properties.
+
+ This object will be passed to the template function each time the render
+ method is called, but it is up to the individual function to decide what
+ to do with it.
+
+ By default, this will be the view's controller.
+
+ @property context
+ @type Object
+ */
+ context: computed(function(key, value) {
+ if (arguments.length === 2) {
+ set(this, '_context', value);
+ return value;
+ } else {
+ return get(this, '_context');
+ }
+ })["volatile"](),
+
+ /**
+ Private copy of the view's template context. This can be set directly
+ by Handlebars without triggering the observer that causes the view
+ to be re-rendered.
+
+ The context of a view is looked up as follows:
+
+ 1. Supplied context (usually by Handlebars)
+ 2. Specified controller
+ 3. `parentView`'s context (for a child of a ContainerView)
+
+ The code in Handlebars that overrides the `_context` property first
+ checks to see whether the view has a specified controller. This is
+ something of a hack and should be revisited.
+
+ @property _context
+ @private
+ */
+ _context: computed(function(key, value) {
+ if (arguments.length === 2) {
+ return value;
+ }
+
+ var parentView, controller;
+
+ if (controller = get(this, 'controller')) {
+ return controller;
+ }
+
+ parentView = this._parentView;
+ if (parentView) {
+ return get(parentView, '_context');
+ }
+
+ return null;
+ }),
+
+ /**
+ If a value that affects template rendering changes, the view should be
+ re-rendered to reflect the new value.
+
+ @method _contextDidChange
+ @private
+ */
+ _contextDidChange: observer('context', function() {
+ this.rerender();
+ }),
+
+ /**
+ If `false`, the view will appear hidden in DOM.
+
+ @property isVisible
+ @type Boolean
+ @default null
+ */
+ isVisible: true,
+
+ /**
+ Array of child views. You should never edit this array directly.
+ Instead, use `appendChild` and `removeFromParent`.
+
+ @property childViews
+ @type Array
+ @default []
+ @private
+ */
+ childViews: childViewsProperty,
+
+ _childViews: EMPTY_ARRAY,
+
+ // When it's a virtual view, we need to notify the parent that their
+ // childViews will change.
+ _childViewsWillChange: beforeObserver('childViews', function() {
+ if (this.isVirtual) {
+ var parentView = get(this, 'parentView');
+ if (parentView) { propertyWillChange(parentView, 'childViews'); }
+ }
+ }),
+
+ // When it's a virtual view, we need to notify the parent that their
+ // childViews did change.
+ _childViewsDidChange: observer('childViews', function() {
+ if (this.isVirtual) {
+ var parentView = get(this, 'parentView');
+ if (parentView) { propertyDidChange(parentView, 'childViews'); }
+ }
+ }),
+
+ /**
+ Return the nearest ancestor that is an instance of the provided
+ class.
+
+ @method nearestInstanceOf
+ @param {Class} klass Subclass of Ember.View (or Ember.View itself)
+ @return Ember.View
+ @deprecated
+ */
+ nearestInstanceOf: function(klass) {
+ Ember.deprecate("nearestInstanceOf is deprecated and will be removed from future releases. Use nearestOfType.");
+ var view = get(this, 'parentView');
+
+ while (view) {
+ if (view instanceof klass) { return view; }
+ view = get(view, 'parentView');
+ }
+ },
+
+ /**
+ Return the nearest ancestor that is an instance of the provided
+ class or mixin.
+
+ @method nearestOfType
+ @param {Class,Mixin} klass Subclass of Ember.View (or Ember.View itself),
+ or an instance of Ember.Mixin.
+ @return Ember.View
+ */
+ nearestOfType: function(klass) {
+ var view = get(this, 'parentView');
+ var isOfType = klass instanceof Mixin ?
+ function(view) { return klass.detect(view); } :
+ function(view) { return klass.detect(view.constructor); };
+
+ while (view) {
+ if (isOfType(view)) { return view; }
+ view = get(view, 'parentView');
+ }
+ },
+
+ /**
+ Return the nearest ancestor that has a given property.
+
+ @method nearestWithProperty
+ @param {String} property A property name
+ @return Ember.View
+ */
+ nearestWithProperty: function(property) {
+ var view = get(this, 'parentView');
+
+ while (view) {
+ if (property in view) { return view; }
+ view = get(view, 'parentView');
+ }
+ },
+
+ /**
+ Return the nearest ancestor whose parent is an instance of
+ `klass`.
+
+ @method nearestChildOf
+ @param {Class} klass Subclass of Ember.View (or Ember.View itself)
+ @return Ember.View
+ */
+ nearestChildOf: function(klass) {
+ var view = get(this, 'parentView');
+
+ while (view) {
+ if (get(view, 'parentView') instanceof klass) { return view; }
+ view = get(view, 'parentView');
+ }
+ },
+
+ /**
+ When the parent view changes, recursively invalidate `controller`
+
+ @method _parentViewDidChange
+ @private
+ */
+ _parentViewDidChange: observer('_parentView', function() {
+ if (this.isDestroying) { return; }
+
+ this._setupKeywords();
+ this.trigger('parentViewDidChange');
+
+ if (get(this, 'parentView.controller') && !get(this, 'controller')) {
+ this.notifyPropertyChange('controller');
+ }
+ }),
+
+ _controllerDidChange: observer('controller', function() {
+ if (this.isDestroying) { return; }
+
+ this.rerender();
+
+ this.forEachChildView(function(view) {
+ view.propertyDidChange('controller');
+ });
+ }),
+
+ _setupKeywords: function() {
+ var keywords = this._keywords;
+ var contextView = this._contextView || this._parentView;
+
+ if (contextView) {
+ var parentKeywords = contextView._keywords;
+
+ keywords.view = this.isVirtual ? parentKeywords.view : this;
+
+ for (var name in parentKeywords) {
+ if (keywords[name]) continue;
+ keywords[name] = parentKeywords[name];
+ }
+ } else {
+ keywords.view = this.isVirtual ? null : this;
+ }
+ },
+
+ /**
+ Called on your view when it should push strings of HTML into a
+ `Ember.RenderBuffer`. Most users will want to override the `template`
+ or `templateName` properties instead of this method.
+
+ By default, `Ember.View` will look for a function in the `template`
+ property and invoke it with the value of `context`. The value of
+ `context` will be the view's controller unless you override it.
+
+ @method render
+ @param {Ember.RenderBuffer} buffer The render buffer
+ */
+ render: function(buffer) {
+ // If this view has a layout, it is the responsibility of the
+ // the layout to render the view's template. Otherwise, render the template
+ // directly.
+ var template = get(this, 'layout') || get(this, 'template');
+
+ if (template) {
+ var context = get(this, 'context');
+ var output;
+
+ var data = {
+ view: this,
+ buffer: buffer,
+ isRenderData: true
+ };
+
+ // Invoke the template with the provided template context, which
+ // is the view's controller by default. A hash of data is also passed that provides
+ // the template with access to the view and render buffer.
+
+ // The template should write directly to the render buffer instead
+ // of returning a string.
+ var options = { data: data };
+ var useHTMLBars = false;
+
+
+ useHTMLBars = template.isHTMLBars;
+
+
+ if (useHTMLBars) {
+ Ember.assert('template must be an object. Did you mean to call Ember.Handlebars.compile("...") or specify templateName instead?', typeof template === 'object');
+ var env = Ember.merge(buildHTMLBarsDefaultEnv(), options);
+ output = template.render(this, env, buffer.innerContextualElement(), this._blockArguments);
+ } else {
+ Ember.assert('template must be a function. Did you mean to call Ember.Handlebars.compile("...") or specify templateName instead?', typeof template === 'function');
+ output = template(context, options);
+ }
+
+ // If the template returned a string instead of writing to the buffer,
+ // push the string onto the buffer.
+ if (output !== undefined) { buffer.push(output); }
+ }
+ },
+
+ /**
+ Renders the view again. This will work regardless of whether the
+ view is already in the DOM or not. If the view is in the DOM, the
+ rendering process will be deferred to give bindings a chance
+ to synchronize.
+
+ If children were added during the rendering process using `appendChild`,
+ `rerender` will remove them, because they will be added again
+ if needed by the next `render`.
+
+ In general, if the display of your view changes, you should modify
+ the DOM element directly instead of manually calling `rerender`, which can
+ be slow.
+
+ @method rerender
+ */
+ rerender: function() {
+ return this.currentState.rerender(this);
+ },
+
+ /**
+ Iterates over the view's `classNameBindings` array, inserts the value
+ of the specified property into the `classNames` array, then creates an
+ observer to update the view's element if the bound property ever changes
+ in the future.
+
+ @method _applyClassNameBindings
+ @private
+ */
+ _applyClassNameBindings: function(classBindings) {
+ var classNames = this.classNames;
+ var elem, newClass, dasherizedClass;
+
+ // Loop through all of the configured bindings. These will be either
+ // property names ('isUrgent') or property paths relative to the view
+ // ('content.isUrgent')
+ forEach(classBindings, function(binding) {
+
+ var boundBinding;
+ if (isStream(binding)) {
+ boundBinding = binding;
+ } else {
+ boundBinding = streamifyClassNameBinding(this, binding, '_view.');
+ }
+
+ // Variable in which the old class value is saved. The observer function
+ // closes over this variable, so it knows which string to remove when
+ // the property changes.
+ var oldClass;
+
+ // Set up an observer on the context. If the property changes, toggle the
+ // class name.
+ var observer = this._wrapAsScheduled(function() {
+ // Get the current value of the property
+ elem = this.$();
+ newClass = read(boundBinding);
+
+ // If we had previously added a class to the element, remove it.
+ if (oldClass) {
+ elem.removeClass(oldClass);
+ // Also remove from classNames so that if the view gets rerendered,
+ // the class doesn't get added back to the DOM.
+ classNames.removeObject(oldClass);
+ }
+
+ // If necessary, add a new class. Make sure we keep track of it so
+ // it can be removed in the future.
+ if (newClass) {
+ elem.addClass(newClass);
+ oldClass = newClass;
+ } else {
+ oldClass = null;
+ }
+ });
+
+ // Get the class name for the property at its current value
+ dasherizedClass = read(boundBinding);
+
+ if (dasherizedClass) {
+ // Ensure that it gets into the classNames array
+ // so it is displayed when we render.
+ addObject(classNames, dasherizedClass);
+
+ // Save a reference to the class name so we can remove it
+ // if the observer fires. Remember that this variable has
+ // been closed over by the observer.
+ oldClass = dasherizedClass;
+ }
+
+ subscribe(boundBinding, observer, this);
+ // Remove className so when the view is rerendered,
+ // the className is added based on binding reevaluation
+ this.one('willClearRender', function() {
+ if (oldClass) {
+ classNames.removeObject(oldClass);
+ oldClass = null;
+ }
+ });
+
+ }, this);
+ },
+
+ _unspecifiedAttributeBindings: null,
+
+ /**
+ Iterates through the view's attribute bindings, sets up observers for each,
+ then applies the current value of the attributes to the passed render buffer.
+
+ @method _applyAttributeBindings
+ @param {Ember.RenderBuffer} buffer
+ @private
+ */
+ _applyAttributeBindings: function(buffer, attributeBindings) {
+ var attributeValue;
+ var unspecifiedAttributeBindings = this._unspecifiedAttributeBindings = this._unspecifiedAttributeBindings || {};
+
+ forEach(attributeBindings, function(binding) {
+ var split = binding.split(':');
+ var property = split[0];
+ var attributeName = split[1] || property;
+
+ Ember.assert('You cannot use class as an attributeBinding, use classNameBindings instead.', attributeName !== 'class');
+
+ if (property in this) {
+ this._setupAttributeBindingObservation(property, attributeName);
+
+ // Determine the current value and add it to the render buffer
+ // if necessary.
+ attributeValue = get(this, property);
+ View.applyAttributeBindings(buffer, attributeName, attributeValue);
+ } else {
+ unspecifiedAttributeBindings[property] = attributeName;
+ }
+ }, this);
+
+ // Lazily setup setUnknownProperty after attributeBindings are initially applied
+ this.setUnknownProperty = this._setUnknownProperty;
+ },
+
+ _setupAttributeBindingObservation: function(property, attributeName) {
+ var attributeValue, elem;
+
+ // Create an observer to add/remove/change the attribute if the
+ // JavaScript property changes.
+ var observer = function() {
+ elem = this.$();
+
+ attributeValue = get(this, property);
+
+ var normalizedName = normalizeProperty(elem, attributeName.toLowerCase()) || attributeName;
+ View.applyAttributeBindings(elem, normalizedName, attributeValue);
+ };
+
+ this.registerObserver(this, property, observer);
+ },
+
+ /**
+ We're using setUnknownProperty as a hook to setup attributeBinding observers for
+ properties that aren't defined on a view at initialization time.
+
+ Note: setUnknownProperty will only be called once for each property.
+
+ @method setUnknownProperty
+ @param key
+ @param value
+ @private
+ */
+ setUnknownProperty: null, // Gets defined after initialization by _applyAttributeBindings
+
+ _setUnknownProperty: function(key, value) {
+ var attributeName = this._unspecifiedAttributeBindings && this._unspecifiedAttributeBindings[key];
+ if (attributeName) {
+ this._setupAttributeBindingObservation(key, attributeName);
+ }
+
+ defineProperty(this, key);
+ return set(this, key, value);
+ },
+
+ /**
+ Given a property name, returns a dasherized version of that
+ property name if the property evaluates to a non-falsy value.
+
+ For example, if the view has property `isUrgent` that evaluates to true,
+ passing `isUrgent` to this method will return `"is-urgent"`.
+
+ @method _classStringForProperty
+ @param property
+ @private
+ */
+ _classStringForProperty: function(parsedPath) {
+ return View._classStringForValue(parsedPath.path, parsedPath.stream.value(), parsedPath.className, parsedPath.falsyClassName);
+ },
+
+ // ..........................................................
+ // ELEMENT SUPPORT
+ //
+
+ /**
+ Returns the current DOM element for the view.
+
+ @property element
+ @type DOMElement
+ */
+ element: null,
+
+ /**
+ Returns a jQuery object for this view's element. If you pass in a selector
+ string, this method will return a jQuery object, using the current element
+ as its buffer.
+
+ For example, calling `view.$('li')` will return a jQuery object containing
+ all of the `li` elements inside the DOM element of this view.
+
+ @method $
+ @param {String} [selector] a jQuery-compatible selector string
+ @return {jQuery} the jQuery object for the DOM node
+ */
+ $: function(sel) {
+ return this.currentState.$(this, sel);
+ },
+
+ mutateChildViews: function(callback) {
+ var childViews = this._childViews;
+ var idx = childViews.length;
+ var view;
+
+ while(--idx >= 0) {
+ view = childViews[idx];
+ callback(this, view, idx);
+ }
+
+ return this;
+ },
+
+ forEachChildView: function(callback) {
+ var childViews = this._childViews;
+
+ if (!childViews) { return this; }
+
+ var len = childViews.length;
+ var view, idx;
+
+ for (idx = 0; idx < len; idx++) {
+ view = childViews[idx];
+ callback(view);
+ }
+
+ return this;
+ },
+
+ /**
+ Appends the view's element to the specified parent element.
+
+ If the view does not have an HTML representation yet, `createElement()`
+ will be called automatically.
+
+ Note that this method just schedules the view to be appended; the DOM
+ element will not be appended to the given element until all bindings have
+ finished synchronizing.
+
+ This is not typically a function that you will need to call directly when
+ building your application. You might consider using `Ember.ContainerView`
+ instead. If you do need to use `appendTo`, be sure that the target element
+ you are providing is associated with an `Ember.Application` and does not
+ have an ancestor element that is associated with an Ember view.
+
+ @method appendTo
+ @param {String|DOMElement|jQuery} A selector, element, HTML string, or jQuery object
+ @return {Ember.View} receiver
+ */
+ appendTo: function(selector) {
+ var target = jQuery(selector);
+
+ Ember.assert("You tried to append to (" + selector + ") but that isn't in the DOM", target.length > 0);
+ Ember.assert("You cannot append to an existing Ember.View. Consider using Ember.ContainerView instead.", !target.is('.ember-view') && !target.parents().is('.ember-view'));
+
+ this.constructor.renderer.appendTo(this, target[0]);
+
+ return this;
+ },
+
+ /**
+ Replaces the content of the specified parent element with this view's
+ element. If the view does not have an HTML representation yet,
+ the element will be generated automatically.
+
+ Note that this method just schedules the view to be appended; the DOM
+ element will not be appended to the given element until all bindings have
+ finished synchronizing
+
+ @method replaceIn
+ @param {String|DOMElement|jQuery} target A selector, element, HTML string, or jQuery object
+ @return {Ember.View} received
+ */
+ replaceIn: function(selector) {
+ var target = jQuery(selector);
+
+ Ember.assert("You tried to replace in (" + selector + ") but that isn't in the DOM", target.length > 0);
+ Ember.assert("You cannot replace an existing Ember.View. Consider using Ember.ContainerView instead.", !target.is('.ember-view') && !target.parents().is('.ember-view'));
+
+ this.constructor.renderer.replaceIn(this, target[0]);
+
+ return this;
+ },
+
+ /**
+ Appends the view's element to the document body. If the view does
+ not have an HTML representation yet
+ the element will be generated automatically.
+
+ If your application uses the `rootElement` property, you must append
+ the view within that element. Rendering views outside of the `rootElement`
+ is not supported.
+
+ Note that this method just schedules the view to be appended; the DOM
+ element will not be appended to the document body until all bindings have
+ finished synchronizing.
+
+ @method append
+ @return {Ember.View} receiver
+ */
+ append: function() {
+ return this.appendTo(document.body);
+ },
+
+ /**
+ Removes the view's element from the element to which it is attached.
+
+ @method remove
+ @return {Ember.View} receiver
+ */
+ remove: function() {
+ // What we should really do here is wait until the end of the run loop
+ // to determine if the element has been re-appended to a different
+ // element.
+ // In the interim, we will just re-render if that happens. It is more
+ // important than elements get garbage collected.
+ if (!this.removedFromDOM) { this.destroyElement(); }
+ },
+
+ /**
+ The HTML `id` of the view's element in the DOM. You can provide this
+ value yourself but it must be unique (just as in HTML):
+
+ ```handlebars
+ {{my-component elementId="a-really-cool-id"}}
+ ```
+
+ If not manually set a default value will be provided by the framework.
+
+ Once rendered an element's `elementId` is considered immutable and you
+ should never change it.
+
+ @property elementId
+ @type String
+ */
+ elementId: null,
+
+ /**
+ Attempts to discover the element in the parent element. The default
+ implementation looks for an element with an ID of `elementId` (or the
+ view's guid if `elementId` is null). You can override this method to
+ provide your own form of lookup. For example, if you want to discover your
+ element using a CSS class name instead of an ID.
+
+ @method findElementInParentElement
+ @param {DOMElement} parentElement The parent's DOM element
+ @return {DOMElement} The discovered element
+ */
+ findElementInParentElement: function(parentElem) {
+ var id = "#" + this.elementId;
+ return jQuery(id)[0] || jQuery(id, parentElem)[0];
+ },
+
+ /**
+ Creates a DOM representation of the view and all of its child views by
+ recursively calling the `render()` method.
+
+ After the element has been inserted into the DOM, `didInsertElement` will
+ be called on this view and all of its child views.
+
+ @method createElement
+ @return {Ember.View} receiver
+ */
+ createElement: function() {
+ if (this.element) { return this; }
+
+ this._didCreateElementWithoutMorph = true;
+ this.constructor.renderer.renderTree(this);
+
+ return this;
+ },
+
+ /**
+ Called when a view is going to insert an element into the DOM.
+
+ @event willInsertElement
+ */
+ willInsertElement: K,
+
+ /**
+ Called when the element of the view has been inserted into the DOM
+ or after the view was re-rendered. Override this function to do any
+ set up that requires an element in the document body.
+
+ When a view has children, didInsertElement will be called on the
+ child view(s) first, bubbling upwards through the hierarchy.
+
+ @event didInsertElement
+ */
+ didInsertElement: K,
+
+ /**
+ Called when the view is about to rerender, but before anything has
+ been torn down. This is a good opportunity to tear down any manual
+ observers you have installed based on the DOM state
+
+ @event willClearRender
+ */
+ willClearRender: K,
+
+ /**
+ Destroys any existing element along with the element for any child views
+ as well. If the view does not currently have a element, then this method
+ will do nothing.
+
+ If you implement `willDestroyElement()` on your view, then this method will
+ be invoked on your view before your element is destroyed to give you a
+ chance to clean up any event handlers, etc.
+
+ If you write a `willDestroyElement()` handler, you can assume that your
+ `didInsertElement()` handler was called earlier for the same element.
+
+ You should not call or override this method yourself, but you may
+ want to implement the above callbacks.
+
+ @method destroyElement
+ @return {Ember.View} receiver
+ */
+ destroyElement: function() {
+ return this.currentState.destroyElement(this);
+ },
+
+ /**
+ Called when the element of the view is going to be destroyed. Override
+ this function to do any teardown that requires an element, like removing
+ event listeners.
+
+ Please note: any property changes made during this event will have no
+ effect on object observers.
+
+ @event willDestroyElement
+ */
+ willDestroyElement: K,
+
+ /**
+ Called when the parentView property has changed.
+
+ @event parentViewDidChange
+ */
+ parentViewDidChange: K,
+
+ instrumentName: 'view',
+
+ instrumentDetails: function(hash) {
+ hash.template = get(this, 'templateName');
+ this._super(hash);
+ },
+
+ beforeRender: function(buffer) {},
+
+ afterRender: function(buffer) {},
+
+ applyAttributesToBuffer: function(buffer) {
+ // Creates observers for all registered class name and attribute bindings,
+ // then adds them to the element.
+ var classNameBindings = this.classNameBindings;
+ if (classNameBindings.length) {
+ this._applyClassNameBindings(classNameBindings);
+ }
+
+ // Pass the render buffer so the method can apply attributes directly.
+ // This isn't needed for class name bindings because they use the
+ // existing classNames infrastructure.
+ var attributeBindings = this.attributeBindings;
+ if (attributeBindings.length) {
+ this._applyAttributeBindings(buffer, attributeBindings);
+ }
+
+ buffer.setClasses(this.classNames);
+ buffer.id(this.elementId);
+
+ var role = get(this, 'ariaRole');
+ if (role) {
+ buffer.attr('role', role);
+ }
+
+ if (get(this, 'isVisible') === false) {
+ buffer.style('display', 'none');
+ }
+ },
+
+ // ..........................................................
+ // STANDARD RENDER PROPERTIES
+ //
+
+ /**
+ Tag name for the view's outer element. The tag name is only used when an
+ element is first created. If you change the `tagName` for an element, you
+ must destroy and recreate the view element.
+
+ By default, the render buffer will use a `
` tag for views.
+
+ @property tagName
+ @type String
+ @default null
+ */
+
+ // We leave this null by default so we can tell the difference between
+ // the default case and a user-specified tag.
+ tagName: null,
+
+ /**
+ The WAI-ARIA role of the control represented by this view. For example, a
+ button may have a role of type 'button', or a pane may have a role of
+ type 'alertdialog'. This property is used by assistive software to help
+ visually challenged users navigate rich web applications.
+
+ The full list of valid WAI-ARIA roles is available at:
+ [http://www.w3.org/TR/wai-aria/roles#roles_categorization](http://www.w3.org/TR/wai-aria/roles#roles_categorization)
+
+ @property ariaRole
+ @type String
+ @default null
+ */
+ ariaRole: null,
+
+ /**
+ Standard CSS class names to apply to the view's outer element. This
+ property automatically inherits any class names defined by the view's
+ superclasses as well.
+
+ @property classNames
+ @type Array
+ @default ['ember-view']
+ */
+ classNames: ['ember-view'],
+
+ /**
+ A list of properties of the view to apply as class names. If the property
+ is a string value, the value of that string will be applied as a class
+ name.
+
+ ```javascript
+ // Applies the 'high' class to the view element
+ Ember.View.extend({
+ classNameBindings: ['priority']
+ priority: 'high'
+ });
+ ```
+
+ If the value of the property is a Boolean, the name of that property is
+ added as a dasherized class name.
+
+ ```javascript
+ // Applies the 'is-urgent' class to the view element
+ Ember.View.extend({
+ classNameBindings: ['isUrgent']
+ isUrgent: true
+ });
+ ```
+
+ If you would prefer to use a custom value instead of the dasherized
+ property name, you can pass a binding like this:
+
+ ```javascript
+ // Applies the 'urgent' class to the view element
+ Ember.View.extend({
+ classNameBindings: ['isUrgent:urgent']
+ isUrgent: true
+ });
+ ```
+
+ This list of properties is inherited from the view's superclasses as well.
+
+ @property classNameBindings
+ @type Array
+ @default []
+ */
+ classNameBindings: EMPTY_ARRAY,
+
+ /**
+ A list of properties of the view to apply as attributes. If the property is
+ a string value, the value of that string will be applied as the attribute.
+
+ ```javascript
+ // Applies the type attribute to the element
+ // with the value "button", like
+ Ember.View.extend({
+ attributeBindings: ['type'],
+ type: 'button'
+ });
+ ```
+
+ If the value of the property is a Boolean, the name of that property is
+ added as an attribute.
+
+ ```javascript
+ // Renders something like
+ Ember.View.extend({
+ attributeBindings: ['enabled'],
+ enabled: true
+ });
+ ```
+
+ @property attributeBindings
+ */
+ attributeBindings: EMPTY_ARRAY,
+
+ // .......................................................
+ // CORE DISPLAY METHODS
+ //
+
+ /**
+ Setup a view, but do not finish waking it up.
+
+ * configure `childViews`
+ * register the view with the global views hash, which is used for event
+ dispatch
+
+ @method init
+ @private
+ */
+ init: function() {
+ if (!this.isVirtual && !this.elementId) {
+ this.elementId = guidFor(this);
+ }
+
+ this._super();
+
+ // setup child views. be sure to clone the child views array first
+ this._childViews = this._childViews.slice();
+ this._baseContext = undefined;
+ this._contextStream = undefined;
+ this._streamBindings = undefined;
+
+ if (!this._keywords) {
+ this._keywords = create(null);
+ }
+ this._keywords._view = this;
+ this._keywords.view = undefined;
+ this._keywords.controller = new KeyStream(this, 'controller');
+ this._setupKeywords();
+
+ Ember.assert("Only arrays are allowed for 'classNameBindings'", typeOf(this.classNameBindings) === 'array');
+ this.classNameBindings = emberA(this.classNameBindings.slice());
+
+ Ember.assert("Only arrays of static class strings are allowed for 'classNames'. For dynamic classes, use 'classNameBindings'.", typeOf(this.classNames) === 'array');
+ this.classNames = emberA(this.classNames.slice());
+ },
+
+ appendChild: function(view, options) {
+ return this.currentState.appendChild(this, view, options);
+ },
+
+ /**
+ Removes the child view from the parent view.
+
+ @method removeChild
+ @param {Ember.View} view
+ @return {Ember.View} receiver
+ */
+ removeChild: function(view) {
+ // If we're destroying, the entire subtree will be
+ // freed, and the DOM will be handled separately,
+ // so no need to mess with childViews.
+ if (this.isDestroying) { return; }
+
+ // update parent node
+ set(view, '_parentView', null);
+
+ // remove view from childViews array.
+ var childViews = this._childViews;
+
+ removeObject(childViews, view);
+
+ this.propertyDidChange('childViews'); // HUH?! what happened to will change?
+
+ return this;
+ },
+
+ /**
+ Removes all children from the `parentView`.
+
+ @method removeAllChildren
+ @return {Ember.View} receiver
+ */
+ removeAllChildren: function() {
+ return this.mutateChildViews(function(parentView, view) {
+ parentView.removeChild(view);
+ });
+ },
+
+ destroyAllChildren: function() {
+ return this.mutateChildViews(function(parentView, view) {
+ view.destroy();
+ });
+ },
+
+ /**
+ Removes the view from its `parentView`, if one is found. Otherwise
+ does nothing.
+
+ @method removeFromParent
+ @return {Ember.View} receiver
+ */
+ removeFromParent: function() {
+ var parent = this._parentView;
+
+ // Remove DOM element from parent
+ this.remove();
+
+ if (parent) { parent.removeChild(this); }
+ return this;
+ },
+
+ /**
+ You must call `destroy` on a view to destroy the view (and all of its
+ child views). This will remove the view from any parent node, then make
+ sure that the DOM element managed by the view can be released by the
+ memory manager.
+
+ @method destroy
+ */
+ destroy: function() {
+ // get parentView before calling super because it'll be destroyed
+ var nonVirtualParentView = get(this, 'parentView');
+ var viewName = this.viewName;
+
+ if (!this._super()) { return; }
+
+ // remove from non-virtual parent view if viewName was specified
+ if (viewName && nonVirtualParentView) {
+ nonVirtualParentView.set(viewName, null);
+ }
+
+ return this;
+ },
+
+ /**
+ Instantiates a view to be added to the childViews array during view
+ initialization. You generally will not call this method directly unless
+ you are overriding `createChildViews()`. Note that this method will
+ automatically configure the correct settings on the new view instance to
+ act as a child of the parent.
+
+ @method createChildView
+ @param {Class|String} viewClass
+ @param {Hash} [attrs] Attributes to add
+ @return {Ember.View} new instance
+ */
+ createChildView: function(view, attrs) {
+ if (!view) {
+ throw new TypeError("createChildViews first argument must exist");
+ }
+
+ if (view.isView && view._parentView === this && view.container === this.container) {
+ return view;
+ }
+
+ attrs = attrs || {};
+ attrs._parentView = this;
+
+ if (CoreView.detect(view)) {
+ attrs.container = this.container;
+ view = view.create(attrs);
+
+ // don't set the property on a virtual view, as they are invisible to
+ // consumers of the view API
+ if (view.viewName) {
+ set(get(this, 'concreteView'), view.viewName, view);
+ }
+ } else if ('string' === typeof view) {
+ var fullName = 'view:' + view;
+ var ViewKlass = this.container.lookupFactory(fullName);
+
+ Ember.assert("Could not find view: '" + fullName + "'", !!ViewKlass);
+
+ view = ViewKlass.create(attrs);
+ } else {
+ Ember.assert('You must pass instance or subclass of View', view.isView);
+
+ attrs.container = this.container;
+ setProperties(view, attrs);
+ }
+
+ return view;
+ },
+
+ becameVisible: K,
+ becameHidden: K,
+
+ /**
+ When the view's `isVisible` property changes, toggle the visibility
+ element of the actual DOM element.
+
+ @method _isVisibleDidChange
+ @private
+ */
+ _isVisibleDidChange: observer('isVisible', function() {
+ if (this._isVisible === get(this, 'isVisible')) { return ; }
+ run.scheduleOnce('render', this, this._toggleVisibility);
+ }),
+
+ _toggleVisibility: function() {
+ var $el = this.$();
+ var isVisible = get(this, 'isVisible');
+
+ if (this._isVisible === isVisible) { return ; }
+
+ // It's important to keep these in sync, even if we don't yet have
+ // an element in the DOM to manipulate:
+ this._isVisible = isVisible;
+
+ if (!$el) { return; }
+
+ $el.toggle(isVisible);
+
+ if (this._isAncestorHidden()) { return; }
+
+ if (isVisible) {
+ this._notifyBecameVisible();
+ } else {
+ this._notifyBecameHidden();
+ }
+ },
+
+ _notifyBecameVisible: function() {
+ this.trigger('becameVisible');
+
+ this.forEachChildView(function(view) {
+ var isVisible = get(view, 'isVisible');
+
+ if (isVisible || isVisible === null) {
+ view._notifyBecameVisible();
+ }
+ });
+ },
+
+ _notifyBecameHidden: function() {
+ this.trigger('becameHidden');
+ this.forEachChildView(function(view) {
+ var isVisible = get(view, 'isVisible');
+
+ if (isVisible || isVisible === null) {
+ view._notifyBecameHidden();
+ }
+ });
+ },
+
+ _isAncestorHidden: function() {
+ var parent = get(this, 'parentView');
+
+ while (parent) {
+ if (get(parent, 'isVisible') === false) { return true; }
+
+ parent = get(parent, 'parentView');
+ }
+
+ return false;
+ },
+ transitionTo: function(state, children) {
+ Ember.deprecate("Ember.View#transitionTo has been deprecated, it is for internal use only");
+ this._transitionTo(state, children);
+ },
+ _transitionTo: function(state, children) {
+ var priorState = this.currentState;
+ var currentState = this.currentState = this._states[state];
+ this._state = state;
+
+ if (priorState && priorState.exit) { priorState.exit(this); }
+ if (currentState.enter) { currentState.enter(this); }
+ },
+
+ // .......................................................
+ // EVENT HANDLING
+ //
+
+ /**
+ Handle events from `Ember.EventDispatcher`
+
+ @method handleEvent
+ @param eventName {String}
+ @param evt {Event}
+ @private
+ */
+ handleEvent: function(eventName, evt) {
+ return this.currentState.handleEvent(this, eventName, evt);
+ },
+
+ registerObserver: function(root, path, target, observer) {
+ if (!observer && 'function' === typeof target) {
+ observer = target;
+ target = null;
+ }
+
+ if (!root || typeof root !== 'object') {
+ return;
+ }
+
+ var scheduledObserver = this._wrapAsScheduled(observer);
+
+ addObserver(root, path, target, scheduledObserver);
+
+ this.one('willClearRender', function() {
+ removeObserver(root, path, target, scheduledObserver);
+ });
+ },
+
+ _wrapAsScheduled: function(fn) {
+ var view = this;
+ var stateCheckedFn = function() {
+ view.currentState.invokeObserver(this, fn);
+ };
+ var scheduledFn = function() {
+ run.scheduleOnce('render', this, stateCheckedFn);
+ };
+ return scheduledFn;
+ },
+
+ getStream: function(path) {
+ var stream = this._getContextStream().get(path);
+
+ stream._label = path;
+
+ return stream;
+ },
+
+ _getBindingForStream: function(pathOrStream) {
+ if (this._streamBindings === undefined) {
+ this._streamBindings = create(null);
+ this.one('willDestroyElement', this, this._destroyStreamBindings);
+ }
+
+ var path = pathOrStream;
+ if (isStream(pathOrStream)) {
+ path = pathOrStream._label;
+
+ if (!path) {
+ // if no _label is present on the provided stream
+ // it is likely a subexpr and cannot be set (so it
+ // does not need a StreamBinding)
+ return pathOrStream;
+ }
+ }
+
+ if (this._streamBindings[path] !== undefined) {
+ return this._streamBindings[path];
+ } else {
+ var stream = this._getContextStream().get(path);
+ var streamBinding = new StreamBinding(stream);
+
+ streamBinding._label = path;
+
+ return this._streamBindings[path] = streamBinding;
+ }
+ },
+
+ _destroyStreamBindings: function() {
+ var streamBindings = this._streamBindings;
+ for (var path in streamBindings) {
+ streamBindings[path].destroy();
+ }
+ this._streamBindings = undefined;
+ },
+
+ _getContextStream: function() {
+ if (this._contextStream === undefined) {
+ this._baseContext = new KeyStream(this, 'context');
+ this._contextStream = new ContextStream(this);
+ this.one('willDestroyElement', this, this._destroyContextStream);
+ }
+
+ return this._contextStream;
+ },
+
+ _destroyContextStream: function() {
+ this._baseContext.destroy();
+ this._baseContext = undefined;
+ this._contextStream.destroy();
+ this._contextStream = undefined;
+ },
+
+ _unsubscribeFromStreamBindings: function() {
+ for (var key in this._streamBindingSubscriptions) {
+ var streamBinding = this[key + 'Binding'];
+ var callback = this._streamBindingSubscriptions[key];
+ streamBinding.unsubscribe(callback);
+ }
+ }
+ });
+
+ deprecateProperty(View.prototype, 'state', '_state');
+ deprecateProperty(View.prototype, 'states', '_states');
+
+ /*
+ Describe how the specified actions should behave in the various
+ states that a view can exist in. Possible states:
+
+ * preRender: when a view is first instantiated, and after its
+ element was destroyed, it is in the preRender state
+ * inBuffer: once a view has been rendered, but before it has
+ been inserted into the DOM, it is in the inBuffer state
+ * hasElement: the DOM representation of the view is created,
+ and is ready to be inserted
+ * inDOM: once a view has been inserted into the DOM it is in
+ the inDOM state. A view spends the vast majority of its
+ existence in this state.
+ * destroyed: once a view has been destroyed (using the destroy
+ method), it is in this state. No further actions can be invoked
+ on a destroyed view.
+ */
+
+ // in the destroyed state, everything is illegal
+
+ // before rendering has begun, all legal manipulations are noops.
+
+ // inside the buffer, legal manipulations are done on the buffer
+
+ // once the view has been inserted into the DOM, legal manipulations
+ // are done on the DOM element.
+
+ var mutation = EmberObject.extend(Evented).create();
+ // TODO MOVE TO RENDERER HOOKS
+ View.addMutationListener = function(callback) {
+ mutation.on('change', callback);
+ };
+
+ View.removeMutationListener = function(callback) {
+ mutation.off('change', callback);
+ };
+
+ View.notifyMutationListeners = function() {
+ mutation.trigger('change');
+ };
+
+ /**
+ Global views hash
+
+ @property views
+ @static
+ @type Hash
+ */
+ View.views = {};
+
+ // If someone overrides the child views computed property when
+ // defining their class, we want to be able to process the user's
+ // supplied childViews and then restore the original computed property
+ // at view initialization time. This happens in Ember.ContainerView's init
+ // method.
+ View.childViewsProperty = childViewsProperty;
+
+ // Used by Handlebars helpers, view element attributes
+ View.applyAttributeBindings = function(elem, name, initialValue) {
+ var value = sanitizeAttributeValue(elem[0], name, initialValue);
+ var type = typeOf(value);
+
+ // if this changes, also change the logic in ember-handlebars/lib/helpers/binding.js
+ if (name !== 'value' && (type === 'string' || (type === 'number' && !isNaN(value)))) {
+ if (value !== elem.attr(name)) {
+ elem.attr(name, value);
+ }
+ } else if (name === 'value' || type === 'boolean') {
+ if (isNone(value) || value === false) {
+ // `null`, `undefined` or `false` should remove attribute
+ elem.removeAttr(name);
+ // In IE8 `prop` couldn't remove attribute when name is `required`.
+ if (name === 'required') {
+ elem.removeProp(name);
+ } else {
+ elem.prop(name, '');
+ }
+ } else if (value !== elem.prop(name)) {
+ // value should always be properties
+ elem.prop(name, value);
+ }
+ } else if (!value) {
+ elem.removeAttr(name);
+ }
+ };
+
+ __exports__["default"] = View;
+ });
+enifed("ember-views/views/with_view",
+ ["ember-metal/property_set","ember-metal/utils","ember-views/views/bound_view","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+
+ /**
+ @module ember
+ @submodule ember-views
+ */
+
+ var set = __dependency1__.set;
+ var apply = __dependency2__.apply;
+ var BoundView = __dependency3__["default"];
+
+ __exports__["default"] = BoundView.extend({
+ init: function() {
+ apply(this, this._super, arguments);
+
+ var controllerName = this.templateHash.controller;
+
+ if (controllerName) {
+ var previousContext = this.previousContext;
+ var controller = this.container.lookupFactory('controller:'+controllerName).create({
+ parentController: previousContext,
+ target: previousContext
+ });
+
+ this._generatedController = controller;
+
+ if (this.preserveContext) {
+ this._blockArguments = [ controller ];
+ this.lazyValue.subscribe(function(modelStream) {
+ set(controller, 'model', modelStream.value());
+ });
+ } else {
+ set(this, 'controller', controller);
+ this.valueNormalizerFunc = function(result) {
+ controller.set('model', result);
+ return controller;
+ };
+ }
+
+ set(controller, 'model', this.lazyValue.value());
+ } else {
+ if (this.preserveContext) {
+ this._blockArguments = [ this.lazyValue ];
+ }
+ }
+ },
+
+ willDestroy: function() {
+ this._super();
+
+ if (this._generatedController) {
+ this._generatedController.destroy();
+ }
+ }
+ });
+ });
+enifed("ember",
+ ["ember-metal","ember-runtime","ember-views","ember-routing","ember-application","ember-extension-support","ember-htmlbars","ember-routing-htmlbars","ember-runtime/system/lazy_load"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__) {
+ "use strict";
+ /* global navigator */
+ // require the main entry points for each of these packages
+ // this is so that the global exports occur properly
+
+ var runLoadHooks = __dependency9__.runLoadHooks;
+
+ if (Ember.__loader.registry['ember-template-compiler']) {
+ requireModule('ember-template-compiler');
+ }
+
+ // do this to ensure that Ember.Test is defined properly on the global
+ // if it is present.
+ if (Ember.__loader.registry['ember-testing']) {
+ requireModule('ember-testing');
+ }
+
+ runLoadHooks('Ember');
+
+ /**
+ Ember
+
+ @module ember
+ */
+
+ Ember.deprecate('Usage of Ember is deprecated for Internet Explorer 6 and 7, support will be removed in the next major version.', !navigator.userAgent.match(/MSIE [67]/));
+ });
+enifed("htmlbars-util",
+ ["./htmlbars-util/safe-string","./htmlbars-util/handlebars/utils","./htmlbars-util/namespaces","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var SafeString = __dependency1__["default"];
+ var escapeExpression = __dependency2__.escapeExpression;
+ var getAttrNamespace = __dependency3__.getAttrNamespace;
+
+ __exports__.SafeString = SafeString;
+ __exports__.escapeExpression = escapeExpression;
+ __exports__.getAttrNamespace = getAttrNamespace;
+ });
+enifed("htmlbars-util/array-utils",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ function forEach(array, callback, binding) {
+ var i, l;
+ if (binding === undefined) {
+ for (i = 0, l = array.length; i < l; i++) {
+ callback(array[i], i, array);
+ }
+ } else {
+ for (i = 0, l = array.length; i < l; i++) {
+ callback.call(binding, array[i], i, array);
+ }
+ }
+ }
+
+ __exports__.forEach = forEach;function map(array, callback) {
+ var output = [];
+ var i, l;
+
+ for (i = 0, l = array.length; i < l; i++) {
+ output.push(callback(array[i], i, array));
+ }
+
+ return output;
+ }
+
+ __exports__.map = map;var getIdx;
+ if (Array.prototype.indexOf) {
+ getIdx = function(array, obj, from){
+ return array.indexOf(obj, from);
+ };
+ } else {
+ getIdx = function(array, obj, from) {
+ if (from === undefined || from === null) {
+ from = 0;
+ } else if (from < 0) {
+ from = Math.max(0, array.length + from);
+ }
+ for (var i = from, l= array.length; i < l; i++) {
+ if (array[i] === obj) {
+ return i;
+ }
+ }
+ return -1;
+ };
+ }
+
+ var indexOfArray = getIdx;
+ __exports__.indexOfArray = indexOfArray;
+ });
+enifed("htmlbars-util/handlebars/safe-string",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ // Build out our basic SafeString type
+ function SafeString(string) {
+ this.string = string;
+ }
+
+ SafeString.prototype.toString = SafeString.prototype.toHTML = function() {
+ return "" + this.string;
+ };
+
+ __exports__["default"] = SafeString;
+ });
+enifed("htmlbars-util/handlebars/utils",
+ ["./safe-string","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ /*jshint -W004 */
+ var SafeString = __dependency1__["default"];
+
+ var escape = {
+ "&": "&",
+ "<": "<",
+ ">": ">",
+ '"': """,
+ "'": "'",
+ "`": "`"
+ };
+
+ var badChars = /[&<>"'`]/g;
+ var possible = /[&<>"'`]/;
+
+ function escapeChar(chr) {
+ return escape[chr];
+ }
+
+ function extend(obj /* , ...source */) {
+ for (var i = 1; i < arguments.length; i++) {
+ for (var key in arguments[i]) {
+ if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
+ obj[key] = arguments[i][key];
+ }
+ }
+ }
+
+ return obj;
+ }
+
+ __exports__.extend = extend;var toString = Object.prototype.toString;
+ __exports__.toString = toString;
+ // Sourced from lodash
+ // https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
+ var isFunction = function(value) {
+ return typeof value === 'function';
+ };
+ // fallback for older versions of Chrome and Safari
+ /* istanbul ignore next */
+ if (isFunction(/x/)) {
+ isFunction = function(value) {
+ return typeof value === 'function' && toString.call(value) === '[object Function]';
+ };
+ }
+ var isFunction;
+ __exports__.isFunction = isFunction;
+ /* istanbul ignore next */
+ var isArray = Array.isArray || function(value) {
+ return (value && typeof value === 'object') ? toString.call(value) === '[object Array]' : false;
+ };
+ __exports__.isArray = isArray;
+
+ function escapeExpression(string) {
+ // don't escape SafeStrings, since they're already safe
+ if (string && string.toHTML) {
+ return string.toHTML();
+ } else if (string == null) {
+ return "";
+ } else if (!string) {
+ return string + '';
+ }
+
+ // Force a string conversion as this will be done by the append regardless and
+ // the regex test will do this transparently behind the scenes, causing issues if
+ // an object's to string has escaped characters in it.
+ string = "" + string;
+
+ if(!possible.test(string)) { return string; }
+ return string.replace(badChars, escapeChar);
+ }
+
+ __exports__.escapeExpression = escapeExpression;function isEmpty(value) {
+ if (!value && value !== 0) {
+ return true;
+ } else if (isArray(value) && value.length === 0) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ __exports__.isEmpty = isEmpty;function appendContextPath(contextPath, id) {
+ return (contextPath ? contextPath + '.' : '') + id;
+ }
+
+ __exports__.appendContextPath = appendContextPath;
+ });
+enifed("htmlbars-util/namespaces",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ // ref http://dev.w3.org/html5/spec-LC/namespaces.html
+ var defaultNamespaces = {
+ html: 'http://www.w3.org/1999/xhtml',
+ mathml: 'http://www.w3.org/1998/Math/MathML',
+ svg: 'http://www.w3.org/2000/svg',
+ xlink: 'http://www.w3.org/1999/xlink',
+ xml: 'http://www.w3.org/XML/1998/namespace'
+ };
+
+ function getAttrNamespace(attrName) {
+ var namespace;
+
+ var colonIndex = attrName.indexOf(':');
+ if (colonIndex !== -1) {
+ var prefix = attrName.slice(0, colonIndex);
+ namespace = defaultNamespaces[prefix];
+ }
+
+ return namespace || null;
+ }
+
+ __exports__.getAttrNamespace = getAttrNamespace;
+ });
+enifed("htmlbars-util/object-utils",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ function merge(options, defaults) {
+ for (var prop in defaults) {
+ if (options.hasOwnProperty(prop)) { continue; }
+ options[prop] = defaults[prop];
+ }
+ return options;
+ }
+
+ __exports__.merge = merge;
+ });
+enifed("htmlbars-util/quoting",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ function escapeString(str) {
+ str = str.replace(/\\/g, "\\\\");
+ str = str.replace(/"/g, '\\"');
+ str = str.replace(/\n/g, "\\n");
+ return str;
+ }
+
+ __exports__.escapeString = escapeString;
+
+ function string(str) {
+ return '"' + escapeString(str) + '"';
+ }
+
+ __exports__.string = string;
+
+ function array(a) {
+ return "[" + a + "]";
+ }
+
+ __exports__.array = array;
+
+ function hash(pairs) {
+ return "{" + pairs.join(", ") + "}";
+ }
+
+ __exports__.hash = hash;function repeat(chars, times) {
+ var str = "";
+ while (times--) {
+ str += chars;
+ }
+ return str;
+ }
+
+ __exports__.repeat = repeat;
+ });
+enifed("htmlbars-util/safe-string",
+ ["./handlebars/safe-string","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var SafeString = __dependency1__["default"];
+
+ __exports__["default"] = SafeString;
+ });
+enifed("morph",
+ ["./morph/morph","./morph/attr-morph","./morph/dom-helper","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var Morph = __dependency1__["default"];
+ var AttrMorph = __dependency2__["default"];
+ var DOMHelper = __dependency3__["default"];
+
+ __exports__.Morph = Morph;
+ __exports__.AttrMorph = AttrMorph;
+ __exports__.DOMHelper = DOMHelper;
+ });
+enifed("morph/attr-morph",
+ ["./attr-morph/sanitize-attribute-value","./dom-helper/prop","./dom-helper/build-html-dom","../htmlbars-util","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ var sanitizeAttributeValue = __dependency1__.sanitizeAttributeValue;
+ var isAttrRemovalValue = __dependency2__.isAttrRemovalValue;
+ var normalizeProperty = __dependency2__.normalizeProperty;
+ var svgNamespace = __dependency3__.svgNamespace;
+ var getAttrNamespace = __dependency4__.getAttrNamespace;
+
+ function updateProperty(value) {
+ this.domHelper.setPropertyStrict(this.element, this.attrName, value);
+ }
+
+ function updateAttribute(value) {
+ if (isAttrRemovalValue(value)) {
+ this.domHelper.removeAttribute(this.element, this.attrName);
+ } else {
+ this.domHelper.setAttribute(this.element, this.attrName, value);
+ }
+ }
+
+ function updateAttributeNS(value) {
+ if (isAttrRemovalValue(value)) {
+ this.domHelper.removeAttribute(this.element, this.attrName);
+ } else {
+ this.domHelper.setAttributeNS(this.element, this.namespace, this.attrName, value);
+ }
+ }
+
+ function AttrMorph(element, attrName, domHelper, namespace) {
+ this.element = element;
+ this.domHelper = domHelper;
+ this.namespace = namespace !== undefined ? namespace : getAttrNamespace(attrName);
+ this.escaped = true;
+
+ var normalizedAttrName = normalizeProperty(this.element, attrName);
+ if (this.namespace) {
+ this._update = updateAttributeNS;
+ this.attrName = attrName;
+ } else {
+ if (element.namespaceURI === svgNamespace || attrName === 'style' || !normalizedAttrName) {
+ this.attrName = attrName;
+ this._update = updateAttribute;
+ } else {
+ this.attrName = normalizedAttrName;
+ this._update = updateProperty;
+ }
+ }
+ }
+
+ AttrMorph.prototype.setContent = function (value) {
+ if (this.escaped) {
+ var sanitized = sanitizeAttributeValue(this.element, this.attrName, value);
+ this._update(sanitized, this.namespace);
+ } else {
+ this._update(value, this.namespace);
+ }
+ };
+
+ __exports__["default"] = AttrMorph;
+ });
+enifed("morph/attr-morph/sanitize-attribute-value",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ /* jshint scripturl:true */
+
+ var parsingNode;
+ var badProtocols = {
+ 'javascript:': true,
+ 'vbscript:': true
+ };
+
+ var badTags = {
+ 'A': true,
+ 'BODY': true,
+ 'LINK': true,
+ 'IMG': true,
+ 'IFRAME': true
+ };
+
+ var badAttributes = {
+ 'href': true,
+ 'src': true,
+ 'background': true
+ };
+ __exports__.badAttributes = badAttributes;
+ function sanitizeAttributeValue(element, attribute, value) {
+ var tagName;
+
+ if (!parsingNode) {
+ parsingNode = document.createElement('a');
+ }
+
+ if (!element) {
+ tagName = null;
+ } else {
+ tagName = element.tagName;
+ }
+
+ if (value && value.toHTML) {
+ return value.toHTML();
+ }
+
+ if ((tagName === null || badTags[tagName]) && badAttributes[attribute]) {
+ parsingNode.href = value;
+
+ if (badProtocols[parsingNode.protocol] === true) {
+ return 'unsafe:' + value;
+ }
+ }
+
+ return value;
+ }
+
+ __exports__.sanitizeAttributeValue = sanitizeAttributeValue;
+ });
+enifed("morph/dom-helper",
+ ["../morph/morph","../morph/attr-morph","./dom-helper/build-html-dom","./dom-helper/classes","./dom-helper/prop","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+ "use strict";
+ var Morph = __dependency1__["default"];
+ var AttrMorph = __dependency2__["default"];
+ var buildHTMLDOM = __dependency3__.buildHTMLDOM;
+ var svgNamespace = __dependency3__.svgNamespace;
+ var svgHTMLIntegrationPoints = __dependency3__.svgHTMLIntegrationPoints;
+ var addClasses = __dependency4__.addClasses;
+ var removeClasses = __dependency4__.removeClasses;
+ var normalizeProperty = __dependency5__.normalizeProperty;
+ var isAttrRemovalValue = __dependency5__.isAttrRemovalValue;
+
+ var doc = typeof document === 'undefined' ? false : document;
+
+ var deletesBlankTextNodes = doc && (function(document){
+ var element = document.createElement('div');
+ element.appendChild( document.createTextNode('') );
+ var clonedElement = element.cloneNode(true);
+ return clonedElement.childNodes.length === 0;
+ })(doc);
+
+ var ignoresCheckedAttribute = doc && (function(document){
+ var element = document.createElement('input');
+ element.setAttribute('checked', 'checked');
+ var clonedElement = element.cloneNode(false);
+ return !clonedElement.checked;
+ })(doc);
+
+ var canRemoveSvgViewBoxAttribute = doc && (doc.createElementNS ? (function(document){
+ var element = document.createElementNS(svgNamespace, 'svg');
+ element.setAttribute('viewBox', '0 0 100 100');
+ element.removeAttribute('viewBox');
+ return !element.getAttribute('viewBox');
+ })(doc) : true);
+
+ var canClone = doc && (function(document){
+ var element = document.createElement('div');
+ element.appendChild( document.createTextNode(' '));
+ element.appendChild( document.createTextNode(' '));
+ var clonedElement = element.cloneNode(true);
+ return clonedElement.childNodes[0].nodeValue === ' ';
+ })(doc);
+
+ // This is not the namespace of the element, but of
+ // the elements inside that elements.
+ function interiorNamespace(element){
+ if (
+ element &&
+ element.namespaceURI === svgNamespace &&
+ !svgHTMLIntegrationPoints[element.tagName]
+ ) {
+ return svgNamespace;
+ } else {
+ return null;
+ }
+ }
+
+ // The HTML spec allows for "omitted start tags". These tags are optional
+ // when their intended child is the first thing in the parent tag. For
+ // example, this is a tbody start tag:
+ //
+ //
+ //
+ //
+ //
+ // The tbody may be omitted, and the browser will accept and render:
+ //
+ //
+ //
+ //
+ // However, the omitted start tag will still be added to the DOM. Here
+ // we test the string and context to see if the browser is about to
+ // perform this cleanup.
+ //
+ // http://www.whatwg.org/specs/web-apps/current-work/multipage/syntax.html#optional-tags
+ // describes which tags are omittable. The spec for tbody and colgroup
+ // explains this behavior:
+ //
+ // http://www.whatwg.org/specs/web-apps/current-work/multipage/tables.html#the-tbody-element
+ // http://www.whatwg.org/specs/web-apps/current-work/multipage/tables.html#the-colgroup-element
+ //
+
+ var omittedStartTagChildTest = /<([\w:]+)/;
+ function detectOmittedStartTag(string, contextualElement){
+ // Omitted start tags are only inside table tags.
+ if (contextualElement.tagName === 'TABLE') {
+ var omittedStartTagChildMatch = omittedStartTagChildTest.exec(string);
+ if (omittedStartTagChildMatch) {
+ var omittedStartTagChild = omittedStartTagChildMatch[1];
+ // It is already asserted that the contextual element is a table
+ // and not the proper start tag. Just see if a tag was omitted.
+ return omittedStartTagChild === 'tr' ||
+ omittedStartTagChild === 'col';
+ }
+ }
+ }
+
+ function buildSVGDOM(html, dom){
+ var div = dom.document.createElement('div');
+ div.innerHTML = '';
+ return div.firstChild.childNodes;
+ }
+
+ /*
+ * A class wrapping DOM functions to address environment compatibility,
+ * namespaces, contextual elements for morph un-escaped content
+ * insertion.
+ *
+ * When entering a template, a DOMHelper should be passed:
+ *
+ * template(context, { hooks: hooks, dom: new DOMHelper() });
+ *
+ * TODO: support foreignObject as a passed contextual element. It has
+ * a namespace (svg) that does not match its internal namespace
+ * (xhtml).
+ *
+ * @class DOMHelper
+ * @constructor
+ * @param {HTMLDocument} _document The document DOM methods are proxied to
+ */
+ function DOMHelper(_document){
+ this.document = _document || document;
+ if (!this.document) {
+ throw new Error("A document object must be passed to the DOMHelper, or available on the global scope");
+ }
+ this.canClone = canClone;
+ this.namespace = null;
+ }
+
+ var prototype = DOMHelper.prototype;
+ prototype.constructor = DOMHelper;
+
+ prototype.getElementById = function(id, rootNode) {
+ rootNode = rootNode || this.document;
+ return rootNode.getElementById(id);
+ };
+
+ prototype.insertBefore = function(element, childElement, referenceChild) {
+ return element.insertBefore(childElement, referenceChild);
+ };
+
+ prototype.appendChild = function(element, childElement) {
+ return element.appendChild(childElement);
+ };
+
+ prototype.childAt = function(element, indices) {
+ var child = element;
+
+ for (var i = 0; i < indices.length; i++) {
+ child = child.childNodes.item(indices[i]);
+ }
+
+ return child;
+ };
+
+ // Note to a Fellow Implementor:
+ // Ahh, accessing a child node at an index. Seems like it should be so simple,
+ // doesn't it? Unfortunately, this particular method has caused us a surprising
+ // amount of pain. As you'll note below, this method has been modified to walk
+ // the linked list of child nodes rather than access the child by index
+ // directly, even though there are two (2) APIs in the DOM that do this for us.
+ // If you're thinking to yourself, "What an oversight! What an opportunity to
+ // optimize this code!" then to you I say: stop! For I have a tale to tell.
+ //
+ // First, this code must be compatible with simple-dom for rendering on the
+ // server where there is no real DOM. Previously, we accessed a child node
+ // directly via `element.childNodes[index]`. While we *could* in theory do a
+ // full-fidelity simulation of a live `childNodes` array, this is slow,
+ // complicated and error-prone.
+ //
+ // "No problem," we thought, "we'll just use the similar
+ // `childNodes.item(index)` API." Then, we could just implement our own `item`
+ // method in simple-dom and walk the child node linked list there, allowing
+ // us to retain the performance advantages of the (surely optimized) `item()`
+ // API in the browser.
+ //
+ // Unfortunately, an enterprising soul named Samy Alzahrani discovered that in
+ // IE8, accessing an item out-of-bounds via `item()` causes an exception where
+ // other browsers return null. This necessitated a... check of
+ // `childNodes.length`, bringing us back around to having to support a
+ // full-fidelity `childNodes` array!
+ //
+ // Worst of all, Kris Selden investigated how browsers are actualy implemented
+ // and discovered that they're all linked lists under the hood anyway. Accessing
+ // `childNodes` requires them to allocate a new live collection backed by that
+ // linked list, which is itself a rather expensive operation. Our assumed
+ // optimization had backfired! That is the danger of magical thinking about
+ // the performance of native implementations.
+ //
+ // And this, my friends, is why the following implementation just walks the
+ // linked list, as surprised as that may make you. Please ensure you understand
+ // the above before changing this and submitting a PR.
+ //
+ // Tom Dale, January 18th, 2015, Portland OR
+ prototype.childAtIndex = function(element, index) {
+ var node = element.firstChild;
+
+ for (var idx = 0; node && idx < index; idx++) {
+ node = node.nextSibling;
+ }
+
+ return node;
+ };
+
+ prototype.appendText = function(element, text) {
+ return element.appendChild(this.document.createTextNode(text));
+ };
+
+ prototype.setAttribute = function(element, name, value) {
+ element.setAttribute(name, String(value));
+ };
+
+ prototype.setAttributeNS = function(element, namespace, name, value) {
+ element.setAttributeNS(namespace, name, String(value));
+ };
+
+ if (canRemoveSvgViewBoxAttribute){
+ prototype.removeAttribute = function(element, name) {
+ element.removeAttribute(name);
+ };
+ } else {
+ prototype.removeAttribute = function(element, name) {
+ if (element.tagName === 'svg' && name === 'viewBox') {
+ element.setAttribute(name, null);
+ } else {
+ element.removeAttribute(name);
+ }
+ };
+ }
+
+ prototype.setPropertyStrict = function(element, name, value) {
+ element[name] = value;
+ };
+
+ prototype.setProperty = function(element, name, value, namespace) {
+ var lowercaseName = name.toLowerCase();
+ if (element.namespaceURI === svgNamespace || lowercaseName === 'style') {
+ if (isAttrRemovalValue(value)) {
+ element.removeAttribute(name);
+ } else {
+ if (namespace) {
+ element.setAttributeNS(namespace, name, value);
+ } else {
+ element.setAttribute(name, value);
+ }
+ }
+ } else {
+ var normalized = normalizeProperty(element, name);
+ if (normalized) {
+ element[normalized] = value;
+ } else {
+ if (isAttrRemovalValue(value)) {
+ element.removeAttribute(name);
+ } else {
+ if (namespace && element.setAttributeNS) {
+ element.setAttributeNS(namespace, name, value);
+ } else {
+ element.setAttribute(name, value);
+ }
+ }
+ }
+ }
+ };
+
+ if (doc && doc.createElementNS) {
+ // Only opt into namespace detection if a contextualElement
+ // is passed.
+ prototype.createElement = function(tagName, contextualElement) {
+ var namespace = this.namespace;
+ if (contextualElement) {
+ if (tagName === 'svg') {
+ namespace = svgNamespace;
+ } else {
+ namespace = interiorNamespace(contextualElement);
+ }
+ }
+ if (namespace) {
+ return this.document.createElementNS(namespace, tagName);
+ } else {
+ return this.document.createElement(tagName);
+ }
+ };
+ prototype.setAttributeNS = function(element, namespace, name, value) {
+ element.setAttributeNS(namespace, name, String(value));
+ };
+ } else {
+ prototype.createElement = function(tagName) {
+ return this.document.createElement(tagName);
+ };
+ prototype.setAttributeNS = function(element, namespace, name, value) {
+ element.setAttribute(name, String(value));
+ };
+ }
+
+ prototype.addClasses = addClasses;
+ prototype.removeClasses = removeClasses;
+
+ prototype.setNamespace = function(ns) {
+ this.namespace = ns;
+ };
+
+ prototype.detectNamespace = function(element) {
+ this.namespace = interiorNamespace(element);
+ };
+
+ prototype.createDocumentFragment = function(){
+ return this.document.createDocumentFragment();
+ };
+
+ prototype.createTextNode = function(text){
+ return this.document.createTextNode(text);
+ };
+
+ prototype.createComment = function(text){
+ return this.document.createComment(text);
+ };
+
+ prototype.repairClonedNode = function(element, blankChildTextNodes, isChecked){
+ if (deletesBlankTextNodes && blankChildTextNodes.length > 0) {
+ for (var i=0, len=blankChildTextNodes.length;i]*selected/;
+ return function detectAutoSelectedOption(select, option, html) { //jshint ignore:line
+ return select.selectedIndex === 0 &&
+ !detectAutoSelectedOptionRegex.test(html);
+ };
+ })();
+ } else {
+ detectAutoSelectedOption = function detectAutoSelectedOption(select, option, html) { //jshint ignore:line
+ var selectedAttribute = option.getAttribute('selected');
+ return select.selectedIndex === 0 && (
+ selectedAttribute === null ||
+ ( selectedAttribute !== '' && selectedAttribute.toLowerCase() !== 'selected' )
+ );
+ };
+ }
+
+ var tagNamesRequiringInnerHTMLFix = doc && (function(document) {
+ var tagNamesRequiringInnerHTMLFix;
+ // IE 9 and earlier don't allow us to set innerHTML on col, colgroup, frameset,
+ // html, style, table, tbody, tfoot, thead, title, tr. Detect this and add
+ // them to an initial list of corrected tags.
+ //
+ // Here we are only dealing with the ones which can have child nodes.
+ //
+ var tableNeedsInnerHTMLFix;
+ var tableInnerHTMLTestElement = document.createElement('table');
+ try {
+ tableInnerHTMLTestElement.innerHTML = '';
+ } catch (e) {
+ } finally {
+ tableNeedsInnerHTMLFix = (tableInnerHTMLTestElement.childNodes.length === 0);
+ }
+ if (tableNeedsInnerHTMLFix) {
+ tagNamesRequiringInnerHTMLFix = {
+ colgroup: ['table'],
+ table: [],
+ tbody: ['table'],
+ tfoot: ['table'],
+ thead: ['table'],
+ tr: ['table', 'tbody']
+ };
+ }
+
+ // IE 8 doesn't allow setting innerHTML on a select tag. Detect this and
+ // add it to the list of corrected tags.
+ //
+ var selectInnerHTMLTestElement = document.createElement('select');
+ selectInnerHTMLTestElement.innerHTML = '';
+ if (!selectInnerHTMLTestElement.childNodes[0]) {
+ tagNamesRequiringInnerHTMLFix = tagNamesRequiringInnerHTMLFix || {};
+ tagNamesRequiringInnerHTMLFix.select = [];
+ }
+ return tagNamesRequiringInnerHTMLFix;
+ })(doc);
+
+ function scriptSafeInnerHTML(element, html) {
+ // without a leading text node, IE will drop a leading script tag.
+ html = ''+html;
+
+ element.innerHTML = html;
+
+ var nodes = element.childNodes;
+
+ // Look for to remove it.
+ var shyElement = nodes[0];
+ while (shyElement.nodeType === 1 && !shyElement.nodeName) {
+ shyElement = shyElement.firstChild;
+ }
+ // At this point it's the actual unicode character.
+ if (shyElement.nodeType === 3 && shyElement.nodeValue.charAt(0) === "\u00AD") {
+ var newValue = shyElement.nodeValue.slice(1);
+ if (newValue.length) {
+ shyElement.nodeValue = shyElement.nodeValue.slice(1);
+ } else {
+ shyElement.parentNode.removeChild(shyElement);
+ }
+ }
+
+ return nodes;
+ }
+
+ function buildDOMWithFix(html, contextualElement){
+ var tagName = contextualElement.tagName;
+
+ // Firefox versions < 11 do not have support for element.outerHTML.
+ var outerHTML = contextualElement.outerHTML || new XMLSerializer().serializeToString(contextualElement);
+ if (!outerHTML) {
+ throw "Can't set innerHTML on "+tagName+" in this browser";
+ }
+
+ var wrappingTags = tagNamesRequiringInnerHTMLFix[tagName.toLowerCase()];
+ var startTag = outerHTML.match(new RegExp("<"+tagName+"([^>]*)>", 'i'))[0];
+ var endTag = '';
+
+ var wrappedHTML = [startTag, html, endTag];
+
+ var i = wrappingTags.length;
+ var wrappedDepth = 1 + i;
+ while(i--) {
+ wrappedHTML.unshift('<'+wrappingTags[i]+'>');
+ wrappedHTML.push('');
+ }
+
+ var wrapper = document.createElement('div');
+ scriptSafeInnerHTML(wrapper, wrappedHTML.join(''));
+ var element = wrapper;
+ while (wrappedDepth--) {
+ element = element.firstChild;
+ while (element && element.nodeType !== 1) {
+ element = element.nextSibling;
+ }
+ }
+ while (element && element.tagName !== tagName) {
+ element = element.nextSibling;
+ }
+ return element ? element.childNodes : [];
+ }
+
+ var buildDOM;
+ if (needsShy) {
+ buildDOM = function buildDOM(html, contextualElement, dom){
+ contextualElement = dom.cloneNode(contextualElement, false);
+ scriptSafeInnerHTML(contextualElement, html);
+ return contextualElement.childNodes;
+ };
+ } else {
+ buildDOM = function buildDOM(html, contextualElement, dom){
+ contextualElement = dom.cloneNode(contextualElement, false);
+ contextualElement.innerHTML = html;
+ return contextualElement.childNodes;
+ };
+ }
+
+ var buildIESafeDOM;
+ if (tagNamesRequiringInnerHTMLFix || movesWhitespace) {
+ buildIESafeDOM = function buildIESafeDOM(html, contextualElement, dom) {
+ // Make a list of the leading text on script nodes. Include
+ // script tags without any whitespace for easier processing later.
+ var spacesBefore = [];
+ var spacesAfter = [];
+ if (typeof html === 'string') {
+ html = html.replace(/(\s*)()(\s*)/g, function(match, tag, spaces) {
+ spacesAfter.push(spaces);
+ return tag;
+ });
+ }
+
+ // Fetch nodes
+ var nodes;
+ if (tagNamesRequiringInnerHTMLFix[contextualElement.tagName.toLowerCase()]) {
+ // buildDOMWithFix uses string wrappers for problematic innerHTML.
+ nodes = buildDOMWithFix(html, contextualElement);
+ } else {
+ nodes = buildDOM(html, contextualElement, dom);
+ }
+
+ // Build a list of script tags, the nodes themselves will be
+ // mutated as we add test nodes.
+ var i, j, node, nodeScriptNodes;
+ var scriptNodes = [];
+ for (i=0;i 0) {
+ textNode = dom.document.createTextNode(spaceBefore);
+ scriptNode.parentNode.insertBefore(textNode, scriptNode);
+ }
+
+ spaceAfter = spacesAfter[i];
+ if (spaceAfter && spaceAfter.length > 0) {
+ textNode = dom.document.createTextNode(spaceAfter);
+ scriptNode.parentNode.insertBefore(textNode, scriptNode.nextSibling);
+ }
+ }
+
+ return nodes;
+ };
+ } else {
+ buildIESafeDOM = buildDOM;
+ }
+
+ // When parsing innerHTML, the browser may set up DOM with some things
+ // not desired. For example, with a select element context and option
+ // innerHTML the first option will be marked selected.
+ //
+ // This method cleans up some of that, resetting those values back to
+ // their defaults.
+ //
+ function buildSafeDOM(html, contextualElement, dom) {
+ var childNodes = buildIESafeDOM(html, contextualElement, dom);
+
+ if (contextualElement.tagName === 'SELECT') {
+ // Walk child nodes
+ for (var i = 0; childNodes[i]; i++) {
+ // Find and process the first option child node
+ if (childNodes[i].tagName === 'OPTION') {
+ if (detectAutoSelectedOption(childNodes[i].parentNode, childNodes[i], html)) {
+ // If the first node is selected but does not have an attribute,
+ // presume it is not really selected.
+ childNodes[i].parentNode.selectedIndex = -1;
+ }
+ break;
+ }
+ }
+ }
+
+ return childNodes;
+ }
+
+ var buildHTMLDOM;
+ if (needsIntegrationPointFix) {
+ buildHTMLDOM = function buildHTMLDOM(html, contextualElement, dom){
+ if (svgHTMLIntegrationPoints[contextualElement.tagName]) {
+ return buildSafeDOM(html, document.createElement('div'), dom);
+ } else {
+ return buildSafeDOM(html, contextualElement, dom);
+ }
+ };
+ } else {
+ buildHTMLDOM = buildSafeDOM;
+ }
+
+ __exports__.buildHTMLDOM = buildHTMLDOM;
+ });
+enifed("morph/dom-helper/classes",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ var doc = typeof document === 'undefined' ? false : document;
+
+ // PhantomJS has a broken classList. See https://github.com/ariya/phantomjs/issues/12782
+ var canClassList = doc && (function(){
+ var d = document.createElement('div');
+ if (!d.classList) {
+ return false;
+ }
+ d.classList.add('boo');
+ d.classList.add('boo', 'baz');
+ return (d.className === 'boo baz');
+ })();
+
+ function buildClassList(element) {
+ var classString = (element.getAttribute('class') || '');
+ return classString !== '' && classString !== ' ' ? classString.split(' ') : [];
+ }
+
+ function intersect(containingArray, valuesArray) {
+ var containingIndex = 0;
+ var containingLength = containingArray.length;
+ var valuesIndex = 0;
+ var valuesLength = valuesArray.length;
+
+ var intersection = new Array(valuesLength);
+
+ // TODO: rewrite this loop in an optimal manner
+ for (;containingIndex 0 ? existingClasses.join(' ') : '');
+ }
+ }
+
+ function removeClassesViaAttribute(element, classNames) {
+ var existingClasses = buildClassList(element);
+
+ var indexes = intersect(classNames, existingClasses);
+ var didChange = false;
+ var newClasses = [];
+
+ for (var i=0, l=existingClasses.length; i 0 ? newClasses.join(' ') : '');
+ }
+ }
+
+ var addClasses, removeClasses;
+ if (canClassList) {
+ addClasses = function addClasses(element, classNames) {
+ if (element.classList) {
+ if (classNames.length === 1) {
+ element.classList.add(classNames[0]);
+ } else if (classNames.length === 2) {
+ element.classList.add(classNames[0], classNames[1]);
+ } else {
+ element.classList.add.apply(element.classList, classNames);
+ }
+ } else {
+ addClassesViaAttribute(element, classNames);
+ }
+ };
+ removeClasses = function removeClasses(element, classNames) {
+ if (element.classList) {
+ if (classNames.length === 1) {
+ element.classList.remove(classNames[0]);
+ } else if (classNames.length === 2) {
+ element.classList.remove(classNames[0], classNames[1]);
+ } else {
+ element.classList.remove.apply(element.classList, classNames);
+ }
+ } else {
+ removeClassesViaAttribute(element, classNames);
+ }
+ };
+ } else {
+ addClasses = addClassesViaAttribute;
+ removeClasses = removeClassesViaAttribute;
+ }
+
+ __exports__.addClasses = addClasses;
+ __exports__.removeClasses = removeClasses;
+ });
+enifed("morph/dom-helper/prop",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ function isAttrRemovalValue(value) {
+ return value === null || value === undefined;
+ }
+
+ __exports__.isAttrRemovalValue = isAttrRemovalValue;// TODO should this be an o_create kind of thing?
+ var propertyCaches = {};
+ __exports__.propertyCaches = propertyCaches;
+ function normalizeProperty(element, attrName) {
+ var tagName = element.tagName;
+ var key;
+ var cache = propertyCaches[tagName];
+ if (!cache) {
+ // TODO should this be an o_create kind of thing?
+ cache = {};
+ for (key in element) {
+ cache[key.toLowerCase()] = key;
+ }
+ propertyCaches[tagName] = cache;
+ }
+
+ // presumes that the attrName has been lowercased.
+ return cache[attrName];
+ }
+
+ __exports__.normalizeProperty = normalizeProperty;
+ });
+enifed("morph/morph",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ var splice = Array.prototype.splice;
+
+ function ensureStartEnd(start, end) {
+ if (start === null || end === null) {
+ throw new Error('a fragment parent must have boundary nodes in order to detect insertion');
+ }
+ }
+
+ function ensureContext(contextualElement) {
+ if (!contextualElement || contextualElement.nodeType !== 1) {
+ throw new Error('An element node must be provided for a contextualElement, you provided ' +
+ (contextualElement ? 'nodeType ' + contextualElement.nodeType : 'nothing'));
+ }
+ }
+
+ // TODO: this is an internal API, this should be an assert
+ function Morph(parent, start, end, domHelper, contextualElement) {
+ if (parent.nodeType === 11) {
+ ensureStartEnd(start, end);
+ this.element = null;
+ } else {
+ this.element = parent;
+ }
+ this._parent = parent;
+ this.start = start;
+ this.end = end;
+ this.domHelper = domHelper;
+ ensureContext(contextualElement);
+ this.contextualElement = contextualElement;
+ this.escaped = true;
+ this.reset();
+ }
+
+ Morph.prototype.reset = function() {
+ this.text = null;
+ this.owner = null;
+ this.morphs = null;
+ this.before = null;
+ this.after = null;
+ };
+
+ Morph.prototype.parent = function () {
+ if (!this.element) {
+ var parent = this.start.parentNode;
+ if (this._parent !== parent) {
+ this._parent = parent;
+ }
+ if (parent.nodeType === 1) {
+ this.element = parent;
+ }
+ }
+ return this._parent;
+ };
+
+ Morph.prototype.destroy = function () {
+ if (this.owner) {
+ this.owner.removeMorph(this);
+ } else {
+ clear(this.element || this.parent(), this.start, this.end);
+ }
+ };
+
+ Morph.prototype.removeMorph = function (morph) {
+ var morphs = this.morphs;
+ for (var i=0, l=morphs.length; i 0 ? morphs[index-1] : null;
+ var after = index < morphs.length ? morphs[index] : null;
+ var start = before === null ? this.start : (before.end === null ? parent.lastChild : before.end.previousSibling);
+ var end = after === null ? this.end : (after.start === null ? parent.firstChild : after.start.nextSibling);
+ var morph = new Morph(parent, start, end, this.domHelper, this.contextualElement);
+
+ morph.owner = this;
+ morph._update(parent, node);
+
+ if (before !== null) {
+ morph.before = before;
+ before.end = start.nextSibling;
+ before.after = morph;
+ }
+
+ if (after !== null) {
+ morph.after = after;
+ after.before = morph;
+ after.start = end.previousSibling;
+ }
+
+ this.morphs.splice(index, 0, morph);
+ return morph;
+ };
+
+ Morph.prototype.replace = function (index, removedLength, addedNodes) {
+ if (this.morphs === null) {
+ this.morphs = [];
+ }
+ var parent = this.element || this.parent();
+ var morphs = this.morphs;
+ var before = index > 0 ? morphs[index-1] : null;
+ var after = index+removedLength < morphs.length ? morphs[index+removedLength] : null;
+ var start = before === null ? this.start : (before.end === null ? parent.lastChild : before.end.previousSibling);
+ var end = after === null ? this.end : (after.start === null ? parent.firstChild : after.start.nextSibling);
+ var addedLength = addedNodes === undefined ? 0 : addedNodes.length;
+ var args, i, current;
+
+ if (removedLength > 0) {
+ clear(parent, start, end);
+ }
+
+ if (addedLength === 0) {
+ if (before !== null) {
+ before.after = after;
+ before.end = end;
+ }
+ if (after !== null) {
+ after.before = before;
+ after.start = start;
+ }
+ morphs.splice(index, removedLength);
+ return;
+ }
+
+ args = new Array(addedLength+2);
+ if (addedLength > 0) {
+ for (i=0; i " + n.nextStates.map(function(s) { return s.debug() }).join(" or ") + " )";
+ }).join(", ")
+ }
+ END IF **/
+
+ // This is a somewhat naive strategy, but should work in a lot of cases
+ // A better strategy would properly resolve /posts/:id/new and /posts/edit/:id.
+ //
+ // This strategy generally prefers more static and less dynamic matching.
+ // Specifically, it
+ //
+ // * prefers fewer stars to more, then
+ // * prefers using stars for less of the match to more, then
+ // * prefers fewer dynamic segments to more, then
+ // * prefers more static segments to more
+ function sortSolutions(states) {
+ return states.sort(function(a, b) {
+ if (a.types.stars !== b.types.stars) { return a.types.stars - b.types.stars; }
+
+ if (a.types.stars) {
+ if (a.types.statics !== b.types.statics) { return b.types.statics - a.types.statics; }
+ if (a.types.dynamics !== b.types.dynamics) { return b.types.dynamics - a.types.dynamics; }
+ }
+
+ if (a.types.dynamics !== b.types.dynamics) { return a.types.dynamics - b.types.dynamics; }
+ if (a.types.statics !== b.types.statics) { return b.types.statics - a.types.statics; }
+
+ return 0;
+ });
+ }
+
+ function recognizeChar(states, ch) {
+ var nextStates = [];
+
+ for (var i=0, l=states.length; i 2 && key.slice(keyLength -2) === '[]') {
+ isArray = true;
+ key = key.slice(0, keyLength - 2);
+ if(!queryParams[key]) {
+ queryParams[key] = [];
+ }
+ }
+ value = pair[1] ? decodeQueryParamPart(pair[1]) : '';
+ }
+ if (isArray) {
+ queryParams[key].push(value);
+ } else {
+ queryParams[key] = value;
+ }
+ }
+ return queryParams;
+ },
+
+ recognize: function(path) {
+ var states = [ this.rootState ],
+ pathLen, i, l, queryStart, queryParams = {},
+ isSlashDropped = false;
+
+ queryStart = path.indexOf('?');
+ if (queryStart !== -1) {
+ var queryString = path.substr(queryStart + 1, path.length);
+ path = path.substr(0, queryStart);
+ queryParams = this.parseQueryString(queryString);
+ }
+
+ path = decodeURI(path);
+
+ // DEBUG GROUP path
+
+ if (path.charAt(0) !== "/") { path = "/" + path; }
+
+ pathLen = path.length;
+ if (pathLen > 1 && path.charAt(pathLen - 1) === "/") {
+ path = path.substr(0, pathLen - 1);
+ isSlashDropped = true;
+ }
+
+ for (i=0, l=path.length; i= 0 && proceed; --i) {
+ var route = routes[i];
+ recognizer.add(routes, { as: route.handler });
+ proceed = route.path === '/' || route.path === '' || route.handler.slice(-6) === '.index';
+ }
+ });
+ },
+
+ hasRoute: function(route) {
+ return this.recognizer.hasRoute(route);
+ },
+
+ queryParamsTransition: function(changelist, wasTransitioning, oldState, newState) {
+ var router = this;
+
+ fireQueryParamDidChange(this, newState, changelist);
+
+ if (!wasTransitioning && this.activeTransition) {
+ // One of the handlers in queryParamsDidChange
+ // caused a transition. Just return that transition.
+ return this.activeTransition;
+ } else {
+ // Running queryParamsDidChange didn't change anything.
+ // Just update query params and be on our way.
+
+ // We have to return a noop transition that will
+ // perform a URL update at the end. This gives
+ // the user the ability to set the url update
+ // method (default is replaceState).
+ var newTransition = new Transition(this);
+ newTransition.queryParamsOnly = true;
+
+ oldState.queryParams = finalizeQueryParamChange(this, newState.handlerInfos, newState.queryParams, newTransition);
+
+ newTransition.promise = newTransition.promise.then(function(result) {
+ updateURL(newTransition, oldState, true);
+ if (router.didTransition) {
+ router.didTransition(router.currentHandlerInfos);
+ }
+ return result;
+ }, null, promiseLabel("Transition complete"));
+ return newTransition;
+ }
+ },
+
+ // NOTE: this doesn't really belong here, but here
+ // it shall remain until our ES6 transpiler can
+ // handle cyclical deps.
+ transitionByIntent: function(intent, isIntermediate) {
+ try {
+ return getTransitionByIntent.apply(this, arguments);
+ } catch(e) {
+ return new Transition(this, intent, null, e);
+ }
+ },
+
+ /**
+ Clears the current and target route handlers and triggers exit
+ on each of them starting at the leaf and traversing up through
+ its ancestors.
+ */
+ reset: function() {
+ if (this.state) {
+ forEach(this.state.handlerInfos.slice().reverse(), function(handlerInfo) {
+ var handler = handlerInfo.handler;
+ callHook(handler, 'exit');
+ });
+ }
+
+ this.state = new TransitionState();
+ this.currentHandlerInfos = null;
+ },
+
+ activeTransition: null,
+
+ /**
+ var handler = handlerInfo.handler;
+ The entry point for handling a change to the URL (usually
+ via the back and forward button).
+
+ Returns an Array of handlers and the parameters associated
+ with those parameters.
+
+ @param {String} url a URL to process
+
+ @return {Array} an Array of `[handler, parameter]` tuples
+ */
+ handleURL: function(url) {
+ // Perform a URL-based transition, but don't change
+ // the URL afterward, since it already happened.
+ var args = slice.call(arguments);
+ if (url.charAt(0) !== '/') { args[0] = '/' + url; }
+
+ return doTransition(this, args).method(null);
+ },
+
+ /**
+ Hook point for updating the URL.
+
+ @param {String} url a URL to update to
+ */
+ updateURL: function() {
+ throw new Error("updateURL is not implemented");
+ },
+
+ /**
+ Hook point for replacing the current URL, i.e. with replaceState
+
+ By default this behaves the same as `updateURL`
+
+ @param {String} url a URL to update to
+ */
+ replaceURL: function(url) {
+ this.updateURL(url);
+ },
+
+ /**
+ Transition into the specified named route.
+
+ If necessary, trigger the exit callback on any handlers
+ that are no longer represented by the target route.
+
+ @param {String} name the name of the route
+ */
+ transitionTo: function(name) {
+ return doTransition(this, arguments);
+ },
+
+ intermediateTransitionTo: function(name) {
+ return doTransition(this, arguments, true);
+ },
+
+ refresh: function(pivotHandler) {
+ var state = this.activeTransition ? this.activeTransition.state : this.state;
+ var handlerInfos = state.handlerInfos;
+ var params = {};
+ for (var i = 0, len = handlerInfos.length; i < len; ++i) {
+ var handlerInfo = handlerInfos[i];
+ params[handlerInfo.name] = handlerInfo.params || {};
+ }
+
+ log(this, "Starting a refresh transition");
+ var intent = new NamedTransitionIntent({
+ name: handlerInfos[handlerInfos.length - 1].name,
+ pivotHandler: pivotHandler || handlerInfos[0].handler,
+ contexts: [], // TODO collect contexts...?
+ queryParams: this._changedQueryParams || state.queryParams || {}
+ });
+
+ return this.transitionByIntent(intent, false);
+ },
+
+ /**
+ Identical to `transitionTo` except that the current URL will be replaced
+ if possible.
+
+ This method is intended primarily for use with `replaceState`.
+
+ @param {String} name the name of the route
+ */
+ replaceWith: function(name) {
+ return doTransition(this, arguments).method('replace');
+ },
+
+ /**
+ Take a named route and context objects and generate a
+ URL.
+
+ @param {String} name the name of the route to generate
+ a URL for
+ @param {...Object} objects a list of objects to serialize
+
+ @return {String} a URL
+ */
+ generate: function(handlerName) {
+
+ var partitionedArgs = extractQueryParams(slice.call(arguments, 1)),
+ suppliedParams = partitionedArgs[0],
+ queryParams = partitionedArgs[1];
+
+ // Construct a TransitionIntent with the provided params
+ // and apply it to the present state of the router.
+ var intent = new NamedTransitionIntent({ name: handlerName, contexts: suppliedParams });
+ var state = intent.applyToState(this.state, this.recognizer, this.getHandler);
+ var params = {};
+
+ for (var i = 0, len = state.handlerInfos.length; i < len; ++i) {
+ var handlerInfo = state.handlerInfos[i];
+ var handlerParams = handlerInfo.serialize();
+ merge(params, handlerParams);
+ }
+ params.queryParams = queryParams;
+
+ return this.recognizer.generate(handlerName, params);
+ },
+
+ applyIntent: function(handlerName, contexts) {
+ var intent = new NamedTransitionIntent({
+ name: handlerName,
+ contexts: contexts
+ });
+
+ var state = this.activeTransition && this.activeTransition.state || this.state;
+ return intent.applyToState(state, this.recognizer, this.getHandler);
+ },
+
+ isActiveIntent: function(handlerName, contexts, queryParams) {
+ var targetHandlerInfos = this.state.handlerInfos,
+ found = false, names, object, handlerInfo, handlerObj, i, len;
+
+ if (!targetHandlerInfos.length) { return false; }
+
+ var targetHandler = targetHandlerInfos[targetHandlerInfos.length - 1].name;
+ var recogHandlers = this.recognizer.handlersFor(targetHandler);
+
+ var index = 0;
+ for (len = recogHandlers.length; index < len; ++index) {
+ handlerInfo = targetHandlerInfos[index];
+ if (handlerInfo.name === handlerName) { break; }
+ }
+
+ if (index === recogHandlers.length) {
+ // The provided route name isn't even in the route hierarchy.
+ return false;
+ }
+
+ var state = new TransitionState();
+ state.handlerInfos = targetHandlerInfos.slice(0, index + 1);
+ recogHandlers = recogHandlers.slice(0, index + 1);
+
+ var intent = new NamedTransitionIntent({
+ name: targetHandler,
+ contexts: contexts
+ });
+
+ var newState = intent.applyToHandlers(state, recogHandlers, this.getHandler, targetHandler, true, true);
+
+ var handlersEqual = handlerInfosEqual(newState.handlerInfos, state.handlerInfos);
+ if (!queryParams || !handlersEqual) {
+ return handlersEqual;
+ }
+
+ // Get a hash of QPs that will still be active on new route
+ var activeQPsOnNewHandler = {};
+ merge(activeQPsOnNewHandler, queryParams);
+
+ var activeQueryParams = this.state.queryParams;
+ for (var key in activeQueryParams) {
+ if (activeQueryParams.hasOwnProperty(key) &&
+ activeQPsOnNewHandler.hasOwnProperty(key)) {
+ activeQPsOnNewHandler[key] = activeQueryParams[key];
+ }
+ }
+
+ return handlersEqual && !getChangelist(activeQPsOnNewHandler, queryParams);
+ },
+
+ isActive: function(handlerName) {
+ var partitionedArgs = extractQueryParams(slice.call(arguments, 1));
+ return this.isActiveIntent(handlerName, partitionedArgs[0], partitionedArgs[1]);
+ },
+
+ trigger: function(name) {
+ var args = slice.call(arguments);
+ trigger(this, this.currentHandlerInfos, false, args);
+ },
+
+ /**
+ Hook point for logging transition status updates.
+
+ @param {String} message The message to log.
+ */
+ log: null,
+
+ _willChangeContextEvent: 'willChangeContext',
+ _triggerWillChangeContext: function(handlerInfos, newTransition) {
+ trigger(this, handlerInfos, true, [this._willChangeContextEvent, newTransition]);
+ },
+
+ _triggerWillLeave: function(handlerInfos, newTransition, leavingChecker) {
+ trigger(this, handlerInfos, true, ['willLeave', newTransition, leavingChecker]);
+ }
+ };
+
+ /**
+ @private
+
+ Fires queryParamsDidChange event
+ */
+ function fireQueryParamDidChange(router, newState, queryParamChangelist) {
+ // If queryParams changed trigger event
+ if (queryParamChangelist) {
+
+ // This is a little hacky but we need some way of storing
+ // changed query params given that no activeTransition
+ // is guaranteed to have occurred.
+ router._changedQueryParams = queryParamChangelist.all;
+ trigger(router, newState.handlerInfos, true, ['queryParamsDidChange', queryParamChangelist.changed, queryParamChangelist.all, queryParamChangelist.removed]);
+ router._changedQueryParams = null;
+ }
+ }
+
+ /**
+ @private
+
+ Takes an Array of `HandlerInfo`s, figures out which ones are
+ exiting, entering, or changing contexts, and calls the
+ proper handler hooks.
+
+ For example, consider the following tree of handlers. Each handler is
+ followed by the URL segment it handles.
+
+ ```
+ |~index ("/")
+ | |~posts ("/posts")
+ | | |-showPost ("/:id")
+ | | |-newPost ("/new")
+ | | |-editPost ("/edit")
+ | |~about ("/about/:id")
+ ```
+
+ Consider the following transitions:
+
+ 1. A URL transition to `/posts/1`.
+ 1. Triggers the `*model` callbacks on the
+ `index`, `posts`, and `showPost` handlers
+ 2. Triggers the `enter` callback on the same
+ 3. Triggers the `setup` callback on the same
+ 2. A direct transition to `newPost`
+ 1. Triggers the `exit` callback on `showPost`
+ 2. Triggers the `enter` callback on `newPost`
+ 3. Triggers the `setup` callback on `newPost`
+ 3. A direct transition to `about` with a specified
+ context object
+ 1. Triggers the `exit` callback on `newPost`
+ and `posts`
+ 2. Triggers the `serialize` callback on `about`
+ 3. Triggers the `enter` callback on `about`
+ 4. Triggers the `setup` callback on `about`
+
+ @param {Router} transition
+ @param {TransitionState} newState
+ */
+ function setupContexts(router, newState, transition) {
+ var partition = partitionHandlers(router.state, newState);
+
+ forEach(partition.exited, function(handlerInfo) {
+ var handler = handlerInfo.handler;
+ delete handler.context;
+
+ callHook(handler, 'reset', true, transition);
+ callHook(handler, 'exit', transition);
+ });
+
+ var oldState = router.oldState = router.state;
+ router.state = newState;
+ var currentHandlerInfos = router.currentHandlerInfos = partition.unchanged.slice();
+
+ try {
+ forEach(partition.reset, function(handlerInfo) {
+ var handler = handlerInfo.handler;
+ callHook(handler, 'reset', false, transition);
+ });
+
+ forEach(partition.updatedContext, function(handlerInfo) {
+ return handlerEnteredOrUpdated(currentHandlerInfos, handlerInfo, false, transition);
+ });
+
+ forEach(partition.entered, function(handlerInfo) {
+ return handlerEnteredOrUpdated(currentHandlerInfos, handlerInfo, true, transition);
+ });
+ } catch(e) {
+ router.state = oldState;
+ router.currentHandlerInfos = oldState.handlerInfos;
+ throw e;
+ }
+
+ router.state.queryParams = finalizeQueryParamChange(router, currentHandlerInfos, newState.queryParams, transition);
+ }
+
+
+ /**
+ @private
+
+ Helper method used by setupContexts. Handles errors or redirects
+ that may happen in enter/setup.
+ */
+ function handlerEnteredOrUpdated(currentHandlerInfos, handlerInfo, enter, transition) {
+
+ var handler = handlerInfo.handler,
+ context = handlerInfo.context;
+
+ if (enter) {
+ callHook(handler, 'enter', transition);
+ }
+ if (transition && transition.isAborted) {
+ throw new TransitionAborted();
+ }
+
+ handler.context = context;
+ callHook(handler, 'contextDidChange');
+
+ callHook(handler, 'setup', context, transition);
+ if (transition && transition.isAborted) {
+ throw new TransitionAborted();
+ }
+
+ currentHandlerInfos.push(handlerInfo);
+
+ return true;
+ }
+
+
+ /**
+ @private
+
+ This function is called when transitioning from one URL to
+ another to determine which handlers are no longer active,
+ which handlers are newly active, and which handlers remain
+ active but have their context changed.
+
+ Take a list of old handlers and new handlers and partition
+ them into four buckets:
+
+ * unchanged: the handler was active in both the old and
+ new URL, and its context remains the same
+ * updated context: the handler was active in both the
+ old and new URL, but its context changed. The handler's
+ `setup` method, if any, will be called with the new
+ context.
+ * exited: the handler was active in the old URL, but is
+ no longer active.
+ * entered: the handler was not active in the old URL, but
+ is now active.
+
+ The PartitionedHandlers structure has four fields:
+
+ * `updatedContext`: a list of `HandlerInfo` objects that
+ represent handlers that remain active but have a changed
+ context
+ * `entered`: a list of `HandlerInfo` objects that represent
+ handlers that are newly active
+ * `exited`: a list of `HandlerInfo` objects that are no
+ longer active.
+ * `unchanged`: a list of `HanderInfo` objects that remain active.
+
+ @param {Array[HandlerInfo]} oldHandlers a list of the handler
+ information for the previous URL (or `[]` if this is the
+ first handled transition)
+ @param {Array[HandlerInfo]} newHandlers a list of the handler
+ information for the new URL
+
+ @return {Partition}
+ */
+ function partitionHandlers(oldState, newState) {
+ var oldHandlers = oldState.handlerInfos;
+ var newHandlers = newState.handlerInfos;
+
+ var handlers = {
+ updatedContext: [],
+ exited: [],
+ entered: [],
+ unchanged: []
+ };
+
+ var handlerChanged, contextChanged = false, i, l;
+
+ for (i=0, l=newHandlers.length; i= 0; --i) {
+ var handlerInfo = handlerInfos[i];
+ merge(params, handlerInfo.params);
+ if (handlerInfo.handler.inaccessibleByURL) {
+ urlMethod = null;
+ }
+ }
+
+ if (urlMethod) {
+ params.queryParams = transition._visibleQueryParams || state.queryParams;
+ var url = router.recognizer.generate(handlerName, params);
+
+ if (urlMethod === 'replace') {
+ router.replaceURL(url);
+ } else {
+ router.updateURL(url);
+ }
+ }
+ }
+
+ /**
+ @private
+
+ Updates the URL (if necessary) and calls `setupContexts`
+ to update the router's array of `currentHandlerInfos`.
+ */
+ function finalizeTransition(transition, newState) {
+
+ try {
+ log(transition.router, transition.sequence, "Resolved all models on destination route; finalizing transition.");
+
+ var router = transition.router,
+ handlerInfos = newState.handlerInfos,
+ seq = transition.sequence;
+
+ // Run all the necessary enter/setup/exit hooks
+ setupContexts(router, newState, transition);
+
+ // Check if a redirect occurred in enter/setup
+ if (transition.isAborted) {
+ // TODO: cleaner way? distinguish b/w targetHandlerInfos?
+ router.state.handlerInfos = router.currentHandlerInfos;
+ return Promise.reject(logAbort(transition));
+ }
+
+ updateURL(transition, newState, transition.intent.url);
+
+ transition.isActive = false;
+ router.activeTransition = null;
+
+ trigger(router, router.currentHandlerInfos, true, ['didTransition']);
+
+ if (router.didTransition) {
+ router.didTransition(router.currentHandlerInfos);
+ }
+
+ log(router, transition.sequence, "TRANSITION COMPLETE.");
+
+ // Resolve with the final handler.
+ return handlerInfos[handlerInfos.length - 1].handler;
+ } catch(e) {
+ if (!((e instanceof TransitionAborted))) {
+ //var erroneousHandler = handlerInfos.pop();
+ var infos = transition.state.handlerInfos;
+ transition.trigger(true, 'error', e, transition, infos[infos.length-1].handler);
+ transition.abort();
+ }
+
+ throw e;
+ }
+ }
+
+ /**
+ @private
+
+ Begins and returns a Transition based on the provided
+ arguments. Accepts arguments in the form of both URL
+ transitions and named transitions.
+
+ @param {Router} router
+ @param {Array[Object]} args arguments passed to transitionTo,
+ replaceWith, or handleURL
+ */
+ function doTransition(router, args, isIntermediate) {
+ // Normalize blank transitions to root URL transitions.
+ var name = args[0] || '/';
+
+ var lastArg = args[args.length-1];
+ var queryParams = {};
+ if (lastArg && lastArg.hasOwnProperty('queryParams')) {
+ queryParams = pop.call(args).queryParams;
+ }
+
+ var intent;
+ if (args.length === 0) {
+
+ log(router, "Updating query params");
+
+ // A query param update is really just a transition
+ // into the route you're already on.
+ var handlerInfos = router.state.handlerInfos;
+ intent = new NamedTransitionIntent({
+ name: handlerInfos[handlerInfos.length - 1].name,
+ contexts: [],
+ queryParams: queryParams
+ });
+
+ } else if (name.charAt(0) === '/') {
+
+ log(router, "Attempting URL transition to " + name);
+ intent = new URLTransitionIntent({ url: name });
+
+ } else {
+
+ log(router, "Attempting transition to " + name);
+ intent = new NamedTransitionIntent({
+ name: args[0],
+ contexts: slice.call(args, 1),
+ queryParams: queryParams
+ });
+ }
+
+ return router.transitionByIntent(intent, isIntermediate);
+ }
+
+ function handlerInfosEqual(handlerInfos, otherHandlerInfos) {
+ if (handlerInfos.length !== otherHandlerInfos.length) {
+ return false;
+ }
+
+ for (var i = 0, len = handlerInfos.length; i < len; ++i) {
+ if (handlerInfos[i] !== otherHandlerInfos[i]) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ function finalizeQueryParamChange(router, resolvedHandlers, newQueryParams, transition) {
+ // We fire a finalizeQueryParamChange event which
+ // gives the new route hierarchy a chance to tell
+ // us which query params it's consuming and what
+ // their final values are. If a query param is
+ // no longer consumed in the final route hierarchy,
+ // its serialized segment will be removed
+ // from the URL.
+
+ for (var k in newQueryParams) {
+ if (newQueryParams.hasOwnProperty(k) &&
+ newQueryParams[k] === null) {
+ delete newQueryParams[k];
+ }
+ }
+
+ var finalQueryParamsArray = [];
+ trigger(router, resolvedHandlers, true, ['finalizeQueryParamChange', newQueryParams, finalQueryParamsArray, transition]);
+
+ if (transition) {
+ transition._visibleQueryParams = {};
+ }
+
+ var finalQueryParams = {};
+ for (var i = 0, len = finalQueryParamsArray.length; i < len; ++i) {
+ var qp = finalQueryParamsArray[i];
+ finalQueryParams[qp.key] = qp.value;
+ if (transition && qp.visible !== false) {
+ transition._visibleQueryParams[qp.key] = qp.value;
+ }
+ }
+ return finalQueryParams;
+ }
+
+ function notifyExistingHandlers(router, newState, newTransition) {
+ var oldHandlers = router.state.handlerInfos,
+ changing = [],
+ leavingIndex = null,
+ leaving, leavingChecker, i, oldHandlerLen, oldHandler, newHandler;
+
+ oldHandlerLen = oldHandlers.length;
+ for (i = 0; i < oldHandlerLen; i++) {
+ oldHandler = oldHandlers[i];
+ newHandler = newState.handlerInfos[i];
+
+ if (!newHandler || oldHandler.name !== newHandler.name) {
+ leavingIndex = i;
+ break;
+ }
+
+ if (!newHandler.isResolved) {
+ changing.push(oldHandler);
+ }
+ }
+
+ if (leavingIndex !== null) {
+ leaving = oldHandlers.slice(leavingIndex, oldHandlerLen);
+ leavingChecker = function(name) {
+ for (var h = 0, len = leaving.length; h < len; h++) {
+ if (leaving[h].name === name) {
+ return true;
+ }
+ }
+ return false;
+ };
+
+ router._triggerWillLeave(leaving, newTransition, leavingChecker);
+ }
+
+ if (changing.length > 0) {
+ router._triggerWillChangeContext(changing, newTransition);
+ }
+
+ trigger(router, oldHandlers, true, ['willTransition', newTransition]);
+ }
+
+ __exports__["default"] = Router;
+ });
+enifed("router/transition-intent",
+ ["./utils","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var merge = __dependency1__.merge;
+
+ function TransitionIntent(props) {
+ this.initialize(props);
+
+ // TODO: wat
+ this.data = this.data || {};
+ }
+
+ TransitionIntent.prototype = {
+ initialize: null,
+ applyToState: null
+ };
+
+ __exports__["default"] = TransitionIntent;
+ });
+enifed("router/transition-intent/named-transition-intent",
+ ["../transition-intent","../transition-state","../handler-info/factory","../utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ var TransitionIntent = __dependency1__["default"];
+ var TransitionState = __dependency2__["default"];
+ var handlerInfoFactory = __dependency3__["default"];
+ var isParam = __dependency4__.isParam;
+ var extractQueryParams = __dependency4__.extractQueryParams;
+ var merge = __dependency4__.merge;
+ var subclass = __dependency4__.subclass;
+
+ __exports__["default"] = subclass(TransitionIntent, {
+ name: null,
+ pivotHandler: null,
+ contexts: null,
+ queryParams: null,
+
+ initialize: function(props) {
+ this.name = props.name;
+ this.pivotHandler = props.pivotHandler;
+ this.contexts = props.contexts || [];
+ this.queryParams = props.queryParams;
+ },
+
+ applyToState: function(oldState, recognizer, getHandler, isIntermediate) {
+
+ var partitionedArgs = extractQueryParams([this.name].concat(this.contexts)),
+ pureArgs = partitionedArgs[0],
+ queryParams = partitionedArgs[1],
+ handlers = recognizer.handlersFor(pureArgs[0]);
+
+ var targetRouteName = handlers[handlers.length-1].handler;
+
+ return this.applyToHandlers(oldState, handlers, getHandler, targetRouteName, isIntermediate);
+ },
+
+ applyToHandlers: function(oldState, handlers, getHandler, targetRouteName, isIntermediate, checkingIfActive) {
+
+ var i, len;
+ var newState = new TransitionState();
+ var objects = this.contexts.slice(0);
+
+ var invalidateIndex = handlers.length;
+
+ // Pivot handlers are provided for refresh transitions
+ if (this.pivotHandler) {
+ for (i = 0, len = handlers.length; i < len; ++i) {
+ if (getHandler(handlers[i].handler) === this.pivotHandler) {
+ invalidateIndex = i;
+ break;
+ }
+ }
+ }
+
+ var pivotHandlerFound = !this.pivotHandler;
+
+ for (i = handlers.length - 1; i >= 0; --i) {
+ var result = handlers[i];
+ var name = result.handler;
+ var handler = getHandler(name);
+
+ var oldHandlerInfo = oldState.handlerInfos[i];
+ var newHandlerInfo = null;
+
+ if (result.names.length > 0) {
+ if (i >= invalidateIndex) {
+ newHandlerInfo = this.createParamHandlerInfo(name, handler, result.names, objects, oldHandlerInfo);
+ } else {
+ newHandlerInfo = this.getHandlerInfoForDynamicSegment(name, handler, result.names, objects, oldHandlerInfo, targetRouteName, i);
+ }
+ } else {
+ // This route has no dynamic segment.
+ // Therefore treat as a param-based handlerInfo
+ // with empty params. This will cause the `model`
+ // hook to be called with empty params, which is desirable.
+ newHandlerInfo = this.createParamHandlerInfo(name, handler, result.names, objects, oldHandlerInfo);
+ }
+
+ if (checkingIfActive) {
+ // If we're performing an isActive check, we want to
+ // serialize URL params with the provided context, but
+ // ignore mismatches between old and new context.
+ newHandlerInfo = newHandlerInfo.becomeResolved(null, newHandlerInfo.context);
+ var oldContext = oldHandlerInfo && oldHandlerInfo.context;
+ if (result.names.length > 0 && newHandlerInfo.context === oldContext) {
+ // If contexts match in isActive test, assume params also match.
+ // This allows for flexibility in not requiring that every last
+ // handler provide a `serialize` method
+ newHandlerInfo.params = oldHandlerInfo && oldHandlerInfo.params;
+ }
+ newHandlerInfo.context = oldContext;
+ }
+
+ var handlerToUse = oldHandlerInfo;
+ if (i >= invalidateIndex || newHandlerInfo.shouldSupercede(oldHandlerInfo)) {
+ invalidateIndex = Math.min(i, invalidateIndex);
+ handlerToUse = newHandlerInfo;
+ }
+
+ if (isIntermediate && !checkingIfActive) {
+ handlerToUse = handlerToUse.becomeResolved(null, handlerToUse.context);
+ }
+
+ newState.handlerInfos.unshift(handlerToUse);
+ }
+
+ if (objects.length > 0) {
+ throw new Error("More context objects were passed than there are dynamic segments for the route: " + targetRouteName);
+ }
+
+ if (!isIntermediate) {
+ this.invalidateChildren(newState.handlerInfos, invalidateIndex);
+ }
+
+ merge(newState.queryParams, this.queryParams || {});
+
+ return newState;
+ },
+
+ invalidateChildren: function(handlerInfos, invalidateIndex) {
+ for (var i = invalidateIndex, l = handlerInfos.length; i < l; ++i) {
+ var handlerInfo = handlerInfos[i];
+ handlerInfos[i] = handlerInfos[i].getUnresolved();
+ }
+ },
+
+ getHandlerInfoForDynamicSegment: function(name, handler, names, objects, oldHandlerInfo, targetRouteName, i) {
+
+ var numNames = names.length;
+ var objectToUse;
+ if (objects.length > 0) {
+
+ // Use the objects provided for this transition.
+ objectToUse = objects[objects.length - 1];
+ if (isParam(objectToUse)) {
+ return this.createParamHandlerInfo(name, handler, names, objects, oldHandlerInfo);
+ } else {
+ objects.pop();
+ }
+ } else if (oldHandlerInfo && oldHandlerInfo.name === name) {
+ // Reuse the matching oldHandlerInfo
+ return oldHandlerInfo;
+ } else {
+ if (this.preTransitionState) {
+ var preTransitionHandlerInfo = this.preTransitionState.handlerInfos[i];
+ objectToUse = preTransitionHandlerInfo && preTransitionHandlerInfo.context;
+ } else {
+ // Ideally we should throw this error to provide maximal
+ // information to the user that not enough context objects
+ // were provided, but this proves too cumbersome in Ember
+ // in cases where inner template helpers are evaluated
+ // before parent helpers un-render, in which cases this
+ // error somewhat prematurely fires.
+ //throw new Error("Not enough context objects were provided to complete a transition to " + targetRouteName + ". Specifically, the " + name + " route needs an object that can be serialized into its dynamic URL segments [" + names.join(', ') + "]");
+ return oldHandlerInfo;
+ }
+ }
+
+ return handlerInfoFactory('object', {
+ name: name,
+ handler: handler,
+ context: objectToUse,
+ names: names
+ });
+ },
+
+ createParamHandlerInfo: function(name, handler, names, objects, oldHandlerInfo) {
+ var params = {};
+
+ // Soak up all the provided string/numbers
+ var numNames = names.length;
+ while (numNames--) {
+
+ // Only use old params if the names match with the new handler
+ var oldParams = (oldHandlerInfo && name === oldHandlerInfo.name && oldHandlerInfo.params) || {};
+
+ var peek = objects[objects.length - 1];
+ var paramName = names[numNames];
+ if (isParam(peek)) {
+ params[paramName] = "" + objects.pop();
+ } else {
+ // If we're here, this means only some of the params
+ // were string/number params, so try and use a param
+ // value from a previous handler.
+ if (oldParams.hasOwnProperty(paramName)) {
+ params[paramName] = oldParams[paramName];
+ } else {
+ throw new Error("You didn't provide enough string/numeric parameters to satisfy all of the dynamic segments for route " + name);
+ }
+ }
+ }
+
+ return handlerInfoFactory('param', {
+ name: name,
+ handler: handler,
+ params: params
+ });
+ }
+ });
+ });
+enifed("router/transition-intent/url-transition-intent",
+ ["../transition-intent","../transition-state","../handler-info/factory","../utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ var TransitionIntent = __dependency1__["default"];
+ var TransitionState = __dependency2__["default"];
+ var handlerInfoFactory = __dependency3__["default"];
+ var oCreate = __dependency4__.oCreate;
+ var merge = __dependency4__.merge;
+ var subclass = __dependency4__.subclass;
+
+ __exports__["default"] = subclass(TransitionIntent, {
+ url: null,
+
+ initialize: function(props) {
+ this.url = props.url;
+ },
+
+ applyToState: function(oldState, recognizer, getHandler) {
+ var newState = new TransitionState();
+
+ var results = recognizer.recognize(this.url),
+ queryParams = {},
+ i, len;
+
+ if (!results) {
+ throw new UnrecognizedURLError(this.url);
+ }
+
+ var statesDiffer = false;
+
+ for (i = 0, len = results.length; i < len; ++i) {
+ var result = results[i];
+ var name = result.handler;
+ var handler = getHandler(name);
+
+ if (handler.inaccessibleByURL) {
+ throw new UnrecognizedURLError(this.url);
+ }
+
+ var newHandlerInfo = handlerInfoFactory('param', {
+ name: name,
+ handler: handler,
+ params: result.params
+ });
+
+ var oldHandlerInfo = oldState.handlerInfos[i];
+ if (statesDiffer || newHandlerInfo.shouldSupercede(oldHandlerInfo)) {
+ statesDiffer = true;
+ newState.handlerInfos[i] = newHandlerInfo;
+ } else {
+ newState.handlerInfos[i] = oldHandlerInfo;
+ }
+ }
+
+ merge(newState.queryParams, results.queryParams);
+
+ return newState;
+ }
+ });
+
+ /**
+ Promise reject reasons passed to promise rejection
+ handlers for failed transitions.
+ */
+ function UnrecognizedURLError(message) {
+ this.message = (message || "UnrecognizedURLError");
+ this.name = "UnrecognizedURLError";
+ }
+ });
+enifed("router/transition-state",
+ ["./handler-info","./utils","rsvp/promise","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var ResolvedHandlerInfo = __dependency1__.ResolvedHandlerInfo;
+ var forEach = __dependency2__.forEach;
+ var promiseLabel = __dependency2__.promiseLabel;
+ var callHook = __dependency2__.callHook;
+ var Promise = __dependency3__["default"];
+
+ function TransitionState(other) {
+ this.handlerInfos = [];
+ this.queryParams = {};
+ this.params = {};
+ }
+
+ TransitionState.prototype = {
+ handlerInfos: null,
+ queryParams: null,
+ params: null,
+
+ promiseLabel: function(label) {
+ var targetName = '';
+ forEach(this.handlerInfos, function(handlerInfo) {
+ if (targetName !== '') {
+ targetName += '.';
+ }
+ targetName += handlerInfo.name;
+ });
+ return promiseLabel("'" + targetName + "': " + label);
+ },
+
+ resolve: function(shouldContinue, payload) {
+ var self = this;
+ // First, calculate params for this state. This is useful
+ // information to provide to the various route hooks.
+ var params = this.params;
+ forEach(this.handlerInfos, function(handlerInfo) {
+ params[handlerInfo.name] = handlerInfo.params || {};
+ });
+
+ payload = payload || {};
+ payload.resolveIndex = 0;
+
+ var currentState = this;
+ var wasAborted = false;
+
+ // The prelude RSVP.resolve() asyncs us into the promise land.
+ return Promise.resolve(null, this.promiseLabel("Start transition"))
+ .then(resolveOneHandlerInfo, null, this.promiseLabel('Resolve handler'))['catch'](handleError, this.promiseLabel('Handle error'));
+
+ function innerShouldContinue() {
+ return Promise.resolve(shouldContinue(), currentState.promiseLabel("Check if should continue"))['catch'](function(reason) {
+ // We distinguish between errors that occurred
+ // during resolution (e.g. beforeModel/model/afterModel),
+ // and aborts due to a rejecting promise from shouldContinue().
+ wasAborted = true;
+ return Promise.reject(reason);
+ }, currentState.promiseLabel("Handle abort"));
+ }
+
+ function handleError(error) {
+ // This is the only possible
+ // reject value of TransitionState#resolve
+ var handlerInfos = currentState.handlerInfos;
+ var errorHandlerIndex = payload.resolveIndex >= handlerInfos.length ?
+ handlerInfos.length - 1 : payload.resolveIndex;
+ return Promise.reject({
+ error: error,
+ handlerWithError: currentState.handlerInfos[errorHandlerIndex].handler,
+ wasAborted: wasAborted,
+ state: currentState
+ });
+ }
+
+ function proceed(resolvedHandlerInfo) {
+ var wasAlreadyResolved = currentState.handlerInfos[payload.resolveIndex].isResolved;
+
+ // Swap the previously unresolved handlerInfo with
+ // the resolved handlerInfo
+ currentState.handlerInfos[payload.resolveIndex++] = resolvedHandlerInfo;
+
+ if (!wasAlreadyResolved) {
+ // Call the redirect hook. The reason we call it here
+ // vs. afterModel is so that redirects into child
+ // routes don't re-run the model hooks for this
+ // already-resolved route.
+ var handler = resolvedHandlerInfo.handler;
+ callHook(handler, 'redirect', resolvedHandlerInfo.context, payload);
+ }
+
+ // Proceed after ensuring that the redirect hook
+ // didn't abort this transition by transitioning elsewhere.
+ return innerShouldContinue().then(resolveOneHandlerInfo, null, currentState.promiseLabel('Resolve handler'));
+ }
+
+ function resolveOneHandlerInfo() {
+ if (payload.resolveIndex === currentState.handlerInfos.length) {
+ // This is is the only possible
+ // fulfill value of TransitionState#resolve
+ return {
+ error: null,
+ state: currentState
+ };
+ }
+
+ var handlerInfo = currentState.handlerInfos[payload.resolveIndex];
+
+ return handlerInfo.resolve(innerShouldContinue, payload)
+ .then(proceed, null, currentState.promiseLabel('Proceed'));
+ }
+ }
+ };
+
+ __exports__["default"] = TransitionState;
+ });
+enifed("router/transition",
+ ["rsvp/promise","./handler-info","./utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var Promise = __dependency1__["default"];
+ var ResolvedHandlerInfo = __dependency2__.ResolvedHandlerInfo;
+ var trigger = __dependency3__.trigger;
+ var slice = __dependency3__.slice;
+ var log = __dependency3__.log;
+ var promiseLabel = __dependency3__.promiseLabel;
+
+ /**
+ @private
+
+ A Transition is a thennable (a promise-like object) that represents
+ an attempt to transition to another route. It can be aborted, either
+ explicitly via `abort` or by attempting another transition while a
+ previous one is still underway. An aborted transition can also
+ be `retry()`d later.
+ */
+ function Transition(router, intent, state, error) {
+ var transition = this;
+ this.state = state || router.state;
+ this.intent = intent;
+ this.router = router;
+ this.data = this.intent && this.intent.data || {};
+ this.resolvedModels = {};
+ this.queryParams = {};
+
+ if (error) {
+ this.promise = Promise.reject(error);
+ this.error = error;
+ return;
+ }
+
+ if (state) {
+ this.params = state.params;
+ this.queryParams = state.queryParams;
+ this.handlerInfos = state.handlerInfos;
+
+ var len = state.handlerInfos.length;
+ if (len) {
+ this.targetName = state.handlerInfos[len-1].name;
+ }
+
+ for (var i = 0; i < len; ++i) {
+ var handlerInfo = state.handlerInfos[i];
+
+ // TODO: this all seems hacky
+ if (!handlerInfo.isResolved) { break; }
+ this.pivotHandler = handlerInfo.handler;
+ }
+
+ this.sequence = Transition.currentSequence++;
+ this.promise = state.resolve(checkForAbort, this)['catch'](function(result) {
+ if (result.wasAborted || transition.isAborted) {
+ return Promise.reject(logAbort(transition));
+ } else {
+ transition.trigger('error', result.error, transition, result.handlerWithError);
+ transition.abort();
+ return Promise.reject(result.error);
+ }
+ }, promiseLabel('Handle Abort'));
+ } else {
+ this.promise = Promise.resolve(this.state);
+ this.params = {};
+ }
+
+ function checkForAbort() {
+ if (transition.isAborted) {
+ return Promise.reject(undefined, promiseLabel("Transition aborted - reject"));
+ }
+ }
+ }
+
+ Transition.currentSequence = 0;
+
+ Transition.prototype = {
+ targetName: null,
+ urlMethod: 'update',
+ intent: null,
+ params: null,
+ pivotHandler: null,
+ resolveIndex: 0,
+ handlerInfos: null,
+ resolvedModels: null,
+ isActive: true,
+ state: null,
+ queryParamsOnly: false,
+
+ isTransition: true,
+
+ isExiting: function(handler) {
+ var handlerInfos = this.handlerInfos;
+ for (var i = 0, len = handlerInfos.length; i < len; ++i) {
+ var handlerInfo = handlerInfos[i];
+ if (handlerInfo.name === handler || handlerInfo.handler === handler) {
+ return false;
+ }
+ }
+ return true;
+ },
+
+ /**
+ @public
+
+ The Transition's internal promise. Calling `.then` on this property
+ is that same as calling `.then` on the Transition object itself, but
+ this property is exposed for when you want to pass around a
+ Transition's promise, but not the Transition object itself, since
+ Transition object can be externally `abort`ed, while the promise
+ cannot.
+ */
+ promise: null,
+
+ /**
+ @public
+
+ Custom state can be stored on a Transition's `data` object.
+ This can be useful for decorating a Transition within an earlier
+ hook and shared with a later hook. Properties set on `data` will
+ be copied to new transitions generated by calling `retry` on this
+ transition.
+ */
+ data: null,
+
+ /**
+ @public
+
+ A standard promise hook that resolves if the transition
+ succeeds and rejects if it fails/redirects/aborts.
+
+ Forwards to the internal `promise` property which you can
+ use in situations where you want to pass around a thennable,
+ but not the Transition itself.
+
+ @param {Function} onFulfilled
+ @param {Function} onRejected
+ @param {String} label optional string for labeling the promise.
+ Useful for tooling.
+ @return {Promise}
+ */
+ then: function(onFulfilled, onRejected, label) {
+ return this.promise.then(onFulfilled, onRejected, label);
+ },
+
+ /**
+ @public
+
+ Forwards to the internal `promise` property which you can
+ use in situations where you want to pass around a thennable,
+ but not the Transition itself.
+
+ @method catch
+ @param {Function} onRejection
+ @param {String} label optional string for labeling the promise.
+ Useful for tooling.
+ @return {Promise}
+ */
+ "catch": function(onRejection, label) {
+ return this.promise["catch"](onRejection, label);
+ },
+
+ /**
+ @public
+
+ Forwards to the internal `promise` property which you can
+ use in situations where you want to pass around a thennable,
+ but not the Transition itself.
+
+ @method finally
+ @param {Function} callback
+ @param {String} label optional string for labeling the promise.
+ Useful for tooling.
+ @return {Promise}
+ */
+ "finally": function(callback, label) {
+ return this.promise["finally"](callback, label);
+ },
+
+ /**
+ @public
+
+ Aborts the Transition. Note you can also implicitly abort a transition
+ by initiating another transition while a previous one is underway.
+ */
+ abort: function() {
+ if (this.isAborted) { return this; }
+ log(this.router, this.sequence, this.targetName + ": transition was aborted");
+ this.intent.preTransitionState = this.router.state;
+ this.isAborted = true;
+ this.isActive = false;
+ this.router.activeTransition = null;
+ return this;
+ },
+
+ /**
+ @public
+
+ Retries a previously-aborted transition (making sure to abort the
+ transition if it's still active). Returns a new transition that
+ represents the new attempt to transition.
+ */
+ retry: function() {
+ // TODO: add tests for merged state retry()s
+ this.abort();
+ return this.router.transitionByIntent(this.intent, false);
+ },
+
+ /**
+ @public
+
+ Sets the URL-changing method to be employed at the end of a
+ successful transition. By default, a new Transition will just
+ use `updateURL`, but passing 'replace' to this method will
+ cause the URL to update using 'replaceWith' instead. Omitting
+ a parameter will disable the URL change, allowing for transitions
+ that don't update the URL at completion (this is also used for
+ handleURL, since the URL has already changed before the
+ transition took place).
+
+ @param {String} method the type of URL-changing method to use
+ at the end of a transition. Accepted values are 'replace',
+ falsy values, or any other non-falsy value (which is
+ interpreted as an updateURL transition).
+
+ @return {Transition} this transition
+ */
+ method: function(method) {
+ this.urlMethod = method;
+ return this;
+ },
+
+ /**
+ @public
+
+ Fires an event on the current list of resolved/resolving
+ handlers within this transition. Useful for firing events
+ on route hierarchies that haven't fully been entered yet.
+
+ Note: This method is also aliased as `send`
+
+ @param {Boolean} [ignoreFailure=false] a boolean specifying whether unhandled events throw an error
+ @param {String} name the name of the event to fire
+ */
+ trigger: function (ignoreFailure) {
+ var args = slice.call(arguments);
+ if (typeof ignoreFailure === 'boolean') {
+ args.shift();
+ } else {
+ // Throw errors on unhandled trigger events by default
+ ignoreFailure = false;
+ }
+ trigger(this.router, this.state.handlerInfos.slice(0, this.resolveIndex + 1), ignoreFailure, args);
+ },
+
+ /**
+ @public
+
+ Transitions are aborted and their promises rejected
+ when redirects occur; this method returns a promise
+ that will follow any redirects that occur and fulfill
+ with the value fulfilled by any redirecting transitions
+ that occur.
+
+ @return {Promise} a promise that fulfills with the same
+ value that the final redirecting transition fulfills with
+ */
+ followRedirects: function() {
+ var router = this.router;
+ return this.promise['catch'](function(reason) {
+ if (router.activeTransition) {
+ return router.activeTransition.followRedirects();
+ }
+ return Promise.reject(reason);
+ });
+ },
+
+ toString: function() {
+ return "Transition (sequence " + this.sequence + ")";
+ },
+
+ /**
+ @private
+ */
+ log: function(message) {
+ log(this.router, this.sequence, message);
+ }
+ };
+
+ // Alias 'trigger' as 'send'
+ Transition.prototype.send = Transition.prototype.trigger;
+
+ /**
+ @private
+
+ Logs and returns a TransitionAborted error.
+ */
+ function logAbort(transition) {
+ log(transition.router, transition.sequence, "detected abort.");
+ return new TransitionAborted();
+ }
+
+ function TransitionAborted(message) {
+ this.message = (message || "TransitionAborted");
+ this.name = "TransitionAborted";
+ }
+
+ __exports__.Transition = Transition;
+ __exports__.logAbort = logAbort;
+ __exports__.TransitionAborted = TransitionAborted;
+ });
+enifed("router/utils",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ var slice = Array.prototype.slice;
+
+ var _isArray;
+ if (!Array.isArray) {
+ _isArray = function (x) {
+ return Object.prototype.toString.call(x) === "[object Array]";
+ };
+ } else {
+ _isArray = Array.isArray;
+ }
+
+ var isArray = _isArray;
+ __exports__.isArray = isArray;
+ function merge(hash, other) {
+ for (var prop in other) {
+ if (other.hasOwnProperty(prop)) { hash[prop] = other[prop]; }
+ }
+ }
+
+ var oCreate = Object.create || function(proto) {
+ function F() {}
+ F.prototype = proto;
+ return new F();
+ };
+ __exports__.oCreate = oCreate;
+ /**
+ @private
+
+ Extracts query params from the end of an array
+ **/
+ function extractQueryParams(array) {
+ var len = (array && array.length), head, queryParams;
+
+ if(len && len > 0 && array[len - 1] && array[len - 1].hasOwnProperty('queryParams')) {
+ queryParams = array[len - 1].queryParams;
+ head = slice.call(array, 0, len - 1);
+ return [head, queryParams];
+ } else {
+ return [array, null];
+ }
+ }
+
+ __exports__.extractQueryParams = extractQueryParams;/**
+ @private
+
+ Coerces query param properties and array elements into strings.
+ **/
+ function coerceQueryParamsToString(queryParams) {
+ for (var key in queryParams) {
+ if (typeof queryParams[key] === 'number') {
+ queryParams[key] = '' + queryParams[key];
+ } else if (isArray(queryParams[key])) {
+ for (var i = 0, l = queryParams[key].length; i < l; i++) {
+ queryParams[key][i] = '' + queryParams[key][i];
+ }
+ }
+ }
+ }
+ /**
+ @private
+ */
+ function log(router, sequence, msg) {
+ if (!router.log) { return; }
+
+ if (arguments.length === 3) {
+ router.log("Transition #" + sequence + ": " + msg);
+ } else {
+ msg = sequence;
+ router.log(msg);
+ }
+ }
+
+ __exports__.log = log;function bind(context, fn) {
+ var boundArgs = arguments;
+ return function(value) {
+ var args = slice.call(boundArgs, 2);
+ args.push(value);
+ return fn.apply(context, args);
+ };
+ }
+
+ __exports__.bind = bind;function isParam(object) {
+ return (typeof object === "string" || object instanceof String || typeof object === "number" || object instanceof Number);
+ }
+
+
+ function forEach(array, callback) {
+ for (var i=0, l=array.length; i=0; i--) {
+ var handlerInfo = handlerInfos[i],
+ handler = handlerInfo.handler;
+
+ if (handler.events && handler.events[name]) {
+ if (handler.events[name].apply(handler, args) === true) {
+ eventWasHandled = true;
+ } else {
+ return;
+ }
+ }
+ }
+
+ if (!eventWasHandled && !ignoreFailure) {
+ throw new Error("Nothing handled the event '" + name + "'.");
+ }
+ }
+
+ __exports__.trigger = trigger;function getChangelist(oldObject, newObject) {
+ var key;
+ var results = {
+ all: {},
+ changed: {},
+ removed: {}
+ };
+
+ merge(results.all, newObject);
+
+ var didChange = false;
+ coerceQueryParamsToString(oldObject);
+ coerceQueryParamsToString(newObject);
+
+ // Calculate removals
+ for (key in oldObject) {
+ if (oldObject.hasOwnProperty(key)) {
+ if (!newObject.hasOwnProperty(key)) {
+ didChange = true;
+ results.removed[key] = oldObject[key];
+ }
+ }
+ }
+
+ // Calculate changes
+ for (key in newObject) {
+ if (newObject.hasOwnProperty(key)) {
+ if (isArray(oldObject[key]) && isArray(newObject[key])) {
+ if (oldObject[key].length !== newObject[key].length) {
+ results.changed[key] = newObject[key];
+ didChange = true;
+ } else {
+ for (var i = 0, l = oldObject[key].length; i < l; i++) {
+ if (oldObject[key][i] !== newObject[key][i]) {
+ results.changed[key] = newObject[key];
+ didChange = true;
+ }
+ }
+ }
+ }
+ else {
+ if (oldObject[key] !== newObject[key]) {
+ results.changed[key] = newObject[key];
+ didChange = true;
+ }
+ }
+ }
+ }
+
+ return didChange && results;
+ }
+
+ __exports__.getChangelist = getChangelist;function promiseLabel(label) {
+ return 'Router: ' + label;
+ }
+
+ __exports__.promiseLabel = promiseLabel;function subclass(parentConstructor, proto) {
+ function C(props) {
+ parentConstructor.call(this, props || {});
+ }
+ C.prototype = oCreate(parentConstructor.prototype);
+ merge(C.prototype, proto);
+ return C;
+ }
+
+ __exports__.subclass = subclass;function resolveHook(obj, hookName) {
+ if (!obj) { return; }
+ var underscored = "_" + hookName;
+ return obj[underscored] && underscored ||
+ obj[hookName] && hookName;
+ }
+
+ function callHook(obj, hookName) {
+ var args = slice.call(arguments, 2);
+ return applyHook(obj, hookName, args);
+ }
+
+ function applyHook(obj, _hookName, args) {
+ var hookName = resolveHook(obj, _hookName);
+ if (hookName) {
+ return obj[hookName].apply(obj, args);
+ }
+ }
+
+ __exports__.merge = merge;
+ __exports__.slice = slice;
+ __exports__.isParam = isParam;
+ __exports__.coerceQueryParamsToString = coerceQueryParamsToString;
+ __exports__.callHook = callHook;
+ __exports__.resolveHook = resolveHook;
+ __exports__.applyHook = applyHook;
+ });
+enifed("rsvp",
+ ["./rsvp/promise","./rsvp/events","./rsvp/node","./rsvp/all","./rsvp/all-settled","./rsvp/race","./rsvp/hash","./rsvp/hash-settled","./rsvp/rethrow","./rsvp/defer","./rsvp/config","./rsvp/map","./rsvp/resolve","./rsvp/reject","./rsvp/filter","./rsvp/asap","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __exports__) {
+ "use strict";
+ var Promise = __dependency1__["default"];
+ var EventTarget = __dependency2__["default"];
+ var denodeify = __dependency3__["default"];
+ var all = __dependency4__["default"];
+ var allSettled = __dependency5__["default"];
+ var race = __dependency6__["default"];
+ var hash = __dependency7__["default"];
+ var hashSettled = __dependency8__["default"];
+ var rethrow = __dependency9__["default"];
+ var defer = __dependency10__["default"];
+ var config = __dependency11__.config;
+ var configure = __dependency11__.configure;
+ var map = __dependency12__["default"];
+ var resolve = __dependency13__["default"];
+ var reject = __dependency14__["default"];
+ var filter = __dependency15__["default"];
+ var asap = __dependency16__["default"];
+
+ config.async = asap; // default async is asap;
+ var cast = resolve;
+ function async(callback, arg) {
+ config.async(callback, arg);
+ }
+
+ function on() {
+ config.on.apply(config, arguments);
+ }
+
+ function off() {
+ config.off.apply(config, arguments);
+ }
+
+ // Set up instrumentation through `window.__PROMISE_INTRUMENTATION__`
+ if (typeof window !== 'undefined' && typeof window['__PROMISE_INSTRUMENTATION__'] === 'object') {
+ var callbacks = window['__PROMISE_INSTRUMENTATION__'];
+ configure('instrument', true);
+ for (var eventName in callbacks) {
+ if (callbacks.hasOwnProperty(eventName)) {
+ on(eventName, callbacks[eventName]);
+ }
+ }
+ }
+
+ __exports__.cast = cast;
+ __exports__.Promise = Promise;
+ __exports__.EventTarget = EventTarget;
+ __exports__.all = all;
+ __exports__.allSettled = allSettled;
+ __exports__.race = race;
+ __exports__.hash = hash;
+ __exports__.hashSettled = hashSettled;
+ __exports__.rethrow = rethrow;
+ __exports__.defer = defer;
+ __exports__.denodeify = denodeify;
+ __exports__.configure = configure;
+ __exports__.on = on;
+ __exports__.off = off;
+ __exports__.resolve = resolve;
+ __exports__.reject = reject;
+ __exports__.async = async;
+ __exports__.map = map;
+ __exports__.filter = filter;
+ });
+enifed("rsvp.umd",
+ ["./rsvp"],
+ function(__dependency1__) {
+ "use strict";
+ var Promise = __dependency1__.Promise;
+ var allSettled = __dependency1__.allSettled;
+ var hash = __dependency1__.hash;
+ var hashSettled = __dependency1__.hashSettled;
+ var denodeify = __dependency1__.denodeify;
+ var on = __dependency1__.on;
+ var off = __dependency1__.off;
+ var map = __dependency1__.map;
+ var filter = __dependency1__.filter;
+ var resolve = __dependency1__.resolve;
+ var reject = __dependency1__.reject;
+ var rethrow = __dependency1__.rethrow;
+ var all = __dependency1__.all;
+ var defer = __dependency1__.defer;
+ var EventTarget = __dependency1__.EventTarget;
+ var configure = __dependency1__.configure;
+ var race = __dependency1__.race;
+ var async = __dependency1__.async;
+
+ var RSVP = {
+ 'race': race,
+ 'Promise': Promise,
+ 'allSettled': allSettled,
+ 'hash': hash,
+ 'hashSettled': hashSettled,
+ 'denodeify': denodeify,
+ 'on': on,
+ 'off': off,
+ 'map': map,
+ 'filter': filter,
+ 'resolve': resolve,
+ 'reject': reject,
+ 'all': all,
+ 'rethrow': rethrow,
+ 'defer': defer,
+ 'EventTarget': EventTarget,
+ 'configure': configure,
+ 'async': async
+ };
+
+ /* global define:true module:true window: true */
+ if (typeof enifed === 'function' && enifed['amd']) {
+ enifed(function() { return RSVP; });
+ } else if (typeof module !== 'undefined' && module['exports']) {
+ module['exports'] = RSVP;
+ } else if (typeof this !== 'undefined') {
+ this['RSVP'] = RSVP;
+ }
+ });
+enifed("rsvp/-internal",
+ ["./utils","./instrument","./config","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var objectOrFunction = __dependency1__.objectOrFunction;
+ var isFunction = __dependency1__.isFunction;
+
+ var instrument = __dependency2__["default"];
+
+ var config = __dependency3__.config;
+
+ function withOwnPromise() {
+ return new TypeError('A promises callback cannot return that same promise.');
+ }
+
+ function noop() {}
+
+ var PENDING = void 0;
+ var FULFILLED = 1;
+ var REJECTED = 2;
+
+ var GET_THEN_ERROR = new ErrorObject();
+
+ function getThen(promise) {
+ try {
+ return promise.then;
+ } catch(error) {
+ GET_THEN_ERROR.error = error;
+ return GET_THEN_ERROR;
+ }
+ }
+
+ function tryThen(then, value, fulfillmentHandler, rejectionHandler) {
+ try {
+ then.call(value, fulfillmentHandler, rejectionHandler);
+ } catch(e) {
+ return e;
+ }
+ }
+
+ function handleForeignThenable(promise, thenable, then) {
+ config.async(function(promise) {
+ var sealed = false;
+ var error = tryThen(then, thenable, function(value) {
+ if (sealed) { return; }
+ sealed = true;
+ if (thenable !== value) {
+ resolve(promise, value);
+ } else {
+ fulfill(promise, value);
+ }
+ }, function(reason) {
+ if (sealed) { return; }
+ sealed = true;
+
+ reject(promise, reason);
+ }, 'Settle: ' + (promise._label || ' unknown promise'));
+
+ if (!sealed && error) {
+ sealed = true;
+ reject(promise, error);
+ }
+ }, promise);
+ }
+
+ function handleOwnThenable(promise, thenable) {
+ if (thenable._state === FULFILLED) {
+ fulfill(promise, thenable._result);
+ } else if (promise._state === REJECTED) {
+ reject(promise, thenable._result);
+ } else {
+ subscribe(thenable, undefined, function(value) {
+ if (thenable !== value) {
+ resolve(promise, value);
+ } else {
+ fulfill(promise, value);
+ }
+ }, function(reason) {
+ reject(promise, reason);
+ });
+ }
+ }
+
+ function handleMaybeThenable(promise, maybeThenable) {
+ if (maybeThenable.constructor === promise.constructor) {
+ handleOwnThenable(promise, maybeThenable);
+ } else {
+ var then = getThen(maybeThenable);
+
+ if (then === GET_THEN_ERROR) {
+ reject(promise, GET_THEN_ERROR.error);
+ } else if (then === undefined) {
+ fulfill(promise, maybeThenable);
+ } else if (isFunction(then)) {
+ handleForeignThenable(promise, maybeThenable, then);
+ } else {
+ fulfill(promise, maybeThenable);
+ }
+ }
+ }
+
+ function resolve(promise, value) {
+ if (promise === value) {
+ fulfill(promise, value);
+ } else if (objectOrFunction(value)) {
+ handleMaybeThenable(promise, value);
+ } else {
+ fulfill(promise, value);
+ }
+ }
+
+ function publishRejection(promise) {
+ if (promise._onerror) {
+ promise._onerror(promise._result);
+ }
+
+ publish(promise);
+ }
+
+ function fulfill(promise, value) {
+ if (promise._state !== PENDING) { return; }
+
+ promise._result = value;
+ promise._state = FULFILLED;
+
+ if (promise._subscribers.length === 0) {
+ if (config.instrument) {
+ instrument('fulfilled', promise);
+ }
+ } else {
+ config.async(publish, promise);
+ }
+ }
+
+ function reject(promise, reason) {
+ if (promise._state !== PENDING) { return; }
+ promise._state = REJECTED;
+ promise._result = reason;
+
+ config.async(publishRejection, promise);
+ }
+
+ function subscribe(parent, child, onFulfillment, onRejection) {
+ var subscribers = parent._subscribers;
+ var length = subscribers.length;
+
+ parent._onerror = null;
+
+ subscribers[length] = child;
+ subscribers[length + FULFILLED] = onFulfillment;
+ subscribers[length + REJECTED] = onRejection;
+
+ if (length === 0 && parent._state) {
+ config.async(publish, parent);
+ }
+ }
+
+ function publish(promise) {
+ var subscribers = promise._subscribers;
+ var settled = promise._state;
+
+ if (config.instrument) {
+ instrument(settled === FULFILLED ? 'fulfilled' : 'rejected', promise);
+ }
+
+ if (subscribers.length === 0) { return; }
+
+ var child, callback, detail = promise._result;
+
+ for (var i = 0; i < subscribers.length; i += 3) {
+ child = subscribers[i];
+ callback = subscribers[i + settled];
+
+ if (child) {
+ invokeCallback(settled, child, callback, detail);
+ } else {
+ callback(detail);
+ }
+ }
+
+ promise._subscribers.length = 0;
+ }
+
+ function ErrorObject() {
+ this.error = null;
+ }
+
+ var TRY_CATCH_ERROR = new ErrorObject();
+
+ function tryCatch(callback, detail) {
+ try {
+ return callback(detail);
+ } catch(e) {
+ TRY_CATCH_ERROR.error = e;
+ return TRY_CATCH_ERROR;
+ }
+ }
+
+ function invokeCallback(settled, promise, callback, detail) {
+ var hasCallback = isFunction(callback),
+ value, error, succeeded, failed;
+
+ if (hasCallback) {
+ value = tryCatch(callback, detail);
+
+ if (value === TRY_CATCH_ERROR) {
+ failed = true;
+ error = value.error;
+ value = null;
+ } else {
+ succeeded = true;
+ }
+
+ if (promise === value) {
+ reject(promise, withOwnPromise());
+ return;
+ }
+
+ } else {
+ value = detail;
+ succeeded = true;
+ }
+
+ if (promise._state !== PENDING) {
+ // noop
+ } else if (hasCallback && succeeded) {
+ resolve(promise, value);
+ } else if (failed) {
+ reject(promise, error);
+ } else if (settled === FULFILLED) {
+ fulfill(promise, value);
+ } else if (settled === REJECTED) {
+ reject(promise, value);
+ }
+ }
+
+ function initializePromise(promise, resolver) {
+ try {
+ resolver(function resolvePromise(value){
+ resolve(promise, value);
+ }, function rejectPromise(reason) {
+ reject(promise, reason);
+ });
+ } catch(e) {
+ reject(promise, e);
+ }
+ }
+
+ __exports__.noop = noop;
+ __exports__.resolve = resolve;
+ __exports__.reject = reject;
+ __exports__.fulfill = fulfill;
+ __exports__.subscribe = subscribe;
+ __exports__.publish = publish;
+ __exports__.publishRejection = publishRejection;
+ __exports__.initializePromise = initializePromise;
+ __exports__.invokeCallback = invokeCallback;
+ __exports__.FULFILLED = FULFILLED;
+ __exports__.REJECTED = REJECTED;
+ __exports__.PENDING = PENDING;
+ });
+enifed("rsvp/all-settled",
+ ["./enumerator","./promise","./utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var Enumerator = __dependency1__["default"];
+ var makeSettledResult = __dependency1__.makeSettledResult;
+ var Promise = __dependency2__["default"];
+ var o_create = __dependency3__.o_create;
+
+ function AllSettled(Constructor, entries, label) {
+ this._superConstructor(Constructor, entries, false /* don't abort on reject */, label);
+ }
+
+ AllSettled.prototype = o_create(Enumerator.prototype);
+ AllSettled.prototype._superConstructor = Enumerator;
+ AllSettled.prototype._makeResult = makeSettledResult;
+ AllSettled.prototype._validationError = function() {
+ return new Error('allSettled must be called with an array');
+ };
+
+ /**
+ `RSVP.allSettled` is similar to `RSVP.all`, but instead of implementing
+ a fail-fast method, it waits until all the promises have returned and
+ shows you all the results. This is useful if you want to handle multiple
+ promises' failure states together as a set.
+
+ Returns a promise that is fulfilled when all the given promises have been
+ settled. The return promise is fulfilled with an array of the states of
+ the promises passed into the `promises` array argument.
+
+ Each state object will either indicate fulfillment or rejection, and
+ provide the corresponding value or reason. The states will take one of
+ the following formats:
+
+ ```javascript
+ { state: 'fulfilled', value: value }
+ or
+ { state: 'rejected', reason: reason }
+ ```
+
+ Example:
+
+ ```javascript
+ var promise1 = RSVP.Promise.resolve(1);
+ var promise2 = RSVP.Promise.reject(new Error('2'));
+ var promise3 = RSVP.Promise.reject(new Error('3'));
+ var promises = [ promise1, promise2, promise3 ];
+
+ RSVP.allSettled(promises).then(function(array){
+ // array == [
+ // { state: 'fulfilled', value: 1 },
+ // { state: 'rejected', reason: Error },
+ // { state: 'rejected', reason: Error }
+ // ]
+ // Note that for the second item, reason.message will be '2', and for the
+ // third item, reason.message will be '3'.
+ }, function(error) {
+ // Not run. (This block would only be called if allSettled had failed,
+ // for instance if passed an incorrect argument type.)
+ });
+ ```
+
+ @method allSettled
+ @static
+ @for RSVP
+ @param {Array} promises
+ @param {String} label - optional string that describes the promise.
+ Useful for tooling.
+ @return {Promise} promise that is fulfilled with an array of the settled
+ states of the constituent promises.
+ */
+
+ __exports__["default"] = function allSettled(entries, label) {
+ return new AllSettled(Promise, entries, label).promise;
+ }
+ });
+enifed("rsvp/all",
+ ["./promise","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var Promise = __dependency1__["default"];
+
+ /**
+ This is a convenient alias for `RSVP.Promise.all`.
+
+ @method all
+ @static
+ @for RSVP
+ @param {Array} array Array of promises.
+ @param {String} label An optional label. This is useful
+ for tooling.
+ */
+ __exports__["default"] = function all(array, label) {
+ return Promise.all(array, label);
+ }
+ });
+enifed("rsvp/asap",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ var len = 0;
+
+ __exports__["default"] = function asap(callback, arg) {
+ queue[len] = callback;
+ queue[len + 1] = arg;
+ len += 2;
+ if (len === 2) {
+ // If len is 1, that means that we need to schedule an async flush.
+ // If additional callbacks are queued before the queue is flushed, they
+ // will be processed by this flush that we are scheduling.
+ scheduleFlush();
+ }
+ }
+
+ var browserWindow = (typeof window !== 'undefined') ? window : undefined
+ var browserGlobal = browserWindow || {};
+ var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+
+ // test for web worker but not in IE10
+ var isWorker = typeof Uint8ClampedArray !== 'undefined' &&
+ typeof importScripts !== 'undefined' &&
+ typeof MessageChannel !== 'undefined';
+
+ // node
+ function useNextTick() {
+ return function() {
+ process.nextTick(flush);
+ };
+ }
+
+ // vertx
+ function useVertxTimer() {
+ return function() {
+ vertxNext(flush);
+ };
+ }
+
+ function useMutationObserver() {
+ var iterations = 0;
+ var observer = new BrowserMutationObserver(flush);
+ var node = document.createTextNode('');
+ observer.observe(node, { characterData: true });
+
+ return function() {
+ node.data = (iterations = ++iterations % 2);
+ };
+ }
+
+ // web worker
+ function useMessageChannel() {
+ var channel = new MessageChannel();
+ channel.port1.onmessage = flush;
+ return function () {
+ channel.port2.postMessage(0);
+ };
+ }
+
+ function useSetTimeout() {
+ return function() {
+ setTimeout(flush, 1);
+ };
+ }
+
+ var queue = new Array(1000);
+ function flush() {
+ for (var i = 0; i < len; i+=2) {
+ var callback = queue[i];
+ var arg = queue[i+1];
+
+ callback(arg);
+
+ queue[i] = undefined;
+ queue[i+1] = undefined;
+ }
+
+ len = 0;
+ }
+
+ function attemptVertex() {
+ try {
+ var vertx = eriuqer('vertx');
+ var vertxNext = vertx.runOnLoop || vertx.runOnContext;
+ return useVertxTimer();
+ } catch(e) {
+ return useSetTimeout();
+ }
+ }
+
+ var scheduleFlush;
+ // Decide what async method to use to triggering processing of queued callbacks:
+ if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
+ scheduleFlush = useNextTick();
+ } else if (BrowserMutationObserver) {
+ scheduleFlush = useMutationObserver();
+ } else if (isWorker) {
+ scheduleFlush = useMessageChannel();
+ } else if (browserWindow === undefined && typeof eriuqer === 'function') {
+ scheduleFlush = attemptVertex();
+ } else {
+ scheduleFlush = useSetTimeout();
+ }
+ });
+enifed("rsvp/config",
+ ["./events","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var EventTarget = __dependency1__["default"];
+
+ var config = {
+ instrument: false
+ };
+
+ EventTarget.mixin(config);
+
+ function configure(name, value) {
+ if (name === 'onerror') {
+ // handle for legacy users that expect the actual
+ // error to be passed to their function added via
+ // `RSVP.configure('onerror', someFunctionHere);`
+ config.on('error', value);
+ return;
+ }
+
+ if (arguments.length === 2) {
+ config[name] = value;
+ } else {
+ return config[name];
+ }
+ }
+
+ __exports__.config = config;
+ __exports__.configure = configure;
+ });
+enifed("rsvp/defer",
+ ["./promise","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var Promise = __dependency1__["default"];
+
+ /**
+ `RSVP.defer` returns an object similar to jQuery's `$.Deferred`.
+ `RSVP.defer` should be used when porting over code reliant on `$.Deferred`'s
+ interface. New code should use the `RSVP.Promise` constructor instead.
+
+ The object returned from `RSVP.defer` is a plain object with three properties:
+
+ * promise - an `RSVP.Promise`.
+ * reject - a function that causes the `promise` property on this object to
+ become rejected
+ * resolve - a function that causes the `promise` property on this object to
+ become fulfilled.
+
+ Example:
+
+ ```javascript
+ var deferred = RSVP.defer();
+
+ deferred.resolve("Success!");
+
+ defered.promise.then(function(value){
+ // value here is "Success!"
+ });
+ ```
+
+ @method defer
+ @static
+ @for RSVP
+ @param {String} label optional string for labeling the promise.
+ Useful for tooling.
+ @return {Object}
+ */
+
+ __exports__["default"] = function defer(label) {
+ var deferred = { };
+
+ deferred['promise'] = new Promise(function(resolve, reject) {
+ deferred['resolve'] = resolve;
+ deferred['reject'] = reject;
+ }, label);
+
+ return deferred;
+ }
+ });
+enifed("rsvp/enumerator",
+ ["./utils","./-internal","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var isArray = __dependency1__.isArray;
+ var isMaybeThenable = __dependency1__.isMaybeThenable;
+
+ var noop = __dependency2__.noop;
+ var reject = __dependency2__.reject;
+ var fulfill = __dependency2__.fulfill;
+ var subscribe = __dependency2__.subscribe;
+ var FULFILLED = __dependency2__.FULFILLED;
+ var REJECTED = __dependency2__.REJECTED;
+ var PENDING = __dependency2__.PENDING;
+
+ function makeSettledResult(state, position, value) {
+ if (state === FULFILLED) {
+ return {
+ state: 'fulfilled',
+ value: value
+ };
+ } else {
+ return {
+ state: 'rejected',
+ reason: value
+ };
+ }
+ }
+
+ __exports__.makeSettledResult = makeSettledResult;function Enumerator(Constructor, input, abortOnReject, label) {
+ this._instanceConstructor = Constructor;
+ this.promise = new Constructor(noop, label);
+ this._abortOnReject = abortOnReject;
+
+ if (this._validateInput(input)) {
+ this._input = input;
+ this.length = input.length;
+ this._remaining = input.length;
+
+ this._init();
+
+ if (this.length === 0) {
+ fulfill(this.promise, this._result);
+ } else {
+ this.length = this.length || 0;
+ this._enumerate();
+ if (this._remaining === 0) {
+ fulfill(this.promise, this._result);
+ }
+ }
+ } else {
+ reject(this.promise, this._validationError());
+ }
+ }
+
+ Enumerator.prototype._validateInput = function(input) {
+ return isArray(input);
+ };
+
+ Enumerator.prototype._validationError = function() {
+ return new Error('Array Methods must be provided an Array');
+ };
+
+ Enumerator.prototype._init = function() {
+ this._result = new Array(this.length);
+ };
+
+ __exports__["default"] = Enumerator;
+
+ Enumerator.prototype._enumerate = function() {
+ var length = this.length;
+ var promise = this.promise;
+ var input = this._input;
+
+ for (var i = 0; promise._state === PENDING && i < length; i++) {
+ this._eachEntry(input[i], i);
+ }
+ };
+
+ Enumerator.prototype._eachEntry = function(entry, i) {
+ var c = this._instanceConstructor;
+ if (isMaybeThenable(entry)) {
+ if (entry.constructor === c && entry._state !== PENDING) {
+ entry._onerror = null;
+ this._settledAt(entry._state, i, entry._result);
+ } else {
+ this._willSettleAt(c.resolve(entry), i);
+ }
+ } else {
+ this._remaining--;
+ this._result[i] = this._makeResult(FULFILLED, i, entry);
+ }
+ };
+
+ Enumerator.prototype._settledAt = function(state, i, value) {
+ var promise = this.promise;
+
+ if (promise._state === PENDING) {
+ this._remaining--;
+
+ if (this._abortOnReject && state === REJECTED) {
+ reject(promise, value);
+ } else {
+ this._result[i] = this._makeResult(state, i, value);
+ }
+ }
+
+ if (this._remaining === 0) {
+ fulfill(promise, this._result);
+ }
+ };
+
+ Enumerator.prototype._makeResult = function(state, i, value) {
+ return value;
+ };
+
+ Enumerator.prototype._willSettleAt = function(promise, i) {
+ var enumerator = this;
+
+ subscribe(promise, undefined, function(value) {
+ enumerator._settledAt(FULFILLED, i, value);
+ }, function(reason) {
+ enumerator._settledAt(REJECTED, i, reason);
+ });
+ };
+ });
+enifed("rsvp/events",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ function indexOf(callbacks, callback) {
+ for (var i=0, l=callbacks.length; i 1;
+ };
+
+ RSVP.filter(promises, filterFn).then(function(result){
+ // result is [ 2, 3 ]
+ });
+ ```
+
+ If any of the `promises` given to `RSVP.filter` are rejected, the first promise
+ that is rejected will be given as an argument to the returned promise's
+ rejection handler. For example:
+
+ ```javascript
+ var promise1 = RSVP.resolve(1);
+ var promise2 = RSVP.reject(new Error('2'));
+ var promise3 = RSVP.reject(new Error('3'));
+ var promises = [ promise1, promise2, promise3 ];
+
+ var filterFn = function(item){
+ return item > 1;
+ };
+
+ RSVP.filter(promises, filterFn).then(function(array){
+ // Code here never runs because there are rejected promises!
+ }, function(reason) {
+ // reason.message === '2'
+ });
+ ```
+
+ `RSVP.filter` will also wait for any promises returned from `filterFn`.
+ For instance, you may want to fetch a list of users then return a subset
+ of those users based on some asynchronous operation:
+
+ ```javascript
+
+ var alice = { name: 'alice' };
+ var bob = { name: 'bob' };
+ var users = [ alice, bob ];
+
+ var promises = users.map(function(user){
+ return RSVP.resolve(user);
+ });
+
+ var filterFn = function(user){
+ // Here, Alice has permissions to create a blog post, but Bob does not.
+ return getPrivilegesForUser(user).then(function(privs){
+ return privs.can_create_blog_post === true;
+ });
+ };
+ RSVP.filter(promises, filterFn).then(function(users){
+ // true, because the server told us only Alice can create a blog post.
+ users.length === 1;
+ // false, because Alice is the only user present in `users`
+ users[0] === bob;
+ });
+ ```
+
+ @method filter
+ @static
+ @for RSVP
+ @param {Array} promises
+ @param {Function} filterFn - function to be called on each resolved value to
+ filter the final results.
+ @param {String} label optional string describing the promise. Useful for
+ tooling.
+ @return {Promise}
+ */
+ __exports__["default"] = function filter(promises, filterFn, label) {
+ return Promise.all(promises, label).then(function(values) {
+ if (!isFunction(filterFn)) {
+ throw new TypeError("You must pass a function as filter's second argument.");
+ }
+
+ var length = values.length;
+ var filtered = new Array(length);
+
+ for (var i = 0; i < length; i++) {
+ filtered[i] = filterFn(values[i]);
+ }
+
+ return Promise.all(filtered, label).then(function(filtered) {
+ var results = new Array(length);
+ var newLength = 0;
+
+ for (var i = 0; i < length; i++) {
+ if (filtered[i]) {
+ results[newLength] = values[i];
+ newLength++;
+ }
+ }
+
+ results.length = newLength;
+
+ return results;
+ });
+ });
+ }
+ });
+enifed("rsvp/hash-settled",
+ ["./promise","./enumerator","./promise-hash","./utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+ "use strict";
+ var Promise = __dependency1__["default"];
+ var makeSettledResult = __dependency2__.makeSettledResult;
+ var PromiseHash = __dependency3__["default"];
+ var Enumerator = __dependency2__["default"];
+ var o_create = __dependency4__.o_create;
+
+ function HashSettled(Constructor, object, label) {
+ this._superConstructor(Constructor, object, false, label);
+ }
+
+ HashSettled.prototype = o_create(PromiseHash.prototype);
+ HashSettled.prototype._superConstructor = Enumerator;
+ HashSettled.prototype._makeResult = makeSettledResult;
+
+ HashSettled.prototype._validationError = function() {
+ return new Error('hashSettled must be called with an object');
+ };
+
+ /**
+ `RSVP.hashSettled` is similar to `RSVP.allSettled`, but takes an object
+ instead of an array for its `promises` argument.
+
+ Unlike `RSVP.all` or `RSVP.hash`, which implement a fail-fast method,
+ but like `RSVP.allSettled`, `hashSettled` waits until all the
+ constituent promises have returned and then shows you all the results
+ with their states and values/reasons. This is useful if you want to
+ handle multiple promises' failure states together as a set.
+
+ Returns a promise that is fulfilled when all the given promises have been
+ settled, or rejected if the passed parameters are invalid.
+
+ The returned promise is fulfilled with a hash that has the same key names as
+ the `promises` object argument. If any of the values in the object are not
+ promises, they will be copied over to the fulfilled object and marked with state
+ 'fulfilled'.
+
+ Example:
+
+ ```javascript
+ var promises = {
+ myPromise: RSVP.Promise.resolve(1),
+ yourPromise: RSVP.Promise.resolve(2),
+ theirPromise: RSVP.Promise.resolve(3),
+ notAPromise: 4
+ };
+
+ RSVP.hashSettled(promises).then(function(hash){
+ // hash here is an object that looks like:
+ // {
+ // myPromise: { state: 'fulfilled', value: 1 },
+ // yourPromise: { state: 'fulfilled', value: 2 },
+ // theirPromise: { state: 'fulfilled', value: 3 },
+ // notAPromise: { state: 'fulfilled', value: 4 }
+ // }
+ });
+ ```
+
+ If any of the `promises` given to `RSVP.hash` are rejected, the state will
+ be set to 'rejected' and the reason for rejection provided.
+
+ Example:
+
+ ```javascript
+ var promises = {
+ myPromise: RSVP.Promise.resolve(1),
+ rejectedPromise: RSVP.Promise.reject(new Error('rejection')),
+ anotherRejectedPromise: RSVP.Promise.reject(new Error('more rejection')),
+ };
+
+ RSVP.hashSettled(promises).then(function(hash){
+ // hash here is an object that looks like:
+ // {
+ // myPromise: { state: 'fulfilled', value: 1 },
+ // rejectedPromise: { state: 'rejected', reason: Error },
+ // anotherRejectedPromise: { state: 'rejected', reason: Error },
+ // }
+ // Note that for rejectedPromise, reason.message == 'rejection',
+ // and for anotherRejectedPromise, reason.message == 'more rejection'.
+ });
+ ```
+
+ An important note: `RSVP.hashSettled` is intended for plain JavaScript objects that
+ are just a set of keys and values. `RSVP.hashSettled` will NOT preserve prototype
+ chains.
+
+ Example:
+
+ ```javascript
+ function MyConstructor(){
+ this.example = RSVP.Promise.resolve('Example');
+ }
+
+ MyConstructor.prototype = {
+ protoProperty: RSVP.Promise.resolve('Proto Property')
+ };
+
+ var myObject = new MyConstructor();
+
+ RSVP.hashSettled(myObject).then(function(hash){
+ // protoProperty will not be present, instead you will just have an
+ // object that looks like:
+ // {
+ // example: { state: 'fulfilled', value: 'Example' }
+ // }
+ //
+ // hash.hasOwnProperty('protoProperty'); // false
+ // 'undefined' === typeof hash.protoProperty
+ });
+ ```
+
+ @method hashSettled
+ @for RSVP
+ @param {Object} promises
+ @param {String} label optional string that describes the promise.
+ Useful for tooling.
+ @return {Promise} promise that is fulfilled when when all properties of `promises`
+ have been settled.
+ @static
+ */
+ __exports__["default"] = function hashSettled(object, label) {
+ return new HashSettled(Promise, object, label).promise;
+ }
+ });
+enifed("rsvp/hash",
+ ["./promise","./promise-hash","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var Promise = __dependency1__["default"];
+ var PromiseHash = __dependency2__["default"];
+
+ /**
+ `RSVP.hash` is similar to `RSVP.all`, but takes an object instead of an array
+ for its `promises` argument.
+
+ Returns a promise that is fulfilled when all the given promises have been
+ fulfilled, or rejected if any of them become rejected. The returned promise
+ is fulfilled with a hash that has the same key names as the `promises` object
+ argument. If any of the values in the object are not promises, they will
+ simply be copied over to the fulfilled object.
+
+ Example:
+
+ ```javascript
+ var promises = {
+ myPromise: RSVP.resolve(1),
+ yourPromise: RSVP.resolve(2),
+ theirPromise: RSVP.resolve(3),
+ notAPromise: 4
+ };
+
+ RSVP.hash(promises).then(function(hash){
+ // hash here is an object that looks like:
+ // {
+ // myPromise: 1,
+ // yourPromise: 2,
+ // theirPromise: 3,
+ // notAPromise: 4
+ // }
+ });
+ ````
+
+ If any of the `promises` given to `RSVP.hash` are rejected, the first promise
+ that is rejected will be given as the reason to the rejection handler.
+
+ Example:
+
+ ```javascript
+ var promises = {
+ myPromise: RSVP.resolve(1),
+ rejectedPromise: RSVP.reject(new Error('rejectedPromise')),
+ anotherRejectedPromise: RSVP.reject(new Error('anotherRejectedPromise')),
+ };
+
+ RSVP.hash(promises).then(function(hash){
+ // Code here never runs because there are rejected promises!
+ }, function(reason) {
+ // reason.message === 'rejectedPromise'
+ });
+ ```
+
+ An important note: `RSVP.hash` is intended for plain JavaScript objects that
+ are just a set of keys and values. `RSVP.hash` will NOT preserve prototype
+ chains.
+
+ Example:
+
+ ```javascript
+ function MyConstructor(){
+ this.example = RSVP.resolve('Example');
+ }
+
+ MyConstructor.prototype = {
+ protoProperty: RSVP.resolve('Proto Property')
+ };
+
+ var myObject = new MyConstructor();
+
+ RSVP.hash(myObject).then(function(hash){
+ // protoProperty will not be present, instead you will just have an
+ // object that looks like:
+ // {
+ // example: 'Example'
+ // }
+ //
+ // hash.hasOwnProperty('protoProperty'); // false
+ // 'undefined' === typeof hash.protoProperty
+ });
+ ```
+
+ @method hash
+ @static
+ @for RSVP
+ @param {Object} promises
+ @param {String} label optional string that describes the promise.
+ Useful for tooling.
+ @return {Promise} promise that is fulfilled when all properties of `promises`
+ have been fulfilled, or rejected if any of them become rejected.
+ */
+ __exports__["default"] = function hash(object, label) {
+ return new PromiseHash(Promise, object, label).promise;
+ }
+ });
+enifed("rsvp/instrument",
+ ["./config","./utils","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var config = __dependency1__.config;
+ var now = __dependency2__.now;
+
+ var queue = [];
+
+ function scheduleFlush() {
+ setTimeout(function() {
+ var entry;
+ for (var i = 0; i < queue.length; i++) {
+ entry = queue[i];
+
+ var payload = entry.payload;
+
+ payload.guid = payload.key + payload.id;
+ payload.childGuid = payload.key + payload.childId;
+ if (payload.error) {
+ payload.stack = payload.error.stack;
+ }
+
+ config.trigger(entry.name, entry.payload);
+ }
+ queue.length = 0;
+ }, 50);
+ }
+
+ __exports__["default"] = function instrument(eventName, promise, child) {
+ if (1 === queue.push({
+ name: eventName,
+ payload: {
+ key: promise._guidKey,
+ id: promise._id,
+ eventName: eventName,
+ detail: promise._result,
+ childId: child && child._id,
+ label: promise._label,
+ timeStamp: now(),
+ error: config["instrument-with-stack"] ? new Error(promise._label) : null
+ }})) {
+ scheduleFlush();
+ }
+ }
+ });
+enifed("rsvp/map",
+ ["./promise","./utils","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var Promise = __dependency1__["default"];
+ var isFunction = __dependency2__.isFunction;
+
+ /**
+ `RSVP.map` is similar to JavaScript's native `map` method, except that it
+ waits for all promises to become fulfilled before running the `mapFn` on
+ each item in given to `promises`. `RSVP.map` returns a promise that will
+ become fulfilled with the result of running `mapFn` on the values the promises
+ become fulfilled with.
+
+ For example:
+
+ ```javascript
+
+ var promise1 = RSVP.resolve(1);
+ var promise2 = RSVP.resolve(2);
+ var promise3 = RSVP.resolve(3);
+ var promises = [ promise1, promise2, promise3 ];
+
+ var mapFn = function(item){
+ return item + 1;
+ };
+
+ RSVP.map(promises, mapFn).then(function(result){
+ // result is [ 2, 3, 4 ]
+ });
+ ```
+
+ If any of the `promises` given to `RSVP.map` are rejected, the first promise
+ that is rejected will be given as an argument to the returned promise's
+ rejection handler. For example:
+
+ ```javascript
+ var promise1 = RSVP.resolve(1);
+ var promise2 = RSVP.reject(new Error('2'));
+ var promise3 = RSVP.reject(new Error('3'));
+ var promises = [ promise1, promise2, promise3 ];
+
+ var mapFn = function(item){
+ return item + 1;
+ };
+
+ RSVP.map(promises, mapFn).then(function(array){
+ // Code here never runs because there are rejected promises!
+ }, function(reason) {
+ // reason.message === '2'
+ });
+ ```
+
+ `RSVP.map` will also wait if a promise is returned from `mapFn`. For example,
+ say you want to get all comments from a set of blog posts, but you need
+ the blog posts first because they contain a url to those comments.
+
+ ```javscript
+
+ var mapFn = function(blogPost){
+ // getComments does some ajax and returns an RSVP.Promise that is fulfilled
+ // with some comments data
+ return getComments(blogPost.comments_url);
+ };
+
+ // getBlogPosts does some ajax and returns an RSVP.Promise that is fulfilled
+ // with some blog post data
+ RSVP.map(getBlogPosts(), mapFn).then(function(comments){
+ // comments is the result of asking the server for the comments
+ // of all blog posts returned from getBlogPosts()
+ });
+ ```
+
+ @method map
+ @static
+ @for RSVP
+ @param {Array} promises
+ @param {Function} mapFn function to be called on each fulfilled promise.
+ @param {String} label optional string for labeling the promise.
+ Useful for tooling.
+ @return {Promise} promise that is fulfilled with the result of calling
+ `mapFn` on each fulfilled promise or value when they become fulfilled.
+ The promise will be rejected if any of the given `promises` become rejected.
+ @static
+ */
+ __exports__["default"] = function map(promises, mapFn, label) {
+ return Promise.all(promises, label).then(function(values) {
+ if (!isFunction(mapFn)) {
+ throw new TypeError("You must pass a function as map's second argument.");
+ }
+
+ var length = values.length;
+ var results = new Array(length);
+
+ for (var i = 0; i < length; i++) {
+ results[i] = mapFn(values[i]);
+ }
+
+ return Promise.all(results, label);
+ });
+ }
+ });
+enifed("rsvp/node",
+ ["./promise","./-internal","./utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var Promise = __dependency1__["default"];
+ var noop = __dependency2__.noop;
+ var resolve = __dependency2__.resolve;
+ var reject = __dependency2__.reject;
+ var isArray = __dependency3__.isArray;
+
+ function Result() {
+ this.value = undefined;
+ }
+
+ var ERROR = new Result();
+ var GET_THEN_ERROR = new Result();
+
+ function getThen(obj) {
+ try {
+ return obj.then;
+ } catch(error) {
+ ERROR.value= error;
+ return ERROR;
+ }
+ }
+
+
+ function tryApply(f, s, a) {
+ try {
+ f.apply(s, a);
+ } catch(error) {
+ ERROR.value = error;
+ return ERROR;
+ }
+ }
+
+ function makeObject(_, argumentNames) {
+ var obj = {};
+ var name;
+ var i;
+ var length = _.length;
+ var args = new Array(length);
+
+ for (var x = 0; x < length; x++) {
+ args[x] = _[x];
+ }
+
+ for (i = 0; i < argumentNames.length; i++) {
+ name = argumentNames[i];
+ obj[name] = args[i + 1];
+ }
+
+ return obj;
+ }
+
+ function arrayResult(_) {
+ var length = _.length;
+ var args = new Array(length - 1);
+
+ for (var i = 1; i < length; i++) {
+ args[i - 1] = _[i];
+ }
+
+ return args;
+ }
+
+ function wrapThenable(then, promise) {
+ return {
+ then: function(onFulFillment, onRejection) {
+ return then.call(promise, onFulFillment, onRejection);
+ }
+ };
+ }
+
+ /**
+ `RSVP.denodeify` takes a 'node-style' function and returns a function that
+ will return an `RSVP.Promise`. You can use `denodeify` in Node.js or the
+ browser when you'd prefer to use promises over using callbacks. For example,
+ `denodeify` transforms the following:
+
+ ```javascript
+ var fs = require('fs');
+
+ fs.readFile('myfile.txt', function(err, data){
+ if (err) return handleError(err);
+ handleData(data);
+ });
+ ```
+
+ into:
+
+ ```javascript
+ var fs = require('fs');
+ var readFile = RSVP.denodeify(fs.readFile);
+
+ readFile('myfile.txt').then(handleData, handleError);
+ ```
+
+ If the node function has multiple success parameters, then `denodeify`
+ just returns the first one:
+
+ ```javascript
+ var request = RSVP.denodeify(require('request'));
+
+ request('http://example.com').then(function(res) {
+ // ...
+ });
+ ```
+
+ However, if you need all success parameters, setting `denodeify`'s
+ second parameter to `true` causes it to return all success parameters
+ as an array:
+
+ ```javascript
+ var request = RSVP.denodeify(require('request'), true);
+
+ request('http://example.com').then(function(result) {
+ // result[0] -> res
+ // result[1] -> body
+ });
+ ```
+
+ Or if you pass it an array with names it returns the parameters as a hash:
+
+ ```javascript
+ var request = RSVP.denodeify(require('request'), ['res', 'body']);
+
+ request('http://example.com').then(function(result) {
+ // result.res
+ // result.body
+ });
+ ```
+
+ Sometimes you need to retain the `this`:
+
+ ```javascript
+ var app = require('express')();
+ var render = RSVP.denodeify(app.render.bind(app));
+ ```
+
+ The denodified function inherits from the original function. It works in all
+ environments, except IE 10 and below. Consequently all properties of the original
+ function are available to you. However, any properties you change on the
+ denodeified function won't be changed on the original function. Example:
+
+ ```javascript
+ var request = RSVP.denodeify(require('request')),
+ cookieJar = request.jar(); // <- Inheritance is used here
+
+ request('http://example.com', {jar: cookieJar}).then(function(res) {
+ // cookieJar.cookies holds now the cookies returned by example.com
+ });
+ ```
+
+ Using `denodeify` makes it easier to compose asynchronous operations instead
+ of using callbacks. For example, instead of:
+
+ ```javascript
+ var fs = require('fs');
+
+ fs.readFile('myfile.txt', function(err, data){
+ if (err) { ... } // Handle error
+ fs.writeFile('myfile2.txt', data, function(err){
+ if (err) { ... } // Handle error
+ console.log('done')
+ });
+ });
+ ```
+
+ you can chain the operations together using `then` from the returned promise:
+
+ ```javascript
+ var fs = require('fs');
+ var readFile = RSVP.denodeify(fs.readFile);
+ var writeFile = RSVP.denodeify(fs.writeFile);
+
+ readFile('myfile.txt').then(function(data){
+ return writeFile('myfile2.txt', data);
+ }).then(function(){
+ console.log('done')
+ }).catch(function(error){
+ // Handle error
+ });
+ ```
+
+ @method denodeify
+ @static
+ @for RSVP
+ @param {Function} nodeFunc a 'node-style' function that takes a callback as
+ its last argument. The callback expects an error to be passed as its first
+ argument (if an error occurred, otherwise null), and the value from the
+ operation as its second argument ('function(err, value){ }').
+ @param {Boolean|Array} argumentNames An optional paramter that if set
+ to `true` causes the promise to fulfill with the callback's success arguments
+ as an array. This is useful if the node function has multiple success
+ paramters. If you set this paramter to an array with names, the promise will
+ fulfill with a hash with these names as keys and the success parameters as
+ values.
+ @return {Function} a function that wraps `nodeFunc` to return an
+ `RSVP.Promise`
+ @static
+ */
+ __exports__["default"] = function denodeify(nodeFunc, options) {
+ var fn = function() {
+ var self = this;
+ var l = arguments.length;
+ var args = new Array(l + 1);
+ var arg;
+ var promiseInput = false;
+
+ for (var i = 0; i < l; ++i) {
+ arg = arguments[i];
+
+ if (!promiseInput) {
+ // TODO: clean this up
+ promiseInput = needsPromiseInput(arg);
+ if (promiseInput === GET_THEN_ERROR) {
+ var p = new Promise(noop);
+ reject(p, GET_THEN_ERROR.value);
+ return p;
+ } else if (promiseInput && promiseInput !== true) {
+ arg = wrapThenable(promiseInput, arg);
+ }
+ }
+ args[i] = arg;
+ }
+
+ var promise = new Promise(noop);
+
+ args[l] = function(err, val) {
+ if (err)
+ reject(promise, err);
+ else if (options === undefined)
+ resolve(promise, val);
+ else if (options === true)
+ resolve(promise, arrayResult(arguments));
+ else if (isArray(options))
+ resolve(promise, makeObject(arguments, options));
+ else
+ resolve(promise, val);
+ };
+
+ if (promiseInput) {
+ return handlePromiseInput(promise, args, nodeFunc, self);
+ } else {
+ return handleValueInput(promise, args, nodeFunc, self);
+ }
+ };
+
+ fn.__proto__ = nodeFunc;
+
+ return fn;
+ }
+
+ function handleValueInput(promise, args, nodeFunc, self) {
+ var result = tryApply(nodeFunc, self, args);
+ if (result === ERROR) {
+ reject(promise, result.value);
+ }
+ return promise;
+ }
+
+ function handlePromiseInput(promise, args, nodeFunc, self){
+ return Promise.all(args).then(function(args){
+ var result = tryApply(nodeFunc, self, args);
+ if (result === ERROR) {
+ reject(promise, result.value);
+ }
+ return promise;
+ });
+ }
+
+ function needsPromiseInput(arg) {
+ if (arg && typeof arg === 'object') {
+ if (arg.constructor === Promise) {
+ return true;
+ } else {
+ return getThen(arg);
+ }
+ } else {
+ return false;
+ }
+ }
+ });
+enifed("rsvp/promise-hash",
+ ["./enumerator","./-internal","./utils","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+ "use strict";
+ var Enumerator = __dependency1__["default"];
+ var PENDING = __dependency2__.PENDING;
+ var o_create = __dependency3__.o_create;
+
+ function PromiseHash(Constructor, object, label) {
+ this._superConstructor(Constructor, object, true, label);
+ }
+
+ __exports__["default"] = PromiseHash;
+
+ PromiseHash.prototype = o_create(Enumerator.prototype);
+ PromiseHash.prototype._superConstructor = Enumerator;
+ PromiseHash.prototype._init = function() {
+ this._result = {};
+ };
+
+ PromiseHash.prototype._validateInput = function(input) {
+ return input && typeof input === 'object';
+ };
+
+ PromiseHash.prototype._validationError = function() {
+ return new Error('Promise.hash must be called with an object');
+ };
+
+ PromiseHash.prototype._enumerate = function() {
+ var promise = this.promise;
+ var input = this._input;
+ var results = [];
+
+ for (var key in input) {
+ if (promise._state === PENDING && input.hasOwnProperty(key)) {
+ results.push({
+ position: key,
+ entry: input[key]
+ });
+ }
+ }
+
+ var length = results.length;
+ this._remaining = length;
+ var result;
+
+ for (var i = 0; promise._state === PENDING && i < length; i++) {
+ result = results[i];
+ this._eachEntry(result.entry, result.position);
+ }
+ };
+ });
+enifed("rsvp/promise",
+ ["./config","./instrument","./utils","./-internal","./promise/all","./promise/race","./promise/resolve","./promise/reject","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
+ "use strict";
+ var config = __dependency1__.config;
+ var instrument = __dependency2__["default"];
+
+ var isFunction = __dependency3__.isFunction;
+ var now = __dependency3__.now;
+
+ var noop = __dependency4__.noop;
+ var subscribe = __dependency4__.subscribe;
+ var initializePromise = __dependency4__.initializePromise;
+ var invokeCallback = __dependency4__.invokeCallback;
+ var FULFILLED = __dependency4__.FULFILLED;
+ var REJECTED = __dependency4__.REJECTED;
+
+ var all = __dependency5__["default"];
+ var race = __dependency6__["default"];
+ var Resolve = __dependency7__["default"];
+ var Reject = __dependency8__["default"];
+
+ var guidKey = 'rsvp_' + now() + '-';
+ var counter = 0;
+
+ function needsResolver() {
+ throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
+ }
+
+ function needsNew() {
+ throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
+ }
+ __exports__["default"] = Promise;
+ /**
+ Promise objects represent the eventual result of an asynchronous operation. The
+ primary way of interacting with a promise is through its `then` method, which
+ registers callbacks to receive either a promise’s eventual value or the reason
+ why the promise cannot be fulfilled.
+
+ Terminology
+ -----------
+
+ - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
+ - `thenable` is an object or function that defines a `then` method.
+ - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
+ - `exception` is a value that is thrown using the throw statement.
+ - `reason` is a value that indicates why a promise was rejected.
+ - `settled` the final resting state of a promise, fulfilled or rejected.
+
+ A promise can be in one of three states: pending, fulfilled, or rejected.
+
+ Promises that are fulfilled have a fulfillment value and are in the fulfilled
+ state. Promises that are rejected have a rejection reason and are in the
+ rejected state. A fulfillment value is never a thenable.
+
+ Promises can also be said to *resolve* a value. If this value is also a
+ promise, then the original promise's settled state will match the value's
+ settled state. So a promise that *resolves* a promise that rejects will
+ itself reject, and a promise that *resolves* a promise that fulfills will
+ itself fulfill.
+
+
+ Basic Usage:
+ ------------
+
+ ```js
+ var promise = new Promise(function(resolve, reject) {
+ // on success
+ resolve(value);
+
+ // on failure
+ reject(reason);
+ });
+
+ promise.then(function(value) {
+ // on fulfillment
+ }, function(reason) {
+ // on rejection
+ });
+ ```
+
+ Advanced Usage:
+ ---------------
+
+ Promises shine when abstracting away asynchronous interactions such as
+ `XMLHttpRequest`s.
+
+ ```js
+ function getJSON(url) {
+ return new Promise(function(resolve, reject){
+ var xhr = new XMLHttpRequest();
+
+ xhr.open('GET', url);
+ xhr.onreadystatechange = handler;
+ xhr.responseType = 'json';
+ xhr.setRequestHeader('Accept', 'application/json');
+ xhr.send();
+
+ function handler() {
+ if (this.readyState === this.DONE) {
+ if (this.status === 200) {
+ resolve(this.response);
+ } else {
+ reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
+ }
+ }
+ };
+ });
+ }
+
+ getJSON('/posts.json').then(function(json) {
+ // on fulfillment
+ }, function(reason) {
+ // on rejection
+ });
+ ```
+
+ Unlike callbacks, promises are great composable primitives.
+
+ ```js
+ Promise.all([
+ getJSON('/posts'),
+ getJSON('/comments')
+ ]).then(function(values){
+ values[0] // => postsJSON
+ values[1] // => commentsJSON
+
+ return values;
+ });
+ ```
+
+ @class RSVP.Promise
+ @param {function} resolver
+ @param {String} label optional string for labeling the promise.
+ Useful for tooling.
+ @constructor
+ */
+ function Promise(resolver, label) {
+ this._id = counter++;
+ this._label = label;
+ this._state = undefined;
+ this._result = undefined;
+ this._subscribers = [];
+
+ if (config.instrument) {
+ instrument('created', this);
+ }
+
+ if (noop !== resolver) {
+ if (!isFunction(resolver)) {
+ needsResolver();
+ }
+
+ if (!(this instanceof Promise)) {
+ needsNew();
+ }
+
+ initializePromise(this, resolver);
+ }
+ }
+
+ Promise.cast = Resolve; // deprecated
+ Promise.all = all;
+ Promise.race = race;
+ Promise.resolve = Resolve;
+ Promise.reject = Reject;
+
+ Promise.prototype = {
+ constructor: Promise,
+
+ _guidKey: guidKey,
+
+ _onerror: function (reason) {
+ config.trigger('error', reason);
+ },
+
+ /**
+ The primary way of interacting with a promise is through its `then` method,
+ which registers callbacks to receive either a promise's eventual value or the
+ reason why the promise cannot be fulfilled.
+
+ ```js
+ findUser().then(function(user){
+ // user is available
+ }, function(reason){
+ // user is unavailable, and you are given the reason why
+ });
+ ```
+
+ Chaining
+ --------
+
+ The return value of `then` is itself a promise. This second, 'downstream'
+ promise is resolved with the return value of the first promise's fulfillment
+ or rejection handler, or rejected if the handler throws an exception.
+
+ ```js
+ findUser().then(function (user) {
+ return user.name;
+ }, function (reason) {
+ return 'default name';
+ }).then(function (userName) {
+ // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
+ // will be `'default name'`
+ });
+
+ findUser().then(function (user) {
+ throw new Error('Found user, but still unhappy');
+ }, function (reason) {
+ throw new Error('`findUser` rejected and we're unhappy');
+ }).then(function (value) {
+ // never reached
+ }, function (reason) {
+ // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
+ // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
+ });
+ ```
+ If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
+
+ ```js
+ findUser().then(function (user) {
+ throw new PedagogicalException('Upstream error');
+ }).then(function (value) {
+ // never reached
+ }).then(function (value) {
+ // never reached
+ }, function (reason) {
+ // The `PedgagocialException` is propagated all the way down to here
+ });
+ ```
+
+ Assimilation
+ ------------
+
+ Sometimes the value you want to propagate to a downstream promise can only be
+ retrieved asynchronously. This can be achieved by returning a promise in the
+ fulfillment or rejection handler. The downstream promise will then be pending
+ until the returned promise is settled. This is called *assimilation*.
+
+ ```js
+ findUser().then(function (user) {
+ return findCommentsByAuthor(user);
+ }).then(function (comments) {
+ // The user's comments are now available
+ });
+ ```
+
+ If the assimliated promise rejects, then the downstream promise will also reject.
+
+ ```js
+ findUser().then(function (user) {
+ return findCommentsByAuthor(user);
+ }).then(function (comments) {
+ // If `findCommentsByAuthor` fulfills, we'll have the value here
+ }, function (reason) {
+ // If `findCommentsByAuthor` rejects, we'll have the reason here
+ });
+ ```
+
+ Simple Example
+ --------------
+
+ Synchronous Example
+
+ ```javascript
+ var result;
+
+ try {
+ result = findResult();
+ // success
+ } catch(reason) {
+ // failure
+ }
+ ```
+
+ Errback Example
+
+ ```js
+ findResult(function(result, err){
+ if (err) {
+ // failure
+ } else {
+ // success
+ }
+ });
+ ```
+
+ Promise Example;
+
+ ```javascript
+ findResult().then(function(result){
+ // success
+ }, function(reason){
+ // failure
+ });
+ ```
+
+ Advanced Example
+ --------------
+
+ Synchronous Example
+
+ ```javascript
+ var author, books;
+
+ try {
+ author = findAuthor();
+ books = findBooksByAuthor(author);
+ // success
+ } catch(reason) {
+ // failure
+ }
+ ```
+
+ Errback Example
+
+ ```js
+
+ function foundBooks(books) {
+
+ }
+
+ function failure(reason) {
+
+ }
+
+ findAuthor(function(author, err){
+ if (err) {
+ failure(err);
+ // failure
+ } else {
+ try {
+ findBoooksByAuthor(author, function(books, err) {
+ if (err) {
+ failure(err);
+ } else {
+ try {
+ foundBooks(books);
+ } catch(reason) {
+ failure(reason);
+ }
+ }
+ });
+ } catch(error) {
+ failure(err);
+ }
+ // success
+ }
+ });
+ ```
+
+ Promise Example;
+
+ ```javascript
+ findAuthor().
+ then(findBooksByAuthor).
+ then(function(books){
+ // found books
+ }).catch(function(reason){
+ // something went wrong
+ });
+ ```
+
+ @method then
+ @param {Function} onFulfilled
+ @param {Function} onRejected
+ @param {String} label optional string for labeling the promise.
+ Useful for tooling.
+ @return {Promise}
+ */
+ then: function(onFulfillment, onRejection, label) {
+ var parent = this;
+ var state = parent._state;
+
+ if (state === FULFILLED && !onFulfillment || state === REJECTED && !onRejection) {
+ if (config.instrument) {
+ instrument('chained', this, this);
+ }
+ return this;
+ }
+
+ parent._onerror = null;
+
+ var child = new this.constructor(noop, label);
+ var result = parent._result;
+
+ if (config.instrument) {
+ instrument('chained', parent, child);
+ }
+
+ if (state) {
+ var callback = arguments[state - 1];
+ config.async(function(){
+ invokeCallback(state, child, callback, result);
+ });
+ } else {
+ subscribe(parent, child, onFulfillment, onRejection);
+ }
+
+ return child;
+ },
+
+ /**
+ `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
+ as the catch block of a try/catch statement.
+
+ ```js
+ function findAuthor(){
+ throw new Error('couldn't find that author');
+ }
+
+ // synchronous
+ try {
+ findAuthor();
+ } catch(reason) {
+ // something went wrong
+ }
+
+ // async with promises
+ findAuthor().catch(function(reason){
+ // something went wrong
+ });
+ ```
+
+ @method catch
+ @param {Function} onRejection
+ @param {String} label optional string for labeling the promise.
+ Useful for tooling.
+ @return {Promise}
+ */
+ 'catch': function(onRejection, label) {
+ return this.then(null, onRejection, label);
+ },
+
+ /**
+ `finally` will be invoked regardless of the promise's fate just as native
+ try/catch/finally behaves
+
+ Synchronous example:
+
+ ```js
+ findAuthor() {
+ if (Math.random() > 0.5) {
+ throw new Error();
+ }
+ return new Author();
+ }
+
+ try {
+ return findAuthor(); // succeed or fail
+ } catch(error) {
+ return findOtherAuther();
+ } finally {
+ // always runs
+ // doesn't affect the return value
+ }
+ ```
+
+ Asynchronous example:
+
+ ```js
+ findAuthor().catch(function(reason){
+ return findOtherAuther();
+ }).finally(function(){
+ // author was either found, or not
+ });
+ ```
+
+ @method finally
+ @param {Function} callback
+ @param {String} label optional string for labeling the promise.
+ Useful for tooling.
+ @return {Promise}
+ */
+ 'finally': function(callback, label) {
+ var constructor = this.constructor;
+
+ return this.then(function(value) {
+ return constructor.resolve(callback()).then(function(){
+ return value;
+ });
+ }, function(reason) {
+ return constructor.resolve(callback()).then(function(){
+ throw reason;
+ });
+ }, label);
+ }
+ };
+ });
+enifed("rsvp/promise/all",
+ ["../enumerator","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var Enumerator = __dependency1__["default"];
+
+ /**
+ `RSVP.Promise.all` accepts an array of promises, and returns a new promise which
+ is fulfilled with an array of fulfillment values for the passed promises, or
+ rejected with the reason of the first passed promise to be rejected. It casts all
+ elements of the passed iterable to promises as it runs this algorithm.
+
+ Example:
+
+ ```javascript
+ var promise1 = RSVP.resolve(1);
+ var promise2 = RSVP.resolve(2);
+ var promise3 = RSVP.resolve(3);
+ var promises = [ promise1, promise2, promise3 ];
+
+ RSVP.Promise.all(promises).then(function(array){
+ // The array here would be [ 1, 2, 3 ];
+ });
+ ```
+
+ If any of the `promises` given to `RSVP.all` are rejected, the first promise
+ that is rejected will be given as an argument to the returned promises's
+ rejection handler. For example:
+
+ Example:
+
+ ```javascript
+ var promise1 = RSVP.resolve(1);
+ var promise2 = RSVP.reject(new Error("2"));
+ var promise3 = RSVP.reject(new Error("3"));
+ var promises = [ promise1, promise2, promise3 ];
+
+ RSVP.Promise.all(promises).then(function(array){
+ // Code here never runs because there are rejected promises!
+ }, function(error) {
+ // error.message === "2"
+ });
+ ```
+
+ @method all
+ @static
+ @param {Array} entries array of promises
+ @param {String} label optional string for labeling the promise.
+ Useful for tooling.
+ @return {Promise} promise that is fulfilled when all `promises` have been
+ fulfilled, or rejected if any of them become rejected.
+ @static
+ */
+ __exports__["default"] = function all(entries, label) {
+ return new Enumerator(this, entries, true /* abort on reject */, label).promise;
+ }
+ });
+enifed("rsvp/promise/race",
+ ["../utils","../-internal","exports"],
+ function(__dependency1__, __dependency2__, __exports__) {
+ "use strict";
+ var isArray = __dependency1__.isArray;
+
+ var noop = __dependency2__.noop;
+ var resolve = __dependency2__.resolve;
+ var reject = __dependency2__.reject;
+ var subscribe = __dependency2__.subscribe;
+ var PENDING = __dependency2__.PENDING;
+
+ /**
+ `RSVP.Promise.race` returns a new promise which is settled in the same way as the
+ first passed promise to settle.
+
+ Example:
+
+ ```javascript
+ var promise1 = new RSVP.Promise(function(resolve, reject){
+ setTimeout(function(){
+ resolve('promise 1');
+ }, 200);
+ });
+
+ var promise2 = new RSVP.Promise(function(resolve, reject){
+ setTimeout(function(){
+ resolve('promise 2');
+ }, 100);
+ });
+
+ RSVP.Promise.race([promise1, promise2]).then(function(result){
+ // result === 'promise 2' because it was resolved before promise1
+ // was resolved.
+ });
+ ```
+
+ `RSVP.Promise.race` is deterministic in that only the state of the first
+ settled promise matters. For example, even if other promises given to the
+ `promises` array argument are resolved, but the first settled promise has
+ become rejected before the other promises became fulfilled, the returned
+ promise will become rejected:
+
+ ```javascript
+ var promise1 = new RSVP.Promise(function(resolve, reject){
+ setTimeout(function(){
+ resolve('promise 1');
+ }, 200);
+ });
+
+ var promise2 = new RSVP.Promise(function(resolve, reject){
+ setTimeout(function(){
+ reject(new Error('promise 2'));
+ }, 100);
+ });
+
+ RSVP.Promise.race([promise1, promise2]).then(function(result){
+ // Code here never runs
+ }, function(reason){
+ // reason.message === 'promise 2' because promise 2 became rejected before
+ // promise 1 became fulfilled
+ });
+ ```
+
+ An example real-world use case is implementing timeouts:
+
+ ```javascript
+ RSVP.Promise.race([ajax('foo.json'), timeout(5000)])
+ ```
+
+ @method race
+ @static
+ @param {Array} promises array of promises to observe
+ @param {String} label optional string for describing the promise returned.
+ Useful for tooling.
+ @return {Promise} a promise which settles in the same way as the first passed
+ promise to settle.
+ */
+ __exports__["default"] = function race(entries, label) {
+ /*jshint validthis:true */
+ var Constructor = this;
+
+ var promise = new Constructor(noop, label);
+
+ if (!isArray(entries)) {
+ reject(promise, new TypeError('You must pass an array to race.'));
+ return promise;
+ }
+
+ var length = entries.length;
+
+ function onFulfillment(value) {
+ resolve(promise, value);
+ }
+
+ function onRejection(reason) {
+ reject(promise, reason);
+ }
+
+ for (var i = 0; promise._state === PENDING && i < length; i++) {
+ subscribe(Constructor.resolve(entries[i]), undefined, onFulfillment, onRejection);
+ }
+
+ return promise;
+ }
+ });
+enifed("rsvp/promise/reject",
+ ["../-internal","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var noop = __dependency1__.noop;
+ var _reject = __dependency1__.reject;
+
+ /**
+ `RSVP.Promise.reject` returns a promise rejected with the passed `reason`.
+ It is shorthand for the following:
+
+ ```javascript
+ var promise = new RSVP.Promise(function(resolve, reject){
+ reject(new Error('WHOOPS'));
+ });
+
+ promise.then(function(value){
+ // Code here doesn't run because the promise is rejected!
+ }, function(reason){
+ // reason.message === 'WHOOPS'
+ });
+ ```
+
+ Instead of writing the above, your code now simply becomes the following:
+
+ ```javascript
+ var promise = RSVP.Promise.reject(new Error('WHOOPS'));
+
+ promise.then(function(value){
+ // Code here doesn't run because the promise is rejected!
+ }, function(reason){
+ // reason.message === 'WHOOPS'
+ });
+ ```
+
+ @method reject
+ @static
+ @param {Any} reason value that the returned promise will be rejected with.
+ @param {String} label optional string for identifying the returned promise.
+ Useful for tooling.
+ @return {Promise} a promise rejected with the given `reason`.
+ */
+ __exports__["default"] = function reject(reason, label) {
+ /*jshint validthis:true */
+ var Constructor = this;
+ var promise = new Constructor(noop, label);
+ _reject(promise, reason);
+ return promise;
+ }
+ });
+enifed("rsvp/promise/resolve",
+ ["../-internal","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var noop = __dependency1__.noop;
+ var _resolve = __dependency1__.resolve;
+
+ /**
+ `RSVP.Promise.resolve` returns a promise that will become resolved with the
+ passed `value`. It is shorthand for the following:
+
+ ```javascript
+ var promise = new RSVP.Promise(function(resolve, reject){
+ resolve(1);
+ });
+
+ promise.then(function(value){
+ // value === 1
+ });
+ ```
+
+ Instead of writing the above, your code now simply becomes the following:
+
+ ```javascript
+ var promise = RSVP.Promise.resolve(1);
+
+ promise.then(function(value){
+ // value === 1
+ });
+ ```
+
+ @method resolve
+ @static
+ @param {Any} value value that the returned promise will be resolved with
+ @param {String} label optional string for identifying the returned promise.
+ Useful for tooling.
+ @return {Promise} a promise that will become fulfilled with the given
+ `value`
+ */
+ __exports__["default"] = function resolve(object, label) {
+ /*jshint validthis:true */
+ var Constructor = this;
+
+ if (object && typeof object === 'object' && object.constructor === Constructor) {
+ return object;
+ }
+
+ var promise = new Constructor(noop, label);
+ _resolve(promise, object);
+ return promise;
+ }
+ });
+enifed("rsvp/race",
+ ["./promise","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var Promise = __dependency1__["default"];
+
+ /**
+ This is a convenient alias for `RSVP.Promise.race`.
+
+ @method race
+ @static
+ @for RSVP
+ @param {Array} array Array of promises.
+ @param {String} label An optional label. This is useful
+ for tooling.
+ */
+ __exports__["default"] = function race(array, label) {
+ return Promise.race(array, label);
+ }
+ });
+enifed("rsvp/reject",
+ ["./promise","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var Promise = __dependency1__["default"];
+
+ /**
+ This is a convenient alias for `RSVP.Promise.reject`.
+
+ @method reject
+ @static
+ @for RSVP
+ @param {Any} reason value that the returned promise will be rejected with.
+ @param {String} label optional string for identifying the returned promise.
+ Useful for tooling.
+ @return {Promise} a promise rejected with the given `reason`.
+ */
+ __exports__["default"] = function reject(reason, label) {
+ return Promise.reject(reason, label);
+ }
+ });
+enifed("rsvp/resolve",
+ ["./promise","exports"],
+ function(__dependency1__, __exports__) {
+ "use strict";
+ var Promise = __dependency1__["default"];
+
+ /**
+ This is a convenient alias for `RSVP.Promise.resolve`.
+
+ @method resolve
+ @static
+ @for RSVP
+ @param {Any} value value that the returned promise will be resolved with
+ @param {String} label optional string for identifying the returned promise.
+ Useful for tooling.
+ @return {Promise} a promise that will become fulfilled with the given
+ `value`
+ */
+ __exports__["default"] = function resolve(value, label) {
+ return Promise.resolve(value, label);
+ }
+ });
+enifed("rsvp/rethrow",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ /**
+ `RSVP.rethrow` will rethrow an error on the next turn of the JavaScript event
+ loop in order to aid debugging.
+
+ Promises A+ specifies that any exceptions that occur with a promise must be
+ caught by the promises implementation and bubbled to the last handler. For
+ this reason, it is recommended that you always specify a second rejection
+ handler function to `then`. However, `RSVP.rethrow` will throw the exception
+ outside of the promise, so it bubbles up to your console if in the browser,
+ or domain/cause uncaught exception in Node. `rethrow` will also throw the
+ error again so the error can be handled by the promise per the spec.
+
+ ```javascript
+ function throws(){
+ throw new Error('Whoops!');
+ }
+
+ var promise = new RSVP.Promise(function(resolve, reject){
+ throws();
+ });
+
+ promise.catch(RSVP.rethrow).then(function(){
+ // Code here doesn't run because the promise became rejected due to an
+ // error!
+ }, function (err){
+ // handle the error here
+ });
+ ```
+
+ The 'Whoops' error will be thrown on the next turn of the event loop
+ and you can watch for it in your console. You can also handle it using a
+ rejection handler given to `.then` or `.catch` on the returned promise.
+
+ @method rethrow
+ @static
+ @for RSVP
+ @param {Error} reason reason the promise became rejected.
+ @throws Error
+ @static
+ */
+ __exports__["default"] = function rethrow(reason) {
+ setTimeout(function() {
+ throw reason;
+ });
+ throw reason;
+ }
+ });
+enifed("rsvp/utils",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ function objectOrFunction(x) {
+ return typeof x === 'function' || (typeof x === 'object' && x !== null);
+ }
+
+ __exports__.objectOrFunction = objectOrFunction;function isFunction(x) {
+ return typeof x === 'function';
+ }
+
+ __exports__.isFunction = isFunction;function isMaybeThenable(x) {
+ return typeof x === 'object' && x !== null;
+ }
+
+ __exports__.isMaybeThenable = isMaybeThenable;var _isArray;
+ if (!Array.isArray) {
+ _isArray = function (x) {
+ return Object.prototype.toString.call(x) === '[object Array]';
+ };
+ } else {
+ _isArray = Array.isArray;
+ }
+
+ var isArray = _isArray;
+ __exports__.isArray = isArray;
+ // Date.now is not available in browsers < IE9
+ // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/now#Compatibility
+ var now = Date.now || function() { return new Date().getTime(); };
+ __exports__.now = now;
+ function F() { }
+
+ var o_create = (Object.create || function (o) {
+ if (arguments.length > 1) {
+ throw new Error('Second argument not supported');
+ }
+ if (typeof o !== 'object') {
+ throw new TypeError('Argument must be an object');
+ }
+ F.prototype = o;
+ return new F();
+ });
+ __exports__.o_create = o_create;
+ });
+requireModule("ember");
+
+})();
diff --git a/website/source/assets/javascripts/lib/ember-1-10.min.js b/website/source/assets/javascripts/lib/ember-1-10.min.js
deleted file mode 100644
index 2ad58cc2f..000000000
--- a/website/source/assets/javascripts/lib/ember-1-10.min.js
+++ /dev/null
@@ -1,12 +0,0 @@
-!function(){var e,t,r,n,i;!function(){function a(){}function s(e,t){if("."!==e.charAt(0))return e;for(var r=e.split("/"),n=t.split("/").slice(0,-1),i=0,a=r.length;a>i;i++){var s=r[i];if(".."===s)n.pop();else{if("."===s)continue;n.push(s)}}return n.join("/")}if(i=this.Ember=this.Ember||{},"undefined"==typeof i&&(i={}),"undefined"==typeof i.__loader){var o={},u={};e=function(e,t,r){o[e]={deps:t,callback:r}},n=r=t=function(e){var r=u[e];if(void 0!==r)return u[e];if(r===a)return void 0;if(u[e]={},!o[e])throw new Error("Could not find module "+e);for(var n,i=o[e],l=i.deps,c=i.callback,h=[],m=l.length,p=0;m>p;p++)h.push("exports"===l[p]?n={}:t(s(l[p],e)));var f=0===m?c.call(this):c.apply(this,h);return u[e]=n||(void 0===f?a:f)},n._eak_seen=o,i.__loader={define:e,require:r,registry:o}}else e=i.__loader.define,n=r=t=i.__loader.require}(),e("backburner",["backburner/utils","backburner/platform","backburner/binary-search","backburner/deferred-action-queues","exports"],function(e,t,r,n,i){"use strict";function a(e,t){this.queueNames=e,this.options=t||{},this.options.defaultQueue||(this.options.defaultQueue=e[0]),this.instanceStack=[],this._debouncees=[],this._throttlers=[],this._timers=[]}function s(e){return e.onError||e.onErrorTarget&&e.onErrorTarget[e.onErrorMethod]}function o(e){e.begin(),e._autorun=O.setTimeout(function(){e._autorun=null,e.end()})}function u(e,t,r){var n=y();(!e._laterTimer||tr;r+=2)e.schedule(e.options.defaultQueue,null,t[r])}),e._timers.length&&u(e,e._timers[0],e._timers[0]-i)}function c(e,t,r){return m(e,t,r)}function h(e,t,r){return m(e,t,r)}function m(e,t,r){for(var n,i=-1,a=0,s=r.length;s>a;a++)if(n=r[a],n[0]===e&&n[1]===t){i=a;break}return i}var p=e.each,f=e.isString,d=e.isFunction,v=e.isNumber,b=e.isCoercableNumber,g=e.wrapInTryCatch,y=e.now,_=t.needsIETryCatchFix,w=r["default"],x=n["default"],C=[].slice,E=[].pop,O=this;if(a.prototype={begin:function(){var e=this.options,t=e&&e.onBegin,r=this.currentInstance;r&&this.instanceStack.push(r),this.currentInstance=new x(this.queueNames,e),t&&t(this.currentInstance,r)},end:function(){var e=this.options,t=e&&e.onEnd,r=this.currentInstance,n=null,i=!1;try{r.flush()}finally{i||(i=!0,this.currentInstance=null,this.instanceStack.length&&(n=this.instanceStack.pop(),this.currentInstance=n),t&&t(r,n))}},run:function(e,t){var r=s(this.options);this.begin(),t||(t=e,e=null),f(t)&&(t=e[t]);var n=C.call(arguments,2),i=!1;if(r)try{return t.apply(e,n)}catch(a){r(a)}finally{i||(i=!0,this.end())}else try{return t.apply(e,n)}finally{i||(i=!0,this.end())}},join:function(e,t){return this.currentInstance?(t||(t=e,e=null),f(t)&&(t=e[t]),t.apply(e,C.call(arguments,2))):this.run.apply(this,arguments)},defer:function(e,t,r){r||(r=t,t=null),f(r)&&(r=t[r]);var n,i=this.DEBUG?new Error:void 0,a=arguments.length;if(a>3){n=new Array(a-3);for(var s=3;a>s;s++)n[s-3]=arguments[s]}else n=void 0;return this.currentInstance||o(this),this.currentInstance.schedule(e,t,r,n,!1,i)},deferOnce:function(e,t,r){r||(r=t,t=null),f(r)&&(r=t[r]);var n,i=this.DEBUG?new Error:void 0,a=arguments.length;if(a>3){n=new Array(a-3);for(var s=3;a>s;s++)n[s-3]=arguments[s]}else n=void 0;return this.currentInstance||o(this),this.currentInstance.schedule(e,t,r,n,!0,i)},setTimeout:function(){function e(){if(g)try{i.apply(o,r)}catch(e){g(e)}else i.apply(o,r)}for(var t=arguments.length,r=new Array(t),n=0;t>n;n++)r[n]=arguments[n];var i,a,o,l,c,h,m=r.length;if(0!==m){if(1===m)i=r.shift(),a=0;else if(2===m)l=r[0],c=r[1],d(c)||d(l[c])?(o=r.shift(),i=r.shift(),a=0):b(c)?(i=r.shift(),a=r.shift()):(i=r.shift(),a=0);else{var p=r[r.length-1];a=b(p)?r.pop():0,l=r[0],h=r[1],d(h)||f(h)&&null!==l&&h in l?(o=r.shift(),i=r.shift()):i=r.shift()}var v=y()+parseInt(a,10);f(i)&&(i=o[i]);var g=s(this.options),_=w(v,this._timers);return this._timers.splice(_,0,v,e),u(this,v,a),e}},throttle:function(e,t){var r,n,i,a,s=this,o=arguments,u=E.call(o);return v(u)||f(u)?(r=u,u=!0):r=E.call(o),r=parseInt(r,10),i=h(e,t,this._throttlers),i>-1?this._throttlers[i]:(a=O.setTimeout(function(){u||s.run.apply(s,o);var r=h(e,t,s._throttlers);r>-1&&s._throttlers.splice(r,1)},r),u&&this.run.apply(this,o),n=[e,t,a],this._throttlers.push(n),n)},debounce:function(e,t){var r,n,i,a,s=this,o=arguments,u=E.call(o);return v(u)||f(u)?(r=u,u=!1):r=E.call(o),r=parseInt(r,10),n=c(e,t,this._debouncees),n>-1&&(i=this._debouncees[n],this._debouncees.splice(n,1),clearTimeout(i[2])),a=O.setTimeout(function(){u||s.run.apply(s,o);var r=c(e,t,s._debouncees);r>-1&&s._debouncees.splice(r,1)},r),u&&-1===n&&s.run.apply(s,o),i=[e,t,a],s._debouncees.push(i),i},cancelTimers:function(){var e=function(e){clearTimeout(e[2])};p(this._throttlers,e),this._throttlers=[],p(this._debouncees,e),this._debouncees=[],this._laterTimer&&(clearTimeout(this._laterTimer),this._laterTimer=null),this._timers=[],this._autorun&&(clearTimeout(this._autorun),this._autorun=null)},hasTimers:function(){return!!this._timers.length||!!this._debouncees.length||!!this._throttlers.length||this._autorun},cancel:function(e){var t=typeof e;if(e&&"object"===t&&e.queue&&e.method)return e.queue.cancel(e);if("function"!==t)return"[object Array]"===Object.prototype.toString.call(e)?this._cancelItem(h,this._throttlers,e)||this._cancelItem(c,this._debouncees,e):void 0;for(var r=0,n=this._timers.length;n>r;r+=2)if(this._timers[r+1]===e)return this._timers.splice(r,2),0===r&&(this._laterTimer&&(clearTimeout(this._laterTimer),this._laterTimer=null),this._timers.length>0&&u(this,this._timers[0],this._timers[0]-y())),!0},_cancelItem:function(e,t,r){var n,i;return r.length<3?!1:(i=e(r[0],r[1],t),i>-1&&(n=t[i],n[2]===r[2])?(t.splice(i,1),clearTimeout(r[2]),!0):!1)}},a.prototype.schedule=a.prototype.defer,a.prototype.scheduleOnce=a.prototype.deferOnce,a.prototype.later=a.prototype.setTimeout,_){var P=a.prototype.run;a.prototype.run=g(P);var A=a.prototype.end;a.prototype.end=g(A)}i["default"]=a}),e("backburner.umd",["./backburner"],function(t){"use strict";var r=t["default"];"function"==typeof e&&e.amd?e(function(){return r}):"undefined"!=typeof module&&module.exports?module.exports=r:"undefined"!=typeof this&&(this.Backburner=r)}),e("backburner/binary-search",["exports"],function(e){"use strict";e["default"]=function(e,t){for(var r,n,i=0,a=t.length-2;a>i;)n=(a-i)/2,r=i+n-n%2,e>=t[r]?i=r+2:a=r;return e>=t[i]?i+2:i}}),e("backburner/deferred-action-queues",["./utils","./queue","exports"],function(e,t,r){"use strict";function n(e,t){var r=this.queues=Object.create(null);this.queueNames=e=e||[],this.options=t,a(e,function(e){r[e]=new s(e,t[e],t)})}function i(e){throw new Error("You attempted to schedule an action in a queue ("+e+") that doesn't exist")}var a=e.each,s=t["default"];n.prototype={schedule:function(e,t,r,n,a,s){var o=this.queues,u=o[e];return u||i(e),a?u.pushUnique(t,r,n,s):u.push(t,r,n,s)},flush:function(){var e,t,r=this.queues,n=this.queueNames,i=0,a=n.length;for(this.options;a>i;){e=n[i],t=r[e];var s=t._queue.length;0===s?i++:(t.flush(!1),i=0)}}},r["default"]=n}),e("backburner/platform",["exports"],function(e){"use strict";var t=function(e,t){try{t()}catch(e){}return!!e}();e.needsIETryCatchFix=t}),e("backburner/queue",["./utils","exports"],function(e,t){"use strict";function r(e,t,r){this.name=e,this.globalOptions=r||{},this.options=t,this._queue=[],this.targetQueues=Object.create(null),this._queueBeingFlushed=void 0}var n=e.isString;r.prototype={push:function(e,t,r,n){var i=this._queue;return i.push(e,t,r,n),{queue:this,target:e,method:t}},pushUniqueWithoutGuid:function(e,t,r,n){for(var i=this._queue,a=0,s=i.length;s>a;a+=4){var o=i[a],u=i[a+1];if(o===e&&u===t)return i[a+2]=r,void(i[a+3]=n)}i.push(e,t,r,n)},targetQueue:function(e,t,r,n,i){for(var a=this._queue,s=0,o=e.length;o>s;s+=4){var u=e[s],l=e[s+1];if(u===r)return a[l+2]=n,void(a[l+3]=i)}e.push(r,a.push(t,r,n,i)-4)},pushUniqueWithGuid:function(e,t,r,n,i){var a=this.targetQueues[e];return a?this.targetQueue(a,t,r,n,i):this.targetQueues[e]=[r,this._queue.push(t,r,n,i)-4],{queue:this,target:t,method:r}},pushUnique:function(e,t,r,n){var i=(this._queue,this.globalOptions.GUID_KEY);if(e&&i){var a=e[i];if(a)return this.pushUniqueWithGuid(a,e,t,r,n)}return this.pushUniqueWithoutGuid(e,t,r,n),{queue:this,target:e,method:t}},invoke:function(e,t,r){r&&r.length>0?t.apply(e,r):t.call(e)},invokeWithOnError:function(e,t,r,n,i){try{r&&r.length>0?t.apply(e,r):t.call(e)}catch(a){n(a,i)}},flush:function(e){var t=this._queue,r=t.length;if(0!==r){var i,a,s,o,u=this.globalOptions,l=this.options,c=l&&l.before,h=l&&l.after,m=u.onError||u.onErrorTarget&&u.onErrorTarget[u.onErrorMethod],p=m?this.invokeWithOnError:this.invoke;this.targetQueues=Object.create(null);var f=this._queueBeingFlushed=this._queue.slice();this._queue=[],c&&c();for(var d=0;r>d;d+=4)i=f[d],a=f[d+1],s=f[d+2],o=f[d+3],n(a)&&(a=i[a]),a&&p(i,a,s,m,o);h&&h(),this._queueBeingFlushed=void 0,e!==!1&&this._queue.length>0&&this.flush(!0)}},cancel:function(e){var t,r,n,i,a=this._queue,s=e.target,o=e.method,u=this.globalOptions.GUID_KEY;if(u&&this.targetQueues&&s){var l=this.targetQueues[s[u]];if(l)for(n=0,i=l.length;i>n;n++)l[n]===o&&l.splice(n,1)}for(n=0,i=a.length;i>n;n+=4)if(t=a[n],r=a[n+1],t===s&&r===o)return a.splice(n,4),!0;if(a=this._queueBeingFlushed)for(n=0,i=a.length;i>n;n+=4)if(t=a[n],r=a[n+1],t===s&&r===o)return a[n+1]=null,!0}},t["default"]=r}),e("backburner/utils",["exports"],function(e){"use strict";function t(e,t){for(var r=0;r-1){try{if(e.existsSync(s)){var o,u=e.readFileSync(s,{encoding:"utf8"}),l=u.split("/").slice(-1)[0].trim(),c=u.split(" ")[1];if(c){var h=t.join(a,c.trim());o=e.readFileSync(h)}else o=l;i.push(o.slice(0,10))}}catch(m){console.error(m.stack)}return i.join(".")}return n}}),e("container",["container/container","exports"],function(e,t){"use strict";i.MODEL_FACTORY_INJECTIONS=!1,i.ENV&&"undefined"!=typeof i.ENV.MODEL_FACTORY_INJECTIONS&&(i.MODEL_FACTORY_INJECTIONS=!!i.ENV.MODEL_FACTORY_INJECTIONS);var r=e["default"];t["default"]=r}),e("container/container",["ember-metal/core","ember-metal/keys","ember-metal/dictionary","exports"],function(e,t,r,n){"use strict";function i(e){this.parent=e,this.children=[],this.resolver=e&&e.resolver||function(){},this.registry=P(e?e.registry:null),this.cache=P(e?e.cache:null),this.factoryCache=P(e?e.factoryCache:null),this.resolveCache=P(e?e.resolveCache:null),this.typeInjections=P(e?e.typeInjections:null),this.injections=P(null),this.normalizeCache=P(null),this.validationCache=P(e?e.validationCache:null),this.factoryTypeInjections=P(e?e.factoryTypeInjections:null),this.factoryInjections=P(null),this._options=P(e?e._options:null),this._typeOptions=P(e?e._typeOptions:null)}function a(e,t){var r=e.resolveCache[t];if(r)return r;var n=e.resolver(t)||e.registry[t];return e.resolveCache[t]=n,n}function s(e,t){return e.cache[t]?!0:void 0!==e.resolve(t)}function o(e,t,r){if(r=r||{},e.cache[t]&&r.singleton!==!1)return e.cache[t];var n=b(e,t);return void 0!==n?(l(e,t)&&r.singleton!==!1&&(e.cache[t]=n),n):void 0}function u(e){throw new Error(e+" is not currently supported on child containers")}function l(e,t){var r=m(e,t,"singleton");return r!==!1}function c(e,t){var r={};if(!t)return r;h(e,t);for(var n,i=0,a=t.length;a>i;i++)n=t[i],r[n.property]=o(e,n.fullName);return r}function h(e,t){if(t)for(var r,n=0,i=t.length;i>n;n++)if(r=t[n].fullName,!e.has(r))throw new Error("Attempting to inject an unknown injection: `"+r+"`")}function m(e,t,r){var n=e._options[t];if(n&&void 0!==n[r])return n[r];var i=t.split(":")[0];return n=e._typeOptions[i],n?n[r]:void 0}function p(e,t){var r=e.factoryCache;if(r[t])return r[t];var n=e.resolve(t);if(void 0!==n){var i=t.split(":")[0];if(!n||"function"!=typeof n.extend||!E.MODEL_FACTORY_INJECTIONS&&"model"===i)return n&&"function"==typeof n._onLookup&&n._onLookup(t),r[t]=n,n;var a=f(e,t),s=d(e,t);s._toString=e.makeToString(n,t);var o=n.extend(a);return o.reopenClass(s),n&&"function"==typeof n._onLookup&&n._onLookup(t),r[t]=o,o}}function f(e,t){var r=t.split(":"),n=r[0],i=[];return i=i.concat(e.typeInjections[n]||[]),i=i.concat(e.injections[t]||[]),i=c(e,i),i._debugContainerKey=t,i.container=e,i}function d(e,t){var r=t.split(":"),n=r[0],i=[];return i=i.concat(e.factoryTypeInjections[n]||[]),i=i.concat(e.factoryInjections[t]||[]),i=c(e,i),i._debugContainerKey=t,i}function v(e){var t=[];for(var r in e)e.hasOwnProperty(r)&&C(t,r,e[r]);return t}function b(e,t){var r,n,i=p(e,t);if(m(e,t,"instantiate")===!1)return i;if(i){if("function"!=typeof i.create)throw new Error("Failed to create an instance of '"+t+"'. Most likely an improperly defined class or an invalid module export.");return n=e.validationCache,n[t]||"function"!=typeof i._lazyInjections||(r=i._lazyInjections(),h(e,v(r))),n[t]=!0,"function"==typeof i.extend?i.create():i.create(f(e,t))}}function g(e,t){for(var r,n,i=e.cache,a=O(i),s=0,o=a.length;o>s;s++)r=a[s],n=i[r],m(e,r,"instantiate")!==!1&&t(n)}function y(e){g(e,function(e){e.destroy()}),e.cache.dict=P(null)}function _(e,t,r,n){var i=e[t];i||(i=[],e[t]=i),i.push({property:r,fullName:n})}function w(e){if(!A.test(e))throw new TypeError("Invalid Fullname, expected: `type:name` got: "+e);return!0}function x(e,t){return e[t]||(e[t]=[])}function C(e,t,r){e.push({property:t,fullName:r})}var E=e["default"],O=t["default"],P=r["default"];i.prototype={parent:null,children:null,resolver:null,registry:null,cache:null,typeInjections:null,injections:null,_options:null,_typeOptions:null,child:function(){var e=new i(this);return this.children.push(e),e},register:function(e,t,r){if(void 0===t)throw new TypeError("Attempting to register an unknown factory: `"+e+"`");var n=this.normalize(e);if(n in this.cache)throw new Error("Cannot re-register: `"+e+"`, as it has already been looked up.");this.registry[n]=t,this._options[n]=r||{}},unregister:function(e){var t=this.normalize(e);delete this.registry[t],delete this.cache[t],delete this.factoryCache[t],delete this.resolveCache[t],delete this._options[t],delete this.validationCache[t]},resolve:function(e){return a(this,this.normalize(e))},describe:function(e){return e},normalizeFullName:function(e){return e},normalize:function(e){return this.normalizeCache[e]||(this.normalizeCache[e]=this.normalizeFullName(e))},makeToString:function(e){return e.toString()},lookup:function(e,t){return o(this,this.normalize(e),t)},lookupFactory:function(e){return p(this,this.normalize(e))},has:function(e){return s(this,this.normalize(e))},optionsForType:function(e,t){this.parent&&u("optionsForType"),this._typeOptions[e]=t},options:function(e,t){t=t||{};var r=this.normalize(e);this._options[r]=t},typeInjection:function(e,t,r){this.parent&&u("typeInjection");var n=r.split(":")[0];if(n===e)throw new Error("Cannot inject a `"+r+"` on other "+e+"(s). Register the `"+r+"` as a different type and perform the typeInjection.");_(this.typeInjections,e,t,r)},injection:function(e,t,r){this.parent&&u("injection"),w(r);var n=this.normalize(r);if(-1===e.indexOf(":"))return this.typeInjection(e,t,n);var i=this.normalize(e);if(this.cache[i])throw new Error("Attempted to register an injection for a type that has already been looked up. ('"+i+"', '"+t+"', '"+r+"')");C(x(this.injections,i),t,n)},factoryTypeInjection:function(e,t,r){this.parent&&u("factoryTypeInjection"),_(this.factoryTypeInjections,e,t,this.normalize(r))},factoryInjection:function(e,t,r){this.parent&&u("injection");var n=this.normalize(e),i=this.normalize(r);if(w(r),-1===e.indexOf(":"))return this.factoryTypeInjection(n,t,i);if(this.factoryCache[n])throw new Error("Attempted to register a factoryInjection for a type that has already been looked up. ('"+n+"', '"+t+"', '"+r+"')");C(x(this.factoryInjections,n),t,i)},destroy:function(){for(var e=0,t=this.children.length;t>e;e++)this.children[e].destroy();this.children=[],g(this,function(e){e.destroy()}),this.parent=void 0,this.isDestroyed=!0},reset:function(){for(var e=0,t=this.children.length;t>e;e++)y(this.children[e]);y(this)}};var A=/^[^:]+.+:[^:]+$/;n["default"]=i}),e("dag-map",["exports"],function(e){"use strict";function t(e,r,n,i){var a,s=e.name,o=e.incoming,u=e.incomingNames,l=u.length;if(n||(n={}),i||(i=[]),!n.hasOwnProperty(s)){for(i.push(s),n[s]=!0,a=0;l>a;a++)t(o[u[a]],r,n,i);r(e,i),i.pop()}}function r(){this.names=[],this.vertices=Object.create(null)}function n(e){this.name=e,this.incoming={},this.incomingNames=[],this.hasOutgoing=!1,this.value=null}r.prototype.add=function(e){if(!e)throw new Error("Can't add Vertex without name");if(void 0!==this.vertices[e])return this.vertices[e];var t=new n(e);return this.vertices[e]=t,this.names.push(e),t},r.prototype.map=function(e,t){this.add(e).value=t},r.prototype.addEdge=function(e,r){function n(e,t){if(e.name===r)throw new Error("cycle detected: "+r+" <- "+t.join(" <- "))}if(e&&r&&e!==r){var i=this.add(e),a=this.add(r);a.incoming.hasOwnProperty(e)||(t(i,n),i.hasOutgoing=!0,a.incoming[e]=i,a.incomingNames.push(e))}},r.prototype.topsort=function(e){var r,n,i={},a=this.vertices,s=this.names,o=s.length;for(r=0;o>r;r++)n=a[s[r]],n.hasOutgoing||t(n,e,i)},r.prototype.addEdges=function(e,t,r,n){var i;if(this.map(e,t),r)if("string"==typeof r)this.addEdge(e,r);else for(i=0;ii;i++)n=r[i],-1===n.indexOf(":")&&(n="controller:"+n),t.has(n)||s.push(n);if(s.length)throw new c(h(e)+" needs [ "+s.join(", ")+" ] but "+(s.length>1?"they":"it")+" could not be found")}var l=(e["default"],t.get),c=r["default"],h=n.inspect,m=i.computed,p=a["default"],f=(n.meta,s["default"]),d=m(function(){var e=this;return{needs:l(e,"needs"),container:l(e,"container"),unknownProperty:function(t){var r,n,i,a=this.needs;for(n=0,i=a.length;i>n;n++)if(r=a[n],r===t)return this.container.lookup("controller:"+t);var s=h(e)+"#needs does not include `"+t+"`. To access the "+t+" controller from "+h(e)+", "+h(e)+" should have a `needs` property that is an array of the controllers it has access to.";throw new ReferenceError(s)},setUnknownProperty:function(t){throw new Error("You cannot overwrite the value of `controllers."+t+"` of "+h(e))}}});p.reopen({concatenatedProperties:["needs"],needs:[],init:function(){var e=l(this,"needs"),t=l(e,"length");t>0&&(this.container&&u(this,this.container,e),l(this,"controllers")),this._super.apply(this,arguments)},controllerFor:function(e){return f(l(this,"container"),e)},controllers:d}),o["default"]=p}),e("ember-application/system/application",["dag-map","container/container","ember-metal","ember-metal/property_get","ember-metal/property_set","ember-runtime/system/lazy_load","ember-runtime/system/namespace","ember-runtime/mixins/deferred","ember-application/system/resolver","ember-metal/platform","ember-metal/run_loop","ember-metal/utils","ember-runtime/controllers/controller","ember-metal/enumerable_utils","ember-runtime/controllers/object_controller","ember-runtime/controllers/array_controller","ember-views/views/select","ember-views/system/event_dispatcher","ember-views/system/jquery","ember-routing/system/route","ember-routing/system/router","ember-routing/location/hash_location","ember-routing/location/history_location","ember-routing/location/auto_location","ember-routing/location/none_location","ember-routing/system/cache","ember-extension-support/container_debug_adapter","ember-metal/core","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m,p,f,d,v,b,g,y,_,w,x,C,E,O,P,A,N){"use strict";function S(e){var t=[];for(var r in e)t.push(r);return t}function T(e){function t(e){return n.resolve(e)}var r=e.get("resolver")||e.get("Resolver")||F,n=r.create({namespace:e});return t.describe=function(e){return n.lookupDescription(e)},t.makeToString=function(e,t){return n.makeToString(e,t)},t.normalize=function(e){return n.normalize?n.normalize(e):e},t.__resolver__=n,t}var k=e["default"],V=t["default"],I=r["default"],j=n.get,M=i.set,R=a.runLoadHooks,D=s["default"],L=o["default"],F=u["default"],B=l.create,H=c["default"],z=(h.canInvoke,m["default"]),q=p["default"],U=f["default"],W=d["default"],K=v["default"],G=b["default"],Q=g["default"],$=y["default"],Y=_["default"],X=w["default"],Z=x["default"],J=C["default"],et=E["default"],tt=O["default"],rt=P["default"],nt=A.K,it=!1,at=D.extend(L,{_suppressDeferredDeprecation:!0,rootElement:"body",eventDispatcher:null,customEvents:null,init:function(){if(this._readinessDeferrals=1,this.$||(this.$=Q),this.__container__=this.buildContainer(),this.Router=this.defaultRouter(),this._super(),this.scheduleInitialize(),it||(it=!0,I.libraries.registerCoreLibrary("jQuery",Q().jquery)),I.LOG_VERSION){I.LOG_VERSION=!1;for(var e=I.libraries._registry,t=q.map(e,function(e){return j(e,"name.length")}),r=Math.max.apply(this,t),n=0,i=e.length;i>n;n++){var a=e[n];new Array(r-a.name.length+1).join(" ")}}},buildContainer:function(){var e=this.__container__=at.buildContainer(this);return e},defaultRouter:function(){if(this.Router!==!1){var e=this.__container__;return this.Router&&(e.unregister("router:main"),e.register("router:main",this.Router)),e.lookupFactory("router:main")}},scheduleInitialize:function(){!this.$||this.$.isReady?H.schedule("actions",this,"_initialize"):this.$().ready(I.run.bind(this,"_initialize"))},deferReadiness:function(){this._readinessDeferrals++},advanceReadiness:function(){this._readinessDeferrals--,0===this._readinessDeferrals&&H.once(this,this.didBecomeReady)},register:function(){var e=this.__container__;e.register.apply(e,arguments)},inject:function(){var e=this.__container__;e.injection.apply(e,arguments)},initialize:function(){},_initialize:function(){if(!this.isDestroyed){if(this.Router){var e=this.__container__;e.unregister("router:main"),e.register("router:main",this.Router)}return this.runInitializers(),R("application",this),this.advanceReadiness(),this}},reset:function(){function e(){var e=this.__container__.lookup("router:main");e.reset(),H(this.__container__,"destroy"),this.buildContainer(),H.schedule("actions",this,"_initialize")}this._readinessDeferrals=1,H.join(this,e)},runInitializers:function(){for(var e,t=j(this.constructor,"initializers"),r=S(t),n=this.__container__,i=new k,a=this,s=0;s-1&&(i=i.replace(/\.(.)/g,function(e){return e.charAt(1).toUpperCase()})),n.indexOf("_")>-1&&(i=i.replace(/_(.)/g,function(e){return e.charAt(1).toUpperCase()})),r+":"+i}return e},resolve:function(e){var t,r=this.parseName(e),n=r.resolveMethodName;if(!r.name||!r.type)throw new TypeError("Invalid fullName: `"+e+"`, must be of the form `type:name` ");return this[n]&&(t=this[n](r)),t||(t=this.resolveOther(r)),r.root&&r.root.LOG_RESOLVER&&this._logLookup(t,r),t},parseName:function(e){return this._parseNameCache[e]||(this._parseNameCache[e]=this._parseName(e))},_parseName:function(e){var t=e.split(":"),r=t[0],n=t[1],i=n,a=c(this,"namespace"),s=a;if("template"!==r&&-1!==i.indexOf("/")){var o=i.split("/");i=o[o.length-1];var u=p(o.slice(0,-1).join("."));s=v.byName(u)}return{fullName:e,type:r,fullNameWithoutType:n,name:i,root:s,resolveMethodName:"resolve"+m(r)}},lookupDescription:function(e){var t,r=this.parseName(e);return"template"===r.type?"template at "+r.fullNameWithoutType.replace(/\./g,"/"):(t=r.root+"."+m(r.name).replace(/\./g,""),"model"!==r.type&&(t+=m(r.type)),t)},makeToString:function(e){return e.toString()},useRouterNaming:function(e){e.name=e.name.replace(/\./g,"_"),"basic"===e.name&&(e.name="")},resolveTemplate:function(e){var t=e.fullNameWithoutType.replace(/\./g,"/");return l.TEMPLATES[t]?l.TEMPLATES[t]:(t=f(t),l.TEMPLATES[t]?l.TEMPLATES[t]:void 0)},resolveView:function(e){return this.useRouterNaming(e),this.resolveOther(e)},resolveController:function(e){return this.useRouterNaming(e),this.resolveOther(e)},resolveRoute:function(e){return this.useRouterNaming(e),this.resolveOther(e)},resolveModel:function(e){var t=m(e.name),r=c(e.root,t);return r?r:void 0},resolveHelper:function(e){return this.resolveOther(e)||b[e.fullNameWithoutType]},resolveOther:function(e){var t=m(e.name)+m(e.type),r=c(e.root,t);return r?r:void 0},_logLookup:function(e,t){var r,n;r=e?"[✓]":"[ ]",n=t.fullName.length>60?".":new Array(60-t.fullName.length).join("."),h.info(r,t.fullName,n,this.lookupDescription(t.fullName))}})}),e("ember-extension-support",["ember-metal/core","ember-extension-support/data_adapter","ember-extension-support/container_debug_adapter"],function(e,t,r){"use strict";var n=e["default"],i=t["default"],a=r["default"];n.DataAdapter=i,n.ContainerDebugAdapter=a}),e("ember-extension-support/container_debug_adapter",["ember-metal/core","ember-runtime/system/native_array","ember-metal/utils","ember-runtime/system/string","ember-runtime/system/namespace","ember-runtime/system/object","exports"],function(e,t,r,n,i,a,s){"use strict";var o=e["default"],u=t.A,l=r.typeOf,c=n.dasherize,h=n.classify,m=i["default"],p=a["default"];s["default"]=p.extend({container:null,resolver:null,canCatalogEntriesByType:function(e){return"model"===e||"template"===e?!1:!0},catalogEntriesByType:function(e){var t=u(m.NAMESPACES),r=u(),n=new RegExp(h(e)+"$");return t.forEach(function(e){if(e!==o)for(var t in e)if(e.hasOwnProperty(t)&&n.test(t)){var i=e[t];"class"===l(i)&&r.push(c(t.replace(n,"")))}}),r}})}),e("ember-extension-support/data_adapter",["ember-metal/property_get","ember-metal/run_loop","ember-runtime/system/string","ember-runtime/system/namespace","ember-runtime/system/object","ember-runtime/system/native_array","ember-application/system/application","exports"],function(e,t,r,n,i,a,s,o){"use strict";var u=e.get,l=t["default"],c=r.dasherize,h=n["default"],m=i["default"],p=a.A,f=s["default"];o["default"]=m.extend({init:function(){this._super(),this.releaseMethods=p()},container:null,containerDebugAdapter:void 0,attributeLimit:3,releaseMethods:p(),getFilters:function(){return p()},watchModelTypes:function(e,t){var r,n=this.getModelTypes(),i=this,a=p();r=n.map(function(e){var r=e.klass,n=i.wrapModelType(r,e.name);return a.push(i.observeModelType(r,t)),n}),e(r);var s=function(){a.forEach(function(e){e()}),i.releaseMethods.removeObject(s)};return this.releaseMethods.pushObject(s),s},_nameToClass:function(e){return"string"==typeof e&&(e=this.container.lookupFactory("model:"+e)),e},watchRecords:function(e,t,r,n){var i,a=this,s=p(),o=this.getRecords(e),u=function(e){r([e])},l=o.map(function(e){return s.push(a.observeRecord(e,u)),a.wrapRecord(e)}),c=function(e,r,i,o){for(var l=r;r+o>l;l++){var c=e.objectAt(l),h=a.wrapRecord(c);
-s.push(a.observeRecord(c,u)),t([h])}i&&n(r,i)},h={didChange:c,willChange:function(){return this}};return o.addArrayObserver(a,h),i=function(){s.forEach(function(e){e()}),o.removeArrayObserver(a,h),a.releaseMethods.removeObject(i)},t(l),this.releaseMethods.pushObject(i),i},willDestroy:function(){this._super(),this.releaseMethods.forEach(function(e){e()})},detect:function(){return!1},columnsForType:function(){return p()},observeModelType:function(e,t){var r=this,n=this.getRecords(e),i=function(){t([r.wrapModelType(e)])},a={didChange:function(){l.scheduleOnce("actions",this,i)},willChange:function(){return this}};n.addArrayObserver(this,a);var s=function(){n.removeArrayObserver(r,a)};return s},wrapModelType:function(e,t){var r,n=this.getRecords(e);return r={name:t||e.toString(),count:u(n,"length"),columns:this.columnsForType(e),object:e}},getModelTypes:function(){var e,t=this,r=this.get("containerDebugAdapter");return e=r.canCatalogEntriesByType("model")?r.catalogEntriesByType("model"):this._getObjectsOnNamespaces(),e=p(e).map(function(e){return{klass:t._nameToClass(e),name:e}}),e=p(e).filter(function(e){return t.detect(e.klass)}),p(e)},_getObjectsOnNamespaces:function(){var e=p(h.NAMESPACES),t=p(),r=this;return e.forEach(function(e){for(var n in e)if(e.hasOwnProperty(n)&&r.detect(e[n])){var i=c(n);e instanceof f||!e.toString()||(i=e+"/"+i),t.push(i)}}),t},getRecords:function(){return p()},wrapRecord:function(e){var t={object:e};return t.columnValues=this.getRecordColumnValues(e),t.searchKeywords=this.getRecordKeywords(e),t.filterValues=this.getRecordFilterValues(e),t.color=this.getRecordColor(e),t},getRecordColumnValues:function(){return{}},getRecordKeywords:function(){return p()},getRecordFilterValues:function(){return{}},getRecordColor:function(){return null},observeRecord:function(){return function(){}}})}),e("ember-htmlbars",["ember-metal/core","ember-template-compiler","ember-htmlbars/hooks/inline","ember-htmlbars/hooks/content","ember-htmlbars/hooks/component","ember-htmlbars/hooks/block","ember-htmlbars/hooks/element","ember-htmlbars/hooks/subexpr","ember-htmlbars/hooks/attribute","ember-htmlbars/hooks/concat","ember-htmlbars/hooks/get","ember-htmlbars/hooks/set","morph","ember-htmlbars/system/make-view-helper","ember-htmlbars/system/make_bound_helper","ember-htmlbars/helpers","ember-htmlbars/helpers/binding","ember-htmlbars/helpers/view","ember-htmlbars/helpers/yield","ember-htmlbars/helpers/with","ember-htmlbars/helpers/log","ember-htmlbars/helpers/debugger","ember-htmlbars/helpers/bind-attr","ember-htmlbars/helpers/if_unless","ember-htmlbars/helpers/loc","ember-htmlbars/helpers/partial","ember-htmlbars/helpers/template","ember-htmlbars/helpers/input","ember-htmlbars/helpers/text_area","ember-htmlbars/helpers/collection","ember-htmlbars/helpers/each","ember-htmlbars/helpers/unbound","ember-htmlbars/system/bootstrap","ember-htmlbars/compat","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m,p,f,d,v,b,g,y,_,w,x,C,E,O,P,A,N,S,T,k,V,I,j){"use strict";var M=e["default"],R=t.precompile,D=t.compile,L=t.template,F=t.registerPlugin,B=r["default"],H=n["default"],z=i["default"],q=a["default"],U=s["default"],W=o["default"],K=u["default"],G=l["default"],Q=c["default"],$=h["default"],Y=m.DOMHelper,X=p["default"],Z=f["default"],J=d.registerHelper,et=d["default"],tt=v.bindHelper,rt=b.viewHelper,nt=g.yieldHelper,it=y.withHelper,at=_.logHelper,st=w.debuggerHelper,ot=x.bindAttrHelper,ut=x.bindAttrHelperDeprecated,lt=C.ifHelper,ct=C.unlessHelper,ht=C.unboundIfHelper,mt=C.boundIfHelper,pt=E.locHelper,ft=O.partialHelper,dt=P.templateHelper,vt=A.inputHelper,bt=N.textareaHelper,gt=S.collectionHelper,yt=T.eachHelper,_t=k.unboundHelper;J("bindHelper",tt),J("bind",tt),J("view",rt),J("yield",nt),J("with",it),J("if",lt),J("unless",ct),J("unboundIf",ht),J("boundIf",mt),J("log",at),J("debugger",st),J("loc",pt),J("partial",ft),J("template",dt),J("bind-attr",ot),J("bindAttr",ut),J("input",vt),J("textarea",bt),J("collection",gt),J("each",yt),J("unbound",_t),J("concat",G),M.HTMLBars={_registerHelper:J,template:L,compile:D,precompile:R,makeViewHelper:X,makeBoundHelper:Z,registerPlugin:F};var wt={dom:new Y,hooks:{get:Q,set:$,inline:B,content:H,block:q,element:U,subexpr:W,component:z,attribute:K,concat:G},helpers:et,useFragmentCache:!0};j.defaultEnv=wt}),e("ember-htmlbars/compat",["ember-metal/core","ember-htmlbars/helpers","ember-htmlbars/compat/helper","ember-htmlbars/compat/handlebars-get","ember-htmlbars/compat/make-bound-helper","ember-htmlbars/compat/register-bound-helper","ember-htmlbars/system/make-view-helper","ember-htmlbars/utils/string","exports"],function(e,t,r,n,i,a,s,o,u){"use strict";var l,c=e["default"],h=t["default"],m=r.registerHandlebarsCompatibleHelper,p=r.handlebarsHelper,f=n["default"],d=i["default"],v=a["default"],b=s["default"],g=o.SafeString,y=o.escapeExpression;l=c.Handlebars=c.Handlebars||{},l.helpers=h,l.helper=p,l.registerHelper=m,l.registerBoundHelper=v,l.makeBoundHelper=d,l.get=f,l.makeViewHelper=b,l.SafeString=g,l.Utils={escapeExpression:y},u["default"]=l}),e("ember-htmlbars/compat/handlebars-get",["exports"],function(e){"use strict";e["default"]=function(e,t,r){return r.data.view.getStream(t).value()}}),e("ember-htmlbars/compat/helper",["ember-metal/merge","ember-htmlbars/helpers","ember-views/views/view","ember-views/views/component","ember-htmlbars/system/make-view-helper","ember-htmlbars/compat/make-bound-helper","ember-metal/streams/utils","exports"],function(e,t,r,n,i,a,s,o){"use strict";function u(e){if(b(e))return"ID";var t=typeof e;return t.toUpperCase()}function l(e){this.helperFunction=function(t,r,n,i){var a,s,o,l=this,c={hash:{},types:new Array(t.length),hashTypes:{}};m(c,n),m(c,i),c.hash={},n.isBlock&&(c.fn=function(){s=n.template.render(l,i,n.morph.contextualElement)});for(var h in r)a=r[h],c.hashTypes[h]=u(a),c.hash[h]=b(a)?a._label:a;for(var p=new Array(t.length),f=0,d=t.length;d>f;f++)a=t[f],c.types[f]=u(a),p[f]=b(a)?a._label:a;return p.push(c),o=e.apply(this,p),n.isBlock?s:o},this.isHTMLBars=!0}function c(e,t){var r;r=t&&t.isHTMLBars?t:new l(t),p[e]=r}function h(e,t){if(f.detect(t))p[e]=d(t);else{var r=g.call(arguments,1),n=v.apply(this,r);p[e]=n}}var m=e["default"],p=t["default"],f=r["default"],d=(n["default"],i["default"]),v=a["default"],b=s.isStream,g=[].slice;l.prototype={preprocessArguments:function(){}},o.registerHandlebarsCompatibleHelper=c,o.handlebarsHelper=h,o["default"]=l}),e("ember-htmlbars/compat/make-bound-helper",["ember-metal/core","ember-metal/mixin","ember-htmlbars/system/helper","ember-metal/streams/stream","ember-metal/streams/utils","exports"],function(e,t,r,n,i,a){"use strict";var s=(e["default"],t.IS_BINDING),o=r["default"],u=n["default"],l=i.readArray,c=i.scanArray,h=i.scanHash,m=i.readHash,p=i.isStream;a["default"]=function(e){function t(t,i,a,o){function f(){for(var r=l(t),n=new Array(t.length),a=0,s=t.length;s>a;a++)d=t[a],n[a]=p(d)?d._label:d;return r.push({hash:m(i),data:{properties:n}}),e.apply(v,r)}var d,v=this,b=t.length;for(var g in i)s.test(g)&&(i[g.slice(0,-7)]=v.getStream(i[g]),delete i[g]);var y=c(t)||h(i);if(o.data.isUnbound||!y)return f();var _=new u(f);for(n=0;b>n;n++)d=t[n],p(d)&&d.subscribe(_.notify,_);for(g in i)d=i[g],p(d)&&d.subscribe(_.notify,_);if(b>0){var w=t[0];if(p(w)){var x=function(e){e.value(),_.notify()};for(n=0;nb;b++)u=v[b],"class"!==u&&(l=t[u],c=g(l)?l:a.getStream(l),m=new f(u,c),m._morph=n.dom.createAttrMorph(i,u),a.appendChild(m))}function h(e,t){var r=e.split(" "),n=b(r,function(e){return _(t,e)}),i=y(n," ");return i}function m(){return v["bind-attr"].helperFunction.apply(this,arguments)}var p=(e["default"],t.fmt,r["default"]),f=n["default"],d=i["default"],v=a["default"],b=s.map,g=o.isStream,y=o.concat,_=u.streamifyClassNameBinding;l["default"]=c,l.bindAttrHelper=c,l.bindAttrHelperDeprecated=m}),e("ember-htmlbars/helpers/binding",["ember-metal/is_none","ember-metal/run_loop","ember-metal/property_get","ember-metal/streams/simple","ember-views/views/bound_view","ember-metal/streams/utils","exports"],function(e,t,r,n,i,a,s){"use strict";function o(e){return!c(e)}function u(e,t,r,n,i,a,s,o,u){var l,c=d(e)?e:this.getStream(e);if(o){l=new p(c);for(var v=function(e){e.value(),l.notify()},b=0;b=2){n.data.isUnbound=!0;for(var l=e[0]._label,c=[],h=1,m=e.length;m>h;h++){var p=s(e[h]);c.push(p)}var f=a(l,this,n);if(!f)throw new o("HTMLBars error: Could not find component or helper named "+l+".");i=f.helperFunction.call(this,c,t,r,n),delete n.data.isUnbound}return i}var a=e["default"],s=t.read,o=r["default"];n.unboundHelper=i}),e("ember-htmlbars/helpers/view",["ember-metal/core","ember-runtime/system/object","ember-metal/property_get","ember-metal/streams/simple","ember-metal/keys","ember-metal/mixin","ember-metal/streams/utils","ember-views/streams/utils","ember-views/views/view","ember-metal/enumerable_utils","ember-views/streams/class_name_binding","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h){"use strict";function m(e,t,r){for(var n in e){var i=e[n];"class"===n&&_(i)?(e.classBinding=i._label,delete e["class"]):"classBinding"!==n&&(g.test(n)?_(i)||"string"==typeof i&&(e[n]=r._getBindingForStream(i)):_(i)&&"id"!==n&&(e[n+"Binding"]=r._getBindingForStream(i),delete e[n]))}}function p(e,t,r,n){var i,a=this.container||y(this._keywords.view).container;if(0===e.length)i=a?a.lookupFactory("view:toplevel"):x;else{var s=e[0];i=w(s,a)}return r.helperName=r.helperName||"view",O.helper(i,t,r,n)}var f=(e["default"],t["default"]),d=r.get,v=n["default"],b=i["default"],g=a.IS_BINDING,y=s.read,_=s.isStream,w=o.readViewFactory,x=u["default"],C=l.map,E=c.streamifyClassNameBinding,O=f.create({propertiesFromHTMLOptions:function(e,t,r){var n=r.data.view,i=y(e["class"]),a={helperName:t.helperName||""};e.id&&(a.elementId=y(e.id)),e.tag&&(a.tagName=e.tag),i&&(i=i.split(" "),a.classNames=i),e.classBinding&&(a.classNameBindings=e.classBinding.split(" ")),e.classNameBindings&&(void 0===a.classNameBindings&&(a.classNameBindings=[]),a.classNameBindings=a.classNameBindings.concat(e.classNameBindings.split(" "))),e.attributeBindings&&(a.attributeBindings=null);for(var s=b(e),o=0,u=s.length;u>o;o++){var l=s[o];"classNameBindings"!==l&&(a[l]=e[l])}return a.classNameBindings&&(a.classNameBindings=C(a.classNameBindings,function(e){var t=E(n,e);return _(t)?t:new v(t)})),a},helper:function(e,t,r,n){var i,a=n.data,s=r.template;m(t,r,n.data.view);var o=this.propertiesFromHTMLOptions(t,r,n),u=a.view;i=x.detectInstance(e)?e:e.proto(),s&&(o.template=s),i.controller||i.controllerBinding||o.controller||o.controllerBinding||(o._context=d(u,"context")),o._morph=r.morph,u.appendChild(e,o)},instanceHelper:function(e,t,r,n){var i=n.data,a=r.template;m(t,r,n.data.view);var s=this.propertiesFromHTMLOptions(t,r,n),o=i.view;a&&(s.template=a),e.controller||e.controllerBinding||s.controller||s.controllerBinding||(s._context=d(o,"context")),s._morph=r.morph,o.appendChild(e,s)}});h.ViewHelper=O,h.viewHelper=p}),e("ember-htmlbars/helpers/with",["ember-metal/core","ember-metal/is_none","ember-htmlbars/helpers/binding","ember-views/views/with_view","exports"],function(e,t,r,n,i){"use strict";function a(e,t,r,n){var i;i=r.template.blockParams?!0:!1,u.call(this,e[0],t,r,n,i,s,void 0,void 0,l)}function s(e){return!o(e)}var o=(e["default"],t["default"]),u=r.bind,l=n["default"];i.withHelper=a}),e("ember-htmlbars/helpers/yield",["ember-metal/core","ember-metal/property_get","exports"],function(e,t,r){"use strict";function n(e,t,r,n){for(var a=this;a&&!i(a,"layout");)a=a._contextView?a._contextView:i(a,"_parentView");return a._yield(this,n,r.morph,e)}var i=(e["default"],t.get);r.yieldHelper=n}),e("ember-htmlbars/hooks/attribute",["ember-views/attr_nodes/attr_node","ember-metal/error","ember-metal/streams/utils","ember-views/system/sanitize_attribute_value","exports"],function(e,t,r,n,i){"use strict";var a=e["default"],s=t["default"],o=r.isStream,u=n["default"],l=!1;i["default"]=function(e,t,r,n,i){if(l){var c=new a(n,i);c._morph=t,e.data.view.appendChild(c)}else{if(o(i))throw new s("Bound attributes are not yet supported in Ember.js");var h=u(r,n,i);e.dom.setProperty(r,n,h)}}}),e("ember-htmlbars/hooks/block",["ember-views/views/simple_bound_view","ember-metal/streams/utils","ember-htmlbars/system/lookup-helper","exports"],function(e,t,r,n){"use strict";var i=e.appendSimpleBoundView,a=t.isStream,s=r["default"];n["default"]=function(e,t,r,n,o,u,l,c){var h=s(n,r,e),m={morph:t,template:l,inverse:c,isBlock:!0},p=h.helperFunction.call(r,o,u,m,e);a(p)?i(r,t,p):t.setContent(p)}}),e("ember-htmlbars/hooks/component",["ember-metal/core","ember-htmlbars/system/lookup-helper","exports"],function(e,t,r){"use strict";var n=(e["default"],t["default"]);r["default"]=function(e,t,r,i,a,s){var o=n(i,r,e);return o.helperFunction.call(r,[],a,{morph:t,template:s},e)}}),e("ember-htmlbars/hooks/concat",["ember-metal/streams/utils","exports"],function(e,t){"use strict";var r=e.concat;t["default"]=function(e,t){return r(t,"")}}),e("ember-htmlbars/hooks/content",["ember-views/views/simple_bound_view","ember-metal/streams/utils","ember-htmlbars/system/lookup-helper","exports"],function(e,t,r,n){"use strict";var i=e.appendSimpleBoundView,a=t.isStream,s=r["default"];n["default"]=function(e,t,r,n){var o,u=s(n,r,e);if(u){var l={morph:t,isInline:!0};o=u.helperFunction.call(r,[],{},l,e)}else o=r.getStream(n);a(o)?i(r,t,o):t.setContent(o)}}),e("ember-htmlbars/hooks/element",["ember-metal/core","ember-metal/streams/utils","ember-htmlbars/system/lookup-helper","exports"],function(e,t,r,n){"use strict";var i=(e["default"],t.read),a=r["default"];n["default"]=function(e,t,r,n,s,o){var u,l=a(n,r,e);if(l){var c={element:t};u=l.helperFunction.call(r,s,o,c,e)}else u=r.getStream(n);var h=i(u);if(h)for(var m=h.toString().split(/\s+/),p=0,f=m.length;f>p;p++){var d=m[p].split("="),v=d[0],b=d[1];b=b.replace(/^['"]/,"").replace(/['"]$/,""),e.dom.setAttribute(t,v,b)}}}),e("ember-htmlbars/hooks/get",["exports"],function(e){"use strict";e["default"]=function(e,t,r){return t.getStream(r)}}),e("ember-htmlbars/hooks/inline",["ember-views/views/simple_bound_view","ember-metal/streams/utils","ember-htmlbars/system/lookup-helper","exports"],function(e,t,r,n){"use strict";var i=e.appendSimpleBoundView,a=t.isStream,s=r["default"];n["default"]=function(e,t,r,n,o,u){var l=s(n,r,e),c=l.helperFunction.call(r,o,u,{morph:t},e);a(c)?i(r,t,c):t.setContent(c)}}),e("ember-htmlbars/hooks/set",["ember-metal/core","ember-metal/error","exports"],function(e,t,r){"use strict";e["default"],t["default"];r["default"]=function(e,t,r,n){t._keywords[r]=n}}),e("ember-htmlbars/hooks/subexpr",["ember-htmlbars/system/lookup-helper","exports"],function(e,t){"use strict";var r=e["default"];t["default"]=function(e,t,n,i,a){var s=r(n,t,e),o={isInline:!0};return s.helperFunction.call(t,i,a,o,e)}}),e("ember-htmlbars/system/bootstrap",["ember-metal/core","ember-views/component_lookup","ember-views/system/jquery","ember-metal/error","ember-runtime/system/lazy_load","ember-template-compiler/system/compile","exports"],function(e,t,r,n,i,a,s){"use strict";function o(e){var t='script[type="text/x-handlebars"], script[type="text/x-raw-handlebars"]';m(t,e).each(function(){var e=m(this),t="text/x-raw-handlebars"===e.attr("type")?m.proxy(Handlebars.compile,Handlebars):d,r=e.attr("data-template-name")||e.attr("id")||"application",n=t(e.html());if(void 0!==c.TEMPLATES[r])throw new p('Template named "'+r+'" already exists.');c.TEMPLATES[r]=n,e.remove()})}function u(){o(m(document))}function l(e){e.register("component-lookup:main",h)}var c=e["default"],h=t["default"],m=r["default"],p=n["default"],f=i.onLoad,d=a["default"];f("Ember.Application",function(e){e.initializer({name:"domTemplates",initialize:u}),e.initializer({name:"registerComponentLookup",after:"domTemplates",initialize:l})}),s["default"]=o}),e("ember-htmlbars/system/helper",["exports"],function(e){"use strict";function t(e){this.helperFunction=e,this.isHelper=!0,this.isHTMLBars=!0}e["default"]=t}),e("ember-htmlbars/system/lookup-helper",["ember-metal/core","ember-metal/cache","ember-htmlbars/system/make-view-helper","ember-htmlbars/compat/helper","exports"],function(e,t,r,n,i){"use strict";var a=(e["default"],t["default"]),s=r["default"],o=n["default"],u=new a(1e3,function(e){return-1===e.indexOf("-")});i.ISNT_HELPER_CACHE=u,i["default"]=function(e,t,r){var n=r.helpers[e];if(n)return n;var i=t.container;if(i&&!u.get(e)){var a="helper:"+e;if(n=i.lookup(a),!n){var l=i.lookup("component-lookup:main"),c=l.lookupFactory(e,i);c&&(n=s(c),i.register(a,n))}return n&&!n.isHTMLBars&&(n=new o(n),i.unregister(a),i.register(a,n)),n}}}),e("ember-htmlbars/system/make-view-helper",["ember-metal/core","ember-htmlbars/system/helper","exports"],function(e,t,r){"use strict";var n=(e["default"],t["default"]);r["default"]=function(e){function t(t,r,n,i){return i.helpers.view.helperFunction.call(this,[e],r,n,i)}return new n(t)}}),e("ember-htmlbars/system/make_bound_helper",["ember-metal/core","ember-htmlbars/system/helper","ember-metal/streams/stream","ember-metal/streams/utils","exports"],function(e,t,r,n,i){"use strict";var a=(e["default"],t["default"]),s=r["default"],o=n.readArray,u=n.readHash,l=n.subscribe,c=n.scanHash,h=n.scanArray;i["default"]=function(e){function t(t,r,n,i){function a(){return e.call(f,o(t),u(r),n,i)}var m,p,f=this,d=t.length,v=h(t)||c(r);if(i.data.isUnbound||!v)return a();for(var b=new s(a),g=0;d>g;g++)m=t[g],l(m,b.notify,b);for(p in r)m=r[p],l(m,b.notify,b);return b}return new a(t)}}),e("ember-htmlbars/templates/component",["ember-template-compiler/system/template","exports"],function(e,t){"use strict";var r=e["default"],n=function(){return{isHTMLBars:!0,blockParams:0,cachedFragment:null,hasRendered:!1,build:function(e){var t=e.createDocumentFragment(),r=e.createTextNode("");e.appendChild(t,r);var r=e.createTextNode("");return e.appendChild(t,r),t},render:function(e,t,r){var n=t.dom,i=t.hooks,a=i.content;n.detectNamespace(r);var s;t.useFragmentCache&&n.canClone?(null===this.cachedFragment&&(s=this.build(n),this.hasRendered?this.cachedFragment=s:this.hasRendered=!0),this.cachedFragment&&(s=n.cloneNode(this.cachedFragment,!0))):s=this.build(n),this.cachedFragment&&n.repairClonedNode(s,[0,1]);var o=n.createMorphAt(s,0,1,r);return a(t,o,e,"yield"),s}}}();t["default"]=r(n)}),e("ember-htmlbars/templates/link-to-escaped",["ember-template-compiler/system/template","exports"],function(e,t){"use strict";var r=e["default"],n=function(){return{isHTMLBars:!0,blockParams:0,cachedFragment:null,hasRendered:!1,build:function(e){var t=e.createDocumentFragment(),r=e.createTextNode("");e.appendChild(t,r);var r=e.createTextNode("");return e.appendChild(t,r),t},render:function(e,t,r){var n=t.dom,i=t.hooks,a=i.content;n.detectNamespace(r);var s;t.useFragmentCache&&n.canClone?(null===this.cachedFragment&&(s=this.build(n),this.hasRendered?this.cachedFragment=s:this.hasRendered=!0),this.cachedFragment&&(s=n.cloneNode(this.cachedFragment,!0))):s=this.build(n),this.cachedFragment&&n.repairClonedNode(s,[0,1]);var o=n.createMorphAt(s,0,1,r);return a(t,o,e,"linkTitle"),s}}}();t["default"]=r(n)}),e("ember-htmlbars/templates/link-to-unescaped",["ember-template-compiler/system/template","exports"],function(e,t){"use strict";var r=e["default"],n=function(){return{isHTMLBars:!0,blockParams:0,cachedFragment:null,hasRendered:!1,build:function(e){var t=e.createDocumentFragment(),r=e.createTextNode("");e.appendChild(t,r);var r=e.createTextNode("");return e.appendChild(t,r),t},render:function(e,t,r){var n=t.dom,i=t.hooks,a=i.content;n.detectNamespace(r);var s;t.useFragmentCache&&n.canClone?(null===this.cachedFragment&&(s=this.build(n),this.hasRendered?this.cachedFragment=s:this.hasRendered=!0),this.cachedFragment&&(s=n.cloneNode(this.cachedFragment,!0))):s=this.build(n),this.cachedFragment&&n.repairClonedNode(s,[0,1]);var o=n.createUnsafeMorphAt(s,0,1,r);return a(t,o,e,"linkTitle"),s}}}();t["default"]=r(n)}),e("ember-htmlbars/templates/select",["ember-template-compiler/system/template","exports"],function(e,t){"use strict";var r=e["default"],n=function(){var e=function(){return{isHTMLBars:!0,blockParams:0,cachedFragment:null,hasRendered:!1,build:function(e){var t=e.createElement("option");return e.setAttribute(t,"value",""),t},render:function(e,t,r){var n=t.dom,i=t.hooks,a=i.content;n.detectNamespace(r);var s;t.useFragmentCache&&n.canClone?(null===this.cachedFragment&&(s=this.build(n),this.hasRendered?this.cachedFragment=s:this.hasRendered=!0),this.cachedFragment&&(s=n.cloneNode(this.cachedFragment,!0))):s=this.build(n);var o=n.createMorphAt(s,-1,-1);return a(t,o,e,"view.prompt"),s}}}(),t=function(){var e=function(){return{isHTMLBars:!0,blockParams:0,cachedFragment:null,hasRendered:!1,build:function(e){var t=e.createDocumentFragment(),r=e.createTextNode("");e.appendChild(t,r);var r=e.createTextNode("");return e.appendChild(t,r),t},render:function(e,t,r){var n=t.dom,i=t.hooks,a=i.get,s=i.inline;n.detectNamespace(r);var o;t.useFragmentCache&&n.canClone?(null===this.cachedFragment&&(o=this.build(n),this.hasRendered?this.cachedFragment=o:this.hasRendered=!0),this.cachedFragment&&(o=n.cloneNode(this.cachedFragment,!0))):o=this.build(n),this.cachedFragment&&n.repairClonedNode(o,[0,1]);var u=n.createMorphAt(o,0,1,r);return s(t,u,e,"view",[a(t,e,"view.groupView")],{content:a(t,e,"group.content"),label:a(t,e,"group.label")}),o}}}();return{isHTMLBars:!0,blockParams:0,cachedFragment:null,hasRendered:!1,build:function(e){var t=e.createDocumentFragment(),r=e.createTextNode("");e.appendChild(t,r);var r=e.createTextNode("");return e.appendChild(t,r),t},render:function(t,r,n){var i=r.dom,a=r.hooks,s=a.get,o=a.block;i.detectNamespace(n);var u;r.useFragmentCache&&i.canClone?(null===this.cachedFragment&&(u=this.build(i),this.hasRendered?this.cachedFragment=u:this.hasRendered=!0),this.cachedFragment&&(u=i.cloneNode(this.cachedFragment,!0))):u=this.build(i),this.cachedFragment&&i.repairClonedNode(u,[0,1]);var l=i.createMorphAt(u,0,1,n);return o(r,l,t,"each",[s(r,t,"view.groupedContent")],{keyword:"group"},e,null),u}}}(),r=function(){var e=function(){return{isHTMLBars:!0,blockParams:0,cachedFragment:null,hasRendered:!1,build:function(e){var t=e.createDocumentFragment(),r=e.createTextNode("");e.appendChild(t,r);var r=e.createTextNode("");return e.appendChild(t,r),t},render:function(e,t,r){var n=t.dom,i=t.hooks,a=i.get,s=i.inline;n.detectNamespace(r);var o;t.useFragmentCache&&n.canClone?(null===this.cachedFragment&&(o=this.build(n),this.hasRendered?this.cachedFragment=o:this.hasRendered=!0),this.cachedFragment&&(o=n.cloneNode(this.cachedFragment,!0))):o=this.build(n),this.cachedFragment&&n.repairClonedNode(o,[0,1]);var u=n.createMorphAt(o,0,1,r);return s(t,u,e,"view",[a(t,e,"view.optionView")],{content:a(t,e,"item")}),o}}}();return{isHTMLBars:!0,blockParams:0,cachedFragment:null,hasRendered:!1,build:function(e){var t=e.createDocumentFragment(),r=e.createTextNode("");e.appendChild(t,r);var r=e.createTextNode("");return e.appendChild(t,r),t},render:function(t,r,n){var i=r.dom,a=r.hooks,s=a.get,o=a.block;i.detectNamespace(n);var u;r.useFragmentCache&&i.canClone?(null===this.cachedFragment&&(u=this.build(i),this.hasRendered?this.cachedFragment=u:this.hasRendered=!0),this.cachedFragment&&(u=i.cloneNode(this.cachedFragment,!0))):u=this.build(i),this.cachedFragment&&i.repairClonedNode(u,[0,1]);var l=i.createMorphAt(u,0,1,n);return o(r,l,t,"each",[s(r,t,"view.content")],{keyword:"item"},e,null),u}}}();return{isHTMLBars:!0,blockParams:0,cachedFragment:null,hasRendered:!1,build:function(e){var t=e.createDocumentFragment(),r=e.createTextNode("");e.appendChild(t,r);var r=e.createTextNode("");e.appendChild(t,r);var r=e.createTextNode("\n");return e.appendChild(t,r),t},render:function(n,i,a){var s=i.dom,o=i.hooks,u=o.get,l=o.block;s.detectNamespace(a);var c;i.useFragmentCache&&s.canClone?(null===this.cachedFragment&&(c=this.build(s),this.hasRendered?this.cachedFragment=c:this.hasRendered=!0),this.cachedFragment&&(c=s.cloneNode(this.cachedFragment,!0))):c=this.build(s),this.cachedFragment&&s.repairClonedNode(c,[0,1]);
-var h=s.createMorphAt(c,0,1,a),m=s.createMorphAt(c,1,2,a);return l(i,h,n,"if",[u(i,n,"view.prompt")],{},e,null),l(i,m,n,"if",[u(i,n,"view.optionGroupPath")],{},t,r),c}}}();t["default"]=r(n)}),e("ember-htmlbars/utils/string",["htmlbars-util","ember-runtime/system/string","exports"],function(e,t,r){"use strict";function n(e){return null===e||void 0===e?"":("string"!=typeof e&&(e=""+e),new a(e))}var a=e.SafeString,s=e.escapeExpression,o=t["default"];o.htmlSafe=n,(i.EXTEND_PROTOTYPES===!0||i.EXTEND_PROTOTYPES.String)&&(String.prototype.htmlSafe=function(){return n(this)}),r.SafeString=a,r.htmlSafe=n,r.escapeExpression=s}),e("ember-metal-views",["ember-metal-views/renderer","exports"],function(e,t){"use strict";var r=e["default"];t.Renderer=r}),e("ember-metal-views/renderer",["morph","exports"],function(e,t){"use strict";function r(){this._uuid=0,this._views=new Array(2e3),this._queue=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],this._parents=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],this._elements=new Array(17),this._inserts={},this._dom=new u}function n(e,t,r){var n=this._views;n[0]=e;var i=void 0===r?-1:r,a=0,s=1,o=t?t._level+1:0,u=null==t?e:t._root,l=!!u._morph,c=this._queue;c[0]=0;for(var h,m,p,f=1,d=-1,v=this._parents,b=t||null,g=this._elements,y=null,_=null,w=0,x=e;f;){if(g[w]=y,x._morph||(x._morph=null),x._root=u,this.uuid(x),x._level=o+w,x._elementCreated&&this.remove(x,!1,!0),this.willCreateElement(x),_=x._morph&&x._morph.contextualElement,!_&&b&&b._childViewsMorph&&(_=b._childViewsMorph.contextualElement),!_&&x._didCreateElementWithoutMorph&&(_=document.body),y=this.createElement(x,_),v[w++]=d,d=a,b=x,c[f++]=a,h=this.childViews(x))for(m=h.length-1;m>=0;m--)p=h[m],a=s++,n[a]=p,c[f++]=a,x=p;for(a=c[--f],x=n[a];d===a;){if(w--,x._elementCreated=!0,this.didCreateElement(x),l&&this.willInsertElement(x),0===w){f--;break}d=v[w],b=-1===d?t:n[d],this.insertElement(x,b,y,-1),a=c[--f],x=n[a],y=g[w],g[w]=null}}for(this.insertElement(x,t,y,i),m=s-1;m>=0;m--)l&&(n[m]._elementInserted=!0,this.didInsertElement(n[m])),n[m]=null;return y}function i(e,t,r){var n=this.uuid(e);if(this._inserts[n]&&(this.cancelRender(this._inserts[n]),this._inserts[n]=void 0),e._elementCreated){var i,a,s,o,u,l,c,h=[],m=[],p=e._morph;for(h.push(e),i=0;il;l++)o.push(u[l]);for(i=0;il;l++)m.push(u[l]);for(p&&!r&&p.destroy(),i=0,a=h.length;a>i;i++)this.afterRemove(h[i],!1);for(i=0,a=m.length;a>i;i++)this.afterRemove(m[i],!0);r&&(e._morph=p)}}function a(e,t,r,n){null!==r&&void 0!==r&&(e._morph?e._morph.setContent(r):t&&(e._morph=-1===n?t._childViewsMorph.append(r):t._childViewsMorph.insert(n,r)))}function s(e){e._elementCreated&&this.willDestroyElement(e),e._elementInserted&&this.willRemoveElement(e)}function o(e,t){e._elementInserted=!1,e._morph=null,e._childViewsMorph=null,e._elementCreated&&(e._elementCreated=!1,this.didDestroyElement(e)),t&&this.destroyView(e)}var u=e.DOMHelper;r.prototype.uuid=function(e){return void 0===e._uuid&&(e._uuid=++this._uuid,e._renderer=this),e._uuid},r.prototype.scheduleInsert=function(e,t){if(e._morph||e._elementCreated)throw new Error("You cannot insert a View that has already been rendered");e._morph=t;var r=this.uuid(e);this._inserts[r]=this.scheduleRender(this,function(){this._inserts[r]=null,this.renderTree(e)})},r.prototype.appendTo=function(e,t){var r=this._dom.appendMorph(t);this.scheduleInsert(e,r)},r.prototype.replaceIn=function(e,t){var r=this._dom.createMorph(t,null,null);this.scheduleInsert(e,r)},r.prototype.remove=i,r.prototype.destroy=function(e){this.remove(e,!0)},r.prototype.renderTree=n,r.prototype.insertElement=a,r.prototype.beforeRemove=s,r.prototype.afterRemove=o;var l=function(){};r.prototype.willCreateElement=l,r.prototype.createElement=l,r.prototype.didCreateElement=l,r.prototype.willInsertElement=l,r.prototype.didInsertElement=l,r.prototype.willRemoveElement=l,r.prototype.willDestroyElement=l,r.prototype.didDestroyElement=l,r.prototype.destroyView=l,r.prototype.childViews=l,t["default"]=r}),e("ember-metal",["ember-metal/core","ember-metal/merge","ember-metal/instrumentation","ember-metal/utils","ember-metal/error","ember-metal/enumerable_utils","ember-metal/cache","ember-metal/platform","ember-metal/array","ember-metal/logger","ember-metal/property_get","ember-metal/events","ember-metal/observer_set","ember-metal/property_events","ember-metal/properties","ember-metal/property_set","ember-metal/map","ember-metal/get_properties","ember-metal/set_properties","ember-metal/watch_key","ember-metal/chains","ember-metal/watch_path","ember-metal/watching","ember-metal/expand_properties","ember-metal/computed","ember-metal/computed_macros","ember-metal/observer","ember-metal/mixin","ember-metal/binding","ember-metal/run_loop","ember-metal/libraries","ember-metal/is_none","ember-metal/is_empty","ember-metal/is_blank","ember-metal/is_present","ember-metal/keys","backburner","exports"],function(e,r,n,i,a,s,o,u,l,c,h,m,p,f,d,v,b,g,y,_,w,x,C,E,O,P,A,N,S,T,k,V,I,j,M,R,D,L){"use strict";var F=e["default"],B=r["default"],H=n.instrument,z=n.reset,q=n.subscribe,U=n.unsubscribe,W=i.EMPTY_META,K=i.GUID_KEY,G=i.META_DESC,Q=i.apply,$=i.applyStr,Y=i.canInvoke,X=i.generateGuid,Z=i.getMeta,J=i.guidFor,et=i.inspect,tt=i.isArray,rt=i.makeArray,nt=i.meta,it=i.metaPath,at=i.setMeta,st=i.tryCatchFinally,ot=i.tryFinally,ut=i.tryInvoke,lt=i.typeOf,ct=i.uuid,ht=i.wrap,mt=a["default"],pt=s["default"],ft=o["default"],dt=u.create,vt=u.hasPropertyAccessors,bt=l.filter,gt=l.forEach,yt=l.indexOf,_t=l.map,wt=c["default"],xt=h._getPath,Ct=h.get,Et=h.getWithDefault,Ot=h.normalizeTuple,Pt=m.accumulateListeners,At=m.addListener,Nt=m.hasListeners,St=m.listenersFor,Tt=m.on,kt=m.removeListener,Vt=m.sendEvent,It=m.suspendListener,jt=m.suspendListeners,Mt=m.watchedEvents,Rt=p["default"],Dt=f.beginPropertyChanges,Lt=f.changeProperties,Ft=f.endPropertyChanges,Bt=f.overrideChains,Ht=f.propertyDidChange,zt=f.propertyWillChange,qt=d.Descriptor,Ut=d.defineProperty,Wt=v.set,Kt=v.trySet,Gt=b.Map,Qt=b.MapWithDefault,$t=b.OrderedSet,Yt=g["default"],Xt=y["default"],Zt=_.watchKey,Jt=_.unwatchKey,er=w.ChainNode,tr=w.finishChains,rr=w.flushPendingChains,nr=w.removeChainWatcher,ir=x.watchPath,ar=x.unwatchPath,sr=C.destroy,or=C.isWatching,ur=C.rewatch,lr=C.unwatch,cr=C.watch,hr=E["default"],mr=O.ComputedProperty,pr=O.computed,fr=O.cacheFor,dr=A._suspendBeforeObserver,vr=A._suspendBeforeObservers,br=A._suspendObserver,gr=A._suspendObservers,yr=A.addBeforeObserver,_r=A.addObserver,wr=A.beforeObserversFor,xr=A.observersFor,Cr=A.removeBeforeObserver,Er=A.removeObserver,Or=N.IS_BINDING,Pr=N.Mixin,Ar=N.aliasMethod,Nr=N.beforeObserver,Sr=N.immediateObserver,Tr=N.mixin,kr=N.observer,Vr=N.required,Ir=S.Binding,jr=S.bind,Mr=S.isGlobalPath,Rr=S.oneWay,Dr=T["default"],Lr=k["default"],Fr=V["default"],Br=I["default"],Hr=j["default"],zr=M["default"],qr=R["default"],Ur=D["default"],Wr=F.Instrumentation={};Wr.instrument=H,Wr.subscribe=q,Wr.unsubscribe=U,Wr.reset=z,F.instrument=H,F.subscribe=q,F._Cache=ft,F.generateGuid=X,F.GUID_KEY=K,F.create=dt,F.keys=qr,F.platform={defineProperty:Ut,hasPropertyAccessors:vt};var Kr=F.ArrayPolyfills={};Kr.map=_t,Kr.forEach=gt,Kr.filter=bt,Kr.indexOf=yt,F.Error=mt,F.guidFor=J,F.META_DESC=G,F.EMPTY_META=W,F.meta=nt,F.getMeta=Z,F.setMeta=at,F.metaPath=it,F.inspect=et,F.typeOf=lt,F.tryCatchFinally=st,F.isArray=tt,F.makeArray=rt,F.canInvoke=Y,F.tryInvoke=ut,F.tryFinally=ot,F.wrap=ht,F.apply=Q,F.applyStr=$,F.uuid=ct,F.Logger=wt,F.get=Ct,F.getWithDefault=Et,F.normalizeTuple=Ot,F._getPath=xt,F.EnumerableUtils=pt,F.on=Tt,F.addListener=At,F.removeListener=kt,F._suspendListener=It,F._suspendListeners=jt,F.sendEvent=Vt,F.hasListeners=Nt,F.watchedEvents=Mt,F.listenersFor=St,F.accumulateListeners=Pt,F._ObserverSet=Rt,F.propertyWillChange=zt,F.propertyDidChange=Ht,F.overrideChains=Bt,F.beginPropertyChanges=Dt,F.endPropertyChanges=Ft,F.changeProperties=Lt,F.Descriptor=qt,F.defineProperty=Ut,F.set=Wt,F.trySet=Kt,F.OrderedSet=$t,F.Map=Gt,F.MapWithDefault=Qt,F.getProperties=Yt,F.setProperties=Xt,F.watchKey=Zt,F.unwatchKey=Jt,F.flushPendingChains=rr,F.removeChainWatcher=nr,F._ChainNode=er,F.finishChains=tr,F.watchPath=ir,F.unwatchPath=ar,F.watch=cr,F.isWatching=or,F.unwatch=lr,F.rewatch=ur,F.destroy=sr,F.expandProperties=hr,F.ComputedProperty=mr,F.computed=pr,F.cacheFor=fr,F.addObserver=_r,F.observersFor=xr,F.removeObserver=Er,F.addBeforeObserver=yr,F._suspendBeforeObserver=dr,F._suspendBeforeObservers=vr,F._suspendObserver=br,F._suspendObservers=gr,F.beforeObserversFor=wr,F.removeBeforeObserver=Cr,F.IS_BINDING=Or,F.required=Vr,F.aliasMethod=Ar,F.observer=kr,F.immediateObserver=Sr,F.beforeObserver=Nr,F.mixin=Tr,F.Mixin=Pr,F.oneWay=Rr,F.bind=jr,F.Binding=Ir,F.isGlobalPath=Mr,F.run=Dr,F.Backburner=Ur,F.libraries=new Lr,F.libraries.registerCoreLibrary("Ember",F.VERSION),F.isNone=Fr,F.isEmpty=Br,F.isBlank=Hr,F.isPresent=zr,F.merge=B,F.onerror=null,F.__loader.registry["ember-debug"]&&t("ember-debug"),L["default"]=F}),e("ember-metal/alias",["ember-metal/property_get","ember-metal/property_set","ember-metal/core","ember-metal/error","ember-metal/properties","ember-metal/computed","ember-metal/platform","ember-metal/utils","ember-metal/dependent_keys","exports"],function(e,t,r,n,i,a,s,o,u,l){"use strict";function c(e){this.altKey=e,this._dependentKeys=[e]}function h(e,t){throw new d('Cannot set read-only property "'+t+'" on object: '+w(e))}function m(e,t,r){return b(e,t,null),f(e,t,r)}var p=e.get,f=t.set,d=(r["default"],n["default"]),v=i.Descriptor,b=i.defineProperty,g=a.ComputedProperty,y=s.create,_=o.meta,w=o.inspect,x=u.addDependentKeys,C=u.removeDependentKeys;l["default"]=function(e){return new c(e)},l.AliasedProperty=c,c.prototype=y(v.prototype),c.prototype.get=function(e){return p(e,this.altKey)},c.prototype.set=function(e,t,r){return f(e,this.altKey,r)},c.prototype.willWatch=function(e,t){x(this,e,t,_(e))},c.prototype.didUnwatch=function(e,t){C(this,e,t,_(e))},c.prototype.setup=function(e,t){var r=_(e);r.watching[t]&&x(this,e,t,r)},c.prototype.teardown=function(e,t){var r=_(e);r.watching[t]&&C(this,e,t,r)},c.prototype.readOnly=function(){return this.set=h,this},c.prototype.oneWay=function(){return this.set=m,this},c.prototype._meta=void 0,c.prototype.meta=g.prototype.meta}),e("ember-metal/array",["exports"],function(e){"use strict";var t=Array.prototype,r=function(e){return e&&Function.prototype.toString.call(e).indexOf("[native code]")>-1},n=function(e,t){return r(e)?e:t},a=n(t.map,function(e){if(void 0===this||null===this||"function"!=typeof e)throw new TypeError;for(var t=Object(this),r=t.length>>>0,n=new Array(r),i=arguments[1],a=0;r>a;a++)a in t&&(n[a]=e.call(i,t[a],a,t));return n}),s=n(t.forEach,function(e){if(void 0===this||null===this||"function"!=typeof e)throw new TypeError;for(var t=Object(this),r=t.length>>>0,n=arguments[1],i=0;r>i;i++)i in t&&e.call(n,t[i],i,t)}),o=n(t.indexOf,function(e,t){null===t||void 0===t?t=0:0>t&&(t=Math.max(0,this.length+t));for(var r=t,n=this.length;n>r;r++)if(this[r]===e)return r;return-1}),u=n(t.lastIndexOf,function(e,t){var r,n=this.length;for(t=void 0===t?n-1:0>t?Math.ceil(t):Math.floor(t),0>t&&(t+=n),r=t;r>=0;r--)if(this[r]===e)return r;return-1}),l=n(t.filter,function(e,t){var r,n,i=[],a=this.length;for(r=0;a>r;r++)this.hasOwnProperty(r)&&(n=this[r],e.call(t,n,r,this)&&i.push(n));return i});i.SHIM_ES5&&(t.map=t.map||a,t.forEach=t.forEach||s,t.filter=t.filter||l,t.indexOf=t.indexOf||o,t.lastIndexOf=t.lastIndexOf||u),e.map=a,e.forEach=s,e.filter=l,e.indexOf=o,e.lastIndexOf=u}),e("ember-metal/binding",["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/observer","ember-metal/run_loop","ember-metal/path_cache","exports"],function(e,t,r,n,i,a,s,o){"use strict";function u(e,t){return f(w(t)?p.lookup:e,t)}function l(e,t){this._direction=void 0,this._from=t,this._to=e,this._readyToSync=void 0,this._oneWay=void 0}function c(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])}function h(e,t,r){return new l(t,r).connect(e)}function m(e,t,r){return new l(t,r).oneWay().connect(e)}var p=e["default"],f=t.get,d=r.trySet,v=n.guidFor,b=i.addObserver,g=i.removeObserver,y=i._suspendObserver,_=a["default"],w=s.isGlobal;p.LOG_BINDINGS=!1||!!p.ENV.LOG_BINDINGS,l.prototype={copy:function(){var e=new l(this._to,this._from);return this._oneWay&&(e._oneWay=!0),e},from:function(e){return this._from=e,this},to:function(e){return this._to=e,this},oneWay:function(){return this._oneWay=!0,this},toString:function(){var e=this._oneWay?"[oneWay]":"";return"Ember.Binding<"+v(this)+">("+this._from+" -> "+this._to+")"+e},connect:function(e){var t=this._from,r=this._to;return d(e,r,u(e,t)),b(e,t,this,this.fromDidChange),this._oneWay||b(e,r,this,this.toDidChange),this._readyToSync=!0,this},disconnect:function(e){var t=!this._oneWay;return g(e,this._from,this,this.fromDidChange),t&&g(e,this._to,this,this.toDidChange),this._readyToSync=!1,this},fromDidChange:function(e){this._scheduleSync(e,"fwd")},toDidChange:function(e){this._scheduleSync(e,"back")},_scheduleSync:function(e,t){var r=this._direction;void 0===r&&(_.schedule("sync",this,this._sync,e),this._direction=t),"back"===r&&"fwd"===t&&(this._direction="fwd")},_sync:function(e){var t=p.LOG_BINDINGS;if(!e.isDestroyed&&this._readyToSync){var r=this._direction,n=this._from,i=this._to;if(this._direction=void 0,"fwd"===r){var a=u(e,this._from);t&&p.Logger.log(" ",this.toString(),"->",a,e),this._oneWay?d(e,i,a):y(e,i,this,this.toDidChange,function(){d(e,i,a)})}else if("back"===r){var s=f(e,this._to);t&&p.Logger.log(" ",this.toString(),"<-",s,e),y(e,n,this,this.fromDidChange,function(){d(w(n)?p.lookup:e,n,s)})}}}},c(l,{from:function(e){var t=this;return new t(void 0,e)},to:function(e){var t=this;return new t(e,void 0)},oneWay:function(e,t){var r=this;return new r(void 0,e).oneWay(t)}}),o.bind=h,o.oneWay=m,o.Binding=l,o.isGlobalPath=w}),e("ember-metal/cache",["ember-metal/dictionary","exports"],function(e,t){"use strict";function r(e,t){this.store=n(null),this.size=0,this.misses=0,this.hits=0,this.limit=e,this.func=t}var n=e["default"];t["default"]=r;var i=function(){};r.prototype={set:function(e,t){return this.limit>this.size&&(this.size++,this.store[e]=void 0===t?i:t),t},get:function(e){var t=this.store[e];return void 0===t?(this.misses++,t=this.set(e,this.func(e))):t===i?(this.hits++,t=void 0):this.hits++,t},purge:function(){this.store=n(null),this.size=0,this.hits=0,this.misses=0}}}),e("ember-metal/chains",["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/array","ember-metal/watch_key","exports"],function(e,t,r,n,i,a){"use strict";function s(e){return e.match(w)[0]}function o(){if(0!==x.length){var e=x;x=[],b.call(e,function(e){e[0].add(e[1])}),_("Watching an undefined global, Ember expects watched globals to be setup by the time the run loop is flushed, check for typos",0===x.length)}}function u(e,t,r){if(e&&"object"==typeof e){var n=v(e),i=n.chainWatchers;n.hasOwnProperty("chainWatchers")||(i=n.chainWatchers={}),i[t]||(i[t]=[]),i[t].push(r),g(e,t,n)}}function l(e,t,r){if(e&&"object"==typeof e){var n=e.__ember_meta__;if(!n||n.hasOwnProperty("chainWatchers")){var i=n&&n.chainWatchers;if(i&&i[t]){i=i[t];for(var a=0,s=i.length;s>a;a++)if(i[a]===r){i.splice(a,1);break}}y(e,t,n)}}}function c(e,t,r){this._parent=e,this._key=t,this._watching=void 0===r,this._value=r,this._paths={},this._watching&&(this._object=e.value(),this._object&&u(this._object,this._key,this)),this._parent&&"@each"===this._parent._key&&this.value()}function h(e,t){if(!e)return void 0;var r=e.__ember_meta__;if(r&&r.proto===e)return void 0;if("@each"===t)return f(e,t);var n=r&&r.descs[t];return n&&n._cacheable?t in r.cache?r.cache[t]:void 0:f(e,t)}function m(e){var t,r,n,i=e.__ember_meta__;if(i){if(r=i.chainWatchers)for(var a in r)if(r.hasOwnProperty(a)&&(n=r[a]))for(var s=0,o=n.length;o>s;s++)n[s].didChange(null);t=i.chains,t&&t.value()!==e&&(v(e).chains=t=t.copy(e))}}var p=e["default"],f=t.get,d=t.normalizeTuple,v=r.meta,b=n.forEach,g=i.watchKey,y=i.unwatchKey,_=p.warn,w=/^([^\.]+)/,x=[];a.flushPendingChains=o;var C=c.prototype;C.value=function(){if(void 0===this._value&&this._watching){var e=this._parent.value();this._value=h(e,this._key)}return this._value},C.destroy=function(){if(this._watching){var e=this._object;e&&l(e,this._key,this),this._watching=!1}},C.copy=function(e){var t,r=new c(null,null,e),n=this._paths;for(t in n)n[t]<=0||r.add(t);return r},C.add=function(e){var t,r,n,i,a;if(a=this._paths,a[e]=(a[e]||0)+1,t=this.value(),r=d(t,e),r[0]&&r[0]===t)e=r[1],n=s(e),e=e.slice(n.length+1);else{if(!r[0])return x.push([this,e]),void(r.length=0);i=r[0],n=e.slice(0,0-(r[1].length+1)),e=r[1]}r.length=0,this.chain(n,e,i)},C.remove=function(e){var t,r,n,i,a;a=this._paths,a[e]>0&&a[e]--,t=this.value(),r=d(t,e),r[0]===t?(e=r[1],n=s(e),e=e.slice(n.length+1)):(i=r[0],n=e.slice(0,0-(r[1].length+1)),e=r[1]),r.length=0,this.unchain(n,e)},C.count=0,C.chain=function(e,t,r){var n,i=this._chains;i||(i=this._chains={}),n=i[e],n||(n=i[e]=new c(this,e,r)),n.count++,t&&(e=s(t),t=t.slice(e.length+1),n.chain(e,t))},C.unchain=function(e,t){var r=this._chains,n=r[e];if(t&&t.length>1){var i=s(t),a=t.slice(i.length+1);n.unchain(i,a)}n.count--,n.count<=0&&(delete r[n._key],n.destroy())},C.willChange=function(e){var t=this._chains;if(t)for(var r in t)t.hasOwnProperty(r)&&t[r].willChange(e);this._parent&&this._parent.chainWillChange(this,this._key,1,e)},C.chainWillChange=function(e,t,r,n){this._key&&(t=this._key+"."+t),this._parent?this._parent.chainWillChange(this,t,r+1,n):(r>1&&n.push(this.value(),t),t="this."+t,this._paths[t]>0&&n.push(this.value(),t))},C.chainDidChange=function(e,t,r,n){this._key&&(t=this._key+"."+t),this._parent?this._parent.chainDidChange(this,t,r+1,n):(r>1&&n.push(this.value(),t),t="this."+t,this._paths[t]>0&&n.push(this.value(),t))},C.didChange=function(e){if(this._watching){var t=this._parent.value();t!==this._object&&(l(this._object,this._key,this),this._object=t,u(t,this._key,this)),this._value=void 0,this._parent&&"@each"===this._parent._key&&this.value()}var r=this._chains;if(r)for(var n in r)r.hasOwnProperty(n)&&r[n].didChange(e);null!==e&&this._parent&&this._parent.chainDidChange(this,this._key,1,e)},a.finishChains=m,a.removeChainWatcher=l,a.ChainNode=c}),e("ember-metal/computed",["ember-metal/property_set","ember-metal/utils","ember-metal/expand_properties","ember-metal/error","ember-metal/properties","ember-metal/property_events","ember-metal/dependent_keys","exports"],function(e,t,r,n,i,a,s,o){"use strict";function u(){}function l(e,t){e.__ember_arity__=e.length,this.func=e,this._dependentKeys=void 0,this._suspended=void 0,this._meta=void 0,this._cacheable=t&&void 0!==t.cacheable?t.cacheable:!0,this._dependentKeys=t&&t.dependentKeys,this._readOnly=t&&(void 0!==t.readOnly||!!t.readOnly)||!1}function c(e){for(var t=0,r=e.length;r>t;t++)e[t].didChange(null)}function h(e){var t;if(arguments.length>1&&(t=O.call(arguments),e=t.pop()),"function"!=typeof e)throw new b("Computed Property declared without a property function");var r=new l(e);return t&&r.property.apply(r,t),r}function m(e,t){var r=e.__ember_meta__,n=r&&r.cache,i=n&&n[t];return i===u?void 0:i}var p=e.set,f=t.meta,d=t.inspect,v=r["default"],b=n["default"],g=i.Descriptor,y=i.defineProperty,_=a.propertyWillChange,w=a.propertyDidChange,x=s.addDependentKeys,C=s.removeDependentKeys,E=f,O=[].slice;l.prototype=new g;var P=l.prototype;P.cacheable=function(e){return this._cacheable=e!==!1,this},P["volatile"]=function(){return this._cacheable=!1,this},P.readOnly=function(e){return this._readOnly=void 0===e||!!e,this},P.property=function(){var e,t=function(t){e.push(t)};e=[];for(var r=0,n=arguments.length;n>r;r++)v(arguments[r],t);return this._dependentKeys=e,this},P.meta=function(e){return 0===arguments.length?this._meta||{}:(this._meta=e,this)},P.didChange=function(e,t){if(this._cacheable&&this._suspended!==e){var r=E(e);void 0!==r.cache[t]&&(r.cache[t]=void 0,C(this,e,t,r))}},P.get=function(e,t){var r,n,i,a;if(this._cacheable){i=E(e),n=i.cache;var s=n[t];if(s===u)return void 0;if(void 0!==s)return s;r=this.func.call(e,t),n[t]=void 0===r?u:r,a=i.chainWatchers&&i.chainWatchers[t],a&&c(a),x(this,e,t,i)}else r=this.func.call(e,t);return r},P.set=function(e,t,r){var n=this._suspended;this._suspended=e;try{this._set(e,t,r)}finally{this._suspended=n}},P._set=function(e,t,r){var n,i,a,s=this._cacheable,o=this.func,l=E(e,s),c=l.cache,h=!1;if(this._readOnly)throw new b('Cannot set read-only property "'+t+'" on object: '+d(e));if(s&&void 0!==c[t]&&(c[t]!==u&&(i=c[t]),h=!0),n=o.wrappedFunction?o.wrappedFunction.__ember_arity__:o.__ember_arity__,3===n)a=o.call(e,t,r,i);else{if(2!==n)return y(e,t,null,i),void p(e,t,r);a=o.call(e,t,r)}if(!h||i!==a){var m=l.watching[t];return m&&_(e,t),h&&(c[t]=void 0),s&&(h||x(this,e,t,l),c[t]=void 0===a?u:a),m&&w(e,t),a}},P.teardown=function(e,t){var r=E(e);return t in r.cache&&C(this,e,t,r),this._cacheable&&delete r.cache[t],null},m.set=function(e,t,r){e[t]=void 0===r?u:r},m.get=function(e,t){var r=e[t];return r===u?void 0:r},m.remove=function(e,t){e[t]=void 0},o.ComputedProperty=l,o.computed=h,o.cacheFor=m}),e("ember-metal/computed_macros",["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/computed","ember-metal/is_empty","ember-metal/is_none","ember-metal/alias"],function(e,t,r,n,i,a,s){"use strict";function o(e,t){for(var r={},n=0;nt}),u("gte",function(e,t){return h(this,e)>=t}),u("lt",function(e,t){return h(this,e)1?(m(this,e,r),r):h(this,e)})}}),e("ember-metal/core",["exports"],function(e){"use strict";function t(){return this}"undefined"==typeof i&&(i={}),i.imports=i.imports||this,i.lookup=i.lookup||this;var r=i.exports=i.exports||this;r.Em=r.Ember=i,i.isNamespace=!0,i.toString=function(){return"Ember"},i.VERSION="1.10.0",i.ENV||(i.ENV="undefined"!=typeof EmberENV?EmberENV:"undefined"!=typeof ENV?ENV:{}),i.config=i.config||{},"undefined"==typeof i.ENV.DISABLE_RANGE_API&&(i.ENV.DISABLE_RANGE_API=!0),"undefined"==typeof MetamorphENV&&(r.MetamorphENV={}),MetamorphENV.DISABLE_RANGE_API=i.ENV.DISABLE_RANGE_API,i.FEATURES=i.ENV.FEATURES||{},i.FEATURES.isEnabled=function(e){var t=i.FEATURES[e];return i.ENV.ENABLE_ALL_FEATURES?!0:t===!0||t===!1||void 0===t?t:i.ENV.ENABLE_OPTIONAL_FEATURES?!0:!1},i.EXTEND_PROTOTYPES=i.ENV.EXTEND_PROTOTYPES,"undefined"==typeof i.EXTEND_PROTOTYPES&&(i.EXTEND_PROTOTYPES=!0),i.LOG_STACKTRACE_ON_DEPRECATION=i.ENV.LOG_STACKTRACE_ON_DEPRECATION!==!1,i.SHIM_ES5=i.ENV.SHIM_ES5===!1?!1:i.EXTEND_PROTOTYPES,i.LOG_VERSION=i.ENV.LOG_VERSION===!1?!1:!0,e.K=t,i.K=t,"undefined"==typeof i.assert&&(i.assert=t),"undefined"==typeof i.warn&&(i.warn=t),"undefined"==typeof i.debug&&(i.debug=t),"undefined"==typeof i.runInDebug&&(i.runInDebug=t),"undefined"==typeof i.deprecate&&(i.deprecate=t),"undefined"==typeof i.deprecateFunc&&(i.deprecateFunc=function(e,t){return t}),e["default"]=i}),e("ember-metal/dependent_keys",["ember-metal/platform","ember-metal/watching","exports"],function(e,t,r){function n(e,t){var r=e[t];return r?e.hasOwnProperty(t)||(r=e[t]=o(r)):r=e[t]={},r}function i(e){return n(e,"deps")}function a(e,t,r,a){var s,o,l,c,h,m=e._dependentKeys;if(m)for(s=i(a),o=0,l=m.length;l>o;o++)c=m[o],h=n(s,c),h[r]=(h[r]||0)+1,u(t,c,a)}function s(e,t,r,a){var s,o,u,c,h,m=e._dependentKeys;if(m)for(s=i(a),o=0,u=m.length;u>o;o++)c=m[o],h=n(s,c),h[r]=(h[r]||0)-1,l(t,c,a)}var o=e.create,u=t.watch,l=t.unwatch;r.addDependentKeys=a,r.removeDependentKeys=s}),e("ember-metal/deprecate_property",["ember-metal/core","ember-metal/platform","ember-metal/properties","ember-metal/property_get","ember-metal/property_set","exports"],function(e,t,r,n,i,a){"use strict";function s(e,t,r){function n(){}o&&u(e,t,{configurable:!0,enumerable:!1,set:function(e){n(),c(this,r,e)},get:function(){return n(),l(this,r)}})}var o=(e["default"],t.hasPropertyAccessors),u=r.defineProperty,l=n.get,c=i.set;a.deprecateProperty=s}),e("ember-metal/dictionary",["ember-metal/platform","exports"],function(e,t){"use strict";var r=e.create;t["default"]=function(e){var t=r(e);return t._dict=null,delete t._dict,t}}),e("ember-metal/enumerable_utils",["ember-metal/array","exports"],function(e,t){"use strict";function r(e,t,r){return e.map?e.map(t,r):d.call(e,t,r)}function n(e,t,r){return e.forEach?e.forEach(t,r):p.call(e,t,r)}function i(e,t,r){return e.filter?e.filter(t,r):m.call(e,t,r)}function a(e,t,r){return e.indexOf?e.indexOf(t,r):f.call(e,t,r)}function s(e,t){return void 0===t?[]:r(t,function(t){return a(e,t)})}function o(e,t){var r=a(e,t);-1===r&&e.push(t)}function u(e,t){var r=a(e,t);-1!==r&&e.splice(r,1)}function l(e,t,r,n){for(var i,a,s=[].concat(n),o=[],u=6e4,l=t,c=r;s.length;)i=c>u?u:c,0>=i&&(i=0),a=s.splice(0,u),a=[l,i].concat(a),l+=u,c-=i,o=o.concat(v.apply(e,a));return o}function c(e,t,r,n){return e.replace?e.replace(t,r,n):l(e,t,r,n)}function h(e,t){var r=[];return n(e,function(e){a(t,e)>=0&&r.push(e)}),r}var m=e.filter,p=e.forEach,f=e.indexOf,d=e.map,v=Array.prototype.splice;t.map=r,t.forEach=n,t.filter=i,t.indexOf=a,t.indexesOf=s,t.addObject=o,t.removeObject=u,t._replace=l,t.replace=c,t.intersection=h,t["default"]={_replace:l,addObject:o,filter:i,forEach:n,indexOf:a,indexesOf:s,intersection:h,map:r,removeObject:u,replace:c}}),e("ember-metal/error",["ember-metal/platform","exports"],function(e,t){"use strict";function r(){var e=Error.apply(this,arguments);Error.captureStackTrace&&Error.captureStackTrace(this,i.Error);for(var t=0;t=0;i-=3)if(t===e[i]&&r===e[i+1]){n=i;break}return n}function a(e,t){var r,n=b(e,!0),i=n.listeners;return i?i.__source__!==e&&(i=n.listeners=w(i),i.__source__=e):(i=n.listeners=w(null),i.__source__=e),r=i[t],r&&r.__source__!==e?(r=i[t]=i[t].slice(),r.__source__=e):r||(r=i[t]=[],r.__source__=e),r}function s(e,t,r){var n=e.__ember_meta__,a=n&&n.listeners&&n.listeners[t];if(a){for(var s=[],o=a.length-3;o>=0;o-=3){var u=a[o],l=a[o+1],c=a[o+2],h=i(r,u,l);-1===h&&(r.push(u,l,c),s.push(u,l,c))}return s}}function o(e,t,r,n,s){n||"function"!=typeof r||(n=r,r=null);var o=a(e,t),u=i(o,r,n),l=0;s&&(l|=C),-1===u&&(o.push(r,n,l),"function"==typeof e.didAddListener&&e.didAddListener(t,r,n))}function u(e,t,r,n){function s(r,n){var s=a(e,t),o=i(s,r,n);-1!==o&&(s.splice(o,3),"function"==typeof e.didRemoveListener&&e.didRemoveListener(t,r,n))}if(n||"function"!=typeof r||(n=r,r=null),n)s(r,n);else{var o=e.__ember_meta__,u=o&&o.listeners&&o.listeners[t];if(!u)return;for(var l=u.length-3;l>=0;l-=3)s(u[l],u[l+1])}}function l(e,t,r,n,s){function o(){return s.call(r)}function u(){-1!==c&&(l[c+2]&=~E)}n||"function"!=typeof r||(n=r,r=null);var l=a(e,t),c=i(l,r,n);return-1!==c&&(l[c+2]|=E),g(o,u)}function c(e,t,r,n,s){function o(){return s.call(r)}function u(){for(var e=0,t=p.length;t>e;e++){var r=p[e];f[e][r+2]&=~E}}n||"function"!=typeof r||(n=r,r=null);var l,c,h,m,p=[],f=[];for(h=0,m=t.length;m>h;h++){l=t[h],c=a(e,l);var d=i(c,r,n);-1!==d&&(c[d+2]|=E,p.push(d),f.push(c))}return g(o,u)}function h(e){var t=e.__ember_meta__.listeners,r=[];if(t)for(var n in t)"__source__"!==n&&t[n]&&r.push(n);return r}function m(e,t,r,n){if(e!==v&&"function"==typeof e.sendEvent&&e.sendEvent(t,r),!n){var i=e.__ember_meta__;n=i&&i.listeners&&i.listeners[t]}if(n){for(var a=n.length-3;a>=0;a-=3){var s=n[a],o=n[a+1],l=n[a+2];o&&(l&E||(l&C&&u(e,t,s,o),s||(s=e),"string"==typeof o?r?_(s,o,r):s[o]():r?y(s,o,r):o.call(s)))}return!0}}function p(e,t){var r=e.__ember_meta__,n=r&&r.listeners&&r.listeners[t];return!(!n||!n.length)}function f(e,t){var r=[],n=e.__ember_meta__,i=n&&n.listeners&&n.listeners[t];if(!i)return r;for(var a=0,s=i.length;s>a;a+=3){var o=i[a],u=i[a+1];r.push([o,u])}return r}function d(){var e=x.call(arguments,-1)[0],t=x.call(arguments,0,-1);return e.__ember_listens__=t,e}var v=e["default"],b=t.meta,g=t.tryFinally,y=t.apply,_=t.applyStr,w=r.create,x=[].slice,C=1,E=2;n.accumulateListeners=s,n.addListener=o,n.suspendListener=l,n.suspendListeners=c,n.watchedEvents=h,n.sendEvent=m,n.hasListeners=p,n.listenersFor=f,n.on=d,n.removeListener=u}),e("ember-metal/expand_properties",["ember-metal/core","ember-metal/error","ember-metal/enumerable_utils","exports"],function(e,t,r,n){"use strict";function i(e,t){if("string"===s.typeOf(e)){var r=e.split(l),n=[r];u(r,function(e,t){e.indexOf(",")>=0&&(n=a(n,e.split(","),t))}),u(n,function(e){t(e.join(""))})}else t(e)}function a(e,t,r){var n=[];return u(e,function(e){u(t,function(t){var i=e.slice(0);i[r]=t,n.push(i)})}),n}var s=e["default"],o=t["default"],u=r.forEach,l=/\{|\}/;n["default"]=function(e,t){if(e.indexOf(" ")>-1)throw new o("Brace expanded properties cannot contain spaces, e.g. `user.{firstName, lastName}` should be `user.{firstName,lastName}`");return i(e,t)}}),e("ember-metal/get_properties",["ember-metal/property_get","ember-metal/utils","exports"],function(e,t,r){"use strict";var n=e.get,i=t.typeOf;r["default"]=function(e){var t={},r=arguments,a=1;2===arguments.length&&"array"===i(arguments[1])&&(a=0,r=arguments[1]);for(var s=r.length;s>a;a++)t[r[a]]=n(e,r[a]);return t}}),e("ember-metal/injected_property",["ember-metal/core","ember-metal/computed","ember-metal/alias","ember-metal/properties","ember-metal/platform","ember-metal/utils","exports"],function(e,t,r,n,i,a,s){"use strict";function o(e,t){this.type=e,this.name=t,this._super$Constructor(u),v.oneWay.call(this)}function u(e){var t=p(this).descs[e];return this.container.lookup(t.type+":"+(t.name||e))}var l=(e["default"],t.ComputedProperty),c=r.AliasedProperty,h=n.Descriptor,m=i.create,p=a.meta;o.prototype=m(h.prototype);var f=o.prototype,d=l.prototype,v=c.prototype;f._super$Constructor=l,f.get=d.get,f.readOnly=d.readOnly,f.teardown=d.teardown,s["default"]=o}),e("ember-metal/instrumentation",["ember-metal/core","ember-metal/utils","exports"],function(e,t,r){"use strict";function n(e,t,r,n){if(arguments.length<=3&&"function"==typeof t&&(n=r,r=t,t=void 0),0===c.length)return r.call(n);var a=t||{},s=i(e,function(){return a
-});if(s){var o=function(){return r.call(n)},u=function(e){a.exception=e};return l(o,u,s)}return r.call(n)}function i(e,t){var r=h[e];if(r||(r=m(e)),0!==r.length){var n,i=t(),a=u.STRUCTURED_PROFILE;a&&(n=e+": "+i.object,console.time(n));var s,o,l=r.length,c=new Array(l),f=p();for(s=0;l>s;s++)o=r[s],c[s]=o.before(e,f,i);return function(){var t,s,o,u=p();for(t=0,s=r.length;s>t;t++)o=r[t],o.after(e,u,i,c[t]);a&&console.timeEnd(n)}}}function a(e,t){for(var r,n=e.split("."),i=[],a=0,s=n.length;s>a;a++)r=n[a],i.push("*"===r?"[^\\.]*":r);i=i.join("\\."),i+="(\\..*)?";var o={pattern:e,regex:new RegExp("^"+i+"$"),object:t};return c.push(o),h={},o}function s(e){for(var t,r=0,n=c.length;n>r;r++)c[r]===e&&(t=r);c.splice(t,1),h={}}function o(){c.length=0,h={}}var u=e["default"],l=t.tryCatchFinally,c=[];r.subscribers=c;var h={},m=function(e){for(var t,r=[],n=0,i=c.length;i>n;n++)t=c[n],t.regex.test(e)&&r.push(t.object);return h[e]=r,r},p=function(){var e="undefined"!=typeof window?window.performance||{}:{},t=e.now||e.mozNow||e.webkitNow||e.msNow||e.oNow;return t?t.bind(e):function(){return+new Date}}();r.instrument=n,r._instrumentStart=i,r.subscribe=a,r.unsubscribe=s,r.reset=o}),e("ember-metal/is_blank",["ember-metal/is_empty","exports"],function(e,t){"use strict";var r=e["default"];t["default"]=function(e){return r(e)||"string"==typeof e&&null===e.match(/\S/)}}),e("ember-metal/is_empty",["ember-metal/property_get","ember-metal/is_none","exports"],function(e,t,r){"use strict";function n(e){var t=a(e);if(t)return t;if("number"==typeof e.size)return!e.size;var r=typeof e;if("object"===r){var n=i(e,"size");if("number"==typeof n)return!n}if("number"==typeof e.length&&"function"!==r)return!e.length;if("object"===r){var s=i(e,"length");if("number"==typeof s)return!s}return!1}var i=e.get,a=t["default"];r["default"]=n}),e("ember-metal/is_none",["exports"],function(e){"use strict";function t(e){return null===e||void 0===e}e["default"]=t}),e("ember-metal/is_present",["ember-metal/is_blank","exports"],function(e,t){"use strict";var r,n=e["default"];r=function(e){return!n(e)},t["default"]=r}),e("ember-metal/keys",["ember-metal/platform","exports"],function(e,t){"use strict";var r=e.canDefineNonEnumerableProperties,n=Object.keys;n&&r||(n=function(){var e=Object.prototype.hasOwnProperty,t=!{toString:null}.propertyIsEnumerable("toString"),r=["toString","toLocaleString","valueOf","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","constructor"],n=r.length;return function(i){if("object"!=typeof i&&("function"!=typeof i||null===i))throw new TypeError("Object.keys called on non-object");var a,s,o=[];for(a in i)"_super"!==a&&0!==a.lastIndexOf("__",0)&&e.call(i,a)&&o.push(a);if(t)for(s=0;n>s;s++)e.call(i,r[s])&&o.push(r[s]);return o}}()),t["default"]=n}),e("ember-metal/libraries",["ember-metal/core","ember-metal/enumerable_utils","exports"],function(e,t,r){"use strict";function n(){this._registry=[],this._coreLibIndex=0}var i=(e["default"],t.forEach),a=t.indexOf;n.prototype={constructor:n,_getLibraryByName:function(e){for(var t=this._registry,r=t.length,n=0;r>n;n++)if(t[n].name===e)return t[n]},register:function(e,t,r){var n=this._registry.length;this._getLibraryByName(e)||(r&&(n=this._coreLibIndex++),this._registry.splice(n,0,{name:e,version:t}))},registerCoreLibrary:function(e,t){this.register(e,t,!0)},deRegister:function(e){var t,r=this._getLibraryByName(e);r&&(t=a(this._registry,r),this._registry.splice(t,1))},each:function(e){i(this._registry,function(t){e(t.name,t.version)})}},r["default"]=n}),e("ember-metal/logger",["ember-metal/core","ember-metal/error","exports"],function(e,t,r){"use strict";function n(){return this}function i(e){var t,r;s.imports.console?t=s.imports.console:"undefined"!=typeof console&&(t=console);var n="object"==typeof t?t[e]:null;return n?"function"==typeof n.bind?(r=n.bind(t),r.displayName="console."+e,r):"function"==typeof n.apply?(r=function(){n.apply(t,arguments)},r.displayName="console."+e,r):function(){var e=Array.prototype.join.call(arguments,", ");n(e)}:void 0}function a(e,t){if(!e)try{throw new o("assertion failed: "+t)}catch(r){setTimeout(function(){throw r},0)}}var s=e["default"],o=t["default"];r["default"]={log:i("log")||n,warn:i("warn")||n,error:i("error")||n,info:i("info")||n,debug:i("debug")||i("info")||n,assert:i("assert")||a}}),e("ember-metal/map",["ember-metal/utils","ember-metal/array","ember-metal/platform","ember-metal/deprecate_property","exports"],function(e,t,r,n,a){"use strict";function s(e){throw new TypeError(""+Object.prototype.toString.call(e)+" is not a function")}function o(e){throw new TypeError("Constructor "+e+"requires 'new'")}function u(e){var t=d(null);for(var r in e)t[r]=e[r];return t}function l(e,t){var r=e.keys.copy(),n=u(e.values);return t.keys=r,t.values=n,t.size=e.size,t}function c(){this instanceof c?(this.clear(),this._silenceRemoveDeprecation=!1):o("OrderedSet")}function h(){this instanceof this.constructor?(this.keys=c.create(),this.keys._silenceRemoveDeprecation=!0,this.values=d(null),this.size=0):o("OrderedSet")}function m(e){this._super$constructor(),this.defaultValue=e.defaultValue}var p=e.guidFor,f=t.indexOf,d=r.create,v=n.deprecateProperty;c.create=function(){var e=this;return new e},c.prototype={constructor:c,clear:function(){this.presenceSet=d(null),this.list=[],this.size=0},add:function(e,t){var r=t||p(e),n=this.presenceSet,i=this.list;return n[r]!==!0?(n[r]=!0,this.size=i.push(e),this):void 0},remove:function(e,t){return this["delete"](e,t)},"delete":function(e,t){var r=t||p(e),n=this.presenceSet,i=this.list;if(n[r]===!0){delete n[r];var a=f.call(i,e);return a>-1&&i.splice(a,1),this.size=i.length,!0}return!1},isEmpty:function(){return 0===this.size},has:function(e){if(0===this.size)return!1;var t=p(e),r=this.presenceSet;return r[t]===!0},forEach:function(e){if("function"!=typeof e&&s(e),0!==this.size){var t,r=this.list,n=arguments.length;if(2===n)for(t=0;ts;s++)n=i[s],e[n]=t[n];return e}}),e("ember-metal/mixin",["ember-metal/core","ember-metal/merge","ember-metal/array","ember-metal/platform","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/expand_properties","ember-metal/properties","ember-metal/computed","ember-metal/binding","ember-metal/observer","ember-metal/events","ember-metal/streams/utils","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m,p,f){function d(){var e,t=this.__nextSuper;if(t){var r=arguments.length;return this.__nextSuper=null,e=0===r?t.call(this):1===r?t.call(this,arguments[0]):2===r?t.call(this,arguments[0],arguments[1]):t.apply(this,arguments),this.__nextSuper=t,e}}function v(e){var t=et(e,!0),r=t.mixins;return r?t.hasOwnProperty("mixins")||(r=t.mixins=$(r)):r=t.mixins={},r}function b(e){return"function"==typeof e&&e.isMethod!==!1&&e!==Boolean&&e!==Object&&e!==Number&&e!==Array&&e!==Date&&e!==String}function g(e,t){var r;return t instanceof M?(r=J(t),e[r]?gt:(e[r]=t,t.properties)):t}function y(e,t,r,n){var i;return i=r[e]||n[e],t[e]&&(i=i?i.concat(t[e]):t[e]),i}function _(e,t,r,n,i){var a;return void 0===n[t]&&(a=i[t]),a=a||e.descs[t],void 0!==a&&a instanceof st?(r=$(r),r.func=tt(r.func,a.func),r):r}function w(e,t,r,n,i){var a;if(void 0===i[t]&&(a=n[t]),a=a||e[t],void 0===a||"function"!=typeof a)return r;var s;return yt&&(s=r.__hasSuper,void 0===s&&(s=r.toString().indexOf("_super")>-1,r.__hasSuper=s)),yt===!1||s?tt(r,a):r}function x(e,t,r,n){var i=n[t]||e[t];return i?"function"==typeof i.concat?null===r||void 0===r?i:i.concat(r):rt(i).concat(r):rt(r)}function C(e,t,r,n){var i=n[t]||e[t];if(!i)return r;var a=K({},i),s=!1;for(var o in r)if(r.hasOwnProperty(o)){var u=r[o];b(u)?(s=!0,a[o]=w(e,o,u,i,{})):a[o]=u}return s&&(a._super=d),a}function E(e,t,r,n,i,a,s,o){if(r instanceof it){if(r===U&&i[t])return gt;r.func&&(r=_(n,t,r,a,i)),i[t]=r,a[t]=void 0}else s&&G.call(s,t)>=0||"concatenatedProperties"===t||"mergedProperties"===t?r=x(e,t,r,a):o&&G.call(o,t)>=0?r=C(e,t,r,a):b(r)&&(r=w(e,t,r,a,i)),i[t]=void 0,a[t]=r}function O(e,t,r,n,i,a){function s(e){delete r[e],delete n[e]}for(var o,u,l,c,h,m,p=0,f=e.length;f>p;p++)if(o=e[p],u=g(t,o),u!==gt)if(u){m=et(i),i.willMergeMixin&&i.willMergeMixin(u),c=y("concatenatedProperties",u,n,i),h=y("mergedProperties",u,n,i);for(l in u)u.hasOwnProperty(l)&&(a.push(l),E(i,l,u[l],m,r,n,c,h));u.hasOwnProperty("toString")&&(i.toString=u.toString)}else o.mixins&&(O(o.mixins,t,r,n,i,a),o._without&&Q.call(o._without,s))}function P(e,t,r,n){if(_t.test(t)){var i=n.bindings;i?n.hasOwnProperty("bindings")||(i=n.bindings=$(n.bindings)):i=n.bindings={},i[t]=r}}function A(e,t,r){var n=function(r){mt(e,t,null,i,function(){Z(e,t,r.value())})},i=function(){r.setValue(Y(e,t),n)};X(e,t,r.value()),ut(e,t,null,i),r.subscribe(n),void 0===e._streamBindingSubscriptions&&(e._streamBindingSubscriptions=$(null)),e._streamBindingSubscriptions[t]=n}function N(e,t){var r,n,i,a=t.bindings;if(a){for(r in a)if(n=a[r]){if(i=r.slice(0,-7),dt(n)){A(e,i,n);continue}n instanceof ot?(n=n.copy(),n.to(i)):n=new ot(i,n),n.connect(e),e[r]=n}t.bindings={}}}function S(e,t){return N(e,t||et(e)),e}function T(e,t,r,n,i){var a,s=t.methodName;return n[s]||i[s]?(a=i[s],t=n[s]):r.descs[s]?(t=r.descs[s],a=void 0):(t=void 0,a=e[s]),{desc:t,value:a}}function k(e,t,r,n,i){var a=r[n];if(a)for(var s=0,o=a.length;o>s;s++)i(e,a[s],null,t)}function V(e,t,r){var n=e[t];"function"==typeof n&&(k(e,t,n,"__ember_observesBefore__",ht),k(e,t,n,"__ember_observes__",lt),k(e,t,n,"__ember_listens__",ft)),"function"==typeof r&&(k(e,t,r,"__ember_observesBefore__",ct),k(e,t,r,"__ember_observes__",ut),k(e,t,r,"__ember_listens__",pt))}function I(e,t,r){var n,i,a,s={},o={},u=et(e),l=[];e._super=d,O(t,v(e),s,o,e,l);for(var c=0,h=l.length;h>c;c++)if(n=l[c],"constructor"!==n&&o.hasOwnProperty(n)&&(a=s[n],i=o[n],a!==U)){for(;a&&a instanceof F;){var m=T(e,a,u,s,o);a=m.desc,i=m.value}(void 0!==a||void 0!==i)&&(V(e,n,i),P(e,n,i,u),at(e,n,a,i,u))}return r||S(e,u),e}function j(e){var t=vt.call(arguments,1);return I(e,t,!1),e}function M(e,t){this.properties=t;var r=e&&e.length;if(r>0){for(var n=new Array(r),i=0;r>i;i++){var a=e[i];n[i]=a instanceof M?a:new M(void 0,a)}this.mixins=n}else this.mixins=void 0;this.ownerConstructor=void 0}function R(e,t,r){var n=J(e);if(r[n])return!1;if(r[n]=!0,e===t)return!0;for(var i=e.mixins,a=i?i.length:0;--a>=0;)if(R(i[a],t,r))return!0;return!1}function D(e,t,r){if(!r[J(t)])if(r[J(t)]=!0,t.properties){var n=t.properties;for(var i in n)n.hasOwnProperty(i)&&(e[i]=!0)}else t.mixins&&Q.call(t.mixins,function(t){D(e,t,r)})}function L(){return U}function F(e){this.methodName=e}function B(e){return new F(e)}function H(){var e,t=vt.call(arguments,-1)[0],r=function(t){e.push(t)},n=vt.call(arguments,0,-1);"function"!=typeof t&&(t=arguments[0],n=vt.call(arguments,1)),e=[];for(var i=0;ie;e++){arguments[e]}return H.apply(this,arguments)}function q(){var e,t=vt.call(arguments,-1)[0],r=function(t){e.push(t)},n=vt.call(arguments,0,-1);"function"!=typeof t&&(t=arguments[0],n=vt.call(arguments,1)),e=[];for(var i=0;i-1,_t=/^.+Binding$/;f.mixin=j,f["default"]=M,M._apply=I,M.applyPartial=function(e){var t=vt.call(arguments,1);return I(e,t,!0)},M.finishPartial=S,W.anyUnprocessedMixins=!1,M.create=function(){W.anyUnprocessedMixins=!0;for(var e=this,t=arguments.length,r=new Array(t),n=0;t>n;n++)r[n]=arguments[n];return new e(r,void 0)};var wt=M.prototype;wt.reopen=function(){var e;this.properties?(e=new M(void 0,this.properties),this.properties=void 0,this.mixins=[e]):this.mixins||(this.mixins=[]);var t,r=arguments.length,n=this.mixins;for(t=0;r>t;t++)e=arguments[t],n.push(e instanceof M?e:new M(void 0,e));return this},wt.apply=function(e){return I(e,[this],!1)},wt.applyPartial=function(e){return I(e,[this],!0)},wt.detect=function(e){if(!e)return!1;if(e instanceof M)return R(e,this,{});var t=e.__ember_meta__,r=t&&t.mixins;return r?!!r[J(this)]:!1},wt.without=function(){var e=new M([this]);return e._without=vt.call(arguments),e},wt.keys=function(){var e={},t={},r=[];D(e,this,t);for(var n in e)e.hasOwnProperty(n)&&r.push(n);return r},M.mixins=function(e){var t=e.__ember_meta__,r=t&&t.mixins,n=[];if(!r)return n;for(var i in r){var a=r[i];a.properties||n.push(a)}return n},U=new it,U.toString=function(){return"(Required Property)"},f.required=L,F.prototype=new it,f.aliasMethod=B,f.observer=H,f.immediateObserver=z,f.beforeObserver=q,f.IS_BINDING=_t,f.Mixin=M}),e("ember-metal/observer",["ember-metal/watching","ember-metal/array","ember-metal/events","exports"],function(e,t,r,n){"use strict";function i(e){return e+E}function a(e){return e+O}function s(e,t,r,n){return _(e,i(t),r,n),v(e,t),this}function o(e,t){return y(e,i(t))}function u(e,t,r,n){return b(e,t),w(e,i(t),r,n),this}function l(e,t,r,n){return _(e,a(t),r,n),v(e,t),this}function c(e,t,r,n,i){return C(e,a(t),r,n,i)}function h(e,t,r,n,a){return C(e,i(t),r,n,a)}function m(e,t,r,n,i){var s=g.call(t,a);return x(e,s,r,n,i)}function p(e,t,r,n,a){var s=g.call(t,i);return x(e,s,r,n,a)}function f(e,t){return y(e,a(t))}function d(e,t,r,n){return b(e,t),w(e,a(t),r,n),this}var v=e.watch,b=e.unwatch,g=t.map,y=r.listenersFor,_=r.addListener,w=r.removeListener,x=r.suspendListeners,C=r.suspendListener,E=":change",O=":before";n.addObserver=s,n.observersFor=o,n.removeObserver=u,n.addBeforeObserver=l,n._suspendBeforeObserver=c,n._suspendObserver=h,n._suspendBeforeObservers=m,n._suspendObservers=p,n.beforeObserversFor=f,n.removeBeforeObserver=d}),e("ember-metal/observer_set",["ember-metal/utils","ember-metal/events","exports"],function(e,t,r){"use strict";function n(){this.clear()}var i=e.guidFor,a=t.sendEvent;r["default"]=n,n.prototype.add=function(e,t,r){var n,a=this.observerSet,s=this.observers,o=i(e),u=a[o];return u||(a[o]=u={}),n=u[t],void 0===n&&(n=s.push({sender:e,keyName:t,eventName:r,listeners:[]})-1,u[t]=n),s[n].listeners},n.prototype.flush=function(){var e,t,r,n,i=this.observers;for(this.clear(),e=0,t=i.length;t>e;++e)r=i[e],n=r.sender,n.isDestroying||n.isDestroyed||a(n,r.eventName,[n,r.keyName],r.listeners)},n.prototype.clear=function(){this.observerSet={},this.observers=[]}}),e("ember-metal/path_cache",["ember-metal/cache","exports"],function(e,t){"use strict";function r(e){return m.get(e)}function n(e){return p.get(e)}function i(e){return f.get(e)}function a(e){return-1!==d.get(e)}function s(e){return v.get(e)}function o(e){return b.get(e)}var u=e["default"],l=/^([A-Z$]|([0-9][A-Z$]))/,c=/^([A-Z$]|([0-9][A-Z$])).*[\.]/,h="this.",m=new u(1e3,function(e){return l.test(e)}),p=new u(1e3,function(e){return c.test(e)}),f=new u(1e3,function(e){return 0===e.lastIndexOf(h,0)}),d=new u(1e3,function(e){return e.indexOf(".")}),v=new u(1e3,function(e){var t=d.get(e);return-1===t?e:e.slice(0,t)}),b=new u(1e3,function(e){var t=d.get(e);return-1!==t?e.slice(t+1):void 0}),g={isGlobalCache:m,isGlobalPathCache:p,hasThisCache:f,firstDotIndexCache:d,firstKeyCache:v,tailPathCache:b};t.caches=g,t.isGlobal=r,t.isGlobalPath=n,t.hasThis=i,t.isPath=a,t.getFirstKey=s,t.getTailPath=o}),e("ember-metal/platform",["ember-metal/platform/define_property","ember-metal/platform/define_properties","ember-metal/platform/create","exports"],function(e,t,r,n){"use strict";var i=e.hasES5CompliantDefineProperty,a=e.defineProperty,s=t["default"],o=r["default"],u=i,l=i;n.create=o,n.defineProperty=a,n.defineProperties=s,n.hasPropertyAccessors=u,n.canDefineNonEnumerableProperties=l}),e("ember-metal/platform/create",["ember-metal/platform/define_properties","exports"],function(e,t){var r,n=e["default"];if(!Object.create||Object.create(null).hasOwnProperty){var i,a=!({__proto__:null}instanceof Object);i=a||"undefined"==typeof document?function(){return{__proto__:null}}:function(){function e(){}var t=document.createElement("iframe"),r=document.body||document.documentElement;t.style.display="none",r.appendChild(t),t.src="javascript:";var n=t.contentWindow.Object.prototype;return r.removeChild(t),t=null,delete n.constructor,delete n.hasOwnProperty,delete n.propertyIsEnumerable,delete n.isPrototypeOf,delete n.toLocaleString,delete n.toString,delete n.valueOf,e.prototype=n,i=function(){return new e},new e},r=Object.create=function(e,t){function r(){}var a;if(null===e)a=i();else{if("object"!=typeof e&&"function"!=typeof e)throw new TypeError("Object prototype may only be an Object or null");r.prototype=e,a=new r}return void 0!==t&&n(a,t),a}}else r=Object.create;t["default"]=r}),e("ember-metal/platform/define_properties",["ember-metal/platform/define_property","exports"],function(e,t){"use strict";var r=e.defineProperty,n=Object.defineProperties;n||(n=function(e,t){for(var n in t)t.hasOwnProperty(n)&&"__proto__"!==n&&r(e,n,t[n]);return e},Object.defineProperties=n),t["default"]=n}),e("ember-metal/platform/define_property",["exports"],function(e){"use strict";var t=function(e){if(e)try{var t=5,r={};if(e(r,"a",{configurable:!0,enumerable:!0,get:function(){return t},set:function(e){t=e}}),5!==r.a)return;if(r.a=10,10!==t)return;e(r,"a",{configurable:!0,enumerable:!1,writable:!0,value:!0});for(var n in r)if("a"===n)return;if(r.a!==!0)return;if(e(r,"a",{enumerable:!1}),r.a!==!0)return;return e}catch(i){return}}(Object.defineProperty),r=!!t;if(r&&"undefined"!=typeof document){var n=function(){try{return t(document.createElement("div"),"definePropertyOnDOM",{}),!0}catch(e){}return!1}();n||(t=function(e,t,r){var n;return n="object"==typeof Node?e instanceof Node:"object"==typeof e&&"number"==typeof e.nodeType&&"string"==typeof e.nodeName,n?e[t]=r.value:Object.defineProperty(e,t,r)})}r||(t=function(e,t,r){r.get||(e[t]=r.value)}),e.hasES5CompliantDefineProperty=r,e.defineProperty=t}),e("ember-metal/properties",["ember-metal/core","ember-metal/utils","ember-metal/platform","ember-metal/property_events","exports"],function(e,t,r,n,i){"use strict";function a(){}function s(){return function(){}}function o(e){return function(){var t=this.__ember_meta__;return t&&t.values[e]}}function u(e,t,r,n,i){var s,o,u,m;i||(i=l(e)),s=i.descs,o=i.descs[t];var p=i.watching[t];return u=void 0!==p&&p>0,o instanceof a&&o.teardown(e,t),r instanceof a?(m=r,s[t]=r,e[t]=void 0,r.setup&&r.setup(e,t)):(s[t]=void 0,null==r?(m=n,e[t]=n):(m=r,c(e,t,r))),u&&h(e,t,i),e.didDefineProperty&&e.didDefineProperty(e,t,m),this}var l=(e["default"],t.meta),c=r.defineProperty,h=(r.hasPropertyAccessors,n.overrideChains);i.Descriptor=a,i.MANDATORY_SETTER_FUNCTION=s,i.DEFAULT_GETTER_FUNCTION=o,i.defineProperty=u}),e("ember-metal/property_events",["ember-metal/utils","ember-metal/events","ember-metal/observer_set","exports"],function(e,t,r,n){"use strict";function i(e,t){var r=e.__ember_meta__,n=r&&r.watching[t]>0||"length"===t,i=r&&r.proto,a=r&&r.descs[t];n&&i!==e&&(a&&a.willChange&&a.willChange(e,t),s(e,t,r),c(e,t,r),v(e,t))}function a(e,t){var r=e.__ember_meta__,n=r&&r.watching[t]>0||"length"===t,i=r&&r.proto,a=r&&r.descs[t];i!==e&&(a&&a.didChange&&a.didChange(e,t),(n||"length"===t)&&(r&&r.deps&&r.deps[t]&&o(e,t,r),h(e,t,r,!1),b(e,t)))}function s(e,t,r){if(!e.isDestroying){var n;if(r&&r.deps&&(n=r.deps[t])){var a=g,s=!a;s&&(a=g={}),l(i,e,n,t,a,r),s&&(g=null)}}}function o(e,t,r){if(!e.isDestroying){var n;if(r&&r.deps&&(n=r.deps[t])){var i=y,s=!i;s&&(i=y={}),l(a,e,n,t,i,r),s&&(y=null)}}}function u(e){var t=[];for(var r in e)t.push(r);return t}function l(e,t,r,n,i,a){var s,o,l,c,h=_(t),m=i[h];if(m||(m=i[h]={}),!m[n]&&(m[n]=!0,r)){s=u(r);var p=a.descs;for(l=0;ln;n++)s[n].willChange(o);for(n=0,a=o.length;a>n;n+=2)i(o[n],o[n+1])}}function h(e,t,r,n){if(r&&r.hasOwnProperty("chainWatchers")&&r.chainWatchers[t]){var i,s,o=r.chainWatchers[t],u=n?null:[];for(i=0,s=o.length;s>i;i++)o[i].didChange(u);if(!n)for(i=0,s=u.length;s>i;i+=2)a(u[i],u[i+1])}}function m(e,t,r){h(e,t,r,!0)}function p(){A++}function f(){A--,0>=A&&(O.clear(),P.flush())}function d(e,t){p(),w(e,f,t)}function v(e,t){if(!e.isDestroying){var r,n,i=t+":before";A?(r=O.add(e,t,i),n=C(e,i,r),x(e,i,[e,t],n)):x(e,i,[e,t])}}function b(e,t){if(!e.isDestroying){var r,n=t+":change";A?(r=P.add(e,t,n),C(e,n,r)):x(e,n,[e,t])}}var g,y,_=e.guidFor,w=e.tryFinally,x=t.sendEvent,C=t.accumulateListeners,E=r["default"],O=new E,P=new E,A=0;n.propertyWillChange=i,n.propertyDidChange=a,n.overrideChains=m,n.beginPropertyChanges=p,n.endPropertyChanges=f,n.changeProperties=d}),e("ember-metal/property_get",["ember-metal/core","ember-metal/error","ember-metal/path_cache","ember-metal/platform","exports"],function(e,t,r,n,i){"use strict";function a(e,t){var r,n=m(t),i=!n&&c(t);if((!e||i)&&(e=u.lookup),n&&(t=t.slice(5)),e===u.lookup&&(r=t.match(p)[0],e=f(e,r),t=t.slice(r.length+1)),!t||0===t.length)throw new l("Path cannot be empty");return[e,t]}function s(e,t){var r,n,i,s,o;if(null===e&&!h(t))return f(u.lookup,t);for(r=m(t),(!e||r)&&(i=a(e,t),e=i[0],t=i[1],i.length=0),n=t.split("."),o=n.length,s=0;null!=e&&o>s;s++)if(e=f(e,n[s],!0),e&&e.isDestroyed)return void 0;return e}function o(e,t,r){var n=f(e,t);return void 0===n?r:n}var u=e["default"],l=t["default"],c=r.isGlobalPath,h=r.isPath,m=r.hasThis,p=(n.hasPropertyAccessors,/^([^\.]+)/),f=function(e,t){if(""===t)return e;if(t||"string"!=typeof e||(t=e,e=null),null===e){var r=s(e,t);return r}var n,i=e.__ember_meta__,a=i&&i.descs[t];return void 0===a&&h(t)?s(e,t):a?a.get(e,t):(n=e[t],void 0!==n||"object"!=typeof e||t in e||"function"!=typeof e.unknownProperty?n:e.unknownProperty(t))};i.getWithDefault=o,i["default"]=f,i.get=f,i.normalizeTuple=a,i._getPath=s}),e("ember-metal/property_set",["ember-metal/core","ember-metal/property_get","ember-metal/property_events","ember-metal/properties","ember-metal/error","ember-metal/path_cache","ember-metal/platform","exports"],function(e,t,r,n,i,a,s,o){"use strict";function u(e,t,r,n){var i;if(i=t.slice(t.lastIndexOf(".")+1),t=t===i?i:t.slice(0,t.length-(i.length+1)),"this"!==t&&(e=c(e,t)),!i||0===i.length)throw new p("Property set failed: You passed an empty path");if(!e){if(n)return;throw new p('Property set failed: object in path "'+t+'" could not be found or was destroyed.')}return d(e,i,r)}function l(e,t,r){return d(e,t,r,!0)}var c=(e["default"],t._getPath),h=r.propertyWillChange,m=r.propertyDidChange,p=(n.defineProperty,i["default"]),f=a.isPath,d=(s.hasPropertyAccessors,function(e,t,r,n){if("string"==typeof e&&(r=t,t=e,e=null),!e)return u(e,t,r,n);var i,a,s=e.__ember_meta__,o=s&&s.descs[t];if(void 0===o&&f(t))return u(e,t,r,n);if(void 0!==o)o.set(e,t,r);else{if("object"==typeof e&&null!==e&&void 0!==r&&e[t]===r)return r;i="object"==typeof e&&!(t in e),i&&"function"==typeof e.setUnknownProperty?e.setUnknownProperty(t,r):s&&s.watching[t]>0?(s.proto!==e&&(a=e[t]),r!==a&&(h(e,t),e[t]=r,m(e,t))):e[t]=r}return r});o.trySet=l,o.set=d}),e("ember-metal/run_loop",["ember-metal/core","ember-metal/utils","ember-metal/array","ember-metal/property_events","backburner","exports"],function(e,t,r,n,i,a){"use strict";function s(e){u.currentRunLoop=e}function o(e,t){u.currentRunLoop=t}function u(){return b.run.apply(b,arguments)}function l(){!u.currentRunLoop}var c=e["default"],h=t.apply,m=t.GUID_KEY,p=r.indexOf,f=n.beginPropertyChanges,d=n.endPropertyChanges,v=i["default"],b=new v(["sync","actions","destroy"],{GUID_KEY:m,sync:{before:f,after:d},defaultQueue:"actions",onBegin:s,onEnd:o,onErrorTarget:c,onErrorMethod:"onerror"}),g=[].slice;a["default"]=u,u.join=function(){return b.join.apply(b,arguments)},u.bind=function(){var e=g.call(arguments);return function(){return u.join.apply(u,e.concat(g.call(arguments)))}},u.backburner=b,u.currentRunLoop=null,u.queues=b.queueNames,u.begin=function(){b.begin()},u.end=function(){b.end()},u.schedule=function(){l(),b.schedule.apply(b,arguments)},u.hasScheduledTimers=function(){return b.hasTimers()},u.cancelTimers=function(){b.cancelTimers()},u.sync=function(){b.currentInstance&&b.currentInstance.queues.sync.flush()},u.later=function(){return b.later.apply(b,arguments)},u.once=function(){l();var e=arguments.length,t=new Array(e);t[0]="actions";for(var r=0;e>r;r++)t[r+1]=arguments[r];return h(b,b.scheduleOnce,t)},u.scheduleOnce=function(){return l(),b.scheduleOnce.apply(b,arguments)},u.next=function(){var e=g.call(arguments);return e.push(1),h(b,b.later,e)},u.cancel=function(e){return b.cancel(e)},u.debounce=function(){return b.debounce.apply(b,arguments)},u.throttle=function(){return b.throttle.apply(b,arguments)},u._addQueue=function(e,t){-1===p.call(u.queues,e)&&u.queues.splice(p.call(u.queues,t)+1,0,e)}}),e("ember-metal/set_properties",["ember-metal/property_events","ember-metal/property_set","ember-metal/keys","exports"],function(e,t,r,n){"use strict";var i=e.changeProperties,a=t.set,s=r["default"];n["default"]=function(e,t){return t&&"object"==typeof t?(i(function(){for(var r,n=s(t),i=0,o=n.length;o>i;i++)r=n[i],a(e,r,t[r])}),e):e}}),e("ember-metal/streams/simple",["ember-metal/merge","ember-metal/streams/stream","ember-metal/platform","ember-metal/streams/utils","exports"],function(e,t,r,n,i){"use strict";function a(e){this.init(),this.source=e,c(e)&&e.subscribe(this._didChange,this)}var s=e["default"],o=t["default"],u=r.create,l=n.read,c=n.isStream;a.prototype=u(o.prototype),s(a.prototype,{valueFn:function(){return l(this.source)},setValue:function(e){var t=this.source;c(t)&&t.setValue(e)},setSource:function(e){var t=this.source;e!==t&&(c(t)&&t.unsubscribe(this._didChange,this),c(e)&&e.subscribe(this._didChange,this),this.source=e,this.notify())},_didChange:function(){this.notify()},_super$destroy:o.prototype.destroy,destroy:function(){return this._super$destroy()?(c(this.source)&&this.source.unsubscribe(this._didChange,this),this.source=void 0,!0):void 0}}),i["default"]=a}),e("ember-metal/streams/stream",["ember-metal/platform","ember-metal/path_cache","exports"],function(e,t,r){"use strict";function n(e){this.init(),this.valueFn=e}var i=e.create,a=t.getFirstKey,s=t.getTailPath;n.prototype={isStream:!0,init:function(){this.state="dirty",this.cache=void 0,this.subscribers=void 0,this.children=void 0,this._label=void 0},get:function(e){var t=a(e),r=s(e);void 0===this.children&&(this.children=i(null));var n=this.children[t];return void 0===n&&(n=this._makeChildStream(t,e),this.children[t]=n),void 0===r?n:n.get(r)},value:function(){return"clean"===this.state?this.cache:"dirty"===this.state?(this.state="clean",this.cache=this.valueFn()):void 0},valueFn:function(){throw new Error("Stream error: valueFn not implemented")},setValue:function(){throw new Error("Stream error: setValue not implemented")},notify:function(){this.notifyExcept()},notifyExcept:function(e,t){"clean"===this.state&&(this.state="dirty",this._notifySubscribers(e,t))},subscribe:function(e,t){void 0===this.subscribers?this.subscribers=[e,t]:this.subscribers.push(e,t)},unsubscribe:function(e,t){var r=this.subscribers;if(void 0!==r)for(var n=0,i=r.length;i>n;n+=2)if(r[n]===e&&r[n+1]===t)return void r.splice(n,2)},_notifySubscribers:function(e,t){var r=this.subscribers;if(void 0!==r)for(var n=0,i=r.length;i>n;n+=2){var a=r[n],s=r[n+1];(a!==e||s!==t)&&(void 0===s?a(this):a.call(s,this))}},destroy:function(){if("destroyed"!==this.state){this.state="destroyed";var e=this.children;for(var t in e)e[t].destroy();return!0}},isGlobal:function(){for(var e=this;void 0!==e;){if(e._isRoot)return e._isGlobal;e=e.source}}},r["default"]=n}),e("ember-metal/streams/stream_binding",["ember-metal/platform","ember-metal/merge","ember-metal/run_loop","ember-metal/streams/stream","exports"],function(e,t,r,n,i){"use strict";function a(e){this.init(),this.stream=e,this.senderCallback=void 0,this.senderContext=void 0,this.senderValue=void 0,e.subscribe(this._onNotify,this)}var s=e.create,o=t["default"],u=r["default"],l=n["default"];a.prototype=s(l.prototype),o(a.prototype,{valueFn:function(){return this.stream.value()},_onNotify:function(){this._scheduleSync(void 0,void 0,this)},setValue:function(e,t,r){this._scheduleSync(e,t,r)},_scheduleSync:function(e,t,r){void 0===this.senderCallback&&void 0===this.senderContext?(this.senderCallback=t,this.senderContext=r,this.senderValue=e,u.schedule("sync",this,this._sync)):this.senderContext!==this&&(this.senderCallback=t,this.senderContext=r,this.senderValue=e)},_sync:function(){if("destroyed"!==this.state){this.senderContext!==this&&this.stream.setValue(this.senderValue);var e=this.senderCallback,t=this.senderContext;this.senderCallback=void 0,this.senderContext=void 0,this.senderValue=void 0,this.state="clean",this.notifyExcept(e,t)}},_super$destroy:l.prototype.destroy,destroy:function(){return this._super$destroy()?(this.stream.unsubscribe(this._onNotify,this),!0):void 0}}),i["default"]=a}),e("ember-metal/streams/utils",["./stream","exports"],function(e,t){"use strict";function r(e){return e&&e.isStream}function n(e,t,r){e&&e.isStream&&e.subscribe(t,r)}function i(e,t,r){e&&e.isStream&&e.unsubscribe(t,r)}function a(e){return e&&e.isStream?e.value():e}function s(e){for(var t=e.length,r=new Array(t),n=0;t>n;n++)r[n]=a(e[n]);return r}function o(e){var t={};for(var r in e)t[r]=a(e[r]);return t}function u(e){for(var t=e.length,n=!1,i=0;t>i;i++)if(r(e[i])){n=!0;break}return n}function l(e){var t=!1;for(var n in e)if(r(e[n])){t=!0;break}return t}function c(e,t){var r=u(e);
-if(r){var i,a,o=new m(function(){return s(e).join(t)});for(i=0,a=e.length;a>i;i++)n(e[i],o.notify,o);return o}return e.join(t)}function h(e,t){if(r(e)){var i=new m(t);return n(e,i.notify,i),i}return t()}var m=e["default"];t.isStream=r,t.subscribe=n,t.unsubscribe=i,t.read=a,t.readArray=s,t.readHash=o,t.scanArray=u,t.scanHash=l,t.concat=c,t.chain=h}),e("ember-metal/utils",["ember-metal/core","ember-metal/platform","ember-metal/array","exports"],function(e,t,r,n){function i(){return++A}function a(e){var t={};t[e]=1;for(var r in t)if(r===e)return r;return e}function s(e,t){t||(t=N);var r=t+i();return e&&(null===e[k]?e[k]=r:(V.value=r,C(e,k,V))),r}function o(e){if(void 0===e)return"(undefined)";if(null===e)return"(null)";var t,r=typeof e;switch(r){case"number":return t=S[e],t||(t=S[e]="nu"+e),t;case"string":return t=T[e],t||(t=T[e]="st"+i()),t;case"boolean":return e?"(true)":"(false)";default:return e[k]?e[k]:e===Object?"(Object)":e===Array?"(Array)":(t=N+i(),null===e[k]?e[k]=t:(V.value=t,C(e,k,V)),t)}}function u(e){this.descs={},this.watching={},this.cache={},this.cacheMeta={},this.source=e,this.deps=void 0,this.listeners=void 0,this.mixins=void 0,this.bindings=void 0,this.chains=void 0,this.values=void 0,this.proto=void 0}function l(e,t){var r=e.__ember_meta__;return t===!1?r||j:(r?r.source!==e&&(E&&C(e,"__ember_meta__",I),r=O(r),r.descs=O(r.descs),r.watching=O(r.watching),r.cache={},r.cacheMeta={},r.source=e,e.__ember_meta__=r):(E&&C(e,"__ember_meta__",I),r=new u(e),e.__ember_meta__=r,r.descs.constructor=null),r)}function c(e,t){var r=l(e,!1);return r[t]}function h(e,t,r){var n=l(e,!0);return n[t]=r,r}function m(e,t,r){for(var n,i,a=l(e,r),s=0,o=t.length;o>s;s++){if(n=t[s],i=a[n]){if(i.__ember_source__!==e){if(!r)return void 0;i=a[n]=O(i),i.__ember_source__=e}}else{if(!r)return void 0;i=a[n]={__ember_source__:e}}a=i}return i}function p(e,t){function r(){var r,n=this&&this.__nextSuper,i=arguments.length;if(this&&(this.__nextSuper=t),0===i)r=e.call(this);else if(1===i)r=e.call(this,arguments[0]);else if(2===i)r=e.call(this,arguments[0],arguments[1]);else{for(var a=new Array(i),s=0;i>s;s++)a[s]=arguments[s];r=_(this,e,a)}return this&&(this.__nextSuper=n),r}return r.wrappedFunction=e,r.wrappedFunction.__ember_arity__=e.length,r.__ember_observes__=e.__ember_observes__,r.__ember_observesBefore__=e.__ember_observesBefore__,r.__ember_listens__=e.__ember_listens__,r}function f(e){var t,r;return"undefined"==typeof M&&(t="ember-runtime/mixins/array",x.__loader.registry[t]&&(M=x.__loader.require(t)["default"])),!e||e.setInterval?!1:Array.isArray&&Array.isArray(e)?!0:M&&M.detect(e)?!0:(r=g(e),"array"===r?!0:void 0!==e.length&&"object"===r?!0:!1)}function d(e){return null===e||void 0===e?[]:f(e)?e:[e]}function v(e,t){return!(!e||"function"!=typeof e[t])}function b(e,t,r){return v(e,t)?r?w(e,t,r):w(e,t):void 0}function g(e){var t,r;return"undefined"==typeof H&&(r="ember-runtime/system/object",x.__loader.registry[r]&&(H=x.__loader.require(r)["default"])),t=null===e||void 0===e?String(e):F[z.call(e)]||"object","function"===t?H&&H.detect(e)&&(t="class"):"object"===t&&(e instanceof Error?t="error":H&&e instanceof H?t="instance":e instanceof Date&&(t="date")),t}function y(e){var t=g(e);if("array"===t)return"["+e+"]";if("object"!==t)return e+"";var r,n=[];for(var i in e)if(e.hasOwnProperty(i)){if(r=e[i],"toString"===r)continue;"function"===g(r)&&(r="function() { ... }"),n.push(r&&"function"!=typeof r.toString?i+": "+z.call(r):i+": "+r)}return"{"+n.join(", ")+"}"}function _(e,t,r){var n=r&&r.length;if(!r||!n)return t.call(e);switch(n){case 1:return t.call(e,r[0]);case 2:return t.call(e,r[0],r[1]);case 3:return t.call(e,r[0],r[1],r[2]);case 4:return t.call(e,r[0],r[1],r[2],r[3]);case 5:return t.call(e,r[0],r[1],r[2],r[3],r[4]);default:return t.apply(e,r)}}function w(e,t,r){var n=r&&r.length;if(!r||!n)return e[t]();switch(n){case 1:return e[t](r[0]);case 2:return e[t](r[0],r[1]);case 3:return e[t](r[0],r[1],r[2]);case 4:return e[t](r[0],r[1],r[2],r[3]);case 5:return e[t](r[0],r[1],r[2],r[3],r[4]);default:return e[t].apply(e,r)}}var x=e["default"],C=t.defineProperty,E=t.canDefineNonEnumerableProperties,O=(t.hasPropertyAccessors,t.create),P=r.forEach,A=0;n.uuid=i;var N="ember",S=[],T={},k=a("__ember"+ +new Date),V={writable:!1,configurable:!1,enumerable:!1,value:null};n.generateGuid=s,n.guidFor=o;var I={writable:!0,configurable:!1,enumerable:!1,value:null};u.prototype={chainWatchers:null},E||(u.prototype.__preventPlainObject__=!0,u.prototype.toJSON=function(){});var j=new u(null);n.getMeta=c,n.setMeta=h,n.metaPath=m,n.wrap=p;var M;n.makeArray=d,n.tryInvoke=b;var R,D=function(){var e=0;try{try{}finally{throw e++,new Error("needsFinallyFixTest")}}catch(t){}return 1!==e}();R=D?function(e,t,r){var n,i,a;r=r||this;try{n=e.call(r)}finally{try{i=t.call(r)}catch(s){a=s}}if(a)throw a;return void 0===i?n:i}:function(e,t,r){var n,i;r=r||this;try{n=e.call(r)}finally{i=t.call(r)}return void 0===i?n:i};var L;L=D?function(e,t,r,n){var i,a,s;n=n||this;try{i=e.call(n)}catch(o){i=t.call(n,o)}finally{try{a=r.call(n)}catch(u){s=u}}if(s)throw s;return void 0===a?i:a}:function(e,t,r,n){var i,a;n=n||this;try{i=e.call(n)}catch(s){i=t.call(n,s)}finally{a=r.call(n)}return void 0===a?i:a};var F={},B="Boolean Number String Function Array Date RegExp Object".split(" ");P.call(B,function(e){F["[object "+e+"]"]=e.toLowerCase()});var H,z=Object.prototype.toString;n.inspect=y,n.apply=_,n.applyStr=w,n.GUID_KEY=k,n.META_DESC=I,n.EMPTY_META=j,n.meta=l,n.typeOf=g,n.tryCatchFinally=L,n.isArray=f,n.canInvoke=v,n.tryFinally=R}),e("ember-metal/watch_key",["ember-metal/core","ember-metal/utils","ember-metal/platform","ember-metal/properties","exports"],function(e,t,r,n,i){"use strict";function a(e,t,r){if("length"!==t||"array"!==u(e)){var n=r||o(e),i=n.watching;if(i[t])i[t]=(i[t]||0)+1;else{i[t]=1;var a=n.descs[t];a&&a.willWatch&&a.willWatch(e,t),"function"==typeof e.willWatchProperty&&e.willWatchProperty(t)}}}function s(e,t,r){var n=r||o(e),i=n.watching;if(1===i[t]){i[t]=0;var a=n.descs[t];a&&a.didUnwatch&&a.didUnwatch(e,t),"function"==typeof e.didUnwatchProperty&&e.didUnwatchProperty(t)}else i[t]>1&&i[t]--}{var o=(e["default"],t.meta),u=t.typeOf;r.defineProperty,r.hasPropertyAccessors,n.MANDATORY_SETTER_FUNCTION,n.DEFAULT_GETTER_FUNCTION}i.watchKey=a,i.unwatchKey=s}),e("ember-metal/watch_path",["ember-metal/utils","ember-metal/chains","exports"],function(e,t,r){"use strict";function n(e,t){var r=t||s(e),n=r.chains;return n?n.value()!==e&&(n=r.chains=n.copy(e)):n=r.chains=new u(null,null,e),n}function i(e,t,r){if("length"!==t||"array"!==o(e)){var i=r||s(e),a=i.watching;a[t]?a[t]=(a[t]||0)+1:(a[t]=1,n(e,i).add(t))}}function a(e,t,r){var i=r||s(e),a=i.watching;1===a[t]?(a[t]=0,n(e,i).remove(t)):a[t]>1&&a[t]--}var s=e.meta,o=e.typeOf,u=t.ChainNode;r.watchPath=i,r.unwatchPath=a}),e("ember-metal/watching",["ember-metal/utils","ember-metal/chains","ember-metal/watch_key","ember-metal/watch_path","ember-metal/path_cache","exports"],function(e,t,r,n,i,a){"use strict";function s(e,t,r){("length"!==t||"array"!==c(e))&&(b(t)?d(e,t,r):p(e,t,r))}function o(e,t){var r=e.__ember_meta__;return(r&&r.watching[t])>0}function u(e,t,r){("length"!==t||"array"!==c(e))&&(b(t)?v(e,t,r):f(e,t,r))}function l(e){var t,r,n,i,a=e.__ember_meta__;if(a&&(e.__ember_meta__=null,t=a.chains))for(g.push(t);g.length>0;){if(t=g.pop(),r=t._chains)for(n in r)r.hasOwnProperty(n)&&g.push(r[n]);t._watching&&(i=t._object,i&&h(i,t._key,t))}}var c=e.typeOf,h=t.removeChainWatcher,m=t.flushPendingChains,p=r.watchKey,f=r.unwatchKey,d=n.watchPath,v=n.unwatchPath,b=i.isPath;a.watch=s,a.isWatching=o,s.flushPending=m,a.unwatch=u;var g=[];a.destroy=l}),e("ember-routing-htmlbars",["ember-metal/core","ember-htmlbars/helpers","ember-routing-htmlbars/helpers/outlet","ember-routing-htmlbars/helpers/render","ember-routing-htmlbars/helpers/link-to","ember-routing-htmlbars/helpers/action","ember-routing-htmlbars/helpers/query-params","exports"],function(e,t,r,n,i,a,s,o){"use strict";var u=e["default"],l=t.registerHelper,c=r.outletHelper,h=n.renderHelper,m=i.linkToHelper,p=i.deprecatedLinkToHelper,f=a.actionHelper,d=s.queryParamsHelper;l("outlet",c),l("render",h),l("link-to",m),l("linkTo",p),l("action",f),l("query-params",d),o["default"]=u}),e("ember-routing-htmlbars/helpers/action",["ember-metal/core","ember-metal/utils","ember-metal/run_loop","ember-views/streams/utils","ember-views/system/utils","ember-views/system/action_manager","ember-metal/array","ember-metal/streams/utils","exports"],function(e,t,r,n,i,a,s,o,u){"use strict";function l(e,t){var r,n,i;if(void 0===t)for(r=new Array(e.length),n=0,i=e.length;i>n;n++)r[n]=p(e[n]);else for(r=new Array(e.length+1),r[0]=t,n=0,i=e.length;i>n;n++)r[n+1]=p(e[n]);return r}function c(e,t,r,n){var i;i=t.target?v(t.target)?t.target:this.getStream(t.target):this.getStream("controller");var a={eventName:t.on||"click",parameters:e.slice(1),view:this,bubbles:t.bubbles,preventDefault:t.preventDefault,target:i,withKeyCode:t.withKeyCode},s=b.registerAction(e[0],a,t.allowedKeys);n.dom.setAttribute(r.element,"data-ember-action",s)}var h=(e["default"],t.uuid),m=r["default"],p=n.readUnwrappedModel,f=i.isSimpleClick,d=a["default"],v=(s.indexOf,o.isStream),b={};b.registeredActions=d.registeredActions,u.ActionHelper=b;var g=["alt","shift","meta","ctrl"],y=/^click|mouse|touch/,_=function(e,t){if("undefined"==typeof t){if(y.test(e.type))return f(e);t=""}if(t.indexOf("any")>=0)return!0;for(var r=0,n=g.length;n>r;r++)if(e[g[r]+"Key"]&&-1===t.indexOf(g[r]))return!1;return!0};b.registerAction=function(e,t,r){var n=h(),i=t.eventName,a=t.parameters;return d.registeredActions[n]={eventName:i,handler:function(n){if(!_(n,r))return!0;t.preventDefault!==!1&&n.preventDefault(),t.bubbles===!1&&n.stopPropagation();var i,s=t.target.value();i=v(e)?e.value():e,m(function(){s.send?s.send.apply(s,l(a,i)):s[i].apply(s,l(a))})}},t.view.on("willClearRender",function(){delete d.registeredActions[n]}),n},u.actionHelper=c}),e("ember-routing-htmlbars/helpers/link-to",["ember-metal/core","ember-routing-views/views/link","ember-metal/streams/utils","ember-runtime/mixins/controller","ember-htmlbars/templates/link-to-escaped","ember-htmlbars/templates/link-to-unescaped","ember-htmlbars","exports"],function(e,t,r,n,i,a,s,o){"use strict";function u(e,t,r,n){var i,a=!t.unescaped,s=e[e.length-1];if(s&&s.isQueryParams&&(t.queryParamsObject=i=e.pop()),t.disabledWhen&&(t.disabled=t.disabledWhen,delete t.disabledWhen),!r.template){var o=e.shift();t.layout=a?p:f,t.linkTitle=o}for(var u=0;u1){var y=i.lookupFactory(b)||c(i,v,p);s=y.create({modelBinding:d,parentController:g,target:g}),o.one("willDestroyElement",function(){s.destroy()})}else s=i.lookup(b)||h(i,v),s.setProperties({target:g,parentController:g});t.viewName=l(f);var _="template:"+f;t.template=i.lookup(_),t.controller=s,a&&!p&&a._connectActiveView(f,o),r.helperName=r.helperName||'render "'+f+'"',m.instanceHelper(o,t,r,n)}{var u=(e["default"],t["default"]),l=r.camelize,c=n.generateControllerFactory,h=n["default"],m=i.ViewHelper;a.isStream}s.renderHelper=o}),e("ember-routing-views",["ember-metal/core","ember-routing-views/views/link","ember-routing-views/views/outlet","exports"],function(e,t,r,n){"use strict";var i=e["default"],a=t.LinkView,s=r.OutletView;i.LinkView=a,i.OutletView=s,n["default"]=i}),e("ember-routing-views/views/link",["ember-metal/core","ember-metal/property_get","ember-metal/merge","ember-metal/run_loop","ember-metal/computed","ember-runtime/system/string","ember-metal/keys","ember-views/system/utils","ember-views/views/component","ember-routing/utils","ember-metal/streams/utils","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h){"use strict";function m(e){var t=e.queryParamsObject,r={};if(!t)return r;var n=t.values;for(var i in n)n.hasOwnProperty(i)&&(r[i]=C(n[i]));return r}function p(e){for(var t=0,r=e.length;r>t;++t){var n=e[t];if(null===n||"undefined"==typeof n)return!1}return!0}function f(e,t){var r;for(r in e)if(e.hasOwnProperty(r)&&e[r]!==t[r])return!1;for(r in t)if(t.hasOwnProperty(r)&&e[r]!==t[r])return!1;return!0}var d=e["default"],v=t.get,b=r["default"],g=n["default"],y=i.computed,_=(a.fmt,s["default"],o.isSimpleClick),w=u["default"],x=l.routeArgs,C=c.read,E=c.subscribe,O=function(e,t){for(var r=0,n=0,i=t.length;i>n&&(r+=t[n].names.length,t[n].handler!==e);n++);return r},P=d.LinkView=w.extend({tagName:"a",currentWhen:null,"current-when":null,title:null,rel:null,tabindex:null,target:null,activeClass:"active",loadingClass:"loading",disabledClass:"disabled",_isDisabled:!1,replace:!1,attributeBindings:["href","title","rel","tabindex"],classNameBindings:["active","loading","disabled"],eventName:"click",init:function(){this._super.apply(this,arguments);var e=v(this,"eventName");this.on(e,this,this._invoke)},_paramsChanged:function(){this.notifyPropertyChange("resolvedParams")},_setupPathObservers:function(){for(var e=this.params,t=this._wrapAsScheduled(this._paramsChanged),r=0;ro&&(e=s);var u=x(e,n,null),l=t.isActive.apply(t,u);if(!l)return!1;var c=d.isEmpty(d.keys(r.queryParams));if(!a&&!c&&l){var h={};b(h,r.queryParams),t._prepareQueryParams(r.targetRouteName,r.models,h),l=f(h,t.router.state.queryParams)}return l}if(v(this,"loading"))return!1;var t=v(this,"router"),r=v(this,"loadedParams"),n=r.models,i=this["current-when"]||this.currentWhen,a=Boolean(i);i=i||r.targetRouteName,i=i.split(" ");for(var s=0,o=i.length;o>s;s++)if(e(i[s]))return v(this,"activeClass")}),loading:y("loadedParams",function(){return v(this,"loadedParams")?void 0:v(this,"loadingClass")}),router:y(function(){var e=v(this,"controller");return e&&e.container?e.container.lookup("router:main"):void 0}),_invoke:function(e){if(!_(e))return!0;if(this.preventDefault!==!1){var t=v(this,"target");t&&"_self"!==t||e.preventDefault()}if(this.bubbles===!1&&e.stopPropagation(),v(this,"_isDisabled"))return!1;if(v(this,"loading"))return d.Logger.warn("This link-to is in an inactive loading state because at least one of its parameters presently has a null/undefined value, or the provided route name is invalid."),!1;var r=v(this,"target");if(r&&"_self"!==r)return!1;var n=v(this,"router"),i=v(this,"loadedParams"),a=n._doTransition(i.targetRouteName,i.models,i.queryParams);v(this,"replace")&&a.method("replace");var s=x(i.targetRouteName,i.models,a.state.queryParams),o=n.router.generate.apply(n.router,s);g.scheduleOnce("routerTransitions",this,this._eagerUpdateUrl,a,o)},_eagerUpdateUrl:function(e,t){if(e.isActive&&e.urlMethod){0===t.indexOf("#")&&(t=t.slice(1));var r=v(this,"router.router");"update"===e.urlMethod?r.updateURL(t):"replace"===e.urlMethod&&r.replaceURL(t),e.method(null)}},resolvedParams:y("router.url",function(){var e,t=this.params,r=[],n=0===t.length;if(n){var i=this.container.lookup("controller:application");e=v(i,"currentRouteName")}else{e=C(t[0]);for(var a=1;an;++n)u(t[n],r);return r}),_cacheMeta:m(function(){var e=f(this);if(e.proto!==this)return c(e.proto,"_cacheMeta");var t={},r=c(this,"_normalizedQueryParams");for(var n in r)if(r.hasOwnProperty(n)){var i,a=r[n],s=a.scope;"controller"===s&&(i=[]),t[n]={parts:i,values:null,scope:s,prefix:"",def:c(this,n)}}return t}),_updateCacheParams:function(e){var t=c(this,"_cacheMeta");for(var r in t)if(t.hasOwnProperty(r)){var n=t[r];n.values=e;var i=this._calculateCacheKey(n.prefix,n.parts,n.values),a=this._bucketCache;if(a){var s=a.lookup(i,r,n.def);h(this,r,s)}}},_qpChanged:function(e,t){var r=t.substr(0,t.length-3),n=c(e,"_cacheMeta"),i=n[r],a=e._calculateCacheKey(i.prefix||"",i.parts,i.values),s=c(e,r),o=this._bucketCache;o&&e._bucketCache.stash(a,r,s);var u=e._qpDelegate;u&&u(e,r)},_calculateCacheKey:function(e,t,r){for(var n=t||[],i="",a=0,s=n.length;s>a;++a){var o=n[a],u=c(r,o);i+="::"+o+":"+u}return e+i.replace(b,"-")},transitionToRoute:function(){var e=c(this,"target"),t=e.transitionToRoute||e.transitionTo;return t.apply(e,arguments)},transitionTo:function(){return this.transitionToRoute.apply(this,arguments)},replaceRoute:function(){var e=c(this,"target"),t=e.replaceRoute||e.replaceWith;return t.apply(e,arguments)},replaceWith:function(){return this.replaceRoute.apply(this,arguments)}});var b=/\./g;o["default"]=v}),e("ember-routing/ext/run_loop",["ember-metal/run_loop"],function(e){"use strict";var t=e["default"];t._addQueue("routerTransitions","actions")}),e("ember-routing/ext/view",["ember-metal/property_get","ember-metal/property_set","ember-metal/run_loop","ember-views/views/view","exports"],function(e,t,r,n,i){"use strict";var a=e.get,s=t.set,o=r["default"],u=n["default"];u.reopen({init:function(){this._outlets={},this._super()},connectOutlet:function(e,t){if(this._pendingDisconnections&&delete this._pendingDisconnections[e],this._hasEquivalentView(e,t))return void t.destroy();var r=a(this,"_outlets"),n=a(this,"container"),i=n&&n.lookup("router:main"),o=a(t,"renderedName");s(r,e,t),i&&o&&i._connectActiveView(o,t)},_hasEquivalentView:function(e,t){var r=a(this,"_outlets."+e);return r&&r.constructor===t.constructor&&r.get("template")===t.get("template")&&r.get("context")===t.get("context")},disconnectOutlet:function(e){this._pendingDisconnections||(this._pendingDisconnections={}),this._pendingDisconnections[e]=!0,o.once(this,"_finishDisconnections")},_finishDisconnections:function(){if(!this.isDestroyed){var e=a(this,"_outlets"),t=this._pendingDisconnections;this._pendingDisconnections=null;for(var r in t)s(e,r,null)}}}),i["default"]=u}),e("ember-routing/location/api",["ember-metal/core","exports"],function(e,t){"use strict";e["default"];t["default"]={create:function(e){var t=e&&e.implementation,r=this.implementations[t];return r.create.apply(r,arguments)},registerImplementation:function(e,t){this.implementations[e]=t},implementations:{},_location:window.location,_getHash:function(){var e=(this._location||this.location).href,t=e.indexOf("#");return-1===t?"":e.substr(t)}}}),e("ember-routing/location/auto_location",["ember-metal/core","ember-metal/property_set","ember-routing/location/api","ember-routing/location/history_location","ember-routing/location/hash_location","ember-routing/location/none_location","exports"],function(e,t,r,n,i,a,s){"use strict";var o=(e["default"],t.set),u=r["default"],l=n["default"],c=i["default"],h=a["default"];s["default"]={cancelRouterSetup:!1,rootURL:"/",_window:window,_location:window.location,_history:window.history,_HistoryLocation:l,_HashLocation:c,_NoneLocation:h,_getOrigin:function(){var e=this._location,t=e.origin;return t||(t=e.protocol+"//"+e.hostname,e.port&&(t+=":"+e.port)),t},_getSupportsHistory:function(){var e=this._window.navigator.userAgent;return-1!==e.indexOf("Android 2")&&-1!==e.indexOf("Mobile Safari")&&-1===e.indexOf("Chrome")?!1:!!(this._history&&"pushState"in this._history)},_getSupportsHashChange:function(){var e=this._window,t=e.document.documentMode;return"onhashchange"in e&&(void 0===t||t>7)},_replacePath:function(e){this._location.replace(this._getOrigin()+e)},_getRootURL:function(){return this.rootURL},_getPath:function(){var e=this._location.pathname;return"/"!==e.charAt(0)&&(e="/"+e),e},_getHash:u._getHash,_getQuery:function(){return this._location.search},_getFullPath:function(){return this._getPath()+this._getQuery()+this._getHash()},_getHistoryPath:function(){{var e,t,r=this._getRootURL(),n=this._getPath(),i=this._getHash(),a=this._getQuery();n.indexOf(r)}return"#/"===i.substr(0,2)?(t=i.substr(1).split("#"),e=t.shift(),"/"===n.slice(-1)&&(e=e.substr(1)),n+=e,n+=a,t.length&&(n+="#"+t.join("#"))):(n+=a,n+=i),n},_getHashPath:function(){var e=this._getRootURL(),t=e,r=this._getHistoryPath(),n=r.substr(e.length);return""!==n&&("/"!==n.charAt(0)&&(n="/"+n),t+="#"+n),t},create:function(e){e&&e.rootURL&&(this.rootURL=e.rootURL);var t,r,n=!1,i=this._NoneLocation,a=this._getFullPath();this._getSupportsHistory()?(t=this._getHistoryPath(),a===t?i=this._HistoryLocation:"/#"===a.substr(0,2)?(this._history.replaceState({path:t},null,t),i=this._HistoryLocation):(n=!0,this._replacePath(t))):this._getSupportsHashChange()&&(r=this._getHashPath(),a===r||"/"===a&&"/#/"===r?i=this._HashLocation:(n=!0,this._replacePath(r)));var s=i.create.apply(i,arguments);return n&&o(s,"cancelRouterSetup",!0),s}}}),e("ember-routing/location/hash_location",["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/run_loop","ember-metal/utils","ember-runtime/system/object","ember-routing/location/api","exports"],function(e,t,r,n,i,a,s,o){"use strict";var u=e["default"],l=t.get,c=r.set,h=n["default"],m=i.guidFor,p=a["default"],f=s["default"];o["default"]=p.extend({implementation:"hash",init:function(){c(this,"location",l(this,"_location")||window.location)},getHash:f._getHash,getURL:function(){var e=this.getHash().substr(1),t=e;return"/"!==t.charAt(0)&&(t="/",e&&(t+="#"+e)),t},setURL:function(e){l(this,"location").hash=e,c(this,"lastSetURL",e)},replaceURL:function(e){l(this,"location").replace("#"+e),c(this,"lastSetURL",e)},onUpdateURL:function(e){var t=this,r=m(this);u.$(window).on("hashchange.ember-location-"+r,function(){h(function(){var r=t.getURL();l(t,"lastSetURL")!==r&&(c(t,"lastSetURL",null),e(r))})})},formatURL:function(e){return"#"+e},willDestroy:function(){var e=m(this);u.$(window).off("hashchange.ember-location-"+e)}})}),e("ember-routing/location/history_location",["ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-runtime/system/object","ember-routing/location/api","ember-views/system/jquery","exports"],function(e,t,r,n,i,a,s){"use strict";var o=e.get,u=t.set,l=r.guidFor,c=n["default"],h=i["default"],m=a["default"],p=!1,f=window.history&&"state"in window.history;s["default"]=c.extend({implementation:"history",init:function(){u(this,"location",o(this,"location")||window.location),u(this,"baseURL",m("base").attr("href")||"")},initState:function(){u(this,"history",o(this,"history")||window.history),this.replaceState(this.formatURL(this.getURL()))},rootURL:"/",getURL:function(){var e=o(this,"rootURL"),t=o(this,"location"),r=t.pathname,n=o(this,"baseURL");e=e.replace(/\/$/,""),n=n.replace(/\/$/,"");var i=r.replace(n,"").replace(e,""),a=t.search||"";return i+=a,i+=this.getHash()},setURL:function(e){var t=this.getState();e=this.formatURL(e),t&&t.path===e||this.pushState(e)},replaceURL:function(e){var t=this.getState();e=this.formatURL(e),t&&t.path===e||this.replaceState(e)},getState:function(){return f?o(this,"history").state:this._historyState},pushState:function(e){var t={path:e};o(this,"history").pushState(t,null,e),f||(this._historyState=t),this._previousURL=this.getURL()},replaceState:function(e){var t={path:e};o(this,"history").replaceState(t,null,e),f||(this._historyState=t),this._previousURL=this.getURL()},onUpdateURL:function(e){var t=l(this),r=this;m(window).on("popstate.ember-location-"+t,function(){(p||(p=!0,r.getURL()!==r._previousURL))&&e(r.getURL())})},formatURL:function(e){var t=o(this,"rootURL"),r=o(this,"baseURL");return""!==e?(t=t.replace(/\/$/,""),r=r.replace(/\/$/,"")):r.match(/^\//)&&t.match(/^\//)&&(r=r.replace(/\/$/,"")),r+t+e},willDestroy:function(){var e=l(this);m(window).off("popstate.ember-location-"+e)},getHash:h._getHash})}),e("ember-routing/location/none_location",["ember-metal/property_get","ember-metal/property_set","ember-runtime/system/object","exports"],function(e,t,r,n){"use strict";var i=e.get,a=t.set,s=r["default"];n["default"]=s.extend({implementation:"none",path:"",getURL:function(){return i(this,"path")},setURL:function(e){a(this,"path",e)},onUpdateURL:function(e){this.updateCallback=e},handleURL:function(e){a(this,"path",e),this.updateCallback(e)},formatURL:function(e){return e}})}),e("ember-routing/system/cache",["ember-runtime/system/object","exports"],function(e,t){"use strict";var r=e["default"];t["default"]=r.extend({init:function(){this.cache={}},has:function(e){return e in this.cache},stash:function(e,t,r){var n=this.cache[e];n||(n=this.cache[e]={}),n[t]=r},lookup:function(e,t,r){var n=this.cache;if(!(e in n))return r;var i=n[e];return t in i?i[t]:r},cache:null})}),e("ember-routing/system/controller_for",["exports"],function(e){"use strict";e["default"]=function(e,t,r){return e.lookup("controller:"+t,r)}}),e("ember-routing/system/dsl",["ember-metal/core","exports"],function(e,t){"use strict";function r(e){this.parent=e,this.matches=[]}function n(e){return e.parent&&"application"!==e.parent}function i(e,t,r){return n(e)&&r!==!0?e.parent+"."+t:t}function a(e,t,r,n){r=r||{};var a=i(e,t,r.resetNamespace);"string"!=typeof r.path&&(r.path="/"+t),e.push(r.path,a,n)}e["default"];t["default"]=r,r.prototype={route:function(e,t,n){2===arguments.length&&"function"==typeof t&&(n=t,t={}),1===arguments.length&&(t={});t.resetNamespace===!0?"resource":"route";if(n){var s=i(this,e,t.resetNamespace),o=new r(s);a(o,"loading"),a(o,"error",{path:"/_unused_dummy_error_path_route_"+e+"/:error"}),n.call(o),a(this,e,t,o.generate())}else a(this,e,t)},push:function(e,t,r){var n=t.split(".");(""===e||"/"===e||"index"===n[n.length-1])&&(this.explicitIndex=!0),this.matches.push([e,t,r])},resource:function(e,t,r){2===arguments.length&&"function"==typeof t&&(r=t,t={}),1===arguments.length&&(t={}),t.resetNamespace=!0,this.route(e,t,r)},generate:function(){var e=this.matches;return this.explicitIndex||this.route("index",{path:"/"}),function(t){for(var r=0,n=e.length;n>r;r++){var i=e[r];t(i[0]).to(i[1],i[2])}}}},r.map=function(e){var t=new r;return e.call(t),t}}),e("ember-routing/system/generate_controller",["ember-metal/core","ember-metal/property_get","ember-metal/utils","exports"],function(e,t,r,n){"use strict";function i(e,t,r){var n,i,a,o;return o=r&&s(r)?"array":r?"object":"basic",a="controller:"+o,n=e.lookupFactory(a).extend({isGenerated:!0,toString:function(){return"(generated "+t+" controller)"}}),i="controller:"+t,e.register(i,n),n}var a=(e["default"],t.get),s=r.isArray;n.generateControllerFactory=i,n["default"]=function(e,t,r){i(e,t,r);var n="controller:"+t,s=e.lookup(n);return a(s,"namespace.LOG_ACTIVE_GENERATION"),s}}),e("ember-routing/system/query_params",["ember-runtime/system/object","exports"],function(e,t){"use strict";var r=e["default"];t["default"]=r.extend({isQueryParams:!0,values:null})}),e("ember-routing/system/route",["ember-metal/core","ember-metal/error","ember-metal/property_get","ember-metal/property_set","ember-metal/get_properties","ember-metal/enumerable_utils","ember-metal/is_none","ember-metal/computed","ember-metal/merge","ember-metal/utils","ember-metal/run_loop","ember-metal/keys","ember-runtime/copy","ember-runtime/system/string","ember-runtime/system/object","ember-runtime/mixins/evented","ember-runtime/mixins/action_handler","ember-routing/system/generate_controller","ember-routing/utils","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m,p,f,d,v,b,g,y){"use strict";
-function _(){return this}function w(e){var t=x(e,e.router.router.state.handlerInfos,-1);return t&&t.handler}function x(e,t,r){if(t)for(var n,i=r||0,a=0,s=t.length;s>a;a++)if(n=t[a].handler,n===e)return t[a+i]}function C(e){var t,r=w(e);return r?(t=r.lastRenderedTemplate)?t:C(r):void 0}function E(e,t,r,n){var i=n&&n.controller;if(i||(i=t?e.container.lookup("controller:"+r)||e.controllerName||e.routeName:e.controllerName||e.container.lookup("controller:"+r)),"string"==typeof i){var a=i;if(i=e.container.lookup("controller:"+a),!i)throw new I("You passed `controller: '"+a+"'` into the `render` method, but no such controller could be found.")}n&&n.model&&i.set("model",n.model);var s={into:n&&n.into?n.into.replace(/\//g,"."):C(e),outlet:n&&n.outlet||"main",name:r,controller:i};return s}function O(e,t){return e.create({_debugTemplateName:t.name,renderedName:t.name,controller:t.controller})}function P(e,t,r){if(r.into){var n=e.router._lookupActiveView(r.into),i=N(n,r.outlet);e.teardownOutletViews||(e.teardownOutletViews=[]),L(e.teardownOutletViews,0,0,[i]),n.connectOutlet(r.outlet,t)}else{var a=j(e.router,"namespace.rootElement");e.teardownTopLevelView&&e.teardownTopLevelView(),e.router._connectActiveView(r.name,t),e.teardownTopLevelView=A(t),t.appendTo(a)}}function A(e){return function(){e.destroy()}}function N(e,t){return function(){e.disconnectOutlet(t)}}function S(e,t){if(t.fullQueryParams)return t.fullQueryParams;t.fullQueryParams={},B(t.fullQueryParams,t.queryParams);var r=t.handlerInfos[t.handlerInfos.length-1].name;return e._deserializeQueryParams(r,t.fullQueryParams),t.fullQueryParams}function T(e,t){t.queryParamsFor=t.queryParamsFor||{};var r=e.routeName;if(t.queryParamsFor[r])return t.queryParamsFor[r];for(var n=S(e.router,t),i=t.queryParamsFor[r]={},a=j(e,"_qp"),s=a.qps,o=0,u=s.length;u>o;++o){var l=s[o],c=l.prop in n;i[l.prop]=c?n[l.prop]:k(l.def)}return i}function k(e){return H(e)?V.A(e.slice()):e}var V=e["default"],I=t["default"],j=r.get,M=n.set,R=i["default"],D=a.forEach,L=a.replace,F=(s["default"],o.computed),B=u["default"],H=l.isArray,z=l.typeOf,q=c["default"],U=h["default"],W=m["default"],K=(p.classify,f["default"]),G=d["default"],Q=v["default"],$=b["default"],Y=g.stashParamNames,X=Array.prototype.slice,Z=K.extend(Q,{queryParams:{},_qp:F(function(){var e=this.controllerName||this.routeName,t=this.container.lookupFactory("controller:"+e);if(!t)return J;var r=t.proto(),n=j(r,"_normalizedQueryParams"),i=j(r,"_cacheMeta"),a=[],s={},o=this;for(var u in n)if(n.hasOwnProperty(u)){var l=n[u],c=l.as||this.serializeQueryParamKey(u),h=j(r,u);H(h)&&(h=V.A(h.slice()));var m=z(h),p=this.serializeQueryParam(h,c,m),f=e+":"+u,d={def:h,sdef:p,type:m,urlKey:c,prop:u,fprop:f,ctrl:e,cProto:r,svalue:p,cacheType:l.scope,route:this,cacheMeta:i[u]};s[u]=s[c]=s[f]=d,a.push(d)}return{qps:a,map:s,states:{active:function(e,t){return o._activeQPChanged(e,s[t])},allowOverrides:function(e,t){return o._updatingQPChanged(e,s[t])},changingKeys:function(e,t){return o._updateSerializedQPValue(e,s[t])}}}}),_names:null,_stashNames:function(e,t){var r=e;if(!this._names){var n=this._names=r._names;n.length||(r=t,n=r&&r._names||[]);for(var i=j(this,"_qp.qps"),a=i.length,s=new Array(n.length),o=0,u=n.length;u>o;++o)s[o]=r.name+"."+n[o];for(var l=0;a>l;++l){var c=i[l],h=c.cacheMeta;"model"===h.scope&&(h.parts=s),h.prefix=c.ctrl}}},_updateSerializedQPValue:function(e,t){var r=j(e,t.prop);t.svalue=this.serializeQueryParam(r,t.urlKey,t.type)},_activeQPChanged:function(e,t){var r=j(e,t.prop);this.router._queuedQPChanges[t.fprop]=r,q.once(this,this._fireQueryParamTransition)},_updatingQPChanged:function(e,t){var r=this.router;r._qpUpdates||(r._qpUpdates={}),r._qpUpdates[t.urlKey]=!0},mergedProperties:["events","queryParams"],paramsFor:function(e){var t=this.container.lookup("route:"+e);if(!t)return{};var r=this.router.router.activeTransition,n=r?r.state:this.router.router.state,i={};return B(i,n.params[e]),B(i,T(t,n)),i},serializeQueryParamKey:function(e){return e},serializeQueryParam:function(e,t,r){return"array"===r?JSON.stringify(e):""+e},deserializeQueryParam:function(e,t,r){return"boolean"===r?"true"===e?!0:!1:"number"===r?Number(e).valueOf():"array"===r?V.A(JSON.parse(e)):e},_fireQueryParamTransition:function(){this.transitionTo({queryParams:this.router._queuedQPChanges}),this.router._queuedQPChanges={}},_optionsForQueryParam:function(e){return j(this,"queryParams."+e.urlKey)||j(this,"queryParams."+e.prop)||{}},resetController:_,exit:function(){this.deactivate(),this.trigger("deactivate"),this.teardownViews()},_reset:function(e,t){var r=this.controller;r._qpDelegate=j(this,"_qp.states.inactive"),this.resetController(r,e,t)},enter:function(){this.activate(),this.trigger("activate")},viewName:null,templateName:null,controllerName:null,_actions:{queryParamsDidChange:function(e,t,r){for(var n=j(this,"_qp").map,i=U(e).concat(U(r)),a=0,s=i.length;s>a;++a){var o=n[i[a]];o&&j(this._optionsForQueryParam(o),"refreshModel")&&this.refresh()}return!0},finalizeQueryParamChange:function(e,t,r){if("application"!==this.routeName)return!0;if(r){var n,i=r.state.handlerInfos,a=this.router,s=a._queryParamsFor(i[i.length-1].name),o=a._qpUpdates;Y(a,i);for(var u=0,l=s.qps.length;l>u;++u){var c,h,m=s.qps[u],p=m.route,f=p.controller,d=m.urlKey in e&&m.urlKey;o&&m.urlKey in o?(c=j(f,m.prop),h=p.serializeQueryParam(c,m.urlKey,m.type)):d?(h=e[d],c=p.deserializeQueryParam(h,m.urlKey,m.type)):(h=m.sdef,c=k(m.def)),f._qpDelegate=j(this,"_qp.states.inactive");var v=h!==m.svalue;if(v){if(r.queryParamsOnly&&n!==!1){var b=p._optionsForQueryParam(m),g=j(b,"replace");g?n=!0:g===!1&&(n=!1)}M(f,m.prop,c)}m.svalue=h;var y=m.sdef===h;y||t.push({value:h,visible:!0,key:d||m.urlKey})}n&&r.method("replace"),D(s.qps,function(e){var t=j(e.route,"_qp"),r=e.route.controller;r._qpDelegate=j(t,"states.active")}),a._qpUpdates=null}}},events:null,deactivate:_,activate:_,transitionTo:function(){var e=this.router;return e.transitionTo.apply(e,arguments)},intermediateTransitionTo:function(){var e=this.router;e.intermediateTransitionTo.apply(e,arguments)},refresh:function(){return this.router.router.refresh(this)},replaceWith:function(){var e=this.router;return e.replaceWith.apply(e,arguments)},send:function(){if(this.router||!V.testing)this.router.send.apply(this.router,arguments);else{var e=arguments[0],t=X.call(arguments,1),r=this._actions[e];if(r)return this._actions[e].apply(this,t)}},setup:function(e,t){var r=this.controllerName||this.routeName,n=this.controllerFor(r,!0);if(n||(n=this.generateController(r,e)),this.controller=n,this.setupControllers)this.setupControllers(n,e);else{var i=j(this,"_qp.states");if(t&&(Y(this.router,t.state.handlerInfos),n._qpDelegate=i.changingKeys,n._updateCacheParams(t.params)),n._qpDelegate=i.allowOverrides,t){var a=T(this,t.state);n.setProperties(a)}this.setupController(n,e,t)}this.renderTemplates?this.renderTemplates(e):this.renderTemplate(n,e)},beforeModel:_,afterModel:_,redirect:_,contextDidChange:function(){this.currentModel=this.context},model:function(e,t){var r,n,i,a,s=j(this,"_qp.map");for(var o in e)"queryParams"===o||s&&o in s||((r=o.match(/^(.*)_id$/))&&(n=r[1],a=e[o]),i=!0);if(!n&&i)return W(e);if(!n){if(t.resolveIndex<1)return;var u=t.state.handlerInfos[t.resolveIndex-1].context;return u}return this.findModel(n,a)},deserialize:function(e,t){return this.model(this.paramsFor(this.routeName),t)},findModel:function(){var e=j(this,"store");return e.find.apply(e,arguments)},store:F(function(){{var e=this.container;this.routeName,j(this,"router.namespace")}return{find:function(t,r){var n=e.lookupFactory("model:"+t);if(n)return n.find(r)}}}),serialize:function(e,t){if(!(t.length<1)&&e){var r=t[0],n={};return 1===t.length?r in e?n[r]=j(e,r):/_id$/.test(r)&&(n[r]=j(e,"id")):n=R(e,t),n}},setupController:function(e,t){e&&void 0!==t&&M(e,"model",t)},controllerFor:function(e){var t,r=this.container,n=r.lookup("route:"+e);return n&&n.controllerName&&(e=n.controllerName),t=r.lookup("controller:"+e)},generateController:function(e,t){var r=this.container;return t=t||this.modelFor(e),$(r,e,t)},modelFor:function(e){var t=this.container.lookup("route:"+e),r=this.router?this.router.router.activeTransition:null;if(r){var n=t&&t.routeName||e;if(r.resolvedModels.hasOwnProperty(n))return r.resolvedModels[n]}return t&&t.currentModel},renderTemplate:function(){this.render()},render:function(e,t){var r,n="string"==typeof e&&!!e;"object"!=typeof e||t?r=e:(r=this.routeName,t=e);var i;r?(r=r.replace(/\//g,"."),i=r):(r=this.routeName,i=this.templateName||r);var a,s,o=E(this,n,r,t),u=(j(this.router,"namespace.LOG_VIEW_LOOKUPS"),t&&t.view||n&&r||this.viewName||r),l=this.container.lookupFactory("view:"+u);if(l)a=O(l,o),j(a,"template")||a.set("template",this.container.lookup("template:"+i));else{if(s=this.container.lookup("template:"+i),!s)return;var c=o.into?"view:default":"view:toplevel";l=this.container.lookupFactory(c),a=O(l,o),j(a,"template")||a.set("template",s)}"main"===o.outlet&&(this.lastRenderedTemplate=r),P(this,a,o)},disconnectOutlet:function(e){if(!e||"string"==typeof e){var t=e;e={},e.outlet=t}e.parentView=e.parentView?e.parentView.replace(/\//g,"."):C(this),e.outlet=e.outlet||"main";var r=this.router._lookupActiveView(e.parentView);r&&r.disconnectOutlet(e.outlet)},willDestroy:function(){this.teardownViews()},teardownViews:function(){this.teardownTopLevelView&&this.teardownTopLevelView();var e=this.teardownOutletViews||[];D(e,function(e){e()}),delete this.teardownTopLevelView,delete this.teardownOutletViews,delete this.lastRenderedTemplate}});Z.reopen(G);var J={qps:[],map:{},states:{}};y["default"]=Z}),e("ember-routing/system/router",["ember-metal/core","ember-metal/error","ember-metal/property_get","ember-metal/property_set","ember-metal/properties","ember-metal/computed","ember-metal/merge","ember-metal/run_loop","ember-runtime/system/string","ember-runtime/system/object","ember-runtime/mixins/evented","ember-routing/system/dsl","ember-views/views/view","ember-routing/location/api","ember-views/views/metamorph_view","ember-routing/utils","ember-metal/platform","router","router/transition","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m,p,f,d,v,b,g,y){"use strict";function _(){return this}function w(e,t,r){for(var n,i,a=t.state.handlerInfos,s=!1,o=a.length-1;o>=0;--o)if(n=a[o],i=n.handler,s){if(r(i,a[o+1].handler)!==!0)return!1}else e===i&&(s=!0);return!0}function x(e,t){var r=[];t&&r.push(t),e&&(e.message&&r.push(e.message),e.stack&&r.push(e.stack),"string"==typeof e&&r.push(e)),k.Logger.error.apply(this,r)}function C(e,t,r){var n,i=e.router,a=(t.routeName.split(".").pop(),"application"===e.routeName?"":e.routeName+".");return n=a+r,E(i,n)?n:void 0}function E(e,t){var r=e.container;return e.hasRoute(t)&&(r.has("template:"+t)||r.has("route:"+t))}function O(e,t,r){var n=r.shift();if(!e){if(t)return;throw new V("Can't trigger action '"+n+"' because your app hasn't finished transitioning into its first route. To trigger an action on destination routes during a transition, you can call `.send()` on the `Transition` object passed to the `model/beforeModel/afterModel` hooks.")}for(var i,a,s=!1,o=e.length-1;o>=0;o--)if(i=e[o],a=i.handler,a._actions&&a._actions[n]){if(a._actions[n].apply(a,r)!==!0)return;s=!0}if(Z[n])return void Z[n].apply(null,r);if(!s&&!t)throw new V("Nothing handled the action '"+n+"'. If you did handle the action, this error can be caused by returning true from an action handler in a controller, causing the action to bubble.")}function P(e,t,r){for(var n=e.router,i=n.applyIntent(t,r),a=i.handlerInfos,s=i.params,o=0,u=a.length;u>o;++o){var l=a[o];l.isResolved||(l=l.becomeResolved(null,l.context)),s[l.name]=l.params}return i}function A(e){var t=e.container.lookup("controller:application");if(t){var r=e.router.currentHandlerInfos,n=X._routePath(r);"currentPath"in t||M(t,"currentPath"),j(t,"currentPath",n),"currentRouteName"in t||M(t,"currentRouteName"),j(t,"currentRouteName",r[r.length-1].name)}}function N(e){e.then(null,function(e){return e&&e.name?e:void 0},"Ember: Process errors from Router")}function S(e){return"string"==typeof e&&(""===e||"/"===e.charAt(0))}function T(e,t,r,n){var i=e._queryParamsFor(t);for(var a in r)if(r.hasOwnProperty(a)){var s=r[a],o=i.map[a];o&&n(a,s,o)}}var k=e["default"],V=t["default"],I=r.get,j=n.set,M=i.defineProperty,R=a.computed,D=s["default"],L=o["default"],F=(u.fmt,l["default"]),B=c["default"],H=h["default"],z=m["default"],q=p["default"],U=f["default"],W=d.routeArgs,K=d.getActiveTargetName,G=d.stashParamNames,Q=v.create,$=b["default"],Y=[].slice,X=F.extend(B,{location:"hash",rootURL:"/",init:function(){this.router=this.constructor.router||this.constructor.map(_),this._activeViews={},this._setupLocation(),this._qpCache={},this._queuedQPChanges={},I(this,"namespace.LOG_TRANSITIONS_INTERNAL")&&(this.router.log=k.Logger.debug)},url:R(function(){return I(this,"location").getURL()}),startRouting:function(){this.router=this.router||this.constructor.map(_);var e,t=this.router,r=I(this,"location"),n=this.container,i=this,a=I(this,"initialURL");if(!I(r,"cancelRouterSetup")&&(this._setupRouter(t,r),n.register("view:default",U),n.register("view:toplevel",z.extend()),r.onUpdateURL(function(e){i.handleURL(e)}),"undefined"==typeof a&&(a=r.getURL()),e=this.handleURL(a),e&&e.error))throw e.error},didTransition:function(e){A(this),this._cancelLoadingEvent(),this.notifyPropertyChange("url"),L.once(this,this.trigger,"didTransition"),I(this,"namespace").LOG_TRANSITIONS&&k.Logger.log("Transitioned into '"+X._routePath(e)+"'")},handleURL:function(e){return e=e.split(/#(.+)?/)[0],this._doURLTransition("handleURL",e)},_doURLTransition:function(e,t){var r=this.router[e](t||"/");return N(r),r},transitionTo:function(){var e,t=Y.call(arguments);if(S(t[0]))return this._doURLTransition("transitionTo",t[0]);var r=t[t.length-1];e=r&&r.hasOwnProperty("queryParams")?t.pop().queryParams:{};var n=t.shift();return this._doTransition(n,t,e)},intermediateTransitionTo:function(){this.router.intermediateTransitionTo.apply(this.router,arguments),A(this);var e=this.router.currentHandlerInfos;I(this,"namespace").LOG_TRANSITIONS&&k.Logger.log("Intermediate-transitioned into '"+X._routePath(e)+"'")},replaceWith:function(){return this.transitionTo.apply(this,arguments).method("replace")},generate:function(){var e=this.router.generate.apply(this.router,arguments);return this.location.formatURL(e)},isActive:function(){var e=this.router;return e.isActive.apply(e,arguments)},isActiveIntent:function(){var e=this.router;return e.isActive.apply(e,arguments)},send:function(){this.router.trigger.apply(this.router,arguments)},hasRoute:function(e){return this.router.hasRoute(e)},reset:function(){this.router.reset()},_lookupActiveView:function(e){var t=this._activeViews[e];return t&&t[0]},_connectActiveView:function(e,t){function r(){delete this._activeViews[e]}var n=this._activeViews[e];n&&n[0].off("willDestroyElement",this,n[1]),this._activeViews[e]=[t,r],t.one("willDestroyElement",this,r)},_setupLocation:function(){var e=I(this,"location"),t=I(this,"rootURL");if(t&&this.container&&!this.container.has("-location-setting:root-url")&&this.container.register("-location-setting:root-url",t,{instantiate:!1}),"string"==typeof e&&this.container){var r=this.container.lookup("location:"+e);if("undefined"!=typeof r)e=j(this,"location",r);else{var n={implementation:e};e=j(this,"location",q.create(n))}}null!==e&&"object"==typeof e&&(t&&"string"==typeof t&&(e.rootURL=t),"function"==typeof e.initState&&e.initState())},_getHandlerFunction:function(){var e=Q(null),t=this.container,r=t.lookupFactory("route:basic"),n=this;return function(i){var a="route:"+i,s=t.lookup(a);return e[i]?s:(e[i]=!0,s||(t.register(a,r.extend()),s=t.lookup(a),I(n,"namespace.LOG_ACTIVE_GENERATION")),s.routeName=i,s)}},_setupRouter:function(e,t){var r,n=this;e.getHandler=this._getHandlerFunction();var i=function(){t.setURL(r)};if(e.updateURL=function(e){r=e,L.once(i)},t.replaceURL){var a=function(){t.replaceURL(r)};e.replaceURL=function(e){r=e,L.once(a)}}e.didTransition=function(e){n.didTransition(e)}},_serializeQueryParams:function(e,t){var r={};T(this,e,t,function(e,n,i){var a=i.urlKey;r[a]||(r[a]=[]),r[a].push({qp:i,value:n}),delete t[e]});for(var n in r){var i=r[n],a=i[0].qp;t[a.urlKey]=a.route.serializeQueryParam(i[0].value,a.urlKey,a.type)}},_deserializeQueryParams:function(e,t){T(this,e,t,function(e,r,n){delete t[e],t[n.prop]=n.route.deserializeQueryParam(r,n.urlKey,n.type)})},_pruneDefaultQueryParamValues:function(e,t){var r=this._queryParamsFor(e);for(var n in t){var i=r.map[n];i&&i.sdef===t[n]&&delete t[n]}},_doTransition:function(e,t,r){var n=e||K(this.router),i={};D(i,r),this._prepareQueryParams(n,t,i);var a=W(n,t,i),s=this.router.transitionTo.apply(this.router,a);return N(s),s},_prepareQueryParams:function(e,t,r){this._hydrateUnsuppliedQueryParams(e,t,r),this._serializeQueryParams(e,r),this._pruneDefaultQueryParamValues(e,r)},_queryParamsFor:function(e){if(this._qpCache[e])return this._qpCache[e];var t={},r=[];this._qpCache[e]={map:t,qps:r};for(var n=this.router,i=n.recognizer.handlersFor(e),a=0,s=i.length;s>a;++a){var o=i[a],u=n.getHandler(o.handler),l=I(u,"_qp");l&&(D(t,l.map),r.push.apply(r,l.qps))}return{qps:r,map:t}},_hydrateUnsuppliedQueryParams:function(e,t,r){var n=P(this,e,t),i=n.handlerInfos,a=this._bucketCache;G(this,i);for(var s=0,o=i.length;o>s;++s)for(var u=i[s].handler,l=I(u,"_qp"),c=0,h=l.qps.length;h>c;++c){var m=l.qps[c],p=m.prop in r&&m.prop||m.fprop in r&&m.fprop;if(p)p!==m.fprop&&(r[m.fprop]=r[p],delete r[p]);else{var f=m.cProto,d=I(f,"_cacheMeta"),v=f._calculateCacheKey(m.ctrl,d[m.prop].parts,n.params);r[m.fprop]=a.lookup(v,m.prop,m.def)}}},_scheduleLoadingEvent:function(e,t){this._cancelLoadingEvent(),this._loadingStateTimer=L.scheduleOnce("routerTransitions",this,"_fireLoadingEvent",e,t)},_fireLoadingEvent:function(e,t){this.router.activeTransition&&e.trigger(!0,"loading",e,t)},_cancelLoadingEvent:function(){this._loadingStateTimer&&L.cancel(this._loadingStateTimer),this._loadingStateTimer=null}}),Z={willResolveModel:function(e,t){t.router._scheduleLoadingEvent(e,t)},error:function(e,t,r){var n=r.router,i=w(r,t,function(t,r){var i=C(t,r,"error");return i?void n.intermediateTransitionTo(i,e):!0});return i&&E(r.router,"application_error")?void n.intermediateTransitionTo("application_error",e):void x(e,"Error while processing route: "+t.targetName)},loading:function(e,t){var r=t.router,n=w(t,e,function(t,n){var i=C(t,n,"loading");return i?void r.intermediateTransitionTo(i):e.pivotHandler!==t?!0:void 0});return n&&E(t.router,"application_loading")?void r.intermediateTransitionTo("application_loading"):void 0}};X.reopenClass({router:null,map:function(e){var t=this.router;t||(t=new $,t._triggerWillChangeContext=_,t._triggerWillLeave=_,t.callbacks=[],t.triggerEvent=O,this.reopenClass({router:t}));var r=H.map(function(){this.resource("application",{path:"/"},function(){for(var r=0;rr;++r)if(e[r]!==t[r])return!1;return!0}for(var r,n,i,a=[],s=1,o=e.length;o>s;s++){for(r=e[s].name,n=r.split("."),i=Y.call(a);i.length&&!t(i,n);)i.shift();a.push.apply(a,n.slice(i.length))}return a.join(".")}}),y["default"]=X}),e("ember-routing/utils",["ember-metal/utils","exports"],function(e,t){"use strict";function r(e,t,r){var n=[];return"string"===a(e)&&n.push(""+e),n.push.apply(n,t),n.push({queryParams:r}),n}function n(e){var t=e.activeTransition?e.activeTransition.state.handlerInfos:e.state.handlerInfos;return t[t.length-1].name}function i(e,t){if(!t._namesStashed){for(var r=t[t.length-1].name,n=e.router.recognizer.handlersFor(r),i=null,a=0,s=t.length;s>a;++a){var o=t[a],u=n[a].names;u.length&&(i=o),o._names=u;var l=o.handler;l._stashNames(o,i)}t._namesStashed=!0}}var a=e.typeOf;t.routeArgs=r,t.getActiveTargetName=n,t.stashParamNames=i}),e("ember-runtime",["ember-metal","ember-runtime/core","ember-runtime/compare","ember-runtime/copy","ember-runtime/inject","ember-runtime/system/namespace","ember-runtime/system/object","ember-runtime/system/tracked_array","ember-runtime/system/subarray","ember-runtime/system/container","ember-runtime/system/array_proxy","ember-runtime/system/object_proxy","ember-runtime/system/core_object","ember-runtime/system/each_proxy","ember-runtime/system/native_array","ember-runtime/system/set","ember-runtime/system/string","ember-runtime/system/deferred","ember-runtime/system/lazy_load","ember-runtime/mixins/array","ember-runtime/mixins/comparable","ember-runtime/mixins/copyable","ember-runtime/mixins/enumerable","ember-runtime/mixins/freezable","ember-runtime/mixins/-proxy","ember-runtime/mixins/observable","ember-runtime/mixins/action_handler","ember-runtime/mixins/deferred","ember-runtime/mixins/mutable_enumerable","ember-runtime/mixins/mutable_array","ember-runtime/mixins/target_action_support","ember-runtime/mixins/evented","ember-runtime/mixins/promise_proxy","ember-runtime/mixins/sortable","ember-runtime/computed/array_computed","ember-runtime/computed/reduce_computed","ember-runtime/computed/reduce_computed_macros","ember-runtime/controllers/array_controller","ember-runtime/controllers/object_controller","ember-runtime/controllers/controller","ember-runtime/mixins/controller","ember-runtime/system/service","ember-runtime/ext/rsvp","ember-runtime/ext/string","ember-runtime/ext/function","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m,p,f,d,v,b,g,y,_,w,x,C,E,O,P,A,N,S,T,k,V,I,j,M,R,D,L,F,B,H,z,q,U,W){"use strict";var K=e["default"],G=t.isEqual,Q=r["default"],$=n["default"],Y=i["default"],X=a["default"],Z=s["default"],J=o["default"],et=u["default"],tt=l["default"],rt=c["default"],nt=h["default"],it=m["default"],at=p.EachArray,st=p.EachProxy,ot=f["default"],ut=d["default"],lt=v["default"],ct=b["default"],ht=g.onLoad,mt=g.runLoadHooks,pt=y["default"],ft=_["default"],dt=w["default"],vt=x["default"],bt=C.Freezable,gt=C.FROZEN_ERROR,yt=E["default"],_t=O["default"],wt=P["default"],xt=A["default"],Ct=N["default"],Et=S["default"],Ot=T["default"],Pt=k["default"],At=V["default"],Nt=I["default"],St=j.arrayComputed,Tt=j.ArrayComputedProperty,kt=M.reduceComputed,Vt=M.ReduceComputedProperty,It=R.sum,jt=R.min,Mt=R.max,Rt=R.map,Dt=R.sort,Lt=R.setDiff,Ft=R.mapBy,Bt=R.mapProperty,Ht=R.filter,zt=R.filterBy,qt=R.filterProperty,Ut=R.uniq,Wt=R.union,Kt=R.intersect,Gt=D["default"],Qt=L["default"],$t=F["default"],Yt=B["default"],Xt=H["default"],Zt=z["default"];K.compare=Q,K.copy=$,K.isEqual=G,K.inject=Y,K.Array=pt,K.Comparable=ft,K.Copyable=dt,K.SortableMixin=Nt,K.Freezable=bt,K.FROZEN_ERROR=gt,K.DeferredMixin=xt,K.MutableEnumerable=Ct,K.MutableArray=Et,K.TargetActionSupport=Ot,K.Evented=Pt,K.PromiseProxyMixin=At,K.Observable=_t,K.arrayComputed=St,K.ArrayComputedProperty=Tt,K.reduceComputed=kt,K.ReduceComputedProperty=Vt;var Jt=K.computed;Jt.sum=It,Jt.min=jt,Jt.max=Mt,Jt.map=Rt,Jt.sort=Dt,Jt.setDiff=Lt,Jt.mapBy=Ft,Jt.mapProperty=Bt,Jt.filter=Ht,Jt.filterBy=zt,Jt.filterProperty=qt,Jt.uniq=Ut,Jt.union=Wt,Jt.intersect=Kt,K.String=lt,K.Object=Z,K.TrackedArray=J,K.SubArray=et,K.Container=tt,K.Namespace=X,K.Enumerable=vt,K.ArrayProxy=rt,K.ObjectProxy=nt,K.ActionHandler=wt,K.CoreObject=it,K.EachArray=at,K.EachProxy=st,K.NativeArray=ot,K.Set=ut,K.Deferred=ct,K.onLoad=ht,K.runLoadHooks=mt,K.ArrayController=Gt,K.ObjectController=Qt,K.Controller=$t,K.ControllerMixin=Yt,K.Service=Xt,K._ProxyMixin=yt,K.RSVP=Zt,W["default"]=K}),e("ember-runtime/compare",["ember-metal/utils","ember-runtime/mixins/comparable","exports"],function(e,t,r){"use strict";function n(e,t){var r=e-t;return(r>0)-(0>r)}var i=e.typeOf,a=t["default"],s={undefined:0,"null":1,"boolean":2,number:3,string:4,array:5,object:6,instance:7,"function":8,"class":9,date:10};r["default"]=function o(e,t){if(e===t)return 0;var r=i(e),u=i(t);if(a){if("instance"===r&&a.detect(e)&&e.constructor.compare)return e.constructor.compare(e,t);if("instance"===u&&a.detect(t)&&t.constructor.compare)return-1*t.constructor.compare(t,e)}var l=n(s[r],s[u]);if(0!==l)return l;switch(r){case"boolean":case"number":return n(e,t);case"string":return n(e.localeCompare(t),0);case"array":for(var c=e.length,h=t.length,m=Math.min(c,h),p=0;m>p;p++){var f=o(e[p],t[p]);if(0!==f)return f}return n(c,h);case"instance":return a&&a.detect(e)?e.compare(e,t):0;case"date":return n(e.getTime(),t.getTime());default:return 0}}}),e("ember-runtime/computed/array_computed",["ember-metal/core","ember-runtime/computed/reduce_computed","ember-metal/enumerable_utils","ember-metal/platform","ember-metal/observer","ember-metal/error","exports"],function(e,t,r,n,i,a,s){"use strict";function o(){var e=this;return c.apply(this,arguments),this.func=function(t){return function(r){return e._hasInstanceMeta(this,r)||h(e._dependentKeys,function(t){p(this,t,function(){e.recomputeOnce.call(this,r)})},this),t.apply(this,arguments)}}(this.func),this}function u(e){var t;if(arguments.length>1&&(t=d.call(arguments,0,-1),e=d.call(arguments,-1)[0]),"object"!=typeof e)throw new f("Array Computed Property declared without an options hash");var r=new o(e);return t&&r.property.apply(r,t),r}var l=e["default"],c=t.ReduceComputedProperty,h=r.forEach,m=n.create,p=i.addObserver,f=a["default"],d=[].slice;o.prototype=m(c.prototype),o.prototype.initialValue=function(){return l.A()},o.prototype.resetValue=function(e){return e.clear(),e},o.prototype.didChange=function(){},s.arrayComputed=u,s.ArrayComputedProperty=o}),e("ember-runtime/computed/reduce_computed",["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/error","ember-metal/property_events","ember-metal/expand_properties","ember-metal/observer","ember-metal/computed","ember-metal/platform","ember-metal/enumerable_utils","ember-runtime/system/tracked_array","ember-runtime/mixins/array","ember-metal/run_loop","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m,p){"use strict";function f(e,t){return"@this"===t?e:A(e,t)}function d(e,t,r){this.callbacks=e,this.cp=t,this.instanceMeta=r,this.dependentKeysByGuid={},this.trackedArraysByGuid={},this.suspended=!1,this.changedItems={},this.changedItemCount=0}function v(e,t,r){this.dependentArray=e,this.index=t,this.item=e.objectAt(t),this.trackedArray=r,this.beforeObserver=null,this.observer=null,this.destroyed=!1}function b(e,t,r){return 0>e?Math.max(0,t+e):t>e?e:Math.min(t-r,e)}function g(e,t,r){return Math.min(r,t-e)}function y(e,t,r,n,i,a,s){this.arrayChanged=e,this.index=r,this.item=t,this.propertyName=n,this.property=i,this.changedCount=a,s&&(this.previousValues=s)}function _(e,t,r,n,i){H(e,function(a,s){i.setValue(t.addedItem.call(this,i.getValue(),a,new y(e,a,s,n,r,e.length),i.sugarMeta))},this),t.flushedChanges.call(this,i.getValue(),i.sugarMeta)}function w(e,t){var r=e._hasInstanceMeta(this,t),n=e._instanceMeta(this,t);r&&n.setValue(e.resetValue(n.getValue())),e.options.initialize&&e.options.initialize.call(this,n.getValue(),{property:e,propertyName:t},n.sugarMeta)}function x(e,t){if(X.test(t))return!1;var r=f(e,t);return q.detect(r)}function C(e,t,r){this.context=e,this.propertyName=t,this.cache=S(e).cache,this.dependentArrays={},this.sugarMeta={},this.initialValue=r}function E(e){var t=this;this.options=e,this._dependentKeys=null,this._cacheable=!0,this._itemPropertyKeys={},this._previousItemPropertyKeys={},this.readOnly(),this.recomputeOnce=function(e){U.once(this,r,e)};var r=function(e){var r=t._instanceMeta(this,e),n=t._callbacks();w.call(this,t,e),r.dependentArraysObserver.suspendArrayObservers(function(){H(t._dependentKeys,function(e){if(x(this,e)){var n=f(this,e),i=r.dependentArrays[e];n===i?t._previousItemPropertyKeys[e]&&(delete t._previousItemPropertyKeys[e],r.dependentArraysObserver.setupPropertyObservers(e,t._itemPropertyKeys[e])):(r.dependentArrays[e]=n,i&&r.dependentArraysObserver.teardownObservers(i,e),n&&r.dependentArraysObserver.setupObservers(n,e))}},this)},this),H(t._dependentKeys,function(i){if(x(this,i)){var a=f(this,i);a&&_.call(this,a,n,t,e,r)}},this)};this.func=function(e){return r.call(this,e),t._instanceMeta(this,e).getValue()}}function O(e){return e}function P(e){var t;if(arguments.length>1&&(t=Q.call(arguments,0,-1),e=Q.call(arguments,-1)[0]),"object"!=typeof e)throw new T("Reduce Computed Property declared without an options hash");if(!("initialValue"in e))throw new T("Reduce Computed Property declared without an initial value");var r=new E(e);return t&&r.property.apply(r,t),r}var A=(e["default"],t.get),N=r.guidFor,S=r.meta,T=n["default"],k=i.propertyWillChange,V=i.propertyDidChange,I=a["default"],j=s.addObserver,M=s.removeObserver,R=s.addBeforeObserver,D=s.removeBeforeObserver,L=o.ComputedProperty,F=o.cacheFor,B=u.create,H=l.forEach,z=c["default"],q=h["default"],U=m["default"],W=(r.isArray,F.set),K=F.get,G=F.remove,Q=[].slice,$=/^(.*)\.@each\.(.*)/,Y=/(.*\.@each){2,}/,X=/\.\[\]$/;d.prototype={setValue:function(e){this.instanceMeta.setValue(e,!0)},getValue:function(){return this.instanceMeta.getValue()},setupObservers:function(e,t){this.dependentKeysByGuid[N(e)]=t,e.addArrayObserver(this,{willChange:"dependentArrayWillChange",didChange:"dependentArrayDidChange"}),this.cp._itemPropertyKeys[t]&&this.setupPropertyObservers(t,this.cp._itemPropertyKeys[t])},teardownObservers:function(e,t){var r=this.cp._itemPropertyKeys[t]||[];delete this.dependentKeysByGuid[N(e)],this.teardownPropertyObservers(t,r),e.removeArrayObserver(this,{willChange:"dependentArrayWillChange",didChange:"dependentArrayDidChange"})},suspendArrayObservers:function(e,t){var r=this.suspended;this.suspended=!0,e.call(t),this.suspended=r},setupPropertyObservers:function(e,t){var r=f(this.instanceMeta.context,e),n=f(r,"length"),i=new Array(n);this.resetTransformations(e,i),H(r,function(n,a){var s=this.createPropertyObserverContext(r,a,this.trackedArraysByGuid[e]);i[a]=s,H(t,function(e){R(n,e,this,s.beforeObserver),j(n,e,this,s.observer)},this)},this)},teardownPropertyObservers:function(e,t){var r,n,i,a=this,s=this.trackedArraysByGuid[e];s&&s.apply(function(e,s,o){o!==z.DELETE&&H(e,function(e){e.destroyed=!0,r=e.beforeObserver,n=e.observer,i=e.item,H(t,function(e){D(i,e,a,r),M(i,e,a,n)})})})},createPropertyObserverContext:function(e,t,r){var n=new v(e,t,r);return this.createPropertyObserver(n),n},createPropertyObserver:function(e){var t=this;e.beforeObserver=function(r,n){return t.itemPropertyWillChange(r,n,e.dependentArray,e)},e.observer=function(r,n){return t.itemPropertyDidChange(r,n,e.dependentArray,e)}},resetTransformations:function(e,t){this.trackedArraysByGuid[e]=new z(t)},trackAdd:function(e,t,r){var n=this.trackedArraysByGuid[e];n&&n.addItems(t,r)},trackRemove:function(e,t,r){var n=this.trackedArraysByGuid[e];return n?n.removeItems(t,r):[]},updateIndexes:function(e,t){var r=f(t,"length");e.apply(function(e,t,n,i){n!==z.DELETE&&(0!==i||n!==z.RETAIN||e.length!==r||0!==t)&&H(e,function(e,r){e.index=r+t})})},dependentArrayWillChange:function(e,t,r){function n(e){u[o].destroyed=!0,D(a,e,this,u[o].beforeObserver),M(a,e,this,u[o].observer)}if(!this.suspended){var i,a,s,o,u,l=this.callbacks.removedItem,c=N(e),h=this.dependentKeysByGuid[c],m=this.cp._itemPropertyKeys[h]||[],p=f(e,"length"),d=b(t,p,0),v=g(d,p,r);for(u=this.trackRemove(h,d,v),o=v-1;o>=0&&(s=d+o,!(s>=p));--o)a=e.objectAt(s),H(m,n,this),i=new y(e,a,s,this.instanceMeta.propertyName,this.cp,v),this.setValue(l.call(this.instanceMeta.context,this.getValue(),a,i,this.instanceMeta.sugarMeta));this.callbacks.flushedChanges.call(this.instanceMeta.context,this.getValue(),this.instanceMeta.sugarMeta)}},dependentArrayDidChange:function(e,t,r,n){if(!this.suspended){var i,a,s=this.callbacks.addedItem,o=N(e),u=this.dependentKeysByGuid[o],l=new Array(n),c=this.cp._itemPropertyKeys[u],h=f(e,"length"),m=b(t,h,n),p=m+n;H(e.slice(m,p),function(t,r){c&&(a=this.createPropertyObserverContext(e,m+r,this.trackedArraysByGuid[u]),l[r]=a,H(c,function(e){R(t,e,this,a.beforeObserver),j(t,e,this,a.observer)
-},this)),i=new y(e,t,m+r,this.instanceMeta.propertyName,this.cp,n),this.setValue(s.call(this.instanceMeta.context,this.getValue(),t,i,this.instanceMeta.sugarMeta))},this),this.callbacks.flushedChanges.call(this.instanceMeta.context,this.getValue(),this.instanceMeta.sugarMeta),this.trackAdd(u,m,l)}},itemPropertyWillChange:function(e,t,r,n){var i=N(e);this.changedItems[i]||(this.changedItems[i]={array:r,observerContext:n,obj:e,previousValues:{}}),++this.changedItemCount,this.changedItems[i].previousValues[t]=f(e,t)},itemPropertyDidChange:function(){0===--this.changedItemCount&&this.flushChanges()},flushChanges:function(){var e,t,r,n=this.changedItems;for(e in n)t=n[e],t.observerContext.destroyed||(this.updateIndexes(t.observerContext.trackedArray,t.observerContext.dependentArray),r=new y(t.array,t.obj,t.observerContext.index,this.instanceMeta.propertyName,this.cp,n.length,t.previousValues),this.setValue(this.callbacks.removedItem.call(this.instanceMeta.context,this.getValue(),t.obj,r,this.instanceMeta.sugarMeta)),this.setValue(this.callbacks.addedItem.call(this.instanceMeta.context,this.getValue(),t.obj,r,this.instanceMeta.sugarMeta)));this.changedItems={},this.callbacks.flushedChanges.call(this.instanceMeta.context,this.getValue(),this.instanceMeta.sugarMeta)}},C.prototype={getValue:function(){var e=K(this.cache,this.propertyName);return void 0!==e?e:this.initialValue},setValue:function(e,t){e!==K(this.cache,this.propertyName)&&(t&&k(this.context,this.propertyName),void 0===e?G(this.cache,this.propertyName):W(this.cache,this.propertyName,e),t&&V(this.context,this.propertyName))}},p.ReduceComputedProperty=E,E.prototype=B(L.prototype),E.prototype._callbacks=function(){if(!this.callbacks){var e=this.options;this.callbacks={removedItem:e.removedItem||O,addedItem:e.addedItem||O,flushedChanges:e.flushedChanges||O}}return this.callbacks},E.prototype._hasInstanceMeta=function(e,t){return!!S(e).cacheMeta[t]},E.prototype._instanceMeta=function(e,t){var r=S(e).cacheMeta,n=r[t];return n||(n=r[t]=new C(e,t,this.initialValue()),n.dependentArraysObserver=new d(this._callbacks(),this,n,e,t,n.sugarMeta)),n},E.prototype.initialValue=function(){return"function"==typeof this.options.initialValue?this.options.initialValue():this.options.initialValue},E.prototype.resetValue=function(){return this.initialValue()},E.prototype.itemPropertyKey=function(e,t){this._itemPropertyKeys[e]=this._itemPropertyKeys[e]||[],this._itemPropertyKeys[e].push(t)},E.prototype.clearItemPropertyKeys=function(e){this._itemPropertyKeys[e]&&(this._previousItemPropertyKeys[e]=this._itemPropertyKeys[e],this._itemPropertyKeys[e]=[])},E.prototype.property=function(){var e,t,r=this,n=Q.call(arguments),i={};H(n,function(n){if(Y.test(n))throw new T("Nested @each properties not supported: "+n);if(e=$.exec(n)){t=e[1];var a=e[2],s=function(e){r.itemPropertyKey(t,e)};I(a,s),i[N(t)]=t}else i[N(n)]=n});var a=[];for(var s in i)a.push(i[s]);return L.prototype.property.apply(this,a)},p.reduceComputed=P}),e("ember-runtime/computed/reduce_computed_macros",["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/error","ember-metal/enumerable_utils","ember-metal/run_loop","ember-metal/observer","ember-runtime/computed/array_computed","ember-runtime/computed/reduce_computed","ember-runtime/system/subarray","ember-metal/keys","ember-runtime/compare","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m){"use strict";function p(e){return M(e,{initialValue:0,addedItem:function(e,t){return e+t},removedItem:function(e,t){return e-t}})}function f(e){return M(e,{initialValue:-1/0,addedItem:function(e,t){return Math.max(e,t)},removedItem:function(e,t){return e>t?e:void 0}})}function d(e){return M(e,{initialValue:1/0,addedItem:function(e,t){return Math.min(e,t)},removedItem:function(e,t){return t>e?e:void 0}})}function v(e,t){var r={addedItem:function(e,r,n){var i=t.call(this,r,n.index);return e.insertAt(n.index,i),e},removedItem:function(e,t,r){return e.removeAt(r.index,1),e}};return j(e,r)}function b(e,t){var r=function(e){return N(e,t)};return v(e+".@each."+t,r)}function g(e,t){var r={initialize:function(e,t,r){r.filteredArrayIndexes=new R},addedItem:function(e,r,n,i){var a=!!t.call(this,r,n.index,n.arrayChanged),s=i.filteredArrayIndexes.addItem(n.index,a);return a&&e.insertAt(s,r),e},removedItem:function(e,t,r,n){var i=n.filteredArrayIndexes.removeItem(r.index);return i>-1&&e.removeAt(i),e}};return j(e,r)}function y(e,t,r){var n;return n=2===arguments.length?function(e){return N(e,t)}:function(e){return N(e,t)===r},g(e+".@each."+t,n)}function _(){var e=F.call(arguments);return e.push({initialize:function(e,t,r){r.itemCounts={}},addedItem:function(e,t,r,n){var i=S(t);return n.itemCounts[i]?++n.itemCounts[i]:(n.itemCounts[i]=1,e.pushObject(t)),e},removedItem:function(e,t,r,n){var i=S(t),a=n.itemCounts;return 0===--a[i]&&e.removeObject(t),e}}),j.apply(null,e)}function w(){var e=F.call(arguments);return e.push({initialize:function(e,t,r){r.itemCounts={}},addedItem:function(e,t,r,n){var i=S(t),a=S(r.arrayChanged),s=r.property._dependentKeys.length,o=n.itemCounts;return o[i]||(o[i]={}),void 0===o[i][a]&&(o[i][a]=0),1===++o[i][a]&&s===D(o[i]).length&&e.addObject(t),e},removedItem:function(e,t,r,n){var i,a=S(t),s=S(r.arrayChanged),o=n.itemCounts;return void 0===o[a][s]&&(o[a][s]=0),0===--o[a][s]&&(delete o[a][s],i=D(o[a]).length,0===i&&delete o[a],e.removeObject(t)),e}}),j.apply(null,e)}function x(e,t){if(2!==arguments.length)throw new T("setDiff requires exactly two dependent arrays.");return j(e,t,{addedItem:function(r,n,i){var a=N(this,e),s=N(this,t);return i.arrayChanged===a?s.contains(n)||r.addObject(n):r.removeObject(n),r},removedItem:function(r,n,i){var a=N(this,e),s=N(this,t);return i.arrayChanged===s?a.contains(n)&&r.addObject(n):r.removeObject(n),r}})}function C(e,t,r,n){var i,a,s,o,u;return arguments.length<4&&(n=N(e,"length")),arguments.length<3&&(r=0),r===n?r:(i=r+Math.floor((n-r)/2),a=e.objectAt(i),o=S(a),u=S(t),o===u?i:(s=this.order(a,t),0===s&&(s=u>o?-1:1),0>s?this.binarySearch(e,t,i+1,n):s>0?this.binarySearch(e,t,r,i):i))}function E(e,t){return"function"==typeof t?O(e,t):P(e,t)}function O(e,t){return j(e,{initialize:function(e,r,n){n.order=t,n.binarySearch=C,n.waitingInsertions=[],n.insertWaiting=function(){var t,r,i=n.waitingInsertions;n.waitingInsertions=[];for(var a=0;a=0&&r>e&&(t=this.lookupItemController(i))?this.controllerAt(e,i,t):i},arrangedContentDidChange:function(){this._super(),this._resetSubControllers()},arrayContentDidChange:function(e,t,r){var n=this._subControllers;if(n.length){var i=n.slice(e,e+t);h(i,function(e){e&&e.destroy()}),m(n,e,t,new Array(r))}this._super(e,t,r)},init:function(){this._super(),this._subControllers=[]},model:v(function(){return l.A()}),_isVirtual:!1,controllerAt:function(e,t,r){var n,i,a,s=c(this,"container"),o=this._subControllers;if(o.length>e&&(i=o[e]))return i;if(a=this._isVirtual?c(this,"parentController"):this,n="controller:"+r,!s.has(n))throw new b('Could not resolve itemController: "'+r+'"');return i=s.lookupFactory(n).create({target:a,parentController:a,model:t}),o[e]=i,i},_subControllers:null,_resetSubControllers:function(){var e,t=this._subControllers;if(t.length){for(var r=0,n=t.length;n>r;r++)e=t[r],e&&e.destroy();t.length=0}},willDestroy:function(){this._resetSubControllers(),this._super()}})}),e("ember-runtime/controllers/controller",["ember-metal/core","ember-runtime/system/object","ember-runtime/mixins/controller","ember-runtime/inject","exports"],function(e,t,r,n,i){"use strict";function a(){}var s=(e["default"],t["default"]),o=r["default"],u=n.createInjectionHelper,l=s.extend(o);u("controller",a),i["default"]=l}),e("ember-runtime/controllers/object_controller",["ember-runtime/mixins/controller","ember-runtime/system/object_proxy","exports"],function(e,t,r){"use strict";var n=e["default"],i=t["default"];r["default"]=i.extend(n)}),e("ember-runtime/copy",["ember-metal/enumerable_utils","ember-metal/utils","ember-runtime/system/object","ember-runtime/mixins/copyable","exports"],function(e,t,r,n,i){"use strict";function a(e,t,r,n){var i,l,c;if("object"!=typeof e||null===e)return e;if(t&&(l=s(r,e))>=0)return n[l];if("array"===o(e)){if(i=e.slice(),t)for(l=i.length;--l>=0;)i[l]=a(i[l],t,r,n)}else if(u&&u.detect(e))i=e.copy(t,r,n);else if(e instanceof Date)i=new Date(e.getTime());else{i={};for(c in e)Object.prototype.hasOwnProperty.call(e,c)&&"__"!==c.substring(0,2)&&(i[c]=t?a(e[c],t,r,n):e[c])}return t&&(r.push(e),n.push(i)),i}var s=e.indexOf,o=t.typeOf,u=(r["default"],n["default"]);i["default"]=function(e,t){return"object"!=typeof e||null===e?e:u&&u.detect(e)?e.copy(t):a(e,t,t?[]:null,t?[]:null)}}),e("ember-runtime/core",["exports"],function(e){"use strict";var t=function(e,t){return e&&"function"==typeof e.isEqual?e.isEqual(t):e instanceof Date&&t instanceof Date?e.getTime()===t.getTime():e===t};e.isEqual=t}),e("ember-runtime/ext/function",["ember-metal/core","ember-metal/expand_properties","ember-metal/computed","ember-metal/mixin"],function(e,t,r,n){"use strict";var i=e["default"],a=t["default"],s=r.computed,o=n.observer,u=Array.prototype.slice,l=Function.prototype;(i.EXTEND_PROTOTYPES===!0||i.EXTEND_PROTOTYPES.Function)&&(l.property=function(){var e=s(this);return e.property.apply(e,arguments)},l.observes=function(){for(var e=arguments.length,t=new Array(e),r=0;e>r;r++)t[r]=arguments[r];return o.apply(this,t.concat(this))},l.observesImmediately=function(){return this.observes.apply(this,arguments)},l.observesBefore=function(){for(var e=[],t=function(t){e.push(t)},r=0,n=arguments.length;n>r;++r)a(arguments[r],t);return this.__ember_observesBefore__=e,this},l.on=function(){var e=u.call(arguments);return this.__ember_listens__=e,this})}),e("ember-runtime/ext/rsvp",["ember-metal/core","ember-metal/logger","ember-metal/run_loop","rsvp","exports"],function(e,r,n,i,a){"use strict";var s,o=e["default"],u=r["default"],l=n["default"],c=i,h="ember-testing/test",m=function(){o.Test&&o.Test.adapter&&o.Test.adapter.asyncStart()},p=function(){o.Test&&o.Test.adapter&&o.Test.adapter.asyncEnd()};c.configure("async",function(e,t){var r=!l.currentRunLoop;o.testing&&r&&m(),l.backburner.schedule("actions",function(){o.testing&&r&&p(),e(t)})}),c.Promise.prototype.fail=function(e,t){return this["catch"](e,t)},c.onerrorDefault=function(e){var r;if(e&&e.errorThrown?(r=e.errorThrown,"string"==typeof r&&(r=new Error(r)),r.__reason_with_error_thrown__=e):r=e,r&&"TransitionAborted"!==r.name)if(o.testing){if(!s&&o.__loader.registry[h]&&(s=t(h)["default"]),!s||!s.adapter)throw r;s.adapter.exception(r),u.error(r.stack)}else o.onerror?o.onerror(r):u.error(r.stack)},c.on("error",c.onerrorDefault),a["default"]=c}),e("ember-runtime/ext/string",["ember-metal/core","ember-runtime/system/string"],function(e,t){"use strict";var r=e["default"],n=t.fmt,i=t.w,a=t.loc,s=t.camelize,o=t.decamelize,u=t.dasherize,l=t.underscore,c=t.capitalize,h=t.classify,m=String.prototype;(r.EXTEND_PROTOTYPES===!0||r.EXTEND_PROTOTYPES.String)&&(m.fmt=function(){return n(this,arguments)},m.w=function(){return i(this)},m.loc=function(){return a(this,arguments)},m.camelize=function(){return s(this)},m.decamelize=function(){return o(this)},m.dasherize=function(){return u(this)},m.underscore=function(){return l(this)},m.classify=function(){return h(this)},m.capitalize=function(){return c(this)})}),e("ember-runtime/inject",["ember-metal/core","ember-metal/enumerable_utils","ember-metal/utils","ember-metal/injected_property","ember-metal/keys","exports"],function(e,t,r,n,i,a){"use strict";function s(){}function o(e,t){m[e]=t,s[e]=function(t){return new h(e,t)}}function u(e){var t,r,n,i,a,s=e.proto(),o=c(s).descs,u=[];for(t in o)r=o[t],r instanceof h&&-1===l(u,r.type)&&u.push(r.type);if(u.length)for(i=0,a=u.length;a>i;i++)n=m[u[i]],"function"==typeof n&&n(e);return!0}var l=(e["default"],t.indexOf),c=r.meta,h=n["default"],m=(i["default"],{});a.createInjectionHelper=o,a.validatePropertyInjections=u,a["default"]=s}),e("ember-runtime/mixins/-proxy",["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/observer","ember-metal/property_events","ember-metal/computed","ember-metal/properties","ember-metal/mixin","ember-runtime/system/string","exports"],function(e,t,r,n,i,a,s,o,u,l,c){"use strict";function h(e,t){var r=t.slice(8);r in this||_(this,r)}function m(e,t){var r=t.slice(8);r in this||w(this,r)}{var p=(e["default"],t.get),f=r.set,d=n.meta,v=i.addObserver,b=i.removeObserver,g=i.addBeforeObserver,y=i.removeBeforeObserver,_=a.propertyWillChange,w=a.propertyDidChange,x=s.computed,C=o.defineProperty,E=u.Mixin,O=u.observer;l.fmt}c["default"]=E.create({content:null,_contentDidChange:O("content",function(){}),isTruthy:x.bool("content"),_debugContainerKey:null,willWatchProperty:function(e){var t="content."+e;g(this,t,null,h),v(this,t,null,m)},didUnwatchProperty:function(e){var t="content."+e;y(this,t,null,h),b(this,t,null,m)},unknownProperty:function(e){var t=p(this,"content");return t?p(t,e):void 0},setUnknownProperty:function(e,t){var r=d(this);if(r.proto===this)return C(this,e,null,t),t;var n=p(this,"content");return f(n,e,t)}})}),e("ember-runtime/mixins/action_handler",["ember-metal/merge","ember-metal/mixin","ember-metal/property_get","ember-metal/utils","exports"],function(e,t,r,n,i){"use strict";var a=e["default"],s=t.Mixin,o=r.get,u=n.typeOf,l=s.create({mergedProperties:["_actions"],willMergeMixin:function(e){var t;e._actions||("object"===u(e.actions)?t="actions":"object"===u(e.events)&&(t="events"),t&&(e._actions=a(e._actions||{},e[t])),delete e[t])},send:function(e){var t,r=[].slice.call(arguments,1);this._actions&&this._actions[e]&&this._actions[e].apply(this,r)!==!0||(t=o(this,"target"))&&t.send.apply(t,arguments)}});i["default"]=l}),e("ember-runtime/mixins/array",["ember-metal/core","ember-metal/property_get","ember-metal/computed","ember-metal/is_none","ember-runtime/mixins/enumerable","ember-metal/enumerable_utils","ember-metal/mixin","ember-metal/property_events","ember-metal/events","ember-metal/watching","exports"],function(e,r,n,i,a,s,o,u,l,c,h){"use strict";function m(e,t,r,n,i){var a=r&&r.willChange||"arrayWillChange",s=r&&r.didChange||"arrayDidChange",o=f(e,"hasArrayObservers");return o===i&&x(e,"hasArrayObservers"),n(e,"@array:before",t,a),n(e,"@array:change",t,s),o===i&&C(e,"hasArrayObservers"),e}var p=e["default"],f=r.get,d=n.computed,v=n.cacheFor,b=i["default"],g=a["default"],y=s.map,_=o.Mixin,w=o.required,x=u.propertyWillChange,C=u.propertyDidChange,E=l.addListener,O=l.removeListener,P=l.sendEvent,A=l.hasListeners,N=c.isWatching;h["default"]=_.create(g,{length:w(),objectAt:function(e){return 0>e||e>=f(this,"length")?void 0:f(this,e)},objectsAt:function(e){var t=this;return y(e,function(e){return t.objectAt(e)})},nextObject:function(e){return this.objectAt(e)},"[]":d(function(e,t){return void 0!==t&&this.replace(0,f(this,"length"),t),this}),firstObject:d(function(){return this.objectAt(0)}),lastObject:d(function(){return this.objectAt(f(this,"length")-1)}),contains:function(e){return this.indexOf(e)>=0},slice:function(e,t){var r=p.A(),n=f(this,"length");for(b(e)&&(e=0),(b(t)||t>n)&&(t=n),0>e&&(e=n+e),0>t&&(t=n+t);t>e;)r[r.length]=this.objectAt(e++);return r},indexOf:function(e,t){var r,n=f(this,"length");for(void 0===t&&(t=0),0>t&&(t+=n),r=t;n>r;r++)if(this.objectAt(r)===e)return r;return-1},lastIndexOf:function(e,t){var r,n=f(this,"length");for((void 0===t||t>=n)&&(t=n-1),0>t&&(t+=n),r=t;r>=0;r--)if(this.objectAt(r)===e)return r;return-1},addArrayObserver:function(e,t){return m(this,e,t,E,!1)},removeArrayObserver:function(e,t){return m(this,e,t,O,!0)},hasArrayObservers:d(function(){return A(this,"@array:change")||A(this,"@array:before")}),arrayContentWillChange:function(e,t,r){var n,i;if(void 0===e?(e=0,t=r=-1):(void 0===t&&(t=-1),void 0===r&&(r=-1)),N(this,"@each")&&f(this,"@each"),P(this,"@array:before",[this,e,t,r]),e>=0&&t>=0&&f(this,"hasEnumerableObservers")){n=[],i=e+t;for(var a=e;i>a;a++)n.push(this.objectAt(a))}else n=t;return this.enumerableContentWillChange(n,r),this},arrayContentDidChange:function(e,t,r){var n,i;if(void 0===e?(e=0,t=r=-1):(void 0===t&&(t=-1),void 0===r&&(r=-1)),e>=0&&r>=0&&f(this,"hasEnumerableObservers")){n=[],i=e+r;for(var a=e;i>a;a++)n.push(this.objectAt(a))}else n=r;this.enumerableContentDidChange(t,n),P(this,"@array:change",[this,e,t,r]);var s=f(this,"length"),o=v(this,"firstObject"),u=v(this,"lastObject");return this.objectAt(0)!==o&&(x(this,"firstObject"),C(this,"firstObject")),this.objectAt(s-1)!==u&&(x(this,"lastObject"),C(this,"lastObject")),this},"@each":d(function(){if(!this.__each){var e=t("ember-runtime/system/each_proxy").EachProxy;this.__each=new e(this)}return this.__each})})}),e("ember-runtime/mixins/comparable",["ember-metal/mixin","exports"],function(e,t){"use strict";var r=e.Mixin,n=e.required;t["default"]=r.create({compare:n(Function)})}),e("ember-runtime/mixins/controller",["ember-metal/mixin","ember-metal/computed","ember-runtime/mixins/action_handler","ember-runtime/mixins/controller_content_model_alias_deprecation","exports"],function(e,t,r,n,i){"use strict";var a=e.Mixin,s=t.computed,o=r["default"],u=n["default"];i["default"]=a.create(o,u,{isController:!0,target:null,container:null,parentController:null,store:null,model:null,content:s.alias("model")})}),e("ember-runtime/mixins/controller_content_model_alias_deprecation",["ember-metal/core","ember-metal/mixin","exports"],function(e,t,r){"use strict";var n=(e["default"],t.Mixin);r["default"]=n.create({willMergeMixin:function(e){this._super.apply(this,arguments);var t=!!e.model;e.content&&!t&&(e.model=e.content,delete e.content)}})}),e("ember-runtime/mixins/copyable",["ember-metal/property_get","ember-metal/mixin","ember-runtime/mixins/freezable","ember-runtime/system/string","ember-metal/error","exports"],function(e,t,r,n,i,a){"use strict";var s=e.get,o=t.required,u=r.Freezable,l=t.Mixin,c=n.fmt,h=i["default"];a["default"]=l.create({copy:o(Function),frozenCopy:function(){if(u&&u.detect(this))return s(this,"isFrozen")?this:this.copy().freeze();throw new h(c("%@ does not support freezing",[this]))}})}),e("ember-runtime/mixins/deferred",["ember-metal/core","ember-metal/property_get","ember-metal/mixin","ember-metal/computed","ember-runtime/ext/rsvp","exports"],function(e,t,r,n,i,a){"use strict";var s=(e["default"],t.get),o=r.Mixin,u=n.computed,l=i["default"];a["default"]=o.create({then:function(e,t,r){function n(t){return e(t===a?o:t)}var i,a,o;return o=this,i=s(this,"_deferred"),a=i.promise,a.then(e&&n,t,r)},resolve:function(e){var t,r;t=s(this,"_deferred"),r=t.promise,t.resolve(e===this?r:e)},reject:function(e){s(this,"_deferred").reject(e)},_deferred:u(function(){return l.defer("Ember: DeferredMixin - "+this)})})}),e("ember-runtime/mixins/enumerable",["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/mixin","ember-metal/enumerable_utils","ember-metal/computed","ember-metal/property_events","ember-metal/events","ember-runtime/compare","exports"],function(e,t,r,n,i,a,s,o,u,l,c){"use strict";function h(){return 0===k.length?{}:k.pop()}function m(e){return k.push(e),null}function p(e,t){function r(r){var i=d(r,e);return n?t===i:!!i}var n=2===arguments.length;return r}var f=e["default"],d=t.get,v=r.set,b=n.apply,g=i.Mixin,y=i.required,_=i.aliasMethod,w=a.indexOf,x=s.computed,C=o.propertyWillChange,E=o.propertyDidChange,O=u.addListener,P=u.removeListener,A=u.sendEvent,N=u.hasListeners,S=l["default"],T=Array.prototype.slice,k=[];c["default"]=g.create({nextObject:y(Function),firstObject:x("[]",function(){if(0===d(this,"length"))return void 0;var e=h(),t=this.nextObject(0,null,e);return m(e),t}),lastObject:x("[]",function(){var e=d(this,"length");if(0===e)return void 0;var t,r=h(),n=0,i=null;do i=t,t=this.nextObject(n++,i,r);while(void 0!==t);return m(r),i}),contains:function(e){var t=this.find(function(t){return t===e});return void 0!==t},forEach:function(e,t){if("function"!=typeof e)throw new TypeError;var r=h(),n=d(this,"length"),i=null;void 0===t&&(t=null);for(var a=0;n>a;a++){var s=this.nextObject(a,i,r);e.call(t,s,a,this),i=s}return i=null,r=m(r),this},getEach:function(e){return this.mapBy(e)},setEach:function(e,t){return this.forEach(function(r){v(r,e,t)})},map:function(e,t){var r=f.A();return this.forEach(function(n,i,a){r[i]=e.call(t,n,i,a)}),r},mapBy:function(e){return this.map(function(t){return d(t,e)})},mapProperty:_("mapBy"),filter:function(e,t){var r=f.A();return this.forEach(function(n,i,a){e.call(t,n,i,a)&&r.push(n)}),r},reject:function(e,t){return this.filter(function(){return!b(t,e,arguments)})},filterBy:function(){return this.filter(b(this,p,arguments))},filterProperty:_("filterBy"),rejectBy:function(e,t){var r=function(r){return d(r,e)===t},n=function(t){return!!d(t,e)},i=2===arguments.length?r:n;return this.reject(i)},rejectProperty:_("rejectBy"),find:function(e,t){var r=d(this,"length");void 0===t&&(t=null);for(var n,i,a=h(),s=!1,o=null,u=0;r>u&&!s;u++)n=this.nextObject(u,o,a),(s=e.call(t,n,u,this))&&(i=n),o=n;return n=o=null,a=m(a),i},findBy:function(){return this.find(b(this,p,arguments))},findProperty:_("findBy"),every:function(e,t){return!this.find(function(r,n,i){return!e.call(t,r,n,i)})},everyBy:_("isEvery"),everyProperty:_("isEvery"),isEvery:function(){return this.every(b(this,p,arguments))},any:function(e,t){var r,n,i=d(this,"length"),a=h(),s=!1,o=null;for(void 0===t&&(t=null),n=0;i>n&&!s;n++)r=this.nextObject(n,o,a),s=e.call(t,r,n,this),o=r;return r=o=null,a=m(a),s},some:_("any"),isAny:function(){return this.any(b(this,p,arguments))},anyBy:_("isAny"),someProperty:_("isAny"),reduce:function(e,t,r){if("function"!=typeof e)throw new TypeError;var n=t;return this.forEach(function(t,i){n=e(n,t,i,this,r)},this),n},invoke:function(e){var t,r=f.A();return arguments.length>1&&(t=T.call(arguments,1)),this.forEach(function(n,i){var a=n&&n[e];"function"==typeof a&&(r[i]=t?b(n,a,t):n[e]())},this),r},toArray:function(){var e=f.A();return this.forEach(function(t,r){e[r]=t}),e},compact:function(){return this.filter(function(e){return null!=e})},without:function(e){if(!this.contains(e))return this;var t=f.A();return this.forEach(function(r){r!==e&&(t[t.length]=r)}),t},uniq:function(){var e=f.A();return this.forEach(function(t){w(e,t)<0&&e.push(t)}),e},"[]":x(function(){return this}),addEnumerableObserver:function(e,t){var r=t&&t.willChange||"enumerableWillChange",n=t&&t.didChange||"enumerableDidChange",i=d(this,"hasEnumerableObservers");return i||C(this,"hasEnumerableObservers"),O(this,"@enumerable:before",e,r),O(this,"@enumerable:change",e,n),i||E(this,"hasEnumerableObservers"),this},removeEnumerableObserver:function(e,t){var r=t&&t.willChange||"enumerableWillChange",n=t&&t.didChange||"enumerableDidChange",i=d(this,"hasEnumerableObservers");return i&&C(this,"hasEnumerableObservers"),P(this,"@enumerable:before",e,r),P(this,"@enumerable:change",e,n),i&&E(this,"hasEnumerableObservers"),this},hasEnumerableObservers:x(function(){return N(this,"@enumerable:change")||N(this,"@enumerable:before")}),enumerableContentWillChange:function(e,t){var r,n,i;return r="number"==typeof e?e:e?d(e,"length"):e=-1,n="number"==typeof t?t:t?d(t,"length"):t=-1,i=0>n||0>r||n-r!==0,-1===e&&(e=null),-1===t&&(t=null),C(this,"[]"),i&&C(this,"length"),A(this,"@enumerable:before",[this,e,t]),this},enumerableContentDidChange:function(e,t){var r,n,i;return r="number"==typeof e?e:e?d(e,"length"):e=-1,n="number"==typeof t?t:t?d(t,"length"):t=-1,i=0>n||0>r||n-r!==0,-1===e&&(e=null),-1===t&&(t=null),A(this,"@enumerable:change",[this,e,t]),i&&E(this,"length"),E(this,"[]"),this},sortBy:function(){var e=arguments;return this.toArray().sort(function(t,r){for(var n=0;nn;n++)r[n-1]=arguments[n];o(this,e,r)},off:function(e,t,r){return a(this,e,t,r),this},has:function(e){return s(this,e)}})}),e("ember-runtime/mixins/freezable",["ember-metal/mixin","ember-metal/property_get","ember-metal/property_set","exports"],function(e,t,r,n){"use strict";var i=e.Mixin,a=t.get,s=r.set,o=i.create({isFrozen:!1,freeze:function(){return a(this,"isFrozen")?this:(s(this,"isFrozen",!0),this)}});n.Freezable=o;var u="Frozen object cannot be modified.";n.FROZEN_ERROR=u}),e("ember-runtime/mixins/mutable_array",["ember-metal/property_get","ember-metal/utils","ember-metal/error","ember-metal/mixin","ember-runtime/mixins/array","ember-runtime/mixins/mutable_enumerable","ember-runtime/mixins/enumerable","exports"],function(e,t,r,n,i,a,s,o){"use strict";var u="Index out of range",l=[],c=e.get,h=t.isArray,m=r["default"],p=n.Mixin,f=n.required,d=i["default"],v=a["default"],b=s["default"];o["default"]=p.create(d,v,{replace:f(),clear:function(){var e=c(this,"length");return 0===e?this:(this.replace(0,e,l),this)},insertAt:function(e,t){if(e>c(this,"length"))throw new m(u);return this.replace(e,0,[t]),this},removeAt:function(e,t){if("number"==typeof e){if(0>e||e>=c(this,"length"))throw new m(u);void 0===t&&(t=1),this.replace(e,t,l)}return this},pushObject:function(e){return this.insertAt(c(this,"length"),e),e},pushObjects:function(e){if(!b.detect(e)&&!h(e))throw new TypeError("Must pass Ember.Enumerable to Ember.MutableArray#pushObjects");return this.replace(c(this,"length"),0,e),this},popObject:function(){var e=c(this,"length");if(0===e)return null;var t=this.objectAt(e-1);return this.removeAt(e-1,1),t},shiftObject:function(){if(0===c(this,"length"))return null;var e=this.objectAt(0);return this.removeAt(0),e},unshiftObject:function(e){return this.insertAt(0,e),e},unshiftObjects:function(e){return this.replace(0,0,e),this},reverseObjects:function(){var e=c(this,"length");if(0===e)return this;var t=this.toArray().reverse();return this.replace(0,e,t),this},setObjects:function(e){if(0===e.length)return this.clear();var t=c(this,"length");return this.replace(0,t,e),this},removeObject:function(e){for(var t=c(this,"length")||0;--t>=0;){var r=this.objectAt(t);r===e&&this.removeAt(t)}return this},addObject:function(e){return this.contains(e)||this.pushObject(e),this}})}),e("ember-runtime/mixins/mutable_enumerable",["ember-metal/enumerable_utils","ember-runtime/mixins/enumerable","ember-metal/mixin","ember-metal/property_events","exports"],function(e,t,r,n,i){"use strict";var a=e.forEach,s=t["default"],o=r.Mixin,u=r.required,l=n.beginPropertyChanges,c=n.endPropertyChanges;i["default"]=o.create(s,{addObject:u(Function),addObjects:function(e){return l(this),a(e,function(e){this.addObject(e)},this),c(this),this},removeObject:u(Function),removeObjects:function(e){l(this);for(var t=e.length-1;t>=0;t--)this.removeObject(e[t]);return c(this),this}})}),e("ember-runtime/mixins/observable",["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/get_properties","ember-metal/set_properties","ember-metal/mixin","ember-metal/events","ember-metal/property_events","ember-metal/observer","ember-metal/computed","ember-metal/is_none","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m){"use strict";var p=(e["default"],t.get),f=t.getWithDefault,d=r.set,v=n.apply,b=i["default"],g=a["default"],y=s.Mixin,_=o.hasListeners,w=u.beginPropertyChanges,x=u.propertyWillChange,C=u.propertyDidChange,E=u.endPropertyChanges,O=l.addObserver,P=l.addBeforeObserver,A=l.removeObserver,N=l.observersFor,S=c.cacheFor,T=h["default"],k=Array.prototype.slice;m["default"]=y.create({get:function(e){return p(this,e)},getProperties:function(){return v(null,b,[this].concat(k.call(arguments)))},set:function(e,t){return d(this,e,t),this},setProperties:function(e){return g(this,e)},beginPropertyChanges:function(){return w(),this},endPropertyChanges:function(){return E(),this},propertyWillChange:function(e){return x(this,e),this},propertyDidChange:function(e){return C(this,e),this},notifyPropertyChange:function(e){return this.propertyWillChange(e),this.propertyDidChange(e),this},addBeforeObserver:function(e,t,r){P(this,e,t,r)},addObserver:function(e,t,r){O(this,e,t,r)},removeObserver:function(e,t,r){A(this,e,t,r)},hasObserverFor:function(e){return _(this,e+":change")},getWithDefault:function(e,t){return f(this,e,t)},incrementProperty:function(e,t){return T(t)&&(t=1),d(this,e,(parseFloat(p(this,e))||0)+t),p(this,e)},decrementProperty:function(e,t){return T(t)&&(t=1),d(this,e,(p(this,e)||0)-t),p(this,e)},toggleProperty:function(e){return d(this,e,!p(this,e)),p(this,e)},cacheFor:function(e){return S(this,e)},observersForKey:function(e){return N(this,e)}})}),e("ember-runtime/mixins/promise_proxy",["ember-metal/property_get","ember-metal/set_properties","ember-metal/computed","ember-metal/mixin","ember-metal/error","exports"],function(e,t,r,n,i,a){"use strict";function s(e,t){return l(e,{isFulfilled:!1,isRejected:!1}),t.then(function(t){return l(e,{content:t,isFulfilled:!0}),t},function(t){throw l(e,{reason:t,isRejected:!0}),t},"Ember: PromiseProxy")}function o(e){return function(){var t=u(this,"promise");return t[e].apply(t,arguments)}}var u=e.get,l=t["default"],c=r.computed,h=n.Mixin,m=i["default"],p=c.not,f=c.or;
-a["default"]=h.create({reason:null,isPending:p("isSettled").readOnly(),isSettled:f("isRejected","isFulfilled").readOnly(),isRejected:!1,isFulfilled:!1,promise:c(function(e,t){if(2===arguments.length)return s(this,t);throw new m("PromiseProxy's promise must be set")}),then:o("then"),"catch":o("catch"),"finally":o("finally")})}),e("ember-runtime/mixins/sortable",["ember-metal/core","ember-metal/property_get","ember-metal/enumerable_utils","ember-metal/mixin","ember-runtime/mixins/mutable_enumerable","ember-runtime/compare","ember-metal/observer","ember-metal/computed","exports"],function(e,t,r,n,i,a,s,o,u){"use strict";var l=e["default"],c=t.get,h=r.forEach,m=n.Mixin,p=i["default"],f=a["default"],d=s.addObserver,v=s.removeObserver,b=o.computed,g=n.beforeObserver,y=n.observer;u["default"]=m.create(p,{sortProperties:null,sortAscending:!0,sortFunction:f,orderBy:function(e,t){var r=0,n=c(this,"sortProperties"),i=c(this,"sortAscending"),a=c(this,"sortFunction");return h(n,function(n){0===r&&(r=a.call(this,c(e,n),c(t,n)),0===r||i||(r=-1*r))},this),r},destroy:function(){var e=c(this,"content"),t=c(this,"sortProperties");return e&&t&&h(e,function(e){h(t,function(t){v(e,t,this,"contentItemSortPropertyDidChange")},this)},this),this._super()},isSorted:b.notEmpty("sortProperties"),arrangedContent:b("content","sortProperties.@each",function(){var e=c(this,"content"),t=c(this,"isSorted"),r=c(this,"sortProperties"),n=this;return e&&t?(e=e.slice(),e.sort(function(e,t){return n.orderBy(e,t)}),h(e,function(e){h(r,function(t){d(e,t,this,"contentItemSortPropertyDidChange")},this)},this),l.A(e)):e}),_contentWillChange:g("content",function(){var e=c(this,"content"),t=c(this,"sortProperties");e&&t&&h(e,function(e){h(t,function(t){v(e,t,this,"contentItemSortPropertyDidChange")},this)},this),this._super()}),sortPropertiesWillChange:g("sortProperties",function(){this._lastSortAscending=void 0}),sortPropertiesDidChange:y("sortProperties",function(){this._lastSortAscending=void 0}),sortAscendingWillChange:g("sortAscending",function(){this._lastSortAscending=c(this,"sortAscending")}),sortAscendingDidChange:y("sortAscending",function(){if(void 0!==this._lastSortAscending&&c(this,"sortAscending")!==this._lastSortAscending){var e=c(this,"arrangedContent");e.reverseObjects()}}),contentArrayWillChange:function(e,t,r,n){var i=c(this,"isSorted");if(i){var a=c(this,"arrangedContent"),s=e.slice(t,t+r),o=c(this,"sortProperties");h(s,function(e){a.removeObject(e),h(o,function(t){v(e,t,this,"contentItemSortPropertyDidChange")},this)},this)}return this._super(e,t,r,n)},contentArrayDidChange:function(e,t,r,n){var i=c(this,"isSorted"),a=c(this,"sortProperties");if(i){var s=e.slice(t,t+n);h(s,function(e){this.insertItemSorted(e),h(a,function(t){d(e,t,this,"contentItemSortPropertyDidChange")},this)},this)}return this._super(e,t,r,n)},insertItemSorted:function(e){var t=c(this,"arrangedContent"),r=c(t,"length"),n=this._binarySearch(e,0,r);t.insertAt(n,e)},contentItemSortPropertyDidChange:function(e){var t=c(this,"arrangedContent"),r=t.indexOf(e),n=t.objectAt(r-1),i=t.objectAt(r+1),a=n&&this.orderBy(e,n),s=i&&this.orderBy(e,i);(0>a||s>0)&&(t.removeObject(e),this.insertItemSorted(e))},_binarySearch:function(e,t,r){var n,i,a,s;return t===r?t:(s=c(this,"arrangedContent"),n=t+Math.floor((r-t)/2),i=s.objectAt(n),a=this.orderBy(i,e),0>a?this._binarySearch(e,n+1,r):a>0?this._binarySearch(e,t,n):n)}})}),e("ember-runtime/mixins/target_action_support",["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/mixin","ember-metal/computed","exports"],function(e,t,r,n,i,a){"use strict";var s=e["default"],o=t.get,u=r.typeOf,l=n.Mixin,c=i.computed,h=l.create({target:null,action:null,actionContext:null,targetObject:c(function(){var e=o(this,"target");if("string"===u(e)){var t=o(this,e);return void 0===t&&(t=o(s.lookup,e)),t}return e}).property("target"),actionContextObject:c(function(){var e=o(this,"actionContext");if("string"===u(e)){var t=o(this,e);return void 0===t&&(t=o(s.lookup,e)),t}return e}).property("actionContext"),triggerAction:function(e){function t(e,t){var r=[];return t&&r.push(t),r.concat(e)}e=e||{};var r=e.action||o(this,"action"),n=e.target||o(this,"targetObject"),i=e.actionContext;if("undefined"==typeof i&&(i=o(this,"actionContextObject")||this),n&&r){var a;return a=n.send?n.send.apply(n,t(i,r)):n[r].apply(n,t(i)),a!==!1&&(a=!0),a}return!1}});a["default"]=h}),e("ember-runtime/system/application",["ember-runtime/system/namespace","exports"],function(e,t){"use strict";var r=e["default"];t["default"]=r.extend()}),e("ember-runtime/system/array_proxy",["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/computed","ember-metal/mixin","ember-metal/property_events","ember-metal/error","ember-runtime/system/object","ember-runtime/mixins/mutable_array","ember-runtime/mixins/enumerable","ember-runtime/system/string","ember-metal/alias","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m){"use strict";function p(){return this}var f=(e["default"],t.get),d=r.isArray,v=r.apply,b=n.computed,g=i.beforeObserver,y=i.observer,_=a.beginPropertyChanges,w=a.endPropertyChanges,x=s["default"],C=o["default"],E=u["default"],O=l["default"],P=(c.fmt,h["default"]),A="Index out of range",N=[],S=C.extend(E,{content:null,arrangedContent:P("content"),objectAtContent:function(e){return f(this,"arrangedContent").objectAt(e)},replaceContent:function(e,t,r){f(this,"content").replace(e,t,r)},_contentWillChange:g("content",function(){this._teardownContent()}),_teardownContent:function(){var e=f(this,"content");e&&e.removeArrayObserver(this,{willChange:"contentArrayWillChange",didChange:"contentArrayDidChange"})},contentArrayWillChange:p,contentArrayDidChange:p,_contentDidChange:y("content",function(){f(this,"content");this._setupContent()}),_setupContent:function(){var e=f(this,"content");e&&e.addArrayObserver(this,{willChange:"contentArrayWillChange",didChange:"contentArrayDidChange"})},_arrangedContentWillChange:g("arrangedContent",function(){var e=f(this,"arrangedContent"),t=e?f(e,"length"):0;this.arrangedContentArrayWillChange(this,0,t,void 0),this.arrangedContentWillChange(this),this._teardownArrangedContent(e)}),_arrangedContentDidChange:y("arrangedContent",function(){var e=f(this,"arrangedContent"),t=e?f(e,"length"):0;this._setupArrangedContent(),this.arrangedContentDidChange(this),this.arrangedContentArrayDidChange(this,0,void 0,t)}),_setupArrangedContent:function(){var e=f(this,"arrangedContent");e&&e.addArrayObserver(this,{willChange:"arrangedContentArrayWillChange",didChange:"arrangedContentArrayDidChange"})},_teardownArrangedContent:function(){var e=f(this,"arrangedContent");e&&e.removeArrayObserver(this,{willChange:"arrangedContentArrayWillChange",didChange:"arrangedContentArrayDidChange"})},arrangedContentWillChange:p,arrangedContentDidChange:p,objectAt:function(e){return f(this,"content")&&this.objectAtContent(e)},length:b(function(){var e=f(this,"arrangedContent");return e?f(e,"length"):0}),_replace:function(e,t,r){var n=f(this,"content");return n&&this.replaceContent(e,t,r),this},replace:function(){if(f(this,"arrangedContent")!==f(this,"content"))throw new x("Using replace on an arranged ArrayProxy is not allowed.");v(this,this._replace,arguments)},_insertAt:function(e,t){if(e>f(this,"content.length"))throw new x(A);return this._replace(e,0,[t]),this},insertAt:function(e,t){if(f(this,"arrangedContent")===f(this,"content"))return this._insertAt(e,t);throw new x("Using insertAt on an arranged ArrayProxy is not allowed.")},removeAt:function(e,t){if("number"==typeof e){var r,n=f(this,"content"),i=f(this,"arrangedContent"),a=[];if(0>e||e>=f(this,"length"))throw new x(A);for(void 0===t&&(t=1),r=e;e+t>r;r++)a.push(n.indexOf(i.objectAt(r)));for(a.sort(function(e,t){return t-e}),_(),r=0;rc;c++){var m=o[c];if("object"!=typeof m&&void 0!==m)throw new F("Ember.Object.create only accepts objects.");if(m)for(var p=H(m),f=0,d=p.length;d>f;f++){var v=p[f],b=m[v];if(M.test(v)){var g=i.bindings;g?i.hasOwnProperty("bindings")||(g=i.bindings=N(i.bindings)):g=i.bindings={},g[v]=b}var y=i.descs[v];if(u&&u.length>0&&L(u,v)>=0){var _=this[v];b=_?"function"==typeof _.concat?_.concat(b):V(_).concat(b):V(b)}if(l&&l.length&&L(l,v)>=0){var w=this[v];b=E(w,b)}y?y.set(this,v,b):"function"!=typeof this.setUnknownProperty||v in this?this[v]=b:this.setUnknownProperty(v,b)}}}X(this,i);var x=arguments.length;if(0===x)this.init();else if(1===x)this.init(arguments[0]);else{for(var C=new Array(x),O=0;x>O;O++)C[O]=arguments[O];this.init.apply(this,C)}i.proto=a,I(this),j(this,"init")};return n.toString=R.prototype.toString,n.willReopen=function(){r&&(n.PrototypeMixin=R.create(n.PrototypeMixin)),r=!1},n._initMixins=function(t){e=t},n._initProperties=function(e){t=e},n.proto=function(){var e=n.superclass;return e&&e.proto(),r||(r=!0,n.PrototypeMixin.applyPartial(n.prototype)),this.prototype},n}function w(e){return function(){return e}}function x(){}var C=e["default"],E=t["default"],O=r.get,P=n.guidFor,A=n.apply,N=i.create,S=n.generateGuid,T=n.GUID_KEY,k=n.meta,V=n.makeArray,I=a.finishChains,j=s.sendEvent,M=o.IS_BINDING,R=o.Mixin,D=o.required,L=u.indexOf,F=l["default"],B=i.defineProperty,H=c["default"],z=(h["default"],m.defineProperty,p.Binding),q=f.ComputedProperty,U=f.computed,W=d["default"],K=v["default"],G=b.destroy,Q=e.K,$=(i.hasPropertyAccessors,g.validatePropertyInjections,K.schedule),Y=R._apply,X=R.finishPartial,Z=R.prototype.reopen,J=!1,et={configurable:!0,writable:!0,enumerable:!1,value:void 0},tt={configurable:!0,writable:!0,enumerable:!1,value:null},rt=_();rt.toString=function(){return"Ember.CoreObject"},rt.PrototypeMixin=R.create({reopen:function(){for(var e=arguments.length,t=new Array(e),r=0;e>r;r++)t[r]=arguments[r];return Y(this,t,!0),this},init:function(){},concatenatedProperties:null,isDestroyed:!1,isDestroying:!1,destroy:function(){return this.isDestroying?void 0:(this.isDestroying=!0,$("actions",this,this.willDestroy),$("destroy",this,this._scheduledDestroy),this)},willDestroy:Q,_scheduledDestroy:function(){this.isDestroyed||(G(this),this.isDestroyed=!0)},bind:function(e,t){return t instanceof z||(t=z.from(t)),t.to(e).connect(this),t},toString:function(){var e="function"==typeof this.toStringExtension,t=e?":"+this.toStringExtension():"",r="<"+this.constructor.toString()+":"+P(this)+t+">";return this.toString=w(r),r}}),rt.PrototypeMixin.ownerConstructor=rt,rt.__super__=null;var nt={ClassMixin:D(),PrototypeMixin:D(),isClass:!0,isMethod:!1,extend:function(){var e,t=_();return t.ClassMixin=R.create(this.ClassMixin),t.PrototypeMixin=R.create(this.PrototypeMixin),t.ClassMixin.ownerConstructor=t,t.PrototypeMixin.ownerConstructor=t,Z.apply(t.PrototypeMixin,arguments),t.superclass=this,t.__super__=this.prototype,e=t.prototype=N(this.prototype),e.constructor=t,S(e),k(e).proto=e,t.ClassMixin.apply(t),t},createWithMixins:function(){var e=this,t=arguments.length;if(t>0){for(var r=new Array(t),n=0;t>n;n++)r[n]=arguments[n];this._initMixins(r)}return new e},create:function(){var e=this,t=arguments.length;if(t>0){for(var r=new Array(t),n=0;t>n;n++)r[n]=arguments[n];this._initProperties(r)}return new e},reopen:function(){this.willReopen();var e=arguments.length,t=new Array(e);if(e>0)for(var r=0;e>r;r++)t[r]=arguments[r];return A(this.PrototypeMixin,Z,t),this},reopenClass:function(){var e=arguments.length,t=new Array(e);if(e>0)for(var r=0;e>r;r++)t[r]=arguments[r];return A(this.ClassMixin,Z,t),Y(this,arguments,!1),this},detect:function(e){if("function"!=typeof e)return!1;for(;e;){if(e===this)return!0;e=e.superclass}return!1},detectInstance:function(e){return e instanceof this},metaForProperty:function(e){var t=this.proto().__ember_meta__,r=t&&t.descs[e];return r._meta||{}},_computedProperties:U(function(){J=!0;var e,t=this.proto(),r=k(t).descs,n=[];for(var i in r)e=r[i],e instanceof q&&n.push({name:i,meta:e._meta});return n}).readOnly(),eachComputedProperty:function(e,t){for(var r,n,i={},a=O(this,"_computedProperties"),s=0,o=a.length;o>s;s++)r=a[s],n=r.name,e.call(t||this,r.name,r.meta||i)}};x(),nt._lazyInjections=function(){var e,t,r={},n=this.proto(),i=k(n).descs;for(e in i)t=i[e],t instanceof W&&(r[e]=t.type+":"+(t.name||e));return r};var it=R.create(nt);it.ownerConstructor=rt,rt.ClassMixin=it,it.apply(rt),rt.reopen({didDefineProperty:function(e,t,r){if(J!==!1&&r instanceof C.ComputedProperty){var n=C.meta(this.constructor).cache;void 0!==n._computedProperties&&(n._computedProperties=void 0)}}}),y["default"]=rt}),e("ember-runtime/system/deferred",["ember-metal/core","ember-runtime/mixins/deferred","ember-runtime/system/object","exports"],function(e,t,r,n){"use strict";var i=(e["default"],t["default"]),a=r["default"],s=a.extend(i,{init:function(){this._super()}});s.reopenClass({promise:function(e,t){var r=s.create();return e.call(t,r),r}}),n["default"]=s}),e("ember-runtime/system/each_proxy",["ember-metal/core","ember-metal/property_get","ember-metal/utils","ember-metal/enumerable_utils","ember-metal/array","ember-runtime/mixins/array","ember-runtime/system/object","ember-metal/computed","ember-metal/observer","ember-metal/events","ember-metal/properties","ember-metal/property_events","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m){"use strict";function p(e,t,r,n,i){var a,s=r._objects;for(s||(s=r._objects={});--i>=n;){var o=e.objectAt(i);o&&(C(o,t,r,"contentKeyWillChange"),x(o,t,r,"contentKeyDidChange"),a=v(o),s[a]||(s[a]=[]),s[a].push(i))}}function f(e,t,r,n,i){var a=r._objects;a||(a=r._objects={});for(var s,o;--i>=n;){var u=e.objectAt(i);u&&(E(u,t,r,"contentKeyWillChange"),O(u,t,r,"contentKeyDidChange"),o=v(u),s=a[o],s[g.call(s,i)]=null)}}var d=(e["default"],t.get),v=r.guidFor,b=n.forEach,g=i.indexOf,y=a["default"],_=s["default"],w=o.computed,x=u.addObserver,C=u.addBeforeObserver,E=u.removeBeforeObserver,O=u.removeObserver,P=(r.typeOf,l.watchedEvents),A=c.defineProperty,N=h.beginPropertyChanges,S=h.propertyDidChange,T=h.propertyWillChange,k=h.endPropertyChanges,V=h.changeProperties,I=_.extend(y,{init:function(e,t,r){this._super(),this._keyName=t,this._owner=r,this._content=e},objectAt:function(e){var t=this._content.objectAt(e);return t&&d(t,this._keyName)},length:w(function(){var e=this._content;return e?d(e,"length"):0})}),j=/^.+:(before|change)$/,M=_.extend({init:function(e){this._super(),this._content=e,e.addArrayObserver(this),b(P(this),function(e){this.didAddListener(e)},this)},unknownProperty:function(e){var t;return t=new I(this._content,e,this),A(this,e,null,t),this.beginObservingContentKey(e),t},arrayWillChange:function(e,t,r){var n,i,a=this._keys;i=r>0?t+r:-1,N(this);for(n in a)a.hasOwnProperty(n)&&(i>0&&f(e,n,this,t,i),T(this,n));T(this._content,"@each"),k(this)},arrayDidChange:function(e,t,r,n){var i,a=this._keys;i=n>0?t+n:-1,V(function(){for(var r in a)a.hasOwnProperty(r)&&(i>0&&p(e,r,this,t,i),S(this,r));S(this._content,"@each")},this)},didAddListener:function(e){j.test(e)&&this.beginObservingContentKey(e.slice(0,-7))},didRemoveListener:function(e){j.test(e)&&this.stopObservingContentKey(e.slice(0,-7))},beginObservingContentKey:function(e){var t=this._keys;if(t||(t=this._keys={}),t[e])t[e]++;else{t[e]=1;var r=this._content,n=d(r,"length");p(r,e,this,0,n)}},stopObservingContentKey:function(e){var t=this._keys;if(t&&t[e]>0&&--t[e]<=0){var r=this._content,n=d(r,"length");f(r,e,this,0,n)}},contentKeyWillChange:function(e,t){T(this,t)},contentKeyDidChange:function(e,t){S(this,t)}});m.EachArray=I,m.EachProxy=M}),e("ember-runtime/system/lazy_load",["ember-metal/core","ember-metal/array","ember-runtime/system/native_array","exports"],function(e,t,r,n){"use strict";function i(e,t){var r;u[e]=u[e]||s.A(),u[e].pushObject(t),(r=l[e])&&t(r)}function a(e,t){if(l[e]=t,"object"==typeof window&&"function"==typeof window.dispatchEvent&&"function"==typeof CustomEvent){var r=new CustomEvent(e,{detail:t,name:e});window.dispatchEvent(r)}u[e]&&o.call(u[e],function(e){e(t)})}var s=e["default"],o=t.forEach,u=s.ENV.EMBER_LOAD_HOOKS||{},l={};n.onLoad=i,n.runLoadHooks=a}),e("ember-runtime/system/namespace",["ember-metal/core","ember-metal/property_get","ember-metal/array","ember-metal/utils","ember-metal/mixin","ember-runtime/system/object","exports"],function(e,t,r,n,i,a,s){"use strict";function o(e,t,r){var n=e.length;x[e.join(".")]=t;for(var i in t)if(C.call(t,i)){var a=t[i];if(e[n]=i,a&&a.toString===h)a.toString=p(e.join(".")),a[O]=e.join(".");else if(a&&a.isNamespace){if(r[g(a)])continue;r[g(a)]=!0,o(e,a,r)}}e.length=n}function u(e,t){try{var r=e[t];return r&&r.isNamespace&&r}catch(n){}}function l(){var e,t=f.lookup;if(!w.PROCESSED)for(var r in t)E.test(r)&&(!t.hasOwnProperty||t.hasOwnProperty(r))&&(e=u(t,r),e&&(e[O]=r))}function c(e){var t=e.superclass;return t?t[O]?t[O]:c(t):void 0}function h(){f.BOOTED||this[O]||m();var e;if(this[O])e=this[O];else if(this._toString)e=this._toString;else{var t=c(this);e=t?"(subclass of "+t+")":"(unknown mixin)",this.toString=p(e)}return e}function m(){var e=!w.PROCESSED,t=f.anyUnprocessedMixins;if(e&&(l(),w.PROCESSED=!0),e||t){for(var r,n=w.NAMESPACES,i=0,a=n.length;a>i;i++)r=n[i],o([r.toString()],r,{});f.anyUnprocessedMixins=!1}}function p(e){return function(){return e}}var f=e["default"],d=t.get,v=r.indexOf,b=n.GUID_KEY,g=n.guidFor,y=i.Mixin,_=a["default"],w=_.extend({isNamespace:!0,init:function(){w.NAMESPACES.push(this),w.PROCESSED=!1},toString:function(){var e=d(this,"name")||d(this,"modulePrefix");return e?e:(l(),this[O])},nameClasses:function(){o([this.toString()],this,{})},destroy:function(){var e=w.NAMESPACES,t=this.toString();t&&(f.lookup[t]=void 0,delete w.NAMESPACES_BY_ID[t]),e.splice(v.call(e,this),1),this._super()}});w.reopenClass({NAMESPACES:[f],NAMESPACES_BY_ID:{},PROCESSED:!1,processAll:m,byName:function(e){return f.BOOTED||m(),x[e]}});var x=w.NAMESPACES_BY_ID,C={}.hasOwnProperty,E=/^[A-Z]/,O=f.NAME_KEY=b+"_name";y.prototype.toString=h,s["default"]=w}),e("ember-runtime/system/native_array",["ember-metal/core","ember-metal/property_get","ember-metal/enumerable_utils","ember-metal/mixin","ember-metal/array","ember-runtime/mixins/array","ember-runtime/mixins/mutable_array","ember-runtime/mixins/observable","ember-runtime/mixins/copyable","ember-runtime/mixins/freezable","ember-runtime/copy","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h){"use strict";var m=e["default"],p=t.get,f=r._replace,d=r.forEach,v=n.Mixin,b=i.indexOf,g=i.lastIndexOf,y=a["default"],_=s["default"],w=o["default"],x=u["default"],C=l.FROZEN_ERROR,E=c["default"],O=v.create(_,w,x,{get:function(e){return"length"===e?this.length:"number"==typeof e?this[e]:this._super(e)},objectAt:function(e){return this[e]},replace:function(e,t,r){if(this.isFrozen)throw C;var n=r?p(r,"length"):0;return this.arrayContentWillChange(e,t,n),0===n?this.splice(e,t):f(this,e,t,r),this.arrayContentDidChange(e,t,n),this},unknownProperty:function(e,t){var r;return void 0!==t&&void 0===r&&(r=this[e]=t),r},indexOf:b,lastIndexOf:g,copy:function(e){return e?this.map(function(e){return E(e,!0)}):this.slice()}}),P=["length"];d(O.keys(),function(e){Array.prototype[e]&&P.push(e)}),P.length>0&&(O=O.without.apply(O,P));var A=function(e){return void 0===e&&(e=[]),y.detect(e)?e:O.apply(e)};O.activate=function(){O.apply(Array.prototype),A=function(e){return e||[]}},(m.EXTEND_PROTOTYPES===!0||m.EXTEND_PROTOTYPES.Array)&&O.activate(),m.A=A,h.A=A,h.NativeArray=O,h["default"]=O}),e("ember-runtime/system/object",["ember-runtime/system/core_object","ember-runtime/mixins/observable","exports"],function(e,t,r){"use strict";var n=e["default"],i=t["default"],a=n.extend(i);a.toString=function(){return"Ember.Object"},r["default"]=a}),e("ember-runtime/system/object_proxy",["ember-runtime/system/object","ember-runtime/mixins/-proxy","exports"],function(e,t,r){"use strict";var n=e["default"],i=t["default"];r["default"]=n.extend(i)}),e("ember-runtime/system/service",["ember-runtime/system/object","ember-runtime/inject","exports"],function(e,t,r){"use strict";var n,i=e["default"],a=t.createInjectionHelper;n=i.extend(),a("service"),r["default"]=n}),e("ember-runtime/system/set",["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/utils","ember-metal/is_none","ember-runtime/system/string","ember-runtime/system/core_object","ember-runtime/mixins/mutable_enumerable","ember-runtime/mixins/enumerable","ember-runtime/mixins/copyable","ember-runtime/mixins/freezable","ember-metal/error","ember-metal/property_events","ember-metal/mixin","ember-metal/computed","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m,p,f,d){"use strict";var v=(e["default"],t.get),b=r.set,g=n.guidFor,y=i["default"],_=a.fmt,w=s["default"],x=o["default"],C=u["default"],E=l["default"],O=c.Freezable,P=c.FROZEN_ERROR,A=h["default"],N=m.propertyWillChange,S=m.propertyDidChange,T=p.aliasMethod,k=f.computed;d["default"]=w.extend(x,E,O,{length:0,clear:function(){if(this.isFrozen)throw new A(P);var e=v(this,"length");if(0===e)return this;var t;this.enumerableContentWillChange(e,0),N(this,"firstObject"),N(this,"lastObject");for(var r=0;e>r;r++)t=g(this[r]),delete this[t],delete this[r];return b(this,"length",0),S(this,"firstObject"),S(this,"lastObject"),this.enumerableContentDidChange(e,0),this},isEqual:function(e){if(!C.detect(e))return!1;var t=v(this,"length");if(v(e,"length")!==t)return!1;for(;--t>=0;)if(!e.contains(this[t]))return!1;return!0},add:T("addObject"),remove:T("removeObject"),pop:function(){if(v(this,"isFrozen"))throw new A(P);var e=this.length>0?this[this.length-1]:null;return this.remove(e),e},push:T("addObject"),shift:T("pop"),unshift:T("push"),addEach:T("addObjects"),removeEach:T("removeObjects"),init:function(e){this._super(),e&&this.addObjects(e)},nextObject:function(e){return this[e]},firstObject:k(function(){return this.length>0?this[0]:void 0}),lastObject:k(function(){return this.length>0?this[this.length-1]:void 0}),addObject:function(e){if(v(this,"isFrozen"))throw new A(P);if(y(e))return this;var t,r=g(e),n=this[r],i=v(this,"length");return n>=0&&i>n&&this[n]===e?this:(t=[e],this.enumerableContentWillChange(null,t),N(this,"lastObject"),i=v(this,"length"),this[r]=i,this[i]=e,b(this,"length",i+1),S(this,"lastObject"),this.enumerableContentDidChange(null,t),this)},removeObject:function(e){if(v(this,"isFrozen"))throw new A(P);if(y(e))return this;var t,r,n=g(e),i=this[n],a=v(this,"length"),s=0===i,o=i===a-1;return i>=0&&a>i&&this[i]===e&&(r=[e],this.enumerableContentWillChange(r,null),s&&N(this,"firstObject"),o&&N(this,"lastObject"),a-1>i&&(t=this[a-1],this[i]=t,this[g(t)]=i),delete this[n],delete this[a-1],b(this,"length",a-1),s&&S(this,"firstObject"),o&&S(this,"lastObject"),this.enumerableContentDidChange(r,null)),this},contains:function(e){return this[g(e)]>=0},copy:function(){var e=this.constructor,t=new e,r=v(this,"length");for(b(t,"length",r);--r>=0;)t[r]=this[r],t[g(this[r])]=r;return t},toString:function(){var e,t=this.length,r=[];for(e=0;t>e;e++)r[e]=this[e];return _("Ember.Set<%@>",[r.join(",")])}})}),e("ember-runtime/system/string",["ember-metal/core","ember-metal/utils","ember-metal/cache","exports"],function(e,t,r,n){"use strict";function i(e,t){var r=t;if(!f(r)||arguments.length>2){r=new Array(arguments.length-1);for(var n=1,i=arguments.length;i>n;n++)r[n-1]=arguments[n]}var a=0;return e.replace(/%@([0-9]+)?/g,function(e,t){return t=t?parseInt(t,10)-1:a++,e=r[t],null===e?"(null)":void 0===e?"":d(e)})}function a(e,t){return(!f(t)||arguments.length>2)&&(t=Array.prototype.slice.call(arguments,1)),e=p.STRINGS[e]||e,i(e,t)}function s(e){return e.split(/\s+/)}function o(e){return C.get(e)}function u(e){return g.get(e)}function l(e){return y.get(e)}function c(e){return _.get(e)}function h(e){return w.get(e)}function m(e){return x.get(e)}var p=e["default"],f=t.isArray,d=t.inspect,v=r["default"],b=/[ _]/g,g=new v(1e3,function(e){return o(e).replace(b,"-")}),y=new v(1e3,function(e){return e.replace(O,function(e,t,r){return r?r.toUpperCase():""}).replace(/^([A-Z])/,function(e){return e.toLowerCase()})}),_=new v(1e3,function(e){for(var t=e.split("."),r=[],n=0,i=t.length;i>n;n++){var a=l(t[n]);r.push(a.charAt(0).toUpperCase()+a.substr(1))}return r.join(".")}),w=new v(1e3,function(e){return e.replace(P,"$1_$2").replace(A,"_").toLowerCase()}),x=new v(1e3,function(e){return e.charAt(0).toUpperCase()+e.substr(1)}),C=new v(1e3,function(e){return e.replace(E,"$1_$2").toLowerCase()}),E=/([a-z\d])([A-Z])/g,O=/(\-|_|\.|\s)+(.)?/g,P=/([a-z\d])([A-Z]+)/g,A=/\-|\s+/g;p.STRINGS={},n["default"]={fmt:i,loc:a,w:s,decamelize:o,dasherize:u,camelize:l,classify:c,underscore:h,capitalize:m},n.fmt=i,n.loc=a,n.w=s,n.decamelize=o,n.dasherize=u,n.camelize=l,n.classify=c,n.underscore=h,n.capitalize=m}),e("ember-runtime/system/subarray",["ember-metal/error","ember-metal/enumerable_utils","exports"],function(e,t,r){"use strict";function n(e,t){this.type=e,this.count=t}function i(e){arguments.length<1&&(e=0),this._operations=e>0?[new n(o,e)]:[]}var a=e["default"],s=t["default"],o="r",u="f";r["default"]=i,i.prototype={addItem:function(e,t){var r=-1,i=t?o:u,a=this;return this._findOperation(e,function(s,u,l,c,h){var m,p;i===s.type?++s.count:e===l?a._operations.splice(u,0,new n(i,1)):(m=new n(i,1),p=new n(s.type,c-e+1),s.count=e-l,a._operations.splice(u+1,0,m,p)),t&&(r=s.type===o?h+(e-l):h),a._composeAt(u)},function(e){a._operations.push(new n(i,1)),t&&(r=e),a._composeAt(a._operations.length-1)}),r},removeItem:function(e){var t=-1,r=this;return this._findOperation(e,function(n,i,a,s,u){n.type===o&&(t=u+(e-a)),n.count>1?--n.count:(r._operations.splice(i,1),r._composeAt(i))},function(){throw new a("Can't remove an item that has never been added.")}),t},_findOperation:function(e,t,r){var n,i,a,s,u,l=0;for(n=s=0,i=this._operations.length;i>n;s=u+1,++n){if(a=this._operations[n],u=s+a.count-1,e>=s&&u>=e)return void t(a,n,s,u,l);a.type===o&&(l+=a.count)}r(l)},_composeAt:function(e){var t,r=this._operations[e];r&&(e>0&&(t=this._operations[e-1],t.type===r.type&&(r.count+=t.count,this._operations.splice(e-1,1),--e)),er)){var n,a,o=this._findArrayOperation(e),u=o.operation,c=o.index,h=o.rangeStart;a=new i(l,r,t),u?o.split?(this._split(c,e-h,a),n=c+1):(this._operations.splice(c,0,a),n=c):(this._operations.push(a),n=c),this._composeInsert(n)}},removeItems:function(e,t){if(!(1>t)){var r,n,a=this._findArrayOperation(e),s=a.index,o=a.rangeStart;return r=new i(c,t),a.split?(this._split(s,e-o,r),n=s+1):(this._operations.splice(s,0,r),n=s),this._composeDelete(n)}},apply:function(e){var t=[],r=0;o(this._operations,function(n,i){e(n.items,r,n.type,i),n.type!==c&&(r+=n.count,t=t.concat(n.items))}),this._operations=[new i(u,t.length,t)]},_findArrayOperation:function(e){var t,r,n,i,s,o=!1;for(t=n=0,s=this._operations.length;s>t;++t)if(r=this._operations[t],r.type!==c){if(i=n+r.count-1,e===n)break;if(e>n&&i>=e){o=!0;break}n=i+1}return new a(r,t,o,n)},_split:function(e,t,r){var n=this._operations[e],a=n.items.slice(t),s=new i(n.type,a.length,a);n.count=t,n.items=n.items.slice(0,t),this._operations.splice(e+1,0,r,s)},_composeInsert:function(e){var t=this._operations[e],r=this._operations[e-1],n=this._operations[e+1],i=r&&r.type,a=n&&n.type;i===l?(r.count+=t.count,r.items=r.items.concat(t.items),a===l?(r.count+=n.count,r.items=r.items.concat(n.items),this._operations.splice(e,2)):this._operations.splice(e,1)):a===l&&(t.count+=n.count,t.items=t.items.concat(n.items),this._operations.splice(e+1,1))},_composeDelete:function(e){var t,r,n,i=this._operations[e],a=i.count,s=this._operations[e-1],o=s&&s.type,u=!1,h=[];o===c&&(i=s,e-=1);for(var m=e+1;a>0;++m)t=this._operations[m],r=t.type,n=t.count,r!==c?(n>a?(h=h.concat(t.items.splice(0,a)),t.count-=a,m-=1,n=a,a=0):(n===a&&(u=!0),h=h.concat(t.items),a-=n),r===l&&(i.count-=n)):i.count+=n;return i.count>0?this._operations.splice(e+1,m-1-e):this._operations.splice(e,u?2:1),h},toString:function(){var e="";return o(this._operations,function(t){e+=" "+t.type+":"+t.count}),e.substring(1)}}}),e("ember-template-compiler",["ember-metal/core","ember-template-compiler/system/precompile","ember-template-compiler/system/compile","ember-template-compiler/system/template","ember-template-compiler/plugins","ember-template-compiler/plugins/transform-each-in-to-hash","ember-template-compiler/plugins/transform-with-as-to-hash","ember-template-compiler/compat","exports"],function(e,t,r,n,i,a,s,o,u){"use strict";var l=e["default"],c=t["default"],h=r["default"],m=n["default"],p=i.registerPlugin,f=a["default"],d=s["default"];p("ast",d),p("ast",f),u._Ember=l,u.precompile=c,u.compile=h,u.template=m,u.registerPlugin=p}),e("ember-template-compiler/compat",["ember-metal/core","ember-template-compiler/compat/precompile","ember-template-compiler/system/compile","ember-template-compiler/system/template"],function(e,t,r,n){"use strict";var i=e["default"],a=t["default"],s=r["default"],o=n["default"],u=i.Handlebars=i.Handlebars||{};u.precompile=a,u.compile=s,u.template=o}),e("ember-template-compiler/compat/precompile",["exports"],function(e){"use strict";var r,n;e["default"]=function(e){if((!r||!n)&&i.__loader.registry["htmlbars-compiler/compiler"]){var a=t("htmlbars-compiler/compiler");r=a.compile,n=a.compileSpec}if(!r||!n)throw new Error("Cannot call `precompile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `precompile`.");var s=void 0===arguments[1]?!0:arguments[1],o=s?r:n;
-return o(e)}}),e("ember-template-compiler/plugins",["exports"],function(e){"use strict";function t(e,t){if(!r[e])throw new Error('Attempting to register "'+t+'" as "'+e+'" which is not a valid HTMLBars plugin type.');r[e].push(t)}var r={ast:[]};e.registerPlugin=t,e["default"]=r}),e("ember-template-compiler/plugins/transform-each-in-to-hash",["exports"],function(e){"use strict";function t(){this.syntax=null}t.prototype.transform=function(e){var t=this,r=new t.syntax.Walker,n=t.syntax.builders;return r.visit(e,function(e){if(t.validate(e)){if(e.program&&e.program.blockParams.length)throw new Error("You cannot use keyword (`{{each foo in bar}}`) and block params (`{{each bar as |foo|}}`) at the same time.");var r=e.sexpr.params.splice(0,2),i=r[0].original;e.sexpr.hash||(e.sexpr.hash=n.hash()),e.sexpr.hash.pairs.push(n.pair("keyword",n.string(i)))}}),e},t.prototype.validate=function(e){return("BlockStatement"===e.type||"MustacheStatement"===e.type)&&"each"===e.sexpr.path.original&&3===e.sexpr.params.length&&"PathExpression"===e.sexpr.params[1].type&&"in"===e.sexpr.params[1].original},e["default"]=t}),e("ember-template-compiler/plugins/transform-with-as-to-hash",["exports"],function(e){"use strict";function t(){this.syntax=null}t.prototype.transform=function(e){var t=this,r=new t.syntax.Walker;return r.visit(e,function(e){if(t.validate(e)){if(e.program&&e.program.blockParams.length)throw new Error("You cannot use keyword (`{{with foo as bar}}`) and block params (`{{with foo as |bar|}}`) at the same time.");var r=e.sexpr.params.splice(1,2),n=r[1].original;e.program.blockParams=[n]}}),e},t.prototype.validate=function(e){return"BlockStatement"===e.type&&"with"===e.sexpr.path.original&&3===e.sexpr.params.length&&"PathExpression"===e.sexpr.params[1].type&&"as"===e.sexpr.params[1].original},e["default"]=t}),e("ember-template-compiler/system/compile",["ember-template-compiler/system/compile_options","ember-template-compiler/system/template","exports"],function(e,r,n){"use strict";var a,s=e["default"],o=r["default"];n["default"]=function(e){if(!a&&i.__loader.registry["htmlbars-compiler/compiler"]&&(a=t("htmlbars-compiler/compiler").compile),!a)throw new Error("Cannot call `compile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compile`.");var r=a(e,s());return o(r)}}),e("ember-template-compiler/system/compile_options",["ember-metal/core","ember-template-compiler/plugins","exports"],function(e,t,r){"use strict";var n=(e["default"],t["default"]);r["default"]=function(){var e=!0;return{disableComponentGeneration:e,plugins:n}}}),e("ember-template-compiler/system/precompile",["ember-template-compiler/system/compile_options","exports"],function(e,r){"use strict";var n,a=e["default"];r["default"]=function(e){if(!n&&i.__loader.registry["htmlbars-compiler/compiler"]&&(n=t("htmlbars-compiler/compiler").compileSpec),!n)throw new Error("Cannot call `compileSpec` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compileSpec`.");return n(e,a())}}),e("ember-template-compiler/system/template",["exports"],function(e){"use strict";e["default"]=function(e){return e.isTop=!0,e.isMethod=!1,e}}),e("ember-views",["ember-runtime","ember-views/system/jquery","ember-views/system/utils","ember-views/system/render_buffer","ember-views/system/ext","ember-views/views/states","ember-views/views/core_view","ember-views/views/view","ember-views/views/container_view","ember-views/views/collection_view","ember-views/views/component","ember-views/system/event_dispatcher","ember-views/mixins/view_target_action_support","ember-views/component_lookup","ember-views/views/checkbox","ember-views/mixins/text_support","ember-views/views/text_field","ember-views/views/text_area","ember-views/views/bound_view","ember-views/views/simple_bound_view","ember-views/views/metamorph_view","ember-views/views/select","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m,p,f,d,v,b,g,y,_,w,x){"use strict";var C=e["default"],E=t["default"],O=r.isSimpleClick,P=r.getViewClientRects,A=r.getViewBoundingClientRect,N=n["default"],S=a.cloneStates,T=a.states,k=s["default"],V=o["default"],I=u["default"],j=l["default"],M=c["default"],R=h["default"],D=m["default"],L=p["default"],F=f["default"],B=d["default"],H=v["default"],z=b["default"],q=g["default"],U=y["default"],W=_["default"],K=_._SimpleMetamorphView,G=_._Metamorph,Q=w.Select,$=w.SelectOption,Y=w.SelectOptgroup;C.$=E,C.ViewTargetActionSupport=D,C.RenderBuffer=N;var X=C.ViewUtils={};X.isSimpleClick=O,X.getViewClientRects=P,X.getViewBoundingClientRect=A,C.CoreView=k,C.View=V,C.View.states=T,C.View.cloneStates=S,C.Checkbox=F,C.TextField=H,C.TextArea=z,C._SimpleBoundView=U,C._BoundView=q,C._SimpleMetamorphView=K,C._MetamorphView=W,C._Metamorph=G,C.Select=Q,C.SelectOption=$,C.SelectOptgroup=Y,C.TextSupport=B,C.ComponentLookup=L,C.ContainerView=I,C.CollectionView=j,C.Component=M,C.EventDispatcher=R,x["default"]=C}),e("ember-views/attr_nodes/attr_node",["ember-metal/streams/utils","ember-metal/run_loop","exports"],function(e,t,r){"use strict";function n(e,t){this.init(e,t)}var i=e.read,a=e.subscribe,s=e.unsubscribe,o=t["default"];n.prototype.init=function(e,t){this.isView=!0,this.tagName="",this.classNameBindings=[],this.attrName=e,this.attrValue=t,this.isDirty=!0,this.lastValue=null,a(this.attrValue,this.rerender,this)},n.prototype.renderIfDirty=function(){if(this.isDirty){var e=i(this.attrValue);e!==this.lastValue?this._renderer.renderTree(this,this._parentView):this.isDirty=!1}},n.prototype.render=function(){this.isDirty=!1;var e=i(this.attrValue);this._morph.setContent(e),this.lastValue=e},n.prototype.rerender=function(){this.isDirty=!0,o.schedule("render",this,this.renderIfDirty)},n.prototype.destroy=function(){this.isDirty=!1,s(this.attrValue,this.rerender,this);var e=this._parentView;e&&e.removeChild(this)},r["default"]=n}),e("ember-views/attr_nodes/legacy_bind",["./attr_node","ember-runtime/system/string","ember-metal/utils","ember-metal/streams/utils","ember-metal/platform/create","exports"],function(e,t,r,n,i,a){"use strict";function s(e,t){this.init(e,t)}var o=e["default"],u=(t.fmt,r.typeOf),l=n.read,c=i["default"];s.prototype=c(o.prototype),s.prototype.render=function(){this.isDirty=!1;{var e=l(this.attrValue);u(e)}void 0===e&&(e=null),"value"===this.attrName&&null===e&&(e=""),this._morph.setContent(e),this.lastValue=e},a["default"]=s}),e("ember-views/component_lookup",["ember-runtime/system/object","exports"],function(e,t){"use strict";var r=e["default"];t["default"]=r.extend({lookupFactory:function(e,t){t=t||this.container;var r="component:"+e,n="template:components/"+e,a=t&&t.has(n);a&&t.injection(r,"layout",n);var s=t.lookupFactory(r);return a||s?(s||(t.register(r,i.Component),s=t.lookupFactory(r)),s):void 0}})}),e("ember-views/mixins/component_template_deprecation",["ember-metal/core","ember-metal/property_get","ember-metal/mixin","exports"],function(e,t,r,n){"use strict";var i=(e["default"],t.get),a=r.Mixin;n["default"]=a.create({willMergeMixin:function(e){this._super.apply(this,arguments);var t,r,n=e.layoutName||e.layout||i(this,"layoutName");e.templateName&&!n&&(t="templateName",r="layoutName",e.layoutName=e.templateName,delete e.templateName),e.template&&!n&&(t="template",r="layout",e.layout=e.template,delete e.template)}})}),e("ember-views/mixins/text_support",["ember-metal/property_get","ember-metal/property_set","ember-metal/mixin","ember-runtime/mixins/target_action_support","exports"],function(e,t,r,n,i){"use strict";function a(e,t,r){var n=s(t,e),i=s(t,"onEvent"),a=s(t,"value");(i===e||"keyPress"===i&&"key-press"===e)&&t.sendAction("action",a),t.sendAction(e,a),(n||i===e)&&(s(t,"bubbles")||r.stopPropagation())}var s=e.get,o=t.set,u=r.Mixin,l=n["default"],c=u.create(l,{value:"",attributeBindings:["autocapitalize","autocorrect","autofocus","disabled","form","maxlength","placeholder","readonly","required","selectionDirection","spellcheck","tabindex","title"],placeholder:null,disabled:!1,maxlength:null,init:function(){this._super(),this.on("paste",this,this._elementValueDidChange),this.on("cut",this,this._elementValueDidChange),this.on("input",this,this._elementValueDidChange)},action:null,onEvent:"enter",bubbles:!1,interpretKeyEvents:function(e){var t=c.KEY_EVENTS,r=t[e.keyCode];return this._elementValueDidChange(),r?this[r](e):void 0},_elementValueDidChange:function(){o(this,"value",this.$().val())},change:function(e){this._elementValueDidChange(e)},insertNewline:function(e){a("enter",this,e),a("insert-newline",this,e)},cancel:function(e){a("escape-press",this,e)},focusIn:function(e){a("focus-in",this,e)},focusOut:function(e){this._elementValueDidChange(e),a("focus-out",this,e)},keyPress:function(e){a("key-press",this,e)},keyUp:function(e){this.interpretKeyEvents(e),this.sendAction("key-up",s(this,"value"),e)},keyDown:function(e){this.sendAction("key-down",s(this,"value"),e)}});c.KEY_EVENTS={13:"insertNewline",27:"cancel"},i["default"]=c}),e("ember-views/mixins/view_target_action_support",["ember-metal/mixin","ember-runtime/mixins/target_action_support","ember-metal/alias","exports"],function(e,t,r,n){"use strict";var i=e.Mixin,a=t["default"],s=r["default"];n["default"]=i.create(a,{target:s("controller"),actionContext:s("context")})}),e("ember-views/streams/class_name_binding",["ember-metal/streams/utils","ember-metal/property_get","ember-runtime/system/string","ember-metal/utils","exports"],function(e,t,r,n,i){"use strict";function a(e){var t,r,n=e.split(":"),i=n[0],a="";return n.length>1&&(t=n[1],3===n.length&&(r=n[2]),a=":"+t,r&&(a+=":"+r)),{path:i,classNames:a,className:""===t?void 0:t,falsyClassName:r}}function s(e,t,r,n){if(m(t)&&(t=0!==c(t,"length")),r||n)return r&&t?r:n&&!t?n:null;if(t===!0){var i=e.split(".");return h(i[i.length-1])}return t!==!1&&null!=t?t:null}function o(e,t,r){r=r||"";var n=a(t);if(""===n.path)return s(n.path,!0,n.className,n.falsyClassName);var i=e.getStream(r+n.path);return u(i,function(){return s(n.path,l(i),n.className,n.falsyClassName)})}var u=e.chain,l=e.read,c=t.get,h=r.dasherize,m=n.isArray;i.parsePropertyPath=a,i.classStringForValue=s,i.streamifyClassNameBinding=o}),e("ember-views/streams/conditional_stream",["ember-metal/streams/stream","ember-metal/streams/utils","ember-metal/platform","exports"],function(e,t,r,n){"use strict";function i(e,t,r){this.init(),this.oldTestResult=void 0,this.test=e,this.consequent=t,this.alternate=r}var a=e["default"],s=t.read,o=t.subscribe,u=t.unsubscribe,l=r.create;i.prototype=l(a.prototype),i.prototype.valueFn=function(){var e=this.oldTestResult,t=!!s(this.test);if(t!==e){switch(e){case!0:u(this.consequent,this.notify,this);break;case!1:u(this.alternate,this.notify,this);break;case void 0:o(this.test,this.notify,this)}switch(t){case!0:o(this.consequent,this.notify,this);break;case!1:o(this.alternate,this.notify,this)}this.oldTestResult=t}return s(t?this.consequent:this.alternate)},n["default"]=i}),e("ember-views/streams/context_stream",["ember-metal/core","ember-metal/merge","ember-metal/platform","ember-metal/path_cache","ember-metal/streams/stream","ember-metal/streams/simple","exports"],function(e,t,r,n,i,a,s){"use strict";function o(e){this.init(),this.view=e}var u=e["default"],l=t["default"],c=r.create,h=n.isGlobal,m=i["default"],p=a["default"];o.prototype=c(m.prototype),l(o.prototype,{value:function(){},_makeChildStream:function(e){var t;return""===e||"this"===e?t=this.view._baseContext:h(e)&&u.lookup[e]?(t=new p(u.lookup[e]),t._isGlobal=!0):t=new p(e in this.view._keywords?this.view._keywords[e]:this.view._baseContext.get(e)),t._isRoot=!0,"controller"===e&&(t._isController=!0),t}}),s["default"]=o}),e("ember-views/streams/key_stream",["ember-metal/core","ember-metal/merge","ember-metal/platform","ember-metal/property_get","ember-metal/property_set","ember-metal/observer","ember-metal/streams/stream","ember-metal/streams/utils","exports"],function(e,t,r,n,i,a,s,o,u){"use strict";function l(e,t){this.init(),this.source=e,this.obj=void 0,this.key=t,g(e)&&e.subscribe(this._didChange,this)}var c=(e["default"],t["default"]),h=r.create,m=n.get,p=i.set,f=a.addObserver,d=a.removeObserver,v=s["default"],b=o.read,g=o.isStream;l.prototype=h(v.prototype),c(l.prototype,{valueFn:function(){var e=this.obj,t=b(this.source);return t!==e&&(e&&"object"==typeof e&&d(e,this.key,this,this._didChange),t&&"object"==typeof t&&f(t,this.key,this,this._didChange),this.obj=t),t?m(t,this.key):void 0},setValue:function(e){this.obj&&p(this.obj,this.key,e)},setSource:function(e){var t=this.source;e!==t&&(g(t)&&t.unsubscribe(this._didChange,this),g(e)&&e.subscribe(this._didChange,this),this.source=e,this.notify())},_didChange:function(){this.notify()},_super$destroy:v.prototype.destroy,destroy:function(){return this._super$destroy()?(g(this.source)&&this.source.unsubscribe(this._didChange,this),this.obj&&"object"==typeof this.obj&&d(this.obj,this.key,this,this._didChange),this.source=void 0,this.obj=void 0,!0):void 0}}),u["default"]=l,v.prototype._makeChildStream=function(e){return new l(this,e)}}),e("ember-views/streams/utils",["ember-metal/core","ember-metal/property_get","ember-metal/path_cache","ember-runtime/system/string","ember-metal/streams/utils","ember-views/views/view","ember-runtime/mixins/controller","exports"],function(e,t,r,n,i,a,s,o){"use strict";function u(e,t){var r,n=m(e);return r="string"==typeof n?h(n)?c(null,n):t.lookupFactory("view:"+n):n}function l(e){if(p(e)){var t=e.value();if(!e._isController)for(;f.detect(t);)t=c(t,"model");return t}return e}var c=(e["default"],t.get),h=r.isGlobal,m=(n.fmt,i.read),p=i.isStream,f=(a["default"],s["default"]);o.readViewFactory=u,o.readUnwrappedModel=l}),e("ember-views/system/action_manager",["exports"],function(e){"use strict";function t(){}t.registeredActions={},e["default"]=t}),e("ember-views/system/event_dispatcher",["ember-metal/core","ember-metal/property_get","ember-metal/property_set","ember-metal/is_none","ember-metal/run_loop","ember-metal/utils","ember-runtime/system/string","ember-runtime/system/object","ember-views/system/jquery","ember-views/system/action_manager","ember-views/views/view","ember-metal/merge","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m){"use strict";var p=(e["default"],t.get),f=r.set,d=n["default"],v=i["default"],b=a.typeOf,g=(s.fmt,o["default"]),y=u["default"],_=l["default"],w=c["default"],x=h["default"];m["default"]=g.extend({events:{touchstart:"touchStart",touchmove:"touchMove",touchend:"touchEnd",touchcancel:"touchCancel",keydown:"keyDown",keyup:"keyUp",keypress:"keyPress",mousedown:"mouseDown",mouseup:"mouseUp",contextmenu:"contextMenu",click:"click",dblclick:"doubleClick",mousemove:"mouseMove",focusin:"focusIn",focusout:"focusOut",mouseenter:"mouseEnter",mouseleave:"mouseLeave",submit:"submit",input:"input",change:"change",dragstart:"dragStart",drag:"drag",dragenter:"dragEnter",dragleave:"dragLeave",dragover:"dragOver",drop:"drop",dragend:"dragEnd"},rootElement:"body",canDispatchToEventManager:!0,setup:function(e,t){var r,n=p(this,"events");x(n,e||{}),d(t)||f(this,"rootElement",t),t=y(p(this,"rootElement")),t.addClass("ember-application");for(r in n)n.hasOwnProperty(r)&&this.setupHandler(t,r,n[r])},setupHandler:function(e,t,r){var n=this;e.on(t+".ember",".ember-view",function(e,t){var i=w.views[this.id],a=!0,s=n.canDispatchToEventManager?n._findNearestEventManager(i,r):null;return s&&s!==t?a=n._dispatchEvent(s,e,r,i):i&&(a=n._bubbleEvent(i,e,r)),a}),e.on(t+".ember","[data-ember-action]",function(e){var t=y(e.currentTarget).attr("data-ember-action"),n=_.registeredActions[t];return n&&n.eventName===r?n.handler(e):void 0})},_findNearestEventManager:function(e,t){for(var r=null;e&&(r=p(e,"eventManager"),!r||!r[t]);)e=p(e,"parentView");return r},_dispatchEvent:function(e,t,r,n){var i=!0,a=e[r];return"function"===b(a)?(i=v(e,a,t,n),t.stopPropagation()):i=this._bubbleEvent(n,t,r),i},_bubbleEvent:function(e,t,r){return v.join(e,e.handleEvent,r,t)},destroy:function(){var e=p(this,"rootElement");return y(e).off(".ember","**").removeClass("ember-application"),this._super()},toString:function(){return"(EventDispatcher)"}})}),e("ember-views/system/ext",["ember-metal/run_loop"],function(e){"use strict";var t=e["default"];t._addQueue("render","actions"),t._addQueue("afterRender","render")}),e("ember-views/system/jquery",["ember-metal/core","ember-metal/enumerable_utils","exports"],function(e,t,n){"use strict";var i=e["default"],a=t.forEach,s=i.imports&&i.imports.jQuery||this&&this.jQuery;if(s||"function"!=typeof r||(s=r("jquery")),s){var o=["dragstart","drag","dragenter","dragleave","dragover","drop","dragend"];a(o,function(e){s.event.fixHooks[e]={props:["dataTransfer"]}})}n["default"]=s}),e("ember-views/system/render_buffer",["ember-views/system/jquery","morph","ember-metal/core","ember-metal/platform","morph/dom-helper/prop","exports"],function(e,t,r,n,i,a){"use strict";function s(e,t){if("TABLE"===t.tagName){var r=v.exec(e);if(r)return d[r[1].toLowerCase()]}}function o(){this.seen=p(null),this.list=[]}function u(e){return e&&b.test(e)?e.replace(g,""):e}function l(e){var t={"<":"<",">":">",'"':""","'":"'","`":"`"},r=function(e){return t[e]||"&"},n=e.toString();return _.test(n)?n.replace(y,r):n}function c(e,t){this.tagName=e,this._outerContextualElement=t,this.buffer=null,this.childViews=[],this.dom=new m}var h=e["default"],m=t.DOMHelper,p=(r["default"],n.create),f=i.normalizeProperty,d={tr:document.createElement("tbody"),col:document.createElement("colgroup")},v=/(?:"'`]/g,_=/[&<>"'`]/,w=function(){var e=document.createElement("div"),t=document.createElement("input");return t.setAttribute("name","foo"),e.appendChild(t),!!e.innerHTML.match("foo")}();a["default"]=function(e,t){return new c(e,t)},c.prototype={reset:function(e,t){this.tagName=e,this.buffer=null,this._element=null,this._outerContextualElement=t,this.elementClasses=null,this.elementId=null,this.elementAttributes=null,this.elementProperties=null,this.elementTag=null,this.elementStyle=null,this.childViews.length=0},_element:null,_outerContextualElement:null,elementClasses:null,classes:null,elementId:null,elementAttributes:null,elementProperties:null,elementTag:null,elementStyle:null,pushChildView:function(e){var t=this.childViews.length;this.childViews[t]=e,this.push("")},hydrateMorphs:function(e){for(var t=this.childViews,r=this._element,n=0,i=t.length;i>n;n++){var a=t[n],s=r.querySelector("#morph-"+n),o=s.parentNode;a._morph=this.dom.insertMorphBefore(o,s,1===o.nodeType?o:e),o.removeChild(s)}},push:function(e){return"string"==typeof e?(null===this.buffer&&(this.buffer=""),this.buffer+=e):this.buffer=e,this},addClass:function(e){return this.elementClasses=this.elementClasses||new o,this.elementClasses.add(e),this.classes=this.elementClasses.list,this},setClasses:function(e){this.elementClasses=null;var t,r=e.length;for(t=0;r>t;t++)this.addClass(e[t])},id:function(e){return this.elementId=e,this},attr:function(e,t){var r=this.elementAttributes=this.elementAttributes||{};return 1===arguments.length?r[e]:(r[e]=t,this)},removeAttr:function(e){var t=this.elementAttributes;return t&&delete t[e],this},prop:function(e,t){var r=this.elementProperties=this.elementProperties||{};return 1===arguments.length?r[e]:(r[e]=t,this)},removeProp:function(e){var t=this.elementProperties;return t&&delete t[e],this},style:function(e,t){return this.elementStyle=this.elementStyle||{},this.elementStyle[e]=t,this},generateElement:function(){var e,t,r,n=this.tagName,i=this.elementId,a=this.classes,s=this.elementAttributes,o=this.elementProperties,c=this.elementStyle,h="";r=s&&s.name&&!w?"<"+u(n)+' name="'+l(s.name)+'">':n;var m=this.dom.createElement(r,this.outerContextualElement());if(i&&(this.dom.setAttribute(m,"id",i),this.elementId=null),a&&(this.dom.setAttribute(m,"class",a.join(" ")),this.classes=null,this.elementClasses=null),c){for(t in c)h+=t+":"+c[t]+";";this.dom.setAttribute(m,"style",h),this.elementStyle=null}if(s){for(e in s)this.dom.setAttribute(m,e,s[e]);this.elementAttributes=null}if(o){for(t in o){var p=f(m,t.toLowerCase())||t;this.dom.setPropertyStrict(m,p,o[t])}this.elementProperties=null}this._element=m},element:function(){var e=this.innerContent();if(null===e)return this._element;var t=this.innerContextualElement(e);if(this.dom.detectNamespace(t),this._element||(this._element=document.createDocumentFragment()),e.nodeType)this._element.appendChild(e);else{var r;for(r=this.dom.parseHTML(e,t);r[0];)this._element.appendChild(r[0])}return this.childViews.length>0&&this.hydrateMorphs(t),this._element},string:function(){if(this._element){var e=this.element(),t=e.outerHTML;return"undefined"==typeof t?h("").append(e).html():t}return this.innerString()},outerContextualElement:function(){return this._outerContextualElement||(this.outerContextualElement=document.body),this._outerContextualElement},innerContextualElement:function(e){var t;t=this._element&&1===this._element.nodeType?this._element:this.outerContextualElement();var r;return e&&(r=s(e,t)),r||t},innerString:function(){var e=this.innerContent();return e&&!e.nodeType?e:void 0},innerContent:function(){return this.buffer}}}),e("ember-views/system/renderer",["ember-metal/core","ember-metal-views/renderer","ember-metal/platform","ember-views/system/render_buffer","ember-metal/run_loop","ember-metal/property_set","ember-metal/property_get","ember-metal/instrumentation","exports"],function(e,t,r,n,i,a,s,o,u){"use strict";function l(){this.buffer=m(),this._super$constructor()}var c=(e["default"],t["default"]),h=r.create,m=n["default"],p=i["default"],f=a.set,d=s.get,v=o._instrumentStart,b=o.subscribers;l.prototype=h(c.prototype),l.prototype.constructor=l,l.prototype._super$constructor=c,l.prototype.scheduleRender=function(e,t){return p.scheduleOnce("render",e,t)},l.prototype.cancelRender=function(e){p.cancel(e)},l.prototype.createElement=function(e,t){var r=e.tagName;void 0===r&&(r=d(e,"tagName"));{var n=e.classNameBindings;""===r&&n&&n.length>0}(null===r||void 0===r)&&(r="div");var i=e.buffer=this.buffer;i.reset(r,t),e.beforeRender&&e.beforeRender(i),""!==r&&(e.applyAttributesToBuffer&&e.applyAttributesToBuffer(i),i.generateElement()),e.render&&e.render(i),e.afterRender&&e.afterRender(i);var a=i.element();return e.buffer=null,a&&1===a.nodeType&&(e.element=a),a},l.prototype.destroyView=function(e){e.removedFromDOM=!0,e.destroy()},l.prototype.childViews=function(e){return e._childViews},c.prototype.willCreateElement=function(e){b.length&&e.instrumentDetails&&(e._instrumentEnd=v("render."+e.instrumentName,function(){var t={};return e.instrumentDetails(t),t})),e._transitionTo&&e._transitionTo("inBuffer")},c.prototype.didCreateElement=function(e){e._transitionTo&&e._transitionTo("hasElement"),e._instrumentEnd&&e._instrumentEnd()},c.prototype.willInsertElement=function(e){e.trigger&&e.trigger("willInsertElement")},c.prototype.didInsertElement=function(e){e._transitionTo&&e._transitionTo("inDOM"),e.trigger&&e.trigger("didInsertElement")},c.prototype.willRemoveElement=function(){},c.prototype.willDestroyElement=function(e){e.trigger&&e.trigger("willDestroyElement"),e.trigger&&e.trigger("willClearRender")},c.prototype.didDestroyElement=function(e){f(e,"element",null),e._transitionTo&&e._transitionTo("preRender")},u["default"]=l}),e("ember-views/system/sanitize_attribute_value",["exports"],function(e){"use strict";var t,r={"javascript:":!0,"vbscript:":!0},n={A:!0,BODY:!0,LINK:!0,IMG:!0,IFRAME:!0},i={href:!0,src:!0,background:!0};e.badAttributes=i,e["default"]=function(e,a,s){var o;return t||(t=document.createElement("a")),o=e?e.tagName:null,s&&s.toHTML?s.toHTML():(null===o||n[o])&&i[a]&&(t.href=s,r[t.protocol]===!0)?"unsafe:"+s:s}}),e("ember-views/system/utils",["exports"],function(e){"use strict";function t(e){var t=e.shiftKey||e.metaKey||e.altKey||e.ctrlKey,r=e.which>1;return!t&&!r}function r(e){var t=document.createRange();return t.setStartAfter(e._morph.start),t.setEndBefore(e._morph.end),t}function n(e){var t=r(e);return t.getClientRects()}function i(e){var t=r(e);return t.getBoundingClientRect()}e.isSimpleClick=t,e.getViewClientRects=n,e.getViewBoundingClientRect=i}),e("ember-views/views/bound_view",["ember-metal/property_get","ember-metal/property_set","ember-metal/merge","ember-htmlbars/utils/string","ember-views/views/states","ember-views/views/metamorph_view","exports"],function(e,t,r,n,i,a,s){"use strict";function o(){return this}var u=e.get,l=t.set,c=r["default"],h=n.escapeExpression,m=n.SafeString,p=i.cloneStates,f=i.states,d=a["default"],v=p(f);c(v._default,{rerenderIfNeeded:o}),c(v.inDOM,{rerenderIfNeeded:function(e){e.normalizedValue()!==e._lastNormalizedValue&&e.rerender()}});var b=d.extend({instrumentName:"bound",_states:v,shouldDisplayFunc:null,preserveContext:!1,previousContext:null,displayTemplate:null,inverseTemplate:null,lazyValue:null,normalizedValue:function(){var e=this.lazyValue.value(),t=u(this,"valueNormalizerFunc");return t?t(e):e},rerenderIfNeeded:function(){this.currentState.rerenderIfNeeded(this)},render:function(e){var t=u(this,"isEscaped"),r=u(this,"shouldDisplayFunc"),n=u(this,"preserveContext"),i=u(this,"previousContext"),a=u(this,"inverseTemplate"),s=u(this,"displayTemplate"),o=this.normalizedValue();if(this._lastNormalizedValue=o,r(o))if(l(this,"template",s),n)l(this,"_context",i);else{if(!s)return null===o||void 0===o?o="":o instanceof m||(o=String(o)),t&&(o=h(o)),void e.push(o);l(this,"_context",o)}else a?(l(this,"template",a),n?l(this,"_context",i):l(this,"_context",o)):l(this,"template",function(){return""});return this._super(e)}});s["default"]=b}),e("ember-views/views/checkbox",["ember-metal/property_get","ember-metal/property_set","ember-views/views/view","exports"],function(e,t,r,n){"use strict";var i=e.get,a=t.set,s=r["default"];n["default"]=s.extend({instrumentDisplay:'{{input type="checkbox"}}',classNames:["ember-checkbox"],tagName:"input",attributeBindings:["type","checked","indeterminate","disabled","tabindex","name","autofocus","required","form"],type:"checkbox",checked:!1,disabled:!1,indeterminate:!1,init:function(){this._super(),this.on("change",this,this._updateElementValue)},didInsertElement:function(){this._super(),i(this,"element").indeterminate=!!i(this,"indeterminate")},_updateElementValue:function(){a(this,"checked",this.$().prop("checked"))}})}),e("ember-views/views/collection_view",["ember-metal/core","ember-metal/binding","ember-metal/property_get","ember-metal/property_set","ember-runtime/system/string","ember-views/views/container_view","ember-views/views/core_view","ember-views/views/view","ember-metal/mixin","ember-views/streams/utils","ember-runtime/mixins/array","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h){"use strict";var m=(e["default"],t.isGlobalPath),p=r.get,f=n.set,d=(i.fmt,a["default"]),v=s["default"],b=o["default"],g=u.observer,y=u.beforeObserver,_=l.readViewFactory,w=(c["default"],d.extend({content:null,emptyViewClass:b,emptyView:null,itemViewClass:b,init:function(){var e=this._super();return this._contentDidChange(),e},_contentWillChange:y("content",function(){var e=this.get("content");e&&e.removeArrayObserver(this);var t=e?p(e,"length"):0;this.arrayWillChange(e,0,t)}),_contentDidChange:g("content",function(){var e=p(this,"content");e&&(this._assertArrayLike(e),e.addArrayObserver(this));var t=e?p(e,"length"):0;this.arrayDidChange(e,0,null,t)}),_assertArrayLike:function(){},destroy:function(){if(this._super()){var e=p(this,"content");return e&&e.removeArrayObserver(this),this._createdEmptyView&&this._createdEmptyView.destroy(),this}},arrayWillChange:function(e,t,r){var n=p(this,"emptyView");n&&n instanceof b&&n.removeFromParent();var i,a,s=this._childViews;for(a=t+r-1;a>=t;a--)i=s[a],i.destroy()},arrayDidChange:function(e,t,r,n){var i,a,s,o,u,l,c,h=[];if(o=e?p(e,"length"):0)for(c=this._itemViewProps||{},u=p(this,"itemViewClass"),u=_(u,this.container),s=t;t+n>s;s++)a=e.objectAt(s),c.content=a,c._blockArguments=[a],c.contentIndex=s,i=this.createChildView(u,c),h.push(i);else{if(l=p(this,"emptyView"),!l)return;"string"==typeof l&&m(l)&&(l=p(l)||l),l=this.createChildView(l),h.push(l),f(this,"emptyView",l),v.detect(l)&&(this._createdEmptyView=l)}this.replace(t,0,h)},createChildView:function(e,t){e=this._super(e,t);var r=p(e,"tagName");return(null===r||void 0===r)&&(r=w.CONTAINER_MAP[p(this,"tagName")],f(e,"tagName",r)),e}}));w.CONTAINER_MAP={ul:"li",ol:"li",table:"tr",thead:"tr",tbody:"tr",tfoot:"tr",tr:"td",select:"option"},h["default"]=w}),e("ember-views/views/component",["ember-metal/core","ember-views/mixins/component_template_deprecation","ember-runtime/mixins/target_action_support","ember-views/views/view","ember-metal/property_get","ember-metal/property_set","ember-metal/is_none","ember-metal/computed","ember-htmlbars/templates/component","exports"],function(e,t,r,n,i,a,s,o,u,l){"use strict";var c=e["default"],h=t["default"],m=r["default"],p=n["default"],f=i.get,d=a.set,v=(s["default"],o.computed),b=u["default"],g=Array.prototype.slice,y=p.extend(m,h,{controller:null,context:null,instrumentName:"component",instrumentDisplay:v(function(){return this._debugContainerKey?"{{"+this._debugContainerKey.split(":")[1]+"}}":void 0}),init:function(){this._super(),this._keywords.view=this,d(this,"context",this),d(this,"controller",this)},defaultLayout:b,template:v(function(e,t){if(void 0!==t)return t;var r=f(this,"templateName"),n=this.templateForName(r,"template");return n||f(this,"defaultTemplate")}).property("templateName"),templateName:null,_setupKeywords:function(){},_yield:function(e,t,r,n){var i=t.data.view,a=this._parentView,s=f(this,"template");s&&i.appendChild(p,{isVirtual:!0,tagName:"",template:s,_blockArguments:n,_contextView:a,_morph:r,context:f(a,"context"),controller:f(a,"controller")})},targetObject:v(function(){var e=f(this,"_parentView");return e?f(e,"controller"):null}).property("_parentView"),sendAction:function(e){var t,r=g.call(arguments,1);t=void 0===e?f(this,"action"):f(this,e),void 0!==t&&this.triggerAction({action:t,actionContext:r})},send:function(e){var t,r=[].slice.call(arguments,1),n=this._actions&&this._actions[e];if(!n||this._actions[e].apply(this,r)===!0)if(t=f(this,"target"))t.send.apply(t,arguments);else if(!n)throw new Error(c.inspect(this)+" had no action handler for: "+e)}});l["default"]=y}),e("ember-views/views/container_view",["ember-metal/core","ember-metal/merge","ember-runtime/mixins/mutable_array","ember-metal/property_get","ember-metal/property_set","ember-views/views/view","ember-views/views/states","ember-metal/error","ember-metal/enumerable_utils","ember-metal/computed","ember-metal/run_loop","ember-metal/properties","ember-metal/mixin","ember-runtime/system/native_array","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m,p,f){"use strict";function d(){return this}var v=(e["default"],t["default"]),b=r["default"],g=n.get,y=i.set,_=a["default"],w=s.cloneStates,x=s.states,C=o["default"],E=u.forEach,O=l.computed,P=c["default"],A=h.defineProperty,N=m.observer,S=m.beforeObserver,T=(p.A,w(x)),k=_.extend(b,{_states:T,willWatchProperty:function(){},init:function(){this._super();var e=g(this,"childViews");A(this,"childViews",_.childViewsProperty);var t=this._childViews;E(e,function(e,r){var n;"string"==typeof e?(n=g(this,e),n=this.createChildView(n),y(this,e,n)):n=this.createChildView(e),t[r]=n},this);var r=g(this,"currentView");r&&(t.length||(t=this._childViews=this._childViews.slice()),t.push(this.createChildView(r)))},replace:function(e,t,r){var n=r?g(r,"length"):0;if(this.arrayContentWillChange(e,t,n),this.childViewsWillChange(this._childViews,e,t),0===n)this._childViews.splice(e,t);else{var i=[e,t].concat(r);r.length&&!this._childViews.length&&(this._childViews=this._childViews.slice()),this._childViews.splice.apply(this._childViews,i)
-}return this.arrayContentDidChange(e,t,n),this.childViewsDidChange(this._childViews,e,t,n),this},objectAt:function(e){return this._childViews[e]},length:O(function(){return this._childViews.length})["volatile"](),render:function(e){var t=e.element(),r=e.dom;return""===this.tagName?(t=r.createDocumentFragment(),e._element=t,this._childViewsMorph=r.appendMorph(t,this._morph.contextualElement)):this._childViewsMorph=r.createMorph(t,t.lastChild,null),t},instrumentName:"container",childViewsWillChange:function(e,t,r){if(this.propertyWillChange("childViews"),r>0){var n=e.slice(t,t+r);this.currentState.childViewsWillChange(this,e,t,r),this.initializeViews(n,null,null)}},removeChild:function(e){return this.removeObject(e),this},childViewsDidChange:function(e,t,r,n){if(n>0){var i=e.slice(t,t+n);this.initializeViews(i,this),this.currentState.childViewsDidChange(this,e,t,n)}this.propertyDidChange("childViews")},initializeViews:function(e,t){E(e,function(e){y(e,"_parentView",t),!e.container&&t&&y(e,"container",t.container)})},currentView:null,_currentViewWillChange:S("currentView",function(){var e=g(this,"currentView");e&&e.destroy()}),_currentViewDidChange:N("currentView",function(){var e=g(this,"currentView");e&&this.pushObject(e)}),_ensureChildrenAreInDOM:function(){this.currentState.ensureChildrenAreInDOM(this)}});v(T._default,{childViewsWillChange:d,childViewsDidChange:d,ensureChildrenAreInDOM:d}),v(T.inBuffer,{childViewsDidChange:function(){throw new C("You cannot modify child views while in the inBuffer state")}}),v(T.hasElement,{childViewsWillChange:function(e,t,r,n){for(var i=r;r+n>i;i++){var a=t[i];a._unsubscribeFromStreamBindings(),a.remove()}},childViewsDidChange:function(e){P.scheduleOnce("render",e,"_ensureChildrenAreInDOM")},ensureChildrenAreInDOM:function(e){var t,r,n,i=e._childViews,a=e._renderer;for(t=0,r=i.length;r>t;t++)n=i[t],n._elementCreated||a.renderTree(n,e,t)}}),f["default"]=k}),e("ember-views/views/core_view",["ember-views/system/renderer","ember-views/views/states","ember-runtime/system/object","ember-runtime/mixins/evented","ember-runtime/mixins/action_handler","ember-metal/property_get","ember-metal/computed","ember-metal/utils","exports"],function(e,t,r,n,i,a,s,o,u){"use strict";function l(){return this}var c=e["default"],h=t.cloneStates,m=t.states,p=r["default"],f=n["default"],d=i["default"],v=a.get,b=s.computed,g=o.typeOf,y=p.extend(f,d,{isView:!0,isVirtual:!1,_states:h(m),init:function(){this._super(),this._state="preRender",this.currentState=this._states.preRender,this._isVisible=v(this,"isVisible")},parentView:b("_parentView",function(){var e=this._parentView;return e&&e.isVirtual?v(e,"parentView"):e}),_state:null,_parentView:null,concreteView:b("parentView",function(){return this.isVirtual?v(this,"parentView.concreteView"):this}),instrumentName:"core_view",instrumentDetails:function(e){e.object=this.toString(),e.containerKey=this._debugContainerKey,e.view=this},trigger:function(){this._super.apply(this,arguments);var e=arguments[0],t=this[e];if(t){for(var r=arguments.length,n=new Array(r-1),i=1;r>i;i++)n[i-1]=arguments[i];return t.apply(this,n)}},has:function(e){return"function"===g(this[e])||this._super(e)},destroy:function(){var e=this._parentView;if(this._super())return!this.removedFromDOM&&this._renderer&&this._renderer.remove(this,!0),e&&e.removeChild(this),this._transitionTo("destroying",!1),this},clearRenderedChildren:l,_transitionTo:l,destroyElement:l});y.reopenClass({renderer:new c}),u["default"]=y}),e("ember-views/views/each",["ember-metal/core","ember-runtime/system/string","ember-metal/property_get","ember-metal/property_set","ember-views/views/collection_view","ember-metal/binding","ember-runtime/mixins/controller","ember-runtime/controllers/array_controller","ember-runtime/mixins/array","ember-metal/observer","ember-views/views/metamorph_view","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h){"use strict";var m=(e["default"],t.fmt,r.get),p=n.set,f=i["default"],d=a.Binding,v=(s["default"],o["default"],u["default"],l.addObserver),b=l.removeObserver,g=l.addBeforeObserver,y=l.removeBeforeObserver,_=c["default"],w=c._Metamorph;h["default"]=f.extend(w,{init:function(){var e,t=m(this,"itemController");if(t){var r=m(this,"controller.container").lookupFactory("controller:array").create({_isVirtual:!0,parentController:m(this,"controller"),itemController:t,target:m(this,"controller"),_eachView:this});this.disableContentObservers(function(){p(this,"content",r),e=new d("content","_eachView.dataSource").oneWay(),e.connect(r)}),p(this,"_arrayController",r)}else this.disableContentObservers(function(){e=new d("content","dataSource").oneWay(),e.connect(this)});return this._super()},_assertArrayLike:function(){},disableContentObservers:function(e){y(this,"content",null,"_contentWillChange"),b(this,"content",null,"_contentDidChange"),e.call(this),g(this,"content",null,"_contentWillChange"),v(this,"content",null,"_contentDidChange")},itemViewClass:_,emptyViewClass:_,createChildView:function(e,t){e=this._super(e,t);var r=m(e,"content"),n=m(this,"keyword");return n&&(e._keywords[n]=r),r&&r.isController&&p(e,"controller",r),e},destroy:function(){if(this._super()){var e=m(this,"_arrayController");return e&&e.destroy(),this}}})}),e("ember-views/views/metamorph_view",["ember-metal/core","ember-views/views/core_view","ember-views/views/view","ember-metal/mixin","exports"],function(e,t,r,n,i){"use strict";var a=(e["default"],t["default"]),s=r["default"],o=n.Mixin,u=o.create({isVirtual:!0,tagName:"",instrumentName:"metamorph",init:function(){this._super()}});i._Metamorph=u,i["default"]=s.extend(u);var l=a.extend(u);i._SimpleMetamorphView=l}),e("ember-views/views/select",["ember-metal/enumerable_utils","ember-metal/property_get","ember-metal/property_set","ember-views/views/view","ember-views/views/collection_view","ember-metal/utils","ember-metal/is_none","ember-metal/computed","ember-runtime/system/native_array","ember-metal/mixin","ember-metal/properties","ember-metal/run_loop","ember-htmlbars/templates/select","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m,p){"use strict";var f=e.forEach,d=e.indexOf,v=e.indexesOf,b=e.replace,g=t.get,y=r.set,_=n["default"],w=i["default"],x=a.isArray,C=s["default"],E=o.computed,O=u.A,P=l.observer,A=c.defineProperty,N=h["default"],S=m["default"],T=S,k={isHTMLBars:!0,render:function(e){var t=e.getStream("view.label");return t.subscribe(e._wrapAsScheduled(function(){N.scheduleOnce("render",e,"rerender")})),t.value()}},V=_.extend({instrumentDisplay:"Ember.SelectOption",tagName:"option",attributeBindings:["value","selected"],defaultTemplate:k,init:function(){this.labelPathDidChange(),this.valuePathDidChange(),this._super()},selected:E(function(){var e=g(this,"content"),t=g(this,"parentView.selection");return g(this,"parentView.multiple")?t&&d(t,e.valueOf())>-1:e==t}).property("content","parentView.selection"),labelPathDidChange:P("parentView.optionLabelPath",function(){var e=g(this,"parentView.optionLabelPath");e&&A(this,"label",E(function(){return g(this,e)}).property(e))}),valuePathDidChange:P("parentView.optionValuePath",function(){var e=g(this,"parentView.optionValuePath");e&&A(this,"value",E(function(){return g(this,e)}).property(e))})}),I=w.extend({instrumentDisplay:"Ember.SelectOptgroup",tagName:"optgroup",attributeBindings:["label"],selectionBinding:"parentView.selection",multipleBinding:"parentView.multiple",optionLabelPathBinding:"parentView.optionLabelPath",optionValuePathBinding:"parentView.optionValuePath",itemViewClassBinding:"parentView.optionView"}),j=_.extend({instrumentDisplay:"Ember.Select",tagName:"select",classNames:["ember-select"],defaultTemplate:T,attributeBindings:["multiple","disabled","tabindex","name","required","autofocus","form","size"],multiple:!1,disabled:!1,required:!1,content:null,selection:null,value:E(function(e,t){if(2===arguments.length)return t;var r=g(this,"optionValuePath").replace(/^content\.?/,"");return r?g(this,"selection."+r):g(this,"selection")}).property("selection"),prompt:null,optionLabelPath:"content",optionValuePath:"content",optionGroupPath:null,groupView:I,groupedContent:E(function(){var e=g(this,"optionGroupPath"),t=O(),r=g(this,"content")||[];return f(r,function(r){var n=g(r,e);g(t,"lastObject.label")!==n&&t.pushObject({label:n,content:O()}),g(t,"lastObject.content").push(r)}),t}).property("optionGroupPath","content.@each"),optionView:V,_change:function(){g(this,"multiple")?this._changeMultiple():this._changeSingle()},selectionDidChange:P("selection.@each",function(){var e=g(this,"selection");if(g(this,"multiple")){if(!x(e))return void y(this,"selection",O([e]));this._selectionDidChangeMultiple()}else this._selectionDidChangeSingle()}),valueDidChange:P("value",function(){var e,t=g(this,"content"),r=g(this,"value"),n=g(this,"optionValuePath").replace(/^content\.?/,""),i=n?g(this,"selection."+n):g(this,"selection");r!==i&&(e=t?t.find(function(e){return r===(n?g(e,n):e)}):null,this.set("selection",e))}),_setDefaults:function(){var e=g(this,"selection"),t=g(this,"value");C(e)||this.selectionDidChange(),C(t)||this.valueDidChange(),C(e)&&this._change()},_changeSingle:function(){var e=this.$()[0].selectedIndex,t=g(this,"content"),r=g(this,"prompt");if(t&&g(t,"length")){if(r&&0===e)return void y(this,"selection",null);r&&(e-=1),y(this,"selection",t.objectAt(e))}},_changeMultiple:function(){var e=this.$("option:selected"),t=g(this,"prompt"),r=t?1:0,n=g(this,"content"),i=g(this,"selection");if(n&&e){var a=e.map(function(){return this.index-r}).toArray(),s=n.objectsAt(a);x(i)?b(i,0,g(i,"length"),s):y(this,"selection",s)}},_selectionDidChangeSingle:function(){var e=g(this,"content"),t=g(this,"selection"),r=this;t&&t.then?t.then(function(n){r.get("selection")===t&&r._setSelectionIndex(e,n)}):this._setSelectionIndex(e,t)},_setSelectionIndex:function(e,t){var r=g(this,"element");if(r){var n=e?d(e,t):-1,i=g(this,"prompt");i&&(n+=1),r&&(r.selectedIndex=n)}},_selectionDidChangeMultiple:function(){var e,t=g(this,"content"),r=g(this,"selection"),n=t?v(t,r):[-1],i=g(this,"prompt"),a=i?1:0,s=this.$("option");s&&s.each(function(){e=this.index>-1?this.index-a:-1,this.selected=d(n,e)>-1})},init:function(){this._super(),this.on("didInsertElement",this,this._setDefaults),this.on("change",this,this._change)}});p["default"]=j,p.Select=j,p.SelectOption=V,p.SelectOptgroup=I}),e("ember-views/views/simple_bound_view",["ember-metal/error","ember-metal/run_loop","ember-htmlbars/utils/string","ember-metal/utils","exports"],function(e,t,r,n,i){"use strict";function a(){return this}function s(e,t){this.lazyValue=e,this.isEscaped=t,this[m]=p(),this._lastNormalizedValue=void 0,this.state="preRender",this.updateId=null,this._parentView=null,this.buffer=null,this._morph=null}function o(e,t,r){var n=new s(r,t.escaped);n._morph=t,r.subscribe(e._wrapAsScheduled(function(){l.scheduleOnce("render",n,"rerender")})),e.appendChild(n)}var u=e["default"],l=t["default"],c=r.SafeString,h=r.htmlSafe,m=n.GUID_KEY,p=n.uuid,f=c,d=h;s.prototype={isVirtual:!0,isView:!0,tagName:"",destroy:function(){this.updateId&&(l.cancel(this.updateId),this.updateId=null),this._parentView&&this._parentView.removeChild(this),this.morph=null,this.state="destroyed"},propertyWillChange:a,propertyDidChange:a,normalizedValue:function(){var e=this.lazyValue.value();return null===e||void 0===e?e="":this.isEscaped||e instanceof f||(e=d(e)),e},render:function(e){var t=this.normalizedValue();this._lastNormalizedValue=t,e._element=t},rerender:function(){switch(this.state){case"preRender":case"destroyed":break;case"inBuffer":throw new u("Something you did tried to replace an {{expression}} before it was inserted into the DOM.");case"hasElement":case"inDOM":this.updateId=l.scheduleOnce("render",this,"update")}return this},update:function(){this.updateId=null;var e=this.normalizedValue();e!==this._lastNormalizedValue&&(this._lastNormalizedValue=e,this._morph.setContent(e))},_transitionTo:function(e){this.state=e}},i.appendSimpleBoundView=o,i["default"]=s}),e("ember-views/views/states",["ember-metal/platform","ember-metal/merge","ember-views/views/states/default","ember-views/views/states/pre_render","ember-views/views/states/in_buffer","ember-views/views/states/has_element","ember-views/views/states/in_dom","ember-views/views/states/destroying","exports"],function(e,t,r,n,i,a,s,o,u){"use strict";function l(e){var t={};t._default={},t.preRender=c(t._default),t.destroying=c(t._default),t.inBuffer=c(t._default),t.hasElement=c(t._default),t.inDOM=c(t.hasElement);for(var r in e)e.hasOwnProperty(r)&&h(t[r],e[r]);return t}var c=e.create,h=t["default"],m=r["default"],p=n["default"],f=i["default"],d=a["default"],v=s["default"],b=o["default"];u.cloneStates=l;var g={_default:m,preRender:p,inDOM:v,inBuffer:f,hasElement:d,destroying:b};u.states=g}),e("ember-views/views/states/default",["ember-metal/error","exports"],function(e,t){"use strict";function r(){return this}var n=e["default"];t["default"]={appendChild:function(){throw new n("You can't use appendChild outside of the rendering process")},$:function(){return void 0},getElement:function(){return null},handleEvent:function(){return!0},destroyElement:function(e){return e._renderer&&e._renderer.remove(e,!1),e},rerender:r,invokeObserver:r}}),e("ember-views/views/states/destroying",["ember-metal/merge","ember-metal/platform","ember-runtime/system/string","ember-views/views/states/default","ember-metal/error","exports"],function(e,t,r,n,i,a){"use strict";var s=e["default"],o=t.create,u=r.fmt,l=n["default"],c=i["default"],h="You can't call %@ on a view being destroyed",m=o(l);s(m,{appendChild:function(){throw new c(u(h,["appendChild"]))},rerender:function(){throw new c(u(h,["rerender"]))},destroyElement:function(){throw new c(u(h,["destroyElement"]))}}),a["default"]=m}),e("ember-views/views/states/has_element",["ember-views/views/states/default","ember-metal/run_loop","ember-metal/merge","ember-metal/platform","ember-views/system/jquery","ember-metal/error","ember-metal/property_get","exports"],function(e,t,r,n,i,a,s,o){"use strict";var u=e["default"],l=t["default"],c=r["default"],h=n.create,m=i["default"],p=a["default"],f=s.get,d=h(u);c(d,{$:function(e,t){var r=e.get("concreteView").element;return t?m(t,r):m(r)},getElement:function(e){var t=f(e,"parentView");return t&&(t=f(t,"element")),t?e.findElementInParentElement(t):m("#"+f(e,"elementId"))[0]},rerender:function(e){if(e._root._morph&&!e._elementInserted)throw new p("Something you did caused a view to re-render after it rendered but before it was inserted into the DOM.");l.scheduleOnce("render",function(){e.isDestroying||e._renderer.renderTree(e,e._parentView)})},destroyElement:function(e){return e._renderer.remove(e,!1),e},handleEvent:function(e,t,r){return e.has(t)?e.trigger(t,r):!0},invokeObserver:function(e,t){t.call(e)}}),o["default"]=d}),e("ember-views/views/states/in_buffer",["ember-views/views/states/default","ember-metal/error","ember-views/system/jquery","ember-metal/platform","ember-metal/merge","exports"],function(e,t,r,n,i,a){"use strict";var s=e["default"],o=t["default"],u=r["default"],l=n.create,c=i["default"],h=l(s);c(h,{$:function(e){return e.rerender(),u()},rerender:function(){throw new o("Something you did caused a view to re-render after it rendered but before it was inserted into the DOM.")},appendChild:function(e,t,r){var n=e.buffer,i=e._childViews;return t=e.createChildView(t,r),i.length||(i=e._childViews=i.slice()),i.push(t),t._morph||n.pushChildView(t),e.propertyDidChange("childViews"),t},invokeObserver:function(e,t){t.call(e)}}),a["default"]=h}),e("ember-views/views/states/in_dom",["ember-metal/core","ember-metal/platform","ember-metal/merge","ember-metal/error","ember-metal/observer","ember-views/views/states/has_element","exports"],function(e,r,n,i,a,s,o){"use strict";var u,l=(e["default"],r.create),c=n["default"],h=(i["default"],a.addBeforeObserver,s["default"]),m=l(h);c(m,{enter:function(e){u||(u=t("ember-views/views/view")["default"]),e.isVirtual||(u.views[e.elementId]=e)},exit:function(e){u||(u=t("ember-views/views/view")["default"]),this.isVirtual||delete u.views[e.elementId]}}),o["default"]=m}),e("ember-views/views/states/pre_render",["ember-views/views/states/default","ember-metal/platform","exports"],function(e,t,r){"use strict";var n=e["default"],i=t.create,a=i(n);r["default"]=a}),e("ember-views/views/text_area",["ember-metal/property_get","ember-views/views/component","ember-views/mixins/text_support","ember-metal/mixin","exports"],function(e,t,r,n,i){"use strict";var a=e.get,s=t["default"],o=r["default"],u=n.observer;i["default"]=s.extend(o,{instrumentDisplay:"{{textarea}}",classNames:["ember-text-area"],tagName:"textarea",attributeBindings:["rows","cols","name","selectionEnd","selectionStart","wrap","lang","dir"],rows:null,cols:null,_updateElementValue:u("value",function(){var e=a(this,"value"),t=this.$();t&&e!==t.val()&&t.val(e)}),init:function(){this._super(),this.on("didInsertElement",this,this._updateElementValue)}})}),e("ember-views/views/text_field",["ember-views/views/component","ember-views/mixins/text_support","exports"],function(e,t,r){"use strict";var n=e["default"],i=t["default"];r["default"]=n.extend(i,{instrumentDisplay:'{{input type="text"}}',classNames:["ember-text-field"],tagName:"input",attributeBindings:["accept","autocomplete","autosave","dir","formaction","formenctype","formmethod","formnovalidate","formtarget","height","inputmode","lang","list","max","min","multiple","name","pattern","size","step","type","value","width"],defaultLayout:null,value:"",type:"text",size:null,pattern:null,min:null,max:null})}),e("ember-views/views/view",["ember-metal/core","ember-metal/platform","ember-runtime/mixins/evented","ember-runtime/system/object","ember-metal/error","ember-metal/property_get","ember-metal/property_set","ember-metal/set_properties","ember-metal/run_loop","ember-metal/observer","ember-metal/properties","ember-metal/utils","ember-metal/computed","ember-metal/mixin","ember-views/streams/key_stream","ember-metal/streams/stream_binding","ember-views/streams/context_stream","ember-metal/is_none","ember-metal/deprecate_property","ember-runtime/system/native_array","ember-views/streams/class_name_binding","ember-metal/enumerable_utils","ember-metal/property_events","ember-views/system/jquery","ember-views/system/ext","ember-views/views/core_view","ember-metal/streams/utils","ember-views/system/sanitize_attribute_value","morph/dom-helper/prop","exports"],function(e,t,n,i,a,s,o,u,l,c,h,m,p,f,d,v,b,g,y,_,w,x,C,E,O,P,A,N,S,T){"use strict";function k(){return this}function V(){return I||(I=r("ember-htmlbars").defaultEnv),M(I)}var I,j=e["default"],M=t.create,R=n["default"],D=i["default"],L=a["default"],F=s.get,B=o.set,H=u["default"],z=l["default"],q=c.addObserver,U=c.removeObserver,W=h.defineProperty,K=m.guidFor,G=p.computed,Q=f.observer,$=d["default"],Y=v["default"],X=b["default"],Z=m.typeOf,J=g["default"],et=f.Mixin,tt=y.deprecateProperty,rt=_.A,nt=w.streamifyClassNameBinding,it=x.forEach,at=x.addObject,st=x.removeObject,ot=f.beforeObserver,ut=C.propertyWillChange,lt=C.propertyDidChange,ct=E["default"],ht=P["default"],mt=A.subscribe,pt=A.read,ft=A.isStream,dt=N["default"],vt=S.normalizeProperty,bt=G(function(){var e=this._childViews,t=rt();return it(e,function(e){var r;e.isVirtual?(r=F(e,"childViews"))&&t.pushObjects(r):t.push(e)}),t.replace=function(){throw new L("childViews is immutable")},t});j.TEMPLATES={};var gt=[],yt=ht.extend({concatenatedProperties:["classNames","classNameBindings","attributeBindings"],isView:!0,templateName:null,layoutName:null,instrumentDisplay:G(function(){return this.helperName?"{{"+this.helperName+"}}":void 0}),template:G("templateName",function(e,t){if(void 0!==t)return t;var r=F(this,"templateName"),n=this.templateForName(r,"template");return n||F(this,"defaultTemplate")}),_controller:null,controller:G(function(e,t){if(2===arguments.length)return this._controller=t,t;if(this._controller)return this._controller;var r=F(this,"_parentView");return r?F(r,"controller"):null}),layout:G(function(){var e=F(this,"layoutName"),t=this.templateForName(e,"layout");return t||F(this,"defaultLayout")}).property("layoutName"),_yield:function(e,t,r){var n=F(this,"template");if(n){var i=!1;return i=n.isHTMLBars,i?n.render(e,t,r.contextualElement):n(e,t)}},_blockArguments:gt,templateForName:function(e){if(e){if(!this.container)throw new L("Container was not found when looking up a views template. This is most likely due to manually instantiating an Ember.View. See: http://git.io/EKPpnA");return this.container.lookup("template:"+e)}},context:G(function(e,t){return 2===arguments.length?(B(this,"_context",t),t):F(this,"_context")})["volatile"](),_context:G(function(e,t){if(2===arguments.length)return t;var r,n;return(n=F(this,"controller"))?n:(r=this._parentView,r?F(r,"_context"):null)}),_contextDidChange:Q("context",function(){this.rerender()}),isVisible:!0,childViews:bt,_childViews:gt,_childViewsWillChange:ot("childViews",function(){if(this.isVirtual){var e=F(this,"parentView");e&&ut(e,"childViews")}}),_childViewsDidChange:Q("childViews",function(){if(this.isVirtual){var e=F(this,"parentView");e&<(e,"childViews")}}),nearestInstanceOf:function(e){for(var t=F(this,"parentView");t;){if(t instanceof e)return t;t=F(t,"parentView")}},nearestOfType:function(e){for(var t=F(this,"parentView"),r=e instanceof et?function(t){return e.detect(t)}:function(t){return e.detect(t.constructor)};t;){if(r(t))return t;t=F(t,"parentView")}},nearestWithProperty:function(e){for(var t=F(this,"parentView");t;){if(e in t)return t;t=F(t,"parentView")}},nearestChildOf:function(e){for(var t=F(this,"parentView");t;){if(F(t,"parentView")instanceof e)return t;t=F(t,"parentView")}},_parentViewDidChange:Q("_parentView",function(){this.isDestroying||(this._setupKeywords(),this.trigger("parentViewDidChange"),F(this,"parentView.controller")&&!F(this,"controller")&&this.notifyPropertyChange("controller"))}),_controllerDidChange:Q("controller",function(){this.isDestroying||(this.rerender(),this.forEachChildView(function(e){e.propertyDidChange("controller")}))}),_setupKeywords:function(){var e=this._keywords,t=this._contextView||this._parentView;if(t){var r=t._keywords;e.view=this.isVirtual?r.view:this;for(var n in r)e[n]||(e[n]=r[n])}else e.view=this.isVirtual?null:this},render:function(e){var t=F(this,"layout")||F(this,"template");if(t){var r,n=F(this,"context"),i={view:this,buffer:e,isRenderData:!0},a={data:i},s=!1;if(s=t.isHTMLBars){var o=j.merge(V(),a);r=t.render(this,o,e.innerContextualElement(),this._blockArguments)}else r=t(n,a);void 0!==r&&e.push(r)}},rerender:function(){return this.currentState.rerender(this)},_applyClassNameBindings:function(e){var t,r,n,i=this.classNames;it(e,function(e){var a;a=ft(e)?e:nt(this,e,"_view.");var s,o=this._wrapAsScheduled(function(){t=this.$(),r=pt(a),s&&(t.removeClass(s),i.removeObject(s)),r?(t.addClass(r),s=r):s=null});n=pt(a),n&&(at(i,n),s=n),mt(a,o,this),this.one("willClearRender",function(){s&&(i.removeObject(s),s=null)})},this)},_unspecifiedAttributeBindings:null,_applyAttributeBindings:function(e,t){var r,n=this._unspecifiedAttributeBindings=this._unspecifiedAttributeBindings||{};it(t,function(t){var i=t.split(":"),a=i[0],s=i[1]||a;a in this?(this._setupAttributeBindingObservation(a,s),r=F(this,a),yt.applyAttributeBindings(e,s,r)):n[a]=s},this),this.setUnknownProperty=this._setUnknownProperty},_setupAttributeBindingObservation:function(e,t){var r,n,i=function(){n=this.$(),r=F(this,e);var i=vt(n,t.toLowerCase())||t;yt.applyAttributeBindings(n,i,r)};this.registerObserver(this,e,i)},setUnknownProperty:null,_setUnknownProperty:function(e,t){var r=this._unspecifiedAttributeBindings&&this._unspecifiedAttributeBindings[e];return r&&this._setupAttributeBindingObservation(e,r),W(this,e),B(this,e,t)},_classStringForProperty:function(e){return yt._classStringForValue(e.path,e.stream.value(),e.className,e.falsyClassName)},element:null,$:function(e){return this.currentState.$(this,e)},mutateChildViews:function(e){for(var t,r=this._childViews,n=r.length;--n>=0;)t=r[n],e(this,t,n);return this},forEachChildView:function(e){var t=this._childViews;if(!t)return this;var r,n,i=t.length;for(n=0;i>n;n++)r=t[n],e(r);return this},appendTo:function(e){var t=ct(e);return this.constructor.renderer.appendTo(this,t[0]),this},replaceIn:function(e){var t=ct(e);return this.constructor.renderer.replaceIn(this,t[0]),this},append:function(){return this.appendTo(document.body)},remove:function(){this.removedFromDOM||this.destroyElement()},elementId:null,findElementInParentElement:function(e){var t="#"+this.elementId;return ct(t)[0]||ct(t,e)[0]},createElement:function(){return this.element?this:(this._didCreateElementWithoutMorph=!0,this.constructor.renderer.renderTree(this),this)},willInsertElement:k,didInsertElement:k,willClearRender:k,destroyElement:function(){return this.currentState.destroyElement(this)},willDestroyElement:k,parentViewDidChange:k,instrumentName:"view",instrumentDetails:function(e){e.template=F(this,"templateName"),this._super(e)},beforeRender:function(){},afterRender:function(){},applyAttributesToBuffer:function(e){var t=this.classNameBindings;t.length&&this._applyClassNameBindings(t);var r=this.attributeBindings;r.length&&this._applyAttributeBindings(e,r),e.setClasses(this.classNames),e.id(this.elementId);var n=F(this,"ariaRole");n&&e.attr("role",n),F(this,"isVisible")===!1&&e.style("display","none")},tagName:null,ariaRole:null,classNames:["ember-view"],classNameBindings:gt,attributeBindings:gt,init:function(){this.isVirtual||this.elementId||(this.elementId=K(this)),this._super(),this._childViews=this._childViews.slice(),this._baseContext=void 0,this._contextStream=void 0,this._streamBindings=void 0,this._keywords||(this._keywords=M(null)),this._keywords._view=this,this._keywords.view=void 0,this._keywords.controller=new $(this,"controller"),this._setupKeywords(),this.classNameBindings=rt(this.classNameBindings.slice()),this.classNames=rt(this.classNames.slice())},appendChild:function(e,t){return this.currentState.appendChild(this,e,t)},removeChild:function(e){if(!this.isDestroying){B(e,"_parentView",null);var t=this._childViews;return st(t,e),this.propertyDidChange("childViews"),this}},removeAllChildren:function(){return this.mutateChildViews(function(e,t){e.removeChild(t)})},destroyAllChildren:function(){return this.mutateChildViews(function(e,t){t.destroy()})},removeFromParent:function(){var e=this._parentView;return this.remove(),e&&e.removeChild(this),this},destroy:function(){var e=F(this,"parentView"),t=this.viewName;return this._super()?(t&&e&&e.set(t,null),this):void 0},createChildView:function(e,t){if(!e)throw new TypeError("createChildViews first argument must exist");if(e.isView&&e._parentView===this&&e.container===this.container)return e;if(t=t||{},t._parentView=this,ht.detect(e))t.container=this.container,e=e.create(t),e.viewName&&B(F(this,"concreteView"),e.viewName,e);else if("string"==typeof e){var r="view:"+e,n=this.container.lookupFactory(r);e=n.create(t)}else t.container=this.container,H(e,t);return e},becameVisible:k,becameHidden:k,_isVisibleDidChange:Q("isVisible",function(){this._isVisible!==F(this,"isVisible")&&z.scheduleOnce("render",this,this._toggleVisibility)}),_toggleVisibility:function(){var e=this.$(),t=F(this,"isVisible");this._isVisible!==t&&(this._isVisible=t,e&&(e.toggle(t),this._isAncestorHidden()||(t?this._notifyBecameVisible():this._notifyBecameHidden())))},_notifyBecameVisible:function(){this.trigger("becameVisible"),this.forEachChildView(function(e){var t=F(e,"isVisible");(t||null===t)&&e._notifyBecameVisible()})},_notifyBecameHidden:function(){this.trigger("becameHidden"),this.forEachChildView(function(e){var t=F(e,"isVisible");(t||null===t)&&e._notifyBecameHidden()})},_isAncestorHidden:function(){for(var e=F(this,"parentView");e;){if(F(e,"isVisible")===!1)return!0;e=F(e,"parentView")}return!1},transitionTo:function(e,t){this._transitionTo(e,t)},_transitionTo:function(e){var t=this.currentState,r=this.currentState=this._states[e];this._state=e,t&&t.exit&&t.exit(this),r.enter&&r.enter(this)},handleEvent:function(e,t){return this.currentState.handleEvent(this,e,t)},registerObserver:function(e,t,r,n){if(n||"function"!=typeof r||(n=r,r=null),e&&"object"==typeof e){var i=this._wrapAsScheduled(n);q(e,t,r,i),this.one("willClearRender",function(){U(e,t,r,i)})}},_wrapAsScheduled:function(e){var t=this,r=function(){t.currentState.invokeObserver(this,e)},n=function(){z.scheduleOnce("render",this,r)};return n},getStream:function(e){var t=this._getContextStream().get(e);return t._label=e,t},_getBindingForStream:function(e){void 0===this._streamBindings&&(this._streamBindings=M(null),this.one("willDestroyElement",this,this._destroyStreamBindings));var t=e;if(ft(e)&&(t=e._label,!t))return e;if(void 0!==this._streamBindings[t])return this._streamBindings[t];var r=this._getContextStream().get(t),n=new Y(r);return n._label=t,this._streamBindings[t]=n},_destroyStreamBindings:function(){var e=this._streamBindings;for(var t in e)e[t].destroy();this._streamBindings=void 0},_getContextStream:function(){return void 0===this._contextStream&&(this._baseContext=new $(this,"context"),this._contextStream=new X(this),this.one("willDestroyElement",this,this._destroyContextStream)),this._contextStream},_destroyContextStream:function(){this._baseContext.destroy(),this._baseContext=void 0,this._contextStream.destroy(),this._contextStream=void 0},_unsubscribeFromStreamBindings:function(){for(var e in this._streamBindingSubscriptions){var t=this[e+"Binding"],r=this._streamBindingSubscriptions[e];t.unsubscribe(r)}}});tt(yt.prototype,"state","_state"),tt(yt.prototype,"states","_states");var _t=D.extend(R).create();yt.addMutationListener=function(e){_t.on("change",e)},yt.removeMutationListener=function(e){_t.off("change",e)},yt.notifyMutationListeners=function(){_t.trigger("change")},yt.views={},yt.childViewsProperty=bt,yt.applyAttributeBindings=function(e,t,r){var n=dt(e[0],t,r),i=Z(n);"value"===t||"string"!==i&&("number"!==i||isNaN(n))?"value"===t||"boolean"===i?J(n)||n===!1?(e.removeAttr(t),"required"===t?e.removeProp(t):e.prop(t,"")):n!==e.prop(t)&&e.prop(t,n):n||e.removeAttr(t):n!==e.attr(t)&&e.attr(t,n)},T["default"]=yt}),e("ember-views/views/with_view",["ember-metal/property_set","ember-metal/utils","ember-views/views/bound_view","exports"],function(e,t,r,n){"use strict";var i=e.set,a=t.apply,s=r["default"];n["default"]=s.extend({init:function(){a(this,this._super,arguments);var e=this.templateHash.controller;if(e){var t=this.previousContext,r=this.container.lookupFactory("controller:"+e).create({parentController:t,target:t});this._generatedController=r,this.preserveContext?(this._blockArguments=[r],this.lazyValue.subscribe(function(e){i(r,"model",e.value())})):(i(this,"controller",r),this.valueNormalizerFunc=function(e){return r.set("model",e),r}),i(r,"model",this.lazyValue.value())}else this.preserveContext&&(this._blockArguments=[this.lazyValue])},willDestroy:function(){this._super(),this._generatedController&&this._generatedController.destroy()}})}),e("ember",["ember-metal","ember-runtime","ember-views","ember-routing","ember-application","ember-extension-support","ember-htmlbars","ember-routing-htmlbars","ember-runtime/system/lazy_load"],function(e,r,n,a,s,o,u,l,c){"use strict";var h=c.runLoadHooks;i.__loader.registry["ember-template-compiler"]&&t("ember-template-compiler"),i.__loader.registry["ember-testing"]&&t("ember-testing"),h("Ember")}),e("htmlbars-util",["./htmlbars-util/safe-string","./htmlbars-util/handlebars/utils","./htmlbars-util/namespaces","exports"],function(e,t,r,n){"use strict";var i=e["default"],a=t.escapeExpression,s=r.getAttrNamespace;n.SafeString=i,n.escapeExpression=a,n.getAttrNamespace=s}),e("htmlbars-util/array-utils",["exports"],function(e){"use strict";function t(e,t,r){var n,i;if(void 0===r)for(n=0,i=e.length;i>n;n++)t(e[n],n,e);else for(n=0,i=e.length;i>n;n++)t.call(r,e[n],n,e)}function r(e,t){var r,n,i=[];
-for(r=0,n=e.length;n>r;r++)i.push(t(e[r],r,e));return i}e.forEach=t,e.map=r;var n;n=Array.prototype.indexOf?function(e,t,r){return e.indexOf(t,r)}:function(e,t,r){void 0===r||null===r?r=0:0>r&&(r=Math.max(0,e.length+r));for(var n=r,i=e.length;i>n;n++)if(e[n]===t)return n;return-1};var i=n;e.indexOfArray=i}),e("htmlbars-util/handlebars/safe-string",["exports"],function(e){"use strict";function t(e){this.string=e}t.prototype.toString=t.prototype.toHTML=function(){return""+this.string},e["default"]=t}),e("htmlbars-util/handlebars/utils",["./safe-string","exports"],function(e,t){"use strict";function r(e){return o[e]}function n(e){for(var t=1;t":">",'"':""","'":"'","`":"`"}),u=/[&<>"'`]/g,l=/[&<>"'`]/;t.extend=n;var c=Object.prototype.toString;t.toString=c;var h=function(e){return"function"==typeof e};h(/x/)&&(h=function(e){return"function"==typeof e&&"[object Function]"===c.call(e)});var h;t.isFunction=h;var m=Array.isArray||function(e){return e&&"object"==typeof e?"[object Array]"===c.call(e):!1};t.isArray=m,t.escapeExpression=i,t.isEmpty=a,t.appendContextPath=s}),e("htmlbars-util/namespaces",["exports"],function(e){"use strict";function t(e){var t,n=e.indexOf(":");if(-1!==n){var i=e.slice(0,n);t=r[i]}return t||null}var r={html:"http://www.w3.org/1999/xhtml",mathml:"http://www.w3.org/1998/Math/MathML",svg:"http://www.w3.org/2000/svg",xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace"};e.getAttrNamespace=t}),e("htmlbars-util/object-utils",["exports"],function(e){"use strict";function t(e,t){for(var r in t)e.hasOwnProperty(r)||(e[r]=t[r]);return e}e.merge=t}),e("htmlbars-util/quoting",["exports"],function(e){"use strict";function t(e){return e=e.replace(/\\/g,"\\\\"),e=e.replace(/"/g,'\\"'),e=e.replace(/\n/g,"\\n")}function r(e){return'"'+t(e)+'"'}function n(e){return"["+e+"]"}function i(e){return"{"+e.join(", ")+"}"}function a(e,t){for(var r="";t--;)r+=e;return r}e.escapeString=t,e.string=r,e.array=n,e.hash=i,e.repeat=a}),e("htmlbars-util/safe-string",["./handlebars/safe-string","exports"],function(e,t){"use strict";var r=e["default"];t["default"]=r}),e("morph",["./morph/morph","./morph/attr-morph","./morph/dom-helper","exports"],function(e,t,r,n){"use strict";var i=e["default"],a=t["default"],s=r["default"];n.Morph=i,n.AttrMorph=a,n.DOMHelper=s}),e("morph/attr-morph",["./attr-morph/sanitize-attribute-value","./dom-helper/prop","./dom-helper/build-html-dom","../htmlbars-util","exports"],function(e,t,r,n,i){"use strict";function a(e){this.domHelper.setPropertyStrict(this.element,this.attrName,e)}function s(e){c(e)?this.domHelper.removeAttribute(this.element,this.attrName):this.domHelper.setAttribute(this.element,this.attrName,e)}function o(e){c(e)?this.domHelper.removeAttribute(this.element,this.attrName):this.domHelper.setAttributeNS(this.element,this.namespace,this.attrName,e)}function u(e,t,r,n){this.element=e,this.domHelper=r,this.namespace=void 0!==n?n:p(t),this.escaped=!0;var i=h(this.element,t);this.namespace?(this._update=o,this.attrName=t):e.namespaceURI!==m&&"style"!==t&&i?(this.attrName=i,this._update=a):(this.attrName=t,this._update=s)}var l=e.sanitizeAttributeValue,c=t.isAttrRemovalValue,h=t.normalizeProperty,m=r.svgNamespace,p=n.getAttrNamespace;u.prototype.setContent=function(e){if(this.escaped){var t=l(this.element,this.attrName,e);this._update(t,this.namespace)}else this._update(e,this.namespace)},i["default"]=u}),e("morph/attr-morph/sanitize-attribute-value",["exports"],function(e){"use strict";function t(e,t,s){var o;return r||(r=document.createElement("a")),o=e?e.tagName:null,s&&s.toHTML?s.toHTML():(null===o||i[o])&&a[t]&&(r.href=s,n[r.protocol]===!0)?"unsafe:"+s:s}var r,n={"javascript:":!0,"vbscript:":!0},i={A:!0,BODY:!0,LINK:!0,IMG:!0,IFRAME:!0},a={href:!0,src:!0,background:!0};e.badAttributes=a,e.sanitizeAttributeValue=t}),e("morph/dom-helper",["../morph/morph","../morph/attr-morph","./dom-helper/build-html-dom","./dom-helper/classes","./dom-helper/prop","exports"],function(e,t,r,n,i,a){"use strict";function s(e){return e&&e.namespaceURI===p&&!f[e.tagName]?p:null}function o(e,t){if("TABLE"===t.tagName){var r=E.exec(e);if(r){var n=r[1];return"tr"===n||"col"===n}}}function u(e,t){var r=t.document.createElement("div");return r.innerHTML="",r.firstChild.childNodes}function l(e){if(this.document=e||document,!this.document)throw new Error("A document object must be passed to the DOMHelper, or available on the global scope");this.canClone=C,this.namespace=null}var c=e["default"],h=t["default"],m=r.buildHTMLDOM,p=r.svgNamespace,f=r.svgHTMLIntegrationPoints,d=n.addClasses,v=n.removeClasses,b=i.normalizeProperty,g=i.isAttrRemovalValue,y="undefined"==typeof document?!1:document,_=y&&function(e){var t=e.createElement("div");t.appendChild(e.createTextNode(""));var r=t.cloneNode(!0);return 0===r.childNodes.length}(y),w=y&&function(e){var t=e.createElement("input");t.setAttribute("checked","checked");var r=t.cloneNode(!1);return!r.checked}(y),x=y&&(y.createElementNS?function(e){var t=e.createElementNS(p,"svg");return t.setAttribute("viewBox","0 0 100 100"),t.removeAttribute("viewBox"),!t.getAttribute("viewBox")}(y):!0),C=y&&function(e){var t=e.createElement("div");t.appendChild(e.createTextNode(" ")),t.appendChild(e.createTextNode(" "));var r=t.cloneNode(!0);return" "===r.childNodes[0].nodeValue}(y),E=/<([\w:]+)/,O=l.prototype;O.constructor=l,O.getElementById=function(e,t){return t=t||this.document,t.getElementById(e)},O.insertBefore=function(e,t,r){return e.insertBefore(t,r)},O.appendChild=function(e,t){return e.appendChild(t)},O.childAt=function(e,t){for(var r=e,n=0;nn;n++)r=r.nextSibling;return r},O.appendText=function(e,t){return e.appendChild(this.document.createTextNode(t))},O.setAttribute=function(e,t,r){e.setAttribute(t,String(r))},O.setAttributeNS=function(e,t,r,n){e.setAttributeNS(t,r,String(n))},O.removeAttribute=x?function(e,t){e.removeAttribute(t)}:function(e,t){"svg"===e.tagName&&"viewBox"===t?e.setAttribute(t,null):e.removeAttribute(t)},O.setPropertyStrict=function(e,t,r){e[t]=r},O.setProperty=function(e,t,r,n){var i=t.toLowerCase();if(e.namespaceURI===p||"style"===i)g(r)?e.removeAttribute(t):n?e.setAttributeNS(n,t,r):e.setAttribute(t,r);else{var a=b(e,t);a?e[a]=r:g(r)?e.removeAttribute(t):n&&e.setAttributeNS?e.setAttributeNS(n,t,r):e.setAttribute(t,r)}},y&&y.createElementNS?(O.createElement=function(e,t){var r=this.namespace;return t&&(r="svg"===e?p:s(t)),r?this.document.createElementNS(r,e):this.document.createElement(e)},O.setAttributeNS=function(e,t,r,n){e.setAttributeNS(t,r,String(n))}):(O.createElement=function(e){return this.document.createElement(e)},O.setAttributeNS=function(e,t,r,n){e.setAttribute(r,String(n))}),O.addClasses=d,O.removeClasses=v,O.setNamespace=function(e){this.namespace=e},O.detectNamespace=function(e){this.namespace=s(e)},O.createDocumentFragment=function(){return this.document.createDocumentFragment()},O.createTextNode=function(e){return this.document.createTextNode(e)},O.createComment=function(e){return this.document.createComment(e)},O.repairClonedNode=function(e,t,r){if(_&&t.length>0)for(var n=0,i=t.length;i>n;n++){var a=this.document.createTextNode(""),s=t[n],o=this.childAtIndex(e,s);o?e.insertBefore(a,o):e.appendChild(a)}w&&r&&e.setAttribute("checked","checked")},O.cloneNode=function(e,t){var r=e.cloneNode(!!t);return r},O.createAttrMorph=function(e,t,r){return new h(e,t,this,r)},O.createUnsafeAttrMorph=function(e,t,r){var n=this.createAttrMorph(e,t,r);return n.escaped=!1,n},O.createMorph=function(e,t,r,n){return n||1!==e.nodeType||(n=e),new c(e,t,r,this,n)},O.createUnsafeMorph=function(e,t,r,n){var i=this.createMorph(e,t,r,n);return i.escaped=!1,i},O.createMorphAt=function(e,t,r,n){var i=-1===t?null:this.childAtIndex(e,t),a=-1===r?null:this.childAtIndex(e,r);return this.createMorph(e,i,a,n)},O.createUnsafeMorphAt=function(e,t,r,n){var i=this.createMorphAt(e,t,r,n);return i.escaped=!1,i},O.insertMorphBefore=function(e,t,r){var n=this.document.createTextNode(""),i=this.document.createTextNode("");return e.insertBefore(n,t),e.insertBefore(i,t),this.createMorph(e,n,i,r)},O.appendMorph=function(e,t){var r=this.document.createTextNode(""),n=this.document.createTextNode("");return e.appendChild(r),e.appendChild(n),this.createMorph(e,r,n,t)},O.parseHTML=function(e,t){if(s(t)===p)return u(e,this);var r=m(e,t,this);if(o(e,t)){for(var n=r[0];n&&1!==n.nodeType;)n=n.nextSibling;return n.childNodes}return r};var P;O.protocolForURL=function(e){return P||(P=this.document.createElement("a")),P.href=e,P.protocol},a["default"]=l}),e("morph/dom-helper/build-html-dom",["exports"],function(e){"use strict";function t(e,t){t=""+t,e.innerHTML=t;for(var r=e.childNodes,n=r[0];1===n.nodeType&&!n.nodeName;)n=n.firstChild;if(3===n.nodeType&&""===n.nodeValue.charAt(0)){var i=n.nodeValue.slice(1);i.length?n.nodeValue=n.nodeValue.slice(1):n.parentNode.removeChild(n)}return r}function r(e,r){var n=r.tagName,i=r.outerHTML||(new XMLSerializer).serializeToString(r);if(!i)throw"Can't set innerHTML on "+n+" in this browser";for(var a=p[n.toLowerCase()],s=i.match(new RegExp("<"+n+"([^>]*)>","i"))[0],o="",u=[s,e,o],l=a.length,c=1+l;l--;)u.unshift("<"+a[l]+">"),u.push("");var h=document.createElement("div");t(h,u.join(""));for(var m=h;c--;)for(m=m.firstChild;m&&1!==m.nodeType;)m=m.nextSibling;for(;m&&m.tagName!==n;)m=m.nextSibling;return m?m.childNodes:[]}function n(e,t,r){var n=f(e,t,r);if("SELECT"===t.tagName)for(var i=0;n[i];i++)if("OPTION"===n[i].tagName){s(n[i].parentNode,n[i],e)&&(n[i].parentNode.selectedIndex=-1);break}return n}var i={foreignObject:1,desc:1,title:1};e.svgHTMLIntegrationPoints=i;var a="http://www.w3.org/2000/svg";e.svgNamespace=a;var s,o="undefined"==typeof document?!1:document,u=o&&function(e){if(void 0!==e.createElementNS){var t=e.createElementNS(a,"title");return t.innerHTML="",0===t.childNodes.length||1!==t.childNodes[0].nodeType}}(o),l=o&&function(e){var t=e.createElement("div");return t.innerHTML="",t.firstChild.innerHTML="",""===t.firstChild.innerHTML}(o),c=o&&function(e){var t=e.createElement("div");return t.innerHTML="Test: Value","Test:"===t.childNodes[0].nodeValue&&" Value"===t.childNodes[2].nodeValue}(o),h=o&&function(e){var t=e.createElement("div");return t.innerHTML="","selected"===t.childNodes[0].childNodes[0].getAttribute("selected")}(o);s=h?function(){var e=/]*selected/;return function(t,r,n){return 0===t.selectedIndex&&!e.test(n)}}():function(e,t){var r=t.getAttribute("selected");return 0===e.selectedIndex&&(null===r||""!==r&&"selected"!==r.toLowerCase())};var m,p=o&&function(e){var t,r,n=e.createElement("table");try{n.innerHTML=""}catch(i){}finally{r=0===n.childNodes.length}r&&(t={colgroup:["table"],table:[],tbody:["table"],tfoot:["table"],thead:["table"],tr:["table","tbody"]});var a=e.createElement("select");return a.innerHTML="",a.childNodes[0]||(t=t||{},t.select=[]),t}(o);m=l?function(e,r,n){return r=n.cloneNode(r,!1),t(r,e),r.childNodes}:function(e,t,r){return t=r.cloneNode(t,!1),t.innerHTML=e,t.childNodes};var f;f=p||c?function(e,t,n){var i=[],a=[];"string"==typeof e&&(e=e.replace(/(\s*)()(\s*)/g,function(e,t,r){return a.push(r),t}));var s;s=p[t.tagName.toLowerCase()]?r(e,t):m(e,t,n);var o,u,l,c,h=[];for(o=0;o0&&(d=n.document.createTextNode(v),f.parentNode.insertBefore(d,f)),b=a[o],b&&b.length>0&&(d=n.document.createTextNode(b),f.parentNode.insertBefore(d,f.nextSibling));return s}:m;var d;d=u?function(e,t,r){return i[t.tagName]?n(e,document.createElement("div"),r):n(e,t,r)}:n,e.buildHTMLDOM=d}),e("morph/dom-helper/classes",["exports"],function(e){"use strict";function t(e){var t=e.getAttribute("class")||"";return""!==t&&" "!==t?t.split(" "):[]}function r(e,t){for(var r=0,n=e.length,i=0,a=t.length,s=new Array(a);n>r;r++)for(i=0;a>i;i++)if(t[i]===e[r]){s[i]=r;break}return s}function n(e,n){for(var i=t(e),a=r(i,n),s=!1,o=0,u=n.length;u>o;o++)void 0===a[o]&&(s=!0,i.push(n[o]));s&&e.setAttribute("class",i.length>0?i.join(" "):"")}function i(e,n){for(var i=t(e),a=r(n,i),s=!1,o=[],u=0,l=i.length;l>u;u++)void 0===a[u]?o.push(i[u]):s=!0;s&&e.setAttribute("class",o.length>0?o.join(" "):"")}var a,s,o="undefined"==typeof document?!1:document,u=o&&function(){var e=document.createElement("div");return e.classList?(e.classList.add("boo"),e.classList.add("boo","baz"),"boo baz"===e.className):!1}();u?(a=function(e,t){e.classList?1===t.length?e.classList.add(t[0]):2===t.length?e.classList.add(t[0],t[1]):e.classList.add.apply(e.classList,t):n(e,t)},s=function(e,t){e.classList?1===t.length?e.classList.remove(t[0]):2===t.length?e.classList.remove(t[0],t[1]):e.classList.remove.apply(e.classList,t):i(e,t)}):(a=n,s=i),e.addClasses=a,e.removeClasses=s}),e("morph/dom-helper/prop",["exports"],function(e){"use strict";function t(e){return null===e||void 0===e}function r(e,t){var r,i=e.tagName,a=n[i];if(!a){a={};for(r in e)a[r.toLowerCase()]=r;n[i]=a}return a[t]}e.isAttrRemovalValue=t;var n={};e.propertyCaches=n,e.normalizeProperty=r}),e("morph/morph",["exports"],function(e){"use strict";function t(e,t){if(null===e||null===t)throw new Error("a fragment parent must have boundary nodes in order to detect insertion")}function r(e){if(!e||1!==e.nodeType)throw new Error("An element node must be provided for a contextualElement, you provided "+(e?"nodeType "+e.nodeType:"nothing"))}function n(e,n,i,a,s){11===e.nodeType?(t(n,i),this.element=null):this.element=e,this._parent=e,this.start=n,this.end=i,this.domHelper=a,r(s),this.contextualElement=s,this.escaped=!0,this.reset()}function i(e,t,r){for(var n,i=t,a=r.length;a--;)n=r[a],e.insertBefore(n,i),i=n}function a(e,t,r){var n,i;for(n=null===r?e.lastChild:r.previousSibling;null!==n&&n!==t;)i=n.previousSibling,e.removeChild(n),n=i}var s=Array.prototype.splice;n.prototype.reset=function(){this.text=null,this.owner=null,this.morphs=null,this.before=null,this.after=null},n.prototype.parent=function(){if(!this.element){var e=this.start.parentNode;this._parent!==e&&(this._parent=e),1===e.nodeType&&(this.element=e)}return this._parent},n.prototype.destroy=function(){this.owner?this.owner.removeMorph(this):a(this.element||this.parent(),this.start,this.end)},n.prototype.removeMorph=function(e){for(var t=this.morphs,r=0,n=t.length;n>r;r++)if(t[r]===e){this.replace(r,1);break}},n.prototype.setContent=function(e){this._update(this.element||this.parent(),e)},n.prototype.updateNode=function(e){var t=this.element||this.parent();return e?void this._updateNode(t,e):this._updateText(t,"")},n.prototype.updateText=function(e){this._updateText(this.element||this.parent(),e)},n.prototype.updateHTML=function(e){var t=this.element||this.parent();return e?void this._updateHTML(t,e):this._updateText(t,"")},n.prototype._update=function(e,t){null===t||void 0===t?this._updateText(e,""):"string"==typeof t?this.escaped?this._updateText(e,t):this._updateHTML(e,t):t.nodeType?this._updateNode(e,t):t.string?this._updateHTML(e,t.string):this._updateText(e,t.toString())},n.prototype._updateNode=function(e,t){if(this.text){if(3===t.nodeType)return void(this.text.nodeValue=t.nodeValue);this.text=null}var r=this.start,n=this.end;a(e,r,n),e.insertBefore(t,n),null!==this.before&&(this.before.end=r.nextSibling),null!==this.after&&(this.after.start=n.previousSibling)},n.prototype._updateText=function(e,t){if(this.text)return void(this.text.nodeValue=t);var r=this.domHelper.createTextNode(t);this.text=r,a(e,this.start,this.end),e.insertBefore(r,this.end),null!==this.before&&(this.before.end=r),null!==this.after&&(this.after.start=r)},n.prototype._updateHTML=function(e,t){var r=this.start,n=this.end;a(e,r,n),this.text=null;var s=this.domHelper.parseHTML(t,this.contextualElement);i(e,n,s),null!==this.before&&(this.before.end=r.nextSibling),null!==this.after&&(this.after.start=n.previousSibling)},n.prototype.append=function(e){null===this.morphs&&(this.morphs=[]);var t=this.morphs.length;return this.insert(t,e)},n.prototype.insert=function(e,t){null===this.morphs&&(this.morphs=[]);var r=this.element||this.parent(),i=this.morphs,a=e>0?i[e-1]:null,s=e0?c[e-1]:null,m=e+t0&&a(l,p,f),0===d)return null!==h&&(h.after=m,h.end=f),null!==m&&(m.before=h,m.start=p),void c.splice(e,t);if(i=new Array(d+2),d>0){for(o=0;d>o;o++)i[o+2]=u=new n(l,p,f,this.domHelper,this.contextualElement),u._update(l,r[o]),u.owner=this,null!==h&&(u.before=h,h.end=p.nextSibling,h.after=u),h=u,p=null===f?l.lastChild:f.previousSibling;null!==m&&(u.after=m,m.before=u,m.start=f.previousSibling)}i[0]=e,i[1]=t,s.apply(c,i)},e["default"]=n}),e("route-recognizer",["./route-recognizer/dsl","exports"],function(e,t){"use strict";function r(e){return"[object Array]"===Object.prototype.toString.call(e)}function n(e){this.string=e}function i(e){this.name=e}function a(e){this.name=e}function s(){}function o(e,t,r){"/"===e.charAt(0)&&(e=e.substr(1));for(var o=e.split("/"),u=[],l=0,c=o.length;c>l;l++){var h,m=o[l];(h=m.match(/^:([^\/]+)$/))?(u.push(new i(h[1])),t.push(h[1]),r.dynamics++):(h=m.match(/^\*([^\/]+)$/))?(u.push(new a(h[1])),t.push(h[1]),r.stars++):""===m?u.push(new s):(u.push(new n(m)),r.statics++)}return u}function u(e){this.charSpec=e,this.nextStates=[]}function l(e){return e.sort(function(e,t){if(e.types.stars!==t.types.stars)return e.types.stars-t.types.stars;if(e.types.stars){if(e.types.statics!==t.types.statics)return t.types.statics-e.types.statics;if(e.types.dynamics!==t.types.dynamics)return t.types.dynamics-e.types.dynamics}return e.types.dynamics!==t.types.dynamics?e.types.dynamics-t.types.dynamics:e.types.statics!==t.types.statics?t.types.statics-e.types.statics:0})}function c(e,t){for(var r=[],n=0,i=e.length;i>n;n++){var a=e[n];r=r.concat(a.match(t))}return r}function h(e){this.queryParams=e||{}}function m(e,t,r){for(var n=e.handlers,i=e.regex,a=t.match(i),s=1,o=new h(r),u=0,l=n.length;l>u;u++){for(var c=n[u],m=c.names,p={},f=0,d=m.length;d>f;f++)p[m[f]]=a[s++];o.push({handler:c.handler,params:p,isDynamic:!!m.length})}return o}function p(e,t){return t.eachChar(function(t){e=e.put(t)}),e}function f(e){return e=e.replace(/\+/gm,"%20"),decodeURIComponent(e)}var d=e["default"],v=["/",".","*","+","?","|","(",")","[","]","{","}","\\"],b=new RegExp("(\\"+v.join("|\\")+")","g");n.prototype={eachChar:function(e){for(var t,r=this.string,n=0,i=r.length;i>n;n++)t=r.charAt(n),e({validChars:t})},regex:function(){return this.string.replace(b,"\\$1")},generate:function(){return this.string}},i.prototype={eachChar:function(e){e({invalidChars:"/",repeat:!0})},regex:function(){return"([^/]+)"},generate:function(e){return e[this.name]}},a.prototype={eachChar:function(e){e({invalidChars:"",repeat:!0})},regex:function(){return"(.+)"},generate:function(e){return e[this.name]}},s.prototype={eachChar:function(){},regex:function(){return""},generate:function(){return""}},u.prototype={get:function(e){for(var t=this.nextStates,r=0,n=t.length;n>r;r++){var i=t[r],a=i.charSpec.validChars===e.validChars;if(a=a&&i.charSpec.invalidChars===e.invalidChars)return i}},put:function(e){var t;return(t=this.get(e))?t:(t=new u(e),this.nextStates.push(t),e.repeat&&t.nextStates.push(t),t)},match:function(e){for(var t,r,n,i=this.nextStates,a=[],s=0,o=i.length;o>s;s++)t=i[s],r=t.charSpec,"undefined"!=typeof(n=r.validChars)?-1!==n.indexOf(e)&&a.push(t):"undefined"!=typeof(n=r.invalidChars)&&-1===n.indexOf(e)&&a.push(t);return a}};var g=Object.create||function(e){function t(){}return t.prototype=e,new t};h.prototype=g({splice:Array.prototype.splice,slice:Array.prototype.slice,push:Array.prototype.push,length:0,queryParams:null});var y=function(){this.rootState=new u,this.names={}};y.prototype={add:function(e,t){for(var r,n=this.rootState,i="^",a={statics:0,dynamics:0,stars:0},u=[],l=[],c=!0,h=0,m=e.length;m>h;h++){var f=e[h],d=[],v=o(f.path,d,a);l=l.concat(v);for(var b=0,g=v.length;g>b;b++){var y=v[b];y instanceof s||(c=!1,n=n.put({validChars:"/"}),i+="/",n=p(n,y),i+=y.regex())}var _={handler:f.handler,names:d};u.push(_)}c&&(n=n.put({validChars:"/"}),i+="/"),n.handlers=u,n.regex=new RegExp(i+"$"),n.types=a,(r=t&&t.as)&&(this.names[r]={segments:l,handlers:u})},handlersFor:function(e){var t=this.names[e],r=[];if(!t)throw new Error("There is no route named "+e);for(var n=0,i=t.handlers.length;i>n;n++)r.push(t.handlers[n]);return r},hasRoute:function(e){return!!this.names[e]},generate:function(e,t){var r=this.names[e],n="";if(!r)throw new Error("There is no route named "+e);for(var i=r.segments,a=0,o=i.length;o>a;a++){var u=i[a];u instanceof s||(n+="/",n+=u.generate(t))}return"/"!==n.charAt(0)&&(n="/"+n),t&&t.queryParams&&(n+=this.generateQueryString(t.queryParams,r.handlers)),n},generateQueryString:function(e){var t=[],n=[];for(var i in e)e.hasOwnProperty(i)&&n.push(i);n.sort();for(var a=0,s=n.length;s>a;a++){i=n[a];var o=e[i];if(null!=o){var u=encodeURIComponent(i);if(r(o))for(var l=0,c=o.length;c>l;l++){var h=i+"[]="+encodeURIComponent(o[l]);t.push(h)}else u+="="+encodeURIComponent(o),t.push(u)}}return 0===t.length?"":"?"+t.join("&")},parseQueryString:function(e){for(var t=e.split("&"),r={},n=0;n2&&"[]"===s.slice(o-2)&&(u=!0,s=s.slice(0,o-2),r[s]||(r[s]=[])),i=a[1]?f(a[1]):""),u?r[s].push(i):r[s]=i}return r},recognize:function(e){var t,r,n,i,a=[this.rootState],s={},o=!1;if(i=e.indexOf("?"),-1!==i){var u=e.substr(i+1,e.length);e=e.substr(0,i),s=this.parseQueryString(u)}for(e=decodeURI(e),"/"!==e.charAt(0)&&(e="/"+e),t=e.length,t>1&&"/"===e.charAt(t-1)&&(e=e.substr(0,t-1),o=!0),r=0,n=e.length;n>r&&(a=c(a,e.charAt(r)),a.length);r++);var h=[];for(r=0,n=a.length;n>r;r++)a[r].handlers&&h.push(a[r]);a=l(h);var p=h[0];return p&&p.handlers?(o&&"(.+)$"===p.regex.source.slice(-5)&&(e+="/"),m(p,e,s)):void 0}},y.prototype.map=d,y.VERSION="1.10.0",t["default"]=y}),e("route-recognizer.umd",["./route-recognizer"],function(t){"use strict";var r=t["default"];"function"==typeof e&&e.amd?e(function(){return r}):"undefined"!=typeof module&&module.exports?module.exports=r:"undefined"!=typeof this&&(this.RouteRecognizer=r)}),e("route-recognizer/dsl",["exports"],function(e){"use strict";function t(e,t,r){this.path=e,this.matcher=t,this.delegate=r}function r(e){this.routes={},this.children={},this.target=e}function n(e,r,i){return function(a,s){var o=e+a;return s?void s(n(o,r,i)):new t(e+a,r,i)}}function i(e,t,r){for(var n=0,i=0,a=e.length;a>i;i++)n+=e[i].path.length;t=t.substr(n);var s={path:t,handler:r};e.push(s)}function a(e,t,r,n){var s=t.routes;for(var o in s)if(s.hasOwnProperty(o)){var u=e.slice();i(u,o,s[o]),t.children[o]?a(u,t.children[o],r,n):r.call(n,u)}}t.prototype={to:function(e,t){var r=this.delegate;if(r&&r.willAddRoute&&(e=r.willAddRoute(this.matcher.target,e)),this.matcher.add(this.path,e),t){if(0===t.length)throw new Error("You must have an argument in the function passed to `to`");this.matcher.addChild(this.path,e,t,this.delegate)}return this}},r.prototype={add:function(e,t){this.routes[e]=t},addChild:function(e,t,i,a){var s=new r(t);this.children[e]=s;var o=n(e,s,a);a&&a.contextEntered&&a.contextEntered(t,o),i(o)}},e["default"]=function(e,t){var i=new r;e(n("",i,this.delegate)),a([],i,function(e){t?t(this,e):this.add(e)},this)}}),e("router",["./router/router","exports"],function(e,t){"use strict";var r=e["default"];t["default"]=r}),e("router/handler-info",["./utils","rsvp/promise","exports"],function(e,t,r){"use strict";function n(e){var t=e||{};s(this,t),this.initialize(t)}function i(e,t){if(!e^!t)return!1;if(!e)return!0;for(var r in e)if(e.hasOwnProperty(r)&&e[r]!==t[r])return!1;return!0}var a=e.bind,s=e.merge,o=(e.serialize,e.promiseLabel),u=e.applyHook,l=t["default"];n.prototype={name:null,handler:null,params:null,context:null,factory:null,initialize:function(){},log:function(e,t){e.log&&e.log(this.name+": "+t)},promiseLabel:function(e){return o("'"+this.name+"' "+e)},getUnresolved:function(){return this},serialize:function(){return this.params||{}},resolve:function(e,t){var r=a(this,this.checkForAbort,e),n=a(this,this.runBeforeModelHook,t),i=a(this,this.getModel,t),s=a(this,this.runAfterModelHook,t),o=a(this,this.becomeResolved,t);return l.resolve(void 0,this.promiseLabel("Start handler")).then(r,null,this.promiseLabel("Check for abort")).then(n,null,this.promiseLabel("Before model")).then(r,null,this.promiseLabel("Check if aborted during 'beforeModel' hook")).then(i,null,this.promiseLabel("Model")).then(r,null,this.promiseLabel("Check if aborted in 'model' hook")).then(s,null,this.promiseLabel("After model")).then(r,null,this.promiseLabel("Check if aborted in 'afterModel' hook")).then(o,null,this.promiseLabel("Become resolved"))},runBeforeModelHook:function(e){return e.trigger&&e.trigger(!0,"willResolveModel",e,this.handler),this.runSharedModelHook(e,"beforeModel",[])},runAfterModelHook:function(e,t){var r=this.name;return this.stashResolvedModel(e,t),this.runSharedModelHook(e,"afterModel",[t]).then(function(){return e.resolvedModels[r]},null,this.promiseLabel("Ignore fulfillment value and return model value"))},runSharedModelHook:function(e,t,r){this.log(e,"calling "+t+" hook"),this.queryParams&&r.push(this.queryParams),r.push(e);var n=u(this.handler,t,r);return n&&n.isTransition&&(n=null),l.resolve(n,this.promiseLabel("Resolve value returned from one of the model hooks"))},getModel:null,checkForAbort:function(e,t){return l.resolve(e(),this.promiseLabel("Check for abort")).then(function(){return t},null,this.promiseLabel("Ignore fulfillment value and continue"))},stashResolvedModel:function(e,t){e.resolvedModels=e.resolvedModels||{},e.resolvedModels[this.name]=t},becomeResolved:function(e,t){var r=this.serialize(t);return e&&(this.stashResolvedModel(e,t),e.params=e.params||{},e.params[this.name]=r),this.factory("resolved",{context:t,name:this.name,handler:this.handler,params:r})},shouldSupercede:function(e){if(!e)return!0;var t=e.context===this.context;return e.name!==this.name||this.hasOwnProperty("context")&&!t||this.hasOwnProperty("params")&&!i(this.params,e.params)}},r["default"]=n}),e("router/handler-info/factory",["router/handler-info/resolved-handler-info","router/handler-info/unresolved-handler-info-by-object","router/handler-info/unresolved-handler-info-by-param","exports"],function(e,t,r,n){"use strict";function i(e,t){var r=i.klasses[e],n=new r(t||{});return n.factory=i,n}var a=e["default"],s=t["default"],o=r["default"];i.klasses={resolved:a,param:o,object:s},n["default"]=i}),e("router/handler-info/resolved-handler-info",["../handler-info","router/utils","rsvp/promise","exports"],function(e,t,r,n){"use strict";var i=e["default"],a=t.subclass,s=(t.promiseLabel,r["default"]),o=a(i,{resolve:function(e,t){return t&&t.resolvedModels&&(t.resolvedModels[this.name]=this.context),s.resolve(this,this.promiseLabel("Resolve"))},getUnresolved:function(){return this.factory("param",{name:this.name,handler:this.handler,params:this.params})},isResolved:!0});n["default"]=o}),e("router/handler-info/unresolved-handler-info-by-object",["../handler-info","router/utils","rsvp/promise","exports"],function(e,t,r,n){"use strict";var i=e["default"],a=(t.merge,t.subclass),s=(t.promiseLabel,t.isParam),o=r["default"],u=a(i,{getModel:function(e){return this.log(e,this.name+": resolving provided model"),o.resolve(this.context)},initialize:function(e){this.names=e.names||[],this.context=e.context},serialize:function(e){var t=e||this.context,r=this.names,n=this.handler,i={};if(s(t))return i[r[0]]=t,i;if(n.serialize)return n.serialize(t,r);if(1===r.length){var a=r[0];return i[a]=/_id$/.test(a)?t.id:t,i}}});n["default"]=u}),e("router/handler-info/unresolved-handler-info-by-param",["../handler-info","router/utils","exports"],function(e,t,r){"use strict";var n=e["default"],i=t.resolveHook,a=t.merge,s=t.subclass,o=(t.promiseLabel,s(n,{initialize:function(e){this.params=e.params||{}},getModel:function(e){var t=this.params;e&&e.queryParams&&(t={},a(t,this.params),t.queryParams=e.queryParams);var r=this.handler,n=i(r,"deserialize")||i(r,"model");return this.runSharedModelHook(e,n,[t])}}));r["default"]=o}),e("router/router",["route-recognizer","rsvp/promise","./utils","./transition-state","./transition","./transition-intent/named-transition-intent","./transition-intent/url-transition-intent","./handler-info","exports"],function(e,t,r,n,i,a,s,o,u){"use strict";function l(){this.recognizer=new w,this.reset()}function c(e,t){var r,n=!!this.activeTransition,i=n?this.activeTransition.state:this.state,a=e.applyToState(i,this.recognizer,this.getHandler,t),s=S(i.queryParams,a.queryParams);return g(a.handlerInfos,i.handlerInfos)?s&&(r=this.queryParamsTransition(s,n,i,a))?r:new j(this):t?void m(this,a):(r=new j(this,e,a),this.activeTransition&&this.activeTransition.abort(),this.activeTransition=r,r.promise=r.promise.then(function(e){return v(r,e.state)},null,T("Settle transition promise when transition is finalized")),n||_(this,a,r),h(this,a,s),r)}function h(e,t,r){r&&(e._changedQueryParams=r.all,C(e,t.handlerInfos,!0,["queryParamsDidChange",r.changed,r.all,r.removed]),e._changedQueryParams=null)}function m(e,t,r){var n=f(e.state,t);P(n.exited,function(e){var t=e.handler;delete t.context,k(t,"reset",!0,r),k(t,"exit",r)});var i=e.oldState=e.state;e.state=t;var a=e.currentHandlerInfos=n.unchanged.slice();try{P(n.reset,function(e){var t=e.handler;k(t,"reset",!1,r)}),P(n.updatedContext,function(e){return p(a,e,!1,r)}),P(n.entered,function(e){return p(a,e,!0,r)})}catch(s){throw e.state=i,e.currentHandlerInfos=i.handlerInfos,s}e.state.queryParams=y(e,a,t.queryParams,r)}function p(e,t,r,n){var i=t.handler,a=t.context;if(r&&k(i,"enter",n),n&&n.isAborted)throw new M;if(i.context=a,k(i,"contextDidChange"),k(i,"setup",a,n),n&&n.isAborted)throw new M;return e.push(t),!0}function f(e,t){var r,n,i,a=e.handlerInfos,s=t.handlerInfos,o={updatedContext:[],exited:[],entered:[],unchanged:[]},u=!1;for(n=0,i=s.length;i>n;n++){var l=a[n],c=s[n];l&&l.handler===c.handler||(r=!0),r?(o.entered.push(c),l&&o.exited.unshift(l)):u||l.context!==c.context?(u=!0,o.updatedContext.push(c)):o.unchanged.push(l)}for(n=s.length,i=a.length;i>n;n++)o.exited.unshift(a[n]);return o.reset=o.updatedContext.slice(),o.reset.reverse(),o}function d(e,t){var r=e.urlMethod;if(r){for(var n=e.router,i=t.handlerInfos,a=i[i.length-1].name,s={},o=i.length-1;o>=0;--o){var u=i[o];A(s,u.params),u.handler.inaccessibleByURL&&(r=null)}if(r){s.queryParams=e._visibleQueryParams||t.queryParams;
-var l=n.recognizer.generate(a,s);"replace"===r?n.replaceURL(l):n.updateURL(l)}}}function v(e,t){try{E(e.router,e.sequence,"Resolved all models on destination route; finalizing transition.");{var r=e.router,n=t.handlerInfos;e.sequence}return m(r,t,e),e.isAborted?(r.state.handlerInfos=r.currentHandlerInfos,x.reject(I(e))):(d(e,t,e.intent.url),e.isActive=!1,r.activeTransition=null,C(r,r.currentHandlerInfos,!0,["didTransition"]),r.didTransition&&r.didTransition(r.currentHandlerInfos),E(r,e.sequence,"TRANSITION COMPLETE."),n[n.length-1].handler)}catch(i){if(!(i instanceof M)){var a=e.state.handlerInfos;e.trigger(!0,"error",i,e,a[a.length-1].handler),e.abort()}throw i}}function b(e,t,r){var n=t[0]||"/",i=t[t.length-1],a={};i&&i.hasOwnProperty("queryParams")&&(a=L.call(t).queryParams);var s;if(0===t.length){E(e,"Updating query params");var o=e.state.handlerInfos;s=new R({name:o[o.length-1].name,contexts:[],queryParams:a})}else"/"===n.charAt(0)?(E(e,"Attempting URL transition to "+n),s=new D({url:n})):(E(e,"Attempting transition to "+n),s=new R({name:t[0],contexts:O.call(t,1),queryParams:a}));return e.transitionByIntent(s,r)}function g(e,t){if(e.length!==t.length)return!1;for(var r=0,n=e.length;n>r;++r)if(e[r]!==t[r])return!1;return!0}function y(e,t,r,n){for(var i in r)r.hasOwnProperty(i)&&null===r[i]&&delete r[i];var a=[];C(e,t,!0,["finalizeQueryParamChange",r,a,n]),n&&(n._visibleQueryParams={});for(var s={},o=0,u=a.length;u>o;++o){var l=a[o];s[l.key]=l.value,n&&l.visible!==!1&&(n._visibleQueryParams[l.key]=l.value)}return s}function _(e,t,r){var n,i,a,s,o,u,l=e.state.handlerInfos,c=[],h=null;for(s=l.length,a=0;s>a;a++){if(o=l[a],u=t.handlerInfos[a],!u||o.name!==u.name){h=a;break}u.isResolved||c.push(o)}null!==h&&(n=l.slice(h,s),i=function(e){for(var t=0,r=n.length;r>t;t++)if(n[t].name===e)return!0;return!1},e._triggerWillLeave(n,r,i)),c.length>0&&e._triggerWillChangeContext(c,r),C(e,l,!0,["willTransition",r])}var w=e["default"],x=t["default"],C=r.trigger,E=r.log,O=r.slice,P=r.forEach,A=r.merge,N=(r.serialize,r.extractQueryParams),S=r.getChangelist,T=r.promiseLabel,k=r.callHook,V=n["default"],I=i.logAbort,j=i.Transition,M=i.TransitionAborted,R=a["default"],D=s["default"],L=(o.ResolvedHandlerInfo,Array.prototype.pop);l.prototype={map:function(e){this.recognizer.delegate=this.delegate,this.recognizer.map(e,function(e,t){for(var r=t.length-1,n=!0;r>=0&&n;--r){var i=t[r];e.add(t,{as:i.handler}),n="/"===i.path||""===i.path||".index"===i.handler.slice(-6)}})},hasRoute:function(e){return this.recognizer.hasRoute(e)},queryParamsTransition:function(e,t,r,n){var i=this;if(h(this,n,e),!t&&this.activeTransition)return this.activeTransition;var a=new j(this);return a.queryParamsOnly=!0,r.queryParams=y(this,n.handlerInfos,n.queryParams,a),a.promise=a.promise.then(function(e){return d(a,r,!0),i.didTransition&&i.didTransition(i.currentHandlerInfos),e},null,T("Transition complete")),a},transitionByIntent:function(e){try{return c.apply(this,arguments)}catch(t){return new j(this,e,null,t)}},reset:function(){this.state&&P(this.state.handlerInfos.slice().reverse(),function(e){var t=e.handler;k(t,"exit")}),this.state=new V,this.currentHandlerInfos=null},activeTransition:null,handleURL:function(e){var t=O.call(arguments);return"/"!==e.charAt(0)&&(t[0]="/"+e),b(this,t).method(null)},updateURL:function(){throw new Error("updateURL is not implemented")},replaceURL:function(e){this.updateURL(e)},transitionTo:function(){return b(this,arguments)},intermediateTransitionTo:function(){return b(this,arguments,!0)},refresh:function(e){for(var t=this.activeTransition?this.activeTransition.state:this.state,r=t.handlerInfos,n={},i=0,a=r.length;a>i;++i){var s=r[i];n[s.name]=s.params||{}}E(this,"Starting a refresh transition");var o=new R({name:r[r.length-1].name,pivotHandler:e||r[0].handler,contexts:[],queryParams:this._changedQueryParams||t.queryParams||{}});return this.transitionByIntent(o,!1)},replaceWith:function(){return b(this,arguments).method("replace")},generate:function(e){for(var t=N(O.call(arguments,1)),r=t[0],n=t[1],i=new R({name:e,contexts:r}),a=i.applyToState(this.state,this.recognizer,this.getHandler),s={},o=0,u=a.handlerInfos.length;u>o;++o){var l=a.handlerInfos[o],c=l.serialize();A(s,c)}return s.queryParams=n,this.recognizer.generate(e,s)},applyIntent:function(e,t){var r=new R({name:e,contexts:t}),n=this.activeTransition&&this.activeTransition.state||this.state;return r.applyToState(n,this.recognizer,this.getHandler)},isActiveIntent:function(e,t,r){var n,i,a=this.state.handlerInfos;if(!a.length)return!1;var s=a[a.length-1].name,o=this.recognizer.handlersFor(s),u=0;for(i=o.length;i>u&&(n=a[u],n.name!==e);++u);if(u===o.length)return!1;var l=new V;l.handlerInfos=a.slice(0,u+1),o=o.slice(0,u+1);var c=new R({name:s,contexts:t}),h=c.applyToHandlers(l,o,this.getHandler,s,!0,!0),m=g(h.handlerInfos,l.handlerInfos);if(!r||!m)return m;var p={};A(p,r);var f=this.state.queryParams;for(var d in f)f.hasOwnProperty(d)&&p.hasOwnProperty(d)&&(p[d]=f[d]);return m&&!S(p,r)},isActive:function(e){var t=N(O.call(arguments,1));return this.isActiveIntent(e,t[0],t[1])},trigger:function(){var e=O.call(arguments);C(this,this.currentHandlerInfos,!1,e)},log:null,_willChangeContextEvent:"willChangeContext",_triggerWillChangeContext:function(e,t){C(this,e,!0,[this._willChangeContextEvent,t])},_triggerWillLeave:function(e,t,r){C(this,e,!0,["willLeave",t,r])}},u["default"]=l}),e("router/transition-intent",["./utils","exports"],function(e,t){"use strict";function r(e){this.initialize(e),this.data=this.data||{}}e.merge;r.prototype={initialize:null,applyToState:null},t["default"]=r}),e("router/transition-intent/named-transition-intent",["../transition-intent","../transition-state","../handler-info/factory","../utils","exports"],function(e,t,r,n,i){"use strict";var a=e["default"],s=t["default"],o=r["default"],u=n.isParam,l=n.extractQueryParams,c=n.merge,h=n.subclass;i["default"]=h(a,{name:null,pivotHandler:null,contexts:null,queryParams:null,initialize:function(e){this.name=e.name,this.pivotHandler=e.pivotHandler,this.contexts=e.contexts||[],this.queryParams=e.queryParams},applyToState:function(e,t,r,n){var i=l([this.name].concat(this.contexts)),a=i[0],s=(i[1],t.handlersFor(a[0])),o=s[s.length-1].handler;return this.applyToHandlers(e,s,r,o,n)},applyToHandlers:function(e,t,r,n,i,a){var o,u,l=new s,h=this.contexts.slice(0),m=t.length;if(this.pivotHandler)for(o=0,u=t.length;u>o;++o)if(r(t[o].handler)===this.pivotHandler){m=o;break}!this.pivotHandler;for(o=t.length-1;o>=0;--o){var p=t[o],f=p.handler,d=r(f),v=e.handlerInfos[o],b=null;if(b=p.names.length>0?o>=m?this.createParamHandlerInfo(f,d,p.names,h,v):this.getHandlerInfoForDynamicSegment(f,d,p.names,h,v,n,o):this.createParamHandlerInfo(f,d,p.names,h,v),a){b=b.becomeResolved(null,b.context);var g=v&&v.context;p.names.length>0&&b.context===g&&(b.params=v&&v.params),b.context=g}var y=v;(o>=m||b.shouldSupercede(v))&&(m=Math.min(o,m),y=b),i&&!a&&(y=y.becomeResolved(null,y.context)),l.handlerInfos.unshift(y)}if(h.length>0)throw new Error("More context objects were passed than there are dynamic segments for the route: "+n);return i||this.invalidateChildren(l.handlerInfos,m),c(l.queryParams,this.queryParams||{}),l},invalidateChildren:function(e,t){for(var r=t,n=e.length;n>r;++r){{e[r]}e[r]=e[r].getUnresolved()}},getHandlerInfoForDynamicSegment:function(e,t,r,n,i,a,s){{var l;r.length}if(n.length>0){if(l=n[n.length-1],u(l))return this.createParamHandlerInfo(e,t,r,n,i);n.pop()}else{if(i&&i.name===e)return i;if(!this.preTransitionState)return i;var c=this.preTransitionState.handlerInfos[s];l=c&&c.context}return o("object",{name:e,handler:t,context:l,names:r})},createParamHandlerInfo:function(e,t,r,n,i){for(var a={},s=r.length;s--;){var l=i&&e===i.name&&i.params||{},c=n[n.length-1],h=r[s];if(u(c))a[h]=""+n.pop();else{if(!l.hasOwnProperty(h))throw new Error("You didn't provide enough string/numeric parameters to satisfy all of the dynamic segments for route "+e);a[h]=l[h]}}return o("param",{name:e,handler:t,params:a})}})}),e("router/transition-intent/url-transition-intent",["../transition-intent","../transition-state","../handler-info/factory","../utils","exports"],function(e,t,r,n,i){"use strict";function a(e){this.message=e||"UnrecognizedURLError",this.name="UnrecognizedURLError"}var s=e["default"],o=t["default"],u=r["default"],l=(n.oCreate,n.merge),c=n.subclass;i["default"]=c(s,{url:null,initialize:function(e){this.url=e.url},applyToState:function(e,t,r){var n,i,s=new o,c=t.recognize(this.url);if(!c)throw new a(this.url);var h=!1;for(n=0,i=c.length;i>n;++n){var m=c[n],p=m.handler,f=r(p);if(f.inaccessibleByURL)throw new a(this.url);var d=u("param",{name:p,handler:f,params:m.params}),v=e.handlerInfos[n];h||d.shouldSupercede(v)?(h=!0,s.handlerInfos[n]=d):s.handlerInfos[n]=v}return l(s.queryParams,c.queryParams),s}})}),e("router/transition-state",["./handler-info","./utils","rsvp/promise","exports"],function(e,t,r,n){"use strict";function i(){this.handlerInfos=[],this.queryParams={},this.params={}}var a=(e.ResolvedHandlerInfo,t.forEach),s=t.promiseLabel,o=t.callHook,u=r["default"];i.prototype={handlerInfos:null,queryParams:null,params:null,promiseLabel:function(e){var t="";return a(this.handlerInfos,function(e){""!==t&&(t+="."),t+=e.name}),s("'"+t+"': "+e)},resolve:function(e,t){function r(){return u.resolve(e(),c.promiseLabel("Check if should continue"))["catch"](function(e){return h=!0,u.reject(e)},c.promiseLabel("Handle abort"))}function n(e){var r=c.handlerInfos,n=t.resolveIndex>=r.length?r.length-1:t.resolveIndex;return u.reject({error:e,handlerWithError:c.handlerInfos[n].handler,wasAborted:h,state:c})}function i(e){var n=c.handlerInfos[t.resolveIndex].isResolved;if(c.handlerInfos[t.resolveIndex++]=e,!n){var i=e.handler;o(i,"redirect",e.context,t)}return r().then(s,null,c.promiseLabel("Resolve handler"))}function s(){if(t.resolveIndex===c.handlerInfos.length)return{error:null,state:c};var e=c.handlerInfos[t.resolveIndex];return e.resolve(r,t).then(i,null,c.promiseLabel("Proceed"))}var l=this.params;a(this.handlerInfos,function(e){l[e.name]=e.params||{}}),t=t||{},t.resolveIndex=0;var c=this,h=!1;return u.resolve(null,this.promiseLabel("Start transition")).then(s,null,this.promiseLabel("Resolve handler"))["catch"](n,this.promiseLabel("Handle error"))}},n["default"]=i}),e("router/transition",["rsvp/promise","./handler-info","./utils","exports"],function(e,t,r,n){"use strict";function i(e,t,r,n){function s(){return u.isAborted?o.reject(void 0,h("Transition aborted - reject")):void 0}var u=this;if(this.state=r||e.state,this.intent=t,this.router=e,this.data=this.intent&&this.intent.data||{},this.resolvedModels={},this.queryParams={},n)return this.promise=o.reject(n),void(this.error=n);if(r){this.params=r.params,this.queryParams=r.queryParams,this.handlerInfos=r.handlerInfos;var l=r.handlerInfos.length;l&&(this.targetName=r.handlerInfos[l-1].name);for(var c=0;l>c;++c){var m=r.handlerInfos[c];if(!m.isResolved)break;this.pivotHandler=m.handler}this.sequence=i.currentSequence++,this.promise=r.resolve(s,this)["catch"](function(e){return e.wasAborted||u.isAborted?o.reject(a(u)):(u.trigger("error",e.error,u,e.handlerWithError),u.abort(),o.reject(e.error))},h("Handle Abort"))}else this.promise=o.resolve(this.state),this.params={}}function a(e){return c(e.router,e.sequence,"detected abort."),new s}function s(e){this.message=e||"TransitionAborted",this.name="TransitionAborted"}var o=e["default"],u=(t.ResolvedHandlerInfo,r.trigger),l=r.slice,c=r.log,h=r.promiseLabel;i.currentSequence=0,i.prototype={targetName:null,urlMethod:"update",intent:null,params:null,pivotHandler:null,resolveIndex:0,handlerInfos:null,resolvedModels:null,isActive:!0,state:null,queryParamsOnly:!1,isTransition:!0,isExiting:function(e){for(var t=this.handlerInfos,r=0,n=t.length;n>r;++r){var i=t[r];if(i.name===e||i.handler===e)return!1}return!0},promise:null,data:null,then:function(e,t,r){return this.promise.then(e,t,r)},"catch":function(e,t){return this.promise["catch"](e,t)},"finally":function(e,t){return this.promise["finally"](e,t)},abort:function(){return this.isAborted?this:(c(this.router,this.sequence,this.targetName+": transition was aborted"),this.intent.preTransitionState=this.router.state,this.isAborted=!0,this.isActive=!1,this.router.activeTransition=null,this)},retry:function(){return this.abort(),this.router.transitionByIntent(this.intent,!1)},method:function(e){return this.urlMethod=e,this},trigger:function(e){var t=l.call(arguments);"boolean"==typeof e?t.shift():e=!1,u(this.router,this.state.handlerInfos.slice(0,this.resolveIndex+1),e,t)},followRedirects:function(){var e=this.router;return this.promise["catch"](function(t){return e.activeTransition?e.activeTransition.followRedirects():o.reject(t)})},toString:function(){return"Transition (sequence "+this.sequence+")"},log:function(e){c(this.router,this.sequence,e)}},i.prototype.send=i.prototype.trigger,n.Transition=i,n.logAbort=a,n.TransitionAborted=s}),e("router/utils",["exports"],function(e){"use strict";function t(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])}function r(e){var t,r,n=e&&e.length;return n&&n>0&&e[n-1]&&e[n-1].hasOwnProperty("queryParams")?(r=e[n-1].queryParams,t=v.call(e,0,n-1),[t,r]):[e,null]}function n(e){for(var t in e)if("number"==typeof e[t])e[t]=""+e[t];else if(b(e[t]))for(var r=0,n=e[t].length;n>r;r++)e[t][r]=""+e[t][r]}function i(e,t,r){e.log&&(3===arguments.length?e.log("Transition #"+t+": "+r):(r=t,e.log(r)))}function a(e,t){var r=arguments;return function(n){var i=v.call(r,2);return i.push(n),t.apply(e,i)}}function s(e){return"string"==typeof e||e instanceof String||"number"==typeof e||e instanceof Number}function o(e,t){for(var r=0,n=e.length;n>r&&!1!==t(e[r]);r++);}function u(e,t,r,n){if(e.triggerEvent)return void e.triggerEvent(t,r,n);var i=n.shift();if(!t){if(r)return;throw new Error("Could not trigger event '"+i+"'. There are no active handlers")}for(var a=!1,s=t.length-1;s>=0;s--){var o=t[s],u=o.handler;if(u.events&&u.events[i]){if(u.events[i].apply(u,n)!==!0)return;a=!0}}if(!a&&!r)throw new Error("Nothing handled the event '"+i+"'.")}function l(e,r){var i,a={all:{},changed:{},removed:{}};t(a.all,r);var s=!1;n(e),n(r);for(i in e)e.hasOwnProperty(i)&&(r.hasOwnProperty(i)||(s=!0,a.removed[i]=e[i]));for(i in r)if(r.hasOwnProperty(i))if(b(e[i])&&b(r[i]))if(e[i].length!==r[i].length)a.changed[i]=r[i],s=!0;else for(var o=0,u=e[i].length;u>o;o++)e[i][o]!==r[i][o]&&(a.changed[i]=r[i],s=!0);else e[i]!==r[i]&&(a.changed[i]=r[i],s=!0);return s&&a}function c(e){return"Router: "+e}function h(e,r){function n(t){e.call(this,t||{})}return n.prototype=g(e.prototype),t(n.prototype,r),n}function m(e,t){if(e){var r="_"+t;return e[r]&&r||e[t]&&t}}function p(e,t){var r=v.call(arguments,2);return f(e,t,r)}function f(e,t,r){var n=m(e,t);return n?e[n].apply(e,r):void 0}var d,v=Array.prototype.slice;d=Array.isArray?Array.isArray:function(e){return"[object Array]"===Object.prototype.toString.call(e)};var b=d;e.isArray=b;var g=Object.create||function(e){function t(){}return t.prototype=e,new t};e.oCreate=g,e.extractQueryParams=r,e.log=i,e.bind=a,e.forEach=o,e.trigger=u,e.getChangelist=l,e.promiseLabel=c,e.subclass=h,e.merge=t,e.slice=v,e.isParam=s,e.coerceQueryParamsToString=n,e.callHook=p,e.resolveHook=m,e.applyHook=f}),e("rsvp",["./rsvp/promise","./rsvp/events","./rsvp/node","./rsvp/all","./rsvp/all-settled","./rsvp/race","./rsvp/hash","./rsvp/hash-settled","./rsvp/rethrow","./rsvp/defer","./rsvp/config","./rsvp/map","./rsvp/resolve","./rsvp/reject","./rsvp/filter","./rsvp/asap","exports"],function(e,t,r,n,i,a,s,o,u,l,c,h,m,p,f,d,v){"use strict";function b(e,t){T.async(e,t)}function g(){T.on.apply(T,arguments)}function y(){T.off.apply(T,arguments)}var _=e["default"],w=t["default"],x=r["default"],C=n["default"],E=i["default"],O=a["default"],P=s["default"],A=o["default"],N=u["default"],S=l["default"],T=c.config,k=c.configure,V=h["default"],I=m["default"],j=p["default"],M=f["default"],R=d["default"];T.async=R;var D=I;if("undefined"!=typeof window&&"object"==typeof window.__PROMISE_INSTRUMENTATION__){var L=window.__PROMISE_INSTRUMENTATION__;k("instrument",!0);for(var F in L)L.hasOwnProperty(F)&&g(F,L[F])}v.cast=D,v.Promise=_,v.EventTarget=w,v.all=C,v.allSettled=E,v.race=O,v.hash=P,v.hashSettled=A,v.rethrow=N,v.defer=S,v.denodeify=x,v.configure=k,v.on=g,v.off=y,v.resolve=I,v.reject=j,v.async=b,v.map=V,v.filter=M}),e("rsvp.umd",["./rsvp"],function(t){"use strict";var r=t.Promise,n=t.allSettled,i=t.hash,a=t.hashSettled,s=t.denodeify,o=t.on,u=t.off,l=t.map,c=t.filter,h=t.resolve,m=t.reject,p=t.rethrow,f=t.all,d=t.defer,v=t.EventTarget,b=t.configure,g=t.race,y=t.async,_={race:g,Promise:r,allSettled:n,hash:i,hashSettled:a,denodeify:s,on:o,off:u,map:l,filter:c,resolve:h,reject:m,all:f,rethrow:p,defer:d,EventTarget:v,configure:b,async:y};"function"==typeof e&&e.amd?e(function(){return _}):"undefined"!=typeof module&&module.exports?module.exports=_:"undefined"!=typeof this&&(this.RSVP=_)}),e("rsvp/-internal",["./utils","./instrument","./config","exports"],function(e,t,r,n){"use strict";function i(){return new TypeError("A promises callback cannot return that same promise.")}function a(){}function s(e){try{return e.then}catch(t){return N.error=t,N}}function o(e,t,r,n){try{e.call(t,r,n)}catch(i){return i}}function u(e,t,r){E.async(function(e){var n=!1,i=o(r,t,function(r){n||(n=!0,t!==r?h(e,r):p(e,r))},function(t){n||(n=!0,f(e,t))},"Settle: "+(e._label||" unknown promise"));!n&&i&&(n=!0,f(e,i))},e)}function l(e,t){t._state===P?p(e,t._result):e._state===A?f(e,t._result):d(t,void 0,function(r){t!==r?h(e,r):p(e,r)},function(t){f(e,t)})}function c(e,t){if(t.constructor===e.constructor)l(e,t);else{var r=s(t);r===N?f(e,N.error):void 0===r?p(e,t):x(r)?u(e,t,r):p(e,t)}}function h(e,t){e===t?p(e,t):w(t)?c(e,t):p(e,t)}function m(e){e._onerror&&e._onerror(e._result),v(e)}function p(e,t){e._state===O&&(e._result=t,e._state=P,0===e._subscribers.length?E.instrument&&C("fulfilled",e):E.async(v,e))}function f(e,t){e._state===O&&(e._state=A,e._result=t,E.async(m,e))}function d(e,t,r,n){var i=e._subscribers,a=i.length;e._onerror=null,i[a]=t,i[a+P]=r,i[a+A]=n,0===a&&e._state&&E.async(v,e)}function v(e){var t=e._subscribers,r=e._state;if(E.instrument&&C(r===P?"fulfilled":"rejected",e),0!==t.length){for(var n,i,a=e._result,s=0;se;e+=2){var t=d[e],r=d[e+1];t(r),d[e]=void 0,d[e+1]=void 0}l=0}function u(){try{{var e=r("vertx");e.runOnLoop||e.runOnContext}return n()}catch(t){return s()}}var l=0;e["default"]=function(e,t){d[l]=e,d[l+1]=t,l+=2,2===l&&c()};var c,h="undefined"!=typeof window?window:void 0,m=h||{},p=m.MutationObserver||m.WebKitMutationObserver,f="undefined"!=typeof Uint8ClampedArray&&"undefined"!=typeof importScripts&&"undefined"!=typeof MessageChannel,d=new Array(1e3);c="undefined"!=typeof process&&"[object process]"==={}.toString.call(process)?t():p?i():f?a():void 0===h&&"function"==typeof r?u():s()}),e("rsvp/config",["./events","exports"],function(e,t){"use strict";function r(e,t){return"onerror"===e?void i.on("error",t):2!==arguments.length?i[e]:void(i[e]=t)}var n=e["default"],i={instrument:!1};n.mixin(i),t.config=i,t.configure=r}),e("rsvp/defer",["./promise","exports"],function(e,t){"use strict";var r=e["default"];t["default"]=function(e){var t={};return t.promise=new r(function(e,r){t.resolve=e,t.reject=r},e),t}}),e("rsvp/enumerator",["./utils","./-internal","exports"],function(e,t,r){"use strict";function n(e,t,r){return e===h?{state:"fulfilled",value:r}:{state:"rejected",reason:r}}function i(e,t,r,n){this._instanceConstructor=e,this.promise=new e(o,n),this._abortOnReject=r,this._validateInput(t)?(this._input=t,this.length=t.length,this._remaining=t.length,this._init(),0===this.length?l(this.promise,this._result):(this.length=this.length||0,this._enumerate(),0===this._remaining&&l(this.promise,this._result))):u(this.promise,this._validationError())}var a=e.isArray,s=e.isMaybeThenable,o=t.noop,u=t.reject,l=t.fulfill,c=t.subscribe,h=t.FULFILLED,m=t.REJECTED,p=t.PENDING;r.makeSettledResult=n,i.prototype._validateInput=function(e){return a(e)},i.prototype._validationError=function(){return new Error("Array Methods must be provided an Array")},i.prototype._init=function(){this._result=new Array(this.length)},r["default"]=i,i.prototype._enumerate=function(){for(var e=this.length,t=this.promise,r=this._input,n=0;t._state===p&&e>n;n++)this._eachEntry(r[n],n)},i.prototype._eachEntry=function(e,t){var r=this._instanceConstructor;s(e)?e.constructor===r&&e._state!==p?(e._onerror=null,this._settledAt(e._state,t,e._result)):this._willSettleAt(r.resolve(e),t):(this._remaining--,this._result[t]=this._makeResult(h,t,e))},i.prototype._settledAt=function(e,t,r){var n=this.promise;n._state===p&&(this._remaining--,this._abortOnReject&&e===m?u(n,r):this._result[t]=this._makeResult(e,t,r)),0===this._remaining&&l(n,this._result)},i.prototype._makeResult=function(e,t,r){return r},i.prototype._willSettleAt=function(e,t){var r=this;c(e,void 0,function(e){r._settledAt(h,t,e)},function(e){r._settledAt(m,t,e)})}}),e("rsvp/events",["exports"],function(e){"use strict";function t(e,t){for(var r=0,n=e.length;n>r;r++)if(e[r]===t)return r;return-1}function r(e){var t=e._promiseCallbacks;return t||(t=e._promiseCallbacks={}),t}e["default"]={mixin:function(e){return e.on=this.on,e.off=this.off,e.trigger=this.trigger,e._promiseCallbacks=void 0,e},on:function(e,n){var i,a=r(this);i=a[e],i||(i=a[e]=[]),-1===t(i,n)&&i.push(n)},off:function(e,n){var i,a,s=r(this);return n?(i=s[e],a=t(i,n),void(-1!==a&&i.splice(a,1))):void(s[e]=[])},trigger:function(e,t){var n,i,a=r(this);if(n=a[e])for(var s=0;so;o++)s[o]=t(e[o]);return n.all(s,r).then(function(t){for(var r=new Array(a),n=0,i=0;a>i;i++)t[i]&&(r[n]=e[i],n++);return r.length=n,r})})}}),e("rsvp/hash-settled",["./promise","./enumerator","./promise-hash","./utils","exports"],function(e,t,r,n,i){"use strict";function a(e,t,r){this._superConstructor(e,t,!1,r)}var s=e["default"],o=t.makeSettledResult,u=r["default"],l=t["default"],c=n.o_create;a.prototype=c(u.prototype),a.prototype._superConstructor=l,a.prototype._makeResult=o,a.prototype._validationError=function(){return new Error("hashSettled must be called with an object")},i["default"]=function(e,t){return new a(s,e,t).promise}}),e("rsvp/hash",["./promise","./promise-hash","exports"],function(e,t,r){"use strict";var n=e["default"],i=t["default"];r["default"]=function(e,t){return new i(n,e,t).promise}}),e("rsvp/instrument",["./config","./utils","exports"],function(e,t,r){"use strict";function n(){setTimeout(function(){for(var e,t=0;to;o++)s[o]=t(e[o]);return n.all(s,r)})}}),e("rsvp/node",["./promise","./-internal","./utils","exports"],function(e,t,r,n){"use strict";function i(){this.value=void 0}function a(e){try{return e.then}catch(t){return g.value=t,g}}function s(e,t,r){try{e.apply(t,r)}catch(n){return g.value=n,g}}function o(e,t){for(var r,n,i={},a=e.length,s=new Array(a),o=0;a>o;o++)s[o]=e[o];for(n=0;nn;n++)r[n-1]=e[n];return r}function l(e,t){return{then:function(r,n){return e.call(t,r,n)}}}function c(e,t,r,n){var i=s(r,n,t);return i===g&&v(e,i.value),e}function h(e,t,r,n){return p.all(t).then(function(t){var i=s(r,n,t);return i===g&&v(e,i.value),e})}function m(e){return e&&"object"==typeof e?e.constructor===p?!0:a(e):!1}var p=e["default"],f=t.noop,d=t.resolve,v=t.reject,b=r.isArray,g=new i,y=new i;n["default"]=function(e,t){var r=function(){for(var r,n=this,i=arguments.length,a=new Array(i+1),s=!1,g=0;i>g;++g){if(r=arguments[g],!s){if(s=m(r),s===y){var _=new p(f);return v(_,y.value),_}s&&s!==!0&&(r=l(s,r))}a[g]=r}var w=new p(f);return a[i]=function(e,r){e?v(w,e):void 0===t?d(w,r):t===!0?d(w,u(arguments)):b(t)?d(w,o(arguments,t)):d(w,r)},s?h(w,a,e,n):c(w,a,e,n)};return r.__proto__=e,r}}),e("rsvp/promise-hash",["./enumerator","./-internal","./utils","exports"],function(e,t,r,n){"use strict";function i(e,t,r){this._superConstructor(e,t,!0,r)}var a=e["default"],s=t.PENDING,o=r.o_create;n["default"]=i,i.prototype=o(a.prototype),i.prototype._superConstructor=a,i.prototype._init=function(){this._result={}},i.prototype._validateInput=function(e){return e&&"object"==typeof e},i.prototype._validationError=function(){return new Error("Promise.hash must be called with an object")},i.prototype._enumerate=function(){var e=this.promise,t=this._input,r=[];for(var n in t)e._state===s&&t.hasOwnProperty(n)&&r.push({position:n,entry:t[n]});var i=r.length;this._remaining=i;for(var a,o=0;e._state===s&&i>o;o++)a=r[o],this._eachEntry(a.entry,a.position)}}),e("rsvp/promise",["./config","./instrument","./utils","./-internal","./promise/all","./promise/race","./promise/resolve","./promise/reject","exports"],function(e,t,r,n,i,a,s,o,u){"use strict";function l(){throw new TypeError("You must pass a resolver function as the first argument to the promise constructor")}function c(){throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.")}function h(e,t){this._id=A++,this._label=t,this._state=void 0,this._result=void 0,this._subscribers=[],m.instrument&&p("created",this),v!==e&&(f(e)||l(),this instanceof h||c(),g(this,e))}var m=e.config,p=t["default"],f=r.isFunction,d=r.now,v=n.noop,b=n.subscribe,g=n.initializePromise,y=n.invokeCallback,_=n.FULFILLED,w=n.REJECTED,x=i["default"],C=a["default"],E=s["default"],O=o["default"],P="rsvp_"+d()+"-",A=0;u["default"]=h,h.cast=E,h.all=x,h.race=C,h.resolve=E,h.reject=O,h.prototype={constructor:h,_guidKey:P,_onerror:function(e){m.trigger("error",e)},then:function(e,t,r){var n=this,i=n._state;if(i===_&&!e||i===w&&!t)return m.instrument&&p("chained",this,this),this;n._onerror=null;var a=new this.constructor(v,r),s=n._result;if(m.instrument&&p("chained",n,a),i){var o=arguments[i-1];m.async(function(){y(i,a,o,s)})}else b(n,a,e,t);return a},"catch":function(e,t){return this.then(null,e,t)},"finally":function(e,t){var r=this.constructor;return this.then(function(t){return r.resolve(e()).then(function(){return t})},function(t){return r.resolve(e()).then(function(){throw t})},t)}}}),e("rsvp/promise/all",["../enumerator","exports"],function(e,t){"use strict";var r=e["default"];t["default"]=function(e,t){return new r(this,e,!0,t).promise}}),e("rsvp/promise/race",["../utils","../-internal","exports"],function(e,t,r){"use strict";var n=e.isArray,i=t.noop,a=t.resolve,s=t.reject,o=t.subscribe,u=t.PENDING;r["default"]=function(e,t){function r(e){a(h,e)}function l(e){s(h,e)}var c=this,h=new c(i,t);if(!n(e))return s(h,new TypeError("You must pass an array to race.")),h;for(var m=e.length,p=0;h._state===u&&m>p;p++)o(c.resolve(e[p]),void 0,r,l);return h}}),e("rsvp/promise/reject",["../-internal","exports"],function(e,t){"use strict";var r=e.noop,n=e.reject;t["default"]=function(e,t){var i=this,a=new i(r,t);return n(a,e),a}}),e("rsvp/promise/resolve",["../-internal","exports"],function(e,t){"use strict";var r=e.noop,n=e.resolve;t["default"]=function(e,t){var i=this;if(e&&"object"==typeof e&&e.constructor===i)return e;var a=new i(r,t);return n(a,e),a}}),e("rsvp/race",["./promise","exports"],function(e,t){"use strict";var r=e["default"];t["default"]=function(e,t){return r.race(e,t)}}),e("rsvp/reject",["./promise","exports"],function(e,t){"use strict";var r=e["default"];t["default"]=function(e,t){return r.reject(e,t)}}),e("rsvp/resolve",["./promise","exports"],function(e,t){"use strict";var r=e["default"];t["default"]=function(e,t){return r.resolve(e,t)}}),e("rsvp/rethrow",["exports"],function(e){"use strict";e["default"]=function(e){throw setTimeout(function(){throw e}),e}}),e("rsvp/utils",["exports"],function(e){"use strict";function t(e){return"function"==typeof e||"object"==typeof e&&null!==e}function r(e){return"function"==typeof e}function n(e){return"object"==typeof e&&null!==e}function i(){}e.objectOrFunction=t,e.isFunction=r,e.isMaybeThenable=n;var a;a=Array.isArray?Array.isArray:function(e){return"[object Array]"===Object.prototype.toString.call(e)};var s=a;e.isArray=s;var o=Date.now||function(){return(new Date).getTime()};e.now=o;var u=Object.create||function(e){if(arguments.length>1)throw new Error("Second argument not supported");if("object"!=typeof e)throw new TypeError("Argument must be an object");return i.prototype=e,new i};e.o_create=u}),t("ember")}();
\ No newline at end of file
diff --git a/website/source/assets/javascripts/lib/ember-data-1-0.js b/website/source/assets/javascripts/lib/ember-data-1-0.js
new file mode 100644
index 000000000..1a76339a1
--- /dev/null
+++ b/website/source/assets/javascripts/lib/ember-data-1-0.js
@@ -0,0 +1,13410 @@
+(function() {
+ "use strict";
+ var ember$data$lib$system$model$errors$invalid$$create = Ember.create;
+ var ember$data$lib$system$model$errors$invalid$$EmberError = Ember.Error;
+
+ /**
+ A `DS.InvalidError` is used by an adapter to signal the external API
+ was unable to process a request because the content was not
+ semantically correct or meaningful per the API. Usually this means a
+ record failed some form of server side validation. When a promise
+ from an adapter is rejected with a `DS.InvalidError` the record will
+ transition to the `invalid` state and the errors will be set to the
+ `errors` property on the record.
+
+ For Ember Data to correctly map errors to their corresponding
+ properties on the model, Ember Data expects each error to be
+ namespaced under a key that matches the property name. For example
+ if you had a Post model that looked like this.
+
+ ```app/models/post.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ title: DS.attr('string'),
+ content: DS.attr('string')
+ });
+ ```
+
+ To show an error from the server related to the `title` and
+ `content` properties your adapter could return a promise that
+ rejects with a `DS.InvalidError` object that looks like this:
+
+ ```app/adapters/post.js
+ import Ember from 'ember';
+ import DS from 'ember-data';
+
+ export default DS.RESTAdapter.extend({
+ updateRecord: function() {
+ // Fictional adapter that always rejects
+ return Ember.RSVP.reject(new DS.InvalidError({
+ title: ['Must be unique'],
+ content: ['Must not be blank'],
+ }));
+ }
+ });
+ ```
+
+ Your backend may use different property names for your records the
+ store will attempt extract and normalize the errors using the
+ serializer's `extractErrors` method before the errors get added to
+ the the model. As a result, it is safe for the `InvalidError` to
+ wrap the error payload unaltered.
+
+ Example
+
+ ```app/adapters/application.js
+ import Ember from 'ember';
+ import DS from 'ember-data';
+
+ export default DS.RESTAdapter.extend({
+ ajaxError: function(jqXHR) {
+ var error = this._super(jqXHR);
+
+ // 422 is used by this fictional server to signal a validation error
+ if (jqXHR && jqXHR.status === 422) {
+ var jsonErrors = Ember.$.parseJSON(jqXHR.responseText);
+ return new DS.InvalidError(jsonErrors);
+ } else {
+ // The ajax request failed however it is not a result of this
+ // record being in an invalid state so we do not return a
+ // `InvalidError` object.
+ return error;
+ }
+ }
+ });
+ ```
+
+ @class InvalidError
+ @namespace DS
+ */
+ function ember$data$lib$system$model$errors$invalid$$InvalidError(errors) {
+ ember$data$lib$system$model$errors$invalid$$EmberError.call(this, "The backend rejected the commit because it was invalid: " + Ember.inspect(errors));
+ this.errors = errors;
+ }
+
+ ember$data$lib$system$model$errors$invalid$$InvalidError.prototype = ember$data$lib$system$model$errors$invalid$$create(ember$data$lib$system$model$errors$invalid$$EmberError.prototype);
+
+ var ember$data$lib$system$model$errors$invalid$$default = ember$data$lib$system$model$errors$invalid$$InvalidError;
+
+ /**
+ @module ember-data
+ */
+
+ var ember$data$lib$system$adapter$$get = Ember.get;
+
+ /**
+ An adapter is an object that receives requests from a store and
+ translates them into the appropriate action to take against your
+ persistence layer. The persistence layer is usually an HTTP API, but
+ may be anything, such as the browser's local storage. Typically the
+ adapter is not invoked directly instead its functionality is accessed
+ through the `store`.
+
+ ### Creating an Adapter
+
+ Create a new subclass of `DS.Adapter` in the `app/adapters` folder:
+
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+
+ export default DS.Adapter.extend({
+ // ...your code here
+ });
+ ```
+
+ Model-specific adapters can be created by putting your adapter
+ class in an `app/adapters/` + `model-name` + `.js` file of the application.
+
+ ```app/adapters/post.js
+ import DS from 'ember-data';
+
+ export default DS.Adapter.extend({
+ // ...Post-specific adapter code goes here
+ });
+ ```
+
+ `DS.Adapter` is an abstract base class that you should override in your
+ application to customize it for your backend. The minimum set of methods
+ that you should implement is:
+
+ * `find()`
+ * `createRecord()`
+ * `updateRecord()`
+ * `deleteRecord()`
+ * `findAll()`
+ * `findQuery()`
+
+ To improve the network performance of your application, you can optimize
+ your adapter by overriding these lower-level methods:
+
+ * `findMany()`
+
+
+ For an example implementation, see `DS.RESTAdapter`, the
+ included REST adapter.
+
+ @class Adapter
+ @namespace DS
+ @extends Ember.Object
+ */
+
+ var ember$data$lib$system$adapter$$Adapter = Ember.Object.extend({
+
+ /**
+ If you would like your adapter to use a custom serializer you can
+ set the `defaultSerializer` property to be the name of the custom
+ serializer.
+ Note the `defaultSerializer` serializer has a lower priority than
+ a model specific serializer (i.e. `PostSerializer`) or the
+ `application` serializer.
+ ```app/adapters/django.js
+ import DS from 'ember-data';
+ export default DS.Adapter.extend({
+ defaultSerializer: 'django'
+ });
+ ```
+ @property defaultSerializer
+ @type {String}
+ */
+ defaultSerializer: '-default',
+
+ /**
+ The `find()` method is invoked when the store is asked for a record that
+ has not previously been loaded. In response to `find()` being called, you
+ should query your persistence layer for a record with the given ID. Once
+ found, you can asynchronously call the store's `push()` method to push
+ the record into the store.
+ Here is an example `find` implementation:
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+ export default DS.Adapter.extend({
+ find: function(store, type, id, snapshot) {
+ var url = [type.modelName, id].join('/');
+ return new Ember.RSVP.Promise(function(resolve, reject) {
+ jQuery.getJSON(url).then(function(data) {
+ Ember.run(null, resolve, data);
+ }, function(jqXHR) {
+ jqXHR.then = null; // tame jQuery's ill mannered promises
+ Ember.run(null, reject, jqXHR);
+ });
+ });
+ }
+ });
+ ```
+ @method find
+ @param {DS.Store} store
+ @param {DS.Model} type
+ @param {String} id
+ @param {DS.Snapshot} snapshot
+ @return {Promise} promise
+ */
+ find: null,
+
+ /**
+ The `findAll()` method is called when you call `find` on the store
+ without an ID (i.e. `store.find('post')`).
+ Example
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+ export default DS.Adapter.extend({
+ findAll: function(store, type, sinceToken) {
+ var url = type;
+ var query = { since: sinceToken };
+ return new Ember.RSVP.Promise(function(resolve, reject) {
+ jQuery.getJSON(url, query).then(function(data) {
+ Ember.run(null, resolve, data);
+ }, function(jqXHR) {
+ jqXHR.then = null; // tame jQuery's ill mannered promises
+ Ember.run(null, reject, jqXHR);
+ });
+ });
+ }
+ });
+ ```
+ @private
+ @method findAll
+ @param {DS.Store} store
+ @param {DS.Model} type
+ @param {String} sinceToken
+ @return {Promise} promise
+ */
+ findAll: null,
+
+ /**
+ This method is called when you call `find` on the store with a
+ query object as the second parameter (i.e. `store.find('person', {
+ page: 1 })`).
+ Example
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+ export default DS.Adapter.extend({
+ findQuery: function(store, type, query) {
+ var url = type;
+ return new Ember.RSVP.Promise(function(resolve, reject) {
+ jQuery.getJSON(url, query).then(function(data) {
+ Ember.run(null, resolve, data);
+ }, function(jqXHR) {
+ jqXHR.then = null; // tame jQuery's ill mannered promises
+ Ember.run(null, reject, jqXHR);
+ });
+ });
+ }
+ });
+ ```
+ @private
+ @method findQuery
+ @param {DS.Store} store
+ @param {DS.Model} type
+ @param {Object} query
+ @param {DS.AdapterPopulatedRecordArray} recordArray
+ @return {Promise} promise
+ */
+ findQuery: null,
+
+ /**
+ If the globally unique IDs for your records should be generated on the client,
+ implement the `generateIdForRecord()` method. This method will be invoked
+ each time you create a new record, and the value returned from it will be
+ assigned to the record's `primaryKey`.
+ Most traditional REST-like HTTP APIs will not use this method. Instead, the ID
+ of the record will be set by the server, and your adapter will update the store
+ with the new ID when it calls `didCreateRecord()`. Only implement this method if
+ you intend to generate record IDs on the client-side.
+ The `generateIdForRecord()` method will be invoked with the requesting store as
+ the first parameter and the newly created record as the second parameter:
+ ```javascript
+ generateIdForRecord: function(store, inputProperties) {
+ var uuid = App.generateUUIDWithStatisticallyLowOddsOfCollision();
+ return uuid;
+ }
+ ```
+ @method generateIdForRecord
+ @param {DS.Store} store
+ @param {DS.Model} type the DS.Model class of the record
+ @param {Object} inputProperties a hash of properties to set on the
+ newly created record.
+ @return {(String|Number)} id
+ */
+ generateIdForRecord: null,
+
+ /**
+ Proxies to the serializer's `serialize` method.
+ Example
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+ export default DS.Adapter.extend({
+ createRecord: function(store, type, snapshot) {
+ var data = this.serialize(snapshot, { includeId: true });
+ var url = type;
+ // ...
+ }
+ });
+ ```
+ @method serialize
+ @param {DS.Snapshot} snapshot
+ @param {Object} options
+ @return {Object} serialized snapshot
+ */
+ serialize: function (snapshot, options) {
+ return ember$data$lib$system$adapter$$get(snapshot.record, 'store').serializerFor(snapshot.modelName).serialize(snapshot, options);
+ },
+
+ /**
+ Implement this method in a subclass to handle the creation of
+ new records.
+ Serializes the record and send it to the server.
+ Example
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+ export default DS.Adapter.extend({
+ createRecord: function(store, type, snapshot) {
+ var data = this.serialize(snapshot, { includeId: true });
+ var url = type;
+ return new Ember.RSVP.Promise(function(resolve, reject) {
+ jQuery.ajax({
+ type: 'POST',
+ url: url,
+ dataType: 'json',
+ data: data
+ }).then(function(data) {
+ Ember.run(null, resolve, data);
+ }, function(jqXHR) {
+ jqXHR.then = null; // tame jQuery's ill mannered promises
+ Ember.run(null, reject, jqXHR);
+ });
+ });
+ }
+ });
+ ```
+ @method createRecord
+ @param {DS.Store} store
+ @param {DS.Model} type the DS.Model class of the record
+ @param {DS.Snapshot} snapshot
+ @return {Promise} promise
+ */
+ createRecord: null,
+
+ /**
+ Implement this method in a subclass to handle the updating of
+ a record.
+ Serializes the record update and send it to the server.
+ Example
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+ export default DS.Adapter.extend({
+ updateRecord: function(store, type, snapshot) {
+ var data = this.serialize(snapshot, { includeId: true });
+ var id = snapshot.id;
+ var url = [type, id].join('/');
+ return new Ember.RSVP.Promise(function(resolve, reject) {
+ jQuery.ajax({
+ type: 'PUT',
+ url: url,
+ dataType: 'json',
+ data: data
+ }).then(function(data) {
+ Ember.run(null, resolve, data);
+ }, function(jqXHR) {
+ jqXHR.then = null; // tame jQuery's ill mannered promises
+ Ember.run(null, reject, jqXHR);
+ });
+ });
+ }
+ });
+ ```
+ @method updateRecord
+ @param {DS.Store} store
+ @param {DS.Model} type the DS.Model class of the record
+ @param {DS.Snapshot} snapshot
+ @return {Promise} promise
+ */
+ updateRecord: null,
+
+ /**
+ Implement this method in a subclass to handle the deletion of
+ a record.
+ Sends a delete request for the record to the server.
+ Example
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+ export default DS.Adapter.extend({
+ deleteRecord: function(store, type, snapshot) {
+ var data = this.serialize(snapshot, { includeId: true });
+ var id = snapshot.id;
+ var url = [type, id].join('/');
+ return new Ember.RSVP.Promise(function(resolve, reject) {
+ jQuery.ajax({
+ type: 'DELETE',
+ url: url,
+ dataType: 'json',
+ data: data
+ }).then(function(data) {
+ Ember.run(null, resolve, data);
+ }, function(jqXHR) {
+ jqXHR.then = null; // tame jQuery's ill mannered promises
+ Ember.run(null, reject, jqXHR);
+ });
+ });
+ }
+ });
+ ```
+ @method deleteRecord
+ @param {DS.Store} store
+ @param {DS.Model} type the DS.Model class of the record
+ @param {DS.Snapshot} snapshot
+ @return {Promise} promise
+ */
+ deleteRecord: null,
+
+ /**
+ By default the store will try to coalesce all `fetchRecord` calls within the same runloop
+ into as few requests as possible by calling groupRecordsForFindMany and passing it into a findMany call.
+ You can opt out of this behaviour by either not implementing the findMany hook or by setting
+ coalesceFindRequests to false
+ @property coalesceFindRequests
+ @type {boolean}
+ */
+ coalesceFindRequests: true,
+
+ /**
+ Find multiple records at once if coalesceFindRequests is true
+ @method findMany
+ @param {DS.Store} store
+ @param {DS.Model} type the DS.Model class of the records
+ @param {Array} ids
+ @param {Array} snapshots
+ @return {Promise} promise
+ */
+
+ /**
+ Organize records into groups, each of which is to be passed to separate
+ calls to `findMany`.
+ For example, if your api has nested URLs that depend on the parent, you will
+ want to group records by their parent.
+ The default implementation returns the records as a single group.
+ @method groupRecordsForFindMany
+ @param {DS.Store} store
+ @param {Array} snapshots
+ @return {Array} an array of arrays of records, each of which is to be
+ loaded separately by `findMany`.
+ */
+ groupRecordsForFindMany: function (store, snapshots) {
+ return [snapshots];
+ }
+ });
+
+ var ember$data$lib$system$adapter$$default = ember$data$lib$system$adapter$$Adapter;
+
+ /**
+ @module ember-data
+ */
+ var ember$data$lib$adapters$fixture$adapter$$get = Ember.get;
+ var ember$data$lib$adapters$fixture$adapter$$fmt = Ember.String.fmt;
+ var ember$data$lib$adapters$fixture$adapter$$indexOf = Ember.EnumerableUtils.indexOf;
+
+ var ember$data$lib$adapters$fixture$adapter$$counter = 0;
+
+ var ember$data$lib$adapters$fixture$adapter$$default = ember$data$lib$system$adapter$$default.extend({
+ // by default, fixtures are already in normalized form
+ serializer: null,
+ // The fixture adapter does not support coalesceFindRequests
+ coalesceFindRequests: false,
+
+ /**
+ If `simulateRemoteResponse` is `true` the `FixtureAdapter` will
+ wait a number of milliseconds before resolving promises with the
+ fixture values. The wait time can be configured via the `latency`
+ property.
+ @property simulateRemoteResponse
+ @type {Boolean}
+ @default true
+ */
+ simulateRemoteResponse: true,
+
+ /**
+ By default the `FixtureAdapter` will simulate a wait of the
+ `latency` milliseconds before resolving promises with the fixture
+ values. This behavior can be turned off via the
+ `simulateRemoteResponse` property.
+ @property latency
+ @type {Number}
+ @default 50
+ */
+ latency: 50,
+
+ /**
+ Implement this method in order to provide data associated with a type
+ @method fixturesForType
+ @param {DS.Model} typeClass
+ @return {Array}
+ */
+ fixturesForType: function (typeClass) {
+ if (typeClass.FIXTURES) {
+ var fixtures = Ember.A(typeClass.FIXTURES);
+ return fixtures.map(function (fixture) {
+ var fixtureIdType = typeof fixture.id;
+ if (fixtureIdType !== "number" && fixtureIdType !== "string") {
+ throw new Error(ember$data$lib$adapters$fixture$adapter$$fmt("the id property must be defined as a number or string for fixture %@", [fixture]));
+ }
+ fixture.id = fixture.id + "";
+ return fixture;
+ });
+ }
+ return null;
+ },
+
+ /**
+ Implement this method in order to query fixtures data
+ @method queryFixtures
+ @param {Array} fixtures
+ @param {Object} query
+ @param {DS.Model} typeClass
+ @return {(Promise|Array)}
+ */
+ queryFixtures: function (fixtures, query, typeClass) {
+ },
+
+ /**
+ @method updateFixtures
+ @param {DS.Model} typeClass
+ @param {Array} fixture
+ */
+ updateFixtures: function (typeClass, fixture) {
+ if (!typeClass.FIXTURES) {
+ typeClass.FIXTURES = [];
+ }
+
+ var fixtures = typeClass.FIXTURES;
+
+ this.deleteLoadedFixture(typeClass, fixture);
+
+ fixtures.push(fixture);
+ },
+
+ /**
+ Implement this method in order to provide json for CRUD methods
+ @method mockJSON
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {DS.Snapshot} snapshot
+ */
+ mockJSON: function (store, typeClass, snapshot) {
+ return store.serializerFor(snapshot.modelName).serialize(snapshot, { includeId: true });
+ },
+
+ /**
+ @method generateIdForRecord
+ @param {DS.Store} store
+ @return {String} id
+ */
+ generateIdForRecord: function (store) {
+ return "fixture-" + ember$data$lib$adapters$fixture$adapter$$counter++;
+ },
+
+ /**
+ @method find
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {String} id
+ @param {DS.Snapshot} snapshot
+ @return {Promise} promise
+ */
+ find: function (store, typeClass, id, snapshot) {
+ var fixtures = this.fixturesForType(typeClass);
+ var fixture;
+
+
+ if (fixtures) {
+ fixture = Ember.A(fixtures).findBy("id", id);
+ }
+
+ if (fixture) {
+ return this.simulateRemoteCall(function () {
+ return fixture;
+ }, this);
+ }
+ },
+
+ /**
+ @method findMany
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Array} ids
+ @param {Array} snapshots
+ @return {Promise} promise
+ */
+ findMany: function (store, typeClass, ids, snapshots) {
+ var fixtures = this.fixturesForType(typeClass);
+
+
+ if (fixtures) {
+ fixtures = fixtures.filter(function (item) {
+ return ember$data$lib$adapters$fixture$adapter$$indexOf(ids, item.id) !== -1;
+ });
+ }
+
+ if (fixtures) {
+ return this.simulateRemoteCall(function () {
+ return fixtures;
+ }, this);
+ }
+ },
+
+ /**
+ @private
+ @method findAll
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @return {Promise} promise
+ */
+ findAll: function (store, typeClass) {
+ var fixtures = this.fixturesForType(typeClass);
+
+
+ return this.simulateRemoteCall(function () {
+ return fixtures;
+ }, this);
+ },
+
+ /**
+ @private
+ @method findQuery
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} query
+ @param {DS.AdapterPopulatedRecordArray} array
+ @return {Promise} promise
+ */
+ findQuery: function (store, typeClass, query, array) {
+ var fixtures = this.fixturesForType(typeClass);
+
+
+ fixtures = this.queryFixtures(fixtures, query, typeClass);
+
+ if (fixtures) {
+ return this.simulateRemoteCall(function () {
+ return fixtures;
+ }, this);
+ }
+ },
+
+ /**
+ @method createRecord
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {DS.Snapshot} snapshot
+ @return {Promise} promise
+ */
+ createRecord: function (store, typeClass, snapshot) {
+ var fixture = this.mockJSON(store, typeClass, snapshot);
+
+ this.updateFixtures(typeClass, fixture);
+
+ return this.simulateRemoteCall(function () {
+ return fixture;
+ }, this);
+ },
+
+ /**
+ @method updateRecord
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {DS.Snapshot} snapshot
+ @return {Promise} promise
+ */
+ updateRecord: function (store, typeClass, snapshot) {
+ var fixture = this.mockJSON(store, typeClass, snapshot);
+
+ this.updateFixtures(typeClass, fixture);
+
+ return this.simulateRemoteCall(function () {
+ return fixture;
+ }, this);
+ },
+
+ /**
+ @method deleteRecord
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {DS.Snapshot} snapshot
+ @return {Promise} promise
+ */
+ deleteRecord: function (store, typeClass, snapshot) {
+ this.deleteLoadedFixture(typeClass, snapshot);
+
+ return this.simulateRemoteCall(function () {
+ // no payload in a deletion
+ return null;
+ });
+ },
+
+ /*
+ @method deleteLoadedFixture
+ @private
+ @param typeClass
+ @param snapshot
+ */
+ deleteLoadedFixture: function (typeClass, snapshot) {
+ var existingFixture = this.findExistingFixture(typeClass, snapshot);
+
+ if (existingFixture) {
+ var index = ember$data$lib$adapters$fixture$adapter$$indexOf(typeClass.FIXTURES, existingFixture);
+ typeClass.FIXTURES.splice(index, 1);
+ return true;
+ }
+ },
+
+ /*
+ @method findExistingFixture
+ @private
+ @param typeClass
+ @param snapshot
+ */
+ findExistingFixture: function (typeClass, snapshot) {
+ var fixtures = this.fixturesForType(typeClass);
+ var id = snapshot.id;
+
+ return this.findFixtureById(fixtures, id);
+ },
+
+ /*
+ @method findFixtureById
+ @private
+ @param fixtures
+ @param id
+ */
+ findFixtureById: function (fixtures, id) {
+ return Ember.A(fixtures).find(function (r) {
+ if ("" + ember$data$lib$adapters$fixture$adapter$$get(r, "id") === "" + id) {
+ return true;
+ } else {
+ return false;
+ }
+ });
+ },
+
+ /*
+ @method simulateRemoteCall
+ @private
+ @param callback
+ @param context
+ */
+ simulateRemoteCall: function (callback, context) {
+ var adapter = this;
+
+ return new Ember.RSVP.Promise(function (resolve) {
+ var value = Ember.copy(callback.call(context), true);
+ if (ember$data$lib$adapters$fixture$adapter$$get(adapter, "simulateRemoteResponse")) {
+ // Schedule with setTimeout
+ Ember.run.later(function () {
+ resolve(value);
+ }, ember$data$lib$adapters$fixture$adapter$$get(adapter, "latency"));
+ } else {
+ // Asynchronous, but at the of the runloop with zero latency
+ Ember.run.schedule("actions", null, function () {
+ resolve(value);
+ });
+ }
+ }, "DS: FixtureAdapter#simulateRemoteCall");
+ }
+ });
+
+ var ember$data$lib$system$map$$Map = Ember.Map;
+ var ember$data$lib$system$map$$MapWithDefault = Ember.MapWithDefault;
+
+ var ember$data$lib$system$map$$default = ember$data$lib$system$map$$Map;
+ var ember$data$lib$adapters$build$url$mixin$$get = Ember.get;
+
+ var ember$data$lib$adapters$build$url$mixin$$default = Ember.Mixin.create({
+ /**
+ Builds a URL for a given type and optional ID.
+ By default, it pluralizes the type's name (for example, 'post'
+ becomes 'posts' and 'person' becomes 'people'). To override the
+ pluralization see [pathForType](#method_pathForType).
+ If an ID is specified, it adds the ID to the path generated
+ for the type, separated by a `/`.
+ When called by RESTAdapter.findMany() the `id` and `snapshot` parameters
+ will be arrays of ids and snapshots.
+ @method buildURL
+ @param {String} modelName
+ @param {(String|Array|Object)} id single id or array of ids or query
+ @param {(DS.Snapshot|Array)} snapshot single snapshot or array of snapshots
+ @param {String} requestType
+ @param {Object} query object of query parameters to send for findQuery requests.
+ @return {String} url
+ */
+ buildURL: function (modelName, id, snapshot, requestType, query) {
+ switch (requestType) {
+ case 'find':
+ return this.urlForFind(id, modelName, snapshot);
+ case 'findAll':
+ return this.urlForFindAll(modelName);
+ case 'findQuery':
+ return this.urlForFindQuery(query, modelName);
+ case 'findMany':
+ return this.urlForFindMany(id, modelName, snapshot);
+ case 'findHasMany':
+ return this.urlForFindHasMany(id, modelName);
+ case 'findBelongsTo':
+ return this.urlForFindBelongsTo(id, modelName);
+ case 'createRecord':
+ return this.urlForCreateRecord(modelName, snapshot);
+ case 'updateRecord':
+ return this.urlForUpdateRecord(id, modelName, snapshot);
+ case 'deleteRecord':
+ return this.urlForDeleteRecord(id, modelName, snapshot);
+ default:
+ return this._buildURL(modelName, id);
+ }
+ },
+
+ /**
+ @method _buildURL
+ @private
+ @param {String} modelName
+ @param {String} id
+ @return {String} url
+ */
+ _buildURL: function (modelName, id) {
+ var url = [];
+ var host = ember$data$lib$adapters$build$url$mixin$$get(this, 'host');
+ var prefix = this.urlPrefix();
+ var path;
+
+ if (modelName) {
+ path = this.pathForType(modelName);
+ if (path) {
+ url.push(path);
+ }
+ }
+
+ if (id) {
+ url.push(encodeURIComponent(id));
+ }
+ if (prefix) {
+ url.unshift(prefix);
+ }
+
+ url = url.join('/');
+ if (!host && url && url.charAt(0) !== '/') {
+ url = '/' + url;
+ }
+
+ return url;
+ },
+
+ /**
+ * @method urlForFind
+ * @param {String} id
+ * @param {String} modelName
+ * @param {DS.Snapshot} snapshot
+ * @return {String} url
+ */
+ urlForFind: function (id, modelName, snapshot) {
+ return this._buildURL(modelName, id);
+ },
+
+ /**
+ * @method urlForFindAll
+ * @param {String} modelName
+ * @return {String} url
+ */
+ urlForFindAll: function (modelName) {
+ return this._buildURL(modelName);
+ },
+
+ /**
+ * @method urlForFindQuery
+ * @param {Object} query
+ * @param {String} modelName
+ * @return {String} url
+ */
+ urlForFindQuery: function (query, modelName) {
+ return this._buildURL(modelName);
+ },
+
+ /**
+ * @method urlForFindMany
+ * @param {Array} ids
+ * @param {String} modelName
+ * @param {Array} snapshots
+ * @return {String} url
+ */
+ urlForFindMany: function (ids, modelName, snapshots) {
+ return this._buildURL(modelName);
+ },
+
+ /**
+ * @method urlForFindHasMany
+ * @param {String} id
+ * @param {String} modelName
+ * @return {String} url
+ */
+ urlForFindHasMany: function (id, modelName) {
+ return this._buildURL(modelName, id);
+ },
+
+ /**
+ * @method urlForFindBelongTo
+ * @param {String} id
+ * @param {String} modelName
+ * @return {String} url
+ */
+ urlForFindBelongsTo: function (id, modelName) {
+ return this._buildURL(modelName, id);
+ },
+
+ /**
+ * @method urlForCreateRecord
+ * @param {String} modelName
+ * @param {DS.Snapshot} snapshot
+ * @return {String} url
+ */
+ urlForCreateRecord: function (modelName, snapshot) {
+ return this._buildURL(modelName);
+ },
+
+ /**
+ * @method urlForUpdateRecord
+ * @param {String} id
+ * @param {String} modelName
+ * @param {DS.Snapshot} snapshot
+ * @return {String} url
+ */
+ urlForUpdateRecord: function (id, modelName, snapshot) {
+ return this._buildURL(modelName, id);
+ },
+
+ /**
+ * @method urlForDeleteRecord
+ * @param {String} id
+ * @param {String} modelName
+ * @param {DS.Snapshot} snapshot
+ * @return {String} url
+ */
+ urlForDeleteRecord: function (id, modelName, snapshot) {
+ return this._buildURL(modelName, id);
+ },
+
+ /**
+ @method urlPrefix
+ @private
+ @param {String} path
+ @param {String} parentURL
+ @return {String} urlPrefix
+ */
+ urlPrefix: function (path, parentURL) {
+ var host = ember$data$lib$adapters$build$url$mixin$$get(this, 'host');
+ var namespace = ember$data$lib$adapters$build$url$mixin$$get(this, 'namespace');
+ var url = [];
+
+ if (path) {
+ // Protocol relative url
+ //jscs:disable disallowEmptyBlocks
+ if (/^\/\//.test(path)) {} else if (path.charAt(0) === '/') {
+ //jscs:enable disallowEmptyBlocks
+ if (host) {
+ path = path.slice(1);
+ url.push(host);
+ }
+ // Relative path
+ } else if (!/^http(s)?:\/\//.test(path)) {
+ url.push(parentURL);
+ }
+ } else {
+ if (host) {
+ url.push(host);
+ }
+ if (namespace) {
+ url.push(namespace);
+ }
+ }
+
+ if (path) {
+ url.push(path);
+ }
+
+ return url.join('/');
+ },
+
+ /**
+ Determines the pathname for a given type.
+ By default, it pluralizes the type's name (for example,
+ 'post' becomes 'posts' and 'person' becomes 'people').
+ ### Pathname customization
+ For example if you have an object LineItem with an
+ endpoint of "/line_items/".
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+ export default DS.RESTAdapter.extend({
+ pathForType: function(modelName) {
+ var decamelized = Ember.String.decamelize(modelName);
+ return Ember.String.pluralize(decamelized);
+ }
+ });
+ ```
+ @method pathForType
+ @param {String} modelName
+ @return {String} path
+ **/
+ pathForType: function (modelName) {
+ var camelized = Ember.String.camelize(modelName);
+ return Ember.String.pluralize(camelized);
+ }
+ });
+
+ var ember$data$lib$adapters$rest$adapter$$get = Ember.get;
+ var ember$data$lib$adapters$rest$adapter$$set = Ember.set;
+ var ember$data$lib$adapters$rest$adapter$$forEach = Ember.ArrayPolyfills.forEach;/**
+ The REST adapter allows your store to communicate with an HTTP server by
+ transmitting JSON via XHR. Most Ember.js apps that consume a JSON API
+ should use the REST adapter.
+
+ This adapter is designed around the idea that the JSON exchanged with
+ the server should be conventional.
+
+ ## JSON Structure
+
+ The REST adapter expects the JSON returned from your server to follow
+ these conventions.
+
+ ### Object Root
+
+ The JSON payload should be an object that contains the record inside a
+ root property. For example, in response to a `GET` request for
+ `/posts/1`, the JSON should look like this:
+
+ ```js
+ {
+ "post": {
+ "id": 1,
+ "title": "I'm Running to Reform the W3C's Tag",
+ "author": "Yehuda Katz"
+ }
+ }
+ ```
+
+ Similarly, in response to a `GET` request for `/posts`, the JSON should
+ look like this:
+
+ ```js
+ {
+ "posts": [
+ {
+ "id": 1,
+ "title": "I'm Running to Reform the W3C's Tag",
+ "author": "Yehuda Katz"
+ },
+ {
+ "id": 2,
+ "title": "Rails is omakase",
+ "author": "D2H"
+ }
+ ]
+ }
+ ```
+
+ ### Conventional Names
+
+ Attribute names in your JSON payload should be the camelCased versions of
+ the attributes in your Ember.js models.
+
+ For example, if you have a `Person` model:
+
+ ```app/models/person.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ firstName: DS.attr('string'),
+ lastName: DS.attr('string'),
+ occupation: DS.attr('string')
+ });
+ ```
+
+ The JSON returned should look like this:
+
+ ```js
+ {
+ "person": {
+ "id": 5,
+ "firstName": "Barack",
+ "lastName": "Obama",
+ "occupation": "President"
+ }
+ }
+ ```
+
+ ## Customization
+
+ ### Endpoint path customization
+
+ Endpoint paths can be prefixed with a `namespace` by setting the namespace
+ property on the adapter:
+
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+
+ export default DS.RESTAdapter.extend({
+ namespace: 'api/1'
+ });
+ ```
+ Requests for `App.Person` would now target `/api/1/people/1`.
+
+ ### Host customization
+
+ An adapter can target other hosts by setting the `host` property.
+
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+
+ export default DS.RESTAdapter.extend({
+ host: 'https://api.example.com'
+ });
+ ```
+
+ ### Headers customization
+
+ Some APIs require HTTP headers, e.g. to provide an API key. Arbitrary
+ headers can be set as key/value pairs on the `RESTAdapter`'s `headers`
+ object and Ember Data will send them along with each ajax request.
+
+
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+
+ export default DS.RESTAdapter.extend({
+ headers: {
+ "API_KEY": "secret key",
+ "ANOTHER_HEADER": "Some header value"
+ }
+ });
+ ```
+
+ `headers` can also be used as a computed property to support dynamic
+ headers. In the example below, the `session` object has been
+ injected into an adapter by Ember's container.
+
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+
+ export default DS.RESTAdapter.extend({
+ headers: function() {
+ return {
+ "API_KEY": this.get("session.authToken"),
+ "ANOTHER_HEADER": "Some header value"
+ };
+ }.property("session.authToken")
+ });
+ ```
+
+ In some cases, your dynamic headers may require data from some
+ object outside of Ember's observer system (for example
+ `document.cookie`). You can use the
+ [volatile](/api/classes/Ember.ComputedProperty.html#method_volatile)
+ function to set the property into a non-cached mode causing the headers to
+ be recomputed with every request.
+
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+
+ export default DS.RESTAdapter.extend({
+ headers: function() {
+ return {
+ "API_KEY": Ember.get(document.cookie.match(/apiKey\=([^;]*)/), "1"),
+ "ANOTHER_HEADER": "Some header value"
+ };
+ }.property().volatile()
+ });
+ ```
+
+ @class RESTAdapter
+ @constructor
+ @namespace DS
+ @extends DS.Adapter
+ @uses DS.BuildURLMixin
+ */
+ var ember$data$lib$adapters$rest$adapter$$RestAdapter = ember$data$lib$system$adapter$$Adapter.extend(ember$data$lib$adapters$build$url$mixin$$default, {
+ defaultSerializer: "-rest",
+
+ /**
+ By default, the RESTAdapter will send the query params sorted alphabetically to the
+ server.
+ For example:
+ ```js
+ store.find('posts', {sort: 'price', category: 'pets'});
+ ```
+ will generate a requests like this `/posts?category=pets&sort=price`, even if the
+ parameters were specified in a different order.
+ That way the generated URL will be deterministic and that simplifies caching mechanisms
+ in the backend.
+ Setting `sortQueryParams` to a falsey value will respect the original order.
+ In case you want to sort the query parameters with a different criteria, set
+ `sortQueryParams` to your custom sort function.
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+ export default DS.RESTAdapter.extend({
+ sortQueryParams: function(params) {
+ var sortedKeys = Object.keys(params).sort().reverse();
+ var len = sortedKeys.length, newParams = {};
+ for (var i = 0; i < len; i++) {
+ newParams[sortedKeys[i]] = params[sortedKeys[i]];
+ }
+ return newParams;
+ }
+ });
+ ```
+ @method sortQueryParams
+ @param {Object} obj
+ @return {Object}
+ */
+ sortQueryParams: function (obj) {
+ var keys = Ember.keys(obj);
+ var len = keys.length;
+ if (len < 2) {
+ return obj;
+ }
+ var newQueryParams = {};
+ var sortedKeys = keys.sort();
+
+ for (var i = 0; i < len; i++) {
+ newQueryParams[sortedKeys[i]] = obj[sortedKeys[i]];
+ }
+ return newQueryParams;
+ },
+
+ /**
+ By default the RESTAdapter will send each find request coming from a `store.find`
+ or from accessing a relationship separately to the server. If your server supports passing
+ ids as a query string, you can set coalesceFindRequests to true to coalesce all find requests
+ within a single runloop.
+ For example, if you have an initial payload of:
+ ```javascript
+ {
+ post: {
+ id: 1,
+ comments: [1, 2]
+ }
+ }
+ ```
+ By default calling `post.get('comments')` will trigger the following requests(assuming the
+ comments haven't been loaded before):
+ ```
+ GET /comments/1
+ GET /comments/2
+ ```
+ If you set coalesceFindRequests to `true` it will instead trigger the following request:
+ ```
+ GET /comments?ids[]=1&ids[]=2
+ ```
+ Setting coalesceFindRequests to `true` also works for `store.find` requests and `belongsTo`
+ relationships accessed within the same runloop. If you set `coalesceFindRequests: true`
+ ```javascript
+ store.find('comment', 1);
+ store.find('comment', 2);
+ ```
+ will also send a request to: `GET /comments?ids[]=1&ids[]=2`
+ Note: Requests coalescing rely on URL building strategy. So if you override `buildURL` in your app
+ `groupRecordsForFindMany` more likely should be overridden as well in order for coalescing to work.
+ @property coalesceFindRequests
+ @type {boolean}
+ */
+ coalesceFindRequests: false,
+
+ /**
+ Endpoint paths can be prefixed with a `namespace` by setting the namespace
+ property on the adapter:
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+ export default DS.RESTAdapter.extend({
+ namespace: 'api/1'
+ });
+ ```
+ Requests for `App.Post` would now target `/api/1/post/`.
+ @property namespace
+ @type {String}
+ */
+
+ /**
+ An adapter can target other hosts by setting the `host` property.
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+ export default DS.RESTAdapter.extend({
+ host: 'https://api.example.com'
+ });
+ ```
+ Requests for `App.Post` would now target `https://api.example.com/post/`.
+ @property host
+ @type {String}
+ */
+
+ /**
+ Some APIs require HTTP headers, e.g. to provide an API
+ key. Arbitrary headers can be set as key/value pairs on the
+ `RESTAdapter`'s `headers` object and Ember Data will send them
+ along with each ajax request. For dynamic headers see [headers
+ customization](/api/data/classes/DS.RESTAdapter.html#toc_headers-customization).
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+ export default DS.RESTAdapter.extend({
+ headers: {
+ "API_KEY": "secret key",
+ "ANOTHER_HEADER": "Some header value"
+ }
+ });
+ ```
+ @property headers
+ @type {Object}
+ */
+
+ /**
+ Called by the store in order to fetch the JSON for a given
+ type and ID.
+ The `find` method makes an Ajax request to a URL computed by `buildURL`, and returns a
+ promise for the resulting payload.
+ This method performs an HTTP `GET` request with the id provided as part of the query string.
+ @method find
+ @param {DS.Store} store
+ @param {DS.Model} type
+ @param {String} id
+ @param {DS.Snapshot} snapshot
+ @return {Promise} promise
+ */
+ find: function (store, type, id, snapshot) {
+ return this.ajax(this.buildURL(type.modelName, id, snapshot, "find"), "GET");
+ },
+
+ /**
+ Called by the store in order to fetch a JSON array for all
+ of the records for a given type.
+ The `findAll` method makes an Ajax (HTTP GET) request to a URL computed by `buildURL`, and returns a
+ promise for the resulting payload.
+ @private
+ @method findAll
+ @param {DS.Store} store
+ @param {DS.Model} type
+ @param {String} sinceToken
+ @return {Promise} promise
+ */
+ findAll: function (store, type, sinceToken) {
+ var query, url;
+
+ if (sinceToken) {
+ query = { since: sinceToken };
+ }
+
+ url = this.buildURL(type.modelName, null, null, "findAll");
+
+ return this.ajax(url, "GET", { data: query });
+ },
+
+ /**
+ Called by the store in order to fetch a JSON array for
+ the records that match a particular query.
+ The `findQuery` method makes an Ajax (HTTP GET) request to a URL computed by `buildURL`, and returns a
+ promise for the resulting payload.
+ The `query` argument is a simple JavaScript object that will be passed directly
+ to the server as parameters.
+ @private
+ @method findQuery
+ @param {DS.Store} store
+ @param {DS.Model} type
+ @param {Object} query
+ @return {Promise} promise
+ */
+ findQuery: function (store, type, query) {
+ var url = this.buildURL(type.modelName, null, null, "findQuery", query);
+
+ if (this.sortQueryParams) {
+ query = this.sortQueryParams(query);
+ }
+
+ return this.ajax(url, "GET", { data: query });
+ },
+
+ /**
+ Called by the store in order to fetch several records together if `coalesceFindRequests` is true
+ For example, if the original payload looks like:
+ ```js
+ {
+ "id": 1,
+ "title": "Rails is omakase",
+ "comments": [ 1, 2, 3 ]
+ }
+ ```
+ The IDs will be passed as a URL-encoded Array of IDs, in this form:
+ ```
+ ids[]=1&ids[]=2&ids[]=3
+ ```
+ Many servers, such as Rails and PHP, will automatically convert this URL-encoded array
+ into an Array for you on the server-side. If you want to encode the
+ IDs, differently, just override this (one-line) method.
+ The `findMany` method makes an Ajax (HTTP GET) request to a URL computed by `buildURL`, and returns a
+ promise for the resulting payload.
+ @method findMany
+ @param {DS.Store} store
+ @param {DS.Model} type
+ @param {Array} ids
+ @param {Array} snapshots
+ @return {Promise} promise
+ */
+ findMany: function (store, type, ids, snapshots) {
+ var url = this.buildURL(type.modelName, ids, snapshots, "findMany");
+ return this.ajax(url, "GET", { data: { ids: ids } });
+ },
+
+ /**
+ Called by the store in order to fetch a JSON array for
+ the unloaded records in a has-many relationship that were originally
+ specified as a URL (inside of `links`).
+ For example, if your original payload looks like this:
+ ```js
+ {
+ "post": {
+ "id": 1,
+ "title": "Rails is omakase",
+ "links": { "comments": "/posts/1/comments" }
+ }
+ }
+ ```
+ This method will be called with the parent record and `/posts/1/comments`.
+ The `findHasMany` method will make an Ajax (HTTP GET) request to the originally specified URL.
+ @method findHasMany
+ @param {DS.Store} store
+ @param {DS.Snapshot} snapshot
+ @param {String} url
+ @return {Promise} promise
+ */
+ findHasMany: function (store, snapshot, url, relationship) {
+ var id = snapshot.id;
+ var type = snapshot.modelName;
+
+ url = this.urlPrefix(url, this.buildURL(type, id, null, "findHasMany"));
+
+ return this.ajax(url, "GET");
+ },
+
+ /**
+ Called by the store in order to fetch a JSON array for
+ the unloaded records in a belongs-to relationship that were originally
+ specified as a URL (inside of `links`).
+ For example, if your original payload looks like this:
+ ```js
+ {
+ "person": {
+ "id": 1,
+ "name": "Tom Dale",
+ "links": { "group": "/people/1/group" }
+ }
+ }
+ ```
+ This method will be called with the parent record and `/people/1/group`.
+ The `findBelongsTo` method will make an Ajax (HTTP GET) request to the originally specified URL.
+ @method findBelongsTo
+ @param {DS.Store} store
+ @param {DS.Snapshot} snapshot
+ @param {String} url
+ @return {Promise} promise
+ */
+ findBelongsTo: function (store, snapshot, url, relationship) {
+ var id = snapshot.id;
+ var type = snapshot.modelName;
+
+ url = this.urlPrefix(url, this.buildURL(type, id, null, "findBelongsTo"));
+ return this.ajax(url, "GET");
+ },
+
+ /**
+ Called by the store when a newly created record is
+ saved via the `save` method on a model record instance.
+ The `createRecord` method serializes the record and makes an Ajax (HTTP POST) request
+ to a URL computed by `buildURL`.
+ See `serialize` for information on how to customize the serialized form
+ of a record.
+ @method createRecord
+ @param {DS.Store} store
+ @param {DS.Model} type
+ @param {DS.Snapshot} snapshot
+ @return {Promise} promise
+ */
+ createRecord: function (store, type, snapshot) {
+ var data = {};
+ var serializer = store.serializerFor(type.modelName);
+ var url = this.buildURL(type.modelName, null, snapshot, "createRecord");
+
+ serializer.serializeIntoHash(data, type, snapshot, { includeId: true });
+
+ return this.ajax(url, "POST", { data: data });
+ },
+
+ /**
+ Called by the store when an existing record is saved
+ via the `save` method on a model record instance.
+ The `updateRecord` method serializes the record and makes an Ajax (HTTP PUT) request
+ to a URL computed by `buildURL`.
+ See `serialize` for information on how to customize the serialized form
+ of a record.
+ @method updateRecord
+ @param {DS.Store} store
+ @param {DS.Model} type
+ @param {DS.Snapshot} snapshot
+ @return {Promise} promise
+ */
+ updateRecord: function (store, type, snapshot) {
+ var data = {};
+ var serializer = store.serializerFor(type.modelName);
+
+ serializer.serializeIntoHash(data, type, snapshot);
+
+ var id = snapshot.id;
+ var url = this.buildURL(type.modelName, id, snapshot, "updateRecord");
+
+ return this.ajax(url, "PUT", { data: data });
+ },
+
+ /**
+ Called by the store when a record is deleted.
+ The `deleteRecord` method makes an Ajax (HTTP DELETE) request to a URL computed by `buildURL`.
+ @method deleteRecord
+ @param {DS.Store} store
+ @param {DS.Model} type
+ @param {DS.Snapshot} snapshot
+ @return {Promise} promise
+ */
+ deleteRecord: function (store, type, snapshot) {
+ var id = snapshot.id;
+
+ return this.ajax(this.buildURL(type.modelName, id, snapshot, "deleteRecord"), "DELETE");
+ },
+
+ _stripIDFromURL: function (store, snapshot) {
+ var url = this.buildURL(snapshot.modelName, snapshot.id, snapshot);
+
+ var expandedURL = url.split("/");
+ //Case when the url is of the format ...something/:id
+ var lastSegment = expandedURL[expandedURL.length - 1];
+ var id = snapshot.id;
+ if (lastSegment === id) {
+ expandedURL[expandedURL.length - 1] = "";
+ } else if (ember$data$lib$adapters$rest$adapter$$endsWith(lastSegment, "?id=" + id)) {
+ //Case when the url is of the format ...something?id=:id
+ expandedURL[expandedURL.length - 1] = lastSegment.substring(0, lastSegment.length - id.length - 1);
+ }
+
+ return expandedURL.join("/");
+ },
+
+ // http://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers
+ maxURLLength: 2048,
+
+ /**
+ Organize records into groups, each of which is to be passed to separate
+ calls to `findMany`.
+ This implementation groups together records that have the same base URL but
+ differing ids. For example `/comments/1` and `/comments/2` will be grouped together
+ because we know findMany can coalesce them together as `/comments?ids[]=1&ids[]=2`
+ It also supports urls where ids are passed as a query param, such as `/comments?id=1`
+ but not those where there is more than 1 query param such as `/comments?id=2&name=David`
+ Currently only the query param of `id` is supported. If you need to support others, please
+ override this or the `_stripIDFromURL` method.
+ It does not group records that have differing base urls, such as for example: `/posts/1/comments/2`
+ and `/posts/2/comments/3`
+ @method groupRecordsForFindMany
+ @param {DS.Store} store
+ @param {Array} snapshots
+ @return {Array} an array of arrays of records, each of which is to be
+ loaded separately by `findMany`.
+ */
+ groupRecordsForFindMany: function (store, snapshots) {
+ var groups = ember$data$lib$system$map$$MapWithDefault.create({ defaultValue: function () {
+ return [];
+ } });
+ var adapter = this;
+ var maxURLLength = this.maxURLLength;
+
+ ember$data$lib$adapters$rest$adapter$$forEach.call(snapshots, function (snapshot) {
+ var baseUrl = adapter._stripIDFromURL(store, snapshot);
+ groups.get(baseUrl).push(snapshot);
+ });
+
+ function splitGroupToFitInUrl(group, maxURLLength, paramNameLength) {
+ var baseUrl = adapter._stripIDFromURL(store, group[0]);
+ var idsSize = 0;
+ var splitGroups = [[]];
+
+ ember$data$lib$adapters$rest$adapter$$forEach.call(group, function (snapshot) {
+ var additionalLength = encodeURIComponent(snapshot.id).length + paramNameLength;
+ if (baseUrl.length + idsSize + additionalLength >= maxURLLength) {
+ idsSize = 0;
+ splitGroups.push([]);
+ }
+
+ idsSize += additionalLength;
+
+ var lastGroupIndex = splitGroups.length - 1;
+ splitGroups[lastGroupIndex].push(snapshot);
+ });
+
+ return splitGroups;
+ }
+
+ var groupsArray = [];
+ groups.forEach(function (group, key) {
+ var paramNameLength = "&ids%5B%5D=".length;
+ var splitGroups = splitGroupToFitInUrl(group, maxURLLength, paramNameLength);
+
+ ember$data$lib$adapters$rest$adapter$$forEach.call(splitGroups, function (splitGroup) {
+ groupsArray.push(splitGroup);
+ });
+ });
+
+ return groupsArray;
+ },
+
+ /**
+ Takes an ajax response, and returns an error payload.
+ Returning a `DS.InvalidError` from this method will cause the
+ record to transition into the `invalid` state and make the
+ `errors` object available on the record. When returning an
+ `InvalidError` the store will attempt to normalize the error data
+ returned from the server using the serializer's `extractErrors`
+ method.
+ Example
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+ export default DS.RESTAdapter.extend({
+ ajaxError: function(jqXHR) {
+ var error = this._super(jqXHR);
+ if (jqXHR && jqXHR.status === 422) {
+ var jsonErrors = Ember.$.parseJSON(jqXHR.responseText);
+ return new DS.InvalidError(jsonErrors);
+ } else {
+ return error;
+ }
+ }
+ });
+ ```
+ Note: As a correctness optimization, the default implementation of
+ the `ajaxError` method strips out the `then` method from jquery's
+ ajax response (jqXHR). This is important because the jqXHR's
+ `then` method fulfills the promise with itself resulting in a
+ circular "thenable" chain which may cause problems for some
+ promise libraries.
+ @method ajaxError
+ @param {Object} jqXHR
+ @param {Object} responseText
+ @param {Object} errorThrown
+ @return {Object} jqXHR
+ */
+ ajaxError: function (jqXHR, responseText, errorThrown) {
+ var isObject = jqXHR !== null && typeof jqXHR === "object";
+
+ if (isObject) {
+ jqXHR.then = null;
+ if (!jqXHR.errorThrown) {
+ if (typeof errorThrown === "string") {
+ jqXHR.errorThrown = new Error(errorThrown);
+ } else {
+ jqXHR.errorThrown = errorThrown;
+ }
+ }
+ }
+
+ return jqXHR;
+ },
+
+ /**
+ Takes an ajax response, and returns the json payload.
+ By default this hook just returns the jsonPayload passed to it.
+ You might want to override it in two cases:
+ 1. Your API might return useful results in the request headers.
+ If you need to access these, you can override this hook to copy them
+ from jqXHR to the payload object so they can be processed in you serializer.
+ 2. Your API might return errors as successful responses with status code
+ 200 and an Errors text or object. You can return a DS.InvalidError from
+ this hook and it will automatically reject the promise and put your record
+ into the invalid state.
+ @method ajaxSuccess
+ @param {Object} jqXHR
+ @param {Object} jsonPayload
+ @return {Object} jsonPayload
+ */
+
+ ajaxSuccess: function (jqXHR, jsonPayload) {
+ return jsonPayload;
+ },
+
+ /**
+ Takes a URL, an HTTP method and a hash of data, and makes an
+ HTTP request.
+ When the server responds with a payload, Ember Data will call into `extractSingle`
+ or `extractArray` (depending on whether the original query was for one record or
+ many records).
+ By default, `ajax` method has the following behavior:
+ * It sets the response `dataType` to `"json"`
+ * If the HTTP method is not `"GET"`, it sets the `Content-Type` to be
+ `application/json; charset=utf-8`
+ * If the HTTP method is not `"GET"`, it stringifies the data passed in. The
+ data is the serialized record in the case of a save.
+ * Registers success and failure handlers.
+ @method ajax
+ @private
+ @param {String} url
+ @param {String} type The request type GET, POST, PUT, DELETE etc.
+ @param {Object} options
+ @return {Promise} promise
+ */
+ ajax: function (url, type, options) {
+ var adapter = this;
+
+ return new Ember.RSVP.Promise(function (resolve, reject) {
+ var hash = adapter.ajaxOptions(url, type, options);
+
+ hash.success = function (json, textStatus, jqXHR) {
+ json = adapter.ajaxSuccess(jqXHR, json);
+ if (json instanceof ember$data$lib$system$model$errors$invalid$$default) {
+ Ember.run(null, reject, json);
+ } else {
+ Ember.run(null, resolve, json);
+ }
+ };
+
+ hash.error = function (jqXHR, textStatus, errorThrown) {
+ Ember.run(null, reject, adapter.ajaxError(jqXHR, jqXHR.responseText, errorThrown));
+ };
+
+ Ember.$.ajax(hash);
+ }, "DS: RESTAdapter#ajax " + type + " to " + url);
+ },
+
+ /**
+ @method ajaxOptions
+ @private
+ @param {String} url
+ @param {String} type The request type GET, POST, PUT, DELETE etc.
+ @param {Object} options
+ @return {Object}
+ */
+ ajaxOptions: function (url, type, options) {
+ var hash = options || {};
+ hash.url = url;
+ hash.type = type;
+ hash.dataType = "json";
+ hash.context = this;
+
+ if (hash.data && type !== "GET") {
+ hash.contentType = "application/json; charset=utf-8";
+ hash.data = JSON.stringify(hash.data);
+ }
+
+ var headers = ember$data$lib$adapters$rest$adapter$$get(this, "headers");
+ if (headers !== undefined) {
+ hash.beforeSend = function (xhr) {
+ ember$data$lib$adapters$rest$adapter$$forEach.call(Ember.keys(headers), function (key) {
+ xhr.setRequestHeader(key, headers[key]);
+ });
+ };
+ }
+
+ return hash;
+ }
+ });
+
+ //From http://stackoverflow.com/questions/280634/endswith-in-javascript
+ function ember$data$lib$adapters$rest$adapter$$endsWith(string, suffix) {
+ if (typeof String.prototype.endsWith !== "function") {
+ return string.indexOf(suffix, string.length - suffix.length) !== -1;
+ } else {
+ return string.endsWith(suffix);
+ }
+ }
+
+ if (Ember.platform.hasPropertyAccessors) {
+ Ember.defineProperty(ember$data$lib$adapters$rest$adapter$$RestAdapter.prototype, "maxUrlLength", {
+ enumerable: false,
+ get: function () {
+ return this.maxURLLength;
+ },
+
+ set: function (value) {
+ ember$data$lib$adapters$rest$adapter$$set(this, "maxURLLength", value);
+ }
+ });
+ }
+
+ var ember$data$lib$adapters$rest$adapter$$default = ember$data$lib$adapters$rest$adapter$$RestAdapter;
+ var ember$lib$main$$default = Ember;
+
+ var ember$inflector$lib$lib$system$inflector$$capitalize = ember$lib$main$$default.String.capitalize;
+
+ var ember$inflector$lib$lib$system$inflector$$BLANK_REGEX = /^\s*$/;
+ var ember$inflector$lib$lib$system$inflector$$LAST_WORD_DASHED_REGEX = /([\w/-]+[_/-])([a-z\d]+$)/;
+ var ember$inflector$lib$lib$system$inflector$$LAST_WORD_CAMELIZED_REGEX = /([\w/-]+)([A-Z][a-z\d]*$)/;
+ var ember$inflector$lib$lib$system$inflector$$CAMELIZED_REGEX = /[A-Z][a-z\d]*$/;
+
+ function ember$inflector$lib$lib$system$inflector$$loadUncountable(rules, uncountable) {
+ for (var i = 0, length = uncountable.length; i < length; i++) {
+ rules.uncountable[uncountable[i].toLowerCase()] = true;
+ }
+ }
+
+ function ember$inflector$lib$lib$system$inflector$$loadIrregular(rules, irregularPairs) {
+ var pair;
+
+ for (var i = 0, length = irregularPairs.length; i < length; i++) {
+ pair = irregularPairs[i];
+
+ //pluralizing
+ rules.irregular[pair[0].toLowerCase()] = pair[1];
+ rules.irregular[pair[1].toLowerCase()] = pair[1];
+
+ //singularizing
+ rules.irregularInverse[pair[1].toLowerCase()] = pair[0];
+ rules.irregularInverse[pair[0].toLowerCase()] = pair[0];
+ }
+ }
+
+ /**
+ Inflector.Ember provides a mechanism for supplying inflection rules for your
+ application. Ember includes a default set of inflection rules, and provides an
+ API for providing additional rules.
+
+ Examples:
+
+ Creating an inflector with no rules.
+
+ ```js
+ var inflector = new Ember.Inflector();
+ ```
+
+ Creating an inflector with the default ember ruleset.
+
+ ```js
+ var inflector = new Ember.Inflector(Ember.Inflector.defaultRules);
+
+ inflector.pluralize('cow'); //=> 'kine'
+ inflector.singularize('kine'); //=> 'cow'
+ ```
+
+ Creating an inflector and adding rules later.
+
+ ```javascript
+ var inflector = Ember.Inflector.inflector;
+
+ inflector.pluralize('advice'); // => 'advices'
+ inflector.uncountable('advice');
+ inflector.pluralize('advice'); // => 'advice'
+
+ inflector.pluralize('formula'); // => 'formulas'
+ inflector.irregular('formula', 'formulae');
+ inflector.pluralize('formula'); // => 'formulae'
+
+ // you would not need to add these as they are the default rules
+ inflector.plural(/$/, 's');
+ inflector.singular(/s$/i, '');
+ ```
+
+ Creating an inflector with a nondefault ruleset.
+
+ ```javascript
+ var rules = {
+ plurals: [ /$/, 's' ],
+ singular: [ /\s$/, '' ],
+ irregularPairs: [
+ [ 'cow', 'kine' ]
+ ],
+ uncountable: [ 'fish' ]
+ };
+
+ var inflector = new Ember.Inflector(rules);
+ ```
+
+ @class Inflector
+ @namespace Ember
+ */
+ function ember$inflector$lib$lib$system$inflector$$Inflector(ruleSet) {
+ ruleSet = ruleSet || {};
+ ruleSet.uncountable = ruleSet.uncountable || ember$inflector$lib$lib$system$inflector$$makeDictionary();
+ ruleSet.irregularPairs = ruleSet.irregularPairs || ember$inflector$lib$lib$system$inflector$$makeDictionary();
+
+ var rules = this.rules = {
+ plurals: ruleSet.plurals || [],
+ singular: ruleSet.singular || [],
+ irregular: ember$inflector$lib$lib$system$inflector$$makeDictionary(),
+ irregularInverse: ember$inflector$lib$lib$system$inflector$$makeDictionary(),
+ uncountable: ember$inflector$lib$lib$system$inflector$$makeDictionary()
+ };
+
+ ember$inflector$lib$lib$system$inflector$$loadUncountable(rules, ruleSet.uncountable);
+ ember$inflector$lib$lib$system$inflector$$loadIrregular(rules, ruleSet.irregularPairs);
+
+ this.enableCache();
+ }
+
+ if (!Object.create && !Object.create(null).hasOwnProperty) {
+ throw new Error('This browser does not support Object.create(null), please polyfil with es5-sham: http://git.io/yBU2rg');
+ }
+
+ function ember$inflector$lib$lib$system$inflector$$makeDictionary() {
+ var cache = Object.create(null);
+ cache['_dict'] = null;
+ delete cache['_dict'];
+ return cache;
+ }
+
+ ember$inflector$lib$lib$system$inflector$$Inflector.prototype = {
+ /**
+ @public
+ As inflections can be costly, and commonly the same subset of words are repeatedly
+ inflected an optional cache is provided.
+ @method enableCache
+ */
+ enableCache: function () {
+ this.purgeCache();
+
+ this.singularize = function (word) {
+ this._cacheUsed = true;
+ return this._sCache[word] || (this._sCache[word] = this._singularize(word));
+ };
+
+ this.pluralize = function (word) {
+ this._cacheUsed = true;
+ return this._pCache[word] || (this._pCache[word] = this._pluralize(word));
+ };
+ },
+
+ /**
+ @public
+ @method purgedCache
+ */
+ purgeCache: function () {
+ this._cacheUsed = false;
+ this._sCache = ember$inflector$lib$lib$system$inflector$$makeDictionary();
+ this._pCache = ember$inflector$lib$lib$system$inflector$$makeDictionary();
+ },
+
+ /**
+ @public
+ disable caching
+ @method disableCache;
+ */
+ disableCache: function () {
+ this._sCache = null;
+ this._pCache = null;
+ this.singularize = function (word) {
+ return this._singularize(word);
+ };
+
+ this.pluralize = function (word) {
+ return this._pluralize(word);
+ };
+ },
+
+ /**
+ @method plural
+ @param {RegExp} regex
+ @param {String} string
+ */
+ plural: function (regex, string) {
+ if (this._cacheUsed) {
+ this.purgeCache();
+ }
+ this.rules.plurals.push([regex, string.toLowerCase()]);
+ },
+
+ /**
+ @method singular
+ @param {RegExp} regex
+ @param {String} string
+ */
+ singular: function (regex, string) {
+ if (this._cacheUsed) {
+ this.purgeCache();
+ }
+ this.rules.singular.push([regex, string.toLowerCase()]);
+ },
+
+ /**
+ @method uncountable
+ @param {String} regex
+ */
+ uncountable: function (string) {
+ if (this._cacheUsed) {
+ this.purgeCache();
+ }
+ ember$inflector$lib$lib$system$inflector$$loadUncountable(this.rules, [string.toLowerCase()]);
+ },
+
+ /**
+ @method irregular
+ @param {String} singular
+ @param {String} plural
+ */
+ irregular: function (singular, plural) {
+ if (this._cacheUsed) {
+ this.purgeCache();
+ }
+ ember$inflector$lib$lib$system$inflector$$loadIrregular(this.rules, [[singular, plural]]);
+ },
+
+ /**
+ @method pluralize
+ @param {String} word
+ */
+ pluralize: function (word) {
+ return this._pluralize(word);
+ },
+
+ _pluralize: function (word) {
+ return this.inflect(word, this.rules.plurals, this.rules.irregular);
+ },
+ /**
+ @method singularize
+ @param {String} word
+ */
+ singularize: function (word) {
+ return this._singularize(word);
+ },
+
+ _singularize: function (word) {
+ return this.inflect(word, this.rules.singular, this.rules.irregularInverse);
+ },
+
+ /**
+ @protected
+ @method inflect
+ @param {String} word
+ @param {Object} typeRules
+ @param {Object} irregular
+ */
+ inflect: function (word, typeRules, irregular) {
+ var inflection, substitution, result, lowercase, wordSplit, firstPhrase, lastWord, isBlank, isCamelized, isUncountable, isIrregular, rule;
+
+ isBlank = !word || ember$inflector$lib$lib$system$inflector$$BLANK_REGEX.test(word);
+
+ isCamelized = ember$inflector$lib$lib$system$inflector$$CAMELIZED_REGEX.test(word);
+ firstPhrase = '';
+
+ if (isBlank) {
+ return word;
+ }
+
+ lowercase = word.toLowerCase();
+ wordSplit = ember$inflector$lib$lib$system$inflector$$LAST_WORD_DASHED_REGEX.exec(word) || ember$inflector$lib$lib$system$inflector$$LAST_WORD_CAMELIZED_REGEX.exec(word);
+ if (wordSplit) {
+ firstPhrase = wordSplit[1];
+ lastWord = wordSplit[2].toLowerCase();
+ }
+
+ isUncountable = this.rules.uncountable[lowercase] || this.rules.uncountable[lastWord];
+
+ if (isUncountable) {
+ return word;
+ }
+
+ isIrregular = irregular && (irregular[lowercase] || irregular[lastWord]);
+
+ if (isIrregular) {
+ if (irregular[lowercase]) {
+ return isIrregular;
+ } else {
+ isIrregular = isCamelized ? ember$inflector$lib$lib$system$inflector$$capitalize(isIrregular) : isIrregular;
+ return firstPhrase + isIrregular;
+ }
+ }
+
+ for (var i = typeRules.length, min = 0; i > min; i--) {
+ inflection = typeRules[i - 1];
+ rule = inflection[0];
+
+ if (rule.test(word)) {
+ break;
+ }
+ }
+
+ inflection = inflection || [];
+
+ rule = inflection[0];
+ substitution = inflection[1];
+
+ result = word.replace(rule, substitution);
+
+ return result;
+ }
+ };
+
+ var ember$inflector$lib$lib$system$inflector$$default = ember$inflector$lib$lib$system$inflector$$Inflector;
+
+ function ember$inflector$lib$lib$system$string$$pluralize(word) {
+ return ember$inflector$lib$lib$system$inflector$$default.inflector.pluralize(word);
+ }
+
+ function ember$inflector$lib$lib$system$string$$singularize(word) {
+ return ember$inflector$lib$lib$system$inflector$$default.inflector.singularize(word);
+ }
+
+ var ember$inflector$lib$lib$system$inflections$$default = {
+ plurals: [[/$/, 's'], [/s$/i, 's'], [/^(ax|test)is$/i, '$1es'], [/(octop|vir)us$/i, '$1i'], [/(octop|vir)i$/i, '$1i'], [/(alias|status)$/i, '$1es'], [/(bu)s$/i, '$1ses'], [/(buffal|tomat)o$/i, '$1oes'], [/([ti])um$/i, '$1a'], [/([ti])a$/i, '$1a'], [/sis$/i, 'ses'], [/(?:([^f])fe|([lr])f)$/i, '$1$2ves'], [/(hive)$/i, '$1s'], [/([^aeiouy]|qu)y$/i, '$1ies'], [/(x|ch|ss|sh)$/i, '$1es'], [/(matr|vert|ind)(?:ix|ex)$/i, '$1ices'], [/^(m|l)ouse$/i, '$1ice'], [/^(m|l)ice$/i, '$1ice'], [/^(ox)$/i, '$1en'], [/^(oxen)$/i, '$1'], [/(quiz)$/i, '$1zes']],
+
+ singular: [[/s$/i, ''], [/(ss)$/i, '$1'], [/(n)ews$/i, '$1ews'], [/([ti])a$/i, '$1um'], [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '$1sis'], [/(^analy)(sis|ses)$/i, '$1sis'], [/([^f])ves$/i, '$1fe'], [/(hive)s$/i, '$1'], [/(tive)s$/i, '$1'], [/([lr])ves$/i, '$1f'], [/([^aeiouy]|qu)ies$/i, '$1y'], [/(s)eries$/i, '$1eries'], [/(m)ovies$/i, '$1ovie'], [/(x|ch|ss|sh)es$/i, '$1'], [/^(m|l)ice$/i, '$1ouse'], [/(bus)(es)?$/i, '$1'], [/(o)es$/i, '$1'], [/(shoe)s$/i, '$1'], [/(cris|test)(is|es)$/i, '$1is'], [/^(a)x[ie]s$/i, '$1xis'], [/(octop|vir)(us|i)$/i, '$1us'], [/(alias|status)(es)?$/i, '$1'], [/^(ox)en/i, '$1'], [/(vert|ind)ices$/i, '$1ex'], [/(matr)ices$/i, '$1ix'], [/(quiz)zes$/i, '$1'], [/(database)s$/i, '$1']],
+
+ irregularPairs: [['person', 'people'], ['man', 'men'], ['child', 'children'], ['sex', 'sexes'], ['move', 'moves'], ['cow', 'kine'], ['zombie', 'zombies']],
+
+ uncountable: ['equipment', 'information', 'rice', 'money', 'species', 'series', 'fish', 'sheep', 'jeans', 'police']
+ };
+
+ ember$inflector$lib$lib$system$inflector$$default.inflector = new ember$inflector$lib$lib$system$inflector$$default(ember$inflector$lib$lib$system$inflections$$default);
+
+ var ember$inflector$lib$lib$utils$register$helper$$default = ember$inflector$lib$lib$utils$register$helper$$registerHelper;
+
+ function ember$inflector$lib$lib$utils$register$helper$$registerHelperIteration1(name, helperFunction) {
+ //earlier versions of ember with htmlbars used this
+ ember$lib$main$$default.HTMLBars.helpers[name] = helperFunction;
+ }
+
+ function ember$inflector$lib$lib$utils$register$helper$$registerHelperIteration2(name, helperFunction) {
+ //registerHelper has been made private as _registerHelper
+ //this is kept here if anyone is using it
+ ember$lib$main$$default.HTMLBars.registerHelper(name, helperFunction);
+ }
+
+ function ember$inflector$lib$lib$utils$register$helper$$registerHelperIteration3(name, helperFunction) {
+ //latest versin of ember uses this
+ ember$lib$main$$default.HTMLBars._registerHelper(name, helperFunction);
+ }
+ function ember$inflector$lib$lib$utils$register$helper$$registerHelper(name, helperFunction) {
+ if (ember$lib$main$$default.HTMLBars) {
+ var fn = ember$lib$main$$default.HTMLBars.makeBoundHelper(helperFunction);
+
+ if (ember$lib$main$$default.HTMLBars._registerHelper) {
+ if (ember$lib$main$$default.HTMLBars.helpers) {
+ ember$inflector$lib$lib$utils$register$helper$$registerHelperIteration1(name, fn);
+ } else {
+ ember$inflector$lib$lib$utils$register$helper$$registerHelperIteration3(name, fn);
+ }
+ } else if (ember$lib$main$$default.HTMLBars.registerHelper) {
+ ember$inflector$lib$lib$utils$register$helper$$registerHelperIteration2(name, fn);
+ }
+ } else if (ember$lib$main$$default.Handlebars) {
+ ember$lib$main$$default.Handlebars.helper(name, helperFunction);
+ }
+ }
+
+ /**
+ *
+ * If you have Ember Inflector (such as if Ember Data is present),
+ * singularize a word. For example, turn "oxen" into "ox".
+ *
+ * Example:
+ *
+ * {{singularize myProperty}}
+ * {{singularize "oxen"}}
+ *
+ * @for Ember.HTMLBars.helpers
+ * @method singularize
+ * @param {String|Property} word word to singularize
+ */
+ ember$inflector$lib$lib$utils$register$helper$$default('singularize', function (params) {
+ return ember$inflector$lib$lib$system$string$$singularize(params[0]);
+ });
+
+ /**
+ *
+ * If you have Ember Inflector (such as if Ember Data is present),
+ * pluralize a word. For example, turn "ox" into "oxen".
+ *
+ * Example:
+ *
+ * {{pluralize count myProperty}}
+ * {{pluralize 1 "oxen"}}
+ * {{pluralize myProperty}}
+ * {{pluralize "ox"}}
+ *
+ * @for Ember.HTMLBars.helpers
+ * @method pluralize
+ * @param {Number|Property} [count] count of objects
+ * @param {String|Property} word word to pluralize
+ */
+ ember$inflector$lib$lib$utils$register$helper$$default('pluralize', function (params) {
+ var count, word;
+
+ if (params.length === 1) {
+ word = params[0];
+ return ember$inflector$lib$lib$system$string$$pluralize(word);
+ } else {
+ count = params[0];
+ word = params[1];
+
+ if (count !== 1) {
+ word = ember$inflector$lib$lib$system$string$$pluralize(word);
+ }
+ return count + ' ' + word;
+ }
+ });
+
+ if (ember$lib$main$$default.EXTEND_PROTOTYPES === true || ember$lib$main$$default.EXTEND_PROTOTYPES.String) {
+ /**
+ See {{#crossLink "Ember.String/pluralize"}}{{/crossLink}}
+ @method pluralize
+ @for String
+ */
+ String.prototype.pluralize = function () {
+ return ember$inflector$lib$lib$system$string$$pluralize(this);
+ };
+
+ /**
+ See {{#crossLink "Ember.String/singularize"}}{{/crossLink}}
+ @method singularize
+ @for String
+ */
+ String.prototype.singularize = function () {
+ return ember$inflector$lib$lib$system$string$$singularize(this);
+ };
+ }
+
+ ember$inflector$lib$lib$system$inflector$$default.defaultRules = ember$inflector$lib$lib$system$inflections$$default;
+ ember$lib$main$$default.Inflector = ember$inflector$lib$lib$system$inflector$$default;
+
+ ember$lib$main$$default.String.pluralize = ember$inflector$lib$lib$system$string$$pluralize;
+ ember$lib$main$$default.String.singularize = ember$inflector$lib$lib$system$string$$singularize;
+ var ember$inflector$lib$main$$default = ember$inflector$lib$lib$system$inflector$$default;
+
+ if (typeof define !== "undefined" && define.amd) {
+ define("ember-inflector", ["exports"], function (__exports__) {
+ __exports__["default"] = ember$inflector$lib$lib$system$inflector$$default;
+ return ember$inflector$lib$lib$system$inflector$$default;
+ });
+ } else if (typeof module !== "undefined" && module["exports"]) {
+ module["exports"] = ember$inflector$lib$lib$system$inflector$$default;
+ }
+
+ /**
+ @module ember-data
+ */
+
+ var activemodel$adapter$lib$system$active$model$adapter$$decamelize = Ember.String.decamelize;
+ var activemodel$adapter$lib$system$active$model$adapter$$underscore = Ember.String.underscore;
+
+ /**
+ The ActiveModelAdapter is a subclass of the RESTAdapter designed to integrate
+ with a JSON API that uses an underscored naming convention instead of camelCasing.
+ It has been designed to work out of the box with the
+ [active\_model\_serializers](http://github.com/rails-api/active_model_serializers)
+ Ruby gem. This Adapter expects specific settings using ActiveModel::Serializers,
+ `embed :ids, embed_in_root: true` which sideloads the records.
+
+ This adapter extends the DS.RESTAdapter by making consistent use of the camelization,
+ decamelization and pluralization methods to normalize the serialized JSON into a
+ format that is compatible with a conventional Rails backend and Ember Data.
+
+ ## JSON Structure
+
+ The ActiveModelAdapter expects the JSON returned from your server to follow
+ the REST adapter conventions substituting underscored keys for camelcased ones.
+
+ Unlike the DS.RESTAdapter, async relationship keys must be the singular form
+ of the relationship name, followed by "_id" for DS.belongsTo relationships,
+ or "_ids" for DS.hasMany relationships.
+
+ ### Conventional Names
+
+ Attribute names in your JSON payload should be the underscored versions of
+ the attributes in your Ember.js models.
+
+ For example, if you have a `Person` model:
+
+ ```js
+ App.FamousPerson = DS.Model.extend({
+ firstName: DS.attr('string'),
+ lastName: DS.attr('string'),
+ occupation: DS.attr('string')
+ });
+ ```
+
+ The JSON returned should look like this:
+
+ ```js
+ {
+ "famous_person": {
+ "id": 1,
+ "first_name": "Barack",
+ "last_name": "Obama",
+ "occupation": "President"
+ }
+ }
+ ```
+
+ Let's imagine that `Occupation` is just another model:
+
+ ```js
+ App.Person = DS.Model.extend({
+ firstName: DS.attr('string'),
+ lastName: DS.attr('string'),
+ occupation: DS.belongsTo('occupation')
+ });
+
+ App.Occupation = DS.Model.extend({
+ name: DS.attr('string'),
+ salary: DS.attr('number'),
+ people: DS.hasMany('person')
+ });
+ ```
+
+ The JSON needed to avoid extra server calls, should look like this:
+
+ ```js
+ {
+ "people": [{
+ "id": 1,
+ "first_name": "Barack",
+ "last_name": "Obama",
+ "occupation_id": 1
+ }],
+
+ "occupations": [{
+ "id": 1,
+ "name": "President",
+ "salary": 100000,
+ "person_ids": [1]
+ }]
+ }
+ ```
+
+ @class ActiveModelAdapter
+ @constructor
+ @namespace DS
+ @extends DS.RESTAdapter
+ **/
+
+ var activemodel$adapter$lib$system$active$model$adapter$$ActiveModelAdapter = ember$data$lib$adapters$rest$adapter$$default.extend({
+ defaultSerializer: "-active-model",
+ /**
+ The ActiveModelAdapter overrides the `pathForType` method to build
+ underscored URLs by decamelizing and pluralizing the object type name.
+ ```js
+ this.pathForType("famousPerson");
+ //=> "famous_people"
+ ```
+ @method pathForType
+ @param {String} modelName
+ @return String
+ */
+ pathForType: function (modelName) {
+ var decamelized = activemodel$adapter$lib$system$active$model$adapter$$decamelize(modelName);
+ var underscored = activemodel$adapter$lib$system$active$model$adapter$$underscore(decamelized);
+ return ember$inflector$lib$lib$system$string$$pluralize(underscored);
+ },
+
+ /**
+ The ActiveModelAdapter overrides the `ajaxError` method
+ to return a DS.InvalidError for all 422 Unprocessable Entity
+ responses.
+ A 422 HTTP response from the server generally implies that the request
+ was well formed but the API was unable to process it because the
+ content was not semantically correct or meaningful per the API.
+ For more information on 422 HTTP Error code see 11.2 WebDAV RFC 4918
+ https://tools.ietf.org/html/rfc4918#section-11.2
+ @method ajaxError
+ @param {Object} jqXHR
+ @return error
+ */
+ ajaxError: function (jqXHR) {
+ var error = this._super.apply(this, arguments);
+
+ if (jqXHR && jqXHR.status === 422) {
+ var response = Ember.$.parseJSON(jqXHR.responseText);
+ return new ember$data$lib$system$model$errors$invalid$$default(response);
+ } else {
+ return error;
+ }
+ }
+ });
+
+ var activemodel$adapter$lib$system$active$model$adapter$$default = activemodel$adapter$lib$system$active$model$adapter$$ActiveModelAdapter;
+
+ var ember$data$lib$system$serializer$$Serializer = Ember.Object.extend({
+ /**
+ The `store` property is the application's `store` that contains all records.
+ It's injected as a service.
+ It can be used to push records from a non flat data structure server
+ response.
+ @property store
+ @type {DS.Store}
+ @public
+ */
+
+ /**
+ The `extract` method is used to deserialize the payload received from your
+ data source into the form that Ember Data expects.
+ @method extract
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ @param {(String|Number)} id
+ @param {String} requestType
+ @return {Object}
+ */
+ extract: null,
+
+ /**
+ The `serialize` method is used when a record is saved in order to convert
+ the record into the form that your external data source expects.
+ `serialize` takes an optional `options` hash with a single option:
+ - `includeId`: If this is `true`, `serialize` should include the ID
+ in the serialized object it builds.
+ @method serialize
+ @param {DS.Model} record
+ @param {Object} [options]
+ @return {Object}
+ */
+ serialize: null,
+
+ /**
+ The `normalize` method is used to convert a payload received from your
+ external data source into the normalized form `store.push()` expects. You
+ should override this method, munge the hash and return the normalized
+ payload.
+ @method normalize
+ @param {DS.Model} typeClass
+ @param {Object} hash
+ @return {Object}
+ */
+ normalize: function (typeClass, hash) {
+ return hash;
+ }
+
+ });
+
+ var ember$data$lib$system$serializer$$default = ember$data$lib$system$serializer$$Serializer;
+
+ var ember$data$lib$serializers$json$serializer$$get = Ember.get;
+ var ember$data$lib$serializers$json$serializer$$isNone = Ember.isNone;
+ var ember$data$lib$serializers$json$serializer$$map = Ember.ArrayPolyfills.map;
+ var ember$data$lib$serializers$json$serializer$$merge = Ember.merge;
+
+ var ember$data$lib$serializers$json$serializer$$default = ember$data$lib$system$serializer$$default.extend({
+ /**
+ The primaryKey is used when serializing and deserializing
+ data. Ember Data always uses the `id` property to store the id of
+ the record. The external source may not always follow this
+ convention. In these cases it is useful to override the
+ primaryKey property to match the primaryKey of your external
+ store.
+ Example
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ primaryKey: '_id'
+ });
+ ```
+ @property primaryKey
+ @type {String}
+ @default 'id'
+ */
+ primaryKey: 'id',
+
+ /**
+ The `attrs` object can be used to declare a simple mapping between
+ property names on `DS.Model` records and payload keys in the
+ serialized JSON object representing the record. An object with the
+ property `key` can also be used to designate the attribute's key on
+ the response payload.
+ Example
+ ```app/models/person.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ firstName: DS.attr('string'),
+ lastName: DS.attr('string'),
+ occupation: DS.attr('string'),
+ admin: DS.attr('boolean')
+ });
+ ```
+ ```app/serializers/person.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ attrs: {
+ admin: 'is_admin',
+ occupation: {key: 'career'}
+ }
+ });
+ ```
+ You can also remove attributes by setting the `serialize` key to
+ false in your mapping object.
+ Example
+ ```app/serializers/person.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ attrs: {
+ admin: {serialize: false},
+ occupation: {key: 'career'}
+ }
+ });
+ ```
+ When serialized:
+ ```javascript
+ {
+ "firstName": "Harry",
+ "lastName": "Houdini",
+ "career": "magician"
+ }
+ ```
+ Note that the `admin` is now not included in the payload.
+ @property attrs
+ @type {Object}
+ */
+ mergedProperties: ['attrs'],
+
+ /**
+ Given a subclass of `DS.Model` and a JSON object this method will
+ iterate through each attribute of the `DS.Model` and invoke the
+ `DS.Transform#deserialize` method on the matching property of the
+ JSON object. This method is typically called after the
+ serializer's `normalize` method.
+ @method applyTransforms
+ @private
+ @param {DS.Model} typeClass
+ @param {Object} data The data to transform
+ @return {Object} data The transformed data object
+ */
+ applyTransforms: function (typeClass, data) {
+ typeClass.eachTransformedAttribute(function applyTransform(key, typeClass) {
+ if (!data.hasOwnProperty(key)) {
+ return;
+ }
+
+ var transform = this.transformFor(typeClass);
+ data[key] = transform.deserialize(data[key]);
+ }, this);
+
+ return data;
+ },
+
+ /**
+ Normalizes a part of the JSON payload returned by
+ the server. You should override this method, munge the hash
+ and call super if you have generic normalization to do.
+ It takes the type of the record that is being normalized
+ (as a DS.Model class), the property where the hash was
+ originally found, and the hash to normalize.
+ You can use this method, for example, to normalize underscored keys to camelized
+ or other general-purpose normalizations.
+ Example
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ normalize: function(typeClass, hash) {
+ var fields = Ember.get(typeClass, 'fields');
+ fields.forEach(function(field) {
+ var payloadField = Ember.String.underscore(field);
+ if (field === payloadField) { return; }
+ hash[field] = hash[payloadField];
+ delete hash[payloadField];
+ });
+ return this._super.apply(this, arguments);
+ }
+ });
+ ```
+ @method normalize
+ @param {DS.Model} typeClass
+ @param {Object} hash
+ @return {Object}
+ */
+ normalize: function (typeClass, hash) {
+ if (!hash) {
+ return hash;
+ }
+
+ this.normalizeId(hash);
+ this.normalizeAttributes(typeClass, hash);
+ this.normalizeRelationships(typeClass, hash);
+
+ this.normalizeUsingDeclaredMapping(typeClass, hash);
+ this.applyTransforms(typeClass, hash);
+ return hash;
+ },
+
+ /**
+ You can use this method to normalize all payloads, regardless of whether they
+ represent single records or an array.
+ For example, you might want to remove some extraneous data from the payload:
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ normalizePayload: function(payload) {
+ delete payload.version;
+ delete payload.status;
+ return payload;
+ }
+ });
+ ```
+ @method normalizePayload
+ @param {Object} payload
+ @return {Object} the normalized payload
+ */
+ normalizePayload: function (payload) {
+ return payload;
+ },
+
+ /**
+ @method normalizeAttributes
+ @private
+ */
+ normalizeAttributes: function (typeClass, hash) {
+ var payloadKey;
+
+ if (this.keyForAttribute) {
+ typeClass.eachAttribute(function (key) {
+ payloadKey = this.keyForAttribute(key, 'deserialize');
+ if (key === payloadKey) {
+ return;
+ }
+ if (!hash.hasOwnProperty(payloadKey)) {
+ return;
+ }
+
+ hash[key] = hash[payloadKey];
+ delete hash[payloadKey];
+ }, this);
+ }
+ },
+
+ /**
+ @method normalizeRelationships
+ @private
+ */
+ normalizeRelationships: function (typeClass, hash) {
+ var payloadKey;
+
+ if (this.keyForRelationship) {
+ typeClass.eachRelationship(function (key, relationship) {
+ payloadKey = this.keyForRelationship(key, relationship.kind, 'deserialize');
+ if (key === payloadKey) {
+ return;
+ }
+ if (!hash.hasOwnProperty(payloadKey)) {
+ return;
+ }
+
+ hash[key] = hash[payloadKey];
+ delete hash[payloadKey];
+ }, this);
+ }
+ },
+
+ /**
+ @method normalizeUsingDeclaredMapping
+ @private
+ */
+ normalizeUsingDeclaredMapping: function (typeClass, hash) {
+ var attrs = ember$data$lib$serializers$json$serializer$$get(this, 'attrs');
+ var payloadKey, key;
+
+ if (attrs) {
+ for (key in attrs) {
+ payloadKey = this._getMappedKey(key);
+ if (!hash.hasOwnProperty(payloadKey)) {
+ continue;
+ }
+
+ if (payloadKey !== key) {
+ hash[key] = hash[payloadKey];
+ delete hash[payloadKey];
+ }
+ }
+ }
+ },
+
+ /**
+ @method normalizeId
+ @private
+ */
+ normalizeId: function (hash) {
+ var primaryKey = ember$data$lib$serializers$json$serializer$$get(this, 'primaryKey');
+
+ if (primaryKey === 'id') {
+ return;
+ }
+
+ hash.id = hash[primaryKey];
+ delete hash[primaryKey];
+ },
+
+ /**
+ @method normalizeErrors
+ @private
+ */
+ normalizeErrors: function (typeClass, hash) {
+ this.normalizeId(hash);
+ this.normalizeAttributes(typeClass, hash);
+ this.normalizeRelationships(typeClass, hash);
+ this.normalizeUsingDeclaredMapping(typeClass, hash);
+ },
+
+ /**
+ Looks up the property key that was set by the custom `attr` mapping
+ passed to the serializer.
+ @method _getMappedKey
+ @private
+ @param {String} key
+ @return {String} key
+ */
+ _getMappedKey: function (key) {
+ var attrs = ember$data$lib$serializers$json$serializer$$get(this, 'attrs');
+ var mappedKey;
+ if (attrs && attrs[key]) {
+ mappedKey = attrs[key];
+ //We need to account for both the {title: 'post_title'} and
+ //{title: {key: 'post_title'}} forms
+ if (mappedKey.key) {
+ mappedKey = mappedKey.key;
+ }
+ if (typeof mappedKey === 'string') {
+ key = mappedKey;
+ }
+ }
+
+ return key;
+ },
+
+ /**
+ Check attrs.key.serialize property to inform if the `key`
+ can be serialized
+ @method _canSerialize
+ @private
+ @param {String} key
+ @return {boolean} true if the key can be serialized
+ */
+ _canSerialize: function (key) {
+ var attrs = ember$data$lib$serializers$json$serializer$$get(this, 'attrs');
+
+ return !attrs || !attrs[key] || attrs[key].serialize !== false;
+ },
+
+ // SERIALIZE
+ /**
+ Called when a record is saved in order to convert the
+ record into JSON.
+ By default, it creates a JSON object with a key for
+ each attribute and belongsTo relationship.
+ For example, consider this model:
+ ```app/models/comment.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ title: DS.attr(),
+ body: DS.attr(),
+ author: DS.belongsTo('user')
+ });
+ ```
+ The default serialization would create a JSON object like:
+ ```javascript
+ {
+ "title": "Rails is unagi",
+ "body": "Rails? Omakase? O_O",
+ "author": 12
+ }
+ ```
+ By default, attributes are passed through as-is, unless
+ you specified an attribute type (`DS.attr('date')`). If
+ you specify a transform, the JavaScript value will be
+ serialized when inserted into the JSON hash.
+ By default, belongs-to relationships are converted into
+ IDs when inserted into the JSON hash.
+ ## IDs
+ `serialize` takes an options hash with a single option:
+ `includeId`. If this option is `true`, `serialize` will,
+ by default include the ID in the JSON object it builds.
+ The adapter passes in `includeId: true` when serializing
+ a record for `createRecord`, but not for `updateRecord`.
+ ## Customization
+ Your server may expect a different JSON format than the
+ built-in serialization format.
+ In that case, you can implement `serialize` yourself and
+ return a JSON hash of your choosing.
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ serialize: function(snapshot, options) {
+ var json = {
+ POST_TTL: snapshot.attr('title'),
+ POST_BDY: snapshot.attr('body'),
+ POST_CMS: snapshot.hasMany('comments', { ids: true })
+ }
+ if (options.includeId) {
+ json.POST_ID_ = snapshot.id;
+ }
+ return json;
+ }
+ });
+ ```
+ ## Customizing an App-Wide Serializer
+ If you want to define a serializer for your entire
+ application, you'll probably want to use `eachAttribute`
+ and `eachRelationship` on the record.
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ serialize: function(snapshot, options) {
+ var json = {};
+ snapshot.eachAttribute(function(name) {
+ json[serverAttributeName(name)] = snapshot.attr(name);
+ })
+ snapshot.eachRelationship(function(name, relationship) {
+ if (relationship.kind === 'hasMany') {
+ json[serverHasManyName(name)] = snapshot.hasMany(name, { ids: true });
+ }
+ });
+ if (options.includeId) {
+ json.ID_ = snapshot.id;
+ }
+ return json;
+ }
+ });
+ function serverAttributeName(attribute) {
+ return attribute.underscore().toUpperCase();
+ }
+ function serverHasManyName(name) {
+ return serverAttributeName(name.singularize()) + "_IDS";
+ }
+ ```
+ This serializer will generate JSON that looks like this:
+ ```javascript
+ {
+ "TITLE": "Rails is omakase",
+ "BODY": "Yep. Omakase.",
+ "COMMENT_IDS": [ 1, 2, 3 ]
+ }
+ ```
+ ## Tweaking the Default JSON
+ If you just want to do some small tweaks on the default JSON,
+ you can call super first and make the tweaks on the returned
+ JSON.
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ serialize: function(snapshot, options) {
+ var json = this._super.apply(this, arguments);
+ json.subject = json.title;
+ delete json.title;
+ return json;
+ }
+ });
+ ```
+ @method serialize
+ @param {DS.Snapshot} snapshot
+ @param {Object} options
+ @return {Object} json
+ */
+ serialize: function (snapshot, options) {
+ var json = {};
+
+ if (options && options.includeId) {
+ var id = snapshot.id;
+
+ if (id) {
+ json[ember$data$lib$serializers$json$serializer$$get(this, 'primaryKey')] = id;
+ }
+ }
+
+ snapshot.eachAttribute(function (key, attribute) {
+ this.serializeAttribute(snapshot, json, key, attribute);
+ }, this);
+
+ snapshot.eachRelationship(function (key, relationship) {
+ if (relationship.kind === 'belongsTo') {
+ this.serializeBelongsTo(snapshot, json, relationship);
+ } else if (relationship.kind === 'hasMany') {
+ this.serializeHasMany(snapshot, json, relationship);
+ }
+ }, this);
+
+ return json;
+ },
+
+ /**
+ You can use this method to customize how a serialized record is added to the complete
+ JSON hash to be sent to the server. By default the JSON Serializer does not namespace
+ the payload and just sends the raw serialized JSON object.
+ If your server expects namespaced keys, you should consider using the RESTSerializer.
+ Otherwise you can override this method to customize how the record is added to the hash.
+ For example, your server may expect underscored root objects.
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+ export default DS.RESTSerializer.extend({
+ serializeIntoHash: function(data, type, snapshot, options) {
+ var root = Ember.String.decamelize(type.modelName);
+ data[root] = this.serialize(snapshot, options);
+ }
+ });
+ ```
+ @method serializeIntoHash
+ @param {Object} hash
+ @param {DS.Model} typeClass
+ @param {DS.Snapshot} snapshot
+ @param {Object} options
+ */
+ serializeIntoHash: function (hash, typeClass, snapshot, options) {
+ ember$data$lib$serializers$json$serializer$$merge(hash, this.serialize(snapshot, options));
+ },
+
+ /**
+ `serializeAttribute` can be used to customize how `DS.attr`
+ properties are serialized
+ For example if you wanted to ensure all your attributes were always
+ serialized as properties on an `attributes` object you could
+ write:
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ serializeAttribute: function(snapshot, json, key, attributes) {
+ json.attributes = json.attributes || {};
+ this._super(snapshot, json.attributes, key, attributes);
+ }
+ });
+ ```
+ @method serializeAttribute
+ @param {DS.Snapshot} snapshot
+ @param {Object} json
+ @param {String} key
+ @param {Object} attribute
+ */
+ serializeAttribute: function (snapshot, json, key, attribute) {
+ var type = attribute.type;
+
+ if (this._canSerialize(key)) {
+ var value = snapshot.attr(key);
+ if (type) {
+ var transform = this.transformFor(type);
+ value = transform.serialize(value);
+ }
+
+ // if provided, use the mapping provided by `attrs` in
+ // the serializer
+ var payloadKey = this._getMappedKey(key);
+
+ if (payloadKey === key && this.keyForAttribute) {
+ payloadKey = this.keyForAttribute(key, 'serialize');
+ }
+
+ json[payloadKey] = value;
+ }
+ },
+
+ /**
+ `serializeBelongsTo` can be used to customize how `DS.belongsTo`
+ properties are serialized.
+ Example
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ serializeBelongsTo: function(snapshot, json, relationship) {
+ var key = relationship.key;
+ var belongsTo = snapshot.belongsTo(key);
+ key = this.keyForRelationship ? this.keyForRelationship(key, "belongsTo", "serialize") : key;
+ json[key] = Ember.isNone(belongsTo) ? belongsTo : belongsTo.record.toJSON();
+ }
+ });
+ ```
+ @method serializeBelongsTo
+ @param {DS.Snapshot} snapshot
+ @param {Object} json
+ @param {Object} relationship
+ */
+ serializeBelongsTo: function (snapshot, json, relationship) {
+ var key = relationship.key;
+
+ if (this._canSerialize(key)) {
+ var belongsToId = snapshot.belongsTo(key, { id: true });
+
+ // if provided, use the mapping provided by `attrs` in
+ // the serializer
+ var payloadKey = this._getMappedKey(key);
+ if (payloadKey === key && this.keyForRelationship) {
+ payloadKey = this.keyForRelationship(key, 'belongsTo', 'serialize');
+ }
+
+ //Need to check whether the id is there for new&async records
+ if (ember$data$lib$serializers$json$serializer$$isNone(belongsToId)) {
+ json[payloadKey] = null;
+ } else {
+ json[payloadKey] = belongsToId;
+ }
+
+ if (relationship.options.polymorphic) {
+ this.serializePolymorphicType(snapshot, json, relationship);
+ }
+ }
+ },
+
+ /**
+ `serializeHasMany` can be used to customize how `DS.hasMany`
+ properties are serialized.
+ Example
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ serializeHasMany: function(snapshot, json, relationship) {
+ var key = relationship.key;
+ if (key === 'comments') {
+ return;
+ } else {
+ this._super.apply(this, arguments);
+ }
+ }
+ });
+ ```
+ @method serializeHasMany
+ @param {DS.Snapshot} snapshot
+ @param {Object} json
+ @param {Object} relationship
+ */
+ serializeHasMany: function (snapshot, json, relationship) {
+ var key = relationship.key;
+
+ if (this._canSerialize(key)) {
+ var payloadKey;
+
+ // if provided, use the mapping provided by `attrs` in
+ // the serializer
+ payloadKey = this._getMappedKey(key);
+ if (payloadKey === key && this.keyForRelationship) {
+ payloadKey = this.keyForRelationship(key, 'hasMany', 'serialize');
+ }
+
+ var relationshipType = snapshot.type.determineRelationshipType(relationship, this.store);
+
+ if (relationshipType === 'manyToNone' || relationshipType === 'manyToMany') {
+ json[payloadKey] = snapshot.hasMany(key, { ids: true });
+ // TODO support for polymorphic manyToNone and manyToMany relationships
+ }
+ }
+ },
+
+ /**
+ You can use this method to customize how polymorphic objects are
+ serialized. Objects are considered to be polymorphic if
+ `{polymorphic: true}` is pass as the second argument to the
+ `DS.belongsTo` function.
+ Example
+ ```app/serializers/comment.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ serializePolymorphicType: function(snapshot, json, relationship) {
+ var key = relationship.key,
+ belongsTo = snapshot.belongsTo(key);
+ key = this.keyForAttribute ? this.keyForAttribute(key, "serialize") : key;
+ if (Ember.isNone(belongsTo)) {
+ json[key + "_type"] = null;
+ } else {
+ json[key + "_type"] = belongsTo.modelName;
+ }
+ }
+ });
+ ```
+ @method serializePolymorphicType
+ @param {DS.Snapshot} snapshot
+ @param {Object} json
+ @param {Object} relationship
+ */
+ serializePolymorphicType: Ember.K,
+
+ // EXTRACT
+
+ /**
+ The `extract` method is used to deserialize payload data from the
+ server. By default the `JSONSerializer` does not push the records
+ into the store. However records that subclass `JSONSerializer`
+ such as the `RESTSerializer` may push records into the store as
+ part of the extract call.
+ This method delegates to a more specific extract method based on
+ the `requestType`.
+ To override this method with a custom one, make sure to call
+ `return this._super(store, type, payload, id, requestType)` with your
+ pre-processed data.
+ Here's an example of using `extract` manually:
+ ```javascript
+ socket.on('message', function(message) {
+ var data = message.data;
+ var typeClass = store.modelFor(message.modelName);
+ var serializer = store.serializerFor(typeClass.modelName);
+ var record = serializer.extract(store, typeClass, data, data.id, 'single');
+ store.push(message.modelName, record);
+ });
+ ```
+ @method extract
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ @param {(String|Number)} id
+ @param {String} requestType
+ @return {Object} json The deserialized payload
+ */
+ extract: function (store, typeClass, payload, id, requestType) {
+ this.extractMeta(store, typeClass.modelName, payload);
+
+ var specificExtract = 'extract' + requestType.charAt(0).toUpperCase() + requestType.substr(1);
+ return this[specificExtract](store, typeClass, payload, id, requestType);
+ },
+
+ /**
+ `extractFindAll` is a hook into the extract method used when a
+ call is made to `DS.Store#findAll`. By default this method is an
+ alias for [extractArray](#method_extractArray).
+ @method extractFindAll
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ @param {(String|Number)} id
+ @param {String} requestType
+ @return {Array} array An array of deserialized objects
+ */
+ extractFindAll: function (store, typeClass, payload, id, requestType) {
+ return this.extractArray(store, typeClass, payload, id, requestType);
+ },
+ /**
+ `extractFindQuery` is a hook into the extract method used when a
+ call is made to `DS.Store#findQuery`. By default this method is an
+ alias for [extractArray](#method_extractArray).
+ @method extractFindQuery
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ @param {(String|Number)} id
+ @param {String} requestType
+ @return {Array} array An array of deserialized objects
+ */
+ extractFindQuery: function (store, typeClass, payload, id, requestType) {
+ return this.extractArray(store, typeClass, payload, id, requestType);
+ },
+ /**
+ `extractFindMany` is a hook into the extract method used when a
+ call is made to `DS.Store#findMany`. By default this method is
+ alias for [extractArray](#method_extractArray).
+ @method extractFindMany
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ @param {(String|Number)} id
+ @param {String} requestType
+ @return {Array} array An array of deserialized objects
+ */
+ extractFindMany: function (store, typeClass, payload, id, requestType) {
+ return this.extractArray(store, typeClass, payload, id, requestType);
+ },
+ /**
+ `extractFindHasMany` is a hook into the extract method used when a
+ call is made to `DS.Store#findHasMany`. By default this method is
+ alias for [extractArray](#method_extractArray).
+ @method extractFindHasMany
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ @param {(String|Number)} id
+ @param {String} requestType
+ @return {Array} array An array of deserialized objects
+ */
+ extractFindHasMany: function (store, typeClass, payload, id, requestType) {
+ return this.extractArray(store, typeClass, payload, id, requestType);
+ },
+
+ /**
+ `extractCreateRecord` is a hook into the extract method used when a
+ call is made to `DS.Model#save` and the record is new. By default
+ this method is alias for [extractSave](#method_extractSave).
+ @method extractCreateRecord
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ @param {(String|Number)} id
+ @param {String} requestType
+ @return {Object} json The deserialized payload
+ */
+ extractCreateRecord: function (store, typeClass, payload, id, requestType) {
+ return this.extractSave(store, typeClass, payload, id, requestType);
+ },
+ /**
+ `extractUpdateRecord` is a hook into the extract method used when
+ a call is made to `DS.Model#save` and the record has been updated.
+ By default this method is alias for [extractSave](#method_extractSave).
+ @method extractUpdateRecord
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ @param {(String|Number)} id
+ @param {String} requestType
+ @return {Object} json The deserialized payload
+ */
+ extractUpdateRecord: function (store, typeClass, payload, id, requestType) {
+ return this.extractSave(store, typeClass, payload, id, requestType);
+ },
+ /**
+ `extractDeleteRecord` is a hook into the extract method used when
+ a call is made to `DS.Model#save` and the record has been deleted.
+ By default this method is alias for [extractSave](#method_extractSave).
+ @method extractDeleteRecord
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ @param {(String|Number)} id
+ @param {String} requestType
+ @return {Object} json The deserialized payload
+ */
+ extractDeleteRecord: function (store, typeClass, payload, id, requestType) {
+ return this.extractSave(store, typeClass, payload, id, requestType);
+ },
+
+ /**
+ `extractFind` is a hook into the extract method used when
+ a call is made to `DS.Store#find`. By default this method is
+ alias for [extractSingle](#method_extractSingle).
+ @method extractFind
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ @param {(String|Number)} id
+ @param {String} requestType
+ @return {Object} json The deserialized payload
+ */
+ extractFind: function (store, typeClass, payload, id, requestType) {
+ return this.extractSingle(store, typeClass, payload, id, requestType);
+ },
+ /**
+ `extractFindBelongsTo` is a hook into the extract method used when
+ a call is made to `DS.Store#findBelongsTo`. By default this method is
+ alias for [extractSingle](#method_extractSingle).
+ @method extractFindBelongsTo
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ @param {(String|Number)} id
+ @param {String} requestType
+ @return {Object} json The deserialized payload
+ */
+ extractFindBelongsTo: function (store, typeClass, payload, id, requestType) {
+ return this.extractSingle(store, typeClass, payload, id, requestType);
+ },
+ /**
+ `extractSave` is a hook into the extract method used when a call
+ is made to `DS.Model#save`. By default this method is alias
+ for [extractSingle](#method_extractSingle).
+ @method extractSave
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ @param {(String|Number)} id
+ @param {String} requestType
+ @return {Object} json The deserialized payload
+ */
+ extractSave: function (store, typeClass, payload, id, requestType) {
+ return this.extractSingle(store, typeClass, payload, id, requestType);
+ },
+
+ /**
+ `extractSingle` is used to deserialize a single record returned
+ from the adapter.
+ Example
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ extractSingle: function(store, typeClass, payload) {
+ payload.comments = payload._embedded.comment;
+ delete payload._embedded;
+ return this._super(store, typeClass, payload);
+ },
+ });
+ ```
+ @method extractSingle
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ @param {(String|Number)} id
+ @param {String} requestType
+ @return {Object} json The deserialized payload
+ */
+ extractSingle: function (store, typeClass, payload, id, requestType) {
+ var normalizedPayload = this.normalizePayload(payload);
+ return this.normalize(typeClass, normalizedPayload);
+ },
+
+ /**
+ `extractArray` is used to deserialize an array of records
+ returned from the adapter.
+ Example
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ extractArray: function(store, typeClass, payload) {
+ return payload.map(function(json) {
+ return this.extractSingle(store, typeClass, json);
+ }, this);
+ }
+ });
+ ```
+ @method extractArray
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} arrayPayload
+ @param {(String|Number)} id
+ @param {String} requestType
+ @return {Array} array An array of deserialized objects
+ */
+ extractArray: function (store, typeClass, arrayPayload, id, requestType) {
+ var normalizedPayload = this.normalizePayload(arrayPayload);
+ var serializer = this;
+
+ return ember$data$lib$serializers$json$serializer$$map.call(normalizedPayload, function (singlePayload) {
+ return serializer.normalize(typeClass, singlePayload);
+ });
+ },
+
+ /**
+ `extractMeta` is used to deserialize any meta information in the
+ adapter payload. By default Ember Data expects meta information to
+ be located on the `meta` property of the payload object.
+ Example
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ extractMeta: function(store, typeClass, payload) {
+ if (payload && payload._pagination) {
+ store.setMetadataFor(typeClass, payload._pagination);
+ delete payload._pagination;
+ }
+ }
+ });
+ ```
+ @method extractMeta
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ */
+ extractMeta: function (store, typeClass, payload) {
+ if (payload && payload.meta) {
+ store.setMetadataFor(typeClass, payload.meta);
+ delete payload.meta;
+ }
+ },
+
+ /**
+ `extractErrors` is used to extract model errors when a call is made
+ to `DS.Model#save` which fails with an `InvalidError`. By default
+ Ember Data expects error information to be located on the `errors`
+ property of the payload object.
+ Example
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ extractErrors: function(store, typeClass, payload, id) {
+ if (payload && typeof payload === 'object' && payload._problems) {
+ payload = payload._problems;
+ this.normalizeErrors(typeClass, payload);
+ }
+ return payload;
+ }
+ });
+ ```
+ @method extractErrors
+ @param {DS.Store} store
+ @param {DS.Model} typeClass
+ @param {Object} payload
+ @param {(String|Number)} id
+ @return {Object} json The deserialized errors
+ */
+ extractErrors: function (store, typeClass, payload, id) {
+ if (payload && typeof payload === 'object' && payload.errors) {
+ payload = payload.errors;
+ this.normalizeErrors(typeClass, payload);
+ }
+ return payload;
+ },
+
+ /**
+ `keyForAttribute` can be used to define rules for how to convert an
+ attribute name in your model to a key in your JSON.
+ Example
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+ export default DS.RESTSerializer.extend({
+ keyForAttribute: function(attr, method) {
+ return Ember.String.underscore(attr).toUpperCase();
+ }
+ });
+ ```
+ @method keyForAttribute
+ @param {String} key
+ @param {String} method
+ @return {String} normalized key
+ */
+ keyForAttribute: function (key, method) {
+ return key;
+ },
+
+ /**
+ `keyForRelationship` can be used to define a custom key when
+ serializing and deserializing relationship properties. By default
+ `JSONSerializer` does not provide an implementation of this method.
+ Example
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ keyForRelationship: function(key, relationship, method) {
+ return 'rel_' + Ember.String.underscore(key);
+ }
+ });
+ ```
+ @method keyForRelationship
+ @param {String} key
+ @param {String} typeClass
+ @param {String} method
+ @return {String} normalized key
+ */
+
+ keyForRelationship: function (key, typeClass, method) {
+ return key;
+ },
+
+ // HELPERS
+
+ /**
+ @method transformFor
+ @private
+ @param {String} attributeType
+ @param {Boolean} skipAssertion
+ @return {DS.Transform} transform
+ */
+ transformFor: function (attributeType, skipAssertion) {
+ var transform = this.container.lookup('transform:' + attributeType);
+ return transform;
+ }
+ });
+
+ var ember$data$lib$system$normalize$model$name$$default = ember$data$lib$system$normalize$model$name$$normalizeModelName;
+ /**
+ All modelNames are dasherized internally. Changing this function may
+ require changes to other normalization hooks (such as typeForRoot).
+ @method normalizeModelName
+ @public
+ @param {String} modelName
+ @return {String} if the adapter can generate one, an ID
+ @for DS
+ */
+ function ember$data$lib$system$normalize$model$name$$normalizeModelName(modelName) {
+ return Ember.String.dasherize(modelName);
+ }
+ var ember$data$lib$system$coerce$id$$default = ember$data$lib$system$coerce$id$$coerceId;
+ // Used by the store to normalize IDs entering the store. Despite the fact
+ // that developers may provide IDs as numbers (e.g., `store.find(Person, 1)`),
+ // it is important that internally we use strings, since IDs may be serialized
+ // and lose type information. For example, Ember's router may put a record's
+ // ID into the URL, and if we later try to deserialize that URL and find the
+ // corresponding record, we will not know if it is a string or a number.
+
+ function ember$data$lib$system$coerce$id$$coerceId(id) {
+ return id == null ? null : id + '';
+ }
+
+ var ember$data$lib$serializers$rest$serializer$$forEach = Ember.ArrayPolyfills.forEach;
+ var ember$data$lib$serializers$rest$serializer$$map = Ember.ArrayPolyfills.map;
+ var ember$data$lib$serializers$rest$serializer$$camelize = Ember.String.camelize;
+
+ /**
+ Normally, applications will use the `RESTSerializer` by implementing
+ the `normalize` method and individual normalizations under
+ `normalizeHash`.
+
+ This allows you to do whatever kind of munging you need, and is
+ especially useful if your server is inconsistent and you need to
+ do munging differently for many different kinds of responses.
+
+ See the `normalize` documentation for more information.
+
+ ## Across the Board Normalization
+
+ There are also a number of hooks that you might find useful to define
+ across-the-board rules for your payload. These rules will be useful
+ if your server is consistent, or if you're building an adapter for
+ an infrastructure service, like Parse, and want to encode service
+ conventions.
+
+ For example, if all of your keys are underscored and all-caps, but
+ otherwise consistent with the names you use in your models, you
+ can implement across-the-board rules for how to convert an attribute
+ name in your model to a key in your JSON.
+
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+
+ export default DS.RESTSerializer.extend({
+ keyForAttribute: function(attr, method) {
+ return Ember.String.underscore(attr).toUpperCase();
+ }
+ });
+ ```
+
+ You can also implement `keyForRelationship`, which takes the name
+ of the relationship as the first parameter, the kind of
+ relationship (`hasMany` or `belongsTo`) as the second parameter, and
+ the method (`serialize` or `deserialize`) as the third parameter.
+
+ @class RESTSerializer
+ @namespace DS
+ @extends DS.JSONSerializer
+ */
+ var ember$data$lib$serializers$rest$serializer$$RESTSerializer = ember$data$lib$serializers$json$serializer$$default.extend({
+ /**
+ If you want to do normalizations specific to some part of the payload, you
+ can specify those under `normalizeHash`.
+ For example, given the following json where the the `IDs` under
+ `"comments"` are provided as `_id` instead of `id`.
+ ```javascript
+ {
+ "post": {
+ "id": 1,
+ "title": "Rails is omakase",
+ "comments": [ 1, 2 ]
+ },
+ "comments": [{
+ "_id": 1,
+ "body": "FIRST"
+ }, {
+ "_id": 2,
+ "body": "Rails is unagi"
+ }]
+ }
+ ```
+ You use `normalizeHash` to normalize just the comments:
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.RESTSerializer.extend({
+ normalizeHash: {
+ comments: function(hash) {
+ hash.id = hash._id;
+ delete hash._id;
+ return hash;
+ }
+ }
+ });
+ ```
+ The key under `normalizeHash` is usually just the original key
+ that was in the original payload. However, key names will be
+ impacted by any modifications done in the `normalizePayload`
+ method. The `DS.RESTSerializer`'s default implementation makes no
+ changes to the payload keys.
+ @property normalizeHash
+ @type {Object}
+ @default undefined
+ */
+
+ /**
+ Normalizes a part of the JSON payload returned by
+ the server. You should override this method, munge the hash
+ and call super if you have generic normalization to do.
+ It takes the type of the record that is being normalized
+ (as a DS.Model class), the property where the hash was
+ originally found, and the hash to normalize.
+ For example, if you have a payload that looks like this:
+ ```js
+ {
+ "post": {
+ "id": 1,
+ "title": "Rails is omakase",
+ "comments": [ 1, 2 ]
+ },
+ "comments": [{
+ "id": 1,
+ "body": "FIRST"
+ }, {
+ "id": 2,
+ "body": "Rails is unagi"
+ }]
+ }
+ ```
+ The `normalize` method will be called three times:
+ * With `App.Post`, `"posts"` and `{ id: 1, title: "Rails is omakase", ... }`
+ * With `App.Comment`, `"comments"` and `{ id: 1, body: "FIRST" }`
+ * With `App.Comment`, `"comments"` and `{ id: 2, body: "Rails is unagi" }`
+ You can use this method, for example, to normalize underscored keys to camelized
+ or other general-purpose normalizations.
+ If you want to do normalizations specific to some part of the payload, you
+ can specify those under `normalizeHash`.
+ For example, if the `IDs` under `"comments"` are provided as `_id` instead of
+ `id`, you can specify how to normalize just the comments:
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.RESTSerializer.extend({
+ normalizeHash: {
+ comments: function(hash) {
+ hash.id = hash._id;
+ delete hash._id;
+ return hash;
+ }
+ }
+ });
+ ```
+ The key under `normalizeHash` is just the original key that was in the original
+ payload.
+ @method normalize
+ @param {DS.Model} typeClass
+ @param {Object} hash
+ @param {String} prop
+ @return {Object}
+ */
+ normalize: function (typeClass, hash, prop) {
+ this.normalizeId(hash);
+ this.normalizeAttributes(typeClass, hash);
+ this.normalizeRelationships(typeClass, hash);
+
+ this.normalizeUsingDeclaredMapping(typeClass, hash);
+
+ if (this.normalizeHash && this.normalizeHash[prop]) {
+ this.normalizeHash[prop](hash);
+ }
+
+ this.applyTransforms(typeClass, hash);
+ return hash;
+ },
+
+ /**
+ Called when the server has returned a payload representing
+ a single record, such as in response to a `find` or `save`.
+ It is your opportunity to clean up the server's response into the normalized
+ form expected by Ember Data.
+ If you want, you can just restructure the top-level of your payload, and
+ do more fine-grained normalization in the `normalize` method.
+ For example, if you have a payload like this in response to a request for
+ post 1:
+ ```js
+ {
+ "id": 1,
+ "title": "Rails is omakase",
+ "_embedded": {
+ "comment": [{
+ "_id": 1,
+ "comment_title": "FIRST"
+ }, {
+ "_id": 2,
+ "comment_title": "Rails is unagi"
+ }]
+ }
+ }
+ ```
+ You could implement a serializer that looks like this to get your payload
+ into shape:
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.RESTSerializer.extend({
+ // First, restructure the top-level so it's organized by type
+ extractSingle: function(store, typeClass, payload, id) {
+ var comments = payload._embedded.comment;
+ delete payload._embedded;
+ payload = { comments: comments, post: payload };
+ return this._super(store, typeClass, payload, id);
+ },
+ normalizeHash: {
+ // Next, normalize individual comments, which (after `extract`)
+ // are now located under `comments`
+ comments: function(hash) {
+ hash.id = hash._id;
+ hash.title = hash.comment_title;
+ delete hash._id;
+ delete hash.comment_title;
+ return hash;
+ }
+ }
+ })
+ ```
+ When you call super from your own implementation of `extractSingle`, the
+ built-in implementation will find the primary record in your normalized
+ payload and push the remaining records into the store.
+ The primary record is the single hash found under `post` or the first
+ element of the `posts` array.
+ The primary record has special meaning when the record is being created
+ for the first time or updated (`createRecord` or `updateRecord`). In
+ particular, it will update the properties of the record that was saved.
+ @method extractSingle
+ @param {DS.Store} store
+ @param {DS.Model} primaryTypeClass
+ @param {Object} rawPayload
+ @param {String} recordId
+ @return {Object} the primary response to the original request
+ */
+ extractSingle: function (store, primaryTypeClass, rawPayload, recordId) {
+ var payload = this.normalizePayload(rawPayload);
+ var primaryRecord;
+
+ for (var prop in payload) {
+ var modelName = this.modelNameFromPayloadKey(prop);
+
+ if (!store.modelFactoryFor(modelName)) {
+ continue;
+ }
+ var isPrimary = this.isPrimaryType(store, modelName, primaryTypeClass);
+ var value = payload[prop];
+
+ if (value === null) {
+ continue;
+ }
+
+ // legacy support for singular resources
+ if (isPrimary && Ember.typeOf(value) !== "array") {
+ primaryRecord = this.normalize(primaryTypeClass, value, prop);
+ continue;
+ }
+
+ var normalizedArray = this.normalizeArray(store, modelName, value, prop);
+
+ /*jshint loopfunc:true*/
+ ember$data$lib$serializers$rest$serializer$$forEach.call(normalizedArray, function (hash) {
+ var isFirstCreatedRecord = isPrimary && !recordId && !primaryRecord;
+ var isUpdatedRecord = isPrimary && ember$data$lib$system$coerce$id$$default(hash.id) === recordId;
+
+ // find the primary record.
+ //
+ // It's either:
+ // * the record with the same ID as the original request
+ // * in the case of a newly created record that didn't have an ID, the first
+ // record in the Array
+ if (isFirstCreatedRecord || isUpdatedRecord) {
+ primaryRecord = hash;
+ } else {
+ store.push(modelName, hash);
+ }
+ }, this);
+ }
+
+ return primaryRecord;
+ },
+
+ /**
+ Called when the server has returned a payload representing
+ multiple records, such as in response to a `findAll` or `findQuery`.
+ It is your opportunity to clean up the server's response into the normalized
+ form expected by Ember Data.
+ If you want, you can just restructure the top-level of your payload, and
+ do more fine-grained normalization in the `normalize` method.
+ For example, if you have a payload like this in response to a request for
+ all posts:
+ ```js
+ {
+ "_embedded": {
+ "post": [{
+ "id": 1,
+ "title": "Rails is omakase"
+ }, {
+ "id": 2,
+ "title": "The Parley Letter"
+ }],
+ "comment": [{
+ "_id": 1,
+ "comment_title": "Rails is unagi",
+ "post_id": 1
+ }, {
+ "_id": 2,
+ "comment_title": "Don't tread on me",
+ "post_id": 2
+ }]
+ }
+ }
+ ```
+ You could implement a serializer that looks like this to get your payload
+ into shape:
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.RESTSerializer.extend({
+ // First, restructure the top-level so it's organized by type
+ // and the comments are listed under a post's `comments` key.
+ extractArray: function(store, type, payload) {
+ var posts = payload._embedded.post;
+ var comments = [];
+ var postCache = {};
+ posts.forEach(function(post) {
+ post.comments = [];
+ postCache[post.id] = post;
+ });
+ payload._embedded.comment.forEach(function(comment) {
+ comments.push(comment);
+ postCache[comment.post_id].comments.push(comment);
+ delete comment.post_id;
+ });
+ payload = { comments: comments, posts: posts };
+ return this._super(store, type, payload);
+ },
+ normalizeHash: {
+ // Next, normalize individual comments, which (after `extract`)
+ // are now located under `comments`
+ comments: function(hash) {
+ hash.id = hash._id;
+ hash.title = hash.comment_title;
+ delete hash._id;
+ delete hash.comment_title;
+ return hash;
+ }
+ }
+ })
+ ```
+ When you call super from your own implementation of `extractArray`, the
+ built-in implementation will find the primary array in your normalized
+ payload and push the remaining records into the store.
+ The primary array is the array found under `posts`.
+ The primary record has special meaning when responding to `findQuery`
+ or `findHasMany`. In particular, the primary array will become the
+ list of records in the record array that kicked off the request.
+ If your primary array contains secondary (embedded) records of the same type,
+ you cannot place these into the primary array `posts`. Instead, place the
+ secondary items into an underscore prefixed property `_posts`, which will
+ push these items into the store and will not affect the resulting query.
+ @method extractArray
+ @param {DS.Store} store
+ @param {DS.Model} primaryTypeClass
+ @param {Object} rawPayload
+ @return {Array} The primary array that was returned in response
+ to the original query.
+ */
+ extractArray: function (store, primaryTypeClass, rawPayload) {
+ var payload = this.normalizePayload(rawPayload);
+ var primaryArray;
+
+ for (var prop in payload) {
+ var modelName = prop;
+ var forcedSecondary = false;
+
+ if (prop.charAt(0) === "_") {
+ forcedSecondary = true;
+ modelName = prop.substr(1);
+ }
+
+ var typeName = this.modelNameFromPayloadKey(modelName);
+ if (!store.modelFactoryFor(typeName)) {
+ continue;
+ }
+
+ var normalizedArray = this.normalizeArray(store, typeName, payload[prop], prop);
+ var isPrimary = !forcedSecondary && this.isPrimaryType(store, typeName, primaryTypeClass);
+
+ if (isPrimary) {
+ primaryArray = normalizedArray;
+ } else {
+ store.pushMany(typeName, normalizedArray);
+ }
+ }
+
+ return primaryArray;
+ },
+
+ normalizeArray: function (store, typeName, arrayHash, prop) {
+ var typeClass = store.modelFor(typeName);
+ var typeSerializer = store.serializerFor(typeName);
+
+ /*jshint loopfunc:true*/
+ return ember$data$lib$serializers$rest$serializer$$map.call(arrayHash, function (hash) {
+ return typeSerializer.normalize(typeClass, hash, prop);
+ }, this);
+ },
+
+ isPrimaryType: function (store, typeName, primaryTypeClass) {
+ var typeClass = store.modelFor(typeName);
+ return typeClass.modelName === primaryTypeClass.modelName;
+ },
+
+ /**
+ This method allows you to push a payload containing top-level
+ collections of records organized per type.
+ ```js
+ {
+ "posts": [{
+ "id": "1",
+ "title": "Rails is omakase",
+ "author", "1",
+ "comments": [ "1" ]
+ }],
+ "comments": [{
+ "id": "1",
+ "body": "FIRST"
+ }],
+ "users": [{
+ "id": "1",
+ "name": "@d2h"
+ }]
+ }
+ ```
+ It will first normalize the payload, so you can use this to push
+ in data streaming in from your server structured the same way
+ that fetches and saves are structured.
+ @method pushPayload
+ @param {DS.Store} store
+ @param {Object} rawPayload
+ */
+ pushPayload: function (store, rawPayload) {
+ var payload = this.normalizePayload(rawPayload);
+
+ for (var prop in payload) {
+ var modelName = this.modelNameFromPayloadKey(prop);
+ if (!store.modelFactoryFor(modelName)) {
+ continue;
+ }
+ var typeClass = store.modelFor(modelName);
+ var typeSerializer = store.serializerFor(modelName);
+
+ /*jshint loopfunc:true*/
+ var normalizedArray = ember$data$lib$serializers$rest$serializer$$map.call(Ember.makeArray(payload[prop]), function (hash) {
+ return typeSerializer.normalize(typeClass, hash, prop);
+ }, this);
+
+ store.pushMany(modelName, normalizedArray);
+ }
+ },
+
+ /**
+ This method is used to convert each JSON root key in the payload
+ into a modelName that it can use to look up the appropriate model for
+ that part of the payload.
+ For example, your server may send a model name that does not correspond with
+ the name of the model in your app. Let's take a look at an example model,
+ and an example payload:
+ ```app/models/post.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ });
+ ```
+ ```javascript
+ {
+ "blog/post": {
+ "id": "1
+ }
+ }
+ ```
+ Ember Data is going to normalize the payload's root key for the modelName. As a result,
+ it will try to look up the "blog/post" model. Since we don't have a model called "blog/post"
+ (or a file called app/models/blog/post.js in ember-cli), Ember Data will throw an error
+ because it cannot find the "blog/post" model.
+ Since we want to remove this namespace, we can define a serializer for the application that will
+ remove "blog/" from the payload key whenver it's encountered by Ember Data:
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+ export default DS.RESTSerializer.extend({
+ modelNameFromPayloadKey: function(payloadKey) {
+ if (payloadKey === 'blog/post') {
+ return this._super(payloadKey.replace('blog/', ''));
+ } else {
+ return this._super(payloadKey);
+ }
+ }
+ });
+ ```
+ After refreshing, Ember Data will appropriately look up the "post" model.
+ By default the modelName for a model is its
+ name in dasherized form. This means that a payload key like "blogPost" would be
+ normalized to "blog-post" when Ember Data looks up the model. Usually, Ember Data
+ can use the correct inflection to do this for you. Most of the time, you won't
+ need to override `modelNameFromPayloadKey` for this purpose.
+ @method modelNameFromPayloadKey
+ @param {String} key
+ @return {String} the model's modelName
+ */
+ modelNameFromPayloadKey: function (key) {
+ return ember$inflector$lib$lib$system$string$$singularize(ember$data$lib$system$normalize$model$name$$default(key));
+ },
+
+ // SERIALIZE
+
+ /**
+ Called when a record is saved in order to convert the
+ record into JSON.
+ By default, it creates a JSON object with a key for
+ each attribute and belongsTo relationship.
+ For example, consider this model:
+ ```app/models/comment.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ title: DS.attr(),
+ body: DS.attr(),
+ author: DS.belongsTo('user')
+ });
+ ```
+ The default serialization would create a JSON object like:
+ ```js
+ {
+ "title": "Rails is unagi",
+ "body": "Rails? Omakase? O_O",
+ "author": 12
+ }
+ ```
+ By default, attributes are passed through as-is, unless
+ you specified an attribute type (`DS.attr('date')`). If
+ you specify a transform, the JavaScript value will be
+ serialized when inserted into the JSON hash.
+ By default, belongs-to relationships are converted into
+ IDs when inserted into the JSON hash.
+ ## IDs
+ `serialize` takes an options hash with a single option:
+ `includeId`. If this option is `true`, `serialize` will,
+ by default include the ID in the JSON object it builds.
+ The adapter passes in `includeId: true` when serializing
+ a record for `createRecord`, but not for `updateRecord`.
+ ## Customization
+ Your server may expect a different JSON format than the
+ built-in serialization format.
+ In that case, you can implement `serialize` yourself and
+ return a JSON hash of your choosing.
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.RESTSerializer.extend({
+ serialize: function(snapshot, options) {
+ var json = {
+ POST_TTL: snapshot.attr('title'),
+ POST_BDY: snapshot.attr('body'),
+ POST_CMS: snapshot.hasMany('comments', { ids: true })
+ }
+ if (options.includeId) {
+ json.POST_ID_ = snapshot.id;
+ }
+ return json;
+ }
+ });
+ ```
+ ## Customizing an App-Wide Serializer
+ If you want to define a serializer for your entire
+ application, you'll probably want to use `eachAttribute`
+ and `eachRelationship` on the record.
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+ export default DS.RESTSerializer.extend({
+ serialize: function(snapshot, options) {
+ var json = {};
+ snapshot.eachAttribute(function(name) {
+ json[serverAttributeName(name)] = snapshot.attr(name);
+ })
+ snapshot.eachRelationship(function(name, relationship) {
+ if (relationship.kind === 'hasMany') {
+ json[serverHasManyName(name)] = snapshot.hasMany(name, { ids: true });
+ }
+ });
+ if (options.includeId) {
+ json.ID_ = snapshot.id;
+ }
+ return json;
+ }
+ });
+ function serverAttributeName(attribute) {
+ return attribute.underscore().toUpperCase();
+ }
+ function serverHasManyName(name) {
+ return serverAttributeName(name.singularize()) + "_IDS";
+ }
+ ```
+ This serializer will generate JSON that looks like this:
+ ```js
+ {
+ "TITLE": "Rails is omakase",
+ "BODY": "Yep. Omakase.",
+ "COMMENT_IDS": [ 1, 2, 3 ]
+ }
+ ```
+ ## Tweaking the Default JSON
+ If you just want to do some small tweaks on the default JSON,
+ you can call super first and make the tweaks on the returned
+ JSON.
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.RESTSerializer.extend({
+ serialize: function(snapshot, options) {
+ var json = this._super(snapshot, options);
+ json.subject = json.title;
+ delete json.title;
+ return json;
+ }
+ });
+ ```
+ @method serialize
+ @param {DS.Snapshot} snapshot
+ @param {Object} options
+ @return {Object} json
+ */
+ serialize: function (snapshot, options) {
+ return this._super.apply(this, arguments);
+ },
+
+ /**
+ You can use this method to customize the root keys serialized into the JSON.
+ By default the REST Serializer sends the modelName of a model, which is a camelized
+ version of the name.
+ For example, your server may expect underscored root objects.
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+ export default DS.RESTSerializer.extend({
+ serializeIntoHash: function(data, type, record, options) {
+ var root = Ember.String.decamelize(type.modelName);
+ data[root] = this.serialize(record, options);
+ }
+ });
+ ```
+ @method serializeIntoHash
+ @param {Object} hash
+ @param {DS.Model} typeClass
+ @param {DS.Snapshot} snapshot
+ @param {Object} options
+ */
+ serializeIntoHash: function (hash, typeClass, snapshot, options) {
+ var normalizedRootKey = this.payloadKeyFromModelName(typeClass.modelName);
+ hash[normalizedRootKey] = this.serialize(snapshot, options);
+ },
+
+ /**
+ You can use `payloadKeyFromModelName` to override the root key for an outgoing
+ request. By default, the RESTSerializer returns a camelized version of the
+ model's name.
+ For a model called TacoParty, its `modelName` would be the string `taco-party`. The RESTSerializer
+ will send it to the server with `tacoParty` as the root key in the JSON payload:
+ ```js
+ {
+ "tacoParty": {
+ "id": "1",
+ "location": "Matthew Beale's House"
+ }
+ }
+ ```
+ For example, your server may expect dasherized root objects:
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+ export default DS.RESTSerializer.extend({
+ payloadKeyFromModelName: function(modelName) {
+ return Ember.String.dasherize(modelName);
+ }
+ });
+ ```
+ Given a `TacoParty' model, calling `save` on a tacoModel would produce an outgoing
+ request like:
+ ```js
+ {
+ "taco-party": {
+ "id": "1",
+ "location": "Matthew Beale's House"
+ }
+ }
+ ```
+ @method payloadKeyFromModelName
+ @param {String} modelName
+ @return {String}
+ */
+ payloadKeyFromModelName: function (modelName) {
+ return ember$data$lib$serializers$rest$serializer$$camelize(modelName);
+ },
+
+ /**
+ Deprecated. Use modelNameFromPayloadKey instead
+ @method typeForRoot
+ @param {String} modelName
+ @return {String}
+ @deprecated
+ */
+ typeForRoot: function (modelName) {
+ return this.modelNameFromPayloadKey(modelName);
+ },
+
+ /**
+ You can use this method to customize how polymorphic objects are serialized.
+ By default the JSON Serializer creates the key by appending `Type` to
+ the attribute and value from the model's camelcased model name.
+ @method serializePolymorphicType
+ @param {DS.Snapshot} snapshot
+ @param {Object} json
+ @param {Object} relationship
+ */
+ serializePolymorphicType: function (snapshot, json, relationship) {
+ var key = relationship.key;
+ var belongsTo = snapshot.belongsTo(key);
+ key = this.keyForAttribute ? this.keyForAttribute(key, "serialize") : key;
+ if (Ember.isNone(belongsTo)) {
+ json[key + "Type"] = null;
+ } else {
+ json[key + "Type"] = Ember.String.camelize(belongsTo.modelName);
+ }
+ }
+ });
+
+
+ var ember$data$lib$serializers$rest$serializer$$default = ember$data$lib$serializers$rest$serializer$$RESTSerializer;
+ /**
+ @module ember-data
+ */
+
+ var activemodel$adapter$lib$system$active$model$serializer$$forEach = Ember.EnumerableUtils.forEach;
+ var activemodel$adapter$lib$system$active$model$serializer$$camelize = Ember.String.camelize;
+ var activemodel$adapter$lib$system$active$model$serializer$$classify = Ember.String.classify;
+ var activemodel$adapter$lib$system$active$model$serializer$$decamelize = Ember.String.decamelize;
+ var activemodel$adapter$lib$system$active$model$serializer$$underscore = Ember.String.underscore;
+
+ /**
+ The ActiveModelSerializer is a subclass of the RESTSerializer designed to integrate
+ with a JSON API that uses an underscored naming convention instead of camelCasing.
+ It has been designed to work out of the box with the
+ [active\_model\_serializers](http://github.com/rails-api/active_model_serializers)
+ Ruby gem. This Serializer expects specific settings using ActiveModel::Serializers,
+ `embed :ids, embed_in_root: true` which sideloads the records.
+
+ This serializer extends the DS.RESTSerializer by making consistent
+ use of the camelization, decamelization and pluralization methods to
+ normalize the serialized JSON into a format that is compatible with
+ a conventional Rails backend and Ember Data.
+
+ ## JSON Structure
+
+ The ActiveModelSerializer expects the JSON returned from your server
+ to follow the REST adapter conventions substituting underscored keys
+ for camelcased ones.
+
+ ### Conventional Names
+
+ Attribute names in your JSON payload should be the underscored versions of
+ the attributes in your Ember.js models.
+
+ For example, if you have a `Person` model:
+
+ ```js
+ App.FamousPerson = DS.Model.extend({
+ firstName: DS.attr('string'),
+ lastName: DS.attr('string'),
+ occupation: DS.attr('string')
+ });
+ ```
+
+ The JSON returned should look like this:
+
+ ```js
+ {
+ "famous_person": {
+ "id": 1,
+ "first_name": "Barack",
+ "last_name": "Obama",
+ "occupation": "President"
+ }
+ }
+ ```
+
+ Let's imagine that `Occupation` is just another model:
+
+ ```js
+ App.Person = DS.Model.extend({
+ firstName: DS.attr('string'),
+ lastName: DS.attr('string'),
+ occupation: DS.belongsTo('occupation')
+ });
+
+ App.Occupation = DS.Model.extend({
+ name: DS.attr('string'),
+ salary: DS.attr('number'),
+ people: DS.hasMany('person')
+ });
+ ```
+
+ The JSON needed to avoid extra server calls, should look like this:
+
+ ```js
+ {
+ "people": [{
+ "id": 1,
+ "first_name": "Barack",
+ "last_name": "Obama",
+ "occupation_id": 1
+ }],
+
+ "occupations": [{
+ "id": 1,
+ "name": "President",
+ "salary": 100000,
+ "person_ids": [1]
+ }]
+ }
+ ```
+
+ @class ActiveModelSerializer
+ @namespace DS
+ @extends DS.RESTSerializer
+ */
+ var activemodel$adapter$lib$system$active$model$serializer$$ActiveModelSerializer = ember$data$lib$serializers$rest$serializer$$default.extend({
+ // SERIALIZE
+
+ /**
+ Converts camelCased attributes to underscored when serializing.
+ @method keyForAttribute
+ @param {String} attribute
+ @return String
+ */
+ keyForAttribute: function (attr) {
+ return activemodel$adapter$lib$system$active$model$serializer$$decamelize(attr);
+ },
+
+ /**
+ Underscores relationship names and appends "_id" or "_ids" when serializing
+ relationship keys.
+ @method keyForRelationship
+ @param {String} relationshipModelName
+ @param {String} kind
+ @return String
+ */
+ keyForRelationship: function (relationshipModelName, kind) {
+ var key = activemodel$adapter$lib$system$active$model$serializer$$decamelize(relationshipModelName);
+ if (kind === "belongsTo") {
+ return key + "_id";
+ } else if (kind === "hasMany") {
+ return ember$inflector$lib$lib$system$string$$singularize(key) + "_ids";
+ } else {
+ return key;
+ }
+ },
+
+ /*
+ Does not serialize hasMany relationships by default.
+ */
+ serializeHasMany: Ember.K,
+
+ /**
+ Underscores the JSON root keys when serializing.
+ @method payloadKeyFromModelName
+ @param {String} modelName
+ @return {String}
+ */
+ payloadKeyFromModelName: function (modelName) {
+ return activemodel$adapter$lib$system$active$model$serializer$$underscore(activemodel$adapter$lib$system$active$model$serializer$$decamelize(modelName));
+ },
+
+ /**
+ Serializes a polymorphic type as a fully capitalized model name.
+ @method serializePolymorphicType
+ @param {DS.Snapshot} snapshot
+ @param {Object} json
+ @param {Object} relationship
+ */
+ serializePolymorphicType: function (snapshot, json, relationship) {
+ var key = relationship.key;
+ var belongsTo = snapshot.belongsTo(key);
+ var jsonKey = activemodel$adapter$lib$system$active$model$serializer$$underscore(key + "_type");
+
+ if (Ember.isNone(belongsTo)) {
+ json[jsonKey] = null;
+ } else {
+ json[jsonKey] = activemodel$adapter$lib$system$active$model$serializer$$classify(belongsTo.modelName).replace(/(\/)([a-z])/g, function (match, separator, chr) {
+ return match.toUpperCase();
+ }).replace("/", "::");
+ }
+ },
+
+ // EXTRACT
+
+ /**
+ Add extra step to `DS.RESTSerializer.normalize` so links are normalized.
+ If your payload looks like:
+ ```js
+ {
+ "post": {
+ "id": 1,
+ "title": "Rails is omakase",
+ "links": { "flagged_comments": "api/comments/flagged" }
+ }
+ }
+ ```
+ The normalized version would look like this
+ ```js
+ {
+ "post": {
+ "id": 1,
+ "title": "Rails is omakase",
+ "links": { "flaggedComments": "api/comments/flagged" }
+ }
+ }
+ ```
+ @method normalize
+ @param {subclass of DS.Model} typeClass
+ @param {Object} hash
+ @param {String} prop
+ @return Object
+ */
+
+ normalize: function (typeClass, hash, prop) {
+ this.normalizeLinks(hash);
+
+ return this._super(typeClass, hash, prop);
+ },
+
+ /**
+ Convert `snake_cased` links to `camelCase`
+ @method normalizeLinks
+ @param {Object} data
+ */
+
+ normalizeLinks: function (data) {
+ if (data.links) {
+ var links = data.links;
+
+ for (var link in links) {
+ var camelizedLink = activemodel$adapter$lib$system$active$model$serializer$$camelize(link);
+
+ if (camelizedLink !== link) {
+ links[camelizedLink] = links[link];
+ delete links[link];
+ }
+ }
+ }
+ },
+
+ /**
+ Normalize the polymorphic type from the JSON.
+ Normalize:
+ ```js
+ {
+ id: "1"
+ minion: { type: "evil_minion", id: "12"}
+ }
+ ```
+ To:
+ ```js
+ {
+ id: "1"
+ minion: { type: "evilMinion", id: "12"}
+ }
+ ```
+ @param {Subclass of DS.Model} typeClass
+ @method normalizeRelationships
+ @private
+ */
+ normalizeRelationships: function (typeClass, hash) {
+
+ if (this.keyForRelationship) {
+ typeClass.eachRelationship(function (key, relationship) {
+ var payloadKey, payload;
+ if (relationship.options.polymorphic) {
+ payloadKey = this.keyForAttribute(key, "deserialize");
+ payload = hash[payloadKey];
+ if (payload && payload.type) {
+ payload.type = this.modelNameFromPayloadKey(payload.type);
+ } else if (payload && relationship.kind === "hasMany") {
+ var self = this;
+ activemodel$adapter$lib$system$active$model$serializer$$forEach(payload, function (single) {
+ single.type = self.modelNameFromPayloadKey(single.type);
+ });
+ }
+ } else {
+ payloadKey = this.keyForRelationship(key, relationship.kind, "deserialize");
+ if (!hash.hasOwnProperty(payloadKey)) {
+ return;
+ }
+ payload = hash[payloadKey];
+ }
+
+ hash[key] = payload;
+
+ if (key !== payloadKey) {
+ delete hash[payloadKey];
+ }
+ }, this);
+ }
+ },
+ modelNameFromPayloadKey: function (key) {
+ var convertedFromRubyModule = activemodel$adapter$lib$system$active$model$serializer$$camelize(ember$inflector$lib$lib$system$string$$singularize(key)).replace(/(^|\:)([A-Z])/g, function (match, separator, chr) {
+ return match.toLowerCase();
+ }).replace("::", "/");
+ return ember$data$lib$system$normalize$model$name$$default(convertedFromRubyModule);
+ }
+ });
+
+ var activemodel$adapter$lib$system$active$model$serializer$$default = activemodel$adapter$lib$system$active$model$serializer$$ActiveModelSerializer;
+ function ember$data$lib$system$container$proxy$$ContainerProxy(container) {
+ this.container = container;
+ }
+
+ ember$data$lib$system$container$proxy$$ContainerProxy.prototype.aliasedFactory = function (path, preLookup) {
+ var _this = this;
+
+ return {
+ create: function () {
+ if (preLookup) {
+ preLookup();
+ }
+
+ return _this.container.lookup(path);
+ }
+ };
+ };
+
+ ember$data$lib$system$container$proxy$$ContainerProxy.prototype.registerAlias = function (source, dest, preLookup) {
+ var factory = this.aliasedFactory(dest, preLookup);
+
+ return this.container.register(source, factory);
+ };
+
+ ember$data$lib$system$container$proxy$$ContainerProxy.prototype.registerDeprecation = function (deprecated, valid) {
+ var preLookupCallback = function () {
+ };
+
+ return this.registerAlias(deprecated, valid, preLookupCallback);
+ };
+
+ ember$data$lib$system$container$proxy$$ContainerProxy.prototype.registerDeprecations = function (proxyPairs) {
+ var i, proxyPair, deprecated, valid;
+
+ for (i = proxyPairs.length; i > 0; i--) {
+ proxyPair = proxyPairs[i - 1];
+ deprecated = proxyPair["deprecated"];
+ valid = proxyPair["valid"];
+
+ this.registerDeprecation(deprecated, valid);
+ }
+ };
+
+ var ember$data$lib$system$container$proxy$$default = ember$data$lib$system$container$proxy$$ContainerProxy;
+ var activemodel$adapter$lib$setup$container$$default = activemodel$adapter$lib$setup$container$$setupActiveModelAdapter;
+ function activemodel$adapter$lib$setup$container$$setupActiveModelAdapter(registry, application) {
+ var proxy = new ember$data$lib$system$container$proxy$$default(registry);
+ proxy.registerDeprecations([{ deprecated: "serializer:_ams", valid: "serializer:-active-model" }, { deprecated: "adapter:_ams", valid: "adapter:-active-model" }]);
+
+ registry.register("serializer:-active-model", activemodel$adapter$lib$system$active$model$serializer$$default);
+ registry.register("adapter:-active-model", activemodel$adapter$lib$system$active$model$adapter$$default);
+ }
+ var ember$data$lib$core$$DS = Ember.Namespace.create({
+ VERSION: '1.0.0-beta.19.2'
+ });
+
+ if (Ember.libraries) {
+ Ember.libraries.registerCoreLibrary('Ember Data', ember$data$lib$core$$DS.VERSION);
+ }
+
+ //jshint ignore: line
+ var ember$data$lib$core$$EMBER_DATA_FEATURES = {};
+
+ Ember.merge(Ember.FEATURES, ember$data$lib$core$$EMBER_DATA_FEATURES);
+
+ var ember$data$lib$core$$default = ember$data$lib$core$$DS;
+ var ember$data$lib$initializers$store$$default = ember$data$lib$initializers$store$$initializeStore;
+
+ /**
+ Configures a registry for use with an Ember-Data
+ store. Accepts an optional namespace argument.
+
+ @method initializeStore
+ @param {Ember.Registry} registry
+ @param {Object} [application] an application namespace
+ */
+ function ember$data$lib$initializers$store$$initializeStore(registry, application) {
+
+ registry.optionsForType("serializer", { singleton: false });
+ registry.optionsForType("adapter", { singleton: false });
+
+ if (application && application.Store) {
+ registry.register("store:application", application.Store);
+ }
+
+ // allow older names to be looked up
+
+ var proxy = new ember$data$lib$system$container$proxy$$default(registry);
+ proxy.registerDeprecations([{ deprecated: "serializer:_default", valid: "serializer:-default" }, { deprecated: "serializer:_rest", valid: "serializer:-rest" }, { deprecated: "adapter:_rest", valid: "adapter:-rest" }]);
+
+ // new go forward paths
+ registry.register("serializer:-default", ember$data$lib$serializers$json$serializer$$default);
+ registry.register("serializer:-rest", ember$data$lib$serializers$rest$serializer$$default);
+ registry.register("adapter:-rest", ember$data$lib$adapters$rest$adapter$$default);
+ }
+
+ var ember$data$lib$transforms$base$$default = Ember.Object.extend({
+ /**
+ When given a deserialized value from a record attribute this
+ method must return the serialized value.
+ Example
+ ```javascript
+ serialize: function(deserialized) {
+ return Ember.isEmpty(deserialized) ? null : Number(deserialized);
+ }
+ ```
+ @method serialize
+ @param deserialized The deserialized value
+ @return The serialized value
+ */
+ serialize: null,
+
+ /**
+ When given a serialize value from a JSON object this method must
+ return the deserialized value for the record attribute.
+ Example
+ ```javascript
+ deserialize: function(serialized) {
+ return empty(serialized) ? null : Number(serialized);
+ }
+ ```
+ @method deserialize
+ @param serialized The serialized value
+ @return The deserialized value
+ */
+ deserialize: null
+ });
+
+ var ember$data$lib$transforms$number$$empty = Ember.isEmpty;
+
+ function ember$data$lib$transforms$number$$isNumber(value) {
+ return value === value && value !== Infinity && value !== -Infinity;
+ }
+
+ var ember$data$lib$transforms$number$$default = ember$data$lib$transforms$base$$default.extend({
+ deserialize: function (serialized) {
+ var transformed;
+
+ if (ember$data$lib$transforms$number$$empty(serialized)) {
+ return null;
+ } else {
+ transformed = Number(serialized);
+
+ return ember$data$lib$transforms$number$$isNumber(transformed) ? transformed : null;
+ }
+ },
+
+ serialize: function (deserialized) {
+ var transformed;
+
+ if (ember$data$lib$transforms$number$$empty(deserialized)) {
+ return null;
+ } else {
+ transformed = Number(deserialized);
+
+ return ember$data$lib$transforms$number$$isNumber(transformed) ? transformed : null;
+ }
+ }
+ });
+
+ // Date.prototype.toISOString shim
+ // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString
+ var ember$data$lib$transforms$date$$toISOString = Date.prototype.toISOString || function () {
+ function pad(number) {
+ if (number < 10) {
+ return '0' + number;
+ }
+ return number;
+ }
+
+ return this.getUTCFullYear() + '-' + pad(this.getUTCMonth() + 1) + '-' + pad(this.getUTCDate()) + 'T' + pad(this.getUTCHours()) + ':' + pad(this.getUTCMinutes()) + ':' + pad(this.getUTCSeconds()) + '.' + (this.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';
+ };
+
+ if (Ember.SHIM_ES5) {
+ if (!Date.prototype.toISOString) {
+ Date.prototype.toISOString = ember$data$lib$transforms$date$$toISOString;
+ }
+ }
+
+ var ember$data$lib$transforms$date$$default = ember$data$lib$transforms$base$$default.extend({
+ deserialize: function (serialized) {
+ var type = typeof serialized;
+
+ if (type === 'string') {
+ return new Date(Ember.Date.parse(serialized));
+ } else if (type === 'number') {
+ return new Date(serialized);
+ } else if (serialized === null || serialized === undefined) {
+ // if the value is null return null
+ // if the value is not present in the data return undefined
+ return serialized;
+ } else {
+ return null;
+ }
+ },
+
+ serialize: function (date) {
+ if (date instanceof Date) {
+ return ember$data$lib$transforms$date$$toISOString.call(date);
+ } else {
+ return null;
+ }
+ }
+ });
+
+ var ember$data$lib$transforms$string$$none = Ember.isNone;
+
+ var ember$data$lib$transforms$string$$default = ember$data$lib$transforms$base$$default.extend({
+ deserialize: function (serialized) {
+ return ember$data$lib$transforms$string$$none(serialized) ? null : String(serialized);
+ },
+ serialize: function (deserialized) {
+ return ember$data$lib$transforms$string$$none(deserialized) ? null : String(deserialized);
+ }
+ });
+
+ var ember$data$lib$transforms$boolean$$default = ember$data$lib$transforms$base$$default.extend({
+ deserialize: function (serialized) {
+ var type = typeof serialized;
+
+ if (type === "boolean") {
+ return serialized;
+ } else if (type === "string") {
+ return serialized.match(/^true$|^t$|^1$/i) !== null;
+ } else if (type === "number") {
+ return serialized === 1;
+ } else {
+ return false;
+ }
+ },
+
+ serialize: function (deserialized) {
+ return Boolean(deserialized);
+ }
+ });
+
+ var ember$data$lib$initializers$transforms$$default = ember$data$lib$initializers$transforms$$initializeTransforms;
+
+ /**
+ Configures a registry for use with Ember-Data
+ transforms.
+
+ @method initializeTransforms
+ @param {Ember.Registry} registry
+ */
+ function ember$data$lib$initializers$transforms$$initializeTransforms(registry) {
+ registry.register('transform:boolean', ember$data$lib$transforms$boolean$$default);
+ registry.register('transform:date', ember$data$lib$transforms$date$$default);
+ registry.register('transform:number', ember$data$lib$transforms$number$$default);
+ registry.register('transform:string', ember$data$lib$transforms$string$$default);
+ }
+ var ember$data$lib$initializers$store$injections$$default = ember$data$lib$initializers$store$injections$$initializeStoreInjections;
+ /**
+ Configures a registry with injections on Ember applications
+ for the Ember-Data store. Accepts an optional namespace argument.
+
+ @method initializeStoreInjections
+ @param {Ember.Registry} registry
+ */
+ function ember$data$lib$initializers$store$injections$$initializeStoreInjections(registry) {
+ registry.injection('controller', 'store', 'store:main');
+ registry.injection('route', 'store', 'store:main');
+ registry.injection('data-adapter', 'store', 'store:main');
+ }var ember$data$lib$system$promise$proxies$$Promise = Ember.RSVP.Promise;
+ var ember$data$lib$system$promise$proxies$$get = Ember.get;
+
+ /**
+ A `PromiseArray` is an object that acts like both an `Ember.Array`
+ and a promise. When the promise is resolved the resulting value
+ will be set to the `PromiseArray`'s `content` property. This makes
+ it easy to create data bindings with the `PromiseArray` that will be
+ updated when the promise resolves.
+
+ For more information see the [Ember.PromiseProxyMixin
+ documentation](/api/classes/Ember.PromiseProxyMixin.html).
+
+ Example
+
+ ```javascript
+ var promiseArray = DS.PromiseArray.create({
+ promise: $.getJSON('/some/remote/data.json')
+ });
+
+ promiseArray.get('length'); // 0
+
+ promiseArray.then(function() {
+ promiseArray.get('length'); // 100
+ });
+ ```
+
+ @class PromiseArray
+ @namespace DS
+ @extends Ember.ArrayProxy
+ @uses Ember.PromiseProxyMixin
+ */
+ var ember$data$lib$system$promise$proxies$$PromiseArray = Ember.ArrayProxy.extend(Ember.PromiseProxyMixin);
+
+ /**
+ A `PromiseObject` is an object that acts like both an `Ember.Object`
+ and a promise. When the promise is resolved, then the resulting value
+ will be set to the `PromiseObject`'s `content` property. This makes
+ it easy to create data bindings with the `PromiseObject` that will
+ be updated when the promise resolves.
+
+ For more information see the [Ember.PromiseProxyMixin
+ documentation](/api/classes/Ember.PromiseProxyMixin.html).
+
+ Example
+
+ ```javascript
+ var promiseObject = DS.PromiseObject.create({
+ promise: $.getJSON('/some/remote/data.json')
+ });
+
+ promiseObject.get('name'); // null
+
+ promiseObject.then(function() {
+ promiseObject.get('name'); // 'Tomster'
+ });
+ ```
+
+ @class PromiseObject
+ @namespace DS
+ @extends Ember.ObjectProxy
+ @uses Ember.PromiseProxyMixin
+ */
+ var ember$data$lib$system$promise$proxies$$PromiseObject = Ember.ObjectProxy.extend(Ember.PromiseProxyMixin);
+
+ var ember$data$lib$system$promise$proxies$$promiseObject = function (promise, label) {
+ return ember$data$lib$system$promise$proxies$$PromiseObject.create({
+ promise: ember$data$lib$system$promise$proxies$$Promise.resolve(promise, label)
+ });
+ };
+
+ var ember$data$lib$system$promise$proxies$$promiseArray = function (promise, label) {
+ return ember$data$lib$system$promise$proxies$$PromiseArray.create({
+ promise: ember$data$lib$system$promise$proxies$$Promise.resolve(promise, label)
+ });
+ };
+
+ /**
+ A PromiseManyArray is a PromiseArray that also proxies certain method calls
+ to the underlying manyArray.
+ Right now we proxy:
+
+ * `reload()`
+ * `createRecord()`
+ * `on()`
+ * `one()`
+ * `trigger()`
+ * `off()`
+ * `has()`
+
+ @class PromiseManyArray
+ @namespace DS
+ @extends Ember.ArrayProxy
+ */
+
+ function ember$data$lib$system$promise$proxies$$proxyToContent(method) {
+ return function () {
+ var content = ember$data$lib$system$promise$proxies$$get(this, 'content');
+ return content[method].apply(content, arguments);
+ };
+ }
+
+ var ember$data$lib$system$promise$proxies$$PromiseManyArray = ember$data$lib$system$promise$proxies$$PromiseArray.extend({
+ reload: function () {
+ //I don't think this should ever happen right now, but worth guarding if we refactor the async relationships
+ return ember$data$lib$system$promise$proxies$$PromiseManyArray.create({
+ promise: ember$data$lib$system$promise$proxies$$get(this, 'content').reload()
+ });
+ },
+
+ createRecord: ember$data$lib$system$promise$proxies$$proxyToContent('createRecord'),
+
+ on: ember$data$lib$system$promise$proxies$$proxyToContent('on'),
+
+ one: ember$data$lib$system$promise$proxies$$proxyToContent('one'),
+
+ trigger: ember$data$lib$system$promise$proxies$$proxyToContent('trigger'),
+
+ off: ember$data$lib$system$promise$proxies$$proxyToContent('off'),
+
+ has: ember$data$lib$system$promise$proxies$$proxyToContent('has')
+ });
+
+ var ember$data$lib$system$promise$proxies$$promiseManyArray = function (promise, label) {
+ return ember$data$lib$system$promise$proxies$$PromiseManyArray.create({
+ promise: ember$data$lib$system$promise$proxies$$Promise.resolve(promise, label)
+ });
+ };
+
+ /**
+ @module ember-data
+ */
+
+ var ember$data$lib$system$model$model$$get = Ember.get;
+ var ember$data$lib$system$model$model$$intersection = Ember.EnumerableUtils.intersection;
+ var ember$data$lib$system$model$model$$RESERVED_MODEL_PROPS = ['currentState', 'data', 'store'];
+
+ var ember$data$lib$system$model$model$$retrieveFromCurrentState = Ember.computed('currentState', function (key) {
+ return ember$data$lib$system$model$model$$get(this._internalModel.currentState, key);
+ }).readOnly();
+
+ /**
+
+ The model class that all Ember Data records descend from.
+ This is the public API of Ember Data models. If you are using Ember Data
+ in your application, this is the class you should use.
+ If you are working on Ember Data internals, you most likely want to be dealing
+ with `InternalModel`
+
+ @class Model
+ @namespace DS
+ @extends Ember.Object
+ @uses Ember.Evented
+ */
+ var ember$data$lib$system$model$model$$Model = Ember.Object.extend(Ember.Evented, {
+ _recordArrays: undefined,
+ _relationships: undefined,
+ _internalModel: null,
+
+ store: null,
+
+ /**
+ If this property is `true` the record is in the `empty`
+ state. Empty is the first state all records enter after they have
+ been created. Most records created by the store will quickly
+ transition to the `loading` state if data needs to be fetched from
+ the server or the `created` state if the record is created on the
+ client. A record can also enter the empty state if the adapter is
+ unable to locate the record.
+ @property isEmpty
+ @type {Boolean}
+ @readOnly
+ */
+ isEmpty: ember$data$lib$system$model$model$$retrieveFromCurrentState,
+ /**
+ If this property is `true` the record is in the `loading` state. A
+ record enters this state when the store asks the adapter for its
+ data. It remains in this state until the adapter provides the
+ requested data.
+ @property isLoading
+ @type {Boolean}
+ @readOnly
+ */
+ isLoading: ember$data$lib$system$model$model$$retrieveFromCurrentState,
+ /**
+ If this property is `true` the record is in the `loaded` state. A
+ record enters this state when its data is populated. Most of a
+ record's lifecycle is spent inside substates of the `loaded`
+ state.
+ Example
+ ```javascript
+ var record = store.createRecord('model');
+ record.get('isLoaded'); // true
+ store.find('model', 1).then(function(model) {
+ model.get('isLoaded'); // true
+ });
+ ```
+ @property isLoaded
+ @type {Boolean}
+ @readOnly
+ */
+ isLoaded: ember$data$lib$system$model$model$$retrieveFromCurrentState,
+ /**
+ If this property is `true` the record is in the `dirty` state. The
+ record has local changes that have not yet been saved by the
+ adapter. This includes records that have been created (but not yet
+ saved) or deleted.
+ Example
+ ```javascript
+ var record = store.createRecord('model');
+ record.get('isDirty'); // true
+ store.find('model', 1).then(function(model) {
+ model.get('isDirty'); // false
+ model.set('foo', 'some value');
+ model.get('isDirty'); // true
+ });
+ ```
+ @property isDirty
+ @type {Boolean}
+ @readOnly
+ */
+ isDirty: ember$data$lib$system$model$model$$retrieveFromCurrentState,
+ /**
+ If this property is `true` the record is in the `saving` state. A
+ record enters the saving state when `save` is called, but the
+ adapter has not yet acknowledged that the changes have been
+ persisted to the backend.
+ Example
+ ```javascript
+ var record = store.createRecord('model');
+ record.get('isSaving'); // false
+ var promise = record.save();
+ record.get('isSaving'); // true
+ promise.then(function() {
+ record.get('isSaving'); // false
+ });
+ ```
+ @property isSaving
+ @type {Boolean}
+ @readOnly
+ */
+ isSaving: ember$data$lib$system$model$model$$retrieveFromCurrentState,
+ /**
+ If this property is `true` the record is in the `deleted` state
+ and has been marked for deletion. When `isDeleted` is true and
+ `isDirty` is true, the record is deleted locally but the deletion
+ was not yet persisted. When `isSaving` is true, the change is
+ in-flight. When both `isDirty` and `isSaving` are false, the
+ change has persisted.
+ Example
+ ```javascript
+ var record = store.createRecord('model');
+ record.get('isDeleted'); // false
+ record.deleteRecord();
+ // Locally deleted
+ record.get('isDeleted'); // true
+ record.get('isDirty'); // true
+ record.get('isSaving'); // false
+ // Persisting the deletion
+ var promise = record.save();
+ record.get('isDeleted'); // true
+ record.get('isSaving'); // true
+ // Deletion Persisted
+ promise.then(function() {
+ record.get('isDeleted'); // true
+ record.get('isSaving'); // false
+ record.get('isDirty'); // false
+ });
+ ```
+ @property isDeleted
+ @type {Boolean}
+ @readOnly
+ */
+ isDeleted: ember$data$lib$system$model$model$$retrieveFromCurrentState,
+ /**
+ If this property is `true` the record is in the `new` state. A
+ record will be in the `new` state when it has been created on the
+ client and the adapter has not yet report that it was successfully
+ saved.
+ Example
+ ```javascript
+ var record = store.createRecord('model');
+ record.get('isNew'); // true
+ record.save().then(function(model) {
+ model.get('isNew'); // false
+ });
+ ```
+ @property isNew
+ @type {Boolean}
+ @readOnly
+ */
+ isNew: ember$data$lib$system$model$model$$retrieveFromCurrentState,
+ /**
+ If this property is `true` the record is in the `valid` state.
+ A record will be in the `valid` state when the adapter did not report any
+ server-side validation failures.
+ @property isValid
+ @type {Boolean}
+ @readOnly
+ */
+ isValid: ember$data$lib$system$model$model$$retrieveFromCurrentState,
+ /**
+ If the record is in the dirty state this property will report what
+ kind of change has caused it to move into the dirty
+ state. Possible values are:
+ - `created` The record has been created by the client and not yet saved to the adapter.
+ - `updated` The record has been updated by the client and not yet saved to the adapter.
+ - `deleted` The record has been deleted by the client and not yet saved to the adapter.
+ Example
+ ```javascript
+ var record = store.createRecord('model');
+ record.get('dirtyType'); // 'created'
+ ```
+ @property dirtyType
+ @type {String}
+ @readOnly
+ */
+ dirtyType: ember$data$lib$system$model$model$$retrieveFromCurrentState,
+
+ /**
+ If `true` the adapter reported that it was unable to save local
+ changes to the backend for any reason other than a server-side
+ validation error.
+ Example
+ ```javascript
+ record.get('isError'); // false
+ record.set('foo', 'valid value');
+ record.save().then(null, function() {
+ record.get('isError'); // true
+ });
+ ```
+ @property isError
+ @type {Boolean}
+ @readOnly
+ */
+ isError: false,
+
+ /**
+ If `true` the store is attempting to reload the record form the adapter.
+ Example
+ ```javascript
+ record.get('isReloading'); // false
+ record.reload();
+ record.get('isReloading'); // true
+ ```
+ @property isReloading
+ @type {Boolean}
+ @readOnly
+ */
+ isReloading: false,
+
+ /**
+ All ember models have an id property. This is an identifier
+ managed by an external source. These are always coerced to be
+ strings before being used internally. Note when declaring the
+ attributes for a model it is an error to declare an id
+ attribute.
+ ```javascript
+ var record = store.createRecord('model');
+ record.get('id'); // null
+ store.find('model', 1).then(function(model) {
+ model.get('id'); // '1'
+ });
+ ```
+ @property id
+ @type {String}
+ */
+ id: null,
+
+ /**
+ @property currentState
+ @private
+ @type {Object}
+ */
+
+ /**
+ When the record is in the `invalid` state this object will contain
+ any errors returned by the adapter. When present the errors hash
+ contains keys corresponding to the invalid property names
+ and values which are arrays of Javascript objects with two keys:
+ - `message` A string containing the error message from the backend
+ - `attribute` The name of the property associated with this error message
+ ```javascript
+ record.get('errors.length'); // 0
+ record.set('foo', 'invalid value');
+ record.save().catch(function() {
+ record.get('errors').get('foo');
+ // [{message: 'foo should be a number.', attribute: 'foo'}]
+ });
+ ```
+ The `errors` property us useful for displaying error messages to
+ the user.
+ ```handlebars
+
+ {{#each model.errors.username as |error|}}
+
+ {{error.message}}
+
+ {{/each}}
+
+ {{#each model.errors.email as |error|}}
+
+ {{error.message}}
+
+ {{/each}}
+ ```
+ You can also access the special `messages` property on the error
+ object to get an array of all the error strings.
+ ```handlebars
+ {{#each model.errors.messages as |message|}}
+
+ {{message}}
+
+ {{/each}}
+ ```
+ @property errors
+ @type {DS.Errors}
+ */
+ errors: Ember.computed(function () {
+ return this._internalModel.getErrors();
+ }).readOnly(),
+
+ /**
+ Create a JSON representation of the record, using the serialization
+ strategy of the store's adapter.
+ `serialize` takes an optional hash as a parameter, currently
+ supported options are:
+ - `includeId`: `true` if the record's ID should be included in the
+ JSON representation.
+ @method serialize
+ @param {Object} options
+ @return {Object} an object whose values are primitive JSON values only
+ */
+ serialize: function (options) {
+ return this.store.serialize(this, options);
+ },
+
+ /**
+ Use [DS.JSONSerializer](DS.JSONSerializer.html) to
+ get the JSON representation of a record.
+ `toJSON` takes an optional hash as a parameter, currently
+ supported options are:
+ - `includeId`: `true` if the record's ID should be included in the
+ JSON representation.
+ @method toJSON
+ @param {Object} options
+ @return {Object} A JSON representation of the object.
+ */
+ toJSON: function (options) {
+ // container is for lazy transform lookups
+ var serializer = this.store.serializerFor('-default');
+ var snapshot = this._internalModel.createSnapshot();
+
+ return serializer.serialize(snapshot, options);
+ },
+
+ /**
+ Fired when the record is ready to be interacted with,
+ that is either loaded from the server or created locally.
+ @event ready
+ */
+ ready: Ember.K,
+
+ /**
+ Fired when the record is loaded from the server.
+ @event didLoad
+ */
+ didLoad: Ember.K,
+
+ /**
+ Fired when the record is updated.
+ @event didUpdate
+ */
+ didUpdate: Ember.K,
+
+ /**
+ Fired when a new record is commited to the server.
+ @event didCreate
+ */
+ didCreate: Ember.K,
+
+ /**
+ Fired when the record is deleted.
+ @event didDelete
+ */
+ didDelete: Ember.K,
+
+ /**
+ Fired when the record becomes invalid.
+ @event becameInvalid
+ */
+ becameInvalid: Ember.K,
+
+ /**
+ Fired when the record enters the error state.
+ @event becameError
+ */
+ becameError: Ember.K,
+
+ /**
+ Fired when the record is rolled back.
+ @event rolledBack
+ */
+ rolledBack: Ember.K,
+
+ /**
+ @property data
+ @private
+ @type {Object}
+ */
+ data: Ember.computed.readOnly('_internalModel._data'),
+
+ //TODO Do we want to deprecate these?
+ /**
+ @method send
+ @private
+ @param {String} name
+ @param {Object} context
+ */
+ send: function (name, context) {
+ return this._internalModel.send(name, context);
+ },
+
+ /**
+ @method transitionTo
+ @private
+ @param {String} name
+ */
+ transitionTo: function (name) {
+ return this._internalModel.transitionTo(name);
+ },
+
+ /**
+ Marks the record as deleted but does not save it. You must call
+ `save` afterwards if you want to persist it. You might use this
+ method if you want to allow the user to still `rollback()` a
+ delete after it was made.
+ Example
+ ```app/routes/model/delete.js
+ import Ember from 'ember';
+ export default Ember.Route.extend({
+ actions: {
+ softDelete: function() {
+ this.controller.get('model').deleteRecord();
+ },
+ confirm: function() {
+ this.controller.get('model').save();
+ },
+ undo: function() {
+ this.controller.get('model').rollback();
+ }
+ }
+ });
+ ```
+ @method deleteRecord
+ */
+ deleteRecord: function () {
+ this._internalModel.deleteRecord();
+ },
+
+ /**
+ Same as `deleteRecord`, but saves the record immediately.
+ Example
+ ```app/routes/model/delete.js
+ import Ember from 'ember';
+ export default Ember.Route.extend({
+ actions: {
+ delete: function() {
+ var controller = this.controller;
+ controller.get('model').destroyRecord().then(function() {
+ controller.transitionToRoute('model.index');
+ });
+ }
+ }
+ });
+ ```
+ @method destroyRecord
+ @return {Promise} a promise that will be resolved when the adapter returns
+ successfully or rejected if the adapter returns with an error.
+ */
+ destroyRecord: function () {
+ this.deleteRecord();
+ return this.save();
+ },
+
+ /**
+ @method unloadRecord
+ @private
+ */
+ unloadRecord: function () {
+ if (this.isDestroyed) {
+ return;
+ }
+ this._internalModel.unloadRecord();
+ },
+
+ /**
+ @method _notifyProperties
+ @private
+ */
+ _notifyProperties: function (keys) {
+ Ember.beginPropertyChanges();
+ var key;
+ for (var i = 0, length = keys.length; i < length; i++) {
+ key = keys[i];
+ this.notifyPropertyChange(key);
+ }
+ Ember.endPropertyChanges();
+ },
+
+ /**
+ Returns an object, whose keys are changed properties, and value is
+ an [oldProp, newProp] array.
+ Example
+ ```app/models/mascot.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ name: attr('string')
+ });
+ ```
+ ```javascript
+ var mascot = store.createRecord('mascot');
+ mascot.changedAttributes(); // {}
+ mascot.set('name', 'Tomster');
+ mascot.changedAttributes(); // {name: [undefined, 'Tomster']}
+ ```
+ @method changedAttributes
+ @return {Object} an object, whose keys are changed properties,
+ and value is an [oldProp, newProp] array.
+ */
+ changedAttributes: function () {
+ var oldData = ember$data$lib$system$model$model$$get(this._internalModel, '_data');
+ var newData = ember$data$lib$system$model$model$$get(this._internalModel, '_attributes');
+ var diffData = Ember.create(null);
+ var prop;
+
+ for (prop in newData) {
+ diffData[prop] = [oldData[prop], newData[prop]];
+ }
+
+ return diffData;
+ },
+
+ //TODO discuss with tomhuda about events/hooks
+ //Bring back as hooks?
+ /**
+ @method adapterWillCommit
+ @private
+ adapterWillCommit: function() {
+ this.send('willCommit');
+ },
+ /**
+ @method adapterDidDirty
+ @private
+ adapterDidDirty: function() {
+ this.send('becomeDirty');
+ this.updateRecordArraysLater();
+ },
+ */
+
+ /**
+ If the model `isDirty` this function will discard any unsaved
+ changes. If the model `isNew` it will be removed from the store.
+ Example
+ ```javascript
+ record.get('name'); // 'Untitled Document'
+ record.set('name', 'Doc 1');
+ record.get('name'); // 'Doc 1'
+ record.rollback();
+ record.get('name'); // 'Untitled Document'
+ ```
+ @method rollback
+ */
+ rollback: function () {
+ this._internalModel.rollback();
+ },
+
+ /*
+ @method _createSnapshot
+ @private
+ */
+ _createSnapshot: function () {
+ return this._internalModel.createSnapshot();
+ },
+
+ toStringExtension: function () {
+ return ember$data$lib$system$model$model$$get(this, 'id');
+ },
+
+ /**
+ Save the record and persist any changes to the record to an
+ external source via the adapter.
+ Example
+ ```javascript
+ record.set('name', 'Tomster');
+ record.save().then(function() {
+ // Success callback
+ }, function() {
+ // Error callback
+ });
+ ```
+ @method save
+ @return {Promise} a promise that will be resolved when the adapter returns
+ successfully or rejected if the adapter returns with an error.
+ */
+ save: function () {
+ var model = this;
+ return ember$data$lib$system$promise$proxies$$PromiseObject.create({
+ promise: this._internalModel.save().then(function () {
+ return model;
+ })
+ });
+ },
+
+ /**
+ Reload the record from the adapter.
+ This will only work if the record has already finished loading
+ and has not yet been modified (`isLoaded` but not `isDirty`,
+ or `isSaving`).
+ Example
+ ```app/routes/model/view.js
+ import Ember from 'ember';
+ export default Ember.Route.extend({
+ actions: {
+ reload: function() {
+ this.controller.get('model').reload().then(function(model) {
+ // do something with the reloaded model
+ });
+ }
+ }
+ });
+ ```
+ @method reload
+ @return {Promise} a promise that will be resolved with the record when the
+ adapter returns successfully or rejected if the adapter returns
+ with an error.
+ */
+ reload: function () {
+ var model = this;
+ return ember$data$lib$system$promise$proxies$$PromiseObject.create({
+ promise: this._internalModel.reload().then(function () {
+ return model;
+ })
+ });
+ },
+
+ /**
+ Override the default event firing from Ember.Evented to
+ also call methods with the given name.
+ @method trigger
+ @private
+ @param {String} name
+ */
+ trigger: function (name) {
+ var length = arguments.length;
+ var args = new Array(length - 1);
+
+ for (var i = 1; i < length; i++) {
+ args[i - 1] = arguments[i];
+ }
+
+ Ember.tryInvoke(this, name, args);
+ this._super.apply(this, arguments);
+ },
+
+ willDestroy: function () {
+ //TODO Move!
+ this._internalModel.clearRelationships();
+ this._internalModel.recordObjectWillDestroy();
+ this._super.apply(this, arguments);
+ //TODO should we set internalModel to null here?
+ },
+
+ // This is a temporary solution until we refactor DS.Model to not
+ // rely on the data property.
+ willMergeMixin: function (props) {
+ var constructor = this.constructor;
+ },
+
+ attr: function () {
+ },
+
+ belongsTo: function () {
+ },
+
+ hasMany: function () {
+ }
+ });
+
+ ember$data$lib$system$model$model$$Model.reopenClass({
+ /**
+ Alias DS.Model's `create` method to `_create`. This allows us to create DS.Model
+ instances from within the store, but if end users accidentally call `create()`
+ (instead of `createRecord()`), we can raise an error.
+ @method _create
+ @private
+ @static
+ */
+ _create: ember$data$lib$system$model$model$$Model.create,
+
+ /**
+ Override the class' `create()` method to raise an error. This
+ prevents end users from inadvertently calling `create()` instead
+ of `createRecord()`. The store is still able to create instances
+ by calling the `_create()` method. To create an instance of a
+ `DS.Model` use [store.createRecord](DS.Store.html#method_createRecord).
+ @method create
+ @private
+ @static
+ */
+ create: function () {
+ throw new Ember.Error('You should not call `create` on a model. Instead, call `store.createRecord` with the attributes you would like to set.');
+ },
+
+ /**
+ Represents the model's class name as a string. This can be used to look up the model through
+ DS.Store's modelFor method.
+ `modelName` is generated for you by Ember Data. It will be a lowercased, dasherized string.
+ For example:
+ ```javascript
+ store.modelFor('post').modelName; // 'post'
+ store.modelFor('blog-post').modelName; // 'blog-post'
+ ```
+ The most common place you'll want to access `modelName` is in your serializer's `payloadKeyFromModelName` method. For example, to change payload
+ keys to underscore (instead of dasherized), you might use the following code:
+ ```javascript
+ export default var PostSerializer = DS.RESTSerializer.extend({
+ payloadKeyFromModelName: function(modelName) {
+ return Ember.String.underscore(modelName);
+ }
+ });
+ ```
+ @property
+ @type String
+ @readonly
+ */
+ modelName: null
+ });
+
+ var ember$data$lib$system$model$model$$default = ember$data$lib$system$model$model$$Model;
+ var ember$data$lib$utils$supports$computed$getter$setter$$supportsComputedGetterSetter;
+
+ try {
+ Ember.computed({
+ get: function () {},
+ set: function () {}
+ });
+ ember$data$lib$utils$supports$computed$getter$setter$$supportsComputedGetterSetter = true;
+ } catch (e) {
+ ember$data$lib$utils$supports$computed$getter$setter$$supportsComputedGetterSetter = false;
+ }
+
+ var ember$data$lib$utils$supports$computed$getter$setter$$default = ember$data$lib$utils$supports$computed$getter$setter$$supportsComputedGetterSetter;
+
+ var ember$data$lib$utils$computed$polyfill$$computed = Ember.computed;
+
+ var ember$data$lib$utils$computed$polyfill$$default = function () {
+ var polyfillArguments = [];
+ var config = arguments[arguments.length - 1];
+
+ if (typeof config === 'function' || ember$data$lib$utils$supports$computed$getter$setter$$default) {
+ return ember$data$lib$utils$computed$polyfill$$computed.apply(null, arguments);
+ }
+
+ for (var i = 0, l = arguments.length - 1; i < l; i++) {
+ polyfillArguments.push(arguments[i]);
+ }
+
+ var func;
+ if (config.set) {
+ func = function (key, value) {
+ if (arguments.length > 1) {
+ return config.set.call(this, key, value);
+ } else {
+ return config.get.call(this, key);
+ }
+ };
+ } else {
+ func = function (key) {
+ return config.get.call(this, key);
+ };
+ }
+
+ polyfillArguments.push(func);
+
+ return ember$data$lib$utils$computed$polyfill$$computed.apply(null, polyfillArguments);
+ };
+
+ var ember$data$lib$system$model$attributes$$default = ember$data$lib$system$model$attributes$$attr;
+
+ /**
+ @module ember-data
+ */
+
+ var ember$data$lib$system$model$attributes$$get = Ember.get;
+
+ /**
+ @class Model
+ @namespace DS
+ */
+ ember$data$lib$system$model$model$$default.reopenClass({
+ /**
+ A map whose keys are the attributes of the model (properties
+ described by DS.attr) and whose values are the meta object for the
+ property.
+ Example
+ ```app/models/person.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ firstName: attr('string'),
+ lastName: attr('string'),
+ birthday: attr('date')
+ });
+ ```
+ ```javascript
+ import Ember from 'ember';
+ import Person from 'app/models/person';
+ var attributes = Ember.get(Person, 'attributes')
+ attributes.forEach(function(name, meta) {
+ console.log(name, meta);
+ });
+ // prints:
+ // firstName {type: "string", isAttribute: true, options: Object, parentType: function, name: "firstName"}
+ // lastName {type: "string", isAttribute: true, options: Object, parentType: function, name: "lastName"}
+ // birthday {type: "date", isAttribute: true, options: Object, parentType: function, name: "birthday"}
+ ```
+ @property attributes
+ @static
+ @type {Ember.Map}
+ @readOnly
+ */
+ attributes: Ember.computed(function () {
+ var map = ember$data$lib$system$map$$Map.create();
+
+ this.eachComputedProperty(function (name, meta) {
+ if (meta.isAttribute) {
+
+ meta.name = name;
+ map.set(name, meta);
+ }
+ });
+
+ return map;
+ }).readOnly(),
+
+ /**
+ A map whose keys are the attributes of the model (properties
+ described by DS.attr) and whose values are type of transformation
+ applied to each attribute. This map does not include any
+ attributes that do not have an transformation type.
+ Example
+ ```app/models/person.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ firstName: attr(),
+ lastName: attr('string'),
+ birthday: attr('date')
+ });
+ ```
+ ```javascript
+ import Ember from 'ember';
+ import Person from 'app/models/person';
+ var transformedAttributes = Ember.get(Person, 'transformedAttributes')
+ transformedAttributes.forEach(function(field, type) {
+ console.log(field, type);
+ });
+ // prints:
+ // lastName string
+ // birthday date
+ ```
+ @property transformedAttributes
+ @static
+ @type {Ember.Map}
+ @readOnly
+ */
+ transformedAttributes: Ember.computed(function () {
+ var map = ember$data$lib$system$map$$Map.create();
+
+ this.eachAttribute(function (key, meta) {
+ if (meta.type) {
+ map.set(key, meta.type);
+ }
+ });
+
+ return map;
+ }).readOnly(),
+
+ /**
+ Iterates through the attributes of the model, calling the passed function on each
+ attribute.
+ The callback method you provide should have the following signature (all
+ parameters are optional):
+ ```javascript
+ function(name, meta);
+ ```
+ - `name` the name of the current property in the iteration
+ - `meta` the meta object for the attribute property in the iteration
+ Note that in addition to a callback, you can also pass an optional target
+ object that will be set as `this` on the context.
+ Example
+ ```javascript
+ import DS from 'ember-data';
+ var Person = DS.Model.extend({
+ firstName: attr('string'),
+ lastName: attr('string'),
+ birthday: attr('date')
+ });
+ Person.eachAttribute(function(name, meta) {
+ console.log(name, meta);
+ });
+ // prints:
+ // firstName {type: "string", isAttribute: true, options: Object, parentType: function, name: "firstName"}
+ // lastName {type: "string", isAttribute: true, options: Object, parentType: function, name: "lastName"}
+ // birthday {type: "date", isAttribute: true, options: Object, parentType: function, name: "birthday"}
+ ```
+ @method eachAttribute
+ @param {Function} callback The callback to execute
+ @param {Object} [binding] the value to which the callback's `this` should be bound
+ @static
+ */
+ eachAttribute: function (callback, binding) {
+ ember$data$lib$system$model$attributes$$get(this, "attributes").forEach(function (meta, name) {
+ callback.call(binding, name, meta);
+ }, binding);
+ },
+
+ /**
+ Iterates through the transformedAttributes of the model, calling
+ the passed function on each attribute. Note the callback will not be
+ called for any attributes that do not have an transformation type.
+ The callback method you provide should have the following signature (all
+ parameters are optional):
+ ```javascript
+ function(name, type);
+ ```
+ - `name` the name of the current property in the iteration
+ - `type` a string containing the name of the type of transformed
+ applied to the attribute
+ Note that in addition to a callback, you can also pass an optional target
+ object that will be set as `this` on the context.
+ Example
+ ```javascript
+ import DS from 'ember-data';
+ var Person = DS.Model.extend({
+ firstName: attr(),
+ lastName: attr('string'),
+ birthday: attr('date')
+ });
+ Person.eachTransformedAttribute(function(name, type) {
+ console.log(name, type);
+ });
+ // prints:
+ // lastName string
+ // birthday date
+ ```
+ @method eachTransformedAttribute
+ @param {Function} callback The callback to execute
+ @param {Object} [binding] the value to which the callback's `this` should be bound
+ @static
+ */
+ eachTransformedAttribute: function (callback, binding) {
+ ember$data$lib$system$model$attributes$$get(this, "transformedAttributes").forEach(function (type, name) {
+ callback.call(binding, name, type);
+ });
+ }
+ });
+
+ ember$data$lib$system$model$model$$default.reopen({
+ eachAttribute: function (callback, binding) {
+ this.constructor.eachAttribute(callback, binding);
+ }
+ });
+
+ function ember$data$lib$system$model$attributes$$getDefaultValue(record, options, key) {
+ if (typeof options.defaultValue === "function") {
+ return options.defaultValue.apply(null, arguments);
+ } else {
+ return options.defaultValue;
+ }
+ }
+
+ function ember$data$lib$system$model$attributes$$hasValue(record, key) {
+ return key in record._attributes || key in record._inFlightAttributes || key in record._data;
+ }
+
+ function ember$data$lib$system$model$attributes$$getValue(record, key) {
+ if (key in record._attributes) {
+ return record._attributes[key];
+ } else if (key in record._inFlightAttributes) {
+ return record._inFlightAttributes[key];
+ } else {
+ return record._data[key];
+ }
+ }
+
+ /**
+ `DS.attr` defines an attribute on a [DS.Model](/api/data/classes/DS.Model.html).
+ By default, attributes are passed through as-is, however you can specify an
+ optional type to have the value automatically transformed.
+ Ember Data ships with four basic transform types: `string`, `number`,
+ `boolean` and `date`. You can define your own transforms by subclassing
+ [DS.Transform](/api/data/classes/DS.Transform.html).
+
+ Note that you cannot use `attr` to define an attribute of `id`.
+
+ `DS.attr` takes an optional hash as a second parameter, currently
+ supported options are:
+
+ - `defaultValue`: Pass a string or a function to be called to set the attribute
+ to a default value if none is supplied.
+
+ Example
+
+ ```app/models/user.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ username: DS.attr('string'),
+ email: DS.attr('string'),
+ verified: DS.attr('boolean', {defaultValue: false})
+ });
+ ```
+
+ Default value can also be a function. This is useful it you want to return
+ a new object for each attribute.
+
+ ```app/models/user.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ username: attr('string'),
+ email: attr('string'),
+ settings: attr({defaultValue: function() {
+ return {};
+ }})
+ });
+ ```
+
+ @namespace
+ @method attr
+ @for DS
+ @param {String} type the attribute type
+ @param {Object} options a hash of options
+ @return {Attribute}
+ */
+ function ember$data$lib$system$model$attributes$$attr(type, options) {
+ if (typeof type === "object") {
+ options = type;
+ type = undefined;
+ } else {
+ options = options || {};
+ }
+
+ var meta = {
+ type: type,
+ isAttribute: true,
+ options: options
+ };
+
+ return ember$data$lib$utils$computed$polyfill$$default({
+ get: function (key) {
+ var internalModel = this._internalModel;
+ if (ember$data$lib$system$model$attributes$$hasValue(internalModel, key)) {
+ return ember$data$lib$system$model$attributes$$getValue(internalModel, key);
+ } else {
+ return ember$data$lib$system$model$attributes$$getDefaultValue(this, options, key);
+ }
+ },
+ set: function (key, value) {
+ var internalModel = this._internalModel;
+ var oldValue = ember$data$lib$system$model$attributes$$getValue(internalModel, key);
+
+ if (value !== oldValue) {
+ // Add the new value to the changed attributes hash; it will get deleted by
+ // the 'didSetProperty' handler if it is no different from the original value
+ internalModel._attributes[key] = value;
+
+ this._internalModel.send("didSetProperty", {
+ name: key,
+ oldValue: oldValue,
+ originalValue: internalModel._data[key],
+ value: value
+ });
+ }
+
+ return value;
+ }
+ }).meta(meta);
+ }
+
+ var ember$data$lib$system$model$states$$get = Ember.get;
+ /*
+ This file encapsulates the various states that a record can transition
+ through during its lifecycle.
+ */
+ /**
+ ### State
+
+ Each record has a `currentState` property that explicitly tracks what
+ state a record is in at any given time. For instance, if a record is
+ newly created and has not yet been sent to the adapter to be saved,
+ it would be in the `root.loaded.created.uncommitted` state. If a
+ record has had local modifications made to it that are in the
+ process of being saved, the record would be in the
+ `root.loaded.updated.inFlight` state. (This state paths will be
+ explained in more detail below.)
+
+ Events are sent by the record or its store to the record's
+ `currentState` property. How the state reacts to these events is
+ dependent on which state it is in. In some states, certain events
+ will be invalid and will cause an exception to be raised.
+
+ States are hierarchical and every state is a substate of the
+ `RootState`. For example, a record can be in the
+ `root.deleted.uncommitted` state, then transition into the
+ `root.deleted.inFlight` state. If a child state does not implement
+ an event handler, the state manager will attempt to invoke the event
+ on all parent states until the root state is reached. The state
+ hierarchy of a record is described in terms of a path string. You
+ can determine a record's current state by getting the state's
+ `stateName` property:
+
+ ```javascript
+ record.get('currentState.stateName');
+ //=> "root.created.uncommitted"
+ ```
+
+ The hierarchy of valid states that ship with ember data looks like
+ this:
+
+ ```text
+ * root
+ * deleted
+ * saved
+ * uncommitted
+ * inFlight
+ * empty
+ * loaded
+ * created
+ * uncommitted
+ * inFlight
+ * saved
+ * updated
+ * uncommitted
+ * inFlight
+ * loading
+ ```
+
+ The `DS.Model` states are themselves stateless. What that means is
+ that, the hierarchical states that each of *those* points to is a
+ shared data structure. For performance reasons, instead of each
+ record getting its own copy of the hierarchy of states, each record
+ points to this global, immutable shared instance. How does a state
+ know which record it should be acting on? We pass the record
+ instance into the state's event handlers as the first argument.
+
+ The record passed as the first parameter is where you should stash
+ state about the record if needed; you should never store data on the state
+ object itself.
+
+ ### Events and Flags
+
+ A state may implement zero or more events and flags.
+
+ #### Events
+
+ Events are named functions that are invoked when sent to a record. The
+ record will first look for a method with the given name on the
+ current state. If no method is found, it will search the current
+ state's parent, and then its grandparent, and so on until reaching
+ the top of the hierarchy. If the root is reached without an event
+ handler being found, an exception will be raised. This can be very
+ helpful when debugging new features.
+
+ Here's an example implementation of a state with a `myEvent` event handler:
+
+ ```javascript
+ aState: DS.State.create({
+ myEvent: function(manager, param) {
+ console.log("Received myEvent with", param);
+ }
+ })
+ ```
+
+ To trigger this event:
+
+ ```javascript
+ record.send('myEvent', 'foo');
+ //=> "Received myEvent with foo"
+ ```
+
+ Note that an optional parameter can be sent to a record's `send()` method,
+ which will be passed as the second parameter to the event handler.
+
+ Events should transition to a different state if appropriate. This can be
+ done by calling the record's `transitionTo()` method with a path to the
+ desired state. The state manager will attempt to resolve the state path
+ relative to the current state. If no state is found at that path, it will
+ attempt to resolve it relative to the current state's parent, and then its
+ parent, and so on until the root is reached. For example, imagine a hierarchy
+ like this:
+
+ * created
+ * uncommitted <-- currentState
+ * inFlight
+ * updated
+ * inFlight
+
+ If we are currently in the `uncommitted` state, calling
+ `transitionTo('inFlight')` would transition to the `created.inFlight` state,
+ while calling `transitionTo('updated.inFlight')` would transition to
+ the `updated.inFlight` state.
+
+ Remember that *only events* should ever cause a state transition. You should
+ never call `transitionTo()` from outside a state's event handler. If you are
+ tempted to do so, create a new event and send that to the state manager.
+
+ #### Flags
+
+ Flags are Boolean values that can be used to introspect a record's current
+ state in a more user-friendly way than examining its state path. For example,
+ instead of doing this:
+
+ ```javascript
+ var statePath = record.get('stateManager.currentPath');
+ if (statePath === 'created.inFlight') {
+ doSomething();
+ }
+ ```
+
+ You can say:
+
+ ```javascript
+ if (record.get('isNew') && record.get('isSaving')) {
+ doSomething();
+ }
+ ```
+
+ If your state does not set a value for a given flag, the value will
+ be inherited from its parent (or the first place in the state hierarchy
+ where it is defined).
+
+ The current set of flags are defined below. If you want to add a new flag,
+ in addition to the area below, you will also need to declare it in the
+ `DS.Model` class.
+
+
+ * [isEmpty](DS.Model.html#property_isEmpty)
+ * [isLoading](DS.Model.html#property_isLoading)
+ * [isLoaded](DS.Model.html#property_isLoaded)
+ * [isDirty](DS.Model.html#property_isDirty)
+ * [isSaving](DS.Model.html#property_isSaving)
+ * [isDeleted](DS.Model.html#property_isDeleted)
+ * [isNew](DS.Model.html#property_isNew)
+ * [isValid](DS.Model.html#property_isValid)
+
+ @namespace DS
+ @class RootState
+ */
+
+ function ember$data$lib$system$model$states$$didSetProperty(internalModel, context) {
+ if (context.value === context.originalValue) {
+ delete internalModel._attributes[context.name];
+ internalModel.send('propertyWasReset', context.name);
+ } else if (context.value !== context.oldValue) {
+ internalModel.send('becomeDirty');
+ }
+
+ internalModel.updateRecordArraysLater();
+ }
+
+ // Implementation notes:
+ //
+ // Each state has a boolean value for all of the following flags:
+ //
+ // * isLoaded: The record has a populated `data` property. When a
+ // record is loaded via `store.find`, `isLoaded` is false
+ // until the adapter sets it. When a record is created locally,
+ // its `isLoaded` property is always true.
+ // * isDirty: The record has local changes that have not yet been
+ // saved by the adapter. This includes records that have been
+ // created (but not yet saved) or deleted.
+ // * isSaving: The record has been committed, but
+ // the adapter has not yet acknowledged that the changes have
+ // been persisted to the backend.
+ // * isDeleted: The record was marked for deletion. When `isDeleted`
+ // is true and `isDirty` is true, the record is deleted locally
+ // but the deletion was not yet persisted. When `isSaving` is
+ // true, the change is in-flight. When both `isDirty` and
+ // `isSaving` are false, the change has persisted.
+ // * isError: The adapter reported that it was unable to save
+ // local changes to the backend. This may also result in the
+ // record having its `isValid` property become false if the
+ // adapter reported that server-side validations failed.
+ // * isNew: The record was created on the client and the adapter
+ // did not yet report that it was successfully saved.
+ // * isValid: The adapter did not report any server-side validation
+ // failures.
+
+ // The dirty state is a abstract state whose functionality is
+ // shared between the `created` and `updated` states.
+ //
+ // The deleted state shares the `isDirty` flag with the
+ // subclasses of `DirtyState`, but with a very different
+ // implementation.
+ //
+ // Dirty states have three child states:
+ //
+ // `uncommitted`: the store has not yet handed off the record
+ // to be saved.
+ // `inFlight`: the store has handed off the record to be saved,
+ // but the adapter has not yet acknowledged success.
+ // `invalid`: the record has invalid information and cannot be
+ // send to the adapter yet.
+ var ember$data$lib$system$model$states$$DirtyState = {
+ initialState: 'uncommitted',
+
+ // FLAGS
+ isDirty: true,
+
+ // SUBSTATES
+
+ // When a record first becomes dirty, it is `uncommitted`.
+ // This means that there are local pending changes, but they
+ // have not yet begun to be saved, and are not invalid.
+ uncommitted: {
+ // EVENTS
+ didSetProperty: ember$data$lib$system$model$states$$didSetProperty,
+
+ //TODO(Igor) reloading now triggers a
+ //loadingData event, though it seems fine?
+ loadingData: Ember.K,
+
+ propertyWasReset: function (internalModel, name) {
+ var length = Ember.keys(internalModel._attributes).length;
+ var stillDirty = length > 0;
+
+ if (!stillDirty) {
+ internalModel.send('rolledBack');
+ }
+ },
+
+ pushedData: Ember.K,
+
+ becomeDirty: Ember.K,
+
+ willCommit: function (internalModel) {
+ internalModel.transitionTo('inFlight');
+ },
+
+ reloadRecord: function (internalModel, resolve) {
+ resolve(internalModel.store.reloadRecord(internalModel));
+ },
+
+ rolledBack: function (internalModel) {
+ internalModel.transitionTo('loaded.saved');
+ },
+
+ becameInvalid: function (internalModel) {
+ internalModel.transitionTo('invalid');
+ },
+
+ rollback: function (internalModel) {
+ internalModel.rollback();
+ internalModel.triggerLater('ready');
+ }
+ },
+
+ // Once a record has been handed off to the adapter to be
+ // saved, it is in the 'in flight' state. Changes to the
+ // record cannot be made during this window.
+ inFlight: {
+ // FLAGS
+ isSaving: true,
+
+ // EVENTS
+ didSetProperty: ember$data$lib$system$model$states$$didSetProperty,
+ becomeDirty: Ember.K,
+ pushedData: Ember.K,
+
+ unloadRecord: ember$data$lib$system$model$states$$assertAgainstUnloadRecord,
+
+ // TODO: More robust semantics around save-while-in-flight
+ willCommit: Ember.K,
+
+ didCommit: function (internalModel) {
+ var dirtyType = ember$data$lib$system$model$states$$get(this, 'dirtyType');
+
+ internalModel.transitionTo('saved');
+ internalModel.send('invokeLifecycleCallbacks', dirtyType);
+ },
+
+ becameInvalid: function (internalModel) {
+ internalModel.transitionTo('invalid');
+ internalModel.send('invokeLifecycleCallbacks');
+ },
+
+ becameError: function (internalModel) {
+ internalModel.transitionTo('uncommitted');
+ internalModel.triggerLater('becameError', internalModel);
+ }
+ },
+
+ // A record is in the `invalid` if the adapter has indicated
+ // the the record failed server-side invalidations.
+ invalid: {
+ // FLAGS
+ isValid: false,
+
+ // EVENTS
+ deleteRecord: function (internalModel) {
+ internalModel.transitionTo('deleted.uncommitted');
+ internalModel.disconnectRelationships();
+ },
+
+ didSetProperty: function (internalModel, context) {
+ internalModel.getErrors().remove(context.name);
+
+ ember$data$lib$system$model$states$$didSetProperty(internalModel, context);
+ },
+
+ becomeDirty: Ember.K,
+
+ pushedData: Ember.K,
+
+ willCommit: function (internalModel) {
+ internalModel.getErrors().clear();
+ internalModel.transitionTo('inFlight');
+ },
+
+ rolledBack: function (internalModel) {
+ internalModel.getErrors().clear();
+ internalModel.triggerLater('ready');
+ },
+
+ becameValid: function (internalModel) {
+ internalModel.transitionTo('uncommitted');
+ },
+
+ invokeLifecycleCallbacks: function (internalModel) {
+ internalModel.triggerLater('becameInvalid', internalModel);
+ },
+
+ exit: function (internalModel) {
+ internalModel._inFlightAttributes = Ember.create(null);
+ }
+ }
+ };
+
+ // The created and updated states are created outside the state
+ // chart so we can reopen their substates and add mixins as
+ // necessary.
+
+ function ember$data$lib$system$model$states$$deepClone(object) {
+ var clone = {};
+ var value;
+
+ for (var prop in object) {
+ value = object[prop];
+ if (value && typeof value === 'object') {
+ clone[prop] = ember$data$lib$system$model$states$$deepClone(value);
+ } else {
+ clone[prop] = value;
+ }
+ }
+
+ return clone;
+ }
+
+ function ember$data$lib$system$model$states$$mixin(original, hash) {
+ for (var prop in hash) {
+ original[prop] = hash[prop];
+ }
+
+ return original;
+ }
+
+ function ember$data$lib$system$model$states$$dirtyState(options) {
+ var newState = ember$data$lib$system$model$states$$deepClone(ember$data$lib$system$model$states$$DirtyState);
+ return ember$data$lib$system$model$states$$mixin(newState, options);
+ }
+
+ var ember$data$lib$system$model$states$$createdState = ember$data$lib$system$model$states$$dirtyState({
+ dirtyType: 'created',
+ // FLAGS
+ isNew: true
+ });
+
+ ember$data$lib$system$model$states$$createdState.invalid.rolledBack = function (internalModel) {
+ internalModel.transitionTo('deleted.saved');
+ };
+ ember$data$lib$system$model$states$$createdState.uncommitted.rolledBack = function (internalModel) {
+ internalModel.transitionTo('deleted.saved');
+ };
+
+ var ember$data$lib$system$model$states$$updatedState = ember$data$lib$system$model$states$$dirtyState({
+ dirtyType: 'updated'
+ });
+
+ ember$data$lib$system$model$states$$createdState.uncommitted.deleteRecord = function (internalModel) {
+ internalModel.disconnectRelationships();
+ internalModel.transitionTo('deleted.saved');
+ internalModel.send('invokeLifecycleCallbacks');
+ };
+
+ ember$data$lib$system$model$states$$createdState.uncommitted.rollback = function (internalModel) {
+ ember$data$lib$system$model$states$$DirtyState.uncommitted.rollback.apply(this, arguments);
+ internalModel.transitionTo('deleted.saved');
+ };
+
+ ember$data$lib$system$model$states$$createdState.uncommitted.pushedData = function (internalModel) {
+ internalModel.transitionTo('loaded.updated.uncommitted');
+ internalModel.triggerLater('didLoad');
+ };
+
+ ember$data$lib$system$model$states$$createdState.uncommitted.propertyWasReset = Ember.K;
+
+ function ember$data$lib$system$model$states$$assertAgainstUnloadRecord(internalModel) {
+ }
+
+ ember$data$lib$system$model$states$$updatedState.inFlight.unloadRecord = ember$data$lib$system$model$states$$assertAgainstUnloadRecord;
+
+ ember$data$lib$system$model$states$$updatedState.uncommitted.deleteRecord = function (internalModel) {
+ internalModel.transitionTo('deleted.uncommitted');
+ internalModel.disconnectRelationships();
+ };
+
+ var ember$data$lib$system$model$states$$RootState = {
+ // FLAGS
+ isEmpty: false,
+ isLoading: false,
+ isLoaded: false,
+ isDirty: false,
+ isSaving: false,
+ isDeleted: false,
+ isNew: false,
+ isValid: true,
+
+ // DEFAULT EVENTS
+
+ // Trying to roll back if you're not in the dirty state
+ // doesn't change your state. For example, if you're in the
+ // in-flight state, rolling back the record doesn't move
+ // you out of the in-flight state.
+ rolledBack: Ember.K,
+ unloadRecord: function (internalModel) {
+ // clear relationships before moving to deleted state
+ // otherwise it fails
+ internalModel.clearRelationships();
+ internalModel.transitionTo('deleted.saved');
+ },
+
+ propertyWasReset: Ember.K,
+
+ // SUBSTATES
+
+ // A record begins its lifecycle in the `empty` state.
+ // If its data will come from the adapter, it will
+ // transition into the `loading` state. Otherwise, if
+ // the record is being created on the client, it will
+ // transition into the `created` state.
+ empty: {
+ isEmpty: true,
+
+ // EVENTS
+ loadingData: function (internalModel, promise) {
+ internalModel._loadingPromise = promise;
+ internalModel.transitionTo('loading');
+ },
+
+ loadedData: function (internalModel) {
+ internalModel.transitionTo('loaded.created.uncommitted');
+ internalModel.triggerLater('ready');
+ },
+
+ pushedData: function (internalModel) {
+ internalModel.transitionTo('loaded.saved');
+ internalModel.triggerLater('didLoad');
+ internalModel.triggerLater('ready');
+ }
+ },
+
+ // A record enters this state when the store asks
+ // the adapter for its data. It remains in this state
+ // until the adapter provides the requested data.
+ //
+ // Usually, this process is asynchronous, using an
+ // XHR to retrieve the data.
+ loading: {
+ // FLAGS
+ isLoading: true,
+
+ exit: function (internalModel) {
+ internalModel._loadingPromise = null;
+ },
+
+ // EVENTS
+ pushedData: function (internalModel) {
+ internalModel.transitionTo('loaded.saved');
+ internalModel.triggerLater('didLoad');
+ internalModel.triggerLater('ready');
+ //TODO this seems out of place here
+ internalModel.didCleanError();
+ },
+
+ becameError: function (internalModel) {
+ internalModel.triggerLater('becameError', internalModel);
+ },
+
+ notFound: function (internalModel) {
+ internalModel.transitionTo('empty');
+ }
+ },
+
+ // A record enters this state when its data is populated.
+ // Most of a record's lifecycle is spent inside substates
+ // of the `loaded` state.
+ loaded: {
+ initialState: 'saved',
+
+ // FLAGS
+ isLoaded: true,
+
+ //TODO(Igor) Reloading now triggers a loadingData event,
+ //but it should be ok?
+ loadingData: Ember.K,
+
+ // SUBSTATES
+
+ // If there are no local changes to a record, it remains
+ // in the `saved` state.
+ saved: {
+ setup: function (internalModel) {
+ var attrs = internalModel._attributes;
+ var isDirty = Ember.keys(attrs).length > 0;
+
+ if (isDirty) {
+ internalModel.adapterDidDirty();
+ }
+ },
+
+ // EVENTS
+ didSetProperty: ember$data$lib$system$model$states$$didSetProperty,
+
+ pushedData: Ember.K,
+
+ becomeDirty: function (internalModel) {
+ internalModel.transitionTo('updated.uncommitted');
+ },
+
+ willCommit: function (internalModel) {
+ internalModel.transitionTo('updated.inFlight');
+ },
+
+ reloadRecord: function (internalModel, resolve) {
+ resolve(internalModel.store.reloadRecord(internalModel));
+ },
+
+ deleteRecord: function (internalModel) {
+ internalModel.transitionTo('deleted.uncommitted');
+ internalModel.disconnectRelationships();
+ },
+
+ unloadRecord: function (internalModel) {
+ // clear relationships before moving to deleted state
+ // otherwise it fails
+ internalModel.clearRelationships();
+ internalModel.transitionTo('deleted.saved');
+ },
+
+ didCommit: function (internalModel) {
+ internalModel.send('invokeLifecycleCallbacks', ember$data$lib$system$model$states$$get(internalModel, 'lastDirtyType'));
+ },
+
+ // loaded.saved.notFound would be triggered by a failed
+ // `reload()` on an unchanged record
+ notFound: Ember.K
+
+ },
+
+ // A record is in this state after it has been locally
+ // created but before the adapter has indicated that
+ // it has been saved.
+ created: ember$data$lib$system$model$states$$createdState,
+
+ // A record is in this state if it has already been
+ // saved to the server, but there are new local changes
+ // that have not yet been saved.
+ updated: ember$data$lib$system$model$states$$updatedState
+ },
+
+ // A record is in this state if it was deleted from the store.
+ deleted: {
+ initialState: 'uncommitted',
+ dirtyType: 'deleted',
+
+ // FLAGS
+ isDeleted: true,
+ isLoaded: true,
+ isDirty: true,
+
+ // TRANSITIONS
+ setup: function (internalModel) {
+ internalModel.updateRecordArrays();
+ },
+
+ // SUBSTATES
+
+ // When a record is deleted, it enters the `start`
+ // state. It will exit this state when the record
+ // starts to commit.
+ uncommitted: {
+
+ // EVENTS
+
+ willCommit: function (internalModel) {
+ internalModel.transitionTo('inFlight');
+ },
+
+ rollback: function (internalModel) {
+ internalModel.rollback();
+ internalModel.triggerLater('ready');
+ },
+
+ pushedData: Ember.K,
+ becomeDirty: Ember.K,
+ deleteRecord: Ember.K,
+
+ rolledBack: function (internalModel) {
+ internalModel.transitionTo('loaded.saved');
+ internalModel.triggerLater('ready');
+ }
+ },
+
+ // After a record starts committing, but
+ // before the adapter indicates that the deletion
+ // has saved to the server, a record is in the
+ // `inFlight` substate of `deleted`.
+ inFlight: {
+ // FLAGS
+ isSaving: true,
+
+ // EVENTS
+
+ unloadRecord: ember$data$lib$system$model$states$$assertAgainstUnloadRecord,
+
+ // TODO: More robust semantics around save-while-in-flight
+ willCommit: Ember.K,
+ didCommit: function (internalModel) {
+ internalModel.transitionTo('saved');
+
+ internalModel.send('invokeLifecycleCallbacks');
+ },
+
+ becameError: function (internalModel) {
+ internalModel.transitionTo('uncommitted');
+ internalModel.triggerLater('becameError', internalModel);
+ },
+
+ becameInvalid: function (internalModel) {
+ internalModel.transitionTo('invalid');
+ internalModel.triggerLater('becameInvalid', internalModel);
+ }
+ },
+
+ // Once the adapter indicates that the deletion has
+ // been saved, the record enters the `saved` substate
+ // of `deleted`.
+ saved: {
+ // FLAGS
+ isDirty: false,
+
+ setup: function (internalModel) {
+ var store = internalModel.store;
+ store._dematerializeRecord(internalModel);
+ },
+
+ invokeLifecycleCallbacks: function (internalModel) {
+ internalModel.triggerLater('didDelete', internalModel);
+ internalModel.triggerLater('didCommit', internalModel);
+ },
+
+ willCommit: Ember.K,
+
+ didCommit: Ember.K
+ },
+
+ invalid: {
+ isValid: false,
+
+ didSetProperty: function (internalModel, context) {
+ internalModel.getErrors().remove(context.name);
+
+ ember$data$lib$system$model$states$$didSetProperty(internalModel, context);
+ },
+
+ deleteRecord: Ember.K,
+ becomeDirty: Ember.K,
+ willCommit: Ember.K,
+
+ rolledBack: function (internalModel) {
+ internalModel.getErrors().clear();
+ internalModel.transitionTo('loaded.saved');
+ internalModel.triggerLater('ready');
+ },
+
+ becameValid: function (internalModel) {
+ internalModel.transitionTo('uncommitted');
+ }
+
+ }
+ },
+
+ invokeLifecycleCallbacks: function (internalModel, dirtyType) {
+ if (dirtyType === 'created') {
+ internalModel.triggerLater('didCreate', internalModel);
+ } else {
+ internalModel.triggerLater('didUpdate', internalModel);
+ }
+
+ internalModel.triggerLater('didCommit', internalModel);
+ }
+ };
+
+ function ember$data$lib$system$model$states$$wireState(object, parent, name) {
+ /*jshint proto:true*/
+ // TODO: Use Object.create and copy instead
+ object = ember$data$lib$system$model$states$$mixin(parent ? Ember.create(parent) : {}, object);
+ object.parentState = parent;
+ object.stateName = name;
+
+ for (var prop in object) {
+ if (!object.hasOwnProperty(prop) || prop === 'parentState' || prop === 'stateName') {
+ continue;
+ }
+ if (typeof object[prop] === 'object') {
+ object[prop] = ember$data$lib$system$model$states$$wireState(object[prop], object, name + '.' + prop);
+ }
+ }
+
+ return object;
+ }
+
+ ember$data$lib$system$model$states$$RootState = ember$data$lib$system$model$states$$wireState(ember$data$lib$system$model$states$$RootState, null, 'root');
+
+ var ember$data$lib$system$model$states$$default = ember$data$lib$system$model$states$$RootState;
+
+ var ember$data$lib$system$model$errors$$get = Ember.get;
+ var ember$data$lib$system$model$errors$$isEmpty = Ember.isEmpty;
+ var ember$data$lib$system$model$errors$$map = Ember.EnumerableUtils.map;
+
+ var ember$data$lib$system$model$errors$$default = Ember.Object.extend(Ember.Enumerable, Ember.Evented, {
+ /**
+ Register with target handler
+ @method registerHandlers
+ @param {Object} target
+ @param {Function} becameInvalid
+ @param {Function} becameValid
+ */
+ registerHandlers: function (target, becameInvalid, becameValid) {
+ this.on('becameInvalid', target, becameInvalid);
+ this.on('becameValid', target, becameValid);
+ },
+
+ /**
+ @property errorsByAttributeName
+ @type {Ember.MapWithDefault}
+ @private
+ */
+ errorsByAttributeName: Ember.reduceComputed('content', {
+ initialValue: function () {
+ return ember$data$lib$system$map$$MapWithDefault.create({
+ defaultValue: function () {
+ return Ember.A();
+ }
+ });
+ },
+
+ addedItem: function (errors, error) {
+ errors.get(error.attribute).pushObject(error);
+
+ return errors;
+ },
+
+ removedItem: function (errors, error) {
+ errors.get(error.attribute).removeObject(error);
+
+ return errors;
+ }
+ }),
+
+ /**
+ Returns errors for a given attribute
+ ```javascript
+ var user = store.createRecord('user', {
+ username: 'tomster',
+ email: 'invalidEmail'
+ });
+ user.save().catch(function(){
+ user.get('errors').errorsFor('email'); // returns:
+ // [{attribute: "email", message: "Doesn't look like a valid email."}]
+ });
+ ```
+ @method errorsFor
+ @param {String} attribute
+ @return {Array}
+ */
+ errorsFor: function (attribute) {
+ return ember$data$lib$system$model$errors$$get(this, 'errorsByAttributeName').get(attribute);
+ },
+
+ /**
+ An array containing all of the error messages for this
+ record. This is useful for displaying all errors to the user.
+ ```handlebars
+ {{#each model.errors.messages as |message|}}
+
+ {{message}}
+
+ {{/each}}
+ ```
+ @property messages
+ @type {Array}
+ */
+ messages: Ember.computed.mapBy('content', 'message'),
+
+ /**
+ @property content
+ @type {Array}
+ @private
+ */
+ content: Ember.computed(function () {
+ return Ember.A();
+ }),
+
+ /**
+ @method unknownProperty
+ @private
+ */
+ unknownProperty: function (attribute) {
+ var errors = this.errorsFor(attribute);
+ if (ember$data$lib$system$model$errors$$isEmpty(errors)) {
+ return null;
+ }
+ return errors;
+ },
+
+ /**
+ @method nextObject
+ @private
+ */
+ nextObject: function (index, previousObject, context) {
+ return ember$data$lib$system$model$errors$$get(this, 'content').objectAt(index);
+ },
+
+ /**
+ Total number of errors.
+ @property length
+ @type {Number}
+ @readOnly
+ */
+ length: Ember.computed.oneWay('content.length').readOnly(),
+
+ /**
+ @property isEmpty
+ @type {Boolean}
+ @readOnly
+ */
+ isEmpty: Ember.computed.not('length').readOnly(),
+
+ /**
+ Adds error messages to a given attribute and sends
+ `becameInvalid` event to the record.
+ Example:
+ ```javascript
+ if (!user.get('username') {
+ user.get('errors').add('username', 'This field is required');
+ }
+ ```
+ @method add
+ @param {String} attribute
+ @param {(Array|String)} messages
+ */
+ add: function (attribute, messages) {
+ var wasEmpty = ember$data$lib$system$model$errors$$get(this, 'isEmpty');
+
+ messages = this._findOrCreateMessages(attribute, messages);
+ ember$data$lib$system$model$errors$$get(this, 'content').addObjects(messages);
+
+ this.notifyPropertyChange(attribute);
+ this.enumerableContentDidChange();
+
+ if (wasEmpty && !ember$data$lib$system$model$errors$$get(this, 'isEmpty')) {
+ this.trigger('becameInvalid');
+ }
+ },
+
+ /**
+ @method _findOrCreateMessages
+ @private
+ */
+ _findOrCreateMessages: function (attribute, messages) {
+ var errors = this.errorsFor(attribute);
+
+ return ember$data$lib$system$model$errors$$map(Ember.makeArray(messages), function (message) {
+ return errors.findBy('message', message) || {
+ attribute: attribute,
+ message: message
+ };
+ });
+ },
+
+ /**
+ Removes all error messages from the given attribute and sends
+ `becameValid` event to the record if there no more errors left.
+ Example:
+ ```app/models/user.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ email: DS.attr('string'),
+ twoFactorAuth: DS.attr('boolean'),
+ phone: DS.attr('string')
+ });
+ ```
+ ```app/routes/user/edit.js
+ import Ember from 'ember';
+ export default Ember.Route.extend({
+ actions: {
+ save: function(user) {
+ if (!user.get('twoFactorAuth')) {
+ user.get('errors').remove('phone');
+ }
+ user.save();
+ }
+ }
+ });
+ ```
+ @method remove
+ @param {String} attribute
+ */
+ remove: function (attribute) {
+ if (ember$data$lib$system$model$errors$$get(this, 'isEmpty')) {
+ return;
+ }
+
+ var content = ember$data$lib$system$model$errors$$get(this, 'content').rejectBy('attribute', attribute);
+ ember$data$lib$system$model$errors$$get(this, 'content').setObjects(content);
+
+ this.notifyPropertyChange(attribute);
+ this.enumerableContentDidChange();
+
+ if (ember$data$lib$system$model$errors$$get(this, 'isEmpty')) {
+ this.trigger('becameValid');
+ }
+ },
+
+ /**
+ Removes all error messages and sends `becameValid` event
+ to the record.
+ Example:
+ ```app/routes/user/edit.js
+ import Ember from 'ember';
+ export default Ember.Route.extend({
+ actions: {
+ retrySave: function(user) {
+ user.get('errors').clear();
+ user.save();
+ }
+ }
+ });
+ ```
+ @method clear
+ */
+ clear: function () {
+ if (ember$data$lib$system$model$errors$$get(this, 'isEmpty')) {
+ return;
+ }
+
+ ember$data$lib$system$model$errors$$get(this, 'content').clear();
+ this.enumerableContentDidChange();
+
+ this.trigger('becameValid');
+ },
+
+ /**
+ Checks if there is error messages for the given attribute.
+ ```app/routes/user/edit.js
+ import Ember from 'ember';
+ export default Ember.Route.extend({
+ actions: {
+ save: function(user) {
+ if (user.get('errors').has('email')) {
+ return alert('Please update your email before attempting to save.');
+ }
+ user.save();
+ }
+ }
+ });
+ ```
+ @method has
+ @param {String} attribute
+ @return {Boolean} true if there some errors on given attribute
+ */
+ has: function (attribute) {
+ return !ember$data$lib$system$model$errors$$isEmpty(this.errorsFor(attribute));
+ }
+ });
+
+ var ember$data$lib$system$model$$default = ember$data$lib$system$model$model$$default;
+ var ember$data$lib$system$debug$debug$adapter$$get = Ember.get;
+ var ember$data$lib$system$debug$debug$adapter$$capitalize = Ember.String.capitalize;
+ var ember$data$lib$system$debug$debug$adapter$$underscore = Ember.String.underscore;
+ var ember$data$lib$system$debug$debug$adapter$$_Ember = Ember;
+ var ember$data$lib$system$debug$debug$adapter$$assert = ember$data$lib$system$debug$debug$adapter$$_Ember.assert;
+
+ var ember$data$lib$system$debug$debug$adapter$$default = Ember.DataAdapter.extend({
+ getFilters: function () {
+ return [{ name: 'isNew', desc: 'New' }, { name: 'isModified', desc: 'Modified' }, { name: 'isClean', desc: 'Clean' }];
+ },
+
+ detect: function (typeClass) {
+ return typeClass !== ember$data$lib$system$model$$default && ember$data$lib$system$model$$default.detect(typeClass);
+ },
+
+ columnsForType: function (typeClass) {
+ var columns = [{
+ name: 'id',
+ desc: 'Id'
+ }];
+ var count = 0;
+ var self = this;
+ ember$data$lib$system$debug$debug$adapter$$get(typeClass, 'attributes').forEach(function (meta, name) {
+ if (count++ > self.attributeLimit) {
+ return false;
+ }
+ var desc = ember$data$lib$system$debug$debug$adapter$$capitalize(ember$data$lib$system$debug$debug$adapter$$underscore(name).replace('_', ' '));
+ columns.push({ name: name, desc: desc });
+ });
+ return columns;
+ },
+
+ getRecords: function (modelClass, modelName) {
+ if (arguments.length < 2) {
+ // Legacy Ember.js < 1.13 support
+ var containerKey = modelClass._debugContainerKey;
+ if (containerKey) {
+ var match = containerKey.match(/model:(.*)/);
+ if (match) {
+ modelName = match[1];
+ }
+ }
+ }
+ ember$data$lib$system$debug$debug$adapter$$assert('Cannot find model name. Please upgrade to Ember.js >= 1.13 for Ember Inspector support', !!modelName);
+ return this.get('store').all(modelName);
+ },
+
+ getRecordColumnValues: function (record) {
+ var self = this;
+ var count = 0;
+ var columnValues = { id: ember$data$lib$system$debug$debug$adapter$$get(record, 'id') };
+
+ record.eachAttribute(function (key) {
+ if (count++ > self.attributeLimit) {
+ return false;
+ }
+ var value = ember$data$lib$system$debug$debug$adapter$$get(record, key);
+ columnValues[key] = value;
+ });
+ return columnValues;
+ },
+
+ getRecordKeywords: function (record) {
+ var keywords = [];
+ var keys = Ember.A(['id']);
+ record.eachAttribute(function (key) {
+ keys.push(key);
+ });
+ keys.forEach(function (key) {
+ keywords.push(ember$data$lib$system$debug$debug$adapter$$get(record, key));
+ });
+ return keywords;
+ },
+
+ getRecordFilterValues: function (record) {
+ return {
+ isNew: record.get('isNew'),
+ isModified: record.get('isDirty') && !record.get('isNew'),
+ isClean: !record.get('isDirty')
+ };
+ },
+
+ getRecordColor: function (record) {
+ var color = 'black';
+ if (record.get('isNew')) {
+ color = 'green';
+ } else if (record.get('isDirty')) {
+ color = 'blue';
+ }
+ return color;
+ },
+
+ observeRecord: function (record, recordUpdated) {
+ var releaseMethods = Ember.A();
+ var self = this;
+ var keysToObserve = Ember.A(['id', 'isNew', 'isDirty']);
+
+ record.eachAttribute(function (key) {
+ keysToObserve.push(key);
+ });
+
+ keysToObserve.forEach(function (key) {
+ var handler = function () {
+ recordUpdated(self.wrapRecord(record));
+ };
+ Ember.addObserver(record, key, handler);
+ releaseMethods.push(function () {
+ Ember.removeObserver(record, key, handler);
+ });
+ });
+
+ var release = function () {
+ releaseMethods.forEach(function (fn) {
+ fn();
+ });
+ };
+
+ return release;
+ }
+
+ });
+
+ var ember$data$lib$initializers$data$adapter$$default = ember$data$lib$initializers$data$adapter$$initializeDebugAdapter;
+
+ /**
+ Configures a registry with injections on Ember applications
+ for the Ember-Data store. Accepts an optional namespace argument.
+
+ @method initializeStoreInjections
+ @param {Ember.Registry} registry
+ */
+ function ember$data$lib$initializers$data$adapter$$initializeDebugAdapter(registry) {
+ registry.register("data-adapter:main", ember$data$lib$system$debug$debug$adapter$$default);
+ }
+ var ember$data$lib$system$store$common$$get = Ember.get;
+ function ember$data$lib$system$store$common$$_bind(fn) {
+ var args = Array.prototype.slice.call(arguments, 1);
+
+ return function () {
+ return fn.apply(undefined, args);
+ };
+ }
+
+ function ember$data$lib$system$store$common$$_guard(promise, test) {
+ var guarded = promise["finally"](function () {
+ if (!test()) {
+ guarded._subscribers.length = 0;
+ }
+ });
+
+ return guarded;
+ }
+
+ function ember$data$lib$system$store$common$$_objectIsAlive(object) {
+ return !(ember$data$lib$system$store$common$$get(object, "isDestroyed") || ember$data$lib$system$store$common$$get(object, "isDestroying"));
+ }
+
+ function ember$data$lib$system$store$serializers$$serializerForAdapter(store, adapter, type) {
+ var serializer = adapter.serializer;
+
+ if (serializer === undefined) {
+ serializer = store.serializerFor(type);
+ }
+
+ if (serializer === null || serializer === undefined) {
+ serializer = {
+ extract: function (store, type, payload) {
+ return payload;
+ }
+ };
+ }
+
+ return serializer;
+ }
+
+ var ember$data$lib$system$store$finders$$Promise = Ember.RSVP.Promise;
+ var ember$data$lib$system$store$finders$$map = Ember.EnumerableUtils.map;
+ function ember$data$lib$system$store$finders$$_find(adapter, store, typeClass, id, internalModel) {
+ var snapshot = internalModel.createSnapshot();
+ var promise = adapter.find(store, typeClass, id, snapshot);
+ var serializer = ember$data$lib$system$store$serializers$$serializerForAdapter(store, adapter, internalModel.type.modelName);
+ var label = "DS: Handle Adapter#find of " + typeClass + " with id: " + id;
+
+ promise = ember$data$lib$system$store$finders$$Promise.cast(promise, label);
+ promise = ember$data$lib$system$store$common$$_guard(promise, ember$data$lib$system$store$common$$_bind(ember$data$lib$system$store$common$$_objectIsAlive, store));
+
+ return promise.then(function (adapterPayload) {
+ return store._adapterRun(function () {
+ var payload = serializer.extract(store, typeClass, adapterPayload, id, "find");
+
+ //TODO Optimize
+ var record = store.push(typeClass.modelName, payload);
+ return record._internalModel;
+ });
+ }, function (error) {
+ internalModel.notFound();
+ if (internalModel.isEmpty()) {
+ internalModel.unloadRecord();
+ }
+
+ throw error;
+ }, "DS: Extract payload of '" + typeClass + "'");
+ }
+
+ function ember$data$lib$system$store$finders$$_findMany(adapter, store, typeClass, ids, internalModels) {
+ var snapshots = Ember.A(internalModels).invoke("createSnapshot");
+ var promise = adapter.findMany(store, typeClass, ids, snapshots);
+ var serializer = ember$data$lib$system$store$serializers$$serializerForAdapter(store, adapter, typeClass.modelName);
+ var label = "DS: Handle Adapter#findMany of " + typeClass;
+
+ if (promise === undefined) {
+ throw new Error("adapter.findMany returned undefined, this was very likely a mistake");
+ }
+
+ promise = ember$data$lib$system$store$finders$$Promise.cast(promise, label);
+ promise = ember$data$lib$system$store$common$$_guard(promise, ember$data$lib$system$store$common$$_bind(ember$data$lib$system$store$common$$_objectIsAlive, store));
+
+ return promise.then(function (adapterPayload) {
+ return store._adapterRun(function () {
+ var payload = serializer.extract(store, typeClass, adapterPayload, null, "findMany");
+
+
+ //TODO Optimize, no need to materialize here
+ var records = store.pushMany(typeClass.modelName, payload);
+ return ember$data$lib$system$store$finders$$map(records, function (record) {
+ return record._internalModel;
+ });
+ });
+ }, null, "DS: Extract payload of " + typeClass);
+ }
+
+ function ember$data$lib$system$store$finders$$_findHasMany(adapter, store, internalModel, link, relationship) {
+ var snapshot = internalModel.createSnapshot();
+ var typeClass = store.modelFor(relationship.type);
+ var promise = adapter.findHasMany(store, snapshot, link, relationship);
+ var serializer = ember$data$lib$system$store$serializers$$serializerForAdapter(store, adapter, relationship.type);
+ var label = "DS: Handle Adapter#findHasMany of " + internalModel + " : " + relationship.type;
+
+ promise = ember$data$lib$system$store$finders$$Promise.cast(promise, label);
+ promise = ember$data$lib$system$store$common$$_guard(promise, ember$data$lib$system$store$common$$_bind(ember$data$lib$system$store$common$$_objectIsAlive, store));
+ promise = ember$data$lib$system$store$common$$_guard(promise, ember$data$lib$system$store$common$$_bind(ember$data$lib$system$store$common$$_objectIsAlive, internalModel));
+
+ return promise.then(function (adapterPayload) {
+ return store._adapterRun(function () {
+ var payload = serializer.extract(store, typeClass, adapterPayload, null, "findHasMany");
+
+
+ //TODO Use a non record creating push
+ var records = store.pushMany(relationship.type, payload);
+ return ember$data$lib$system$store$finders$$map(records, function (record) {
+ return record._internalModel;
+ });
+ });
+ }, null, "DS: Extract payload of " + internalModel + " : hasMany " + relationship.type);
+ }
+
+ function ember$data$lib$system$store$finders$$_findBelongsTo(adapter, store, internalModel, link, relationship) {
+ var snapshot = internalModel.createSnapshot();
+ var typeClass = store.modelFor(relationship.type);
+ var promise = adapter.findBelongsTo(store, snapshot, link, relationship);
+ var serializer = ember$data$lib$system$store$serializers$$serializerForAdapter(store, adapter, relationship.type);
+ var label = "DS: Handle Adapter#findBelongsTo of " + internalModel + " : " + relationship.type;
+
+ promise = ember$data$lib$system$store$finders$$Promise.cast(promise, label);
+ promise = ember$data$lib$system$store$common$$_guard(promise, ember$data$lib$system$store$common$$_bind(ember$data$lib$system$store$common$$_objectIsAlive, store));
+ promise = ember$data$lib$system$store$common$$_guard(promise, ember$data$lib$system$store$common$$_bind(ember$data$lib$system$store$common$$_objectIsAlive, internalModel));
+
+ return promise.then(function (adapterPayload) {
+ return store._adapterRun(function () {
+ var payload = serializer.extract(store, typeClass, adapterPayload, null, "findBelongsTo");
+
+ if (!payload) {
+ return null;
+ }
+
+ var record = store.push(relationship.type, payload);
+ //TODO Optimize
+ return record._internalModel;
+ });
+ }, null, "DS: Extract payload of " + internalModel + " : " + relationship.type);
+ }
+
+ function ember$data$lib$system$store$finders$$_findAll(adapter, store, typeClass, sinceToken) {
+ var promise = adapter.findAll(store, typeClass, sinceToken);
+ var modelName = typeClass.modelName;
+ var serializer = ember$data$lib$system$store$serializers$$serializerForAdapter(store, adapter, modelName);
+ var label = "DS: Handle Adapter#findAll of " + typeClass;
+
+ promise = ember$data$lib$system$store$finders$$Promise.cast(promise, label);
+ promise = ember$data$lib$system$store$common$$_guard(promise, ember$data$lib$system$store$common$$_bind(ember$data$lib$system$store$common$$_objectIsAlive, store));
+
+ return promise.then(function (adapterPayload) {
+ store._adapterRun(function () {
+ var payload = serializer.extract(store, typeClass, adapterPayload, null, "findAll");
+
+
+ store.pushMany(modelName, payload);
+ });
+
+ store.didUpdateAll(typeClass);
+ return store.all(modelName);
+ }, null, "DS: Extract payload of findAll " + typeClass);
+ }
+
+ function ember$data$lib$system$store$finders$$_findQuery(adapter, store, typeClass, query, recordArray) {
+ var modelName = typeClass.modelName;
+ var promise = adapter.findQuery(store, typeClass, query, recordArray);
+ var serializer = ember$data$lib$system$store$serializers$$serializerForAdapter(store, adapter, modelName);
+ var label = "DS: Handle Adapter#findQuery of " + typeClass;
+
+ promise = ember$data$lib$system$store$finders$$Promise.cast(promise, label);
+ promise = ember$data$lib$system$store$common$$_guard(promise, ember$data$lib$system$store$common$$_bind(ember$data$lib$system$store$common$$_objectIsAlive, store));
+
+ return promise.then(function (adapterPayload) {
+ var payload;
+ store._adapterRun(function () {
+ payload = serializer.extract(store, typeClass, adapterPayload, null, "findQuery");
+
+ });
+
+ recordArray.load(payload);
+ return recordArray;
+ }, null, "DS: Extract payload of findQuery " + typeClass);
+ }
+ var ember$data$lib$system$record$arrays$record$array$$get = Ember.get;
+ var ember$data$lib$system$record$arrays$record$array$$set = Ember.set;
+
+ var ember$data$lib$system$record$arrays$record$array$$default = Ember.ArrayProxy.extend(Ember.Evented, {
+ /**
+ The model type contained by this record array.
+ @property type
+ @type DS.Model
+ */
+ type: null,
+
+ /**
+ The array of client ids backing the record array. When a
+ record is requested from the record array, the record
+ for the client id at the same index is materialized, if
+ necessary, by the store.
+ @property content
+ @private
+ @type Ember.Array
+ */
+ content: null,
+
+ /**
+ The flag to signal a `RecordArray` is finished loading data.
+ Example
+ ```javascript
+ var people = store.all('person');
+ people.get('isLoaded'); // true
+ ```
+ @property isLoaded
+ @type Boolean
+ */
+ isLoaded: false,
+ /**
+ The flag to signal a `RecordArray` is currently loading data.
+ Example
+ ```javascript
+ var people = store.all('person');
+ people.get('isUpdating'); // false
+ people.update();
+ people.get('isUpdating'); // true
+ ```
+ @property isUpdating
+ @type Boolean
+ */
+ isUpdating: false,
+
+ /**
+ The store that created this record array.
+ @property store
+ @private
+ @type DS.Store
+ */
+ store: null,
+
+ /**
+ Retrieves an object from the content by index.
+ @method objectAtContent
+ @private
+ @param {Number} index
+ @return {DS.Model} record
+ */
+ objectAtContent: function (index) {
+ var content = ember$data$lib$system$record$arrays$record$array$$get(this, 'content');
+ var internalModel = content.objectAt(index);
+ return internalModel && internalModel.getRecord();
+ },
+
+ /**
+ Used to get the latest version of all of the records in this array
+ from the adapter.
+ Example
+ ```javascript
+ var people = store.all('person');
+ people.get('isUpdating'); // false
+ people.update();
+ people.get('isUpdating'); // true
+ ```
+ @method update
+ */
+ update: function () {
+ if (ember$data$lib$system$record$arrays$record$array$$get(this, 'isUpdating')) {
+ return;
+ }
+
+ var store = ember$data$lib$system$record$arrays$record$array$$get(this, 'store');
+ var modelName = ember$data$lib$system$record$arrays$record$array$$get(this, 'type.modelName');
+
+ return store.fetchAll(modelName, this);
+ },
+
+ /**
+ Adds an internal model to the `RecordArray` without duplicates
+ @method addInternalModel
+ @private
+ @param {InternalModel} internalModel
+ @param {number} an optional index to insert at
+ */
+ addInternalModel: function (internalModel, idx) {
+ var content = ember$data$lib$system$record$arrays$record$array$$get(this, 'content');
+ if (idx === undefined) {
+ content.addObject(internalModel);
+ } else if (!content.contains(internalModel)) {
+ content.insertAt(idx, internalModel);
+ }
+ },
+
+ /**
+ Removes an internalModel to the `RecordArray`.
+ @method removeInternalModel
+ @private
+ @param {InternalModel} internalModel
+ */
+ removeInternalModel: function (internalModel) {
+ ember$data$lib$system$record$arrays$record$array$$get(this, 'content').removeObject(internalModel);
+ },
+
+ /**
+ Saves all of the records in the `RecordArray`.
+ Example
+ ```javascript
+ var messages = store.all('message');
+ messages.forEach(function(message) {
+ message.set('hasBeenSeen', true);
+ });
+ messages.save();
+ ```
+ @method save
+ @return {DS.PromiseArray} promise
+ */
+ save: function () {
+ var recordArray = this;
+ var promiseLabel = 'DS: RecordArray#save ' + ember$data$lib$system$record$arrays$record$array$$get(this, 'type');
+ var promise = Ember.RSVP.all(this.invoke('save'), promiseLabel).then(function (array) {
+ return recordArray;
+ }, null, 'DS: RecordArray#save return RecordArray');
+
+ return ember$data$lib$system$promise$proxies$$PromiseArray.create({ promise: promise });
+ },
+
+ _dissociateFromOwnRecords: function () {
+ var array = this;
+
+ this.get('content').forEach(function (record) {
+ var recordArrays = record._recordArrays;
+
+ if (recordArrays) {
+ recordArrays["delete"](array);
+ }
+ });
+ },
+
+ /**
+ @method _unregisterFromManager
+ @private
+ */
+ _unregisterFromManager: function () {
+ var manager = ember$data$lib$system$record$arrays$record$array$$get(this, 'manager');
+ manager.unregisterFilteredRecordArray(this);
+ },
+
+ willDestroy: function () {
+ this._unregisterFromManager();
+ this._dissociateFromOwnRecords();
+ ember$data$lib$system$record$arrays$record$array$$set(this, 'content', undefined);
+ this._super.apply(this, arguments);
+ }
+ });
+
+ /**
+ @module ember-data
+ */
+
+ var ember$data$lib$system$record$arrays$filtered$record$array$$get = Ember.get;
+
+ var ember$data$lib$system$record$arrays$filtered$record$array$$default = ember$data$lib$system$record$arrays$record$array$$default.extend({
+ /**
+ The filterFunction is a function used to test records from the store to
+ determine if they should be part of the record array.
+ Example
+ ```javascript
+ var allPeople = store.all('person');
+ allPeople.mapBy('name'); // ["Tom Dale", "Yehuda Katz", "Trek Glowacki"]
+ var people = store.filter('person', function(person) {
+ if (person.get('name').match(/Katz$/)) { return true; }
+ });
+ people.mapBy('name'); // ["Yehuda Katz"]
+ var notKatzFilter = function(person) {
+ return !person.get('name').match(/Katz$/);
+ };
+ people.set('filterFunction', notKatzFilter);
+ people.mapBy('name'); // ["Tom Dale", "Trek Glowacki"]
+ ```
+ @method filterFunction
+ @param {DS.Model} record
+ @return {Boolean} `true` if the record should be in the array
+ */
+ filterFunction: null,
+ isLoaded: true,
+
+ replace: function () {
+ var type = ember$data$lib$system$record$arrays$filtered$record$array$$get(this, "type").toString();
+ throw new Error("The result of a client-side filter (on " + type + ") is immutable.");
+ },
+
+ /**
+ @method updateFilter
+ @private
+ */
+ _updateFilter: function () {
+ var manager = ember$data$lib$system$record$arrays$filtered$record$array$$get(this, "manager");
+ manager.updateFilter(this, ember$data$lib$system$record$arrays$filtered$record$array$$get(this, "type"), ember$data$lib$system$record$arrays$filtered$record$array$$get(this, "filterFunction"));
+ },
+
+ updateFilter: Ember.observer(function () {
+ Ember.run.once(this, this._updateFilter);
+ }, "filterFunction")
+ });
+
+ /**
+ @module ember-data
+ */
+
+ var ember$data$lib$system$record$arrays$adapter$populated$record$array$$get = Ember.get;
+
+ function ember$data$lib$system$record$arrays$adapter$populated$record$array$$cloneNull(source) {
+ var clone = Ember.create(null);
+ for (var key in source) {
+ clone[key] = source[key];
+ }
+ return clone;
+ }
+
+ var ember$data$lib$system$record$arrays$adapter$populated$record$array$$default = ember$data$lib$system$record$arrays$record$array$$default.extend({
+ query: null,
+
+ replace: function () {
+ var type = ember$data$lib$system$record$arrays$adapter$populated$record$array$$get(this, "type").toString();
+ throw new Error("The result of a server query (on " + type + ") is immutable.");
+ },
+
+ /**
+ @method load
+ @private
+ @param {Array} data
+ */
+ load: function (data) {
+ var store = ember$data$lib$system$record$arrays$adapter$populated$record$array$$get(this, "store");
+ var type = ember$data$lib$system$record$arrays$adapter$populated$record$array$$get(this, "type");
+ var modelName = type.modelName;
+ var records = store.pushMany(modelName, data);
+ var meta = store.metadataFor(modelName);
+
+ //TODO Optimize
+ var internalModels = Ember.A(records).mapBy("_internalModel");
+ this.setProperties({
+ content: Ember.A(internalModels),
+ isLoaded: true,
+ meta: ember$data$lib$system$record$arrays$adapter$populated$record$array$$cloneNull(meta)
+ });
+
+ internalModels.forEach(function (record) {
+ this.manager.recordArraysForRecord(record).add(this);
+ }, this);
+
+ // TODO: should triggering didLoad event be the last action of the runLoop?
+ Ember.run.once(this, "trigger", "didLoad");
+ }
+ });
+
+ var ember$data$lib$system$ordered$set$$EmberOrderedSet = Ember.OrderedSet;
+ var ember$data$lib$system$ordered$set$$guidFor = Ember.guidFor;
+
+ var ember$data$lib$system$ordered$set$$OrderedSet = function () {
+ this._super$constructor();
+ };
+
+ ember$data$lib$system$ordered$set$$OrderedSet.create = function () {
+ var Constructor = this;
+ return new Constructor();
+ };
+
+ ember$data$lib$system$ordered$set$$OrderedSet.prototype = Ember.create(ember$data$lib$system$ordered$set$$EmberOrderedSet.prototype);
+ ember$data$lib$system$ordered$set$$OrderedSet.prototype.constructor = ember$data$lib$system$ordered$set$$OrderedSet;
+ ember$data$lib$system$ordered$set$$OrderedSet.prototype._super$constructor = ember$data$lib$system$ordered$set$$EmberOrderedSet;
+
+ ember$data$lib$system$ordered$set$$OrderedSet.prototype.addWithIndex = function (obj, idx) {
+ var guid = ember$data$lib$system$ordered$set$$guidFor(obj);
+ var presenceSet = this.presenceSet;
+ var list = this.list;
+
+ if (presenceSet[guid] === true) {
+ return;
+ }
+
+ presenceSet[guid] = true;
+
+ if (idx === undefined || idx == null) {
+ list.push(obj);
+ } else {
+ list.splice(idx, 0, obj);
+ }
+
+ this.size += 1;
+
+ return this;
+ };
+
+ var ember$data$lib$system$ordered$set$$default = ember$data$lib$system$ordered$set$$OrderedSet;
+ var ember$data$lib$system$record$array$manager$$get = Ember.get;
+ var ember$data$lib$system$record$array$manager$$forEach = Ember.EnumerableUtils.forEach;
+ var ember$data$lib$system$record$array$manager$$indexOf = Ember.EnumerableUtils.indexOf;
+
+ var ember$data$lib$system$record$array$manager$$default = Ember.Object.extend({
+ init: function () {
+ this.filteredRecordArrays = ember$data$lib$system$map$$MapWithDefault.create({
+ defaultValue: function () {
+ return [];
+ }
+ });
+
+ this.changedRecords = [];
+ this._adapterPopulatedRecordArrays = [];
+ },
+
+ recordDidChange: function (record) {
+ if (this.changedRecords.push(record) !== 1) {
+ return;
+ }
+
+ Ember.run.schedule("actions", this, this.updateRecordArrays);
+ },
+
+ recordArraysForRecord: function (record) {
+ record._recordArrays = record._recordArrays || ember$data$lib$system$ordered$set$$default.create();
+ return record._recordArrays;
+ },
+
+ /**
+ This method is invoked whenever data is loaded into the store by the
+ adapter or updated by the adapter, or when a record has changed.
+ It updates all record arrays that a record belongs to.
+ To avoid thrashing, it only runs at most once per run loop.
+ @method updateRecordArrays
+ */
+ updateRecordArrays: function () {
+ ember$data$lib$system$record$array$manager$$forEach(this.changedRecords, function (record) {
+ if (record.isDeleted()) {
+ this._recordWasDeleted(record);
+ } else {
+ this._recordWasChanged(record);
+ }
+ }, this);
+
+ this.changedRecords.length = 0;
+ },
+
+ _recordWasDeleted: function (record) {
+ var recordArrays = record._recordArrays;
+
+ if (!recordArrays) {
+ return;
+ }
+
+ recordArrays.forEach(function (array) {
+ array.removeInternalModel(record);
+ });
+
+ record._recordArrays = null;
+ },
+
+ //Don't need to update non filtered arrays on simple changes
+ _recordWasChanged: function (record) {
+ var typeClass = record.type;
+ var recordArrays = this.filteredRecordArrays.get(typeClass);
+ var filter;
+
+ ember$data$lib$system$record$array$manager$$forEach(recordArrays, function (array) {
+ filter = ember$data$lib$system$record$array$manager$$get(array, "filterFunction");
+ if (filter) {
+ this.updateRecordArray(array, filter, typeClass, record);
+ }
+ }, this);
+ },
+
+ //Need to update live arrays on loading
+ recordWasLoaded: function (record) {
+ var typeClass = record.type;
+ var recordArrays = this.filteredRecordArrays.get(typeClass);
+ var filter;
+
+ ember$data$lib$system$record$array$manager$$forEach(recordArrays, function (array) {
+ filter = ember$data$lib$system$record$array$manager$$get(array, "filterFunction");
+ this.updateRecordArray(array, filter, typeClass, record);
+ }, this);
+ },
+ /**
+ Update an individual filter.
+ @method updateRecordArray
+ @param {DS.FilteredRecordArray} array
+ @param {Function} filter
+ @param {DS.Model} typeClass
+ @param {InternalModel} record
+ */
+ updateRecordArray: function (array, filter, typeClass, record) {
+ var shouldBeInArray;
+
+ if (!filter) {
+ shouldBeInArray = true;
+ } else {
+ shouldBeInArray = filter(record.getRecord());
+ }
+
+ var recordArrays = this.recordArraysForRecord(record);
+
+ if (shouldBeInArray) {
+ if (!recordArrays.has(array)) {
+ array.addInternalModel(record);
+ recordArrays.add(array);
+ }
+ } else if (!shouldBeInArray) {
+ recordArrays["delete"](array);
+ array.removeInternalModel(record);
+ }
+ },
+
+ /**
+ This method is invoked if the `filterFunction` property is
+ changed on a `DS.FilteredRecordArray`.
+ It essentially re-runs the filter from scratch. This same
+ method is invoked when the filter is created in th first place.
+ @method updateFilter
+ @param {Array} array
+ @param {String} modelName
+ @param {Function} filter
+ */
+ updateFilter: function (array, modelName, filter) {
+ var typeMap = this.store.typeMapFor(modelName);
+ var records = typeMap.records;
+ var record;
+
+ for (var i = 0, l = records.length; i < l; i++) {
+ record = records[i];
+
+ if (!record.isDeleted() && !record.isEmpty()) {
+ this.updateRecordArray(array, filter, modelName, record);
+ }
+ }
+ },
+
+ /**
+ Create a `DS.RecordArray` for a type and register it for updates.
+ @method createRecordArray
+ @param {Class} typeClass
+ @return {DS.RecordArray}
+ */
+ createRecordArray: function (typeClass) {
+ var array = ember$data$lib$system$record$arrays$record$array$$default.create({
+ type: typeClass,
+ content: Ember.A(),
+ store: this.store,
+ isLoaded: true,
+ manager: this
+ });
+
+ this.registerFilteredRecordArray(array, typeClass);
+
+ return array;
+ },
+
+ /**
+ Create a `DS.FilteredRecordArray` for a type and register it for updates.
+ @method createFilteredRecordArray
+ @param {DS.Model} typeClass
+ @param {Function} filter
+ @param {Object} query (optional
+ @return {DS.FilteredRecordArray}
+ */
+ createFilteredRecordArray: function (typeClass, filter, query) {
+ var array = ember$data$lib$system$record$arrays$filtered$record$array$$default.create({
+ query: query,
+ type: typeClass,
+ content: Ember.A(),
+ store: this.store,
+ manager: this,
+ filterFunction: filter
+ });
+
+ this.registerFilteredRecordArray(array, typeClass, filter);
+
+ return array;
+ },
+
+ /**
+ Create a `DS.AdapterPopulatedRecordArray` for a type with given query.
+ @method createAdapterPopulatedRecordArray
+ @param {DS.Model} typeClass
+ @param {Object} query
+ @return {DS.AdapterPopulatedRecordArray}
+ */
+ createAdapterPopulatedRecordArray: function (typeClass, query) {
+ var array = ember$data$lib$system$record$arrays$adapter$populated$record$array$$default.create({
+ type: typeClass,
+ query: query,
+ content: Ember.A(),
+ store: this.store,
+ manager: this
+ });
+
+ this._adapterPopulatedRecordArrays.push(array);
+
+ return array;
+ },
+
+ /**
+ Register a RecordArray for a given type to be backed by
+ a filter function. This will cause the array to update
+ automatically when records of that type change attribute
+ values or states.
+ @method registerFilteredRecordArray
+ @param {DS.RecordArray} array
+ @param {DS.Model} typeClass
+ @param {Function} filter
+ */
+ registerFilteredRecordArray: function (array, typeClass, filter) {
+ var recordArrays = this.filteredRecordArrays.get(typeClass);
+ recordArrays.push(array);
+
+ this.updateFilter(array, typeClass, filter);
+ },
+
+ /**
+ Unregister a FilteredRecordArray.
+ So manager will not update this array.
+ @method unregisterFilteredRecordArray
+ @param {DS.RecordArray} array
+ */
+ unregisterFilteredRecordArray: function (array) {
+ var recordArrays = this.filteredRecordArrays.get(array.type);
+ var index = ember$data$lib$system$record$array$manager$$indexOf(recordArrays, array);
+ recordArrays.splice(index, 1);
+ },
+
+ willDestroy: function () {
+ this._super.apply(this, arguments);
+
+ this.filteredRecordArrays.forEach(function (value) {
+ ember$data$lib$system$record$array$manager$$forEach(ember$data$lib$system$record$array$manager$$flatten(value), ember$data$lib$system$record$array$manager$$destroy);
+ });
+ ember$data$lib$system$record$array$manager$$forEach(this._adapterPopulatedRecordArrays, ember$data$lib$system$record$array$manager$$destroy);
+ }
+ });
+
+ function ember$data$lib$system$record$array$manager$$destroy(entry) {
+ entry.destroy();
+ }
+
+ function ember$data$lib$system$record$array$manager$$flatten(list) {
+ var length = list.length;
+ var result = Ember.A();
+
+ for (var i = 0; i < length; i++) {
+ result = result.concat(list[i]);
+ }
+
+ return result;
+ }
+
+ /**
+ * The `ContainerInstanceCache` serves as a lazy cache for looking up
+ * instances of serializers and adapters. It has some additional logic for
+ * finding the 'fallback' adapter or serializer.
+ *
+ * The 'fallback' adapter or serializer is an adapter or serializer that is looked up
+ * when the preferred lookup fails. For example, say you try to look up `adapter:post`,
+ * but there is no entry (app/adapters/post.js in EmberCLI) for `adapter:post` in the registry.
+ *
+ * The `fallbacks` array passed will then be used; the first entry in the fallbacks array
+ * that exists in the container will then be cached for `adapter:post`. So, the next time you
+ * look up `adapter:post`, you'll get the `adapter:application` instance (or whatever the fallback
+ * was if `adapter:application` doesn't exist).
+ *
+ * @private
+ * @class ContainerInstanceCache
+ *
+ */
+ function ember$data$lib$system$store$container$instance$cache$$ContainerInstanceCache(container) {
+ this._container = container;
+ this._cache = ember$lib$main$$default.create(null);
+ }
+
+ ember$data$lib$system$store$container$instance$cache$$ContainerInstanceCache.prototype = ember$lib$main$$default.create(null);
+
+ ember$lib$main$$default.merge(ember$data$lib$system$store$container$instance$cache$$ContainerInstanceCache.prototype, {
+ get: function (type, preferredKey, fallbacks) {
+ var cache = this._cache;
+ var preferredLookupKey = '' + type + ':' + preferredKey;
+
+ if (!(preferredLookupKey in cache)) {
+ var instance = this.instanceFor(preferredLookupKey) || this._findInstance(type, fallbacks);
+ if (instance) {
+ cache[preferredLookupKey] = instance;
+ }
+ }
+ return cache[preferredLookupKey];
+ },
+
+ _findInstance: function (type, fallbacks) {
+ for (var i = 0, _length = fallbacks.length; i < _length; i++) {
+ var fallback = fallbacks[i];
+ var lookupKey = '' + type + ':' + fallback;
+ var instance = this.instanceFor(lookupKey);
+
+ if (instance) {
+ return instance;
+ }
+ }
+ },
+
+ instanceFor: function (key) {
+ var cache = this._cache;
+ if (!cache[key]) {
+ var instance = this._container.lookup(key);
+ if (instance) {
+ cache[key] = instance;
+ }
+ }
+ return cache[key];
+ },
+
+ destroy: function () {
+ var cache = this._cache;
+ var cacheEntries = ember$lib$main$$default.keys(cache);
+
+ for (var i = 0, _length2 = cacheEntries.length; i < _length2; i++) {
+ var cacheKey = cacheEntries[i];
+ var cacheEntry = cache[cacheKey];
+ if (cacheEntry) {
+ cacheEntry.destroy();
+ }
+ }
+ this._container = null;
+ },
+
+ constructor: ember$data$lib$system$store$container$instance$cache$$ContainerInstanceCache,
+
+ toString: function () {
+ return 'ContainerInstanceCache';
+ }
+ });
+
+ var ember$data$lib$system$store$container$instance$cache$$default = ember$data$lib$system$store$container$instance$cache$$ContainerInstanceCache;
+ function ember$data$lib$system$merge$$merge(original, updates) {
+ if (!updates || typeof updates !== 'object') {
+ return original;
+ }
+
+ var props = Ember.keys(updates);
+ var prop;
+ var length = props.length;
+
+ for (var i = 0; i < length; i++) {
+ prop = props[i];
+ original[prop] = updates[prop];
+ }
+
+ return original;
+ }
+
+ var ember$data$lib$system$merge$$default = ember$data$lib$system$merge$$merge;
+
+ var ember$data$lib$system$relationships$state$relationship$$forEach = Ember.EnumerableUtils.forEach;
+
+ function ember$data$lib$system$relationships$state$relationship$$Relationship(store, record, inverseKey, relationshipMeta) {
+ this.members = new ember$data$lib$system$ordered$set$$default();
+ this.canonicalMembers = new ember$data$lib$system$ordered$set$$default();
+ this.store = store;
+ this.key = relationshipMeta.key;
+ this.inverseKey = inverseKey;
+ this.record = record;
+ this.isAsync = relationshipMeta.options.async;
+ this.relationshipMeta = relationshipMeta;
+ //This probably breaks for polymorphic relationship in complex scenarios, due to
+ //multiple possible modelNames
+ this.inverseKeyForImplicit = this.record.constructor.modelName + this.key;
+ this.linkPromise = null;
+ this.hasData = false;
+ }
+
+ ember$data$lib$system$relationships$state$relationship$$Relationship.prototype = {
+ constructor: ember$data$lib$system$relationships$state$relationship$$Relationship,
+
+ destroy: Ember.K,
+
+ clear: function () {
+ var members = this.members.list;
+ var member;
+
+ while (members.length > 0) {
+ member = members[0];
+ this.removeRecord(member);
+ }
+ },
+
+ disconnect: function () {
+ this.members.forEach(function (member) {
+ this.removeRecordFromInverse(member);
+ }, this);
+ },
+
+ reconnect: function () {
+ this.members.forEach(function (member) {
+ this.addRecordToInverse(member);
+ }, this);
+ },
+
+ removeRecords: function (records) {
+ var self = this;
+ ember$data$lib$system$relationships$state$relationship$$forEach(records, function (record) {
+ self.removeRecord(record);
+ });
+ },
+
+ addRecords: function (records, idx) {
+ var self = this;
+ ember$data$lib$system$relationships$state$relationship$$forEach(records, function (record) {
+ self.addRecord(record, idx);
+ if (idx !== undefined) {
+ idx++;
+ }
+ });
+ },
+
+ addCanonicalRecords: function (records, idx) {
+ for (var i = 0; i < records.length; i++) {
+ if (idx !== undefined) {
+ this.addCanonicalRecord(records[i], i + idx);
+ } else {
+ this.addCanonicalRecord(records[i]);
+ }
+ }
+ },
+
+ addCanonicalRecord: function (record, idx) {
+ if (!this.canonicalMembers.has(record)) {
+ this.canonicalMembers.add(record);
+ if (this.inverseKey) {
+ record._relationships.get(this.inverseKey).addCanonicalRecord(this.record);
+ } else {
+ if (!record._implicitRelationships[this.inverseKeyForImplicit]) {
+ record._implicitRelationships[this.inverseKeyForImplicit] = new ember$data$lib$system$relationships$state$relationship$$Relationship(this.store, record, this.key, { options: {} });
+ }
+ record._implicitRelationships[this.inverseKeyForImplicit].addCanonicalRecord(this.record);
+ }
+ }
+ this.flushCanonicalLater();
+ this.setHasData(true);
+ },
+
+ removeCanonicalRecords: function (records, idx) {
+ for (var i = 0; i < records.length; i++) {
+ if (idx !== undefined) {
+ this.removeCanonicalRecord(records[i], i + idx);
+ } else {
+ this.removeCanonicalRecord(records[i]);
+ }
+ }
+ },
+
+ removeCanonicalRecord: function (record, idx) {
+ if (this.canonicalMembers.has(record)) {
+ this.removeCanonicalRecordFromOwn(record);
+ if (this.inverseKey) {
+ this.removeCanonicalRecordFromInverse(record);
+ } else {
+ if (record._implicitRelationships[this.inverseKeyForImplicit]) {
+ record._implicitRelationships[this.inverseKeyForImplicit].removeCanonicalRecord(this.record);
+ }
+ }
+ }
+ this.flushCanonicalLater();
+ },
+
+ addRecord: function (record, idx) {
+ if (!this.members.has(record)) {
+ this.members.addWithIndex(record, idx);
+ this.notifyRecordRelationshipAdded(record, idx);
+ if (this.inverseKey) {
+ record._relationships.get(this.inverseKey).addRecord(this.record);
+ } else {
+ if (!record._implicitRelationships[this.inverseKeyForImplicit]) {
+ record._implicitRelationships[this.inverseKeyForImplicit] = new ember$data$lib$system$relationships$state$relationship$$Relationship(this.store, record, this.key, { options: {} });
+ }
+ record._implicitRelationships[this.inverseKeyForImplicit].addRecord(this.record);
+ }
+ this.record.updateRecordArraysLater();
+ }
+ this.setHasData(true);
+ },
+
+ removeRecord: function (record) {
+ if (this.members.has(record)) {
+ this.removeRecordFromOwn(record);
+ if (this.inverseKey) {
+ this.removeRecordFromInverse(record);
+ } else {
+ if (record._implicitRelationships[this.inverseKeyForImplicit]) {
+ record._implicitRelationships[this.inverseKeyForImplicit].removeRecord(this.record);
+ }
+ }
+ }
+ },
+
+ addRecordToInverse: function (record) {
+ if (this.inverseKey) {
+ record._relationships.get(this.inverseKey).addRecord(this.record);
+ }
+ },
+
+ removeRecordFromInverse: function (record) {
+ var inverseRelationship = record._relationships.get(this.inverseKey);
+ //Need to check for existence, as the record might unloading at the moment
+ if (inverseRelationship) {
+ inverseRelationship.removeRecordFromOwn(this.record);
+ }
+ },
+
+ removeRecordFromOwn: function (record) {
+ this.members["delete"](record);
+ this.notifyRecordRelationshipRemoved(record);
+ this.record.updateRecordArrays();
+ },
+
+ removeCanonicalRecordFromInverse: function (record) {
+ var inverseRelationship = record._relationships.get(this.inverseKey);
+ //Need to check for existence, as the record might unloading at the moment
+ if (inverseRelationship) {
+ inverseRelationship.removeCanonicalRecordFromOwn(this.record);
+ }
+ },
+
+ removeCanonicalRecordFromOwn: function (record) {
+ this.canonicalMembers["delete"](record);
+ this.flushCanonicalLater();
+ },
+
+ flushCanonical: function () {
+ this.willSync = false;
+ //a hack for not removing new records
+ //TODO remove once we have proper diffing
+ var newRecords = [];
+ for (var i = 0; i < this.members.list.length; i++) {
+ if (this.members.list[i].isNew()) {
+ newRecords.push(this.members.list[i]);
+ }
+ }
+ //TODO(Igor) make this less abysmally slow
+ this.members = this.canonicalMembers.copy();
+ for (i = 0; i < newRecords.length; i++) {
+ this.members.add(newRecords[i]);
+ }
+ },
+
+ flushCanonicalLater: function () {
+ if (this.willSync) {
+ return;
+ }
+ this.willSync = true;
+ var self = this;
+ this.store._backburner.join(function () {
+ self.store._backburner.schedule("syncRelationships", self, self.flushCanonical);
+ });
+ },
+
+ updateLink: function (link) {
+ if (link !== this.link) {
+ this.link = link;
+ this.linkPromise = null;
+ this.record.notifyPropertyChange(this.key);
+ }
+ },
+
+ findLink: function () {
+ if (this.linkPromise) {
+ return this.linkPromise;
+ } else {
+ var promise = this.fetchLink();
+ this.linkPromise = promise;
+ return promise.then(function (result) {
+ return result;
+ });
+ }
+ },
+
+ updateRecordsFromAdapter: function (records) {
+ //TODO(Igor) move this to a proper place
+ var self = this;
+ //TODO Once we have adapter support, we need to handle updated and canonical changes
+ self.computeChanges(records);
+ self.setHasData(true);
+ },
+
+ notifyRecordRelationshipAdded: Ember.K,
+ notifyRecordRelationshipRemoved: Ember.K,
+
+ setHasData: function (value) {
+ this.hasData = value;
+ }
+ };
+
+ var ember$data$lib$system$relationships$state$relationship$$default = ember$data$lib$system$relationships$state$relationship$$Relationship;
+
+ var ember$data$lib$system$many$array$$get = Ember.get;
+ var ember$data$lib$system$many$array$$set = Ember.set;
+ var ember$data$lib$system$many$array$$filter = Ember.ArrayPolyfills.filter;
+ var ember$data$lib$system$many$array$$map = Ember.EnumerableUtils.map;
+
+ var ember$data$lib$system$many$array$$default = Ember.Object.extend(Ember.MutableArray, Ember.Evented, {
+ init: function () {
+ this.currentState = Ember.A([]);
+ },
+
+ record: null,
+
+ canonicalState: null,
+ currentState: null,
+
+ length: 0,
+
+ objectAt: function (index) {
+ //Ember observers such as 'firstObject', 'lastObject' might do out of bounds accesses
+ if (!this.currentState[index]) {
+ return undefined;
+ }
+ return this.currentState[index].getRecord();
+ },
+
+ flushCanonical: function () {
+ //TODO make this smarter, currently its plenty stupid
+ var toSet = ember$data$lib$system$many$array$$filter.call(this.canonicalState, function (internalModel) {
+ return !internalModel.isDeleted();
+ });
+
+ //a hack for not removing new records
+ //TODO remove once we have proper diffing
+ var newRecords = this.currentState.filter(function (internalModel) {
+ return internalModel.isNew();
+ });
+ toSet = toSet.concat(newRecords);
+ var oldLength = this.length;
+ this.arrayContentWillChange(0, this.length, toSet.length);
+ this.set('length', toSet.length);
+ this.currentState = toSet;
+ this.arrayContentDidChange(0, oldLength, this.length);
+ //TODO Figure out to notify only on additions and maybe only if unloaded
+ this.relationship.notifyHasManyChanged();
+ this.record.updateRecordArrays();
+ },
+ /**
+ `true` if the relationship is polymorphic, `false` otherwise.
+ @property {Boolean} isPolymorphic
+ @private
+ */
+ isPolymorphic: false,
+
+ /**
+ The loading state of this array
+ @property {Boolean} isLoaded
+ */
+ isLoaded: false,
+
+ /**
+ The relationship which manages this array.
+ @property {ManyRelationship} relationship
+ @private
+ */
+ relationship: null,
+
+ internalReplace: function (idx, amt, objects) {
+ if (!objects) {
+ objects = [];
+ }
+ this.arrayContentWillChange(idx, amt, objects.length);
+ this.currentState.splice.apply(this.currentState, [idx, amt].concat(objects));
+ this.set('length', this.currentState.length);
+ this.arrayContentDidChange(idx, amt, objects.length);
+ if (objects) {
+ //TODO(Igor) probably needed only for unloaded records
+ this.relationship.notifyHasManyChanged();
+ }
+ this.record.updateRecordArrays();
+ },
+
+ //TODO(Igor) optimize
+ internalRemoveRecords: function (records) {
+ var index;
+ for (var i = 0; i < records.length; i++) {
+ index = this.currentState.indexOf(records[i]);
+ this.internalReplace(index, 1);
+ }
+ },
+
+ //TODO(Igor) optimize
+ internalAddRecords: function (records, idx) {
+ if (idx === undefined) {
+ idx = this.currentState.length;
+ }
+ this.internalReplace(idx, 0, records);
+ },
+
+ replace: function (idx, amt, objects) {
+ var records;
+ if (amt > 0) {
+ records = this.currentState.slice(idx, idx + amt);
+ this.get('relationship').removeRecords(records);
+ }
+ if (objects) {
+ this.get('relationship').addRecords(ember$data$lib$system$many$array$$map(objects, function (obj) {
+ return obj._internalModel;
+ }), idx);
+ }
+ },
+ /**
+ Used for async `hasMany` arrays
+ to keep track of when they will resolve.
+ @property {Ember.RSVP.Promise} promise
+ @private
+ */
+ promise: null,
+
+ /**
+ @method loadingRecordsCount
+ @param {Number} count
+ @private
+ */
+ loadingRecordsCount: function (count) {
+ this.loadingRecordsCount = count;
+ },
+
+ /**
+ @method loadedRecord
+ @private
+ */
+ loadedRecord: function () {
+ this.loadingRecordsCount--;
+ if (this.loadingRecordsCount === 0) {
+ ember$data$lib$system$many$array$$set(this, 'isLoaded', true);
+ this.trigger('didLoad');
+ }
+ },
+
+ /**
+ @method reload
+ @public
+ */
+ reload: function () {
+ return this.relationship.reload();
+ },
+
+ /**
+ Saves all of the records in the `ManyArray`.
+ Example
+ ```javascript
+ store.find('inbox', 1).then(function(inbox) {
+ inbox.get('messages').then(function(messages) {
+ messages.forEach(function(message) {
+ message.set('isRead', true);
+ });
+ messages.save()
+ });
+ });
+ ```
+ @method save
+ @return {DS.PromiseArray} promise
+ */
+ save: function () {
+ var manyArray = this;
+ var promiseLabel = 'DS: ManyArray#save ' + ember$data$lib$system$many$array$$get(this, 'type');
+ var promise = Ember.RSVP.all(this.invoke('save'), promiseLabel).then(function (array) {
+ return manyArray;
+ }, null, 'DS: ManyArray#save return ManyArray');
+
+ return ember$data$lib$system$promise$proxies$$PromiseArray.create({ promise: promise });
+ },
+
+ /**
+ Create a child record within the owner
+ @method createRecord
+ @private
+ @param {Object} hash
+ @return {DS.Model} record
+ */
+ createRecord: function (hash) {
+ var store = ember$data$lib$system$many$array$$get(this, 'store');
+ var type = ember$data$lib$system$many$array$$get(this, 'type');
+ var record;
+
+
+ record = store.createRecord(type.modelName, hash);
+ this.pushObject(record);
+
+ return record;
+ },
+
+ /**
+ @method addRecord
+ @param {DS.Model} record
+ @deprecated Use `addObject()` instead
+ */
+ addRecord: function (record) {
+ this.addObject(record);
+ },
+
+ /**
+ @method removeRecord
+ @param {DS.Model} record
+ @deprecated Use `removeObject()` instead
+ */
+ removeRecord: function (record) {
+ this.removeObject(record);
+ }
+ });
+
+ var ember$data$lib$system$relationships$state$has$many$$map = Ember.EnumerableUtils.map;
+
+ var ember$data$lib$system$relationships$state$has$many$$ManyRelationship = function (store, record, inverseKey, relationshipMeta) {
+ this._super$constructor(store, record, inverseKey, relationshipMeta);
+ this.belongsToType = relationshipMeta.type;
+ this.canonicalState = [];
+ this.manyArray = ember$data$lib$system$many$array$$default.create({
+ canonicalState: this.canonicalState,
+ store: this.store,
+ relationship: this,
+ type: this.store.modelFor(this.belongsToType),
+ record: record
+ });
+ this.isPolymorphic = relationshipMeta.options.polymorphic;
+ this.manyArray.isPolymorphic = this.isPolymorphic;
+ };
+
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype = Ember.create(ember$data$lib$system$relationships$state$relationship$$default.prototype);
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype.constructor = ember$data$lib$system$relationships$state$has$many$$ManyRelationship;
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype._super$constructor = ember$data$lib$system$relationships$state$relationship$$default;
+
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype.destroy = function () {
+ this.manyArray.destroy();
+ };
+
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype._super$addCanonicalRecord = ember$data$lib$system$relationships$state$relationship$$default.prototype.addCanonicalRecord;
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype.addCanonicalRecord = function (record, idx) {
+ if (this.canonicalMembers.has(record)) {
+ return;
+ }
+ if (idx !== undefined) {
+ this.canonicalState.splice(idx, 0, record);
+ } else {
+ this.canonicalState.push(record);
+ }
+ this._super$addCanonicalRecord(record, idx);
+ };
+
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype._super$addRecord = ember$data$lib$system$relationships$state$relationship$$default.prototype.addRecord;
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype.addRecord = function (record, idx) {
+ if (this.members.has(record)) {
+ return;
+ }
+ this._super$addRecord(record, idx);
+ this.manyArray.internalAddRecords([record], idx);
+ };
+
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype._super$removeCanonicalRecordFromOwn = ember$data$lib$system$relationships$state$relationship$$default.prototype.removeCanonicalRecordFromOwn;
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype.removeCanonicalRecordFromOwn = function (record, idx) {
+ var i = idx;
+ if (!this.canonicalMembers.has(record)) {
+ return;
+ }
+ if (i === undefined) {
+ i = this.canonicalState.indexOf(record);
+ }
+ if (i > -1) {
+ this.canonicalState.splice(i, 1);
+ }
+ this._super$removeCanonicalRecordFromOwn(record, idx);
+ };
+
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype._super$flushCanonical = ember$data$lib$system$relationships$state$relationship$$default.prototype.flushCanonical;
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype.flushCanonical = function () {
+ this.manyArray.flushCanonical();
+ this._super$flushCanonical();
+ };
+
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype._super$removeRecordFromOwn = ember$data$lib$system$relationships$state$relationship$$default.prototype.removeRecordFromOwn;
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype.removeRecordFromOwn = function (record, idx) {
+ if (!this.members.has(record)) {
+ return;
+ }
+ this._super$removeRecordFromOwn(record, idx);
+ if (idx !== undefined) {
+ //TODO(Igor) not used currently, fix
+ this.manyArray.currentState.removeAt(idx);
+ } else {
+ this.manyArray.internalRemoveRecords([record]);
+ }
+ };
+
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype.notifyRecordRelationshipAdded = function (record, idx) {
+ var typeClass = this.store.modelFor(this.relationshipMeta.type);
+
+ this.record.notifyHasManyAdded(this.key, record, idx);
+ };
+
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype.reload = function () {
+ var self = this;
+ if (this.link) {
+ return this.fetchLink();
+ } else {
+ return this.store.scheduleFetchMany(this.manyArray.toArray()).then(function () {
+ //Goes away after the manyArray refactor
+ self.manyArray.set("isLoaded", true);
+ return self.manyArray;
+ });
+ }
+ };
+
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype.computeChanges = function (records) {
+ var members = this.canonicalMembers;
+ var recordsToRemove = [];
+ var length;
+ var record;
+ var i;
+
+ records = ember$data$lib$system$relationships$state$has$many$$setForArray(records);
+
+ members.forEach(function (member) {
+ if (records.has(member)) {
+ return;
+ }
+
+ recordsToRemove.push(member);
+ });
+
+ this.removeCanonicalRecords(recordsToRemove);
+
+ // Using records.toArray() since currently using
+ // removeRecord can modify length, messing stuff up
+ // forEach since it directly looks at "length" each
+ // iteration
+ records = records.toArray();
+ length = records.length;
+ for (i = 0; i < length; i++) {
+ record = records[i];
+ this.removeCanonicalRecord(record);
+ this.addCanonicalRecord(record, i);
+ }
+ };
+
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype.fetchLink = function () {
+ var self = this;
+ return this.store.findHasMany(this.record, this.link, this.relationshipMeta).then(function (records) {
+ self.store._backburner.join(function () {
+ self.updateRecordsFromAdapter(records);
+ });
+ return self.manyArray;
+ });
+ };
+
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype.findRecords = function () {
+ var manyArray = this.manyArray;
+ //TODO CLEANUP
+ return this.store.findMany(ember$data$lib$system$relationships$state$has$many$$map(manyArray.toArray(), function (rec) {
+ return rec._internalModel;
+ })).then(function () {
+ //Goes away after the manyArray refactor
+ manyArray.set("isLoaded", true);
+ return manyArray;
+ });
+ };
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype.notifyHasManyChanged = function () {
+ this.record.notifyHasManyAdded(this.key);
+ };
+
+ ember$data$lib$system$relationships$state$has$many$$ManyRelationship.prototype.getRecords = function () {
+ //TODO(Igor) sync server here, once our syncing is not stupid
+ if (this.isAsync) {
+ var self = this;
+ var promise;
+ if (this.link) {
+ promise = this.findLink().then(function () {
+ return self.findRecords();
+ });
+ } else {
+ promise = this.findRecords();
+ }
+ return ember$data$lib$system$promise$proxies$$PromiseManyArray.create({
+ content: this.manyArray,
+ promise: promise
+ });
+ } else {
+
+ //TODO(Igor) WTF DO I DO HERE?
+ if (!this.manyArray.get("isDestroyed")) {
+ this.manyArray.set("isLoaded", true);
+ }
+ return this.manyArray;
+ }
+ };
+
+ function ember$data$lib$system$relationships$state$has$many$$setForArray(array) {
+ var set = new ember$data$lib$system$ordered$set$$default();
+
+ if (array) {
+ for (var i = 0, l = array.length; i < l; i++) {
+ set.add(array[i]);
+ }
+ }
+
+ return set;
+ }
+
+ var ember$data$lib$system$relationships$state$has$many$$default = ember$data$lib$system$relationships$state$has$many$$ManyRelationship;
+
+ var ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship = function (store, record, inverseKey, relationshipMeta) {
+ this._super$constructor(store, record, inverseKey, relationshipMeta);
+ this.record = record;
+ this.key = relationshipMeta.key;
+ this.inverseRecord = null;
+ this.canonicalState = null;
+ };
+
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype = Ember.create(ember$data$lib$system$relationships$state$relationship$$default.prototype);
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype.constructor = ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship;
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype._super$constructor = ember$data$lib$system$relationships$state$relationship$$default;
+
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype.setRecord = function (newRecord) {
+ if (newRecord) {
+ this.addRecord(newRecord);
+ } else if (this.inverseRecord) {
+ this.removeRecord(this.inverseRecord);
+ }
+ this.setHasData(true);
+ };
+
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype.setCanonicalRecord = function (newRecord) {
+ if (newRecord) {
+ this.addCanonicalRecord(newRecord);
+ } else if (this.inverseRecord) {
+ this.removeCanonicalRecord(this.inverseRecord);
+ }
+ this.setHasData(true);
+ };
+
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype._super$addCanonicalRecord = ember$data$lib$system$relationships$state$relationship$$default.prototype.addCanonicalRecord;
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype.addCanonicalRecord = function (newRecord) {
+ if (this.canonicalMembers.has(newRecord)) {
+ return;
+ }
+
+ if (this.canonicalState) {
+ this.removeCanonicalRecord(this.canonicalState);
+ }
+
+ this.canonicalState = newRecord;
+ this._super$addCanonicalRecord(newRecord);
+ };
+
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype._super$flushCanonical = ember$data$lib$system$relationships$state$relationship$$default.prototype.flushCanonical;
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype.flushCanonical = function () {
+ //temporary fix to not remove newly created records if server returned null.
+ //TODO remove once we have proper diffing
+ if (this.inverseRecord && this.inverseRecord.isNew() && !this.canonicalState) {
+ return;
+ }
+ this.inverseRecord = this.canonicalState;
+ this.record.notifyBelongsToChanged(this.key);
+ this._super$flushCanonical();
+ };
+
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype._super$addRecord = ember$data$lib$system$relationships$state$relationship$$default.prototype.addRecord;
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype.addRecord = function (newRecord) {
+ if (this.members.has(newRecord)) {
+ return;
+ }
+ var typeClass = this.store.modelFor(this.relationshipMeta.type);
+
+ if (this.inverseRecord) {
+ this.removeRecord(this.inverseRecord);
+ }
+
+ this.inverseRecord = newRecord;
+ this._super$addRecord(newRecord);
+ this.record.notifyBelongsToChanged(this.key);
+ };
+
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype.setRecordPromise = function (newPromise) {
+ var content = newPromise.get && newPromise.get("content");
+ this.setRecord(content ? content._internalModel : content);
+ };
+
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype._super$removeRecordFromOwn = ember$data$lib$system$relationships$state$relationship$$default.prototype.removeRecordFromOwn;
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype.removeRecordFromOwn = function (record) {
+ if (!this.members.has(record)) {
+ return;
+ }
+ this.inverseRecord = null;
+ this._super$removeRecordFromOwn(record);
+ this.record.notifyBelongsToChanged(this.key);
+ };
+
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype._super$removeCanonicalRecordFromOwn = ember$data$lib$system$relationships$state$relationship$$default.prototype.removeCanonicalRecordFromOwn;
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype.removeCanonicalRecordFromOwn = function (record) {
+ if (!this.canonicalMembers.has(record)) {
+ return;
+ }
+ this.canonicalState = null;
+ this._super$removeCanonicalRecordFromOwn(record);
+ };
+
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype.findRecord = function () {
+ if (this.inverseRecord) {
+ return this.store._findByInternalModel(this.inverseRecord);
+ } else {
+ return Ember.RSVP.Promise.resolve(null);
+ }
+ };
+
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype.fetchLink = function () {
+ var self = this;
+ return this.store.findBelongsTo(this.record, this.link, this.relationshipMeta).then(function (record) {
+ if (record) {
+ self.addRecord(record);
+ }
+ return record;
+ });
+ };
+
+ ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship.prototype.getRecord = function () {
+ //TODO(Igor) flushCanonical here once our syncing is not stupid
+ if (this.isAsync) {
+ var promise;
+ if (this.link) {
+ var self = this;
+ promise = this.findLink().then(function () {
+ return self.findRecord();
+ });
+ } else {
+ promise = this.findRecord();
+ }
+
+ return ember$data$lib$system$promise$proxies$$PromiseObject.create({
+ promise: promise,
+ content: this.inverseRecord ? this.inverseRecord.getRecord() : null
+ });
+ } else {
+ if (this.inverseRecord === null) {
+ return null;
+ }
+ var toReturn = this.inverseRecord.getRecord();
+ return toReturn;
+ }
+ };
+
+ var ember$data$lib$system$relationships$state$belongs$to$$default = ember$data$lib$system$relationships$state$belongs$to$$BelongsToRelationship;
+
+ var ember$data$lib$system$relationships$state$create$$get = Ember.get;
+
+ var ember$data$lib$system$relationships$state$create$$createRelationshipFor = function (record, relationshipMeta, store) {
+ var inverseKey;
+ var inverse = record.type.inverseFor(relationshipMeta.key, store);
+
+ if (inverse) {
+ inverseKey = inverse.name;
+ }
+
+ if (relationshipMeta.kind === "hasMany") {
+ return new ember$data$lib$system$relationships$state$has$many$$default(store, record, inverseKey, relationshipMeta);
+ } else {
+ return new ember$data$lib$system$relationships$state$belongs$to$$default(store, record, inverseKey, relationshipMeta);
+ }
+ };
+
+ var ember$data$lib$system$relationships$state$create$$Relationships = function (record) {
+ this.record = record;
+ this.initializedRelationships = Ember.create(null);
+ };
+
+ ember$data$lib$system$relationships$state$create$$Relationships.prototype.has = function (key) {
+ return !!this.initializedRelationships[key];
+ };
+
+ ember$data$lib$system$relationships$state$create$$Relationships.prototype.get = function (key) {
+ var relationships = this.initializedRelationships;
+ var relationshipsByName = ember$data$lib$system$relationships$state$create$$get(this.record.type, "relationshipsByName");
+ if (!relationships[key] && relationshipsByName.get(key)) {
+ relationships[key] = ember$data$lib$system$relationships$state$create$$createRelationshipFor(this.record, relationshipsByName.get(key), this.record.store);
+ }
+ return relationships[key];
+ };
+
+ var ember$data$lib$system$relationships$state$create$$default = ember$data$lib$system$relationships$state$create$$Relationships;
+
+ var ember$data$lib$system$snapshot$$get = Ember.get;
+
+ /**
+ @class Snapshot
+ @namespace DS
+ @private
+ @constructor
+ @param {DS.Model} internalModel The model to create a snapshot from
+ */
+ function ember$data$lib$system$snapshot$$Snapshot(internalModel) {
+ this._attributes = Ember.create(null);
+ this._belongsToRelationships = Ember.create(null);
+ this._belongsToIds = Ember.create(null);
+ this._hasManyRelationships = Ember.create(null);
+ this._hasManyIds = Ember.create(null);
+
+ var record = internalModel.getRecord();
+ this.record = record;
+ record.eachAttribute(function (keyName) {
+ this._attributes[keyName] = ember$data$lib$system$snapshot$$get(record, keyName);
+ }, this);
+
+ this.id = internalModel.id;
+ this._internalModel = internalModel;
+ this.type = internalModel.type;
+ this.modelName = internalModel.type.modelName;
+
+ this._changedAttributes = record.changedAttributes();
+
+ // The following code is here to keep backwards compatibility when accessing
+ // `constructor` directly.
+ //
+ // With snapshots you should use `type` instead of `constructor`.
+ //
+ // Remove for Ember Data 1.0.
+ if (Ember.platform.hasPropertyAccessors) {
+ var callDeprecate = true;
+
+ Ember.defineProperty(this, 'constructor', {
+ get: function () {
+ // Ugly hack since accessing error.stack (done in `Ember.deprecate()`)
+ // causes the internals of Chrome to access the constructor, which then
+ // causes an infinite loop if accessed and calls `Ember.deprecate()`
+ // again.
+ if (callDeprecate) {
+ callDeprecate = false;
+ callDeprecate = true;
+ }
+
+ return this.type;
+ }
+ });
+ } else {
+ this.constructor = this.type;
+ }
+ }
+
+ ember$data$lib$system$snapshot$$Snapshot.prototype = {
+ constructor: ember$data$lib$system$snapshot$$Snapshot,
+
+ /**
+ The id of the snapshot's underlying record
+ Example
+ ```javascript
+ // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+ postSnapshot.id; // => '1'
+ ```
+ @property id
+ @type {String}
+ */
+ id: null,
+
+ /**
+ The underlying record for this snapshot. Can be used to access methods and
+ properties defined on the record.
+ Example
+ ```javascript
+ var json = snapshot.record.toJSON();
+ ```
+ @property record
+ @type {DS.Model}
+ */
+ record: null,
+
+ /**
+ The type of the underlying record for this snapshot, as a DS.Model.
+ @property type
+ @type {DS.Model}
+ */
+ type: null,
+
+ /**
+ The name of the type of the underlying record for this snapshot, as a string.
+ @property modelName
+ @type {String}
+ */
+ modelName: null,
+
+ /**
+ Returns the value of an attribute.
+ Example
+ ```javascript
+ // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+ postSnapshot.attr('author'); // => 'Tomster'
+ postSnapshot.attr('title'); // => 'Ember.js rocks'
+ ```
+ Note: Values are loaded eagerly and cached when the snapshot is created.
+ @method attr
+ @param {String} keyName
+ @return {Object} The attribute value or undefined
+ */
+ attr: function (keyName) {
+ if (keyName in this._attributes) {
+ return this._attributes[keyName];
+ }
+ throw new Ember.Error('Model \'' + Ember.inspect(this.record) + '\' has no attribute named \'' + keyName + '\' defined.');
+ },
+
+ /**
+ Returns all attributes and their corresponding values.
+ Example
+ ```javascript
+ // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+ postSnapshot.attributes(); // => { author: 'Tomster', title: 'Ember.js rocks' }
+ ```
+ @method attributes
+ @return {Object} All attributes of the current snapshot
+ */
+ attributes: function () {
+ return Ember.copy(this._attributes);
+ },
+
+ /**
+ Returns all changed attributes and their old and new values.
+ Example
+ ```javascript
+ // store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+ postModel.set('title', 'Ember.js rocks!');
+ postSnapshot.changedAttributes(); // => { title: ['Ember.js rocks', 'Ember.js rocks!'] }
+ ```
+ @method changedAttributes
+ @return {Object} All changed attributes of the current snapshot
+ */
+ changedAttributes: function () {
+ var prop;
+ var changedAttributes = Ember.create(null);
+
+ for (prop in this._changedAttributes) {
+ changedAttributes[prop] = Ember.copy(this._changedAttributes[prop]);
+ }
+
+ return changedAttributes;
+ },
+
+ /**
+ Returns the current value of a belongsTo relationship.
+ `belongsTo` takes an optional hash of options as a second parameter,
+ currently supported options are:
+ - `id`: set to `true` if you only want the ID of the related record to be
+ returned.
+ Example
+ ```javascript
+ // store.push('post', { id: 1, title: 'Hello World' });
+ // store.createRecord('comment', { body: 'Lorem ipsum', post: post });
+ commentSnapshot.belongsTo('post'); // => DS.Snapshot
+ commentSnapshot.belongsTo('post', { id: true }); // => '1'
+ // store.push('comment', { id: 1, body: 'Lorem ipsum' });
+ commentSnapshot.belongsTo('post'); // => undefined
+ ```
+ Calling `belongsTo` will return a new Snapshot as long as there's any known
+ data for the relationship available, such as an ID. If the relationship is
+ known but unset, `belongsTo` will return `null`. If the contents of the
+ relationship is unknown `belongsTo` will return `undefined`.
+ Note: Relationships are loaded lazily and cached upon first access.
+ @method belongsTo
+ @param {String} keyName
+ @param {Object} [options]
+ @return {(DS.Snapshot|String|null|undefined)} A snapshot or ID of a known
+ relationship or null if the relationship is known but unset. undefined
+ will be returned if the contents of the relationship is unknown.
+ */
+ belongsTo: function (keyName, options) {
+ var id = options && options.id;
+ var relationship, inverseRecord, hasData;
+ var result;
+
+ if (id && keyName in this._belongsToIds) {
+ return this._belongsToIds[keyName];
+ }
+
+ if (!id && keyName in this._belongsToRelationships) {
+ return this._belongsToRelationships[keyName];
+ }
+
+ relationship = this._internalModel._relationships.get(keyName);
+ if (!(relationship && relationship.relationshipMeta.kind === 'belongsTo')) {
+ throw new Ember.Error('Model \'' + Ember.inspect(this.record) + '\' has no belongsTo relationship named \'' + keyName + '\' defined.');
+ }
+
+ hasData = ember$data$lib$system$snapshot$$get(relationship, 'hasData');
+ inverseRecord = ember$data$lib$system$snapshot$$get(relationship, 'inverseRecord');
+
+ if (hasData) {
+ if (inverseRecord && !inverseRecord.isDeleted()) {
+ if (id) {
+ result = ember$data$lib$system$snapshot$$get(inverseRecord, 'id');
+ } else {
+ result = inverseRecord.createSnapshot();
+ }
+ } else {
+ result = null;
+ }
+ }
+
+ if (id) {
+ this._belongsToIds[keyName] = result;
+ } else {
+ this._belongsToRelationships[keyName] = result;
+ }
+
+ return result;
+ },
+
+ /**
+ Returns the current value of a hasMany relationship.
+ `hasMany` takes an optional hash of options as a second parameter,
+ currently supported options are:
+ - `ids`: set to `true` if you only want the IDs of the related records to be
+ returned.
+ Example
+ ```javascript
+ // store.push('post', { id: 1, title: 'Hello World', comments: [2, 3] });
+ postSnapshot.hasMany('comments'); // => [DS.Snapshot, DS.Snapshot]
+ postSnapshot.hasMany('comments', { ids: true }); // => ['2', '3']
+ // store.push('post', { id: 1, title: 'Hello World' });
+ postSnapshot.hasMany('comments'); // => undefined
+ ```
+ Note: Relationships are loaded lazily and cached upon first access.
+ @method hasMany
+ @param {String} keyName
+ @param {Object} [options]
+ @return {(Array|undefined)} An array of snapshots or IDs of a known
+ relationship or an empty array if the relationship is known but unset.
+ undefined will be returned if the contents of the relationship is unknown.
+ */
+ hasMany: function (keyName, options) {
+ var ids = options && options.ids;
+ var relationship, members, hasData;
+ var results;
+
+ if (ids && keyName in this._hasManyIds) {
+ return this._hasManyIds[keyName];
+ }
+
+ if (!ids && keyName in this._hasManyRelationships) {
+ return this._hasManyRelationships[keyName];
+ }
+
+ relationship = this._internalModel._relationships.get(keyName);
+ if (!(relationship && relationship.relationshipMeta.kind === 'hasMany')) {
+ throw new Ember.Error('Model \'' + Ember.inspect(this.record) + '\' has no hasMany relationship named \'' + keyName + '\' defined.');
+ }
+
+ hasData = ember$data$lib$system$snapshot$$get(relationship, 'hasData');
+ members = ember$data$lib$system$snapshot$$get(relationship, 'members');
+
+ if (hasData) {
+ results = [];
+ members.forEach(function (member) {
+ if (!member.isDeleted()) {
+ if (ids) {
+ results.push(member.id);
+ } else {
+ results.push(member.createSnapshot());
+ }
+ }
+ });
+ }
+
+ if (ids) {
+ this._hasManyIds[keyName] = results;
+ } else {
+ this._hasManyRelationships[keyName] = results;
+ }
+
+ return results;
+ },
+
+ /**
+ Iterates through all the attributes of the model, calling the passed
+ function on each attribute.
+ Example
+ ```javascript
+ snapshot.eachAttribute(function(name, meta) {
+ // ...
+ });
+ ```
+ @method eachAttribute
+ @param {Function} callback the callback to execute
+ @param {Object} [binding] the value to which the callback's `this` should be bound
+ */
+ eachAttribute: function (callback, binding) {
+ this.record.eachAttribute(callback, binding);
+ },
+
+ /**
+ Iterates through all the relationships of the model, calling the passed
+ function on each relationship.
+ Example
+ ```javascript
+ snapshot.eachRelationship(function(name, relationship) {
+ // ...
+ });
+ ```
+ @method eachRelationship
+ @param {Function} callback the callback to execute
+ @param {Object} [binding] the value to which the callback's `this` should be bound
+ */
+ eachRelationship: function (callback, binding) {
+ this.record.eachRelationship(callback, binding);
+ },
+
+ /**
+ @method get
+ @param {String} keyName
+ @return {Object} The property value
+ @deprecated Use [attr](#method_attr), [belongsTo](#method_belongsTo) or [hasMany](#method_hasMany) instead
+ */
+ get: function (keyName) {
+
+ if (keyName === 'id') {
+ return this.id;
+ }
+
+ if (keyName in this._attributes) {
+ return this.attr(keyName);
+ }
+
+ var relationship = this._internalModel._relationships.get(keyName);
+
+ if (relationship && relationship.relationshipMeta.kind === 'belongsTo') {
+ return this.belongsTo(keyName);
+ }
+ if (relationship && relationship.relationshipMeta.kind === 'hasMany') {
+ return this.hasMany(keyName);
+ }
+
+ return ember$data$lib$system$snapshot$$get(this.record, keyName);
+ },
+
+ /**
+ @method serialize
+ @param {Object} options
+ @return {Object} an object whose values are primitive JSON values only
+ */
+ serialize: function (options) {
+ return this.record.store.serializerFor(this.modelName).serialize(this, options);
+ },
+
+ /**
+ @method unknownProperty
+ @param {String} keyName
+ @return {Object} The property value
+ @deprecated Use [attr](#method_attr), [belongsTo](#method_belongsTo) or [hasMany](#method_hasMany) instead
+ */
+ unknownProperty: function (keyName) {
+ return this.get(keyName);
+ },
+
+ /**
+ @method _createSnapshot
+ @private
+ */
+ _createSnapshot: function () {
+ return this;
+ }
+ };
+
+ Ember.defineProperty(ember$data$lib$system$snapshot$$Snapshot.prototype, 'typeKey', {
+ enumerable: false,
+ get: function () {
+ return this.modelName;
+ },
+ set: function () {
+ }
+ });
+
+ var ember$data$lib$system$snapshot$$default = ember$data$lib$system$snapshot$$Snapshot;
+
+ var ember$data$lib$system$model$internal$model$$Promise = Ember.RSVP.Promise;
+ var ember$data$lib$system$model$internal$model$$get = Ember.get;
+ var ember$data$lib$system$model$internal$model$$set = Ember.set;
+ var ember$data$lib$system$model$internal$model$$forEach = Ember.ArrayPolyfills.forEach;
+ var ember$data$lib$system$model$internal$model$$map = Ember.ArrayPolyfills.map;
+
+ var ember$data$lib$system$model$internal$model$$_extractPivotNameCache = Ember.create(null);
+ var ember$data$lib$system$model$internal$model$$_splitOnDotCache = Ember.create(null);
+
+ function ember$data$lib$system$model$internal$model$$splitOnDot(name) {
+ return ember$data$lib$system$model$internal$model$$_splitOnDotCache[name] || (ember$data$lib$system$model$internal$model$$_splitOnDotCache[name] = name.split("."));
+ }
+
+ function ember$data$lib$system$model$internal$model$$extractPivotName(name) {
+ return ember$data$lib$system$model$internal$model$$_extractPivotNameCache[name] || (ember$data$lib$system$model$internal$model$$_extractPivotNameCache[name] = ember$data$lib$system$model$internal$model$$splitOnDot(name)[0]);
+ }
+
+ function ember$data$lib$system$model$internal$model$$retrieveFromCurrentState(key) {
+ return function () {
+ return ember$data$lib$system$model$internal$model$$get(this.currentState, key);
+ };
+ }
+
+ /**
+ `InternalModel` is the Model class that we use internally inside Ember Data to represent models.
+ Internal ED methods should only deal with `InternalModel` objects. It is a fast, plain Javascript class.
+
+ We expose `DS.Model` to application code, by materializing a `DS.Model` from `InternalModel` lazily, as
+ a performance optimization.
+
+ `InternalModel` should never be exposed to application code. At the boundaries of the system, in places
+ like `find`, `push`, etc. we convert between Models and InternalModels.
+
+ We need to make sure that the properties from `InternalModel` are correctly exposed/proxied on `Model`
+ if they are needed.
+
+ @class InternalModel
+ */
+
+ var ember$data$lib$system$model$internal$model$$InternalModel = function InternalModel(type, id, store, container, data) {
+ this.type = type;
+ this.id = id;
+ this.store = store;
+ this.container = container;
+ this._data = data || Ember.create(null);
+ this.modelName = type.modelName;
+ this.errors = null;
+ this.dataHasInitialized = false;
+ //Look into making this lazy
+ this._deferredTriggers = [];
+ this._attributes = Ember.create(null);
+ this._inFlightAttributes = Ember.create(null);
+ this._relationships = new ember$data$lib$system$relationships$state$create$$default(this);
+ this.currentState = ember$data$lib$system$model$states$$default.empty;
+ this.isReloading = false;
+ /*
+ implicit relationships are relationship which have not been declared but the inverse side exists on
+ another record somewhere
+ For example if there was
+ ```app/models/comment.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ name: DS.attr()
+ })
+ ```
+ but there is also
+ ```app/models/post.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ name: DS.attr(),
+ comments: DS.hasMany('comment')
+ })
+ ```
+ would have a implicit post relationship in order to be do things like remove ourselves from the post
+ when we are deleted
+ */
+ this._implicitRelationships = Ember.create(null);
+ };
+
+ ember$data$lib$system$model$internal$model$$InternalModel.prototype = {
+ isEmpty: ember$data$lib$system$model$internal$model$$retrieveFromCurrentState("isEmpty"),
+ isLoading: ember$data$lib$system$model$internal$model$$retrieveFromCurrentState("isLoading"),
+ isLoaded: ember$data$lib$system$model$internal$model$$retrieveFromCurrentState("isLoaded"),
+ isDirty: ember$data$lib$system$model$internal$model$$retrieveFromCurrentState("isDirty"),
+ isSaving: ember$data$lib$system$model$internal$model$$retrieveFromCurrentState("isSaving"),
+ isDeleted: ember$data$lib$system$model$internal$model$$retrieveFromCurrentState("isDeleted"),
+ isNew: ember$data$lib$system$model$internal$model$$retrieveFromCurrentState("isNew"),
+ isValid: ember$data$lib$system$model$internal$model$$retrieveFromCurrentState("isValid"),
+ dirtyType: ember$data$lib$system$model$internal$model$$retrieveFromCurrentState("dirtyType"),
+
+ constructor: ember$data$lib$system$model$internal$model$$InternalModel,
+ materializeRecord: function () {
+ // lookupFactory should really return an object that creates
+ // instances with the injections applied
+ this.record = this.type._create({
+ id: this.id,
+ store: this.store,
+ container: this.container,
+ _internalModel: this,
+ currentState: ember$data$lib$system$model$internal$model$$get(this, "currentState")
+ });
+ this._triggerDeferredTriggers();
+ },
+
+ recordObjectWillDestroy: function () {
+ this.record = null;
+ },
+
+ deleteRecord: function () {
+ this.send("deleteRecord");
+ },
+
+ save: function () {
+ var promiseLabel = "DS: Model#save " + this;
+ var resolver = Ember.RSVP.defer(promiseLabel);
+
+ this.store.scheduleSave(this, resolver);
+ return resolver.promise;
+ },
+
+ startedReloading: function () {
+ this.isReloading = true;
+ if (this.record) {
+ ember$data$lib$system$model$internal$model$$set(this.record, "isReloading", true);
+ }
+ },
+
+ finishedReloading: function () {
+ this.isReloading = false;
+ if (this.record) {
+ ember$data$lib$system$model$internal$model$$set(this.record, "isReloading", false);
+ }
+ },
+
+ reload: function () {
+ this.startedReloading();
+ var record = this;
+ var promiseLabel = "DS: Model#reload of " + this;
+ return new ember$data$lib$system$model$internal$model$$Promise(function (resolve) {
+ record.send("reloadRecord", resolve);
+ }, promiseLabel).then(function () {
+ record.didCleanError();
+ return record;
+ }, function (reason) {
+ record.didError();
+ throw reason;
+ }, "DS: Model#reload complete, update flags")["finally"](function () {
+ record.finishedReloading();
+ record.updateRecordArrays();
+ });
+ },
+
+ getRecord: function () {
+ if (!this.record) {
+ this.materializeRecord();
+ }
+ return this.record;
+ },
+
+ unloadRecord: function () {
+ this.send("unloadRecord");
+ },
+
+ eachRelationship: function (callback, binding) {
+ return this.type.eachRelationship(callback, binding);
+ },
+
+ eachAttribute: function (callback, binding) {
+ return this.type.eachAttribute(callback, binding);
+ },
+
+ inverseFor: function (key) {
+ return this.type.inverseFor(key);
+ },
+
+ setupData: function (data) {
+ var changedKeys = ember$data$lib$system$model$internal$model$$mergeAndReturnChangedKeys(this._data, data);
+ this.pushedData();
+ if (this.record) {
+ this.record._notifyProperties(changedKeys);
+ }
+ this.didInitalizeData();
+ },
+
+ becameReady: function () {
+ Ember.run.schedule("actions", this.store.recordArrayManager, this.store.recordArrayManager.recordWasLoaded, this);
+ },
+
+ didInitalizeData: function () {
+ if (!this.dataHasInitialized) {
+ this.becameReady();
+ this.dataHasInitialized = true;
+ }
+ },
+
+ destroy: function () {
+ if (this.record) {
+ return this.record.destroy();
+ }
+ },
+
+ /**
+ @method createSnapshot
+ @private
+ */
+ createSnapshot: function () {
+ return new ember$data$lib$system$snapshot$$default(this);
+ },
+
+ /**
+ @method loadingData
+ @private
+ @param {Promise} promise
+ */
+ loadingData: function (promise) {
+ this.send("loadingData", promise);
+ },
+
+ /**
+ @method loadedData
+ @private
+ */
+ loadedData: function () {
+ this.send("loadedData");
+ this.didInitalizeData();
+ },
+
+ /**
+ @method notFound
+ @private
+ */
+ notFound: function () {
+ this.send("notFound");
+ },
+
+ /**
+ @method pushedData
+ @private
+ */
+ pushedData: function () {
+ this.send("pushedData");
+ },
+
+ flushChangedAttributes: function () {
+ this._inFlightAttributes = this._attributes;
+ this._attributes = Ember.create(null);
+ },
+
+ /**
+ @method adapterWillCommit
+ @private
+ */
+ adapterWillCommit: function () {
+ this.send("willCommit");
+ },
+
+ /**
+ @method adapterDidDirty
+ @private
+ */
+ adapterDidDirty: function () {
+ this.send("becomeDirty");
+ this.updateRecordArraysLater();
+ },
+
+ /**
+ @method send
+ @private
+ @param {String} name
+ @param {Object} context
+ */
+ send: function (name, context) {
+ var currentState = ember$data$lib$system$model$internal$model$$get(this, "currentState");
+
+ if (!currentState[name]) {
+ this._unhandledEvent(currentState, name, context);
+ }
+
+ return currentState[name](this, context);
+ },
+
+ notifyHasManyAdded: function (key, record, idx) {
+ if (this.record) {
+ this.record.notifyHasManyAdded(key, record, idx);
+ }
+ },
+
+ notifyHasManyRemoved: function (key, record, idx) {
+ if (this.record) {
+ this.record.notifyHasManyRemoved(key, record, idx);
+ }
+ },
+
+ notifyBelongsToChanged: function (key, record) {
+ if (this.record) {
+ this.record.notifyBelongsToChanged(key, record);
+ }
+ },
+
+ notifyPropertyChange: function (key) {
+ if (this.record) {
+ this.record.notifyPropertyChange(key);
+ }
+ },
+
+ rollback: function () {
+ var dirtyKeys = Ember.keys(this._attributes);
+
+ this._attributes = Ember.create(null);
+
+ if (ember$data$lib$system$model$internal$model$$get(this, "isError")) {
+ this._inFlightAttributes = Ember.create(null);
+ this.didCleanError();
+ }
+
+ //Eventually rollback will always work for relationships
+ //For now we support it only out of deleted state, because we
+ //have an explicit way of knowing when the server acked the relationship change
+ if (this.isDeleted()) {
+ //TODO: Should probably move this to the state machine somehow
+ this.becameReady();
+ this.reconnectRelationships();
+ }
+
+ if (this.isNew()) {
+ this.clearRelationships();
+ }
+
+ if (this.isValid()) {
+ this._inFlightAttributes = Ember.create(null);
+ }
+
+ this.send("rolledBack");
+
+ this.record._notifyProperties(dirtyKeys);
+ },
+ /**
+ @method transitionTo
+ @private
+ @param {String} name
+ */
+ transitionTo: function (name) {
+ // POSSIBLE TODO: Remove this code and replace with
+ // always having direct reference to state objects
+
+ var pivotName = ember$data$lib$system$model$internal$model$$extractPivotName(name);
+ var currentState = ember$data$lib$system$model$internal$model$$get(this, "currentState");
+ var state = currentState;
+
+ do {
+ if (state.exit) {
+ state.exit(this);
+ }
+ state = state.parentState;
+ } while (!state.hasOwnProperty(pivotName));
+
+ var path = ember$data$lib$system$model$internal$model$$splitOnDot(name);
+ var setups = [];
+ var enters = [];
+ var i, l;
+
+ for (i = 0, l = path.length; i < l; i++) {
+ state = state[path[i]];
+
+ if (state.enter) {
+ enters.push(state);
+ }
+ if (state.setup) {
+ setups.push(state);
+ }
+ }
+
+ for (i = 0, l = enters.length; i < l; i++) {
+ enters[i].enter(this);
+ }
+
+ ember$data$lib$system$model$internal$model$$set(this, "currentState", state);
+ //TODO Consider whether this is the best approach for keeping these two in sync
+ if (this.record) {
+ ember$data$lib$system$model$internal$model$$set(this.record, "currentState", state);
+ }
+
+ for (i = 0, l = setups.length; i < l; i++) {
+ setups[i].setup(this);
+ }
+
+ this.updateRecordArraysLater();
+ },
+
+ _unhandledEvent: function (state, name, context) {
+ var errorMessage = "Attempted to handle event `" + name + "` ";
+ errorMessage += "on " + String(this) + " while in state ";
+ errorMessage += state.stateName + ". ";
+
+ if (context !== undefined) {
+ errorMessage += "Called with " + Ember.inspect(context) + ".";
+ }
+
+ throw new Ember.Error(errorMessage);
+ },
+
+ triggerLater: function () {
+ var length = arguments.length;
+ var args = new Array(length);
+
+ for (var i = 0; i < length; i++) {
+ args[i] = arguments[i];
+ }
+
+ if (this._deferredTriggers.push(args) !== 1) {
+ return;
+ }
+ Ember.run.scheduleOnce("actions", this, "_triggerDeferredTriggers");
+ },
+
+ _triggerDeferredTriggers: function () {
+ //TODO: Before 1.0 we want to remove all the events that happen on the pre materialized record,
+ //but for now, we queue up all the events triggered before the record was materialized, and flush
+ //them once we have the record
+ if (!this.record) {
+ return;
+ }
+ for (var i = 0, l = this._deferredTriggers.length; i < l; i++) {
+ this.record.trigger.apply(this.record, this._deferredTriggers[i]);
+ }
+
+ this._deferredTriggers.length = 0;
+ },
+ /**
+ @method clearRelationships
+ @private
+ */
+ clearRelationships: function () {
+ this.eachRelationship(function (name, relationship) {
+ if (this._relationships.has(name)) {
+ var rel = this._relationships.get(name);
+ //TODO(Igor) figure out whether we want to clear or disconnect
+ rel.clear();
+ rel.destroy();
+ }
+ }, this);
+ var model = this;
+ ember$data$lib$system$model$internal$model$$forEach.call(Ember.keys(this._implicitRelationships), function (key) {
+ model._implicitRelationships[key].clear();
+ model._implicitRelationships[key].destroy();
+ });
+ },
+
+ disconnectRelationships: function () {
+ this.eachRelationship(function (name, relationship) {
+ this._relationships.get(name).disconnect();
+ }, this);
+ var model = this;
+ ember$data$lib$system$model$internal$model$$forEach.call(Ember.keys(this._implicitRelationships), function (key) {
+ model._implicitRelationships[key].disconnect();
+ });
+ },
+
+ reconnectRelationships: function () {
+ this.eachRelationship(function (name, relationship) {
+ this._relationships.get(name).reconnect();
+ }, this);
+ var model = this;
+ ember$data$lib$system$model$internal$model$$forEach.call(Ember.keys(this._implicitRelationships), function (key) {
+ model._implicitRelationships[key].reconnect();
+ });
+ },
+
+ /**
+ When a find request is triggered on the store, the user can optionally pass in
+ attributes and relationships to be preloaded. These are meant to behave as if they
+ came back from the server, except the user obtained them out of band and is informing
+ the store of their existence. The most common use case is for supporting client side
+ nested URLs, such as `/posts/1/comments/2` so the user can do
+ `store.find('comment', 2, {post:1})` without having to fetch the post.
+ Preloaded data can be attributes and relationships passed in either as IDs or as actual
+ models.
+ @method _preloadData
+ @private
+ @param {Object} preload
+ */
+ _preloadData: function (preload) {
+ var record = this;
+ //TODO(Igor) consider the polymorphic case
+ ember$data$lib$system$model$internal$model$$forEach.call(Ember.keys(preload), function (key) {
+ var preloadValue = ember$data$lib$system$model$internal$model$$get(preload, key);
+ var relationshipMeta = record.type.metaForProperty(key);
+ if (relationshipMeta.isRelationship) {
+ record._preloadRelationship(key, preloadValue);
+ } else {
+ record._data[key] = preloadValue;
+ }
+ });
+ },
+
+ _preloadRelationship: function (key, preloadValue) {
+ var relationshipMeta = this.type.metaForProperty(key);
+ var type = relationshipMeta.type;
+ if (relationshipMeta.kind === "hasMany") {
+ this._preloadHasMany(key, preloadValue, type);
+ } else {
+ this._preloadBelongsTo(key, preloadValue, type);
+ }
+ },
+
+ _preloadHasMany: function (key, preloadValue, type) {
+ var internalModel = this;
+
+ var recordsToSet = ember$data$lib$system$model$internal$model$$map.call(preloadValue, function (recordToPush) {
+ return internalModel._convertStringOrNumberIntoInternalModel(recordToPush, type);
+ });
+ //We use the pathway of setting the hasMany as if it came from the adapter
+ //because the user told us that they know this relationships exists already
+ this._relationships.get(key).updateRecordsFromAdapter(recordsToSet);
+ },
+
+ _preloadBelongsTo: function (key, preloadValue, type) {
+ var recordToSet = this._convertStringOrNumberIntoInternalModel(preloadValue, type);
+
+ //We use the pathway of setting the hasMany as if it came from the adapter
+ //because the user told us that they know this relationships exists already
+ this._relationships.get(key).setRecord(recordToSet);
+ },
+
+ _convertStringOrNumberIntoInternalModel: function (value, type) {
+ if (typeof value === "string" || typeof value === "number") {
+ return this.store._internalModelForId(type, value);
+ }
+ if (value._internalModel) {
+ return value._internalModel;
+ }
+ return value;
+ },
+
+ /**
+ @method updateRecordArrays
+ @private
+ */
+ updateRecordArrays: function () {
+ this._updatingRecordArraysLater = false;
+ this.store.dataWasUpdated(this.type, this);
+ },
+
+ setId: function (id) {
+ this.id = id;
+ //TODO figure out whether maybe we should proxy
+ ember$data$lib$system$model$internal$model$$set(this.record, "id", id);
+ },
+
+ didError: function () {
+ this.isError = true;
+ if (this.record) {
+ this.record.set("isError", true);
+ }
+ },
+
+ didCleanError: function () {
+ this.isError = false;
+ if (this.record) {
+ this.record.set("isError", false);
+ }
+ },
+ /**
+ If the adapter did not return a hash in response to a commit,
+ merge the changed attributes and relationships into the existing
+ saved data.
+ @method adapterDidCommit
+ */
+ adapterDidCommit: function (data) {
+ var changedKeys;
+ this.didCleanError();
+
+ if (data) {
+ changedKeys = ember$data$lib$system$model$internal$model$$mergeAndReturnChangedKeys(this._data, data);
+ } else {
+ ember$data$lib$system$merge$$default(this._data, this._inFlightAttributes);
+ }
+
+ this._inFlightAttributes = Ember.create(null);
+
+ this.send("didCommit");
+ this.updateRecordArraysLater();
+
+ if (!data) {
+ return;
+ }
+
+ this.record._notifyProperties(changedKeys);
+ },
+
+ /**
+ @method updateRecordArraysLater
+ @private
+ */
+ updateRecordArraysLater: function () {
+ // quick hack (something like this could be pushed into run.once
+ if (this._updatingRecordArraysLater) {
+ return;
+ }
+ this._updatingRecordArraysLater = true;
+ Ember.run.schedule("actions", this, this.updateRecordArrays);
+ },
+
+ getErrors: function () {
+ if (this.errors) {
+ return this.errors;
+ }
+ var errors = ember$data$lib$system$model$errors$$default.create();
+
+ errors.registerHandlers(this, function () {
+ this.send("becameInvalid");
+ }, function () {
+ this.send("becameValid");
+ });
+
+ this.errors = errors;
+ return errors;
+ },
+ // FOR USE DURING COMMIT PROCESS
+
+ /**
+ @method adapterDidInvalidate
+ @private
+ */
+ adapterDidInvalidate: function (errors) {
+ var recordErrors = this.getErrors();
+ ember$data$lib$system$model$internal$model$$forEach.call(Ember.keys(errors), function (key) {
+ recordErrors.add(key, errors[key]);
+ });
+ this._saveWasRejected();
+ },
+
+ /**
+ @method adapterDidError
+ @private
+ */
+ adapterDidError: function () {
+ this.send("becameError");
+ this.didError();
+ this._saveWasRejected();
+ },
+
+ _saveWasRejected: function () {
+ var keys = Ember.keys(this._inFlightAttributes);
+ for (var i = 0; i < keys.length; i++) {
+ if (this._attributes[keys[i]] === undefined) {
+ this._attributes[keys[i]] = this._inFlightAttributes[keys[i]];
+ }
+ }
+ this._inFlightAttributes = Ember.create(null);
+ },
+
+ toString: function () {
+ if (this.record) {
+ return this.record.toString();
+ } else {
+ return "<" + this.modelName + ":" + this.id + ">";
+ }
+ }
+ };
+
+ // Like Ember.merge, but instead returns a list of keys
+ // for values that fail a strict equality check
+ // instead of the original object.
+ function ember$data$lib$system$model$internal$model$$mergeAndReturnChangedKeys(original, updates) {
+ var changedKeys = [];
+
+ if (!updates || typeof updates !== "object") {
+ return changedKeys;
+ }
+
+ var keys = Ember.keys(updates);
+ var length = keys.length;
+ var i, val, key;
+
+ for (i = 0; i < length; i++) {
+ key = keys[i];
+ val = updates[key];
+
+ if (original[key] !== val) {
+ changedKeys.push(key);
+ }
+
+ original[key] = val;
+ }
+ return changedKeys;
+ }
+
+ var ember$data$lib$system$model$internal$model$$default = ember$data$lib$system$model$internal$model$$InternalModel;
+
+ var ember$data$lib$system$store$$Backburner = Ember.Backburner || Ember.__loader.require("backburner")["default"] || Ember.__loader.require("backburner")["Backburner"];
+
+ //Shim Backburner.join
+ if (!ember$data$lib$system$store$$Backburner.prototype.join) {
+ var ember$data$lib$system$store$$isString = function (suspect) {
+ return typeof suspect === "string";
+ };
+
+ ember$data$lib$system$store$$Backburner.prototype.join = function () {
+ var method, target;
+
+ if (this.currentInstance) {
+ var length = arguments.length;
+ if (length === 1) {
+ method = arguments[0];
+ target = null;
+ } else {
+ target = arguments[0];
+ method = arguments[1];
+ }
+
+ if (ember$data$lib$system$store$$isString(method)) {
+ method = target[method];
+ }
+
+ if (length === 1) {
+ return method();
+ } else if (length === 2) {
+ return method.call(target);
+ } else {
+ var args = new Array(length - 2);
+ for (var i = 0, l = length - 2; i < l; i++) {
+ args[i] = arguments[i + 2];
+ }
+ return method.apply(target, args);
+ }
+ } else {
+ return this.run.apply(this, arguments);
+ }
+ };
+ }
+
+ //Get the materialized model from the internalModel/promise that returns
+ //an internal model and return it in a promiseObject. Useful for returning
+ //from find methods
+ function ember$data$lib$system$store$$promiseRecord(internalModel, label) {
+ //TODO cleanup
+ var toReturn = internalModel;
+ if (!internalModel.then) {
+ toReturn = internalModel.getRecord();
+ } else {
+ toReturn = internalModel.then(function (model) {
+ return model.getRecord();
+ });
+ }
+ return ember$data$lib$system$promise$proxies$$promiseObject(toReturn, label);
+ }
+
+ var ember$data$lib$system$store$$get = Ember.get;
+ var ember$data$lib$system$store$$set = Ember.set;
+ var ember$data$lib$system$store$$once = Ember.run.once;
+ var ember$data$lib$system$store$$isNone = Ember.isNone;
+ var ember$data$lib$system$store$$forEach = Ember.EnumerableUtils.forEach;
+ var ember$data$lib$system$store$$indexOf = Ember.EnumerableUtils.indexOf;
+ var ember$data$lib$system$store$$map = Ember.EnumerableUtils.map;
+ var ember$data$lib$system$store$$Promise = Ember.RSVP.Promise;
+ var ember$data$lib$system$store$$copy = Ember.copy;
+ var ember$data$lib$system$store$$Store;
+
+ var ember$data$lib$system$store$$Service = Ember.Service;
+ if (!ember$data$lib$system$store$$Service) {
+ ember$data$lib$system$store$$Service = Ember.Object;
+ }
+
+ // Implementors Note:
+ //
+ // The variables in this file are consistently named according to the following
+ // scheme:
+ //
+ // * +id+ means an identifier managed by an external source, provided inside
+ // the data provided by that source. These are always coerced to be strings
+ // before being used internally.
+ // * +clientId+ means a transient numerical identifier generated at runtime by
+ // the data store. It is important primarily because newly created objects may
+ // not yet have an externally generated id.
+ // * +internalModel+ means a record internalModel object, which holds metadata about a
+ // record, even if it has not yet been fully materialized.
+ // * +type+ means a DS.Model.
+
+ /**
+ The store contains all of the data for records loaded from the server.
+ It is also responsible for creating instances of `DS.Model` that wrap
+ the individual data for a record, so that they can be bound to in your
+ Handlebars templates.
+
+ Define your application's store like this:
+
+ ```app/stores/application.js
+ import DS from 'ember-data';
+
+ export default DS.Store.extend({
+ });
+ ```
+
+ Most Ember.js applications will only have a single `DS.Store` that is
+ automatically created by their `Ember.Application`.
+
+ You can retrieve models from the store in several ways. To retrieve a record
+ for a specific id, use `DS.Store`'s `find()` method:
+
+ ```javascript
+ store.find('person', 123).then(function (person) {
+ });
+ ```
+
+ By default, the store will talk to your backend using a standard
+ REST mechanism. You can customize how the store talks to your
+ backend by specifying a custom adapter:
+
+ ```app/adapters/application.js
+ import DS from 'ember-data';
+
+ export default DS.Adapter.extend({
+ });
+ ```
+
+ You can learn more about writing a custom adapter by reading the `DS.Adapter`
+ documentation.
+
+ ### Store createRecord() vs. push() vs. pushPayload()
+
+ The store provides multiple ways to create new record objects. They have
+ some subtle differences in their use which are detailed below:
+
+ [createRecord](#method_createRecord) is used for creating new
+ records on the client side. This will return a new record in the
+ `created.uncommitted` state. In order to persist this record to the
+ backend you will need to call `record.save()`.
+
+ [push](#method_push) is used to notify Ember Data's store of new or
+ updated records that exist in the backend. This will return a record
+ in the `loaded.saved` state. The primary use-case for `store#push` is
+ to notify Ember Data about record updates (full or partial) that happen
+ outside of the normal adapter methods (for example
+ [SSE](http://dev.w3.org/html5/eventsource/) or [Web
+ Sockets](http://www.w3.org/TR/2009/WD-websockets-20091222/)).
+
+ [pushPayload](#method_pushPayload) is a convenience wrapper for
+ `store#push` that will deserialize payloads if the
+ Serializer implements a `pushPayload` method.
+
+ Note: When creating a new record using any of the above methods
+ Ember Data will update `DS.RecordArray`s such as those returned by
+ `store#all()`, `store#findAll()` or `store#filter()`. This means any
+ data bindings or computed properties that depend on the RecordArray
+ will automatically be synced to include the new or updated record
+ values.
+
+ @class Store
+ @namespace DS
+ @extends Ember.Service
+ */
+ ember$data$lib$system$store$$Store = ember$data$lib$system$store$$Service.extend({
+
+ /**
+ @method init
+ @private
+ */
+ init: function () {
+ this._backburner = new ember$data$lib$system$store$$Backburner(["normalizeRelationships", "syncRelationships", "finished"]);
+ // internal bookkeeping; not observable
+ this.typeMaps = {};
+ this.recordArrayManager = ember$data$lib$system$record$array$manager$$default.create({
+ store: this
+ });
+ this._pendingSave = [];
+ this._instanceCache = new ember$data$lib$system$store$container$instance$cache$$default(this.container);
+ //Used to keep track of all the find requests that need to be coalesced
+ this._pendingFetch = ember$data$lib$system$map$$Map.create();
+ },
+
+ /**
+ The adapter to use to communicate to a backend server or other persistence layer.
+ This can be specified as an instance, class, or string.
+ If you want to specify `app/adapters/custom.js` as a string, do:
+ ```js
+ adapter: 'custom'
+ ```
+ @property adapter
+ @default DS.RESTAdapter
+ @type {(DS.Adapter|String)}
+ */
+ adapter: "-rest",
+
+ /**
+ Returns a JSON representation of the record using a custom
+ type-specific serializer, if one exists.
+ The available options are:
+ * `includeId`: `true` if the record's ID should be included in
+ the JSON representation
+ @method serialize
+ @private
+ @param {DS.Model} record the record to serialize
+ @param {Object} options an options hash
+ */
+ serialize: function (record, options) {
+ var snapshot = record._internalModel.createSnapshot();
+ return snapshot.serialize(options);
+ },
+
+ /**
+ This property returns the adapter, after resolving a possible
+ string key.
+ If the supplied `adapter` was a class, or a String property
+ path resolved to a class, this property will instantiate the
+ class.
+ This property is cacheable, so the same instance of a specified
+ adapter class should be used for the lifetime of the store.
+ @property defaultAdapter
+ @private
+ @return DS.Adapter
+ */
+ defaultAdapter: Ember.computed("adapter", function () {
+ var adapter = ember$data$lib$system$store$$get(this, "adapter");
+
+
+ adapter = this.retrieveManagedInstance("adapter", adapter);
+
+ return adapter;
+ }),
+
+ // .....................
+ // . CREATE NEW RECORD .
+ // .....................
+
+ /**
+ Create a new record in the current store. The properties passed
+ to this method are set on the newly created record.
+ To create a new instance of `App.Post`:
+ ```js
+ store.createRecord('post', {
+ title: "Rails is omakase"
+ });
+ ```
+ @method createRecord
+ @param {String} modelName
+ @param {Object} inputProperties a hash of properties to set on the
+ newly created record.
+ @return {DS.Model} record
+ */
+ createRecord: function (modelName, inputProperties) {
+ var typeClass = this.modelFor(modelName);
+ var properties = ember$data$lib$system$store$$copy(inputProperties) || Ember.create(null);
+
+ // If the passed properties do not include a primary key,
+ // give the adapter an opportunity to generate one. Typically,
+ // client-side ID generators will use something like uuid.js
+ // to avoid conflicts.
+
+ if (ember$data$lib$system$store$$isNone(properties.id)) {
+ properties.id = this._generateId(modelName, properties);
+ }
+
+ // Coerce ID to a string
+ properties.id = ember$data$lib$system$coerce$id$$default(properties.id);
+
+ var internalModel = this.buildInternalModel(typeClass, properties.id);
+ var record = internalModel.getRecord();
+
+ // Move the record out of its initial `empty` state into
+ // the `loaded` state.
+ internalModel.loadedData();
+
+ // Set the properties specified on the record.
+ record.setProperties(properties);
+
+ internalModel.eachRelationship(function (key, descriptor) {
+ internalModel._relationships.get(key).setHasData(true);
+ });
+
+ return record;
+ },
+
+ /**
+ If possible, this method asks the adapter to generate an ID for
+ a newly created record.
+ @method _generateId
+ @private
+ @param {String} modelName
+ @param {Object} properties from the new record
+ @return {String} if the adapter can generate one, an ID
+ */
+ _generateId: function (modelName, properties) {
+ var adapter = this.adapterFor(modelName);
+
+ if (adapter && adapter.generateIdForRecord) {
+ return adapter.generateIdForRecord(this, modelName, properties);
+ }
+
+ return null;
+ },
+
+ // .................
+ // . DELETE RECORD .
+ // .................
+
+ /**
+ For symmetry, a record can be deleted via the store.
+ Example
+ ```javascript
+ var post = store.createRecord('post', {
+ title: "Rails is omakase"
+ });
+ store.deleteRecord(post);
+ ```
+ @method deleteRecord
+ @param {DS.Model} record
+ */
+ deleteRecord: function (record) {
+ record.deleteRecord();
+ },
+
+ /**
+ For symmetry, a record can be unloaded via the store. Only
+ non-dirty records can be unloaded.
+ Example
+ ```javascript
+ store.find('post', 1).then(function(post) {
+ store.unloadRecord(post);
+ });
+ ```
+ @method unloadRecord
+ @param {DS.Model} record
+ */
+ unloadRecord: function (record) {
+ record.unloadRecord();
+ },
+
+ // ................
+ // . FIND RECORDS .
+ // ................
+
+ /**
+ This is the main entry point into finding records. The first parameter to
+ this method is the model's name as a string.
+ ---
+ To find a record by ID, pass the `id` as the second parameter:
+ ```javascript
+ store.find('person', 1);
+ ```
+ The `find` method will always return a **promise** that will be resolved
+ with the record. If the record was already in the store, the promise will
+ be resolved immediately. Otherwise, the store will ask the adapter's `find`
+ method to find the necessary data.
+ The `find` method will always resolve its promise with the same object for
+ a given type and `id`.
+ ---
+ You can optionally `preload` specific attributes and relationships that you know of
+ by passing them as the third argument to find.
+ For example, if your Ember route looks like `/posts/1/comments/2` and your API route
+ for the comment also looks like `/posts/1/comments/2` if you want to fetch the comment
+ without fetching the post you can pass in the post to the `find` call:
+ ```javascript
+ store.find('comment', 2, {post: 1});
+ ```
+ If you have access to the post model you can also pass the model itself:
+ ```javascript
+ store.find('post', 1).then(function (myPostModel) {
+ store.find('comment', 2, {post: myPostModel});
+ });
+ ```
+ This way, your adapter's `find` or `buildURL` method will be able to look up the
+ relationship on the record and construct the nested URL without having to first
+ fetch the post.
+ ---
+ To find all records for a type, call `find` with no additional parameters:
+ ```javascript
+ store.find('person');
+ ```
+ This will ask the adapter's `findAll` method to find the records for the
+ given type, and return a promise that will be resolved once the server
+ returns the values. The promise will resolve into all records of this type
+ present in the store, even if the server only returns a subset of them.
+ ---
+ To find a record by a query, call `find` with a hash as the second
+ parameter:
+ ```javascript
+ store.find('person', { page: 1 });
+ ```
+ By passing an object `{page: 1}` as an argument to the find method, it
+ delegates to the adapter's findQuery method. The adapter then makes
+ a call to the server, transforming the object `{page: 1}` as parameters
+ that are sent along, and will return a RecordArray when the promise
+ resolves.
+ Exposing queries this way seems preferable to creating an abstract query
+ language for all server-side queries, and then require all adapters to
+ implement them.
+ The call made to the server, using a Rails backend, will look something like this:
+ ```
+ Started GET "/api/v1/person?page=1"
+ Processing by Api::V1::PersonsController#index as HTML
+ Parameters: {"page"=>"1"}
+ ```
+ If you do something like this:
+ ```javascript
+ store.find('person', {ids: [1, 2, 3]});
+ ```
+ The call to the server, using a Rails backend, will look something like this:
+ ```
+ Started GET "/api/v1/person?ids%5B%5D=1&ids%5B%5D=2&ids%5B%5D=3"
+ Processing by Api::V1::PersonsController#index as HTML
+ Parameters: {"ids"=>["1", "2", "3"]}
+ ```
+ @method find
+ @param {String} modelName
+ @param {(Object|String|Integer|null)} id
+ @param {Object} preload - optional set of attributes and relationships passed in either as IDs or as actual models
+ @return {Promise} promise
+ */
+ find: function (modelName, id, preload) {
+
+ if (arguments.length === 1) {
+ return this.findAll(modelName);
+ }
+
+ // We are passed a query instead of an id.
+ if (Ember.typeOf(id) === "object") {
+ return this.findQuery(modelName, id);
+ }
+
+ return this.findById(modelName, ember$data$lib$system$coerce$id$$default(id), preload);
+ },
+
+ /**
+ This method returns a fresh record for a given type and id combination.
+ If a record is available for the given type/id combination, then
+ it will fetch this record from the store and call `reload()` on it.
+ That will fire a request to server and return a promise that will
+ resolve once the record has been reloaded.
+ If there's no record corresponding in the store it will simply call
+ `store.find`.
+ Example
+ ```app/routes/post.js
+ import Ember from 'ember';
+ export default Ember.Route.extend({
+ model: function(params) {
+ return this.store.fetchById('post', params.post_id);
+ }
+ });
+ ```
+ @method fetchById
+ @param {String} modelName
+ @param {(String|Integer)} id
+ @param {Object} preload - optional set of attributes and relationships passed in either as IDs or as actual models
+ @return {Promise} promise
+ */
+ fetchById: function (modelName, id, preload) {
+ if (this.hasRecordForId(modelName, id)) {
+ return this.getById(modelName, id).reload();
+ } else {
+ return this.find(modelName, id, preload);
+ }
+ },
+
+ /**
+ This method returns a fresh collection from the server, regardless of if there is already records
+ in the store or not.
+ @method fetchAll
+ @param {String} modelName
+ @return {Promise} promise
+ */
+ fetchAll: function (modelName) {
+ var typeClass = this.modelFor(modelName);
+
+ return this._fetchAll(typeClass, this.all(modelName));
+ },
+
+ /**
+ @method fetch
+ @param {String} modelName
+ @param {(String|Integer)} id
+ @param {Object} preload - optional set of attributes and relationships passed in either as IDs or as actual models
+ @return {Promise} promise
+ @deprecated Use [fetchById](#method_fetchById) instead
+ */
+ fetch: function (modelName, id, preload) {
+ return this.fetchById(modelName, id, preload);
+ },
+
+ /**
+ This method returns a record for a given type and id combination.
+ @method findById
+ @private
+ @param {String} modelName
+ @param {(String|Integer)} id
+ @param {Object} preload - optional set of attributes and relationships passed in either as IDs or as actual models
+ @return {Promise} promise
+ */
+ findById: function (modelName, id, preload) {
+ var internalModel = this._internalModelForId(modelName, id);
+
+ return this._findByInternalModel(internalModel, preload);
+ },
+
+ _findByInternalModel: function (internalModel, preload) {
+ var fetchedInternalModel;
+
+ if (preload) {
+ internalModel._preloadData(preload);
+ }
+
+ if (internalModel.isEmpty()) {
+ fetchedInternalModel = this.scheduleFetch(internalModel);
+ //TODO double check about reloading
+ } else if (internalModel.isLoading()) {
+ fetchedInternalModel = internalModel._loadingPromise;
+ }
+
+ return ember$data$lib$system$store$$promiseRecord(fetchedInternalModel || internalModel, "DS: Store#findByRecord " + internalModel.typeKey + " with id: " + ember$data$lib$system$store$$get(internalModel, "id"));
+ },
+ /**
+ This method makes a series of requests to the adapter's `find` method
+ and returns a promise that resolves once they are all loaded.
+ @private
+ @method findByIds
+ @param {String} modelName
+ @param {Array} ids
+ @return {Promise} promise
+ */
+ findByIds: function (modelName, ids) {
+ var store = this;
+
+ return ember$data$lib$system$promise$proxies$$promiseArray(Ember.RSVP.all(ember$data$lib$system$store$$map(ids, function (id) {
+ return store.findById(modelName, id);
+ })).then(Ember.A, null, "DS: Store#findByIds of " + modelName + " complete"));
+ },
+
+ /**
+ This method is called by `findById` if it discovers that a particular
+ type/id pair hasn't been loaded yet to kick off a request to the
+ adapter.
+ @method fetchRecord
+ @private
+ @param {InternalModel} internalModel model
+ @return {Promise} promise
+ */
+ fetchRecord: function (internalModel) {
+ var typeClass = internalModel.type;
+ var id = internalModel.id;
+ var adapter = this.adapterFor(typeClass.modelName);
+
+
+ var promise = ember$data$lib$system$store$finders$$_find(adapter, this, typeClass, id, internalModel);
+ return promise;
+ },
+
+ scheduleFetchMany: function (records) {
+ var internalModels = ember$data$lib$system$store$$map(records, function (record) {
+ return record._internalModel;
+ });
+ return ember$data$lib$system$store$$Promise.all(ember$data$lib$system$store$$map(internalModels, this.scheduleFetch, this));
+ },
+
+ scheduleFetch: function (internalModel) {
+ var typeClass = internalModel.type;
+
+ if (internalModel._loadingPromise) {
+ return internalModel._loadingPromise;
+ }
+
+ var resolver = Ember.RSVP.defer("Fetching " + typeClass + "with id: " + internalModel.id);
+ var recordResolverPair = {
+ record: internalModel,
+ resolver: resolver
+ };
+ var promise = resolver.promise;
+
+ internalModel.loadingData(promise);
+
+ if (!this._pendingFetch.get(typeClass)) {
+ this._pendingFetch.set(typeClass, [recordResolverPair]);
+ } else {
+ this._pendingFetch.get(typeClass).push(recordResolverPair);
+ }
+ Ember.run.scheduleOnce("afterRender", this, this.flushAllPendingFetches);
+
+ return promise;
+ },
+
+ flushAllPendingFetches: function () {
+ if (this.isDestroyed || this.isDestroying) {
+ return;
+ }
+
+ this._pendingFetch.forEach(this._flushPendingFetchForType, this);
+ this._pendingFetch = ember$data$lib$system$map$$Map.create();
+ },
+
+ _flushPendingFetchForType: function (recordResolverPairs, typeClass) {
+ var store = this;
+ var adapter = store.adapterFor(typeClass.modelName);
+ var shouldCoalesce = !!adapter.findMany && adapter.coalesceFindRequests;
+ var records = Ember.A(recordResolverPairs).mapBy("record");
+
+ function _fetchRecord(recordResolverPair) {
+ recordResolverPair.resolver.resolve(store.fetchRecord(recordResolverPair.record));
+ }
+
+ function resolveFoundRecords(records) {
+ ember$data$lib$system$store$$forEach(records, function (record) {
+ var pair = Ember.A(recordResolverPairs).findBy("record", record);
+ if (pair) {
+ var resolver = pair.resolver;
+ resolver.resolve(record);
+ }
+ });
+ return records;
+ }
+
+ function makeMissingRecordsRejector(requestedRecords) {
+ return function rejectMissingRecords(resolvedRecords) {
+ resolvedRecords = Ember.A(resolvedRecords);
+ var missingRecords = requestedRecords.reject(function (record) {
+ return resolvedRecords.contains(record);
+ });
+ if (missingRecords.length) {
+ }
+ rejectRecords(missingRecords);
+ };
+ }
+
+ function makeRecordsRejector(records) {
+ return function (error) {
+ rejectRecords(records, error);
+ };
+ }
+
+ function rejectRecords(records, error) {
+ ember$data$lib$system$store$$forEach(records, function (record) {
+ var pair = Ember.A(recordResolverPairs).findBy("record", record);
+ if (pair) {
+ var resolver = pair.resolver;
+ resolver.reject(error);
+ }
+ });
+ }
+
+ if (recordResolverPairs.length === 1) {
+ _fetchRecord(recordResolverPairs[0]);
+ } else if (shouldCoalesce) {
+
+ // TODO: Improve records => snapshots => records => snapshots
+ //
+ // We want to provide records to all store methods and snapshots to all
+ // adapter methods. To make sure we're doing that we're providing an array
+ // of snapshots to adapter.groupRecordsForFindMany(), which in turn will
+ // return grouped snapshots instead of grouped records.
+ //
+ // But since the _findMany() finder is a store method we need to get the
+ // records from the grouped snapshots even though the _findMany() finder
+ // will once again convert the records to snapshots for adapter.findMany()
+
+ var snapshots = Ember.A(records).invoke("createSnapshot");
+ var groups = adapter.groupRecordsForFindMany(this, snapshots);
+ ember$data$lib$system$store$$forEach(groups, function (groupOfSnapshots) {
+ var groupOfRecords = Ember.A(groupOfSnapshots).mapBy("_internalModel");
+ var requestedRecords = Ember.A(groupOfRecords);
+ var ids = requestedRecords.mapBy("id");
+ if (ids.length > 1) {
+ ember$data$lib$system$store$finders$$_findMany(adapter, store, typeClass, ids, requestedRecords).then(resolveFoundRecords).then(makeMissingRecordsRejector(requestedRecords)).then(null, makeRecordsRejector(requestedRecords));
+ } else if (ids.length === 1) {
+ var pair = Ember.A(recordResolverPairs).findBy("record", groupOfRecords[0]);
+ _fetchRecord(pair);
+ } else {
+ }
+ });
+ } else {
+ ember$data$lib$system$store$$forEach(recordResolverPairs, _fetchRecord);
+ }
+ },
+
+ /**
+ Get a record by a given type and ID without triggering a fetch.
+ This method will synchronously return the record if it is available in the store,
+ otherwise it will return `null`. A record is available if it has been fetched earlier, or
+ pushed manually into the store.
+ _Note: This is an synchronous method and does not return a promise._
+ ```js
+ var post = store.getById('post', 1);
+ post.get('id'); // 1
+ ```
+ @method getById
+ @param {String} modelName
+ @param {String|Integer} id
+ @return {DS.Model|null} record
+ */
+ getById: function (modelName, id) {
+ if (this.hasRecordForId(modelName, id)) {
+ return this._internalModelForId(modelName, id).getRecord();
+ } else {
+ return null;
+ }
+ },
+
+ /**
+ This method is called by the record's `reload` method.
+ This method calls the adapter's `find` method, which returns a promise. When
+ **that** promise resolves, `reloadRecord` will resolve the promise returned
+ by the record's `reload`.
+ @method reloadRecord
+ @private
+ @param {DS.Model} internalModel
+ @return {Promise} promise
+ */
+ reloadRecord: function (internalModel) {
+ var modelName = internalModel.type.modelName;
+ var adapter = this.adapterFor(modelName);
+ var id = internalModel.id;
+
+
+ return this.scheduleFetch(internalModel);
+ },
+
+ /**
+ Returns true if a record for a given type and ID is already loaded.
+ @method hasRecordForId
+ @param {(String|DS.Model)} modelName
+ @param {(String|Integer)} inputId
+ @return {Boolean}
+ */
+ hasRecordForId: function (modelName, inputId) {
+ var typeClass = this.modelFor(modelName);
+ var id = ember$data$lib$system$coerce$id$$default(inputId);
+ var internalModel = this.typeMapFor(typeClass).idToRecord[id];
+ return !!internalModel && internalModel.isLoaded();
+ },
+
+ /**
+ Returns id record for a given type and ID. If one isn't already loaded,
+ it builds a new record and leaves it in the `empty` state.
+ @method recordForId
+ @private
+ @param {String} modelName
+ @param {(String|Integer)} id
+ @return {DS.Model} record
+ */
+ recordForId: function (modelName, id) {
+ return this._internalModelForId(modelName, id).getRecord();
+ },
+
+ _internalModelForId: function (typeName, inputId) {
+ var typeClass = this.modelFor(typeName);
+ var id = ember$data$lib$system$coerce$id$$default(inputId);
+ var idToRecord = this.typeMapFor(typeClass).idToRecord;
+ var record = idToRecord[id];
+
+ if (!record || !idToRecord[id]) {
+ record = this.buildInternalModel(typeClass, id);
+ }
+
+ return record;
+ },
+
+ /**
+ @method findMany
+ @private
+ @param {Array} internalModels
+ @return {Promise} promise
+ */
+ findMany: function (internalModels) {
+ var store = this;
+ return ember$data$lib$system$store$$Promise.all(ember$data$lib$system$store$$map(internalModels, function (internalModel) {
+ return store._findByInternalModel(internalModel);
+ }));
+ },
+
+ /**
+ If a relationship was originally populated by the adapter as a link
+ (as opposed to a list of IDs), this method is called when the
+ relationship is fetched.
+ The link (which is usually a URL) is passed through unchanged, so the
+ adapter can make whatever request it wants.
+ The usual use-case is for the server to register a URL as a link, and
+ then use that URL in the future to make a request for the relationship.
+ @method findHasMany
+ @private
+ @param {DS.Model} owner
+ @param {any} link
+ @param {(Relationship)} relationship
+ @return {Promise} promise
+ */
+ findHasMany: function (owner, link, relationship) {
+ var adapter = this.adapterFor(owner.type.modelName);
+
+
+ return ember$data$lib$system$store$finders$$_findHasMany(adapter, this, owner, link, relationship);
+ },
+
+ /**
+ @method findBelongsTo
+ @private
+ @param {DS.Model} owner
+ @param {any} link
+ @param {Relationship} relationship
+ @return {Promise} promise
+ */
+ findBelongsTo: function (owner, link, relationship) {
+ var adapter = this.adapterFor(owner.type.modelName);
+
+
+ return ember$data$lib$system$store$finders$$_findBelongsTo(adapter, this, owner, link, relationship);
+ },
+
+ /**
+ This method delegates a query to the adapter. This is the one place where
+ adapter-level semantics are exposed to the application.
+ Exposing queries this way seems preferable to creating an abstract query
+ language for all server-side queries, and then require all adapters to
+ implement them.
+ This method returns a promise, which is resolved with a `RecordArray`
+ once the server returns.
+ @method findQuery
+ @private
+ @param {String} modelName
+ @param {any} query an opaque query to be used by the adapter
+ @return {Promise} promise
+ */
+ findQuery: function (modelName, query) {
+ var typeClass = this.modelFor(modelName);
+ var array = this.recordArrayManager.createAdapterPopulatedRecordArray(typeClass, query);
+
+ var adapter = this.adapterFor(modelName);
+
+
+ return ember$data$lib$system$promise$proxies$$promiseArray(ember$data$lib$system$store$finders$$_findQuery(adapter, this, typeClass, query, array));
+ },
+
+ /**
+ This method returns an array of all records adapter can find.
+ It triggers the adapter's `findAll` method to give it an opportunity to populate
+ the array with records of that type.
+ @method findAll
+ @private
+ @param {String} modelName
+ @return {DS.AdapterPopulatedRecordArray}
+ */
+ findAll: function (modelName) {
+ return this.fetchAll(modelName);
+ },
+
+ /**
+ @method _fetchAll
+ @private
+ @param {DS.Model} typeClass
+ @param {DS.RecordArray} array
+ @return {Promise} promise
+ */
+ _fetchAll: function (typeClass, array) {
+ var adapter = this.adapterFor(typeClass.modelName);
+ var sinceToken = this.typeMapFor(typeClass).metadata.since;
+
+ ember$data$lib$system$store$$set(array, "isUpdating", true);
+
+
+ return ember$data$lib$system$promise$proxies$$promiseArray(ember$data$lib$system$store$finders$$_findAll(adapter, this, typeClass, sinceToken));
+ },
+
+ /**
+ @method didUpdateAll
+ @param {DS.Model} typeClass
+ @private
+ */
+ didUpdateAll: function (typeClass) {
+ var findAllCache = this.typeMapFor(typeClass).findAllCache;
+ ember$data$lib$system$store$$set(findAllCache, "isUpdating", false);
+ },
+
+ /**
+ This method returns a filtered array that contains all of the
+ known records for a given type in the store.
+ Note that because it's just a filter, the result will contain any
+ locally created records of the type, however, it will not make a
+ request to the backend to retrieve additional records. If you
+ would like to request all the records from the backend please use
+ [store.find](#method_find).
+ Also note that multiple calls to `all` for a given type will always
+ return the same `RecordArray`.
+ Example
+ ```javascript
+ var localPosts = store.all('post');
+ ```
+ @method all
+ @param {String} modelName
+ @return {DS.RecordArray}
+ */
+ all: function (modelName) {
+ var typeClass = this.modelFor(modelName);
+ var typeMap = this.typeMapFor(typeClass);
+ var findAllCache = typeMap.findAllCache;
+
+ if (findAllCache) {
+ this.recordArrayManager.updateFilter(findAllCache, typeClass);
+ return findAllCache;
+ }
+
+ var array = this.recordArrayManager.createRecordArray(typeClass);
+
+ typeMap.findAllCache = array;
+ return array;
+ },
+
+ /**
+ This method unloads all records in the store.
+ Optionally you can pass a type which unload all records for a given type.
+ ```javascript
+ store.unloadAll();
+ store.unloadAll('post');
+ ```
+ @method unloadAll
+ @param {String=} modelName
+ */
+ unloadAll: function (modelName) {
+ if (arguments.length === 0) {
+ var typeMaps = this.typeMaps;
+ var keys = Ember.keys(typeMaps);
+
+ var types = ember$data$lib$system$store$$map(keys, byType);
+
+ ember$data$lib$system$store$$forEach(types, this.unloadAll, this);
+ } else {
+ var typeClass = this.modelFor(modelName);
+ var typeMap = this.typeMapFor(typeClass);
+ var records = typeMap.records.slice();
+ var record;
+
+ for (var i = 0; i < records.length; i++) {
+ record = records[i];
+ record.unloadRecord();
+ record.destroy(); // maybe within unloadRecord
+ }
+
+ typeMap.findAllCache = null;
+ typeMap.metadata = Ember.create(null);
+ }
+
+ function byType(entry) {
+ return typeMaps[entry]["type"].modelName;
+ }
+ },
+
+ /**
+ Takes a type and filter function, and returns a live RecordArray that
+ remains up to date as new records are loaded into the store or created
+ locally.
+ The filter function takes a materialized record, and returns true
+ if the record should be included in the filter and false if it should
+ not.
+ Example
+ ```javascript
+ store.filter('post', function(post) {
+ return post.get('unread');
+ });
+ ```
+ The filter function is called once on all records for the type when
+ it is created, and then once on each newly loaded or created record.
+ If any of a record's properties change, or if it changes state, the
+ filter function will be invoked again to determine whether it should
+ still be in the array.
+ Optionally you can pass a query, which is the equivalent of calling
+ [find](#method_find) with that same query, to fetch additional records
+ from the server. The results returned by the server could then appear
+ in the filter if they match the filter function.
+ The query itself is not used to filter records, it's only sent to your
+ server for you to be able to do server-side filtering. The filter
+ function will be applied on the returned results regardless.
+ Example
+ ```javascript
+ store.filter('post', { unread: true }, function(post) {
+ return post.get('unread');
+ }).then(function(unreadPosts) {
+ unreadPosts.get('length'); // 5
+ var unreadPost = unreadPosts.objectAt(0);
+ unreadPost.set('unread', false);
+ unreadPosts.get('length'); // 4
+ });
+ ```
+ @method filter
+ @param {String} modelName
+ @param {Object} query optional query
+ @param {Function} filter
+ @return {DS.PromiseArray}
+ */
+ filter: function (modelName, query, filter) {
+ var promise;
+ var length = arguments.length;
+ var array;
+ var hasQuery = length === 3;
+
+ // allow an optional server query
+ if (hasQuery) {
+ promise = this.findQuery(modelName, query);
+ } else if (arguments.length === 2) {
+ filter = query;
+ }
+
+ modelName = this.modelFor(modelName);
+
+ if (hasQuery) {
+ array = this.recordArrayManager.createFilteredRecordArray(modelName, filter, query);
+ } else {
+ array = this.recordArrayManager.createFilteredRecordArray(modelName, filter);
+ }
+
+ promise = promise || ember$data$lib$system$store$$Promise.cast(array);
+
+ return ember$data$lib$system$promise$proxies$$promiseArray(promise.then(function () {
+ return array;
+ }, null, "DS: Store#filter of " + modelName));
+ },
+
+ /**
+ This method returns if a certain record is already loaded
+ in the store. Use this function to know beforehand if a find()
+ will result in a request or that it will be a cache hit.
+ Example
+ ```javascript
+ store.recordIsLoaded('post', 1); // false
+ store.find('post', 1).then(function() {
+ store.recordIsLoaded('post', 1); // true
+ });
+ ```
+ @method recordIsLoaded
+ @param {String} modelName
+ @param {string} id
+ @return {boolean}
+ */
+ recordIsLoaded: function (modelName, id) {
+ return this.hasRecordForId(modelName, id);
+ },
+
+ /**
+ This method returns the metadata for a specific type.
+ @method metadataFor
+ @param {String} modelName
+ @return {object}
+ */
+ metadataFor: function (modelName) {
+ var typeClass = this.modelFor(modelName);
+ return this.typeMapFor(typeClass).metadata;
+ },
+
+ /**
+ This method sets the metadata for a specific type.
+ @method setMetadataFor
+ @param {String} modelName
+ @param {Object} metadata metadata to set
+ @return {object}
+ */
+ setMetadataFor: function (modelName, metadata) {
+ var typeClass = this.modelFor(modelName);
+ Ember.merge(this.typeMapFor(typeClass).metadata, metadata);
+ },
+
+ // ............
+ // . UPDATING .
+ // ............
+
+ /**
+ If the adapter updates attributes the record will notify
+ the store to update its membership in any filters.
+ To avoid thrashing, this method is invoked only once per
+ run loop per record.
+ @method dataWasUpdated
+ @private
+ @param {Class} type
+ @param {InternalModel} internalModel
+ */
+ dataWasUpdated: function (type, internalModel) {
+ this.recordArrayManager.recordDidChange(internalModel);
+ },
+
+ // ..............
+ // . PERSISTING .
+ // ..............
+
+ /**
+ This method is called by `record.save`, and gets passed a
+ resolver for the promise that `record.save` returns.
+ It schedules saving to happen at the end of the run loop.
+ @method scheduleSave
+ @private
+ @param {InternalModel} internalModel
+ @param {Resolver} resolver
+ */
+ scheduleSave: function (internalModel, resolver) {
+ var snapshot = internalModel.createSnapshot();
+ internalModel.flushChangedAttributes();
+ internalModel.adapterWillCommit();
+ this._pendingSave.push([snapshot, resolver]);
+ ember$data$lib$system$store$$once(this, "flushPendingSave");
+ },
+
+ /**
+ This method is called at the end of the run loop, and
+ flushes any records passed into `scheduleSave`
+ @method flushPendingSave
+ @private
+ */
+ flushPendingSave: function () {
+ var pending = this._pendingSave.slice();
+ this._pendingSave = [];
+
+ ember$data$lib$system$store$$forEach(pending, function (tuple) {
+ var snapshot = tuple[0];
+ var resolver = tuple[1];
+ var record = snapshot._internalModel;
+ var adapter = this.adapterFor(record.type.modelName);
+ var operation;
+
+ if (ember$data$lib$system$store$$get(record, "currentState.stateName") === "root.deleted.saved") {
+ return resolver.resolve();
+ } else if (record.isNew()) {
+ operation = "createRecord";
+ } else if (record.isDeleted()) {
+ operation = "deleteRecord";
+ } else {
+ operation = "updateRecord";
+ }
+
+ resolver.resolve(ember$data$lib$system$store$$_commit(adapter, this, operation, snapshot));
+ }, this);
+ },
+
+ /**
+ This method is called once the promise returned by an
+ adapter's `createRecord`, `updateRecord` or `deleteRecord`
+ is resolved.
+ If the data provides a server-generated ID, it will
+ update the record and the store's indexes.
+ @method didSaveRecord
+ @private
+ @param {InternalModel} internalModel the in-flight internal model
+ @param {Object} data optional data (see above)
+ */
+ didSaveRecord: function (internalModel, data) {
+ if (data) {
+ // normalize relationship IDs into records
+ this._backburner.schedule("normalizeRelationships", this, "_setupRelationships", internalModel, internalModel.type, data);
+ this.updateId(internalModel, data);
+ }
+
+ //We first make sure the primary data has been updated
+ //TODO try to move notification to the user to the end of the runloop
+ internalModel.adapterDidCommit(data);
+ },
+
+ /**
+ This method is called once the promise returned by an
+ adapter's `createRecord`, `updateRecord` or `deleteRecord`
+ is rejected with a `DS.InvalidError`.
+ @method recordWasInvalid
+ @private
+ @param {InternalModel} internalModel
+ @param {Object} errors
+ */
+ recordWasInvalid: function (internalModel, errors) {
+ internalModel.adapterDidInvalidate(errors);
+ },
+
+ /**
+ This method is called once the promise returned by an
+ adapter's `createRecord`, `updateRecord` or `deleteRecord`
+ is rejected (with anything other than a `DS.InvalidError`).
+ @method recordWasError
+ @private
+ @param {InternalModel} internalModel
+ */
+ recordWasError: function (internalModel) {
+ internalModel.adapterDidError();
+ },
+
+ /**
+ When an adapter's `createRecord`, `updateRecord` or `deleteRecord`
+ resolves with data, this method extracts the ID from the supplied
+ data.
+ @method updateId
+ @private
+ @param {InternalModel} internalModel
+ @param {Object} data
+ */
+ updateId: function (internalModel, data) {
+ var oldId = internalModel.id;
+ var id = ember$data$lib$system$coerce$id$$default(data.id);
+
+
+ this.typeMapFor(internalModel.type).idToRecord[id] = internalModel;
+
+ internalModel.setId(id);
+ },
+
+ /**
+ Returns a map of IDs to client IDs for a given type.
+ @method typeMapFor
+ @private
+ @param {DS.Model} typeClass
+ @return {Object} typeMap
+ */
+ typeMapFor: function (typeClass) {
+ var typeMaps = ember$data$lib$system$store$$get(this, "typeMaps");
+ var guid = Ember.guidFor(typeClass);
+ var typeMap = typeMaps[guid];
+
+ if (typeMap) {
+ return typeMap;
+ }
+
+ typeMap = {
+ idToRecord: Ember.create(null),
+ records: [],
+ metadata: Ember.create(null),
+ type: typeClass
+ };
+
+ typeMaps[guid] = typeMap;
+
+ return typeMap;
+ },
+
+ // ................
+ // . LOADING DATA .
+ // ................
+
+ /**
+ This internal method is used by `push`.
+ @method _load
+ @private
+ @param {(String|DS.Model)} type
+ @param {Object} data
+ */
+ _load: function (type, data) {
+ var id = ember$data$lib$system$coerce$id$$default(data.id);
+ var internalModel = this._internalModelForId(type, id);
+
+ internalModel.setupData(data);
+
+ this.recordArrayManager.recordDidChange(internalModel);
+
+ return internalModel;
+ },
+
+ /*
+ In case someone defined a relationship to a mixin, for example:
+ ```
+ var Comment = DS.Model.extend({
+ owner: belongsTo('commentable'. { polymorphic: true})
+ });
+ var Commentable = Ember.Mixin.create({
+ comments: hasMany('comment')
+ });
+ ```
+ we want to look up a Commentable class which has all the necessary
+ relationship metadata. Thus, we look up the mixin and create a mock
+ DS.Model, so we can access the relationship CPs of the mixin (`comments`)
+ in this case
+ */
+
+ _modelForMixin: function (modelName) {
+ var normalizedModelName = ember$data$lib$system$normalize$model$name$$default(modelName);
+ var registry = this.container._registry ? this.container._registry : this.container;
+ var mixin = registry.resolve("mixin:" + normalizedModelName);
+ if (mixin) {
+ //Cache the class as a model
+ registry.register("model:" + normalizedModelName, DS.Model.extend(mixin));
+ }
+ var factory = this.modelFactoryFor(normalizedModelName);
+ if (factory) {
+ factory.__isMixin = true;
+ factory.__mixin = mixin;
+ }
+
+ return factory;
+ },
+
+ /**
+ Returns a model class for a particular key. Used by
+ methods that take a type key (like `find`, `createRecord`,
+ etc.)
+ @method modelFor
+ @param {String} modelName
+ @return {DS.Model}
+ */
+ modelFor: function (modelName) {
+
+ var factory = this.modelFactoryFor(modelName);
+ if (!factory) {
+ //Support looking up mixins as base types for polymorphic relationships
+ factory = this._modelForMixin(modelName);
+ }
+ if (!factory) {
+ throw new Ember.Error("No model was found for '" + modelName + "'");
+ }
+ factory.modelName = factory.modelName || ember$data$lib$system$normalize$model$name$$default(modelName);
+
+ // deprecate typeKey
+ if (!("typeKey" in factory)) {
+ Ember.defineProperty(factory, "typeKey", {
+ enumerable: true,
+ configurable: false,
+ get: function () {
+ var typeKey = this.modelName;
+ if (typeKey) {
+ typeKey = Ember.String.camelize(this.modelName);
+ }
+ return typeKey;
+ },
+ set: function () {
+ }
+ });
+ }
+
+ return factory;
+ },
+
+ modelFactoryFor: function (modelName) {
+ var normalizedKey = ember$data$lib$system$normalize$model$name$$default(modelName);
+ return this.container.lookupFactory("model:" + normalizedKey);
+ },
+
+ /**
+ Push some data for a given type into the store.
+ This method expects normalized data:
+ * The ID is a key named `id` (an ID is mandatory)
+ * The names of attributes are the ones you used in
+ your model's `DS.attr`s.
+ * Your relationships must be:
+ * represented as IDs or Arrays of IDs
+ * represented as model instances
+ * represented as URLs, under the `links` key
+ For this model:
+ ```app/models/person.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ firstName: DS.attr(),
+ lastName: DS.attr(),
+ children: DS.hasMany('person')
+ });
+ ```
+ To represent the children as IDs:
+ ```js
+ {
+ id: 1,
+ firstName: "Tom",
+ lastName: "Dale",
+ children: [1, 2, 3]
+ }
+ ```
+ To represent the children relationship as a URL:
+ ```js
+ {
+ id: 1,
+ firstName: "Tom",
+ lastName: "Dale",
+ links: {
+ children: "/people/1/children"
+ }
+ }
+ ```
+ If you're streaming data or implementing an adapter, make sure
+ that you have converted the incoming data into this form. The
+ store's [normalize](#method_normalize) method is a convenience
+ helper for converting a json payload into the form Ember Data
+ expects.
+ ```js
+ store.push('person', store.normalize('person', data));
+ ```
+ This method can be used both to push in brand new
+ records, as well as to update existing records.
+ @method push
+ @param {String} modelName
+ @param {Object} data
+ @return {DS.Model} the record that was created or
+ updated.
+ */
+ push: function (modelName, data) {
+ var internalModel = this._pushInternalModel(modelName, data);
+ return internalModel.getRecord();
+ },
+
+ _pushInternalModel: function (modelName, data) {
+
+ var type = this.modelFor(modelName);
+ var filter = Ember.EnumerableUtils.filter;
+
+ // If Ember.ENV.DS_WARN_ON_UNKNOWN_KEYS is set to true and the payload
+ // contains unknown keys, log a warning.
+ if (Ember.ENV.DS_WARN_ON_UNKNOWN_KEYS) {
+ }
+
+ // Actually load the record into the store.
+ var internalModel = this._load(modelName, data);
+
+ var store = this;
+
+ this._backburner.join(function () {
+ store._backburner.schedule("normalizeRelationships", store, "_setupRelationships", internalModel, type, data);
+ });
+
+ return internalModel;
+ },
+
+ _setupRelationships: function (record, type, data) {
+ // If the payload contains relationships that are specified as
+ // IDs, normalizeRelationships will convert them into DS.Model instances
+ // (possibly unloaded) before we push the payload into the
+ // store.
+
+ data = ember$data$lib$system$store$$normalizeRelationships(this, type, data);
+
+ // Now that the pushed record as well as any related records
+ // are in the store, create the data structures used to track
+ // relationships.
+ ember$data$lib$system$store$$setupRelationships(this, record, data);
+ },
+
+ /**
+ Push some raw data into the store.
+ This method can be used both to push in brand new
+ records, as well as to update existing records. You
+ can push in more than one type of object at once.
+ All objects should be in the format expected by the
+ serializer.
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+ export default DS.ActiveModelSerializer;
+ ```
+ ```js
+ var pushData = {
+ posts: [
+ {id: 1, post_title: "Great post", comment_ids: [2]}
+ ],
+ comments: [
+ {id: 2, comment_body: "Insightful comment"}
+ ]
+ }
+ store.pushPayload(pushData);
+ ```
+ By default, the data will be deserialized using a default
+ serializer (the application serializer if it exists).
+ Alternatively, `pushPayload` will accept a model type which
+ will determine which serializer will process the payload.
+ However, the serializer itself (processing this data via
+ `normalizePayload`) will not know which model it is
+ deserializing.
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+ export default DS.ActiveModelSerializer;
+ ```
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer;
+ ```
+ ```js
+ store.pushPayload('comment', pushData); // Will use the application serializer
+ store.pushPayload('post', pushData); // Will use the post serializer
+ ```
+ @method pushPayload
+ @param {String} modelName Optionally, a model type used to determine which serializer will be used
+ @param {Object} inputPayload
+ */
+ pushPayload: function (modelName, inputPayload) {
+ var serializer;
+ var payload;
+ if (!inputPayload) {
+ payload = modelName;
+ serializer = ember$data$lib$system$store$$defaultSerializer(this.container);
+ } else {
+ payload = inputPayload;
+ serializer = this.serializerFor(modelName);
+ }
+ var store = this;
+ this._adapterRun(function () {
+ serializer.pushPayload(store, payload);
+ });
+ },
+
+ /**
+ `normalize` converts a json payload into the normalized form that
+ [push](#method_push) expects.
+ Example
+ ```js
+ socket.on('message', function(message) {
+ var modelName = message.model;
+ var data = message.data;
+ store.push(modelName, store.normalize(modelName, data));
+ });
+ ```
+ @method normalize
+ @param {String} modelName The name of the model type for this payload
+ @param {Object} payload
+ @return {Object} The normalized payload
+ */
+ normalize: function (modelName, payload) {
+ var serializer = this.serializerFor(modelName);
+ var model = this.modelFor(modelName);
+ return serializer.normalize(model, payload);
+ },
+
+ /**
+ @method update
+ @param {String} modelName
+ @param {Object} data
+ @return {DS.Model} the record that was updated.
+ @deprecated Use [push](#method_push) instead
+ */
+ update: function (modelName, data) {
+ return this.push(modelName, data);
+ },
+
+ /**
+ If you have an Array of normalized data to push,
+ you can call `pushMany` with the Array, and it will
+ call `push` repeatedly for you.
+ @method pushMany
+ @param {String} modelName
+ @param {Array} datas
+ @return {Array}
+ */
+ pushMany: function (modelName, datas) {
+ var length = datas.length;
+ var result = new Array(length);
+
+ for (var i = 0; i < length; i++) {
+ result[i] = this.push(modelName, datas[i]);
+ }
+
+ return result;
+ },
+
+ /**
+ @method metaForType
+ @param {String} modelName
+ @param {Object} metadata
+ @deprecated Use [setMetadataFor](#method_setMetadataFor) instead
+ */
+ metaForType: function (modelName, metadata) {
+ this.setMetadataFor(modelName, metadata);
+ },
+
+ /**
+ Build a brand new record for a given type, ID, and
+ initial data.
+ @method buildRecord
+ @private
+ @param {DS.Model} type
+ @param {String} id
+ @param {Object} data
+ @return {InternalModel} internal model
+ */
+ buildInternalModel: function (type, id, data) {
+ var typeMap = this.typeMapFor(type);
+ var idToRecord = typeMap.idToRecord;
+
+
+ // lookupFactory should really return an object that creates
+ // instances with the injections applied
+ var internalModel = new ember$data$lib$system$model$internal$model$$default(type, id, this, this.container, data);
+
+ // if we're creating an item, this process will be done
+ // later, once the object has been persisted.
+ if (id) {
+ idToRecord[id] = internalModel;
+ }
+
+ typeMap.records.push(internalModel);
+
+ return internalModel;
+ },
+
+ //Called by the state machine to notify the store that the record is ready to be interacted with
+ recordWasLoaded: function (record) {
+ this.recordArrayManager.recordWasLoaded(record);
+ },
+
+ // ...............
+ // . DESTRUCTION .
+ // ...............
+
+ /**
+ @method dematerializeRecord
+ @private
+ @param {DS.Model} record
+ @deprecated Use [unloadRecord](#method_unloadRecord) instead
+ */
+ dematerializeRecord: function (record) {
+ this._dematerializeRecord(record);
+ },
+
+ /**
+ When a record is destroyed, this un-indexes it and
+ removes it from any record arrays so it can be GCed.
+ @method _dematerializeRecord
+ @private
+ @param {InternalModel} internalModel
+ */
+ _dematerializeRecord: function (internalModel) {
+ var type = internalModel.type;
+ var typeMap = this.typeMapFor(type);
+ var id = internalModel.id;
+
+ internalModel.updateRecordArrays();
+
+ if (id) {
+ delete typeMap.idToRecord[id];
+ }
+
+ var loc = ember$data$lib$system$store$$indexOf(typeMap.records, internalModel);
+ typeMap.records.splice(loc, 1);
+ },
+
+ // ......................
+ // . PER-TYPE ADAPTERS
+ // ......................
+
+ /**
+ Returns an instance of the adapter for a given type. For
+ example, `adapterFor('person')` will return an instance of
+ `App.PersonAdapter`.
+ If no `App.PersonAdapter` is found, this method will look
+ for an `App.ApplicationAdapter` (the default adapter for
+ your entire application).
+ If no `App.ApplicationAdapter` is found, it will return
+ the value of the `defaultAdapter`.
+ @method adapterFor
+ @private
+ @param {String} modelName
+ @return DS.Adapter
+ */
+ adapterFor: function (modelOrClass) {
+ var modelName;
+
+
+ if (typeof modelOrClass !== "string") {
+ modelName = modelOrClass.modelName;
+ } else {
+ modelName = modelOrClass;
+ }
+
+ return this.lookupAdapter(modelName);
+ },
+
+ _adapterRun: function (fn) {
+ return this._backburner.run(fn);
+ },
+
+ // ..............................
+ // . RECORD CHANGE NOTIFICATION .
+ // ..............................
+
+ /**
+ Returns an instance of the serializer for a given type. For
+ example, `serializerFor('person')` will return an instance of
+ `App.PersonSerializer`.
+ If no `App.PersonSerializer` is found, this method will look
+ for an `App.ApplicationSerializer` (the default serializer for
+ your entire application).
+ if no `App.ApplicationSerializer` is found, it will attempt
+ to get the `defaultSerializer` from the `PersonAdapter`
+ (`adapterFor('person')`).
+ If a serializer cannot be found on the adapter, it will fall back
+ to an instance of `DS.JSONSerializer`.
+ @method serializerFor
+ @private
+ @param {String} modelName the record to serialize
+ @return {DS.Serializer}
+ */
+ serializerFor: function (modelOrClass) {
+ var modelName;
+
+ if (typeof modelOrClass !== "string") {
+ modelName = modelOrClass.modelName;
+ } else {
+ modelName = modelOrClass;
+ }
+
+ var fallbacks = ["application", this.adapterFor(modelName).get("defaultSerializer"), "-default"];
+
+ var serializer = this.lookupSerializer(modelName, fallbacks);
+ return serializer;
+ },
+
+ /**
+ Retrieve a particular instance from the
+ container cache. If not found, creates it and
+ placing it in the cache.
+ Enabled a store to manage local instances of
+ adapters and serializers.
+ @method retrieveManagedInstance
+ @private
+ @param {String} modelName the object modelName
+ @param {String} name the object name
+ @param {Array} fallbacks the fallback objects to lookup if the lookup for modelName or 'application' fails
+ @return {Ember.Object}
+ */
+ retrieveManagedInstance: function (type, modelName, fallbacks) {
+ var normalizedModelName = ember$data$lib$system$normalize$model$name$$default(modelName);
+
+ var instance = this._instanceCache.get(type, normalizedModelName, fallbacks);
+ ember$data$lib$system$store$$set(instance, "store", this);
+ return instance;
+ },
+
+ lookupAdapter: function (name) {
+ return this.retrieveManagedInstance("adapter", name, this.get("_adapterFallbacks"));
+ },
+
+ _adapterFallbacks: Ember.computed("adapter", function () {
+ var adapter = this.get("adapter");
+ return ["application", adapter, "-rest"];
+ }),
+
+ lookupSerializer: function (name, fallbacks) {
+ return this.retrieveManagedInstance("serializer", name, fallbacks);
+ },
+
+ willDestroy: function () {
+ this.recordArrayManager.destroy();
+
+ this.unloadAll();
+
+ for (var cacheKey in this._containerCache) {
+ this._containerCache[cacheKey].destroy();
+ delete this._containerCache[cacheKey];
+ }
+
+ delete this._containerCache;
+ }
+
+ });
+
+ function ember$data$lib$system$store$$normalizeRelationships(store, type, data, record) {
+ type.eachRelationship(function (key, relationship) {
+ var kind = relationship.kind;
+ var value = data[key];
+ if (kind === "belongsTo") {
+ ember$data$lib$system$store$$deserializeRecordId(store, data, key, relationship, value);
+ } else if (kind === "hasMany") {
+ ember$data$lib$system$store$$deserializeRecordIds(store, data, key, relationship, value);
+ }
+ });
+
+ return data;
+ }
+
+ function ember$data$lib$system$store$$deserializeRecordId(store, data, key, relationship, id) {
+ if (ember$data$lib$system$store$$isNone(id)) {
+ return;
+ }
+
+ //If record objects were given to push directly, uncommon, not sure whether we should actually support
+ if (id instanceof ember$data$lib$system$model$$default) {
+ data[key] = id._internalModel;
+ return;
+ }
+
+
+ var type;
+
+ if (typeof id === "number" || typeof id === "string") {
+ type = ember$data$lib$system$store$$typeFor(relationship, key, data);
+ data[key] = store._internalModelForId(type, id);
+ } else if (typeof id === "object") {
+ // hasMany polymorphic
+ data[key] = store._internalModelForId(id.type, id.id);
+ }
+ }
+
+ function ember$data$lib$system$store$$typeFor(relationship, key, data) {
+ if (relationship.options.polymorphic) {
+ return data[key + "Type"];
+ } else {
+ return relationship.type;
+ }
+ }
+
+ function ember$data$lib$system$store$$deserializeRecordIds(store, data, key, relationship, ids) {
+ if (ember$data$lib$system$store$$isNone(ids)) {
+ return;
+ }
+
+ for (var i = 0, l = ids.length; i < l; i++) {
+ ember$data$lib$system$store$$deserializeRecordId(store, ids, i, relationship, ids[i]);
+ }
+ }
+
+ // Delegation to the adapter and promise management
+
+ function ember$data$lib$system$store$$defaultSerializer(container) {
+ return container.lookup("serializer:application") || container.lookup("serializer:-default");
+ }
+
+ function ember$data$lib$system$store$$_commit(adapter, store, operation, snapshot) {
+ var record = snapshot._internalModel;
+ var modelName = snapshot.modelName;
+ var type = store.modelFor(modelName);
+ var promise = adapter[operation](store, type, snapshot);
+ var serializer = ember$data$lib$system$store$serializers$$serializerForAdapter(store, adapter, modelName);
+ var label = "DS: Extract and notify about " + operation + " completion of " + record;
+
+
+ promise = ember$data$lib$system$store$$Promise.cast(promise, label);
+ promise = ember$data$lib$system$store$common$$_guard(promise, ember$data$lib$system$store$common$$_bind(ember$data$lib$system$store$common$$_objectIsAlive, store));
+ promise = ember$data$lib$system$store$common$$_guard(promise, ember$data$lib$system$store$common$$_bind(ember$data$lib$system$store$common$$_objectIsAlive, record));
+
+ return promise.then(function (adapterPayload) {
+ var payload;
+
+ store._adapterRun(function () {
+ if (adapterPayload) {
+ payload = serializer.extract(store, type, adapterPayload, snapshot.id, operation);
+ }
+ store.didSaveRecord(record, payload);
+ });
+
+ return record;
+ }, function (reason) {
+ if (reason instanceof ember$data$lib$system$model$errors$invalid$$default) {
+ var errors = serializer.extractErrors(store, type, reason.errors, snapshot.id);
+ store.recordWasInvalid(record, errors);
+ reason = new ember$data$lib$system$model$errors$invalid$$default(errors);
+ } else {
+ store.recordWasError(record, reason);
+ }
+
+ throw reason;
+ }, label);
+ }
+
+ function ember$data$lib$system$store$$setupRelationships(store, record, data) {
+ var typeClass = record.type;
+
+ typeClass.eachRelationship(function (key, descriptor) {
+ var kind = descriptor.kind;
+ var value = data[key];
+ var relationship;
+
+ if (data.links && data.links[key]) {
+ relationship = record._relationships.get(key);
+ relationship.updateLink(data.links[key]);
+ }
+
+ if (value !== undefined) {
+ if (kind === "belongsTo") {
+ relationship = record._relationships.get(key);
+ relationship.setCanonicalRecord(value);
+ } else if (kind === "hasMany") {
+ relationship = record._relationships.get(key);
+ relationship.updateRecordsFromAdapter(value);
+ }
+ }
+ });
+ }
+
+ var ember$data$lib$system$store$$default = ember$data$lib$system$store$$Store;
+ var ember$data$lib$instance$initializers$initialize$store$service$$default = ember$data$lib$instance$initializers$initialize$store$service$$initializeStoreService;
+ /**
+ Configures a registry for use with an Ember-Data
+ store.
+
+ @method initializeStore
+ @param {Ember.ApplicationInstance} applicationOrRegistry
+ */
+ function ember$data$lib$instance$initializers$initialize$store$service$$initializeStoreService(applicationOrRegistry) {
+ var registry, container;
+ if (applicationOrRegistry.registry && applicationOrRegistry.container) {
+ // initializeStoreService was registered with an
+ // instanceInitializer. The first argument is the application
+ // instance.
+ registry = applicationOrRegistry.registry;
+ container = applicationOrRegistry.container;
+ } else {
+ // initializeStoreService was called by an initializer instead of
+ // an instanceInitializer. The first argument is a registy. This
+ // case allows ED to support Ember pre 1.12
+ registry = applicationOrRegistry;
+ if (registry.container) {
+ // Support Ember 1.10 - 1.11
+ container = registry.container();
+ } else {
+ // Support Ember 1.9
+ container = registry;
+ }
+ }
+ if (registry.has('store:application')) {
+ var customStoreFactory = container.lookupFactory('store:application');
+ registry.register('store:main', customStoreFactory);
+ } else {
+ registry.register('store:main', ember$data$lib$system$store$$default);
+ }
+
+ // Eagerly generate the store so defaultStore is populated.
+ var store = container.lookup('store:main');
+ registry.register('service:store', store, { instantiate: false });
+ }
+ var ember$data$lib$setup$container$$default = ember$data$lib$setup$container$$setupContainer;
+ function ember$data$lib$setup$container$$setupContainer(registry, application) {
+ // application is not a required argument. This ensures
+ // testing setups can setup a container without booting an
+ // entire ember application.
+
+ ember$data$lib$setup$container$$initializeInjects(registry, application);
+ ember$data$lib$instance$initializers$initialize$store$service$$default(registry);
+ }
+
+ function ember$data$lib$setup$container$$initializeInjects(registry, application) {
+ ember$data$lib$initializers$data$adapter$$default(registry, application);
+ ember$data$lib$initializers$transforms$$default(registry, application);
+ ember$data$lib$initializers$store$injections$$default(registry, application);
+ activemodel$adapter$lib$setup$container$$default(registry, application);
+ ember$data$lib$initializers$store$$default(registry, application);
+ }
+
+ var ember$data$lib$ember$initializer$$K = Ember.K;
+
+ /**
+ @module ember-data
+ */
+
+ /*
+
+ This code initializes Ember-Data onto an Ember application.
+
+ If an Ember.js developer defines a subclass of DS.Store on their application,
+ as `App.ApplicationStore` (or via a module system that resolves to `store:application`)
+ this code will automatically instantiate it and make it available on the
+ router.
+
+ Additionally, after an application's controllers have been injected, they will
+ each have the store made available to them.
+
+ For example, imagine an Ember.js application with the following classes:
+
+ App.ApplicationStore = DS.Store.extend({
+ adapter: 'custom'
+ });
+
+ App.PostsController = Ember.ArrayController.extend({
+ // ...
+ });
+
+ When the application is initialized, `App.ApplicationStore` will automatically be
+ instantiated, and the instance of `App.PostsController` will have its `store`
+ property set to that instance.
+
+ Note that this code will only be run if the `ember-application` package is
+ loaded. If Ember Data is being used in an environment other than a
+ typical application (e.g., node.js where only `ember-runtime` is available),
+ this code will be ignored.
+ */
+
+ Ember.onLoad('Ember.Application', function (Application) {
+
+ Application.initializer({
+ name: 'ember-data',
+ initialize: ember$data$lib$setup$container$$initializeInjects
+ });
+
+ if (Application.instanceInitializer) {
+ Application.instanceInitializer({
+ name: 'ember-data',
+ initialize: ember$data$lib$instance$initializers$initialize$store$service$$default
+ });
+ } else {
+ Application.initializer({
+ name: 'ember-data-store-service',
+ after: 'ember-data',
+ initialize: ember$data$lib$instance$initializers$initialize$store$service$$default
+ });
+ }
+
+ // Deprecated initializers to satisfy old code that depended on them
+ Application.initializer({
+ name: 'store',
+ after: 'ember-data',
+ initialize: ember$data$lib$ember$initializer$$K
+ });
+
+ Application.initializer({
+ name: 'activeModelAdapter',
+ before: 'store',
+ initialize: ember$data$lib$ember$initializer$$K
+ });
+
+ Application.initializer({
+ name: 'transforms',
+ before: 'store',
+ initialize: ember$data$lib$ember$initializer$$K
+ });
+
+ Application.initializer({
+ name: 'data-adapter',
+ before: 'store',
+ initialize: ember$data$lib$ember$initializer$$K
+ });
+
+ Application.initializer({
+ name: 'injectStore',
+ before: 'store',
+ initialize: ember$data$lib$ember$initializer$$K
+ });
+ });
+ Ember.Date = Ember.Date || {};
+
+ var origParse = Date.parse;
+ var numericKeys = [1, 4, 5, 6, 7, 10, 11];
+
+ /**
+ @method parse
+ @param {Date} date
+ @return {Number} timestamp
+ */
+ Ember.Date.parse = function (date) {
+ var timestamp, struct;
+ var minutesOffset = 0;
+
+ // ES5 §15.9.4.2 states that the string should attempt to be parsed as a Date Time String Format string
+ // before falling back to any implementation-specific date parsing, so that’s what we do, even if native
+ // implementations could be faster
+ // 1 YYYY 2 MM 3 DD 4 HH 5 mm 6 ss 7 msec 8 Z 9 ± 10 tzHH 11 tzmm
+ if (struct = /^(\d{4}|[+\-]\d{6})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?(?:(Z)|([+\-])(\d{2})(?::(\d{2}))?)?)?$/.exec(date)) {
+ // avoid NaN timestamps caused by “undefined†values being passed to Date.UTC
+ for (var i = 0, k; k = numericKeys[i]; ++i) {
+ struct[k] = +struct[k] || 0;
+ }
+
+ // allow undefined days and months
+ struct[2] = (+struct[2] || 1) - 1;
+ struct[3] = +struct[3] || 1;
+
+ if (struct[8] !== 'Z' && struct[9] !== undefined) {
+ minutesOffset = struct[10] * 60 + struct[11];
+
+ if (struct[9] === '+') {
+ minutesOffset = 0 - minutesOffset;
+ }
+ }
+
+ timestamp = Date.UTC(struct[1], struct[2], struct[3], struct[4], struct[5] + minutesOffset, struct[6], struct[7]);
+ } else {
+ timestamp = origParse ? origParse(date) : NaN;
+ }
+
+ return timestamp;
+ };
+
+ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Date) {
+ Date.parse = Ember.Date.parse;
+ }
+
+ ember$data$lib$system$model$$default.reopen({
+
+ /**
+ Provides info about the model for debugging purposes
+ by grouping the properties into more semantic groups.
+ Meant to be used by debugging tools such as the Chrome Ember Extension.
+ - Groups all attributes in "Attributes" group.
+ - Groups all belongsTo relationships in "Belongs To" group.
+ - Groups all hasMany relationships in "Has Many" group.
+ - Groups all flags in "Flags" group.
+ - Flags relationship CPs as expensive properties.
+ @method _debugInfo
+ @for DS.Model
+ @private
+ */
+ _debugInfo: function () {
+ var attributes = ['id'];
+ var relationships = { belongsTo: [], hasMany: [] };
+ var expensiveProperties = [];
+
+ this.eachAttribute(function (name, meta) {
+ attributes.push(name);
+ }, this);
+
+ this.eachRelationship(function (name, relationship) {
+ relationships[relationship.kind].push(name);
+ expensiveProperties.push(name);
+ });
+
+ var groups = [{
+ name: 'Attributes',
+ properties: attributes,
+ expand: true
+ }, {
+ name: 'Belongs To',
+ properties: relationships.belongsTo,
+ expand: true
+ }, {
+ name: 'Has Many',
+ properties: relationships.hasMany,
+ expand: true
+ }, {
+ name: 'Flags',
+ properties: ['isLoaded', 'isDirty', 'isSaving', 'isDeleted', 'isError', 'isNew', 'isValid']
+ }];
+
+ return {
+ propertyInfo: {
+ // include all other mixins / properties (not just the grouped ones)
+ includeOtherProperties: true,
+ groups: groups,
+ // don't pre-calculate unless cached
+ expensiveProperties: expensiveProperties
+ }
+ };
+ }
+ });
+
+ var ember$data$lib$system$debug$debug$info$$default = ember$data$lib$system$model$$default;
+ var ember$data$lib$system$debug$$default = ember$data$lib$system$debug$debug$adapter$$default;
+ var ember$data$lib$serializers$embedded$records$mixin$$forEach = Ember.EnumerableUtils.forEach;
+ var ember$data$lib$serializers$embedded$records$mixin$$camelize = Ember.String.camelize;
+
+ /**
+ ## Using Embedded Records
+
+ `DS.EmbeddedRecordsMixin` supports serializing embedded records.
+
+ To set up embedded records, include the mixin when extending a serializer
+ then define and configure embedded (model) relationships.
+
+ Below is an example of a per-type serializer ('post' type).
+
+ ```app/serializers/post.js
+ import DS from 'ember-data';
+
+ export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
+ attrs: {
+ author: { embedded: 'always' },
+ comments: { serialize: 'ids' }
+ }
+ });
+ ```
+ Note that this use of `{ embedded: 'always' }` is unrelated to
+ the `{ embedded: 'always' }` that is defined as an option on `DS.attr` as part of
+ defining a model while working with the ActiveModelSerializer. Nevertheless,
+ using `{ embedded: 'always' }` as an option to DS.attr is not a valid way to setup
+ embedded records.
+
+ The `attrs` option for a resource `{ embedded: 'always' }` is shorthand for:
+
+ ```js
+ {
+ serialize: 'records',
+ deserialize: 'records'
+ }
+ ```
+
+ ### Configuring Attrs
+
+ A resource's `attrs` option may be set to use `ids`, `records` or false for the
+ `serialize` and `deserialize` settings.
+
+ The `attrs` property can be set on the ApplicationSerializer or a per-type
+ serializer.
+
+ In the case where embedded JSON is expected while extracting a payload (reading)
+ the setting is `deserialize: 'records'`, there is no need to use `ids` when
+ extracting as that is the default behavior without this mixin if you are using
+ the vanilla EmbeddedRecordsMixin. Likewise, to embed JSON in the payload while
+ serializing `serialize: 'records'` is the setting to use. There is an option of
+ not embedding JSON in the serialized payload by using `serialize: 'ids'`. If you
+ do not want the relationship sent at all, you can use `serialize: false`.
+
+
+ ### EmbeddedRecordsMixin defaults
+ If you do not overwrite `attrs` for a specific relationship, the `EmbeddedRecordsMixin`
+ will behave in the following way:
+
+ BelongsTo: `{ serialize: 'id', deserialize: 'id' }`
+ HasMany: `{ serialize: false, deserialize: 'ids' }`
+
+ ### Model Relationships
+
+ Embedded records must have a model defined to be extracted and serialized. Note that
+ when defining any relationships on your model such as `belongsTo` and `hasMany`, you
+ should not both specify `async:true` and also indicate through the serializer's
+ `attrs` attribute that the related model should be embedded for deserialization.
+ If a model is declared embedded for deserialization (`embedded: 'always'`,
+ `deserialize: 'record'` or `deserialize: 'records'`), then do not use `async:true`.
+
+ To successfully extract and serialize embedded records the model relationships
+ must be setup correcty See the
+ [defining relationships](/guides/models/defining-models/#toc_defining-relationships)
+ section of the **Defining Models** guide page.
+
+ Records without an `id` property are not considered embedded records, model
+ instances must have an `id` property to be used with Ember Data.
+
+ ### Example JSON payloads, Models and Serializers
+
+ **When customizing a serializer it is important to grok what the customizations
+ are. Please read the docs for the methods this mixin provides, in case you need
+ to modify it to fit your specific needs.**
+
+ For example review the docs for each method of this mixin:
+ * [normalize](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_normalize)
+ * [serializeBelongsTo](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_serializeBelongsTo)
+ * [serializeHasMany](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_serializeHasMany)
+
+ @class EmbeddedRecordsMixin
+ @namespace DS
+ */
+ var ember$data$lib$serializers$embedded$records$mixin$$EmbeddedRecordsMixin = Ember.Mixin.create({
+
+ /**
+ Normalize the record and recursively normalize/extract all the embedded records
+ while pushing them into the store as they are encountered
+ A payload with an attr configured for embedded records needs to be extracted:
+ ```js
+ {
+ "post": {
+ "id": "1"
+ "title": "Rails is omakase",
+ "comments": [{
+ "id": "1",
+ "body": "Rails is unagi"
+ }, {
+ "id": "2",
+ "body": "Omakase O_o"
+ }]
+ }
+ }
+ ```
+ @method normalize
+ @param {DS.Model} typeClass
+ @param {Object} hash to be normalized
+ @param {String} prop the hash has been referenced by
+ @return {Object} the normalized hash
+ **/
+ normalize: function (typeClass, hash, prop) {
+ var normalizedHash = this._super(typeClass, hash, prop);
+ return ember$data$lib$serializers$embedded$records$mixin$$extractEmbeddedRecords(this, this.store, typeClass, normalizedHash);
+ },
+
+ keyForRelationship: function (key, typeClass, method) {
+ if (method === 'serialize' && this.hasSerializeRecordsOption(key) || method === 'deserialize' && this.hasDeserializeRecordsOption(key)) {
+ return this.keyForAttribute(key, method);
+ } else {
+ return this._super(key, typeClass, method) || key;
+ }
+ },
+
+ /**
+ Serialize `belongsTo` relationship when it is configured as an embedded object.
+ This example of an author model belongs to a post model:
+ ```js
+ Post = DS.Model.extend({
+ title: DS.attr('string'),
+ body: DS.attr('string'),
+ author: DS.belongsTo('author')
+ });
+ Author = DS.Model.extend({
+ name: DS.attr('string'),
+ post: DS.belongsTo('post')
+ });
+ ```
+ Use a custom (type) serializer for the post model to configure embedded author
+ ```app/serializers/post.js
+ import DS from 'ember-data;
+ export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
+ attrs: {
+ author: {embedded: 'always'}
+ }
+ })
+ ```
+ A payload with an attribute configured for embedded records can serialize
+ the records together under the root attribute's payload:
+ ```js
+ {
+ "post": {
+ "id": "1"
+ "title": "Rails is omakase",
+ "author": {
+ "id": "2"
+ "name": "dhh"
+ }
+ }
+ }
+ ```
+ @method serializeBelongsTo
+ @param {DS.Snapshot} snapshot
+ @param {Object} json
+ @param {Object} relationship
+ */
+ serializeBelongsTo: function (snapshot, json, relationship) {
+ var attr = relationship.key;
+ if (this.noSerializeOptionSpecified(attr)) {
+ this._super(snapshot, json, relationship);
+ return;
+ }
+ var includeIds = this.hasSerializeIdsOption(attr);
+ var includeRecords = this.hasSerializeRecordsOption(attr);
+ var embeddedSnapshot = snapshot.belongsTo(attr);
+ var key;
+ if (includeIds) {
+ key = this.keyForRelationship(attr, relationship.kind, 'serialize');
+ if (!embeddedSnapshot) {
+ json[key] = null;
+ } else {
+ json[key] = embeddedSnapshot.id;
+ }
+ } else if (includeRecords) {
+ key = this.keyForAttribute(attr, 'serialize');
+ if (!embeddedSnapshot) {
+ json[key] = null;
+ } else {
+ json[key] = embeddedSnapshot.record.serialize({ includeId: true });
+ this.removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, json[key]);
+ }
+ }
+ },
+
+ /**
+ Serialize `hasMany` relationship when it is configured as embedded objects.
+ This example of a post model has many comments:
+ ```js
+ Post = DS.Model.extend({
+ title: DS.attr('string'),
+ body: DS.attr('string'),
+ comments: DS.hasMany('comment')
+ });
+ Comment = DS.Model.extend({
+ body: DS.attr('string'),
+ post: DS.belongsTo('post')
+ });
+ ```
+ Use a custom (type) serializer for the post model to configure embedded comments
+ ```app/serializers/post.js
+ import DS from 'ember-data;
+ export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
+ attrs: {
+ comments: {embedded: 'always'}
+ }
+ })
+ ```
+ A payload with an attribute configured for embedded records can serialize
+ the records together under the root attribute's payload:
+ ```js
+ {
+ "post": {
+ "id": "1"
+ "title": "Rails is omakase",
+ "body": "I want this for my ORM, I want that for my template language..."
+ "comments": [{
+ "id": "1",
+ "body": "Rails is unagi"
+ }, {
+ "id": "2",
+ "body": "Omakase O_o"
+ }]
+ }
+ }
+ ```
+ The attrs options object can use more specific instruction for extracting and
+ serializing. When serializing, an option to embed `ids` or `records` can be set.
+ When extracting the only option is `records`.
+ So `{embedded: 'always'}` is shorthand for:
+ `{serialize: 'records', deserialize: 'records'}`
+ To embed the `ids` for a related object (using a hasMany relationship):
+ ```app/serializers/post.js
+ import DS from 'ember-data;
+ export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
+ attrs: {
+ comments: {serialize: 'ids', deserialize: 'records'}
+ }
+ })
+ ```
+ ```js
+ {
+ "post": {
+ "id": "1"
+ "title": "Rails is omakase",
+ "body": "I want this for my ORM, I want that for my template language..."
+ "comments": ["1", "2"]
+ }
+ }
+ ```
+ @method serializeHasMany
+ @param {DS.Snapshot} snapshot
+ @param {Object} json
+ @param {Object} relationship
+ */
+ serializeHasMany: function (snapshot, json, relationship) {
+ var attr = relationship.key;
+ if (this.noSerializeOptionSpecified(attr)) {
+ this._super(snapshot, json, relationship);
+ return;
+ }
+ var includeIds = this.hasSerializeIdsOption(attr);
+ var includeRecords = this.hasSerializeRecordsOption(attr);
+ var key, hasMany;
+ if (includeIds) {
+ key = this.keyForRelationship(attr, relationship.kind, 'serialize');
+ json[key] = snapshot.hasMany(attr, { ids: true });
+ } else if (includeRecords) {
+ key = this.keyForAttribute(attr, 'serialize');
+ hasMany = snapshot.hasMany(attr);
+
+
+ json[key] = Ember.A(hasMany).map(function (embeddedSnapshot) {
+ var embeddedJson = embeddedSnapshot.record.serialize({ includeId: true });
+ this.removeEmbeddedForeignKey(snapshot, embeddedSnapshot, relationship, embeddedJson);
+ return embeddedJson;
+ }, this);
+ }
+ },
+
+ /**
+ When serializing an embedded record, modify the property (in the json payload)
+ that refers to the parent record (foreign key for relationship).
+ Serializing a `belongsTo` relationship removes the property that refers to the
+ parent record
+ Serializing a `hasMany` relationship does not remove the property that refers to
+ the parent record.
+ @method removeEmbeddedForeignKey
+ @param {DS.Snapshot} snapshot
+ @param {DS.Snapshot} embeddedSnapshot
+ @param {Object} relationship
+ @param {Object} json
+ */
+ removeEmbeddedForeignKey: function (snapshot, embeddedSnapshot, relationship, json) {
+ if (relationship.kind === 'hasMany') {
+ return;
+ } else if (relationship.kind === 'belongsTo') {
+ var parentRecord = snapshot.type.inverseFor(relationship.key, this.store);
+ if (parentRecord) {
+ var name = parentRecord.name;
+ var embeddedSerializer = this.store.serializerFor(embeddedSnapshot.modelName);
+ var parentKey = embeddedSerializer.keyForRelationship(name, parentRecord.kind, 'deserialize');
+ if (parentKey) {
+ delete json[parentKey];
+ }
+ }
+ }
+ },
+
+ // checks config for attrs option to embedded (always) - serialize and deserialize
+ hasEmbeddedAlwaysOption: function (attr) {
+ var option = this.attrsOption(attr);
+ return option && option.embedded === 'always';
+ },
+
+ // checks config for attrs option to serialize ids
+ hasSerializeRecordsOption: function (attr) {
+ var alwaysEmbed = this.hasEmbeddedAlwaysOption(attr);
+ var option = this.attrsOption(attr);
+ return alwaysEmbed || option && option.serialize === 'records';
+ },
+
+ // checks config for attrs option to serialize records
+ hasSerializeIdsOption: function (attr) {
+ var option = this.attrsOption(attr);
+ return option && (option.serialize === 'ids' || option.serialize === 'id');
+ },
+
+ // checks config for attrs option to serialize records
+ noSerializeOptionSpecified: function (attr) {
+ var option = this.attrsOption(attr);
+ return !(option && (option.serialize || option.embedded));
+ },
+
+ // checks config for attrs option to deserialize records
+ // a defined option object for a resource is treated the same as
+ // `deserialize: 'records'`
+ hasDeserializeRecordsOption: function (attr) {
+ var alwaysEmbed = this.hasEmbeddedAlwaysOption(attr);
+ var option = this.attrsOption(attr);
+ return alwaysEmbed || option && option.deserialize === 'records';
+ },
+
+ attrsOption: function (attr) {
+ var attrs = this.get('attrs');
+ return attrs && (attrs[ember$data$lib$serializers$embedded$records$mixin$$camelize(attr)] || attrs[attr]);
+ }
+ });
+
+ // chooses a relationship kind to branch which function is used to update payload
+ // does not change payload if attr is not embedded
+ function ember$data$lib$serializers$embedded$records$mixin$$extractEmbeddedRecords(serializer, store, typeClass, partial) {
+
+ typeClass.eachRelationship(function (key, relationship) {
+ if (serializer.hasDeserializeRecordsOption(key)) {
+ var embeddedTypeClass = store.modelFor(relationship.type);
+ if (relationship.kind === 'hasMany') {
+ if (relationship.options.polymorphic) {
+ ember$data$lib$serializers$embedded$records$mixin$$extractEmbeddedHasManyPolymorphic(store, key, partial);
+ } else {
+ ember$data$lib$serializers$embedded$records$mixin$$extractEmbeddedHasMany(store, key, embeddedTypeClass, partial);
+ }
+ }
+ if (relationship.kind === 'belongsTo') {
+ if (relationship.options.polymorphic) {
+ ember$data$lib$serializers$embedded$records$mixin$$extractEmbeddedBelongsToPolymorphic(store, key, partial);
+ } else {
+ ember$data$lib$serializers$embedded$records$mixin$$extractEmbeddedBelongsTo(store, key, embeddedTypeClass, partial);
+ }
+ }
+ }
+ });
+
+ return partial;
+ }
+
+ // handles embedding for `hasMany` relationship
+ function ember$data$lib$serializers$embedded$records$mixin$$extractEmbeddedHasMany(store, key, embeddedTypeClass, hash) {
+ if (!hash[key]) {
+ return hash;
+ }
+
+ var ids = [];
+
+ var embeddedSerializer = store.serializerFor(embeddedTypeClass.modelName);
+ ember$data$lib$serializers$embedded$records$mixin$$forEach(hash[key], function (data) {
+ var embeddedRecord = embeddedSerializer.normalize(embeddedTypeClass, data, null);
+ store.push(embeddedTypeClass.modelName, embeddedRecord);
+ ids.push(embeddedRecord.id);
+ });
+
+ hash[key] = ids;
+ return hash;
+ }
+
+ function ember$data$lib$serializers$embedded$records$mixin$$extractEmbeddedHasManyPolymorphic(store, key, hash) {
+ if (!hash[key]) {
+ return hash;
+ }
+
+ var ids = [];
+
+ ember$data$lib$serializers$embedded$records$mixin$$forEach(hash[key], function (data) {
+ var modelName = data.type;
+ var embeddedSerializer = store.serializerFor(modelName);
+ var embeddedTypeClass = store.modelFor(modelName);
+ // var primaryKey = embeddedSerializer.get('primaryKey');
+
+ var embeddedRecord = embeddedSerializer.normalize(embeddedTypeClass, data, null);
+ store.push(embeddedTypeClass.modelName, embeddedRecord);
+ ids.push({ id: embeddedRecord.id, type: modelName });
+ });
+
+ hash[key] = ids;
+ return hash;
+ }
+
+ function ember$data$lib$serializers$embedded$records$mixin$$extractEmbeddedBelongsTo(store, key, embeddedTypeClass, hash) {
+ if (!hash[key]) {
+ return hash;
+ }
+
+ var embeddedSerializer = store.serializerFor(embeddedTypeClass.modelName);
+ var embeddedRecord = embeddedSerializer.normalize(embeddedTypeClass, hash[key], null);
+ store.push(embeddedTypeClass.modelName, embeddedRecord);
+
+ hash[key] = embeddedRecord.id;
+ //TODO Need to add a reference to the parent later so relationship works between both `belongsTo` records
+ return hash;
+ }
+
+ function ember$data$lib$serializers$embedded$records$mixin$$extractEmbeddedBelongsToPolymorphic(store, key, hash) {
+ if (!hash[key]) {
+ return hash;
+ }
+
+ var data = hash[key];
+ var modelName = data.type;
+ var embeddedSerializer = store.serializerFor(modelName);
+ var embeddedTypeClass = store.modelFor(modelName);
+
+ var embeddedRecord = embeddedSerializer.normalize(embeddedTypeClass, data, null);
+ store.push(embeddedTypeClass.modelName, embeddedRecord);
+
+ hash[key] = embeddedRecord.id;
+ hash[key + 'Type'] = modelName;
+ return hash;
+ }
+
+ var ember$data$lib$serializers$embedded$records$mixin$$default = ember$data$lib$serializers$embedded$records$mixin$$EmbeddedRecordsMixin;
+
+ /**
+ `DS.belongsTo` is used to define One-To-One and One-To-Many
+ relationships on a [DS.Model](/api/data/classes/DS.Model.html).
+
+
+ `DS.belongsTo` takes an optional hash as a second parameter, currently
+ supported options are:
+
+ - `async`: A boolean value used to explicitly declare this to be an async relationship.
+ - `inverse`: A string used to identify the inverse property on a
+ related model in a One-To-Many relationship. See [Explicit Inverses](#toc_explicit-inverses)
+
+ #### One-To-One
+ To declare a one-to-one relationship between two models, use
+ `DS.belongsTo`:
+
+ ```app/models/user.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ profile: DS.belongsTo('profile')
+ });
+ ```
+
+ ```app/models/profile.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ user: DS.belongsTo('user')
+ });
+ ```
+
+ #### One-To-Many
+ To declare a one-to-many relationship between two models, use
+ `DS.belongsTo` in combination with `DS.hasMany`, like this:
+
+ ```app/models/post.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ comments: DS.hasMany('comment')
+ });
+ ```
+
+ ```app/models/comment.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ post: DS.belongsTo('post')
+ });
+ ```
+
+ You can avoid passing a string as the first parameter. In that case Ember Data
+ will infer the type from the key name.
+
+ ```app/models/comment.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ post: DS.belongsTo()
+ });
+ ```
+
+ will lookup for a Post type.
+
+ @namespace
+ @method belongsTo
+ @for DS
+ @param {String} modelName (optional) type of the relationship
+ @param {Object} options (optional) a hash of options
+ @return {Ember.computed} relationship
+ */
+ function ember$data$lib$system$relationships$belongs$to$$belongsTo(modelName, options) {
+ var opts, userEnteredModelName;
+ if (typeof modelName === "object") {
+ opts = modelName;
+ userEnteredModelName = undefined;
+ } else {
+ opts = options;
+ userEnteredModelName = modelName;
+ }
+
+ if (typeof userEnteredModelName === "string") {
+ userEnteredModelName = ember$data$lib$system$normalize$model$name$$default(userEnteredModelName);
+ }
+
+
+ opts = opts || {};
+
+ var meta = {
+ type: userEnteredModelName,
+ isRelationship: true,
+ options: opts,
+ kind: "belongsTo",
+ key: null
+ };
+
+ return ember$data$lib$utils$computed$polyfill$$default({
+ get: function (key) {
+ return this._internalModel._relationships.get(key).getRecord();
+ },
+ set: function (key, value) {
+ if (value === undefined) {
+ value = null;
+ }
+ if (value && value.then) {
+ this._internalModel._relationships.get(key).setRecordPromise(value);
+ } else if (value) {
+ this._internalModel._relationships.get(key).setRecord(value._internalModel);
+ } else {
+ this._internalModel._relationships.get(key).setRecord(value);
+ }
+
+ return this._internalModel._relationships.get(key).getRecord();
+ }
+ }).meta(meta);
+ }
+
+ /*
+ These observers observe all `belongsTo` relationships on the record. See
+ `relationships/ext` to see how these observers get their dependencies.
+ */
+ ember$data$lib$system$model$$default.reopen({
+ notifyBelongsToChanged: function (key) {
+ this.notifyPropertyChange(key);
+ }
+ });
+
+ var ember$data$lib$system$relationships$belongs$to$$default = ember$data$lib$system$relationships$belongs$to$$belongsTo;
+
+ /**
+ `DS.hasMany` is used to define One-To-Many and Many-To-Many
+ relationships on a [DS.Model](/api/data/classes/DS.Model.html).
+
+ `DS.hasMany` takes an optional hash as a second parameter, currently
+ supported options are:
+
+ - `async`: A boolean value used to explicitly declare this to be an async relationship.
+ - `inverse`: A string used to identify the inverse property on a related model.
+
+ #### One-To-Many
+ To declare a one-to-many relationship between two models, use
+ `DS.belongsTo` in combination with `DS.hasMany`, like this:
+
+ ```app/models/post.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ comments: DS.hasMany('comment')
+ });
+ ```
+
+ ```app/models/comment.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ post: DS.belongsTo('post')
+ });
+ ```
+
+ #### Many-To-Many
+ To declare a many-to-many relationship between two models, use
+ `DS.hasMany`:
+
+ ```app/models/post.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ tags: DS.hasMany('tag')
+ });
+ ```
+
+ ```app/models/tag.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ posts: DS.hasMany('post')
+ });
+ ```
+
+ You can avoid passing a string as the first parameter. In that case Ember Data
+ will infer the type from the singularized key name.
+
+ ```app/models/post.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ tags: DS.hasMany()
+ });
+ ```
+
+ will lookup for a Tag type.
+
+ #### Explicit Inverses
+
+ Ember Data will do its best to discover which relationships map to
+ one another. In the one-to-many code above, for example, Ember Data
+ can figure out that changing the `comments` relationship should update
+ the `post` relationship on the inverse because post is the only
+ relationship to that model.
+
+ However, sometimes you may have multiple `belongsTo`/`hasManys` for the
+ same type. You can specify which property on the related model is
+ the inverse using `DS.hasMany`'s `inverse` option:
+
+ ```app/models/comment.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ onePost: DS.belongsTo('post'),
+ twoPost: DS.belongsTo('post'),
+ redPost: DS.belongsTo('post'),
+ bluePost: DS.belongsTo('post')
+ });
+ ```
+
+ ```app/models/post.js
+ import DS from 'ember-data';
+
+ export default DS.Model.extend({
+ comments: DS.hasMany('comment', {
+ inverse: 'redPost'
+ })
+ });
+ ```
+
+ You can also specify an inverse on a `belongsTo`, which works how
+ you'd expect.
+
+ @namespace
+ @method hasMany
+ @for DS
+ @param {String} type (optional) type of the relationship
+ @param {Object} options (optional) a hash of options
+ @return {Ember.computed} relationship
+ */
+ function ember$data$lib$system$relationships$has$many$$hasMany(type, options) {
+ if (typeof type === "object") {
+ options = type;
+ type = undefined;
+ }
+
+
+ options = options || {};
+
+ if (typeof type === "string") {
+ type = ember$data$lib$system$normalize$model$name$$default(type);
+ }
+
+ // Metadata about relationships is stored on the meta of
+ // the relationship. This is used for introspection and
+ // serialization. Note that `key` is populated lazily
+ // the first time the CP is called.
+ var meta = {
+ type: type,
+ isRelationship: true,
+ options: options,
+ kind: "hasMany",
+ key: null
+ };
+
+ return ember$data$lib$utils$computed$polyfill$$default({
+ get: function (key) {
+ var relationship = this._internalModel._relationships.get(key);
+ return relationship.getRecords();
+ },
+ set: function (key, records) {
+ var relationship = this._internalModel._relationships.get(key);
+ relationship.clear();
+ relationship.addRecords(Ember.A(records).mapBy("_internalModel"));
+ return relationship.getRecords();
+ }
+ }).meta(meta);
+ }
+
+ ember$data$lib$system$model$$default.reopen({
+ notifyHasManyAdded: function (key) {
+ //We need to notifyPropertyChange in the adding case because we need to make sure
+ //we fetch the newly added record in case it is unloaded
+ //TODO(Igor): Consider whether we could do this only if the record state is unloaded
+
+ //Goes away once hasMany is double promisified
+ this.notifyPropertyChange(key);
+ }
+ });
+
+ var ember$data$lib$system$relationships$has$many$$default = ember$data$lib$system$relationships$has$many$$hasMany;
+ function ember$data$lib$system$relationship$meta$$typeForRelationshipMeta(meta) {
+ var modelName;
+
+ modelName = meta.type || meta.key;
+ if (meta.kind === 'hasMany') {
+ modelName = ember$inflector$lib$lib$system$string$$singularize(ember$data$lib$system$normalize$model$name$$default(modelName));
+ }
+ return modelName;
+ }
+
+ function ember$data$lib$system$relationship$meta$$relationshipFromMeta(meta) {
+ return {
+ key: meta.key,
+ kind: meta.kind,
+ type: ember$data$lib$system$relationship$meta$$typeForRelationshipMeta(meta),
+ options: meta.options,
+ parentType: meta.parentType,
+ isRelationship: true
+ };
+ }
+
+ var ember$data$lib$system$relationships$ext$$get = Ember.get;
+ var ember$data$lib$system$relationships$ext$$filter = Ember.ArrayPolyfills.filter;
+
+ var ember$data$lib$system$relationships$ext$$relationshipsDescriptor = Ember.computed(function () {
+ if (Ember.testing === true && ember$data$lib$system$relationships$ext$$relationshipsDescriptor._cacheable === true) {
+ ember$data$lib$system$relationships$ext$$relationshipsDescriptor._cacheable = false;
+ }
+
+ var map = new ember$data$lib$system$map$$MapWithDefault({
+ defaultValue: function () {
+ return [];
+ }
+ });
+
+ // Loop through each computed property on the class
+ this.eachComputedProperty(function (name, meta) {
+ // If the computed property is a relationship, add
+ // it to the map.
+ if (meta.isRelationship) {
+ meta.key = name;
+ var relationshipsForType = map.get(ember$data$lib$system$relationship$meta$$typeForRelationshipMeta(meta));
+
+ relationshipsForType.push({
+ name: name,
+ kind: meta.kind
+ });
+ }
+ });
+
+ return map;
+ }).readOnly();
+
+ var ember$data$lib$system$relationships$ext$$relatedTypesDescriptor = Ember.computed(function () {
+ if (Ember.testing === true && ember$data$lib$system$relationships$ext$$relatedTypesDescriptor._cacheable === true) {
+ ember$data$lib$system$relationships$ext$$relatedTypesDescriptor._cacheable = false;
+ }
+
+ var modelName;
+ var types = Ember.A();
+
+ // Loop through each computed property on the class,
+ // and create an array of the unique types involved
+ // in relationships
+ this.eachComputedProperty(function (name, meta) {
+ if (meta.isRelationship) {
+ meta.key = name;
+ modelName = ember$data$lib$system$relationship$meta$$typeForRelationshipMeta(meta);
+
+
+ if (!types.contains(modelName)) {
+ types.push(modelName);
+ }
+ }
+ });
+
+ return types;
+ }).readOnly();
+
+ var ember$data$lib$system$relationships$ext$$relationshipsByNameDescriptor = Ember.computed(function () {
+ if (Ember.testing === true && ember$data$lib$system$relationships$ext$$relationshipsByNameDescriptor._cacheable === true) {
+ ember$data$lib$system$relationships$ext$$relationshipsByNameDescriptor._cacheable = false;
+ }
+
+ var map = ember$data$lib$system$map$$Map.create();
+
+ this.eachComputedProperty(function (name, meta) {
+ if (meta.isRelationship) {
+ meta.key = name;
+ var relationship = ember$data$lib$system$relationship$meta$$relationshipFromMeta(meta);
+ relationship.type = ember$data$lib$system$relationship$meta$$typeForRelationshipMeta(meta);
+ map.set(name, relationship);
+ }
+ });
+
+ return map;
+ }).readOnly();
+
+ /**
+ @module ember-data
+ */
+
+ /*
+ This file defines several extensions to the base `DS.Model` class that
+ add support for one-to-many relationships.
+ */
+
+ /**
+ @class Model
+ @namespace DS
+ */
+ ember$data$lib$system$model$$default.reopen({
+
+ /**
+ This Ember.js hook allows an object to be notified when a property
+ is defined.
+ In this case, we use it to be notified when an Ember Data user defines a
+ belongs-to relationship. In that case, we need to set up observers for
+ each one, allowing us to track relationship changes and automatically
+ reflect changes in the inverse has-many array.
+ This hook passes the class being set up, as well as the key and value
+ being defined. So, for example, when the user does this:
+ ```javascript
+ DS.Model.extend({
+ parent: DS.belongsTo('user')
+ });
+ ```
+ This hook would be called with "parent" as the key and the computed
+ property returned by `DS.belongsTo` as the value.
+ @method didDefineProperty
+ @param {Object} proto
+ @param {String} key
+ @param {Ember.ComputedProperty} value
+ */
+ didDefineProperty: function (proto, key, value) {
+ // Check if the value being set is a computed property.
+ if (value instanceof Ember.ComputedProperty) {
+
+ // If it is, get the metadata for the relationship. This is
+ // populated by the `DS.belongsTo` helper when it is creating
+ // the computed property.
+ var meta = value.meta();
+
+ meta.parentType = proto.constructor;
+ }
+ }
+ });
+
+ /*
+ These DS.Model extensions add class methods that provide relationship
+ introspection abilities about relationships.
+
+ A note about the computed properties contained here:
+
+ **These properties are effectively sealed once called for the first time.**
+ To avoid repeatedly doing expensive iteration over a model's fields, these
+ values are computed once and then cached for the remainder of the runtime of
+ your application.
+
+ If your application needs to modify a class after its initial definition
+ (for example, using `reopen()` to add additional attributes), make sure you
+ do it before using your model with the store, which uses these properties
+ extensively.
+ */
+
+ ember$data$lib$system$model$$default.reopenClass({
+
+ /**
+ For a given relationship name, returns the model type of the relationship.
+ For example, if you define a model like this:
+ ```app/models/post.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ comments: DS.hasMany('comment')
+ });
+ ```
+ Calling `App.Post.typeForRelationship('comments')` will return `App.Comment`.
+ @method typeForRelationship
+ @static
+ @param {String} name the name of the relationship
+ @param {store} store an instance of DS.Store
+ @return {DS.Model} the type of the relationship, or undefined
+ */
+ typeForRelationship: function (name, store) {
+ var relationship = ember$data$lib$system$relationships$ext$$get(this, "relationshipsByName").get(name);
+ return relationship && store.modelFor(relationship.type);
+ },
+
+ inverseMap: Ember.computed(function () {
+ return Ember.create(null);
+ }),
+
+ /**
+ Find the relationship which is the inverse of the one asked for.
+ For example, if you define models like this:
+ ```app/models/post.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ comments: DS.hasMany('message')
+ });
+ ```
+ ```app/models/message.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ owner: DS.belongsTo('post')
+ });
+ ```
+ App.Post.inverseFor('comments') -> {type: App.Message, name:'owner', kind:'belongsTo'}
+ App.Message.inverseFor('owner') -> {type: App.Post, name:'comments', kind:'hasMany'}
+ @method inverseFor
+ @static
+ @param {String} name the name of the relationship
+ @return {Object} the inverse relationship, or null
+ */
+ inverseFor: function (name, store) {
+ var inverseMap = ember$data$lib$system$relationships$ext$$get(this, "inverseMap");
+ if (inverseMap[name]) {
+ return inverseMap[name];
+ } else {
+ var inverse = this._findInverseFor(name, store);
+ inverseMap[name] = inverse;
+ return inverse;
+ }
+ },
+
+ //Calculate the inverse, ignoring the cache
+ _findInverseFor: function (name, store) {
+
+ var inverseType = this.typeForRelationship(name, store);
+ if (!inverseType) {
+ return null;
+ }
+
+ var propertyMeta = this.metaForProperty(name);
+ //If inverse is manually specified to be null, like `comments: DS.hasMany('message', {inverse: null})`
+ var options = propertyMeta.options;
+ if (options.inverse === null) {
+ return null;
+ }
+
+ var inverseName, inverseKind, inverse;
+
+
+ //If inverse is specified manually, return the inverse
+ if (options.inverse) {
+ inverseName = options.inverse;
+ inverse = Ember.get(inverseType, "relationshipsByName").get(inverseName);
+
+
+ inverseKind = inverse.kind;
+ } else {
+ //No inverse was specified manually, we need to use a heuristic to guess one
+ var possibleRelationships = findPossibleInverses(this, inverseType);
+
+ if (possibleRelationships.length === 0) {
+ return null;
+ }
+
+ var filteredRelationships = ember$data$lib$system$relationships$ext$$filter.call(possibleRelationships, function (possibleRelationship) {
+ var optionsForRelationship = inverseType.metaForProperty(possibleRelationship.name).options;
+ return name === optionsForRelationship.inverse;
+ });
+
+
+ if (filteredRelationships.length === 1) {
+ possibleRelationships = filteredRelationships;
+ }
+
+
+ inverseName = possibleRelationships[0].name;
+ inverseKind = possibleRelationships[0].kind;
+ }
+
+ function findPossibleInverses(type, inverseType, relationshipsSoFar) {
+ var possibleRelationships = relationshipsSoFar || [];
+
+ var relationshipMap = ember$data$lib$system$relationships$ext$$get(inverseType, "relationships");
+ if (!relationshipMap) {
+ return possibleRelationships;
+ }
+
+ var relationships = relationshipMap.get(type.modelName);
+
+ relationships = ember$data$lib$system$relationships$ext$$filter.call(relationships, function (relationship) {
+ var optionsForRelationship = inverseType.metaForProperty(relationship.name).options;
+
+ if (!optionsForRelationship.inverse) {
+ return true;
+ }
+
+ return name === optionsForRelationship.inverse;
+ });
+
+ if (relationships) {
+ possibleRelationships.push.apply(possibleRelationships, relationships);
+ }
+
+ //Recurse to support polymorphism
+ if (type.superclass) {
+ findPossibleInverses(type.superclass, inverseType, possibleRelationships);
+ }
+
+ return possibleRelationships;
+ }
+
+ return {
+ type: inverseType,
+ name: inverseName,
+ kind: inverseKind
+ };
+ },
+
+ /**
+ The model's relationships as a map, keyed on the type of the
+ relationship. The value of each entry is an array containing a descriptor
+ for each relationship with that type, describing the name of the relationship
+ as well as the type.
+ For example, given the following model definition:
+ ```app/models/blog.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ users: DS.hasMany('user'),
+ owner: DS.belongsTo('user'),
+ posts: DS.hasMany('post')
+ });
+ ```
+ This computed property would return a map describing these
+ relationships, like this:
+ ```javascript
+ import Ember from 'ember';
+ import Blog from 'app/models/blog';
+ var relationships = Ember.get(Blog, 'relationships');
+ relationships.get(App.User);
+ //=> [ { name: 'users', kind: 'hasMany' },
+ // { name: 'owner', kind: 'belongsTo' } ]
+ relationships.get(App.Post);
+ //=> [ { name: 'posts', kind: 'hasMany' } ]
+ ```
+ @property relationships
+ @static
+ @type Ember.Map
+ @readOnly
+ */
+
+ relationships: ember$data$lib$system$relationships$ext$$relationshipsDescriptor,
+
+ /**
+ A hash containing lists of the model's relationships, grouped
+ by the relationship kind. For example, given a model with this
+ definition:
+ ```app/models/blog.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ users: DS.hasMany('user'),
+ owner: DS.belongsTo('user'),
+ posts: DS.hasMany('post')
+ });
+ ```
+ This property would contain the following:
+ ```javascript
+ import Ember from 'ember';
+ import Blog from 'app/models/blog';
+ var relationshipNames = Ember.get(Blog, 'relationshipNames');
+ relationshipNames.hasMany;
+ //=> ['users', 'posts']
+ relationshipNames.belongsTo;
+ //=> ['owner']
+ ```
+ @property relationshipNames
+ @static
+ @type Object
+ @readOnly
+ */
+ relationshipNames: Ember.computed(function () {
+ var names = {
+ hasMany: [],
+ belongsTo: []
+ };
+
+ this.eachComputedProperty(function (name, meta) {
+ if (meta.isRelationship) {
+ names[meta.kind].push(name);
+ }
+ });
+
+ return names;
+ }),
+
+ /**
+ An array of types directly related to a model. Each type will be
+ included once, regardless of the number of relationships it has with
+ the model.
+ For example, given a model with this definition:
+ ```app/models/blog.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ users: DS.hasMany('user'),
+ owner: DS.belongsTo('user'),
+ posts: DS.hasMany('post')
+ });
+ ```
+ This property would contain the following:
+ ```javascript
+ import Ember from 'ember';
+ import Blog from 'app/models/blog';
+ var relatedTypes = Ember.get(Blog, 'relatedTypes');
+ //=> [ App.User, App.Post ]
+ ```
+ @property relatedTypes
+ @static
+ @type Ember.Array
+ @readOnly
+ */
+ relatedTypes: ember$data$lib$system$relationships$ext$$relatedTypesDescriptor,
+
+ /**
+ A map whose keys are the relationships of a model and whose values are
+ relationship descriptors.
+ For example, given a model with this
+ definition:
+ ```app/models/blog.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ users: DS.hasMany('user'),
+ owner: DS.belongsTo('user'),
+ posts: DS.hasMany('post')
+ });
+ ```
+ This property would contain the following:
+ ```javascript
+ import Ember from 'ember';
+ import Blog from 'app/models/blog';
+ var relationshipsByName = Ember.get(Blog, 'relationshipsByName');
+ relationshipsByName.get('users');
+ //=> { key: 'users', kind: 'hasMany', type: App.User }
+ relationshipsByName.get('owner');
+ //=> { key: 'owner', kind: 'belongsTo', type: App.User }
+ ```
+ @property relationshipsByName
+ @static
+ @type Ember.Map
+ @readOnly
+ */
+ relationshipsByName: ember$data$lib$system$relationships$ext$$relationshipsByNameDescriptor,
+
+ /**
+ A map whose keys are the fields of the model and whose values are strings
+ describing the kind of the field. A model's fields are the union of all of its
+ attributes and relationships.
+ For example:
+ ```app/models/blog.js
+ import DS from 'ember-data';
+ export default DS.Model.extend({
+ users: DS.hasMany('user'),
+ owner: DS.belongsTo('user'),
+ posts: DS.hasMany('post'),
+ title: DS.attr('string')
+ });
+ ```
+ ```js
+ import Ember from 'ember';
+ import Blog from 'app/models/blog';
+ var fields = Ember.get(Blog, 'fields');
+ fields.forEach(function(kind, field) {
+ console.log(field, kind);
+ });
+ // prints:
+ // users, hasMany
+ // owner, belongsTo
+ // posts, hasMany
+ // title, attribute
+ ```
+ @property fields
+ @static
+ @type Ember.Map
+ @readOnly
+ */
+ fields: Ember.computed(function () {
+ var map = ember$data$lib$system$map$$Map.create();
+
+ this.eachComputedProperty(function (name, meta) {
+ if (meta.isRelationship) {
+ map.set(name, meta.kind);
+ } else if (meta.isAttribute) {
+ map.set(name, "attribute");
+ }
+ });
+
+ return map;
+ }).readOnly(),
+
+ /**
+ Given a callback, iterates over each of the relationships in the model,
+ invoking the callback with the name of each relationship and its relationship
+ descriptor.
+ @method eachRelationship
+ @static
+ @param {Function} callback the callback to invoke
+ @param {any} binding the value to which the callback's `this` should be bound
+ */
+ eachRelationship: function (callback, binding) {
+ ember$data$lib$system$relationships$ext$$get(this, "relationshipsByName").forEach(function (relationship, name) {
+ callback.call(binding, name, relationship);
+ });
+ },
+
+ /**
+ Given a callback, iterates over each of the types related to a model,
+ invoking the callback with the related type's class. Each type will be
+ returned just once, regardless of how many different relationships it has
+ with a model.
+ @method eachRelatedType
+ @static
+ @param {Function} callback the callback to invoke
+ @param {any} binding the value to which the callback's `this` should be bound
+ */
+ eachRelatedType: function (callback, binding) {
+ ember$data$lib$system$relationships$ext$$get(this, "relatedTypes").forEach(function (type) {
+ callback.call(binding, type);
+ });
+ },
+
+ determineRelationshipType: function (knownSide, store) {
+ var knownKey = knownSide.key;
+ var knownKind = knownSide.kind;
+ var inverse = this.inverseFor(knownKey, store);
+ var key, otherKind;
+
+ if (!inverse) {
+ return knownKind === "belongsTo" ? "oneToNone" : "manyToNone";
+ }
+
+ key = inverse.name;
+ otherKind = inverse.kind;
+
+ if (otherKind === "belongsTo") {
+ return knownKind === "belongsTo" ? "oneToOne" : "manyToOne";
+ } else {
+ return knownKind === "belongsTo" ? "oneToMany" : "manyToMany";
+ }
+ }
+
+ });
+
+ ember$data$lib$system$model$$default.reopen({
+ /**
+ Given a callback, iterates over each of the relationships in the model,
+ invoking the callback with the name of each relationship and its relationship
+ descriptor.
+ The callback method you provide should have the following signature (all
+ parameters are optional):
+ ```javascript
+ function(name, descriptor);
+ ```
+ - `name` the name of the current property in the iteration
+ - `descriptor` the meta object that describes this relationship
+ The relationship descriptor argument is an object with the following properties.
+ - **key** String the name of this relationship on the Model
+ - **kind** String "hasMany" or "belongsTo"
+ - **options** Object the original options hash passed when the relationship was declared
+ - **parentType** DS.Model the type of the Model that owns this relationship
+ - **type** DS.Model the type of the related Model
+ Note that in addition to a callback, you can also pass an optional target
+ object that will be set as `this` on the context.
+ Example
+ ```app/serializers/application.js
+ import DS from 'ember-data';
+ export default DS.JSONSerializer.extend({
+ serialize: function(record, options) {
+ var json = {};
+ record.eachRelationship(function(name, descriptor) {
+ if (descriptor.kind === 'hasMany') {
+ var serializedHasManyName = name.toUpperCase() + '_IDS';
+ json[name.toUpperCase()] = record.get(name).mapBy('id');
+ }
+ });
+ return json;
+ }
+ });
+ ```
+ @method eachRelationship
+ @param {Function} callback the callback to invoke
+ @param {any} binding the value to which the callback's `this` should be bound
+ */
+ eachRelationship: function (callback, binding) {
+ this.constructor.eachRelationship(callback, binding);
+ },
+
+ relationshipFor: function (name) {
+ return ember$data$lib$system$relationships$ext$$get(this.constructor, "relationshipsByName").get(name);
+ },
+
+ inverseFor: function (key) {
+ return this.constructor.inverseFor(key, this.store);
+ }
+
+ });
+
+ /**
+ Ember Data
+ @module ember-data
+ @main ember-data
+ */
+
+ if (Ember.VERSION.match(/^1\.[0-7]\./)) {
+ throw new Ember.Error("Ember Data requires at least Ember 1.8.0, but you have " + Ember.VERSION + ". Please upgrade your version of Ember, then upgrade Ember Data");
+ }
+
+ if (Ember.VERSION.match(/^1\.12\.0/)) {
+ throw new Ember.Error("Ember Data does not work with Ember 1.12.0. Please upgrade to Ember 1.12.1 or higher.");
+ }
+
+ // support RSVP 2.x via resolve, but prefer RSVP 3.x's Promise.cast
+ Ember.RSVP.Promise.cast = Ember.RSVP.Promise.cast || Ember.RSVP.resolve;ember$data$lib$core$$default.Store = ember$data$lib$system$store$$Store;
+ ember$data$lib$core$$default.PromiseArray = ember$data$lib$system$promise$proxies$$PromiseArray;
+ ember$data$lib$core$$default.PromiseObject = ember$data$lib$system$promise$proxies$$PromiseObject;
+
+ ember$data$lib$core$$default.PromiseManyArray = ember$data$lib$system$promise$proxies$$PromiseManyArray;
+
+ ember$data$lib$core$$default.Model = ember$data$lib$system$model$$default;
+ ember$data$lib$core$$default.RootState = ember$data$lib$system$model$states$$default;
+ ember$data$lib$core$$default.attr = ember$data$lib$system$model$attributes$$default;
+ ember$data$lib$core$$default.Errors = ember$data$lib$system$model$errors$$default;
+
+ ember$data$lib$core$$default.InternalModel = ember$data$lib$system$model$internal$model$$default;
+ ember$data$lib$core$$default.Snapshot = ember$data$lib$system$snapshot$$default;
+
+ ember$data$lib$core$$default.Adapter = ember$data$lib$system$adapter$$Adapter;
+ ember$data$lib$core$$default.InvalidError = ember$data$lib$system$model$errors$invalid$$default;
+
+ ember$data$lib$core$$default.Serializer = ember$data$lib$system$serializer$$default;
+
+ ember$data$lib$core$$default.DebugAdapter = ember$data$lib$system$debug$$default;
+
+ ember$data$lib$core$$default.RecordArray = ember$data$lib$system$record$arrays$record$array$$default;
+ ember$data$lib$core$$default.FilteredRecordArray = ember$data$lib$system$record$arrays$filtered$record$array$$default;
+ ember$data$lib$core$$default.AdapterPopulatedRecordArray = ember$data$lib$system$record$arrays$adapter$populated$record$array$$default;
+ ember$data$lib$core$$default.ManyArray = ember$data$lib$system$many$array$$default;
+
+ ember$data$lib$core$$default.RecordArrayManager = ember$data$lib$system$record$array$manager$$default;
+
+ ember$data$lib$core$$default.RESTAdapter = ember$data$lib$adapters$rest$adapter$$default;
+ ember$data$lib$core$$default.BuildURLMixin = ember$data$lib$adapters$build$url$mixin$$default;
+
+ ember$data$lib$core$$default.RESTSerializer = ember$data$lib$serializers$rest$serializer$$default;
+ ember$data$lib$core$$default.JSONSerializer = ember$data$lib$serializers$json$serializer$$default;
+
+ ember$data$lib$core$$default.Transform = ember$data$lib$transforms$base$$default;
+ ember$data$lib$core$$default.DateTransform = ember$data$lib$transforms$date$$default;
+ ember$data$lib$core$$default.StringTransform = ember$data$lib$transforms$string$$default;
+ ember$data$lib$core$$default.NumberTransform = ember$data$lib$transforms$number$$default;
+ ember$data$lib$core$$default.BooleanTransform = ember$data$lib$transforms$boolean$$default;
+
+ ember$data$lib$core$$default.ActiveModelAdapter = activemodel$adapter$lib$system$active$model$adapter$$default;
+ ember$data$lib$core$$default.ActiveModelSerializer = activemodel$adapter$lib$system$active$model$serializer$$default;
+ ember$data$lib$core$$default.EmbeddedRecordsMixin = ember$data$lib$serializers$embedded$records$mixin$$default;
+
+ ember$data$lib$core$$default.belongsTo = ember$data$lib$system$relationships$belongs$to$$default;
+ ember$data$lib$core$$default.hasMany = ember$data$lib$system$relationships$has$many$$default;
+
+ ember$data$lib$core$$default.Relationship = ember$data$lib$system$relationships$state$relationship$$default;
+
+ ember$data$lib$core$$default.ContainerProxy = ember$data$lib$system$container$proxy$$default;
+
+ ember$data$lib$core$$default._setupContainer = ember$data$lib$setup$container$$default;
+
+ Ember.defineProperty(ember$data$lib$core$$default, "normalizeModelName", {
+ enumerable: true,
+ writable: false,
+ configurable: false,
+ value: ember$data$lib$system$normalize$model$name$$default
+ });
+
+ var ember$data$lib$main$$fixtureAdapterWasDeprecated = false;
+
+ if (Ember.platform.hasPropertyAccessors) {
+ Ember.defineProperty(ember$data$lib$core$$default, "FixtureAdapter", {
+ get: function () {
+ if (!ember$data$lib$main$$fixtureAdapterWasDeprecated) {
+ ember$data$lib$main$$fixtureAdapterWasDeprecated = true;
+ }
+ return ember$data$lib$adapters$fixture$adapter$$default;
+ }
+ });
+ } else {
+ ember$data$lib$core$$default.FixtureAdapter = ember$data$lib$adapters$fixture$adapter$$default;
+ }
+
+ Ember.lookup.DS = ember$data$lib$core$$default;
+
+ var ember$data$lib$main$$default = ember$data$lib$core$$default;
+}).call(this);
diff --git a/website/source/assets/javascripts/lib/ember-data-1-0.min.js b/website/source/assets/javascripts/lib/ember-data-1-0.min.js
deleted file mode 100644
index 5b6e82280..000000000
--- a/website/source/assets/javascripts/lib/ember-data-1-0.min.js
+++ /dev/null
@@ -1,4 +0,0 @@
-(function(){"use strict";var e=Ember.get;var r=["description","fileName","lineNumber","message","name","number","stack"];function t(e){var t=Error.prototype.constructor.call(this,"The backend rejected the commit because it was invalid: "+Ember.inspect(e));this.errors=e;for(var i=0,n=r.length;i=t){o=0;s.push([])}o+=r;var i=s.length-1;s[i].push(e)});return s}var o=[];t.forEach(function(e,r){var t="&ids%5B%5D=".length;var i=a(e,n,t);v.call(i,function(e){o.push(e)})});return o},ajaxError:function(e,r,t){var i=e!==null&&typeof e==="object";if(i){e.then=null;if(!e.errorThrown){if(typeof t==="string"){e.errorThrown=new Error(t)}else{e.errorThrown=t}}}return e},ajaxSuccess:function(e,r){return r},ajax:function(e,r,i){var n=this;return new Ember.RSVP.Promise(function(a,o){var s=n.ajaxOptions(e,r,i);s.success=function(e,r,i){e=n.ajaxSuccess(i,e);if(e instanceof t){Ember.run(null,o,e)}else{Ember.run(null,a,e)}};s.error=function(e,r,t){Ember.run(null,o,n.ajaxError(e,e.responseText,t))};Ember.$.ajax(s)},"DS: RESTAdapter#ajax "+r+" to "+e)},ajaxOptions:function(e,r,t){var i=t||{};i.url=e;i.type=r;i.dataType="json";i.context=this;if(i.data&&r!=="GET"){i.contentType="application/json; charset=utf-8";i.data=JSON.stringify(i.data)}var n=m(this,"headers");if(n!==undefined){i.beforeSend=function(e){v.call(Ember.keys(n),function(r){e.setRequestHeader(r,n[r])})}}return i}});function b(e,r){if(typeof String.prototype.endsWith!=="function"){return e.indexOf(r,e.length-r.length)!==-1}else{return e.endsWith(r)}}var g=self.Ember;var R=g.String.capitalize;var E=/^\s*$/;var _=/(\w+[_-])([a-z\d]+$)/;var F=/(\w+)([A-Z][a-z\d]*$)/;var A=/[A-Z][a-z\d]*$/;function S(e,r){for(var t=0,i=r.length;tv;m--){i=r[m-1];p=i[0];if(p.test(e)){break}}i=i||[];p=i[0];n=i[1];a=e.replace(p,n);return a}};var C=T;function M(e){return C.inflector.pluralize(e)}function x(e){return C.inflector.singularize(e)}var w={plurals:[[/$/,"s"],[/s$/i,"s"],[/^(ax|test)is$/i,"$1es"],[/(octop|vir)us$/i,"$1i"],[/(octop|vir)i$/i,"$1i"],[/(alias|status)$/i,"$1es"],[/(bu)s$/i,"$1ses"],[/(buffal|tomat)o$/i,"$1oes"],[/([ti])um$/i,"$1a"],[/([ti])a$/i,"$1a"],[/sis$/i,"ses"],[/(?:([^f])fe|([lr])f)$/i,"$1$2ves"],[/(hive)$/i,"$1s"],[/([^aeiouy]|qu)y$/i,"$1ies"],[/(x|ch|ss|sh)$/i,"$1es"],[/(matr|vert|ind)(?:ix|ex)$/i,"$1ices"],[/^(m|l)ouse$/i,"$1ice"],[/^(m|l)ice$/i,"$1ice"],[/^(ox)$/i,"$1en"],[/^(oxen)$/i,"$1"],[/(quiz)$/i,"$1zes"]],singular:[[/s$/i,""],[/(ss)$/i,"$1"],[/(n)ews$/i,"$1ews"],[/([ti])a$/i,"$1um"],[/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i,"$1sis"],[/(^analy)(sis|ses)$/i,"$1sis"],[/([^f])ves$/i,"$1fe"],[/(hive)s$/i,"$1"],[/(tive)s$/i,"$1"],[/([lr])ves$/i,"$1f"],[/([^aeiouy]|qu)ies$/i,"$1y"],[/(s)eries$/i,"$1eries"],[/(m)ovies$/i,"$1ovie"],[/(x|ch|ss|sh)es$/i,"$1"],[/^(m|l)ice$/i,"$1ouse"],[/(bus)(es)?$/i,"$1"],[/(o)es$/i,"$1"],[/(shoe)s$/i,"$1"],[/(cris|test)(is|es)$/i,"$1is"],[/^(a)x[ie]s$/i,"$1xis"],[/(octop|vir)(us|i)$/i,"$1us"],[/(alias|status)(es)?$/i,"$1"],[/^(ox)en/i,"$1"],[/(vert|ind)ices$/i,"$1ex"],[/(matr)ices$/i,"$1ix"],[/(quiz)zes$/i,"$1"],[/(database)s$/i,"$1"]],irregularPairs:[["person","people"],["man","men"],["child","children"],["sex","sexes"],["move","moves"],["cow","kine"],["zombie","zombies"]],uncountable:["equipment","information","rice","money","species","series","fish","sheep","jeans","police"]};C.inflector=new C(w);function D(e,r){g.HTMLBars.helpers[e]=r}function P(e,r){g.HTMLBars.registerHelper(e,r)}function O(e,r){g.HTMLBars._registerHelper(e,r)}function I(e,r){if(g.HTMLBars){var t=g.HTMLBars.makeBoundHelper(r);if(g.HTMLBars._registerHelper){if(g.HTMLBars.helpers){D(e,t)}else{O(e,t)}}else if(g.HTMLBars.registerHelper){P(e,t)}}else if(g.Handlebars){g.Handlebars.helper(e,r)}}var $=I;$("singularize",function(e){return x(e[0])});$("pluralize",function(e){var r,t;if(e.length===1){t=e[0];return M(t)}else{r=e[0];t=e[1];if(r!==1){t=M(t)}return r+" "+t}});if(g.EXTEND_PROTOTYPES===true||g.EXTEND_PROTOTYPES.String){String.prototype.pluralize=function(){return M(this)};String.prototype.singularize=function(){return x(this)}}C.defaultRules=w;g.Inflector=C;g.String.pluralize=M;g.String.singularize=x;var L=C;if(typeof define!=="undefined"&&define.amd){define("ember-inflector",["exports"],function(e){e["default"]=C;return C})}else if(typeof module!=="undefined"&&module["exports"]){module["exports"]=C}var K=Ember.String.decamelize;var j=Ember.String.underscore;var B=y.extend({defaultSerializer:"-active-model",pathForType:function(e){var r=K(e);var t=j(r);return M(t)},ajaxError:function(e){var r=this._super.apply(this,arguments);if(e&&e.status===422){return new t(Ember.$.parseJSON(e.responseText))}else{return r}}});var U=B;var N=Ember.Object.extend({extract:null,serialize:null,normalize:function(e,r){return r}});var H=N;var V=Ember.get;var W=Ember.isNone;var q=Ember.ArrayPolyfills.map;var Q=Ember.merge;var X=H.extend({primaryKey:"id",applyTransforms:function(e,r){e.eachTransformedAttribute(function t(e,i){if(!r.hasOwnProperty(e)){return}var n=this.transformFor(i);r[e]=n.deserialize(r[e])},this);return r},normalize:function(e,r){if(!r){return r}this.normalizeId(r);this.normalizeAttributes(e,r);this.normalizeRelationships(e,r);this.normalizeUsingDeclaredMapping(e,r);this.applyTransforms(e,r);return r},normalizePayload:function(e){return e},normalizeAttributes:function(e,r){var t;if(this.keyForAttribute){e.eachAttribute(function(e){t=this.keyForAttribute(e);if(e===t){return}if(!r.hasOwnProperty(t)){return}r[e]=r[t];delete r[t]},this)}},normalizeRelationships:function(e,r){var t;if(this.keyForRelationship){e.eachRelationship(function(e,i){t=this.keyForRelationship(e,i.kind);if(e===t){return}if(!r.hasOwnProperty(t)){return}r[e]=r[t];delete r[t]},this)}},normalizeUsingDeclaredMapping:function(e,r){var t=V(this,"attrs");var i,n;if(t){for(n in t){i=this._getMappedKey(n);if(!r.hasOwnProperty(i)){continue}if(i!==n){r[n]=r[i];delete r[i]}}}},normalizeId:function(e){var r=V(this,"primaryKey");if(r==="id"){return}e.id=e[r];delete e[r]},normalizeErrors:function(e,r){this.normalizeId(r);this.normalizeAttributes(e,r);this.normalizeRelationships(e,r)},_getMappedKey:function(e){var r=V(this,"attrs");var t;if(r&&r[e]){t=r[e];if(t.key){t=t.key}if(typeof t==="string"){e=t}}return e},_canSerialize:function(e){var r=V(this,"attrs");return!r||!r[e]||r[e].serialize!==false},serialize:function(e,r){var t={};if(r&&r.includeId){var i=e.id;if(i){t[V(this,"primaryKey")]=i}}e.eachAttribute(function(r,i){this.serializeAttribute(e,t,r,i)},this);e.eachRelationship(function(r,i){if(i.kind==="belongsTo"){this.serializeBelongsTo(e,t,i)}else if(i.kind==="hasMany"){this.serializeHasMany(e,t,i)}},this);return t},serializeIntoHash:function(e,r,t,i){Q(e,this.serialize(t,i))},serializeAttribute:function(e,r,t,i){var n=i.type;if(this._canSerialize(t)){var a=e.attr(t);if(n){var o=this.transformFor(n);a=o.serialize(a)}var s=this._getMappedKey(t);if(s===t&&this.keyForAttribute){s=this.keyForAttribute(t)}r[s]=a}},serializeBelongsTo:function(e,r,t){var i=t.key;if(this._canSerialize(i)){var n=e.belongsTo(i,{id:true});var a=this._getMappedKey(i);if(a===i&&this.keyForRelationship){a=this.keyForRelationship(i,"belongsTo")}if(W(n)){r[a]=null}else{r[a]=n}if(t.options.polymorphic){this.serializePolymorphicType(e,r,t)}}},serializeHasMany:function(e,r,t){var i=t.key;if(this._canSerialize(i)){var n;n=this._getMappedKey(i);if(n===i&&this.keyForRelationship){n=this.keyForRelationship(i,"hasMany")}var a=e.type.determineRelationshipType(t);if(a==="manyToNone"||a==="manyToMany"){r[n]=e.hasMany(i,{ids:true})}}},serializePolymorphicType:Ember.K,extract:function(e,r,t,i,n){this.extractMeta(e,r,t);var a="extract"+n.charAt(0).toUpperCase()+n.substr(1);return this[a](e,r,t,i,n)},extractFindAll:function(e,r,t,i,n){return this.extractArray(e,r,t,i,n)},extractFindQuery:function(e,r,t,i,n){return this.extractArray(e,r,t,i,n)},extractFindMany:function(e,r,t,i,n){return this.extractArray(e,r,t,i,n)},extractFindHasMany:function(e,r,t,i,n){return this.extractArray(e,r,t,i,n)},extractCreateRecord:function(e,r,t,i,n){return this.extractSave(e,r,t,i,n)},extractUpdateRecord:function(e,r,t,i,n){return this.extractSave(e,r,t,i,n)},extractDeleteRecord:function(e,r,t,i,n){return this.extractSave(e,r,t,i,n)},extractFind:function(e,r,t,i,n){return this.extractSingle(e,r,t,i,n)},extractFindBelongsTo:function(e,r,t,i,n){return this.extractSingle(e,r,t,i,n)},extractSave:function(e,r,t,i,n){return this.extractSingle(e,r,t,i,n)},extractSingle:function(e,r,t,i,n){t=this.normalizePayload(t);return this.normalize(r,t)},extractArray:function(e,r,t,i,n){var a=this.normalizePayload(t);var o=this;return q.call(a,function(e){return o.normalize(r,e)})},extractMeta:function(e,r,t){if(t&&t.meta){e.setMetadataFor(r,t.meta);delete t.meta}},extractErrors:function(e,r,t,i){if(t&&typeof t==="object"&&t.errors){t=t.errors;this.normalizeErrors(r,t)}return t},keyForAttribute:function(e){return e},keyForRelationship:function(e,r){return e},transformFor:function(e,r){var t=this.container.lookup("transform:"+e);return t}});var G=Ember.ArrayPolyfills.forEach;var J=Ember.ArrayPolyfills.map;var Y=Ember.String.camelize;function Z(e){return e==null?null:e+""}var ee=X.extend({normalize:function(e,r,t){this.normalizeId(r);this.normalizeAttributes(e,r);this.normalizeRelationships(e,r);this.normalizeUsingDeclaredMapping(e,r);if(this.normalizeHash&&this.normalizeHash[t]){this.normalizeHash[t](r)}this.applyTransforms(e,r);return r},extractSingle:function(e,r,t,i){var n=this.normalizePayload(t);var a=r.typeKey;var o;for(var s in n){var u=this.typeForRoot(s);if(!e.modelFactoryFor(u)){continue}var c=e.modelFor(u);var l=c.typeKey===a;var d=n[s];if(d===null){continue}if(l&&Ember.typeOf(d)!=="array"){o=this.normalize(r,d,s);continue}G.call(d,function(r){var t=this.typeForRoot(s);var n=e.modelFor(t);var a=e.serializerFor(n);r=a.normalize(n,r,s);var u=l&&!i&&!o;var c=l&&Z(r.id)===i;if(u||c){o=r}else{e.push(t,r)}},this)}return o},extractArray:function(e,r,t){var i=this.normalizePayload(t);var n=r.typeKey;var a;for(var o in i){var s=o;var u=false;if(o.charAt(0)==="_"){u=true;s=o.substr(1)}var c=this.typeForRoot(s);if(!e.modelFactoryFor(c)){continue}var l=e.modelFor(c);var d=e.serializerFor(l);var h=!u&&l.typeKey===n;var f=J.call(i[o],function(e){return d.normalize(l,e,o)},this);if(h){a=f}else{e.pushMany(c,f)}}return a},pushPayload:function(e,r){var t=this.normalizePayload(r);for(var i in t){var n=this.typeForRoot(i);if(!e.modelFactoryFor(n,i)){continue}var a=e.modelFor(n);var o=e.serializerFor(a);var s=J.call(Ember.makeArray(t[i]),function(e){return o.normalize(a,e,i)},this);e.pushMany(n,s)}},typeForRoot:function(e){return Y(x(e))},serialize:function(e,r){return this._super.apply(this,arguments)},serializeIntoHash:function(e,r,t,i){e[r.typeKey]=this.serialize(t,i)},serializePolymorphicType:function(e,r,t){var i=t.key;var n=e.belongsTo(i);i=this.keyForAttribute?this.keyForAttribute(i):i;if(Ember.isNone(n)){r[i+"Type"]=null}else{r[i+"Type"]=Ember.String.camelize(n.typeKey)}}});var re=ee;var te=Ember.EnumerableUtils.forEach;var ie=Ember.String.camelize;var ne=Ember.String.capitalize;var ae=Ember.String.decamelize;var oe=Ember.String.underscore;var se=re.extend({keyForAttribute:function(e){return ae(e)},keyForRelationship:function(e,r){var t=ae(e);if(r==="belongsTo"){return t+"_id"}else if(r==="hasMany"){return x(t)+"_ids"}else{return t}},serializeHasMany:Ember.K,serializeIntoHash:function(e,r,t,i){var n=oe(ae(r.typeKey));e[n]=this.serialize(t,i)},serializePolymorphicType:function(e,r,t){var i=t.key;var n=e.belongsTo(i);var a=oe(i+"_type");if(Ember.isNone(n)){r[a]=null}else{r[a]=ne(ie(n.typeKey))}},normalize:function(e,r,t){this.normalizeLinks(r);return this._super(e,r,t)},normalizeLinks:function(e){if(e.links){var r=e.links;for(var t in r){var i=ie(t);if(i!==t){r[i]=r[t];delete r[t]}}}},normalizeRelationships:function(e,r){if(this.keyForRelationship){e.eachRelationship(function(e,t){var i,n;if(t.options.polymorphic){i=this.keyForAttribute(e);n=r[i];if(n&&n.type){n.type=this.typeForRoot(n.type)}else if(n&&t.kind==="hasMany"){var a=this;te(n,function(e){e.type=a.typeForRoot(e.type)})}}else{i=this.keyForRelationship(e,t.kind);if(!r.hasOwnProperty(i)){return}n=r[i]}r[e]=n;if(e!==i){delete r[i]}},this)}}});var ue=se;function ce(e){this.container=e}ce.prototype.aliasedFactory=function(e,r){var t=this;return{create:function(){if(r){r()}return t.container.lookup(e)}}};ce.prototype.registerAlias=function(e,r,t){var i=this.aliasedFactory(r,t);return this.container.register(e,i)};ce.prototype.registerDeprecation=function(e,r){var t=function(){};return this.registerAlias(e,r,t)};ce.prototype.registerDeprecations=function(e){var r,t,i,n;for(r=e.length;r>0;r--){t=e[r-1];i=t["deprecated"];n=t["valid"];this.registerDeprecation(i,n)}};var le=ce;function de(e,r){var t=new le(e);t.registerDeprecations([{deprecated:"serializer:_ams",valid:"serializer:-active-model"},{deprecated:"adapter:_ams",valid:"adapter:-active-model"}]);e.register("serializer:-active-model",ue);e.register("adapter:-active-model",U)}var he=de;var fe=Ember.Namespace.create({VERSION:"1.0.0-beta.16.1"});if(Ember.libraries){Ember.libraries.registerCoreLibrary("Ember Data",fe.VERSION)}var pe=fe;var me=Ember.RSVP.Promise;var ve=Ember.get;var ye=Ember.ArrayProxy.extend(Ember.PromiseProxyMixin);var be=Ember.ObjectProxy.extend(Ember.PromiseProxyMixin);var ge=function(e,r){return be.create({promise:me.resolve(e,r)})};var Re=function(e,r){return ye.create({promise:me.resolve(e,r)})};function Ee(e){return function(){var r=ve(this,"content");return r[e].apply(r,arguments)}}var _e=ye.extend({reload:function(){return _e.create({promise:ve(this,"content").reload()})},createRecord:Ee("createRecord"),on:Ee("on"),one:Ee("one"),trigger:Ee("trigger"),off:Ee("off"),has:Ee("has")});var Fe=function(e,r){return _e.create({promise:me.resolve(e,r)})};var Ae=Ember.get;function Se(e){var r=Array.prototype.slice.call(arguments,1);return function(){return e.apply(undefined,r)}}function ze(e,r){var t=e["finally"](function(){if(!r()){t._subscribers.length=0}});return t}function Te(e){return!(Ae(e,"isDestroyed")||Ae(e,"isDestroying"))}function ke(e,r,t){var i=r.serializer;if(i===undefined){i=e.serializerFor(t)}if(i===null||i===undefined){i={extract:function(e,r,t){return t}}}return i}var Ce=Ember.get;var Me=Ember.RSVP.Promise;function xe(e,r,t,i,n){var a=n._createSnapshot();var o=e.find(r,t,i,a);var s=ke(r,e,t);var u="DS: Handle Adapter#find of "+t+" with id: "+i;o=Me.cast(o,u);o=ze(o,Se(Te,r));return o.then(function(e){return r._adapterRun(function(){var n=s.extract(r,t,e,i,"find");return r.push(t,n)})},function(e){var n=r.getById(t,i);if(n){n.notFound();if(Ce(n,"isEmpty")){r.unloadRecord(n)}}throw e},"DS: Extract payload of '"+t+"'")}function we(e,r,t,i,n){var a=Ember.A(n).invoke("_createSnapshot");var o=e.findMany(r,t,i,a);var s=ke(r,e,t);var u="DS: Handle Adapter#findMany of "+t;if(o===undefined){throw new Error("adapter.findMany returned undefined, this was very likely a mistake")}o=Me.cast(o,u);o=ze(o,Se(Te,r));return o.then(function(e){return r._adapterRun(function(){var i=s.extract(r,t,e,null,"findMany");return r.pushMany(t,i)})},null,"DS: Extract payload of "+t)}function De(e,r,t,i,n){var a=t._createSnapshot();var o=e.findHasMany(r,a,i,n);var s=ke(r,e,n.type);var u="DS: Handle Adapter#findHasMany of "+t+" : "+n.type;o=Me.cast(o,u);o=ze(o,Se(Te,r));o=ze(o,Se(Te,t));return o.then(function(e){return r._adapterRun(function(){var t=s.extract(r,n.type,e,null,"findHasMany");var i=r.pushMany(n.type,t);return i})},null,"DS: Extract payload of "+t+" : hasMany "+n.type)}function Pe(e,r,t,i,n){var a=t._createSnapshot();var o=e.findBelongsTo(r,a,i,n);var s=ke(r,e,n.type);var u="DS: Handle Adapter#findBelongsTo of "+t+" : "+n.type;o=Me.cast(o,u);o=ze(o,Se(Te,r));o=ze(o,Se(Te,t));return o.then(function(e){return r._adapterRun(function(){var t=s.extract(r,n.type,e,null,"findBelongsTo");if(!t){return null}var i=r.push(n.type,t);return i})},null,"DS: Extract payload of "+t+" : "+n.type)}function Oe(e,r,t,i){var n=e.findAll(r,t,i);var a=ke(r,e,t);var o="DS: Handle Adapter#findAll of "+t;n=Me.cast(n,o);n=ze(n,Se(Te,r));return n.then(function(e){r._adapterRun(function(){var i=a.extract(r,t,e,null,"findAll");r.pushMany(t,i)});r.didUpdateAll(t);return r.all(t)},null,"DS: Extract payload of findAll "+t)}function Ie(e,r,t,i,n){var a=e.findQuery(r,t,i,n);var o=ke(r,e,t);var s="DS: Handle Adapter#findQuery of "+t;a=Me.cast(a,s);a=ze(a,Se(Te,r));return a.then(function(e){var i;r._adapterRun(function(){i=o.extract(r,t,e,null,"findQuery")});n.load(i);return n},null,"DS: Extract payload of findQuery "+t)}var $e=Ember.get;var Le=Ember.set;var Ke=Ember.ArrayProxy.extend(Ember.Evented,{type:null,content:null,isLoaded:false,isUpdating:false,store:null,objectAtContent:function(e){var r=$e(this,"content");return r.objectAt(e)},update:function(){if($e(this,"isUpdating")){return}var e=$e(this,"store");var r=$e(this,"type");return e.fetchAll(r,this)},addRecord:function(e,r){var t=$e(this,"content");if(r===undefined){t.addObject(e)}else if(!t.contains(e)){t.insertAt(r,e)}},_pushRecord:function(e){$e(this,"content").pushObject(e)},pushRecord:function(e){this._pushRecord(e)},removeRecord:function(e){$e(this,"content").removeObject(e)},save:function(){var e=this;var r="DS: RecordArray#save "+$e(this,"type");var t=Ember.RSVP.all(this.invoke("save"),r).then(function(r){return e},null,"DS: RecordArray#save return RecordArray");return ye.create({promise:t})},_dissociateFromOwnRecords:function(){var e=this;this.forEach(function(r){var t=r._recordArrays;if(t){t["delete"](e)}})},_unregisterFromManager:function(){var e=$e(this,"manager");if(e){e.unregisterFilteredRecordArray(this)}},willDestroy:function(){this._unregisterFromManager();this._dissociateFromOwnRecords();Le(this,"content",undefined);this._super.apply(this,arguments)}});var je=Ember.get;var Be=Ke.extend({filterFunction:null,isLoaded:true,replace:function(){var e=je(this,"type").toString();throw new Error("The result of a client-side filter (on "+e+") is immutable.")},_updateFilter:function(){var e=je(this,"manager");e.updateFilter(this,je(this,"type"),je(this,"filterFunction"))},updateFilter:Ember.observer(function(){Ember.run.once(this,this._updateFilter)},"filterFunction")});var Ue=Ember.get;function Ne(e){var r=Ember.create(null);for(var t in e){r[t]=e[t]}return r}var He=Ke.extend({query:null,replace:function(){var e=Ue(this,"type").toString();throw new Error("The result of a server query (on "+e+") is immutable.")},load:function(e){var r=Ue(this,"store");var t=Ue(this,"type");var i=r.pushMany(t,e);var n=r.metadataFor(t);this.setProperties({content:Ember.A(i),isLoaded:true,meta:Ne(n)});i.forEach(function(e){this.manager.recordArraysForRecord(e).add(this)},this);Ember.run.once(this,"trigger","didLoad")}});var Ve=Ember.OrderedSet;var We=Ember.guidFor;var qe=function(){this._super$constructor()};qe.create=function(){var e=this;return new e};qe.prototype=Ember.create(Ve.prototype);qe.prototype.constructor=qe;qe.prototype._super$constructor=Ve;qe.prototype.addWithIndex=function(e,r){var t=We(e);var i=this.presenceSet;var n=this.list;if(i[t]===true){return}i[t]=true;if(r===undefined||r==null){n.push(e)}else{n.splice(r,0,e)}this.size+=1;return this};var Qe=qe;var Xe=Ember.get;var Ge=Ember.EnumerableUtils.forEach;var Je=Ember.EnumerableUtils.indexOf;var Ye=Ember.Object.extend({init:function(){this.filteredRecordArrays=d.create({defaultValue:function(){return[]}});this.changedRecords=[];this._adapterPopulatedRecordArrays=[]},recordDidChange:function(e){if(this.changedRecords.push(e)!==1){return}Ember.run.schedule("actions",this,this.updateRecordArrays)},recordArraysForRecord:function(e){e._recordArrays=e._recordArrays||Qe.create();return e._recordArrays},updateRecordArrays:function(){Ge(this.changedRecords,function(e){if(Xe(e,"isDeleted")){this._recordWasDeleted(e)}else{this._recordWasChanged(e)}},this);this.changedRecords.length=0},_recordWasDeleted:function(e){var r=e._recordArrays;if(!r){return}r.forEach(function(r){r.removeRecord(e)});e._recordArrays=null},_recordWasChanged:function(e){var r=e.constructor;var t=this.filteredRecordArrays.get(r);var i;Ge(t,function(t){i=Xe(t,"filterFunction");if(i){this.updateRecordArray(t,i,r,e)}},this)},recordWasLoaded:function(e){var r=e.constructor;var t=this.filteredRecordArrays.get(r);var i;Ge(t,function(t){i=Xe(t,"filterFunction");this.updateRecordArray(t,i,r,e)},this)},updateRecordArray:function(e,r,t,i){var n;if(!r){n=true}else{n=r(i)}var a=this.recordArraysForRecord(i);if(n){if(!a.has(e)){e._pushRecord(i);a.add(e)}}else if(!n){a["delete"](e);e.removeRecord(i)}},updateFilter:function(e,r,t){var i=this.store.typeMapFor(r);var n=i.records;var a;for(var o=0,s=n.length;o0;if(!i){e.send("rolledBack")}},pushedData:Ember.K,becomeDirty:Ember.K,willCommit:function(e){e.transitionTo("inFlight")},reloadRecord:function(e,r){r(rr(e,"store").reloadRecord(e))},rolledBack:function(e){e.transitionTo("loaded.saved")},becameInvalid:function(e){e.transitionTo("invalid")},rollback:function(e){e.rollback();e.triggerLater("ready")}},inFlight:{isSaving:true,didSetProperty:ir,becomeDirty:Ember.K,pushedData:Ember.K,unloadRecord:function(e){},willCommit:Ember.K,didCommit:function(e){var r=rr(this,"dirtyType");e.transitionTo("saved");e.send("invokeLifecycleCallbacks",r)},becameInvalid:function(e){e.transitionTo("invalid");e.send("invokeLifecycleCallbacks")},becameError:function(e){e.transitionTo("uncommitted");e.triggerLater("becameError",e)}},invalid:{isValid:false,deleteRecord:function(e){e.transitionTo("deleted.uncommitted");e.disconnectRelationships()},didSetProperty:function(e,r){rr(e,"errors").remove(r.name);ir(e,r)},becomeDirty:Ember.K,willCommit:function(e){rr(e,"errors").clear();e.transitionTo("inFlight")},rolledBack:function(e){rr(e,"errors").clear();e.triggerLater("ready")},becameValid:function(e){e.transitionTo("uncommitted")},invokeLifecycleCallbacks:function(e){e.triggerLater("becameInvalid",e)},exit:function(e){e._inFlightAttributes={}}}};function ar(e){var r={};var t;for(var i in e){t=e[i];if(t&&typeof t==="object"){r[i]=ar(t)}else{r[i]=t}}return r}function or(e,r){for(var t in r){e[t]=r[t]}return e}function sr(e){var r=ar(nr);return or(r,e)}var ur=sr({dirtyType:"created",isNew:true});ur.uncommitted.rolledBack=function(e){e.transitionTo("deleted.saved")};var cr=sr({dirtyType:"updated"});ur.uncommitted.deleteRecord=function(e){e.disconnectRelationships();e.transitionTo("deleted.saved");e.send("invokeLifecycleCallbacks");
-
-};ur.uncommitted.rollback=function(e){nr.uncommitted.rollback.apply(this,arguments);e.transitionTo("deleted.saved")};ur.uncommitted.pushedData=function(e){e.transitionTo("loaded.updated.uncommitted");e.triggerLater("didLoad")};ur.uncommitted.propertyWasReset=Ember.K;function lr(e){}cr.inFlight.unloadRecord=lr;cr.uncommitted.deleteRecord=function(e){e.transitionTo("deleted.uncommitted");e.disconnectRelationships()};var dr={isEmpty:false,isLoading:false,isLoaded:false,isDirty:false,isSaving:false,isDeleted:false,isNew:false,isValid:true,rolledBack:Ember.K,unloadRecord:function(e){e.clearRelationships();e.transitionTo("deleted.saved")},propertyWasReset:Ember.K,empty:{isEmpty:true,loadingData:function(e,r){e._loadingPromise=r;e.transitionTo("loading")},loadedData:function(e){e.transitionTo("loaded.created.uncommitted");e.triggerLater("ready")},pushedData:function(e){e.transitionTo("loaded.saved");e.triggerLater("didLoad");e.triggerLater("ready")}},loading:{isLoading:true,exit:function(e){e._loadingPromise=null},pushedData:function(e){e.transitionTo("loaded.saved");e.triggerLater("didLoad");e.triggerLater("ready");tr(e,"isError",false)},becameError:function(e){e.triggerLater("becameError",e)},notFound:function(e){e.transitionTo("empty")}},loaded:{initialState:"saved",isLoaded:true,loadingData:Ember.K,saved:{setup:function(e){var r=e._attributes;var t=Ember.keys(r).length>0;if(t){e.adapterDidDirty()}},didSetProperty:ir,pushedData:Ember.K,becomeDirty:function(e){e.transitionTo("updated.uncommitted")},willCommit:function(e){e.transitionTo("updated.inFlight")},reloadRecord:function(e,r){r(rr(e,"store").reloadRecord(e))},deleteRecord:function(e){e.transitionTo("deleted.uncommitted");e.disconnectRelationships()},unloadRecord:function(e){e.clearRelationships();e.transitionTo("deleted.saved")},didCommit:function(e){e.send("invokeLifecycleCallbacks",rr(e,"lastDirtyType"))},notFound:Ember.K},created:ur,updated:cr},deleted:{initialState:"uncommitted",dirtyType:"deleted",isDeleted:true,isLoaded:true,isDirty:true,setup:function(e){e.updateRecordArrays()},uncommitted:{willCommit:function(e){e.transitionTo("inFlight")},rollback:function(e){e.rollback();e.triggerLater("ready")},becomeDirty:Ember.K,deleteRecord:Ember.K,rolledBack:function(e){e.transitionTo("loaded.saved");e.triggerLater("ready")}},inFlight:{isSaving:true,unloadRecord:lr,willCommit:Ember.K,didCommit:function(e){e.transitionTo("saved");e.send("invokeLifecycleCallbacks")},becameError:function(e){e.transitionTo("uncommitted");e.triggerLater("becameError",e)},becameInvalid:function(e){e.transitionTo("invalid");e.triggerLater("becameInvalid",e)}},saved:{isDirty:false,setup:function(e){var r=rr(e,"store");r._dematerializeRecord(e)},invokeLifecycleCallbacks:function(e){e.triggerLater("didDelete",e);e.triggerLater("didCommit",e)},willCommit:Ember.K,didCommit:Ember.K},invalid:{isValid:false,didSetProperty:function(e,r){rr(e,"errors").remove(r.name);ir(e,r)},deleteRecord:Ember.K,becomeDirty:Ember.K,willCommit:Ember.K,rolledBack:function(e){rr(e,"errors").clear();e.transitionTo("loaded.saved");e.triggerLater("ready")},becameValid:function(e){e.transitionTo("uncommitted")}}},invokeLifecycleCallbacks:function(e,r){if(r==="created"){e.triggerLater("didCreate",e)}else{e.triggerLater("didUpdate",e)}e.triggerLater("didCommit",e)}};function hr(e,r,t){e=or(r?Ember.create(r):{},e);e.parentState=r;e.stateName=t;for(var i in e){if(!e.hasOwnProperty(i)||i==="parentState"||i==="stateName"){continue}if(typeof e[i]==="object"){e[i]=hr(e[i],e,t+"."+i)}}return e}dr=hr(dr,null,"root");var fr=dr;var pr=Ember.get;var mr=Ember.isEmpty;var vr=Ember.EnumerableUtils.map;var yr=Ember.Object.extend(Ember.Enumerable,Ember.Evented,{registerHandlers:function(e,r,t){this.on("becameInvalid",e,r);this.on("becameValid",e,t)},errorsByAttributeName:Ember.reduceComputed("content",{initialValue:function(){return d.create({defaultValue:function(){return Ember.A()}})},addedItem:function(e,r){e.get(r.attribute).pushObject(r);return e},removedItem:function(e,r){e.get(r.attribute).removeObject(r);return e}}),errorsFor:function(e){return pr(this,"errorsByAttributeName").get(e)},messages:Ember.computed.mapBy("content","message"),content:Ember.computed(function(){return Ember.A()}),unknownProperty:function(e){var r=this.errorsFor(e);if(mr(r)){return null}return r},nextObject:function(e,r,t){return pr(this,"content").objectAt(e)},length:Ember.computed.oneWay("content.length").readOnly(),isEmpty:Ember.computed.not("length").readOnly(),add:function(e,r){var t=pr(this,"isEmpty");r=this._findOrCreateMessages(e,r);pr(this,"content").addObjects(r);this.notifyPropertyChange(e);this.enumerableContentDidChange();if(t&&!pr(this,"isEmpty")){this.trigger("becameInvalid")}},_findOrCreateMessages:function(e,r){var t=this.errorsFor(e);return vr(Ember.makeArray(r),function(r){return t.findBy("message",r)||{attribute:e,message:r}})},remove:function(e){if(pr(this,"isEmpty")){return}var r=pr(this,"content").rejectBy("attribute",e);pr(this,"content").setObjects(r);this.notifyPropertyChange(e);this.enumerableContentDidChange();if(pr(this,"isEmpty")){this.trigger("becameValid")}},clear:function(){if(pr(this,"isEmpty")){return}pr(this,"content").clear();this.enumerableContentDidChange();this.trigger("becameValid")},has:function(e){return!mr(this.errorsFor(e))}});function br(e,r){if(!r||typeof r!=="object"){return e}var t=Ember.keys(r);var i;var n=t.length;for(var a=0;a0){r=e[0];this.removeRecord(r)}},disconnect:function(){this.members.forEach(function(e){this.removeRecordFromInverse(e)},this)},reconnect:function(){this.members.forEach(function(e){this.addRecordToInverse(e)},this)},removeRecords:function(e){var r=this;Rr(e,function(e){r.removeRecord(e)})},addRecords:function(e,r){var t=this;Rr(e,function(e){t.addRecord(e,r);if(r!==undefined){r++}})},addCanonicalRecords:function(e,r){for(var t=0;t0){i=this.currentState.slice(e,e+r);this.get("relationship").removeRecords(i)}if(t){this.get("relationship").addRecords(t,e)}},promise:null,loadingRecordsCount:function(e){this.loadingRecordsCount=e},loadedRecord:function(){this.loadingRecordsCount--;if(this.loadingRecordsCount===0){Ar(this,"isLoaded",true);this.trigger("didLoad")}},reload:function(){return this.relationship.reload()},save:function(){var e=this;var r="DS: ManyArray#save "+Fr(this,"type");var t=Ember.RSVP.all(this.invoke("save"),r).then(function(r){return e},null,"DS: ManyArray#save return ManyArray");return ye.create({promise:t})},createRecord:function(e){var r=Fr(this,"store");var t=Fr(this,"type");var i;i=r.createRecord(t,e);this.pushObject(i);return i},addRecord:function(e){this.addObject(e)},removeRecord:function(e){this.removeObject(e)}});var Tr=function(e,r,t,i){this._super$constructor(e,r,t,i);this.belongsToType=i.type;this.canonicalState=[];this.manyArray=zr.create({canonicalState:this.canonicalState,store:this.store,relationship:this,type:this.belongsToType,record:r});this.isPolymorphic=i.options.polymorphic;this.manyArray.isPolymorphic=this.isPolymorphic};Tr.prototype=Ember.create(_r.prototype);Tr.prototype.constructor=Tr;Tr.prototype._super$constructor=_r;Tr.prototype.destroy=function(){this.manyArray.destroy()};Tr.prototype._super$addCanonicalRecord=_r.prototype.addCanonicalRecord;Tr.prototype.addCanonicalRecord=function(e,r){if(this.canonicalMembers.has(e)){return}if(r!==undefined){this.canonicalState.splice(r,0,e)}else{this.canonicalState.push(e)}this._super$addCanonicalRecord(e,r)};Tr.prototype._super$addRecord=_r.prototype.addRecord;Tr.prototype.addRecord=function(e,r){if(this.members.has(e)){return}this._super$addRecord(e,r);this.manyArray.internalAddRecords([e],r)};Tr.prototype._super$removeCanonicalRecordFromOwn=_r.prototype.removeCanonicalRecordFromOwn;Tr.prototype.removeCanonicalRecordFromOwn=function(e,r){var t=r;if(!this.canonicalMembers.has(e)){return}if(t===undefined){t=this.canonicalState.indexOf(e)}if(t>-1){this.canonicalState.splice(t,1)}this._super$removeCanonicalRecordFromOwn(e,r)};Tr.prototype._super$flushCanonical=_r.prototype.flushCanonical;Tr.prototype.flushCanonical=function(){this.manyArray.flushCanonical();this._super$flushCanonical()};Tr.prototype._super$removeRecordFromOwn=_r.prototype.removeRecordFromOwn;Tr.prototype.removeRecordFromOwn=function(e,r){if(!this.members.has(e)){return}this._super$removeRecordFromOwn(e,r);if(r!==undefined){this.manyArray.currentState.removeAt(r)}else{this.manyArray.internalRemoveRecords([e])}};Tr.prototype.notifyRecordRelationshipAdded=function(e,r){var t=this.relationshipMeta.type;this.record.notifyHasManyAdded(this.key,e,r)};Tr.prototype.reload=function(){var e=this;if(this.link){return this.fetchLink()}else{return this.store.scheduleFetchMany(this.manyArray.toArray()).then(function(){e.manyArray.set("isLoaded",true);return e.manyArray})}};Tr.prototype.computeChanges=function(e){var r=this.canonicalMembers;var t=[];var i;var n;var a;e=kr(e);r.forEach(function(r){if(e.has(r)){return}t.push(r)});this.removeCanonicalRecords(t);e=e.toArray();i=e.length;for(a=0;a1){var i=rt(this,e);if(t!==i){this._attributes[e]=t;this.send("didSetProperty",{name:e,oldValue:i,originalValue:this._data[e],value:t})}return t}else if(et(this,e)){return rt(this,e)}else{return Zr(this,r,e)}}).meta(t)}var it=tt;var nt=Jr;var at=Ember.__loader.require("backburner")["default"]||Ember.__loader.require("backburner")["Backburner"];if(!at.prototype.join){var ot=function(e){return typeof e==="string"};at.prototype.join=function(){var e,r;if(this.currentInstance){var t=arguments.length;if(t===1){e=arguments[0];r=null}else{r=arguments[0];e=arguments[1]}if(ot(e)){e=r[e]}if(t===1){return e()}else if(t===2){return e.call(r)}else{var i=new Array(t-2);for(var n=0,a=t-2;n1){we(i,t,r,d,l).then(s).then(u(l)).then(null,c(l))}else if(d.length===1){var h=Ember.A(e).findBy("record",a[0]);o(h)}else{}})}else{dt(e,o)}},getById:function(e,r){if(this.hasRecordForId(e,r)){return this.recordForId(e,r)}else{return null}},reloadRecord:function(e){var r=e.constructor;var t=this.adapterFor(r);var i=st(e,"id");return this.scheduleFetch(e)},hasRecordForId:function(e,r){var t=this.modelFor(e);var i=gt(r);var n=this.typeMapFor(t).idToRecord[i];return!!n&&st(n,"isLoaded")},recordForId:function(e,r){var t=this.modelFor(e);var i=gt(r);var n=this.typeMapFor(t).idToRecord;var a=n[i];if(!a||!n[i]){a=this.buildRecord(t,i)}return a},findMany:function(e){var r=this;return pt.all(ft(e,function(e){return r._findByRecord(e)}))},findHasMany:function(e,r,t){var i=this.adapterFor(e.constructor);return De(i,this,e,r,t)},findBelongsTo:function(e,r,t){var i=this.adapterFor(e.constructor);return Pe(i,this,e,r,t)},findQuery:function(e,r){var t=this.modelFor(e);var i=this.recordArrayManager.createAdapterPopulatedRecordArray(t,r);var n=this.adapterFor(t);return Re(Ie(n,this,t,r,i))},findAll:function(e){return this.fetchAll(e)},_fetchAll:function(e,r){var t=this.adapterFor(e);var i=this.typeMapFor(e).metadata.since;ut(r,"isUpdating",true);return Re(Oe(t,this,e,i))},didUpdateAll:function(e){var r=this.typeMapFor(e).findAllCache;ut(r,"isUpdating",false)},all:function(e){var r=this.modelFor(e);var t=this.typeMapFor(r);var i=t.findAllCache;if(i){this.recordArrayManager.updateFilter(i,r);return i}var n=this.recordArrayManager.createRecordArray(r);t.findAllCache=n;return n},unloadAll:function(e){var r=this.modelFor(e);var t=this.typeMapFor(r);var i=t.records.slice();var n;for(var a=0;ai.attributeLimit){return false}var a=Ht(Vt(n).replace("_"," "));r.push({name:n,desc:a})});return r},getRecords:function(e){return this.get("store").all(e)},getRecordColumnValues:function(e){var r=this;var t=0;var i={id:Nt(e,"id")};e.eachAttribute(function(n){if(t++>r.attributeLimit){return false}var a=Nt(e,n);i[n]=a});return i},getRecordKeywords:function(e){var r=[];var t=Ember.A(["id"]);e.eachAttribute(function(e){t.push(e)});t.forEach(function(t){r.push(Nt(e,t))});return r},getRecordFilterValues:function(e){return{isNew:e.get("isNew"),isModified:e.get("isDirty")&&!e.get("isNew"),isClean:!e.get("isDirty")}},getRecordColor:function(e){var r="black";if(e.get("isNew")){r="green"}else if(e.get("isDirty")){r="blue"}return r},observeRecord:function(e,r){var t=Ember.A();var i=this;var n=Ember.A(["id","isNew","isDirty"]);e.eachAttribute(function(e){n.push(e)});n.forEach(function(n){var a=function(){r(i.wrapRecord(e))};Ember.addObserver(e,n,a);t.push(function(){Ember.removeObserver(e,n,a)})});var a=function(){t.forEach(function(e){e()})};return a}});function qt(e){e.register("data-adapter:main",Wt)}var Qt=qt;function Xt(e,r){Qt(e,r);jt(e,r);Ut(e,r);Ct(e,r);he(e,r)}var Gt=Xt;var Jt=Ember.K;Ember.onLoad("Ember.Application",function(e){e.initializer({name:"ember-data",initialize:Gt});e.initializer({name:"store",after:"ember-data",initialize:Jt});e.initializer({name:"activeModelAdapter",before:"store",initialize:Jt});e.initializer({name:"transforms",before:"store",initialize:Jt});e.initializer({name:"data-adapter",before:"store",initialize:Jt});e.initializer({name:"injectStore",before:"store",initialize:Jt})});Ember.Date=Ember.Date||{};var Yt=Date.parse;var Zt=[1,4,5,6,7,10,11];Ember.Date.parse=function(e){var r,t;var i=0;if(t=/^(\d{4}|[+\-]\d{6})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?(?:(Z)|([+\-])(\d{2})(?::(\d{2}))?)?)?$/.exec(e)){for(var n=0,a;a=Zt[n];++n){t[a]=+t[a]||0}t[2]=(+t[2]||1)-1;t[3]=+t[3]||1;if(t[8]!=="Z"&&t[9]!==undefined){i=t[10]*60+t[11];if(t[9]==="+"){i=0-i}}r=Date.UTC(t[1],t[2],t[3],t[4],t[5]+i,t[6],t[7])}else{r=Yt?Yt(e):NaN}return r};if(Ember.EXTEND_PROTOTYPES===true||Ember.EXTEND_PROTOTYPES.Date){Date.parse=Ember.Date.parse}nt.reopen({_debugInfo:function(){var e=["id"];var r={belongsTo:[],hasMany:[]};var t=[];this.eachAttribute(function(r,t){e.push(r)},this);this.eachRelationship(function(e,i){r[i.kind].push(e);t.push(e)});var i=[{name:"Attributes",properties:e,expand:true},{name:"Belongs To",properties:r.belongsTo,expand:true},{name:"Has Many",properties:r.hasMany,expand:true},{name:"Flags",properties:["isLoaded","isDirty","isSaving","isDeleted","isError","isNew","isValid"]}];return{propertyInfo:{includeOtherProperties:true,groups:i,expensiveProperties:t}}}});var ei=nt;var ri=Wt;var ti=Ember.get;var ii=Ember.EnumerableUtils.forEach;var ni=Ember.String.camelize;var ai=Ember.Mixin.create({normalize:function(e,r,t){var i=this._super(e,r,t);return oi(this,this.store,e,i)},keyForRelationship:function(e,r){if(this.hasDeserializeRecordsOption(e)){return this.keyForAttribute(e)}else{return this._super(e,r)||e}},serializeBelongsTo:function(e,r,t){var i=t.key;if(this.noSerializeOptionSpecified(i)){this._super(e,r,t);return}var n=this.hasSerializeIdsOption(i);var a=this.hasSerializeRecordsOption(i);var o=e.belongsTo(i);var s;if(n){s=this.keyForRelationship(i,t.kind);if(!o){r[s]=null}else{r[s]=o.id}}else if(a){s=this.keyForAttribute(i);if(!o){r[s]=null}else{r[s]=o.record.serialize({includeId:true});this.removeEmbeddedForeignKey(e,o,t,r[s])}}},serializeHasMany:function(e,r,t){var i=t.key;if(this.noSerializeOptionSpecified(i)){this._super(e,r,t);return}var n=this.hasSerializeIdsOption(i);var a=this.hasSerializeRecordsOption(i);var o;if(n){o=this.keyForRelationship(i,t.kind);r[o]=e.hasMany(i,{ids:true})}else if(a){o=this.keyForAttribute(i);r[o]=e.hasMany(i).map(function(r){var i=r.record.serialize({includeId:true});this.removeEmbeddedForeignKey(e,r,t,i);return i},this)}},removeEmbeddedForeignKey:function(e,r,t,i){if(t.kind==="hasMany"){return}else if(t.kind==="belongsTo"){var n=e.type.inverseFor(t.key);if(n){var a=n.name;var o=this.store.serializerFor(r.type);var s=o.keyForRelationship(a,n.kind);if(s){delete i[s]}}}},hasEmbeddedAlwaysOption:function(e){var r=this.attrsOption(e);return r&&r.embedded==="always"},hasSerializeRecordsOption:function(e){var r=this.hasEmbeddedAlwaysOption(e);var t=this.attrsOption(e);return r||t&&t.serialize==="records"},hasSerializeIdsOption:function(e){var r=this.attrsOption(e);return r&&(r.serialize==="ids"||r.serialize==="id")},noSerializeOptionSpecified:function(e){var r=this.attrsOption(e);return!(r&&(r.serialize||r.embedded))},hasDeserializeRecordsOption:function(e){var r=this.hasEmbeddedAlwaysOption(e);var t=this.attrsOption(e);return r||t&&t.deserialize==="records"},attrsOption:function(e){var r=this.get("attrs");return r&&(r[ni(e)]||r[e])}});function oi(e,r,t,i){t.eachRelationship(function(t,n){if(e.hasDeserializeRecordsOption(t)){var a=r.modelFor(n.type.typeKey);if(n.kind==="hasMany"){if(n.options.polymorphic){ui(r,t,i)}else{si(r,t,a,i)}}if(n.kind==="belongsTo"){if(n.options.polymorphic){li(r,t,i)}else{ci(r,t,a,i)}}}});return i}function si(e,r,t,i){if(!i[r]){return i}var n=[];var a=e.serializerFor(t.typeKey);ii(i[r],function(r){var i=a.normalize(t,r,null);e.push(t,i);n.push(i.id)});i[r]=n;return i}function ui(e,r,t){if(!t[r]){return t}var i=[];ii(t[r],function(r){var t=r.type;var n=e.serializerFor(t);var a=e.modelFor(t);var o=ti(n,"primaryKey");var s=n.normalize(a,r,null);e.push(a,s);i.push({id:s[o],type:t})});t[r]=i;return t}function ci(e,r,t,i){if(!i[r]){return i}var n=e.serializerFor(t.typeKey);var a=n.normalize(t,i[r],null);e.push(t,a);i[r]=a.id;return i}function li(e,r,t){if(!t[r]){return t}var i=t[r];var n=i.type;var a=e.serializerFor(n);var o=e.modelFor(n);var s=ti(a,"primaryKey");var u=a.normalize(o,i,null);e.push(o,u);t[r]=u[s];t[r+"Type"]=n;return t}var di=ai;function hi(e,r){if(typeof e==="object"){r=e;e=undefined}r=r||{};var t={type:e,isRelationship:true,options:r,kind:"belongsTo",key:null};return Ember.computed(function(e,r){if(arguments.length>1){if(r===undefined){r=null}if(r&&r.then){this._relationships[e].setRecordPromise(r)}else{this._relationships[e].setRecord(r)}}return this._relationships[e].getRecord()}).meta(t)}nt.reopen({notifyBelongsToChanged:function(e){this.notifyPropertyChange(e)}});var fi=hi;function pi(e,r){if(typeof e==="object"){r=e;e=undefined}r=r||{};var t={type:e,isRelationship:true,options:r,kind:"hasMany",key:null};return Ember.computed(function(e){var r=this._relationships[e];return r.getRecords()}).meta(t).readOnly()}nt.reopen({notifyHasManyAdded:function(e){this.notifyPropertyChange(e)}});var mi=pi;function vi(e,r){var t,i;t=r.type||r.key;if(typeof t==="string"){if(r.kind==="hasMany"){t=x(t)}i=e.modelFor(t)}else{i=r.type}return i}function yi(e,r){return{key:r.key,kind:r.kind,type:vi(e,r),options:r.options,parentType:r.parentType,isRelationship:true}}var bi=Ember.get;var gi=Ember.ArrayPolyfills.filter;var Ri=Ember.computed(function(){if(Ember.testing===true&&Ri._cacheable===true){Ri._cacheable=false}var e=new d({defaultValue:function(){return[]}});this.eachComputedProperty(function(r,t){if(t.isRelationship){t.key=r;var i=e.get(vi(this.store,t));i.push({name:r,kind:t.kind})}});return e}).readOnly();var Ei=Ember.computed(function(){if(Ember.testing===true&&Ei._cacheable===true){Ei._cacheable=false}var e;var r=Ember.A();this.eachComputedProperty(function(t,i){if(i.isRelationship){i.key=t;e=vi(this.store,i);if(!r.contains(e)){r.push(e)}}});return r}).readOnly();var _i=Ember.computed(function(){if(Ember.testing===true&&_i._cacheable===true){_i._cacheable=false}var e=l.create();this.eachComputedProperty(function(r,t){if(t.isRelationship){t.key=r;var i=yi(this.store,t);i.type=vi(this.store,t);e.set(r,i)}});return e}).readOnly();nt.reopen({didDefineProperty:function(e,r,t){if(t instanceof Ember.ComputedProperty){var i=t.meta();i.parentType=e.constructor}}});nt.reopenClass({typeForRelationship:function(e){var r=bi(this,"relationshipsByName").get(e);return r&&r.type},inverseMap:Ember.computed(function(){return Ember.create(null)}),inverseFor:function(e){var r=bi(this,"inverseMap");if(r[e]){return r[e]}else{var t=this._findInverseFor(e);r[e]=t;return t}},_findInverseFor:function(e){var r=this.typeForRelationship(e);if(!r){return null}var t=this.metaForProperty(e);var i=t.options;if(i.inverse===null){return null}var n,a,o;if(i.inverse){n=i.inverse;o=Ember.get(r,"relationshipsByName").get(n);a=o.kind}else{var s=c(this,r);if(s.length===0){return null}var u=gi.call(s,function(t){var i=r.metaForProperty(t.name).options;return e===i.inverse});if(u.length===1){s=u}n=s[0].name;a=s[0].kind}function c(r,t,i){var n=i||[];var a=bi(t,"relationships");if(!a){return}var o=a.get(r);o=gi.call(o,function(r){var i=t.metaForProperty(r.name).options;if(!i.inverse){return true}return e===i.inverse});if(o){n.push.apply(n,o)}if(r.superclass){c(r.superclass,t,n)}return n}return{type:r,name:n,kind:a}},relationships:Ri,relationshipNames:Ember.computed(function(){var e={hasMany:[],belongsTo:[]};this.eachComputedProperty(function(r,t){if(t.isRelationship){e[t.kind].push(r)}});return e}),relatedTypes:Ei,relationshipsByName:_i,fields:Ember.computed(function(){var e=l.create();this.eachComputedProperty(function(r,t){if(t.isRelationship){e.set(r,t.kind)}else if(t.isAttribute){e.set(r,"attribute")}});return e}).readOnly(),eachRelationship:function(e,r){bi(this,"relationshipsByName").forEach(function(t,i){e.call(r,i,t)})},eachRelatedType:function(e,r){bi(this,"relatedTypes").forEach(function(t){e.call(r,t)})},determineRelationshipType:function(e){var r=e.key;var t=e.kind;var i=this.inverseFor(r);var n,a;if(!i){return t==="belongsTo"?"oneToNone":"manyToNone"}n=i.name;a=i.kind;if(a==="belongsTo"){return t==="belongsTo"?"oneToOne":"manyToOne"}else{return t==="belongsTo"?"oneToMany":"manyToMany"}}});nt.reopen({eachRelationship:function(e,r){this.constructor.eachRelationship(e,r)},relationshipFor:function(e){return bi(this.constructor,"relationshipsByName").get(e)},inverseFor:function(e){return this.constructor.inverseFor(e)}});Ember.RSVP.Promise.cast=Ember.RSVP.Promise.cast||Ember.RSVP.resolve;pe.Store=vt;pe.PromiseArray=ye;pe.PromiseObject=be;pe.PromiseManyArray=_e;pe.Model=nt;pe.RootState=fr;pe.attr=it;pe.Errors=yr;pe.Snapshot=Ir;pe.Adapter=i;pe.InvalidError=t;pe.Serializer=H;pe.DebugAdapter=ri;pe.RecordArray=Ke;pe.FilteredRecordArray=Be;pe.AdapterPopulatedRecordArray=He;pe.ManyArray=zr;pe.RecordArrayManager=Ye;pe.RESTAdapter=y;pe.BuildURLMixin=p;pe.FixtureAdapter=c;pe.RESTSerializer=re;pe.JSONSerializer=X;pe.Transform=Mt;pe.DateTransform=Ot;pe.StringTransform=$t;pe.NumberTransform=Dt;pe.BooleanTransform=Lt;pe.ActiveModelAdapter=U;pe.ActiveModelSerializer=ue;pe.EmbeddedRecordsMixin=di;pe.belongsTo=fi;pe.hasMany=mi;pe.Relationship=_r;pe.ContainerProxy=le;pe._setupContainer=Gt;Ember.lookup.DS=pe;var Fi=pe}).call(this);
\ No newline at end of file
diff --git a/website/source/assets/javascripts/lib/ember-template-compiler.js b/website/source/assets/javascripts/lib/ember-template-compiler.js
index 213f5ad28..3b783f241 100644
--- a/website/source/assets/javascripts/lib/ember-template-compiler.js
+++ b/website/source/assets/javascripts/lib/ember-template-compiler.js
@@ -1,4 +1,7193 @@
-!function(){var t,e,r,n,i;!function(){function s(){}function o(t,e){if("."!==t.charAt(0))return t;for(var r=t.split("/"),n=e.split("/").slice(0,-1),i=0,s=r.length;s>i;i++){var o=r[i];if(".."===o)n.pop();else{if("."===o)continue;n.push(o)}}return n.join("/")}if(i=this.Ember=this.Ember||{},"undefined"==typeof i&&(i={}),"undefined"==typeof i.__loader){var a={},l={};t=function(t,e,r){a[t]={deps:e,callback:r}},n=r=e=function(t){var r=l[t];if(void 0!==r)return l[t];if(r===s)return void 0;if(l[t]={},!a[t])throw new Error("Could not find module "+t);for(var n,i=a[t],c=i.deps,u=i.callback,p=[],h=c.length,m=0;h>m;m++)p.push("exports"===c[m]?n={}:e(o(c[m],t)));var d=0===h?u.call(this):u.apply(this,p);return l[t]=n||(void 0===d?s:d)},n._eak_seen=a,i.__loader={define:t,require:r,registry:a}}else t=i.__loader.define,n=r=e=i.__loader.require}(),t("ember-metal/core",["exports"],function(t){"use strict";function e(){return this}"undefined"==typeof i&&(i={}),i.imports=i.imports||this,i.lookup=i.lookup||this;var r=i.exports=i.exports||this;r.Em=r.Ember=i,i.isNamespace=!0,i.toString=function(){return"Ember"},i.VERSION="1.10.0",i.ENV||(i.ENV="undefined"!=typeof EmberENV?EmberENV:"undefined"!=typeof ENV?ENV:{}),i.config=i.config||{},"undefined"==typeof i.ENV.DISABLE_RANGE_API&&(i.ENV.DISABLE_RANGE_API=!0),"undefined"==typeof MetamorphENV&&(r.MetamorphENV={}),MetamorphENV.DISABLE_RANGE_API=i.ENV.DISABLE_RANGE_API,i.FEATURES=i.ENV.FEATURES||{},i.FEATURES.isEnabled=function(t){var e=i.FEATURES[t];return i.ENV.ENABLE_ALL_FEATURES?!0:e===!0||e===!1||void 0===e?e:i.ENV.ENABLE_OPTIONAL_FEATURES?!0:!1},i.EXTEND_PROTOTYPES=i.ENV.EXTEND_PROTOTYPES,"undefined"==typeof i.EXTEND_PROTOTYPES&&(i.EXTEND_PROTOTYPES=!0),i.LOG_STACKTRACE_ON_DEPRECATION=i.ENV.LOG_STACKTRACE_ON_DEPRECATION!==!1,i.SHIM_ES5=i.ENV.SHIM_ES5===!1?!1:i.EXTEND_PROTOTYPES,i.LOG_VERSION=i.ENV.LOG_VERSION===!1?!1:!0,t.K=e,i.K=e,"undefined"==typeof i.assert&&(i.assert=e),"undefined"==typeof i.warn&&(i.warn=e),"undefined"==typeof i.debug&&(i.debug=e),"undefined"==typeof i.runInDebug&&(i.runInDebug=e),"undefined"==typeof i.deprecate&&(i.deprecate=e),"undefined"==typeof i.deprecateFunc&&(i.deprecateFunc=function(t,e){return e}),t["default"]=i}),t("ember-template-compiler",["ember-metal/core","ember-template-compiler/system/precompile","ember-template-compiler/system/compile","ember-template-compiler/system/template","ember-template-compiler/plugins","ember-template-compiler/plugins/transform-each-in-to-hash","ember-template-compiler/plugins/transform-with-as-to-hash","ember-template-compiler/compat","exports"],function(t,e,r,n,i,s,o,a,l){"use strict";var c=t["default"],u=e["default"],p=r["default"],h=n["default"],m=i.registerPlugin,d=s["default"],f=o["default"];m("ast",f),m("ast",d),l._Ember=c,l.precompile=u,l.compile=p,l.template=h,l.registerPlugin=m}),t("ember-template-compiler/compat",["ember-metal/core","ember-template-compiler/compat/precompile","ember-template-compiler/system/compile","ember-template-compiler/system/template"],function(t,e,r,n){"use strict";var i=t["default"],s=e["default"],o=r["default"],a=n["default"],l=i.Handlebars=i.Handlebars||{};l.precompile=s,l.compile=o,l.template=a}),t("ember-template-compiler/compat/precompile",["exports"],function(t){"use strict";var r,n;t["default"]=function(t){if((!r||!n)&&i.__loader.registry["htmlbars-compiler/compiler"]){var s=e("htmlbars-compiler/compiler");r=s.compile,n=s.compileSpec}if(!r||!n)throw new Error("Cannot call `precompile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `precompile`.");var o=void 0===arguments[1]?!0:arguments[1],a=o?r:n;return a(t)}}),t("ember-template-compiler/plugins",["exports"],function(t){"use strict";function e(t,e){if(!r[t])throw new Error('Attempting to register "'+e+'" as "'+t+'" which is not a valid HTMLBars plugin type.');r[t].push(e)}var r={ast:[]};t.registerPlugin=e,t["default"]=r}),t("ember-template-compiler/plugins/transform-each-in-to-hash",["exports"],function(t){"use strict";function e(){this.syntax=null}e.prototype.transform=function(t){var e=this,r=new e.syntax.Walker,n=e.syntax.builders;return r.visit(t,function(t){if(e.validate(t)){if(t.program&&t.program.blockParams.length)throw new Error("You cannot use keyword (`{{each foo in bar}}`) and block params (`{{each bar as |foo|}}`) at the same time.");var r=t.sexpr.params.splice(0,2),i=r[0].original;t.sexpr.hash||(t.sexpr.hash=n.hash()),t.sexpr.hash.pairs.push(n.pair("keyword",n.string(i)))}}),t},e.prototype.validate=function(t){return("BlockStatement"===t.type||"MustacheStatement"===t.type)&&"each"===t.sexpr.path.original&&3===t.sexpr.params.length&&"PathExpression"===t.sexpr.params[1].type&&"in"===t.sexpr.params[1].original},t["default"]=e}),t("ember-template-compiler/plugins/transform-with-as-to-hash",["exports"],function(t){"use strict";function e(){this.syntax=null}e.prototype.transform=function(t){var e=this,r=new e.syntax.Walker;return r.visit(t,function(t){if(e.validate(t)){if(t.program&&t.program.blockParams.length)throw new Error("You cannot use keyword (`{{with foo as bar}}`) and block params (`{{with foo as |bar|}}`) at the same time.");var r=t.sexpr.params.splice(1,2),n=r[1].original;t.program.blockParams=[n]}}),t},e.prototype.validate=function(t){return"BlockStatement"===t.type&&"with"===t.sexpr.path.original&&3===t.sexpr.params.length&&"PathExpression"===t.sexpr.params[1].type&&"as"===t.sexpr.params[1].original},t["default"]=e}),t("ember-template-compiler/system/compile",["ember-template-compiler/system/compile_options","ember-template-compiler/system/template","exports"],function(t,r,n){"use strict";var s,o=t["default"],a=r["default"];n["default"]=function(t){if(!s&&i.__loader.registry["htmlbars-compiler/compiler"]&&(s=e("htmlbars-compiler/compiler").compile),!s)throw new Error("Cannot call `compile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compile`.");var r=s(t,o());return a(r)}}),t("ember-template-compiler/system/compile_options",["ember-metal/core","ember-template-compiler/plugins","exports"],function(t,e,r){"use strict";var n=(t["default"],e["default"]);r["default"]=function(){var t=!0;return{disableComponentGeneration:t,plugins:n}}}),t("ember-template-compiler/system/precompile",["ember-template-compiler/system/compile_options","exports"],function(t,r){"use strict";var n,s=t["default"];r["default"]=function(t){if(!n&&i.__loader.registry["htmlbars-compiler/compiler"]&&(n=e("htmlbars-compiler/compiler").compileSpec),!n)throw new Error("Cannot call `compileSpec` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compileSpec`.");return n(t,s())}}),t("ember-template-compiler/system/template",["exports"],function(t){"use strict";t["default"]=function(t){return t.isTop=!0,t.isMethod=!1,t}}),t("htmlbars-compiler",["./htmlbars-compiler/compiler","exports"],function(t,e){"use strict";var r=t.compile,n=t.compilerSpec;e.compile=r,e.compilerSpec=n}),t("htmlbars-compiler/compiler",["../htmlbars-syntax/parser","./template-compiler","exports"],function(t,e,r){"use strict";function n(t,e){var r=i(t,e);return new Function("return "+r)()}function i(t,e){var r=s(t,e),n=new o(e),i=n.compile(r);return i}var s=t.preprocess,o=e["default"];r.compile=n,r.compileSpec=i}),t("htmlbars-compiler/fragment-javascript-compiler",["./utils","../htmlbars-util/quoting","exports"],function(t,e,r){"use strict";function n(){this.source=[],this.depth=-1}var i=t.processOpcodes,s=e.string,o="http://www.w3.org/2000/svg",a={foreignObject:!0,desc:!0,title:!0};r["default"]=n,n.prototype.compile=function(t,e){return this.source.length=0,this.depth=-1,this.indent=e&&e.indent||"",this.namespaceFrameStack=[{namespace:null,depth:null}],this.domNamespace=null,this.source.push("function build(dom) {\n"),i(this,t),this.source.push(this.indent+"}"),this.source.join("")},n.prototype.createFragment=function(){var t="el"+ ++this.depth;this.source.push(this.indent+" var "+t+" = dom.createDocumentFragment();\n")},n.prototype.createElement=function(t){var e="el"+ ++this.depth;"svg"===t&&this.pushNamespaceFrame({namespace:o,depth:this.depth}),this.ensureNamespace(),this.source.push(this.indent+" var "+e+" = dom.createElement("+s(t)+");\n"),a[t]&&this.pushNamespaceFrame({namespace:null,depth:this.depth})},n.prototype.createText=function(t){var e="el"+ ++this.depth;this.source.push(this.indent+" var "+e+" = dom.createTextNode("+s(t)+");\n")},n.prototype.createComment=function(t){var e="el"+ ++this.depth;this.source.push(this.indent+" var "+e+" = dom.createComment("+s(t)+");\n")},n.prototype.returnNode=function(){var t="el"+this.depth;this.source.push(this.indent+" return "+t+";\n")},n.prototype.setAttribute=function(t,e,r){var n="el"+this.depth;this.source.push(r?this.indent+" dom.setAttributeNS("+n+","+s(r)+","+s(t)+","+s(e)+");\n":this.indent+" dom.setAttribute("+n+","+s(t)+","+s(e)+");\n")},n.prototype.appendChild=function(){this.depth===this.getCurrentNamespaceFrame().depth&&this.popNamespaceFrame();var t="el"+this.depth--,e="el"+this.depth;this.source.push(this.indent+" dom.appendChild("+e+", "+t+");\n")},n.prototype.getCurrentNamespaceFrame=function(){return this.namespaceFrameStack[this.namespaceFrameStack.length-1]},n.prototype.pushNamespaceFrame=function(t){this.namespaceFrameStack.push(t)},n.prototype.popNamespaceFrame=function(){return this.namespaceFrameStack.pop()},n.prototype.ensureNamespace=function(){var t=this.getCurrentNamespaceFrame().namespace;this.domNamespace!==t&&(this.source.push(this.indent+" dom.setNamespace("+(t?s(t):"null")+");\n"),this.domNamespace=t)}}),t("htmlbars-compiler/fragment-opcode-compiler",["./template-visitor","./utils","../htmlbars-util","../htmlbars-util/array-utils","exports"],function(t,e,r,n,i){"use strict";function s(){this.opcodes=[]}var o=t["default"],a=e.processOpcodes,l=r.getAttrNamespace,c=n.forEach;i["default"]=s,s.prototype.compile=function(t){var e=new o;return e.visit(t),a(this,e.actions),this.opcodes},s.prototype.opcode=function(t,e){this.opcodes.push([t,e])},s.prototype.text=function(t,e,r,n){this.opcode("createText",[t.chars]),n||this.opcode("appendChild")},s.prototype.comment=function(t,e,r,n){this.opcode("createComment",[t.value]),n||this.opcode("appendChild")},s.prototype.openElement=function(t){this.opcode("createElement",[t.tag]),c(t.attributes,this.attribute,this)},s.prototype.closeElement=function(t,e,r,n){n||this.opcode("appendChild")},s.prototype.startProgram=function(t){this.opcodes.length=0,1!==t.body.length&&this.opcode("createFragment")},s.prototype.endProgram=function(){this.opcode("returnNode")},s.prototype.mustache=function(){},s.prototype.component=function(){},s.prototype.block=function(){},s.prototype.attribute=function(t){if("TextNode"===t.value.type){var e=l(t.name);this.opcode("setAttribute",[t.name,t.value.chars,e])}},s.prototype.setNamespace=function(t){this.opcode("setNamespace",[t])}}),t("htmlbars-compiler/hydration-javascript-compiler",["./utils","../htmlbars-util/quoting","exports"],function(t,e,r){"use strict";function n(){this.stack=[],this.source=[],this.mustaches=[],this.parents=[["fragment"]],this.parentCount=0,this.morphs=[],this.fragmentProcessing=[],this.hooks=void 0}var i=t.processOpcodes,s=e.string,o=e.array;r["default"]=n;var a=n.prototype;a.compile=function(t,e){this.stack.length=0,this.mustaches.length=0,this.source.length=0,this.parents.length=1,this.parents[0]=["fragment"],this.morphs.length=0,this.fragmentProcessing.length=0,this.parentCount=0,this.indent=e&&e.indent||"",this.hooks={},i(this,t);var r,n;if(this.morphs.length){var s="";for(r=0,n=this.morphs.length;n>r;++r){var o=this.morphs[r];s+=this.indent+" var "+o[0]+" = "+o[1]+";\n"}this.source.unshift(s)}if(this.fragmentProcessing.length){var a="";for(r=0,n=this.fragmentProcessing.length;n>r;++r)a+=this.indent+" "+this.fragmentProcessing[r]+"\n";this.source.unshift(a)}return this.source.join("")},a.prepareArray=function(t){for(var e=[],r=0;t>r;r++)e.push(this.stack.pop());this.stack.push("["+e.join(", ")+"]")},a.prepareObject=function(t){for(var e=[],r=0;t>r;r++)e.push(this.stack.pop()+": "+this.stack.pop());this.stack.push("{"+e.join(", ")+"}")},a.pushRaw=function(t){this.stack.push(t)},a.pushLiteral=function(t){this.stack.push("string"==typeof t?s(t):t.toString())},a.pushHook=function(t,e){this.hooks[t]=!0,this.stack.push(t+"("+e.join(", ")+")")},a.pushGetHook=function(t){this.pushHook("get",["env","context",s(t)])},a.pushSexprHook=function(){this.pushHook("subexpr",["env","context",this.stack.pop(),this.stack.pop(),this.stack.pop()])},a.pushConcatHook=function(){this.pushHook("concat",["env",this.stack.pop()])},a.printHook=function(t,e){this.hooks[t]=!0,this.source.push(this.indent+" "+t+"("+e.join(", ")+");\n")},a.printSetHook=function(t,e){this.printHook("set",["env","context",s(t),"blockArguments["+e+"]"])},a.printBlockHook=function(t,e,r){this.printHook("block",["env","morph"+t,"context",this.stack.pop(),this.stack.pop(),this.stack.pop(),null===e?"null":"child"+e,null===r?"null":"child"+r])},a.printInlineHook=function(t){this.printHook("inline",["env","morph"+t,"context",this.stack.pop(),this.stack.pop(),this.stack.pop()])},a.printContentHook=function(t){this.printHook("content",["env","morph"+t,"context",this.stack.pop()])},a.printComponentHook=function(t,e){this.printHook("component",["env","morph"+t,"context",this.stack.pop(),this.stack.pop(),null===e?"null":"child"+e])},a.printAttributeHook=function(t,e){this.printHook("attribute",["env","attrMorph"+t,"element"+e,this.stack.pop(),this.stack.pop()])},a.printElementHook=function(t){this.printHook("element",["env","element"+t,"context",this.stack.pop(),this.stack.pop(),this.stack.pop()])},a.createMorph=function(t,e,r,n,i){var s=0===e.length,o=this.getParent(),a=i?"createMorphAt":"createUnsafeMorphAt",l="dom."+a+"("+o+","+(null===r?"-1":r)+","+(null===n?"-1":n)+(s?",contextualElement)":")");this.morphs.push(["morph"+t,l])},a.createAttrMorph=function(t,e,r,n,i){var s=n?"createAttrMorph":"createUnsafeAttrMorph",o="dom."+s+"(element"+e+", '"+r+(i?"', '"+i:"")+"')";this.morphs.push(["attrMorph"+t,o])},a.repairClonedNode=function(t,e){var r=this.getParent(),n="if (this.cachedFragment) { dom.repairClonedNode("+r+","+o(t)+(e?",true":"")+"); }";this.fragmentProcessing.push(n)},a.shareElement=function(t){var e="element"+t;this.fragmentProcessing.push("var "+e+" = "+this.getParent()+";"),this.parents[this.parents.length-1]=[e]},a.consumeParent=function(t){var e=this.lastParent().slice();e.push(t),this.parents.push(e)},a.popParent=function(){this.parents.pop()},a.getParent=function(){var t=this.lastParent().slice(),e=t.shift();return t.length?"dom.childAt("+e+", ["+t.join(", ")+"])":e},a.lastParent=function(){return this.parents[this.parents.length-1]}}),t("htmlbars-compiler/hydration-opcode-compiler",["./template-visitor","./utils","../htmlbars-util","../htmlbars-util/array-utils","../htmlbars-syntax/utils","exports"],function(t,e,r,n,i,s){"use strict";function o(t){return y(t.sexpr)?t.sexpr:t.sexpr.path}function a(t){for(var e=0,r=t.attributes.length;r>e;e++)if("checked"===t.attributes[e].name)return!0;return!1}function l(){this.opcodes=[],this.paths=[],this.templateId=0,this.currentDOMChildIndex=0,this.morphs=[],this.morphNum=0,this.attrMorphNum=0,this.element=null,this.elementNum=-1}function c(t,e){t.opcode("pushLiteral",e.original)}function u(t,e){for(var r=e.length-1;r>=0;r--){var n=e[r];t[n.type](n)}t.opcode("prepareArray",e.length)}function p(t,e){for(var r=e.pairs,n=r.length-1;n>=0;n--){var i=r[n].key,s=r[n].value;t[s.type](s),t.opcode("pushLiteral",i)}t.opcode("prepareObject",r.length)}function h(t,e){p(t,e.hash),u(t,e.params),c(t,e.path)}function m(t,e){if(0!==t.length){var r;for(r=e.length-1;r>=0;--r){var n=e[r][0];if("shareElement"===n||"consumeParent"===n||"popParent"===n)break}for(var i=[r+1,0],s=0;s0&&this.opcode("repairClonedNode",r)},l.prototype.endProgram=function(){m(this.morphs,this.opcodes)},l.prototype.text=function(){++this.currentDOMChildIndex},l.prototype.comment=function(){++this.currentDOMChildIndex},l.prototype.openElement=function(t,e,r,n,i,s){m(this.morphs,this.opcodes),++this.currentDOMChildIndex,this.element=this.currentDOMChildIndex,n||(this.opcode("consumeParent",this.currentDOMChildIndex),i>1&&(this.opcode("shareElement",++this.elementNum),this.element=null));var o=a(t);(s.length>0||o)&&this.opcode("repairClonedNode",s,o),this.paths.push(this.currentDOMChildIndex),this.currentDOMChildIndex=-1,b(t.attributes,this.attribute,this),b(t.helpers,this.elementHelper,this)},l.prototype.closeElement=function(t,e,r,n){m(this.morphs,this.opcodes),n||this.opcode("popParent"),this.currentDOMChildIndex=this.paths.pop()},l.prototype.block=function(t,e,r){var n=t.sexpr,i=this.currentDOMChildIndex,s=0>i?null:i,o=e===r-1?null:i+1,a=this.morphNum++;this.morphs.push([a,this.paths.slice(),s,o,!0]);var l=this.templateId++,c=null===t.inverse?null:this.templateId++;h(this,n),this.opcode("printBlockHook",a,l,c)},l.prototype.component=function(t,e,r){var n=this.currentDOMChildIndex,i=t.program||{},s=i.blockParams||[],a=0>n?null:n,l=e===r-1?null:n+1,c=this.morphNum++;this.morphs.push([c,this.paths.slice(),a,l,!0]);for(var p=t.attributes,h=p.length-1;h>=0;h--){var m=p[h].name,d=p[h].value;"TextNode"===d.type?this.opcode("pushLiteral",d.chars):"MustacheStatement"===d.type?this.accept(o(d)):"ConcatStatement"===d.type&&(u(this,d.parts),this.opcode("pushConcatHook")),this.opcode("pushLiteral",m)}this.opcode("prepareObject",p.length),this.opcode("pushLiteral",t.tag),this.opcode("printComponentHook",c,this.templateId++,s.length)},l.prototype.attribute=function(t){var e=t.value,r=!0,n=g(t.name);if("TextNode"!==e.type){"MustacheStatement"===e.type?(r=e.escaped,this.accept(o(e))):"ConcatStatement"===e.type&&(u(this,e.parts),this.opcode("pushConcatHook")),this.opcode("pushLiteral",t.name),null!==this.element&&(this.opcode("shareElement",++this.elementNum),this.element=null);var i=this.attrMorphNum++;this.opcode("createAttrMorph",i,this.elementNum,t.name,r,n),this.opcode("printAttributeHook",i,this.elementNum)}},l.prototype.elementHelper=function(t){h(this,t),null!==this.element&&(this.opcode("shareElement",++this.elementNum),this.element=null),this.opcode("printElementHook",this.elementNum)},l.prototype.mustache=function(t,e,r){var n=t.sexpr,i=this.currentDOMChildIndex,s=i,o=e===r-1?-1:i+1,a=this.morphNum++;this.morphs.push([a,this.paths.slice(),s,o,t.escaped]),y(n)?(h(this,n),this.opcode("printInlineHook",a)):(c(this,n.path),this.opcode("printContentHook",a))},l.prototype.SubExpression=function(t){h(this,t),this.opcode("pushSexprHook")},l.prototype.PathExpression=function(t){this.opcode("pushGetHook",t.original)},l.prototype.StringLiteral=function(t){this.opcode("pushLiteral",t.value)},l.prototype.BooleanLiteral=function(t){this.opcode("pushLiteral",t.value)},l.prototype.NumberLiteral=function(t){this.opcode("pushLiteral",t.value)}}),t("htmlbars-compiler/template-compiler",["./fragment-opcode-compiler","./fragment-javascript-compiler","./hydration-opcode-compiler","./hydration-javascript-compiler","./template-visitor","./utils","../htmlbars-util/quoting","exports"],function(t,e,r,n,i,s,o,a){"use strict";function l(t){this.options=t||{},this.fragmentOpcodeCompiler=new c,this.fragmentCompiler=new u,this.hydrationOpcodeCompiler=new p,this.hydrationCompiler=new h,this.templates=[],this.childTemplates=[]}var c=t["default"],u=e["default"],p=r["default"],h=n["default"],m=i["default"],d=s.processOpcodes,f=o.repeat;a["default"]=l,l.prototype.compile=function(t){var e=new m;return e.visit(t),d(this,e.actions),this.templates.pop()},l.prototype.startProgram=function(t,e,r){for(this.fragmentOpcodeCompiler.startProgram(t,e,r),this.hydrationOpcodeCompiler.startProgram(t,e,r),this.childTemplates.length=0;e--;)this.childTemplates.push(this.templates.pop())},l.prototype.getChildTemplateVars=function(t){var e="";if(this.childTemplates)for(var r=0;r0?t+"var hooks = env.hooks, "+r.join(", ")+";\n":""},l.prototype.endProgram=function(t,e){this.fragmentOpcodeCompiler.endProgram(t),this.hydrationOpcodeCompiler.endProgram(t);var r=f(" ",e),n={indent:r+" "},i=this.fragmentCompiler.compile(this.fragmentOpcodeCompiler.opcodes,n),s=this.hydrationCompiler.compile(this.hydrationOpcodeCompiler.opcodes,n),o=t.blockParams||[],a="context, env, contextualElement";o.length>0&&(a+=", blockArguments");var l="(function() {\n"+this.getChildTemplateVars(r+" ")+r+" return {\n"+r+" isHTMLBars: true,\n"+r+" blockParams: "+o.length+",\n"+r+" cachedFragment: null,\n"+r+" hasRendered: false,\n"+r+" build: "+i+",\n"+r+" render: function render("+a+") {\n"+r+" var dom = env.dom;\n"+this.getHydrationHooks(r+" ",this.hydrationCompiler.hooks)+r+" dom.detectNamespace(contextualElement);\n"+r+" var fragment;\n"+r+" if (env.useFragmentCache && dom.canClone) {\n"+r+" if (this.cachedFragment === null) {\n"+r+" fragment = this.build(dom);\n"+r+" if (this.hasRendered) {\n"+r+" this.cachedFragment = fragment;\n"+r+" } else {\n"+r+" this.hasRendered = true;\n"+r+" }\n"+r+" }\n"+r+" if (this.cachedFragment) {\n"+r+" fragment = dom.cloneNode(this.cachedFragment, true);\n"+r+" }\n"+r+" } else {\n"+r+" fragment = this.build(dom);\n"+r+" }\n"+s+r+" return fragment;\n"+r+" }\n"+r+" };\n"+r+"}())";this.templates.push(l)},l.prototype.openElement=function(t,e,r,n,i,s){this.fragmentOpcodeCompiler.openElement(t,e,r,n,i,s),this.hydrationOpcodeCompiler.openElement(t,e,r,n,i,s)},l.prototype.closeElement=function(t,e,r,n){this.fragmentOpcodeCompiler.closeElement(t,e,r,n),this.hydrationOpcodeCompiler.closeElement(t,e,r,n)},l.prototype.component=function(t,e,r){this.fragmentOpcodeCompiler.component(t,e,r),this.hydrationOpcodeCompiler.component(t,e,r)},l.prototype.block=function(t,e,r){this.fragmentOpcodeCompiler.block(t,e,r),this.hydrationOpcodeCompiler.block(t,e,r)},l.prototype.text=function(t,e,r,n){this.fragmentOpcodeCompiler.text(t,e,r,n),this.hydrationOpcodeCompiler.text(t,e,r,n)},l.prototype.comment=function(t,e,r,n){this.fragmentOpcodeCompiler.comment(t,e,r,n),this.hydrationOpcodeCompiler.comment(t,e,r,n)},l.prototype.mustache=function(t,e,r){this.fragmentOpcodeCompiler.mustache(t,e,r),this.hydrationOpcodeCompiler.mustache(t,e,r)},l.prototype.setNamespace=function(t){this.fragmentOpcodeCompiler.setNamespace(t)}}),t("htmlbars-compiler/template-visitor",["exports"],function(t){"use strict";function e(){this.parentNode=null,this.children=null,this.childIndex=null,this.childCount=null,this.childTemplateCount=0,this.mustacheCount=0,this.actions=[]}function r(){this.frameStack=[],this.actions=[],this.programDepth=-1}function n(t,e){for(var r=-1,n=0;n=0;n--)r.childIndex=n,this.visit(t.body[n]);r.actions.push(["startProgram",[t,r.childTemplateCount,r.blankChildTextNodes.reverse()]]),this.popFrame(),this.programDepth--,e&&e.childTemplateCount++,i.apply(this.actions,r.actions.reverse())},r.prototype.ElementNode=function(t){var e=this.getCurrentFrame(),r=this.pushFrame(),n=e.parentNode;r.parentNode=t,r.children=t.children,r.childCount=t.children.length,r.mustacheCount+=t.helpers.length,r.blankChildTextNodes=[];var s=[t,e.childIndex,e.childCount,"Program"===n.type&&1===e.childCount];r.actions.push(["closeElement",s]);for(var o=t.attributes.length-1;o>=0;o--)this.visit(t.attributes[o]);for(o=t.children.length-1;o>=0;o--)r.childIndex=o,this.visit(t.children[o]);r.actions.push(["openElement",s.concat([r.mustacheCount,r.blankChildTextNodes.reverse()])]),this.popFrame(),r.mustacheCount>0&&e.mustacheCount++,e.childTemplateCount+=r.childTemplateCount,i.apply(e.actions,r.actions)},r.prototype.AttrNode=function(t){"TextNode"!==t.value.type&&this.getCurrentFrame().mustacheCount++},r.prototype.TextNode=function(t){var e=this.getCurrentFrame(),r="Program"===e.parentNode.type&&1===e.childCount;""===t.chars&&e.blankChildTextNodes.push(n(e.children,t)),e.actions.push(["text",[t,e.childIndex,e.childCount,r]])},r.prototype.BlockStatement=function(t){var e=this.getCurrentFrame();e.mustacheCount++,e.actions.push(["block",[t,e.childIndex,e.childCount]]),t.inverse&&this.visit(t.inverse),t.program&&this.visit(t.program)},r.prototype.ComponentNode=function(t){var e=this.getCurrentFrame();e.mustacheCount++,e.actions.push(["component",[t,e.childIndex,e.childCount]]),t.program&&this.visit(t.program)},r.prototype.PartialStatement=function(t){var e=this.getCurrentFrame();e.mustacheCount++,e.actions.push(["mustache",[t,e.childIndex,e.childCount]])},r.prototype.CommentStatement=function(t){var e=this.getCurrentFrame(),r="Program"===e.parentNode.type&&1===e.childCount;e.actions.push(["comment",[t,e.childIndex,e.childCount,r]])},r.prototype.MustacheStatement=function(t){var e=this.getCurrentFrame();e.mustacheCount++,e.actions.push(["mustache",[t,e.childIndex,e.childCount]])},r.prototype.getCurrentFrame=function(){return this.frameStack[this.frameStack.length-1]},r.prototype.pushFrame=function(){var t=new e;return this.frameStack.push(t),t},r.prototype.popFrame=function(){return this.frameStack.pop()},t["default"]=r}),t("htmlbars-compiler/utils",["exports"],function(t){"use strict";function e(t,e){for(var r=0,n=e.length;n>r;r++){var i=e[r][0],s=e[r][1];s?t[i].apply(t,s):t[i].call(t)}}t.processOpcodes=e}),t("htmlbars-syntax",["./htmlbars-syntax/walker","./htmlbars-syntax/builders","./htmlbars-syntax/parser","exports"],function(t,e,r,n){"use strict";var i=t["default"],s=e["default"],o=r.preprocess;n.Walker=i,n.builders=s,n.parse=o}),t("htmlbars-syntax/builders",["exports"],function(t){"use strict";function e(t,e){return{type:"MustacheStatement",sexpr:t,escaped:!e}}function r(t,e,r){return{type:"BlockStatement",sexpr:t,program:e||null,inverse:r||null}}function n(t,e){return{type:"PartialStatement",sexpr:t,indent:e}}function i(t){return{type:"CommentStatement",value:t}}function s(t){return{type:"ConcatStatement",parts:t||[]}}function o(t,e,r,n){return{type:"ElementNode",tag:t,attributes:e||[],helpers:r||[],children:n||[]}}function a(t,e,r){return{type:"ComponentNode",tag:t,attributes:e,program:r}}function l(t,e){return{type:"AttrNode",name:t,value:e}}function c(t){return{type:"TextNode",chars:t}}function u(t,e,r){return{type:"SubExpression",path:t,params:e||[],hash:r||f([])}}function p(t){return{type:"PathExpression",original:t,parts:t.split(".")}}function h(t){return{type:"StringLiteral",value:t,original:t}}function m(t){return{type:"BooleanLiteral",value:t,original:t}}function d(t){return{type:"NumberLiteral",value:t,original:t}}function f(t){return{type:"Hash",pairs:t||[]}}function g(t,e){return{type:"HashPair",key:t,value:e}}function b(t,e){return{type:"Program",body:t||[],blockParams:e||[]}}t.buildMustache=e,t.buildBlock=r,t.buildPartial=n,t.buildComment=i,t.buildConcat=s,t.buildElement=o,t.buildComponent=a,t.buildAttr=l,t.buildText=c,t.buildSexpr=u,t.buildPath=p,t.buildString=h,t.buildBoolean=m,t.buildNumber=d,t.buildHash=f,t.buildPair=g,t.buildProgram=b,t["default"]={mustache:e,block:r,partial:n,comment:i,element:o,component:a,attr:l,text:c,sexpr:u,path:p,string:h,"boolean":m,number:d,concat:s,hash:f,pair:g,program:b}}),t("htmlbars-syntax/handlebars/compiler/ast",["../exception","exports"],function(t,e){"use strict";var r=(t["default"],{Program:function(t,e,r,n){this.loc=n,this.type="Program",this.body=t,this.blockParams=e,this.strip=r},MustacheStatement:function(t,e,r,n){this.loc=n,this.type="MustacheStatement",this.sexpr=t,this.escaped=e,this.strip=r},BlockStatement:function(t,e,r,n,i,s,o){this.loc=o,this.type="BlockStatement",this.sexpr=t,this.program=e,this.inverse=r,this.openStrip=n,this.inverseStrip=i,this.closeStrip=s},PartialStatement:function(t,e,r){this.loc=r,this.type="PartialStatement",this.sexpr=t,this.indent="",this.strip=e},ContentStatement:function(t,e){this.loc=e,this.type="ContentStatement",this.original=this.value=t},CommentStatement:function(t,e,r){this.loc=r,this.type="CommentStatement",this.value=t,this.strip=e},SubExpression:function(t,e,r,n){this.loc=n,this.type="SubExpression",this.path=t,this.params=e||[],this.hash=r},PathExpression:function(t,e,r,n,i){this.loc=i,this.type="PathExpression",this.data=t,this.original=n,this.parts=r,this.depth=e},StringLiteral:function(t,e){this.loc=e,this.type="StringLiteral",this.original=this.value=t},NumberLiteral:function(t,e){this.loc=e,this.type="NumberLiteral",this.original=this.value=Number(t)},BooleanLiteral:function(t,e){this.loc=e,this.type="BooleanLiteral",this.original=this.value="true"===t},Hash:function(t,e){this.loc=e,this.type="Hash",this.pairs=t},HashPair:function(t,e,r){this.loc=r,this.type="HashPair",this.key=t,this.value=e}});e["default"]=r}),t("htmlbars-syntax/handlebars/compiler/base",["./parser","./ast","./whitespace-control","./helpers","../utils","exports"],function(t,e,r,n,i,s){"use strict";function o(t,e){if("Program"===t.type)return t;a.yy=h,h.locInfo=function(t){return new h.SourceLocation(e&&e.srcName,t)};var r=new c;return r.accept(a.parse(t))}var a=t["default"],l=e["default"],c=r["default"],u=n,p=i.extend;s.parser=a;var h={};p(h,u,l),s.parse=o}),t("htmlbars-syntax/handlebars/compiler/helpers",["../exception","exports"],function(t,e){"use strict";function r(t,e){this.source=t,this.start={line:e.first_line,column:e.first_column},this.end={line:e.last_line,column:e.last_column}}function n(t,e){return{open:"~"===t.charAt(2),close:"~"===e.charAt(e.length-3)}}function i(t){return t.replace(/^\{\{~?\!-?-?/,"").replace(/-?-?~?\}\}$/,"")}function s(t,e,r){r=this.locInfo(r);for(var n=t?"@":"",i=[],s=0,o="",a=0,l=e.length;l>a;a++){var u=e[a].part;if(n+=(e[a].separator||"")+u,".."===u||"."===u||"this"===u){if(i.length>0)throw new c("Invalid path: "+n,{loc:r});".."===u&&(s++,o+="../")}else i.push(u)}return new this.PathExpression(t,s,i,n,r)}function o(t,e,r,n){var i=e.charAt(3)||e.charAt(2),s="{"!==i&&"&"!==i;return new this.MustacheStatement(t,s,r,this.locInfo(n))}function a(t,e,r,n){if(t.sexpr.path.original!==r){var i={loc:t.sexpr.loc};throw new c(t.sexpr.path.original+" doesn't match "+r,i)}n=this.locInfo(n);var s=new this.Program([e],null,{},n);return new this.BlockStatement(t.sexpr,s,void 0,{},{},{},n)}function l(t,e,r,n,i,s){if(n&&n.path&&t.sexpr.path.original!==n.path.original){var o={loc:t.sexpr.loc};throw new c(t.sexpr.path.original+" doesn't match "+n.path.original,o)}e.blockParams=t.blockParams;var a,l;return r&&(r.chain&&(r.program.body[0].closeStrip=n.strip||n.openStrip),l=r.strip,a=r.program),i&&(i=a,a=e,e=i),new this.BlockStatement(t.sexpr,e,a,t.strip,l,n&&(n.strip||n.openStrip),this.locInfo(s))
-}var c=t["default"];e.SourceLocation=r,e.stripFlags=n,e.stripComment=i,e.preparePath=s,e.prepareMustache=o,e.prepareRawBlock=a,e.prepareBlock=l}),t("htmlbars-syntax/handlebars/compiler/parser",["exports"],function(t){"use strict";var e=function(){function t(){this.yy={}}var e={trace:function(){},yy:{},symbols_:{error:2,root:3,program:4,EOF:5,program_repetition0:6,statement:7,mustache:8,block:9,rawBlock:10,partial:11,content:12,COMMENT:13,CONTENT:14,openRawBlock:15,END_RAW_BLOCK:16,OPEN_RAW_BLOCK:17,sexpr:18,CLOSE_RAW_BLOCK:19,openBlock:20,block_option0:21,closeBlock:22,openInverse:23,block_option1:24,OPEN_BLOCK:25,openBlock_option0:26,CLOSE:27,OPEN_INVERSE:28,openInverse_option0:29,openInverseChain:30,OPEN_INVERSE_CHAIN:31,openInverseChain_option0:32,inverseAndProgram:33,INVERSE:34,inverseChain:35,inverseChain_option0:36,OPEN_ENDBLOCK:37,path:38,OPEN:39,OPEN_UNESCAPED:40,CLOSE_UNESCAPED:41,OPEN_PARTIAL:42,helperName:43,sexpr_repetition0:44,sexpr_option0:45,dataName:46,param:47,STRING:48,NUMBER:49,BOOLEAN:50,OPEN_SEXPR:51,CLOSE_SEXPR:52,hash:53,hash_repetition_plus0:54,hashSegment:55,ID:56,EQUALS:57,blockParams:58,OPEN_BLOCK_PARAMS:59,blockParams_repetition_plus0:60,CLOSE_BLOCK_PARAMS:61,DATA:62,pathSegments:63,SEP:64,$accept:0,$end:1},terminals_:{2:"error",5:"EOF",13:"COMMENT",14:"CONTENT",16:"END_RAW_BLOCK",17:"OPEN_RAW_BLOCK",19:"CLOSE_RAW_BLOCK",25:"OPEN_BLOCK",27:"CLOSE",28:"OPEN_INVERSE",31:"OPEN_INVERSE_CHAIN",34:"INVERSE",37:"OPEN_ENDBLOCK",39:"OPEN",40:"OPEN_UNESCAPED",41:"CLOSE_UNESCAPED",42:"OPEN_PARTIAL",48:"STRING",49:"NUMBER",50:"BOOLEAN",51:"OPEN_SEXPR",52:"CLOSE_SEXPR",56:"ID",57:"EQUALS",59:"OPEN_BLOCK_PARAMS",61:"CLOSE_BLOCK_PARAMS",62:"DATA",64:"SEP"},productions_:[0,[3,2],[4,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[12,1],[10,3],[15,3],[9,4],[9,4],[20,4],[23,4],[30,4],[33,2],[35,3],[35,1],[22,3],[8,3],[8,3],[11,3],[18,3],[18,1],[47,1],[47,1],[47,1],[47,1],[47,1],[47,3],[53,1],[55,3],[58,3],[43,1],[43,1],[43,1],[46,2],[38,1],[63,3],[63,1],[6,0],[6,2],[21,0],[21,1],[24,0],[24,1],[26,0],[26,1],[29,0],[29,1],[32,0],[32,1],[36,0],[36,1],[44,0],[44,2],[45,0],[45,1],[54,1],[54,2],[60,1],[60,2]],performAction:function(t,e,r,n,i,s){var o=s.length-1;switch(i){case 1:return s[o-1];case 2:this.$=new n.Program(s[o],null,{},n.locInfo(this._$));break;case 3:this.$=s[o];break;case 4:this.$=s[o];break;case 5:this.$=s[o];break;case 6:this.$=s[o];break;case 7:this.$=s[o];break;case 8:this.$=new n.CommentStatement(n.stripComment(s[o]),n.stripFlags(s[o],s[o]),n.locInfo(this._$));break;case 9:this.$=new n.ContentStatement(s[o],n.locInfo(this._$));break;case 10:this.$=n.prepareRawBlock(s[o-2],s[o-1],s[o],this._$);break;case 11:this.$={sexpr:s[o-1]};break;case 12:this.$=n.prepareBlock(s[o-3],s[o-2],s[o-1],s[o],!1,this._$);break;case 13:this.$=n.prepareBlock(s[o-3],s[o-2],s[o-1],s[o],!0,this._$);break;case 14:this.$={sexpr:s[o-2],blockParams:s[o-1],strip:n.stripFlags(s[o-3],s[o])};break;case 15:this.$={sexpr:s[o-2],blockParams:s[o-1],strip:n.stripFlags(s[o-3],s[o])};break;case 16:this.$={sexpr:s[o-2],blockParams:s[o-1],strip:n.stripFlags(s[o-3],s[o])};break;case 17:this.$={strip:n.stripFlags(s[o-1],s[o-1]),program:s[o]};break;case 18:var a=n.prepareBlock(s[o-2],s[o-1],s[o],s[o],!1,this._$),l=new n.Program([a],null,{},n.locInfo(this._$));l.chained=!0,this.$={strip:s[o-2].strip,program:l,chain:!0};break;case 19:this.$=s[o];break;case 20:this.$={path:s[o-1],strip:n.stripFlags(s[o-2],s[o])};break;case 21:this.$=n.prepareMustache(s[o-1],s[o-2],n.stripFlags(s[o-2],s[o]),this._$);break;case 22:this.$=n.prepareMustache(s[o-1],s[o-2],n.stripFlags(s[o-2],s[o]),this._$);break;case 23:this.$=new n.PartialStatement(s[o-1],n.stripFlags(s[o-2],s[o]),n.locInfo(this._$));break;case 24:this.$=new n.SubExpression(s[o-2],s[o-1],s[o],n.locInfo(this._$));break;case 25:this.$=new n.SubExpression(s[o],null,null,n.locInfo(this._$));break;case 26:this.$=s[o];break;case 27:this.$=new n.StringLiteral(s[o],n.locInfo(this._$));break;case 28:this.$=new n.NumberLiteral(s[o],n.locInfo(this._$));break;case 29:this.$=new n.BooleanLiteral(s[o],n.locInfo(this._$));break;case 30:this.$=s[o];break;case 31:this.$=s[o-1];break;case 32:this.$=new n.Hash(s[o],n.locInfo(this._$));break;case 33:this.$=new n.HashPair(s[o-2],s[o],n.locInfo(this._$));break;case 34:this.$=s[o-1];break;case 35:this.$=s[o];break;case 36:this.$=new n.StringLiteral(s[o],n.locInfo(this._$)),n.locInfo(this._$);break;case 37:this.$=new n.NumberLiteral(s[o],n.locInfo(this._$));break;case 38:this.$=n.preparePath(!0,s[o],this._$);break;case 39:this.$=n.preparePath(!1,s[o],this._$);break;case 40:s[o-2].push({part:s[o],separator:s[o-1]}),this.$=s[o-2];break;case 41:this.$=[{part:s[o]}];break;case 42:this.$=[];break;case 43:s[o-1].push(s[o]);break;case 56:this.$=[];break;case 57:s[o-1].push(s[o]);break;case 60:this.$=[s[o]];break;case 61:s[o-1].push(s[o]);break;case 62:this.$=[s[o]];break;case 63:s[o-1].push(s[o])}},table:[{3:1,4:2,5:[2,42],6:3,13:[2,42],14:[2,42],17:[2,42],25:[2,42],28:[2,42],39:[2,42],40:[2,42],42:[2,42]},{1:[3]},{5:[1,4]},{5:[2,2],7:5,8:6,9:7,10:8,11:9,12:10,13:[1,11],14:[1,18],15:16,17:[1,21],20:14,23:15,25:[1,19],28:[1,20],31:[2,2],34:[2,2],37:[2,2],39:[1,12],40:[1,13],42:[1,17]},{1:[2,1]},{5:[2,43],13:[2,43],14:[2,43],17:[2,43],25:[2,43],28:[2,43],31:[2,43],34:[2,43],37:[2,43],39:[2,43],40:[2,43],42:[2,43]},{5:[2,3],13:[2,3],14:[2,3],17:[2,3],25:[2,3],28:[2,3],31:[2,3],34:[2,3],37:[2,3],39:[2,3],40:[2,3],42:[2,3]},{5:[2,4],13:[2,4],14:[2,4],17:[2,4],25:[2,4],28:[2,4],31:[2,4],34:[2,4],37:[2,4],39:[2,4],40:[2,4],42:[2,4]},{5:[2,5],13:[2,5],14:[2,5],17:[2,5],25:[2,5],28:[2,5],31:[2,5],34:[2,5],37:[2,5],39:[2,5],40:[2,5],42:[2,5]},{5:[2,6],13:[2,6],14:[2,6],17:[2,6],25:[2,6],28:[2,6],31:[2,6],34:[2,6],37:[2,6],39:[2,6],40:[2,6],42:[2,6]},{5:[2,7],13:[2,7],14:[2,7],17:[2,7],25:[2,7],28:[2,7],31:[2,7],34:[2,7],37:[2,7],39:[2,7],40:[2,7],42:[2,7]},{5:[2,8],13:[2,8],14:[2,8],17:[2,8],25:[2,8],28:[2,8],31:[2,8],34:[2,8],37:[2,8],39:[2,8],40:[2,8],42:[2,8]},{18:22,38:25,43:23,46:24,48:[1,26],49:[1,27],56:[1,30],62:[1,28],63:29},{18:31,38:25,43:23,46:24,48:[1,26],49:[1,27],56:[1,30],62:[1,28],63:29},{4:32,6:3,13:[2,42],14:[2,42],17:[2,42],25:[2,42],28:[2,42],31:[2,42],34:[2,42],37:[2,42],39:[2,42],40:[2,42],42:[2,42]},{4:33,6:3,13:[2,42],14:[2,42],17:[2,42],25:[2,42],28:[2,42],34:[2,42],37:[2,42],39:[2,42],40:[2,42],42:[2,42]},{12:34,14:[1,18]},{18:35,38:25,43:23,46:24,48:[1,26],49:[1,27],56:[1,30],62:[1,28],63:29},{5:[2,9],13:[2,9],14:[2,9],16:[2,9],17:[2,9],25:[2,9],28:[2,9],31:[2,9],34:[2,9],37:[2,9],39:[2,9],40:[2,9],42:[2,9]},{18:36,38:25,43:23,46:24,48:[1,26],49:[1,27],56:[1,30],62:[1,28],63:29},{18:37,38:25,43:23,46:24,48:[1,26],49:[1,27],56:[1,30],62:[1,28],63:29},{18:38,38:25,43:23,46:24,48:[1,26],49:[1,27],56:[1,30],62:[1,28],63:29},{27:[1,39]},{19:[2,56],27:[2,56],41:[2,56],44:40,48:[2,56],49:[2,56],50:[2,56],51:[2,56],52:[2,56],56:[2,56],59:[2,56],62:[2,56]},{19:[2,25],27:[2,25],41:[2,25],52:[2,25],59:[2,25]},{19:[2,35],27:[2,35],41:[2,35],48:[2,35],49:[2,35],50:[2,35],51:[2,35],52:[2,35],56:[2,35],59:[2,35],62:[2,35]},{19:[2,36],27:[2,36],41:[2,36],48:[2,36],49:[2,36],50:[2,36],51:[2,36],52:[2,36],56:[2,36],59:[2,36],62:[2,36]},{19:[2,37],27:[2,37],41:[2,37],48:[2,37],49:[2,37],50:[2,37],51:[2,37],52:[2,37],56:[2,37],59:[2,37],62:[2,37]},{56:[1,30],63:41},{19:[2,39],27:[2,39],41:[2,39],48:[2,39],49:[2,39],50:[2,39],51:[2,39],52:[2,39],56:[2,39],59:[2,39],62:[2,39],64:[1,42]},{19:[2,41],27:[2,41],41:[2,41],48:[2,41],49:[2,41],50:[2,41],51:[2,41],52:[2,41],56:[2,41],59:[2,41],62:[2,41],64:[2,41]},{41:[1,43]},{21:44,30:46,31:[1,48],33:47,34:[1,49],35:45,37:[2,44]},{24:50,33:51,34:[1,49],37:[2,46]},{16:[1,52]},{27:[1,53]},{26:54,27:[2,48],58:55,59:[1,56]},{27:[2,50],29:57,58:58,59:[1,56]},{19:[1,59]},{5:[2,21],13:[2,21],14:[2,21],17:[2,21],25:[2,21],28:[2,21],31:[2,21],34:[2,21],37:[2,21],39:[2,21],40:[2,21],42:[2,21]},{19:[2,58],27:[2,58],38:63,41:[2,58],45:60,46:67,47:61,48:[1,64],49:[1,65],50:[1,66],51:[1,68],52:[2,58],53:62,54:69,55:70,56:[1,71],59:[2,58],62:[1,28],63:29},{19:[2,38],27:[2,38],41:[2,38],48:[2,38],49:[2,38],50:[2,38],51:[2,38],52:[2,38],56:[2,38],59:[2,38],62:[2,38],64:[1,42]},{56:[1,72]},{5:[2,22],13:[2,22],14:[2,22],17:[2,22],25:[2,22],28:[2,22],31:[2,22],34:[2,22],37:[2,22],39:[2,22],40:[2,22],42:[2,22]},{22:73,37:[1,74]},{37:[2,45]},{4:75,6:3,13:[2,42],14:[2,42],17:[2,42],25:[2,42],28:[2,42],31:[2,42],34:[2,42],37:[2,42],39:[2,42],40:[2,42],42:[2,42]},{37:[2,19]},{18:76,38:25,43:23,46:24,48:[1,26],49:[1,27],56:[1,30],62:[1,28],63:29},{4:77,6:3,13:[2,42],14:[2,42],17:[2,42],25:[2,42],28:[2,42],37:[2,42],39:[2,42],40:[2,42],42:[2,42]},{22:78,37:[1,74]},{37:[2,47]},{5:[2,10],13:[2,10],14:[2,10],17:[2,10],25:[2,10],28:[2,10],31:[2,10],34:[2,10],37:[2,10],39:[2,10],40:[2,10],42:[2,10]},{5:[2,23],13:[2,23],14:[2,23],17:[2,23],25:[2,23],28:[2,23],31:[2,23],34:[2,23],37:[2,23],39:[2,23],40:[2,23],42:[2,23]},{27:[1,79]},{27:[2,49]},{56:[1,81],60:80},{27:[1,82]},{27:[2,51]},{14:[2,11]},{19:[2,24],27:[2,24],41:[2,24],52:[2,24],59:[2,24]},{19:[2,57],27:[2,57],41:[2,57],48:[2,57],49:[2,57],50:[2,57],51:[2,57],52:[2,57],56:[2,57],59:[2,57],62:[2,57]},{19:[2,59],27:[2,59],41:[2,59],52:[2,59],59:[2,59]},{19:[2,26],27:[2,26],41:[2,26],48:[2,26],49:[2,26],50:[2,26],51:[2,26],52:[2,26],56:[2,26],59:[2,26],62:[2,26]},{19:[2,27],27:[2,27],41:[2,27],48:[2,27],49:[2,27],50:[2,27],51:[2,27],52:[2,27],56:[2,27],59:[2,27],62:[2,27]},{19:[2,28],27:[2,28],41:[2,28],48:[2,28],49:[2,28],50:[2,28],51:[2,28],52:[2,28],56:[2,28],59:[2,28],62:[2,28]},{19:[2,29],27:[2,29],41:[2,29],48:[2,29],49:[2,29],50:[2,29],51:[2,29],52:[2,29],56:[2,29],59:[2,29],62:[2,29]},{19:[2,30],27:[2,30],41:[2,30],48:[2,30],49:[2,30],50:[2,30],51:[2,30],52:[2,30],56:[2,30],59:[2,30],62:[2,30]},{18:83,38:25,43:23,46:24,48:[1,26],49:[1,27],56:[1,30],62:[1,28],63:29},{19:[2,32],27:[2,32],41:[2,32],52:[2,32],55:84,56:[1,85],59:[2,32]},{19:[2,60],27:[2,60],41:[2,60],52:[2,60],56:[2,60],59:[2,60]},{19:[2,41],27:[2,41],41:[2,41],48:[2,41],49:[2,41],50:[2,41],51:[2,41],52:[2,41],56:[2,41],57:[1,86],59:[2,41],62:[2,41],64:[2,41]},{19:[2,40],27:[2,40],41:[2,40],48:[2,40],49:[2,40],50:[2,40],51:[2,40],52:[2,40],56:[2,40],59:[2,40],62:[2,40],64:[2,40]},{5:[2,12],13:[2,12],14:[2,12],17:[2,12],25:[2,12],28:[2,12],31:[2,12],34:[2,12],37:[2,12],39:[2,12],40:[2,12],42:[2,12]},{38:87,56:[1,30],63:29},{30:46,31:[1,48],33:47,34:[1,49],35:89,36:88,37:[2,54]},{27:[2,52],32:90,58:91,59:[1,56]},{37:[2,17]},{5:[2,13],13:[2,13],14:[2,13],17:[2,13],25:[2,13],28:[2,13],31:[2,13],34:[2,13],37:[2,13],39:[2,13],40:[2,13],42:[2,13]},{13:[2,14],14:[2,14],17:[2,14],25:[2,14],28:[2,14],31:[2,14],34:[2,14],37:[2,14],39:[2,14],40:[2,14],42:[2,14]},{56:[1,93],61:[1,92]},{56:[2,62],61:[2,62]},{13:[2,15],14:[2,15],17:[2,15],25:[2,15],28:[2,15],34:[2,15],37:[2,15],39:[2,15],40:[2,15],42:[2,15]},{52:[1,94]},{19:[2,61],27:[2,61],41:[2,61],52:[2,61],56:[2,61],59:[2,61]},{57:[1,86]},{38:63,46:67,47:95,48:[1,64],49:[1,65],50:[1,66],51:[1,68],56:[1,30],62:[1,28],63:29},{27:[1,96]},{37:[2,18]},{37:[2,55]},{27:[1,97]},{27:[2,53]},{27:[2,34]},{56:[2,63],61:[2,63]},{19:[2,31],27:[2,31],41:[2,31],48:[2,31],49:[2,31],50:[2,31],51:[2,31],52:[2,31],56:[2,31],59:[2,31],62:[2,31]},{19:[2,33],27:[2,33],41:[2,33],52:[2,33],56:[2,33],59:[2,33]},{5:[2,20],13:[2,20],14:[2,20],17:[2,20],25:[2,20],28:[2,20],31:[2,20],34:[2,20],37:[2,20],39:[2,20],40:[2,20],42:[2,20]},{13:[2,16],14:[2,16],17:[2,16],25:[2,16],28:[2,16],31:[2,16],34:[2,16],37:[2,16],39:[2,16],40:[2,16],42:[2,16]}],defaultActions:{4:[2,1],45:[2,45],47:[2,19],51:[2,47],55:[2,49],58:[2,51],59:[2,11],77:[2,17],88:[2,18],89:[2,55],91:[2,53],92:[2,34]},parseError:function(t){throw new Error(t)},parse:function(t){function e(){var t;return t=r.lexer.lex()||1,"number"!=typeof t&&(t=r.symbols_[t]||t),t}var r=this,n=[0],i=[null],s=[],o=this.table,a="",l=0,c=0,u=0;this.lexer.setInput(t),this.lexer.yy=this.yy,this.yy.lexer=this.lexer,this.yy.parser=this,"undefined"==typeof this.lexer.yylloc&&(this.lexer.yylloc={});var p=this.lexer.yylloc;s.push(p);var h=this.lexer.options&&this.lexer.options.ranges;"function"==typeof this.yy.parseError&&(this.parseError=this.yy.parseError);for(var m,d,f,g,b,y,v,k,x,E={};;){if(f=n[n.length-1],this.defaultActions[f]?g=this.defaultActions[f]:((null===m||"undefined"==typeof m)&&(m=e()),g=o[f]&&o[f][m]),"undefined"==typeof g||!g.length||!g[0]){var w="";if(!u){x=[];for(y in o[f])this.terminals_[y]&&y>2&&x.push("'"+this.terminals_[y]+"'");w=this.lexer.showPosition?"Parse error on line "+(l+1)+":\n"+this.lexer.showPosition()+"\nExpecting "+x.join(", ")+", got '"+(this.terminals_[m]||m)+"'":"Parse error on line "+(l+1)+": Unexpected "+(1==m?"end of input":"'"+(this.terminals_[m]||m)+"'"),this.parseError(w,{text:this.lexer.match,token:this.terminals_[m]||m,line:this.lexer.yylineno,loc:p,expected:x})}}if(g[0]instanceof Array&&g.length>1)throw new Error("Parse Error: multiple actions possible at state: "+f+", token: "+m);switch(g[0]){case 1:n.push(m),i.push(this.lexer.yytext),s.push(this.lexer.yylloc),n.push(g[1]),m=null,d?(m=d,d=null):(c=this.lexer.yyleng,a=this.lexer.yytext,l=this.lexer.yylineno,p=this.lexer.yylloc,u>0&&u--);break;case 2:if(v=this.productions_[g[1]][1],E.$=i[i.length-v],E._$={first_line:s[s.length-(v||1)].first_line,last_line:s[s.length-1].last_line,first_column:s[s.length-(v||1)].first_column,last_column:s[s.length-1].last_column},h&&(E._$.range=[s[s.length-(v||1)].range[0],s[s.length-1].range[1]]),b=this.performAction.call(E,a,c,l,this.yy,g[1],i,s),"undefined"!=typeof b)return b;v&&(n=n.slice(0,-1*v*2),i=i.slice(0,-1*v),s=s.slice(0,-1*v)),n.push(this.productions_[g[1]][0]),i.push(E.$),s.push(E._$),k=o[n[n.length-2]][n[n.length-1]],n.push(k);break;case 3:return!0}}return!0}},r=function(){var t={EOF:1,parseError:function(t,e){if(!this.yy.parser)throw new Error(t);this.yy.parser.parseError(t,e)},setInput:function(t){return this._input=t,this._more=this._less=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},input:function(){var t=this._input[0];this.yytext+=t,this.yyleng++,this.offset++,this.match+=t,this.matched+=t;var e=t.match(/(?:\r\n?|\n).*/g);return e?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),t},unput:function(t){var e=t.length,r=t.split(/(?:\r\n?|\n)/g);this._input=t+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-e-1),this.offset-=e;var n=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),r.length-1&&(this.yylineno-=r.length-1);var i=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:r?(r.length===n.length?this.yylloc.first_column:0)+n[n.length-r.length].length-r[0].length:this.yylloc.first_column-e},this.options.ranges&&(this.yylloc.range=[i[0],i[0]+this.yyleng-e]),this},more:function(){return this._more=!0,this},less:function(t){this.unput(this.match.slice(t))},pastInput:function(){var t=this.matched.substr(0,this.matched.length-this.match.length);return(t.length>20?"...":"")+t.substr(-20).replace(/\n/g,"")},upcomingInput:function(){var t=this.match;return t.length<20&&(t+=this._input.substr(0,20-t.length)),(t.substr(0,20)+(t.length>20?"...":"")).replace(/\n/g,"")},showPosition:function(){var t=this.pastInput(),e=new Array(t.length+1).join("-");return t+this.upcomingInput()+"\n"+e+"^"},next:function(){if(this.done)return this.EOF;this._input||(this.done=!0);var t,e,r,n,i;this._more||(this.yytext="",this.match="");for(var s=this._currentRules(),o=0;oe[0].length)||(e=r,n=o,this.options.flex));o++);return e?(i=e[0].match(/(?:\r\n?|\n).*/g),i&&(this.yylineno+=i.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:i?i[i.length-1].length-i[i.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+e[0].length},this.yytext+=e[0],this.match+=e[0],this.matches=e,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._input=this._input.slice(e[0].length),this.matched+=e[0],t=this.performAction.call(this,this.yy,this,s[n],this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),t?t:void 0):""===this._input?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+". Unrecognized text.\n"+this.showPosition(),{text:"",token:null,line:this.yylineno})},lex:function(){var t=this.next();return"undefined"!=typeof t?t:this.lex()},begin:function(t){this.conditionStack.push(t)},popState:function(){return this.conditionStack.pop()},_currentRules:function(){return this.conditions[this.conditionStack[this.conditionStack.length-1]].rules},topState:function(){return this.conditionStack[this.conditionStack.length-2]},pushState:function(t){this.begin(t)}};return t.options={},t.performAction=function(t,e,r,n){function i(t,r){return e.yytext=e.yytext.substr(t,e.yyleng-r)}switch(r){case 0:if("\\\\"===e.yytext.slice(-2)?(i(0,1),this.begin("mu")):"\\"===e.yytext.slice(-1)?(i(0,1),this.begin("emu")):this.begin("mu"),e.yytext)return 14;break;case 1:return 14;case 2:return this.popState(),14;case 3:return e.yytext=e.yytext.substr(5,e.yyleng-9),this.popState(),16;case 4:return 14;case 5:return this.popState(),13;case 6:return 51;case 7:return 52;case 8:return 17;case 9:return this.popState(),this.begin("raw"),19;case 10:return 42;case 11:return 25;case 12:return 37;case 13:return this.popState(),34;case 14:return this.popState(),34;case 15:return 28;case 16:return 31;case 17:return 40;case 18:return 39;case 19:this.unput(e.yytext),this.popState(),this.begin("com");break;case 20:return this.popState(),13;case 21:return 39;case 22:return 57;case 23:return 56;case 24:return 56;case 25:return 64;case 26:break;case 27:return this.popState(),41;case 28:return this.popState(),27;case 29:return e.yytext=i(1,2).replace(/\\"/g,'"'),48;case 30:return e.yytext=i(1,2).replace(/\\'/g,"'"),48;case 31:return 62;case 32:return 50;case 33:return 50;case 34:return 49;case 35:return 59;case 36:return 61;case 37:return 56;case 38:return e.yytext=i(1,2),56;case 39:return"INVALID";case 40:return 5}},t.rules=[/^(?:[^\x00]*?(?=(\{\{)))/,/^(?:[^\x00]+)/,/^(?:[^\x00]{2,}?(?=(\{\{|\\\{\{|\\\\\{\{|$)))/,/^(?:\{\{\{\{\/[^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=[=}\s\/.])\}\}\}\})/,/^(?:[^\x00]*?(?=(\{\{\{\{\/)))/,/^(?:[\s\S]*?--(~)?\}\})/,/^(?:\()/,/^(?:\))/,/^(?:\{\{\{\{)/,/^(?:\}\}\}\})/,/^(?:\{\{(~)?>)/,/^(?:\{\{(~)?#)/,/^(?:\{\{(~)?\/)/,/^(?:\{\{(~)?\^\s*(~)?\}\})/,/^(?:\{\{(~)?\s*else\s*(~)?\}\})/,/^(?:\{\{(~)?\^)/,/^(?:\{\{(~)?\s*else\b)/,/^(?:\{\{(~)?\{)/,/^(?:\{\{(~)?&)/,/^(?:\{\{(~)?!--)/,/^(?:\{\{(~)?![\s\S]*?\}\})/,/^(?:\{\{(~)?)/,/^(?:=)/,/^(?:\.\.)/,/^(?:\.(?=([=~}\s\/.)|])))/,/^(?:[\/.])/,/^(?:\s+)/,/^(?:\}(~)?\}\})/,/^(?:(~)?\}\})/,/^(?:"(\\["]|[^"])*")/,/^(?:'(\\[']|[^'])*')/,/^(?:@)/,/^(?:true(?=([~}\s)])))/,/^(?:false(?=([~}\s)])))/,/^(?:-?[0-9]+(?:\.[0-9]+)?(?=([~}\s)])))/,/^(?:as\s+\|)/,/^(?:\|)/,/^(?:([^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=([=~}\s\/.)|]))))/,/^(?:\[[^\]]*\])/,/^(?:.)/,/^(?:$)/],t.conditions={mu:{rules:[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40],inclusive:!1},emu:{rules:[2],inclusive:!1},com:{rules:[5],inclusive:!1},raw:{rules:[3,4],inclusive:!1},INITIAL:{rules:[0,1,40],inclusive:!0}},t}();return e.lexer=r,t.prototype=e,e.Parser=t,new t}();t["default"]=e}),t("htmlbars-syntax/handlebars/compiler/visitor",["exports"],function(t){"use strict";function e(){}e.prototype={constructor:e,accept:function(t){return t&&this[t.type](t)},Program:function(t){var e,r,n=t.body;for(e=0,r=n.length;r>e;e++)this.accept(n[e])},MustacheStatement:function(t){this.accept(t.sexpr)},BlockStatement:function(t){this.accept(t.sexpr),this.accept(t.program),this.accept(t.inverse)},PartialStatement:function(t){this.accept(t.partialName),this.accept(t.context),this.accept(t.hash)},ContentStatement:function(){},CommentStatement:function(){},SubExpression:function(t){var e=t.params;this.accept(t.path);for(var r=0,n=e.length;n>r;r++)this.accept(e[r]);this.accept(t.hash)},PathExpression:function(){},StringLiteral:function(){},NumberLiteral:function(){},BooleanLiteral:function(){},Hash:function(t){for(var e=t.pairs,r=0,n=e.length;n>r;r++)this.accept(e[r])},HashPair:function(t){this.accept(t.value)}},t["default"]=e}),t("htmlbars-syntax/handlebars/compiler/whitespace-control",["./visitor","exports"],function(t,e){"use strict";function r(){}function n(t,e,r){void 0===e&&(e=t.length);var n=t[e-1],i=t[e-2];return n?"ContentStatement"===n.type?(i||!r?/\r?\n\s*?$/:/(^|\r?\n)\s*?$/).test(n.original):void 0:r}function i(t,e,r){void 0===e&&(e=-1);var n=t[e+1],i=t[e+2];return n?"ContentStatement"===n.type?(i||!r?/^\s*?\r?\n/:/^\s*?(\r?\n|$)/).test(n.original):void 0:r}function s(t,e,r){var n=t[null==e?0:e+1];if(n&&"ContentStatement"===n.type&&(r||!n.rightStripped)){var i=n.value;n.value=n.value.replace(r?/^\s+/:/^[ \t]*\r?\n?/,""),n.rightStripped=n.value!==i}}function o(t,e,r){var n=t[null==e?t.length-1:e-1];if(n&&"ContentStatement"===n.type&&(r||!n.leftStripped)){var i=n.value;return n.value=n.value.replace(r?/\s+$/:/[ \t]+$/,""),n.leftStripped=n.value!==i,n.leftStripped}}var a=t["default"];r.prototype=new a,r.prototype.Program=function(t){var e=!this.isRootSeen;this.isRootSeen=!0;for(var r=t.body,a=0,l=r.length;l>a;a++){var c=r[a],u=this.accept(c);if(u){var p=n(r,a,e),h=i(r,a,e),m=u.openStandalone&&p,d=u.closeStandalone&&h,f=u.inlineStandalone&&p&&h;u.close&&s(r,a,!0),u.open&&o(r,a,!0),f&&(s(r,a),o(r,a)&&"PartialStatement"===c.type&&(c.indent=/([ \t]+$)/.exec(r[a-1].original)[1])),m&&(s((c.program||c.inverse).body),o(r,a)),d&&(s(r,a),o((c.inverse||c.program).body))}}return t},r.prototype.BlockStatement=function(t){this.accept(t.program),this.accept(t.inverse);var e=t.program||t.inverse,r=t.program&&t.inverse,a=r,l=r;if(r&&r.chained)for(a=r.body[0].program;l.chained;)l=l.body[l.body.length-1].program;var c={open:t.openStrip.open,close:t.closeStrip.close,openStandalone:i(e.body),closeStandalone:n((a||e).body)};if(t.openStrip.close&&s(e.body,null,!0),r){var u=t.inverseStrip;u.open&&o(e.body,null,!0),u.close&&s(a.body,null,!0),t.closeStrip.open&&o(l.body,null,!0),n(e.body)&&i(a.body)&&(o(e.body),s(a.body))}else t.closeStrip.open&&o(e.body,null,!0);return c},r.prototype.MustacheStatement=function(t){return t.strip},r.prototype.PartialStatement=r.prototype.CommentStatement=function(t){var e=t.strip||{};return{inlineStandalone:!0,open:e.open,close:e.close}},e["default"]=r}),t("htmlbars-syntax/handlebars/exception",["exports"],function(t){"use strict";function e(t,e){var n,i,s=e&&e.loc;s&&(n=s.start.line,i=s.start.column,t+=" - "+n+":"+i);for(var o=Error.prototype.constructor.call(this,t),a=0;a":">",'"':""","'":"'","`":"`"}),l=/[&<>"'`]/g,c=/[&<>"'`]/;e.extend=n;var u=Object.prototype.toString;e.toString=u;var p=function(t){return"function"==typeof t};p(/x/)&&(p=function(t){return"function"==typeof t&&"[object Function]"===u.call(t)});var p;e.isFunction=p;var h=Array.isArray||function(t){return t&&"object"==typeof t?"[object Array]"===u.call(t):!1};e.isArray=h,e.escapeExpression=i,e.isEmpty=s,e.appendContextPath=o}),t("htmlbars-syntax/node-handlers",["./builders","../htmlbars-util/array-utils","./utils","exports"],function(t,e,r,n){"use strict";function i(t){var e=t.tokenizer.token;e&&"Chars"===e.type&&(t.acceptToken(e),t.tokenizer.token=null)}function s(t,e){if(""===e)return t.split("\n").length-1;var r=t.split(e)[0],n=r.split(/\n/);return n.length-1}var o=t.buildProgram,a=t.buildBlock,l=t.buildHash,c=e.forEach,u=r.appendChild,p=r.postprocessProgram,h={Program:function(t){var e,r=[],n=o(r,t.blockParams),i=t.body.length;if(this.elementStack.push(n),0===i)return this.elementStack.pop();for(e=0;i>e;e++)this.acceptNode(t.body[e]);this.acceptToken(this.tokenizer.tokenizeEOF()),p(n);var s=this.elementStack.pop();if(s!==n)throw new Error("Unclosed element `"+s.tag+"` (on line "+s.loc.start.line+").");return n},BlockStatement:function(t){if(delete t.inverseStrip,delete t.openString,delete t.closeStrip,"comment"===this.tokenizer.state)return void this.tokenizer.addChar("{{"+this.sourceForMustache(t)+"}}");i(this),this.acceptToken(t);var e=this.acceptNode(t.sexpr),r=t.program?this.acceptNode(t.program):null,n=t.inverse?this.acceptNode(t.inverse):null,s=a(e,r,n),o=this.currentElement();u(o,s)},MustacheStatement:function(t){return delete t.strip,"comment"===this.tokenizer.state?void this.tokenizer.addChar("{{"+this.sourceForMustache(t)+"}}"):(this.acceptNode(t.sexpr),i(this),this.acceptToken(t),t)},ContentStatement:function(t){var e=0;t.rightStripped&&(e=s(t.original,t.value)),this.tokenizer.line=this.tokenizer.line+e;var r=this.tokenizer.tokenizePart(t.value);return c(r,this.acceptToken,this)},CommentStatement:function(t){return t},PartialStatement:function(t){return u(this.currentElement(),t),t},SubExpression:function(t){if(delete t.isHelper,this.acceptNode(t.path),t.params)for(var e=0;ei;i++){var o=new e.plugins.ast[i];o.syntax=b,n=o.transform(n)}return n}function c(t,e){this.options=e||{},this.elementStack=[],this.tokenizer=new h("",new m(d)),this.nodeHandlers=f,this.tokenHandlers=g,"string"==typeof t&&(this.source=u(t))}var u,p=t.parse,h=e.Tokenizer,m=r["default"],d=n["default"],f=i["default"],g=s["default"],b=o;u=2==="foo\n\nbar".split(/\n/).length?function(t){var e=t.replace(/\r\n?/g,"\n");return e.split("\n")}:function(t){return t.split(/(?:\r\n?|\n)/g)},a.preprocess=l,c.prototype.acceptNode=function(t){return this.nodeHandlers[t.type].call(this,t)},c.prototype.acceptToken=function(t){return t?this.tokenHandlers[t.type].call(this,t):void 0},c.prototype.currentElement=function(){return this.elementStack[this.elementStack.length-1]},c.prototype.sourceForMustache=function(t){var e,r=t.loc.start.line-1,n=t.loc.end.line-1,i=r-1,s=t.loc.start.column+2,o=t.loc.end.column-2,a=[];if(!this.source)return"{{"+t.path.id.original+"}}";for(;n>i;)i++,e=this.source[i],a.push(i===r?r===n?e.slice(s,o):e.slice(s):i===n?e.slice(0,o):e);return a.join("\n")}}),t("htmlbars-syntax/token-handlers",["../htmlbars-util/array-utils","./builders","./utils","exports"],function(t,e,r,n){"use strict";function i(t,e){var r;if(g[t.tagName]&&void 0===e.tag?r="Invalid end tag "+s(t)+" (void elements cannot have end tags).":void 0===e.tag?r="Closing tag "+s(t)+" without an open tag.":e.tag!==t.tagName&&(r="Closing tag "+s(t)+" did not match last open tag `"+e.tag+"` (on line "+e.loc.start.line+")."),r)throw new Error(r)}function s(t){return"`"+t.tagName+"` (on line "+t.lastLine+")"}var o=t.forEach,a=e.buildProgram,l=e.buildComponent,c=e.buildElement,u=e.buildComment,p=e.buildText,h=r.appendChild,m=r.parseComponentBlockParams,d=r.postprocessProgram,f="area base br col command embed hr img input keygen link meta param source track wbr",g={};o(f.split(" "),function(t){g[t]=!0});var b={Comment:function(t){var e=this.currentElement(),r=u(t.chars);h(e,r)},Chars:function(t){var e=this.currentElement(),r=p(t.chars);h(e,r)},StartTag:function(t){var e=c(t.tagName,t.attributes,t.helpers||[],[]);e.loc={start:{line:t.firstLine,column:t.firstColumn},end:{line:null,column:null}},this.elementStack.push(e),(g.hasOwnProperty(t.tagName)||t.selfClosing)&&b.EndTag.call(this,t)},BlockStatement:function(){if("comment"!==this.tokenizer.state&&"data"!==this.tokenizer.state)throw new Error("A block may only be used inside an HTML element or another block.")},MustacheStatement:function(t){var e=this.tokenizer;switch(e.state){case"tagName":return e.addTagHelper(t.sexpr),void(e.state="beforeAttributeName");case"beforeAttributeName":return void e.addTagHelper(t.sexpr);case"attributeName":case"afterAttributeName":return e.finalizeAttributeValue(),e.addTagHelper(t.sexpr),void(e.state="beforeAttributeName");case"afterAttributeValueQuoted":return e.addTagHelper(t.sexpr),void(e.state="beforeAttributeName");case"beforeAttributeValue":return e.markAttributeQuoted(!1),e.addToAttributeValue(t),void(e.state="attributeValueUnquoted");case"attributeValueDoubleQuoted":case"attributeValueSingleQuoted":case"attributeValueUnquoted":return void e.addToAttributeValue(t);default:h(this.currentElement(),t)}},EndTag:function(t){var e=this.elementStack.pop(),r=this.currentElement(),n=this.options.disableComponentGeneration===!0;if(i(t,e),n||-1===e.tag.indexOf("-"))h(r,e);else{var s=a(e.children);m(e,s),d(s);var o=l(e.tag,e.attributes,s);h(r,o)}}};n["default"]=b}),t("htmlbars-syntax/tokenizer",["../simple-html-tokenizer","./utils","../htmlbars-util/array-utils","./builders","exports"],function(t,e,r,n,i){"use strict";function s(t){var e=t.value,r=e.length;return 0===r?h.text(""):1===r&&"TextNode"===e[0].type?e[0]:t.quoted?h.concat(p(e,o)):e[0]}function o(t){switch(t.type){case"TextNode":return h.string(t.chars);case"MustacheStatement":return l(t);default:throw new Error("Unsupported node in quoted attribute value: "+t.type)}}function a(t){return"`"+t.token.tagName+"` (on line "+t.line+")"}function l(t){return u(t.sexpr)?t.sexpr:t.sexpr.path}var c=t.Tokenizer,u=e.isHelper,p=r.map,h=n["default"];c.prototype.createAttribute=function(t){if("EndTag"===this.token.type)throw new Error("Invalid end tag: closing tag must not have attributes, in "+a(this)+".");this.currentAttribute=h.attr(t.toLowerCase(),[],null),this.token.attributes.push(this.currentAttribute),this.state="attributeName"},c.prototype.markAttributeQuoted=function(t){this.currentAttribute.quoted=t},c.prototype.addToAttributeName=function(t){this.currentAttribute.name+=t},c.prototype.addToAttributeValue=function(t){var e=this.currentAttribute.value;if(!this.currentAttribute.quoted&&"/"===t)throw new Error("A space is required between an unquoted attribute value and `/`, in "+a(this)+".");if(!this.currentAttribute.quoted&&e.length>0&&("MustacheStatement"===t.type||"MustacheStatement"===e[0].type))throw new Error("Unquoted attribute value must be a single string or mustache (on line "+this.line+")");
-if("object"==typeof t){if("MustacheStatement"!==t.type)throw new Error("Unsupported node in attribute value: "+t.type);e.push(t)}else e.length>0&&"TextNode"===e[e.length-1].type?e[e.length-1].chars+=t:e.push(h.text(t))},c.prototype.finalizeAttributeValue=function(){this.currentAttribute&&(this.currentAttribute.value=s(this.currentAttribute),delete this.currentAttribute.quoted,delete this.currentAttribute)},c.prototype.addTagHelper=function(t){var e=this.token.helpers=this.token.helpers||[];e.push(t)},i.unwrapMustache=l,i.Tokenizer=c}),t("htmlbars-syntax/utils",["./builders","../htmlbars-util/array-utils","exports"],function(t,e,r){"use strict";function n(t,e){for(var r=t.attributes.length,n=[],i=0;r>i;i++)n.push(t.attributes[i].name);var s=u(n,"as");if(-1!==s&&r>s&&"|"===n[s+1].charAt(0)){var o=n.slice(s).join(" ");if("|"!==o.charAt(o.length-1)||2!==o.match(/\|/g).length)throw new Error("Invalid block parameters syntax: '"+o+"'");var a=[];for(i=s+1;r>i;i++){var l=n[i].replace(/\|/g,"");if(""!==l){if(p.test(l))throw new Error("Invalid identifier for block parameters: '"+l+"' in '"+o+"'");a.push(l)}}if(0===a.length)throw new Error("Cannot use zero block parameters: '"+o+"'");t.attributes=t.attributes.slice(0,s),e.blockParams=a}}function i(t){var e=t.body;0!==e.length&&(o(e[0])&&e.unshift(c("")),o(e[e.length-1])&&e.push(c("")))}function s(t){return"Program"===t.type?t.body:"ElementNode"===t.type?t.children:void 0}function o(t){return"MustacheStatement"===t.type||"BlockStatement"===t.type||"ComponentNode"===t.type}function a(t,e){var r,n=s(t),i=n.length;i>0&&(r=n[i-1],o(r)&&o(e)&&n.push(c(""))),n.push(e)}function l(t){return t.params&&t.params.length>0||t.hash&&t.hash.pairs.length>0}var c=t.buildText,u=e.indexOfArray,p=/[!"#%-,\.\/;->@\[-\^`\{-~]/;r.parseComponentBlockParams=n,r.postprocessProgram=i,r.childrenFor=s,r.usesMorph=o,r.appendChild=a,r.isHelper=l}),t("htmlbars-syntax/walker",["exports"],function(t){"use strict";function e(t){this.order=t,this.stack=[]}t["default"]=e,e.prototype.visit=function(t,e){t&&(this.stack.push(t),"post"===this.order?(this.children(t,e),e(t,this)):(e(t,this),this.children(t,e)),this.stack.pop())};var r={Program:function(t,e,r){for(var n=0;n]+)/gi,function(t,e){return'id="'+e+'"'}),t=t.replace(/<(\/?):([^ >]+)/gi,function(t,e,r){return"<"+e+r}),t=t.replace(/style="(.+?)"/gi,function(t,e){return'style="'+e.toLowerCase()+';"'})),c&&(t=t.replace(/ xmlns="[^"]+"/,""),t=t.replace(/<([^ >]+) [^\/>]*\/>/gi,function(t,e){return t.slice(0,t.length-3)+">"})),t}function i(t){equal(t.outerHTML,p)}function s(t){return 3===t.nodeType?t.nodeValue:t[h]}function o(t){if("function"==typeof Object.create)return Object.create(t);var e=function(){};return e.prototype=t,new e}t.equalInnerHTML=e,t.equalHTML=r;var a=document.createElement("div");a.setAttribute("id","womp");var l=a.outerHTML.indexOf("id=womp")>-1,c=function(){if(!document.createElementNS)return!1;var t=document.createElement("div"),e=document.createElementNS("http://www.w3.org/2000/svg","svg");t.appendChild(e);var r=t.cloneNode(!0);return''===r.innerHTML}();t.normalizeInnerHTML=n;var u=document.createElement("input");u.setAttribute("checked","checked");var p=u.outerHTML;t.isCheckedInputHTML=i;var h=void 0===document.createElement("div").textContent?"innerText":"textContent";t.getTextContent=s,t.createObject=o}),t("htmlbars-util",["./htmlbars-util/safe-string","./htmlbars-util/handlebars/utils","./htmlbars-util/namespaces","exports"],function(t,e,r,n){"use strict";var i=t["default"],s=e.escapeExpression,o=r.getAttrNamespace;n.SafeString=i,n.escapeExpression=s,n.getAttrNamespace=o}),t("htmlbars-util/array-utils",["exports"],function(t){"use strict";function e(t,e,r){var n,i;if(void 0===r)for(n=0,i=t.length;i>n;n++)e(t[n],n,t);else for(n=0,i=t.length;i>n;n++)e.call(r,t[n],n,t)}function r(t,e){var r,n,i=[];for(r=0,n=t.length;n>r;r++)i.push(e(t[r],r,t));return i}t.forEach=e,t.map=r;var n;n=Array.prototype.indexOf?function(t,e,r){return t.indexOf(e,r)}:function(t,e,r){void 0===r||null===r?r=0:0>r&&(r=Math.max(0,t.length+r));for(var n=r,i=t.length;i>n;n++)if(t[n]===e)return n;return-1};var i=n;t.indexOfArray=i}),t("htmlbars-util/handlebars/safe-string",["exports"],function(t){"use strict";function e(t){this.string=t}e.prototype.toString=e.prototype.toHTML=function(){return""+this.string},t["default"]=e}),t("htmlbars-util/handlebars/utils",["./safe-string","exports"],function(t,e){"use strict";function r(t){return a[t]}function n(t){for(var e=1;e":">",'"':""","'":"'","`":"`"}),l=/[&<>"'`]/g,c=/[&<>"'`]/;e.extend=n;var u=Object.prototype.toString;e.toString=u;var p=function(t){return"function"==typeof t};p(/x/)&&(p=function(t){return"function"==typeof t&&"[object Function]"===u.call(t)});var p;e.isFunction=p;var h=Array.isArray||function(t){return t&&"object"==typeof t?"[object Array]"===u.call(t):!1};e.isArray=h,e.escapeExpression=i,e.isEmpty=s,e.appendContextPath=o}),t("htmlbars-util/namespaces",["exports"],function(t){"use strict";function e(t){var e,n=t.indexOf(":");if(-1!==n){var i=t.slice(0,n);e=r[i]}return e||null}var r={html:"http://www.w3.org/1999/xhtml",mathml:"http://www.w3.org/1998/Math/MathML",svg:"http://www.w3.org/2000/svg",xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace"};t.getAttrNamespace=e}),t("htmlbars-util/object-utils",["exports"],function(t){"use strict";function e(t,e){for(var r in e)t.hasOwnProperty(r)||(t[r]=e[r]);return t}t.merge=e}),t("htmlbars-util/quoting",["exports"],function(t){"use strict";function e(t){return t=t.replace(/\\/g,"\\\\"),t=t.replace(/"/g,'\\"'),t=t.replace(/\n/g,"\\n")}function r(t){return'"'+e(t)+'"'}function n(t){return"["+t+"]"}function i(t){return"{"+t.join(", ")+"}"}function s(t,e){for(var r="";e--;)r+=t;return r}t.escapeString=e,t.string=r,t.array=n,t.hash=i,t.repeat=s}),t("htmlbars-util/safe-string",["./handlebars/safe-string","exports"],function(t,e){"use strict";var r=t["default"];e["default"]=r}),t("simple-html-tokenizer",["./simple-html-tokenizer/tokenizer","./simple-html-tokenizer/tokenize","./simple-html-tokenizer/generator","./simple-html-tokenizer/generate","./simple-html-tokenizer/tokens","exports"],function(t,e,r,n,i,s){"use strict";var o=t["default"],a=e["default"],l=r["default"],c=n["default"],u=i.StartTag,p=i.EndTag,h=i.Chars,m=i.Comment;s.Tokenizer=o,s.tokenize=a,s.Generator=l,s.generate=c,s.StartTag=u,s.EndTag=p,s.Chars=h,s.Comment=m}),t("simple-html-tokenizer/char-refs/full",["exports"],function(t){"use strict";t["default"]={AElig:[198],AMP:[38],Aacute:[193],Abreve:[258],Acirc:[194],Acy:[1040],Afr:[120068],Agrave:[192],Alpha:[913],Amacr:[256],And:[10835],Aogon:[260],Aopf:[120120],ApplyFunction:[8289],Aring:[197],Ascr:[119964],Assign:[8788],Atilde:[195],Auml:[196],Backslash:[8726],Barv:[10983],Barwed:[8966],Bcy:[1041],Because:[8757],Bernoullis:[8492],Beta:[914],Bfr:[120069],Bopf:[120121],Breve:[728],Bscr:[8492],Bumpeq:[8782],CHcy:[1063],COPY:[169],Cacute:[262],Cap:[8914],CapitalDifferentialD:[8517],Cayleys:[8493],Ccaron:[268],Ccedil:[199],Ccirc:[264],Cconint:[8752],Cdot:[266],Cedilla:[184],CenterDot:[183],Cfr:[8493],Chi:[935],CircleDot:[8857],CircleMinus:[8854],CirclePlus:[8853],CircleTimes:[8855],ClockwiseContourIntegral:[8754],CloseCurlyDoubleQuote:[8221],CloseCurlyQuote:[8217],Colon:[8759],Colone:[10868],Congruent:[8801],Conint:[8751],ContourIntegral:[8750],Copf:[8450],Coproduct:[8720],CounterClockwiseContourIntegral:[8755],Cross:[10799],Cscr:[119966],Cup:[8915],CupCap:[8781],DD:[8517],DDotrahd:[10513],DJcy:[1026],DScy:[1029],DZcy:[1039],Dagger:[8225],Darr:[8609],Dashv:[10980],Dcaron:[270],Dcy:[1044],Del:[8711],Delta:[916],Dfr:[120071],DiacriticalAcute:[180],DiacriticalDot:[729],DiacriticalDoubleAcute:[733],DiacriticalGrave:[96],DiacriticalTilde:[732],Diamond:[8900],DifferentialD:[8518],Dopf:[120123],Dot:[168],DotDot:[8412],DotEqual:[8784],DoubleContourIntegral:[8751],DoubleDot:[168],DoubleDownArrow:[8659],DoubleLeftArrow:[8656],DoubleLeftRightArrow:[8660],DoubleLeftTee:[10980],DoubleLongLeftArrow:[10232],DoubleLongLeftRightArrow:[10234],DoubleLongRightArrow:[10233],DoubleRightArrow:[8658],DoubleRightTee:[8872],DoubleUpArrow:[8657],DoubleUpDownArrow:[8661],DoubleVerticalBar:[8741],DownArrow:[8595],DownArrowBar:[10515],DownArrowUpArrow:[8693],DownBreve:[785],DownLeftRightVector:[10576],DownLeftTeeVector:[10590],DownLeftVector:[8637],DownLeftVectorBar:[10582],DownRightTeeVector:[10591],DownRightVector:[8641],DownRightVectorBar:[10583],DownTee:[8868],DownTeeArrow:[8615],Downarrow:[8659],Dscr:[119967],Dstrok:[272],ENG:[330],ETH:[208],Eacute:[201],Ecaron:[282],Ecirc:[202],Ecy:[1069],Edot:[278],Efr:[120072],Egrave:[200],Element:[8712],Emacr:[274],EmptySmallSquare:[9723],EmptyVerySmallSquare:[9643],Eogon:[280],Eopf:[120124],Epsilon:[917],Equal:[10869],EqualTilde:[8770],Equilibrium:[8652],Escr:[8496],Esim:[10867],Eta:[919],Euml:[203],Exists:[8707],ExponentialE:[8519],Fcy:[1060],Ffr:[120073],FilledSmallSquare:[9724],FilledVerySmallSquare:[9642],Fopf:[120125],ForAll:[8704],Fouriertrf:[8497],Fscr:[8497],GJcy:[1027],GT:[62],Gamma:[915],Gammad:[988],Gbreve:[286],Gcedil:[290],Gcirc:[284],Gcy:[1043],Gdot:[288],Gfr:[120074],Gg:[8921],Gopf:[120126],GreaterEqual:[8805],GreaterEqualLess:[8923],GreaterFullEqual:[8807],GreaterGreater:[10914],GreaterLess:[8823],GreaterSlantEqual:[10878],GreaterTilde:[8819],Gscr:[119970],Gt:[8811],HARDcy:[1066],Hacek:[711],Hat:[94],Hcirc:[292],Hfr:[8460],HilbertSpace:[8459],Hopf:[8461],HorizontalLine:[9472],Hscr:[8459],Hstrok:[294],HumpDownHump:[8782],HumpEqual:[8783],IEcy:[1045],IJlig:[306],IOcy:[1025],Iacute:[205],Icirc:[206],Icy:[1048],Idot:[304],Ifr:[8465],Igrave:[204],Im:[8465],Imacr:[298],ImaginaryI:[8520],Implies:[8658],Int:[8748],Integral:[8747],Intersection:[8898],InvisibleComma:[8291],InvisibleTimes:[8290],Iogon:[302],Iopf:[120128],Iota:[921],Iscr:[8464],Itilde:[296],Iukcy:[1030],Iuml:[207],Jcirc:[308],Jcy:[1049],Jfr:[120077],Jopf:[120129],Jscr:[119973],Jsercy:[1032],Jukcy:[1028],KHcy:[1061],KJcy:[1036],Kappa:[922],Kcedil:[310],Kcy:[1050],Kfr:[120078],Kopf:[120130],Kscr:[119974],LJcy:[1033],LT:[60],Lacute:[313],Lambda:[923],Lang:[10218],Laplacetrf:[8466],Larr:[8606],Lcaron:[317],Lcedil:[315],Lcy:[1051],LeftAngleBracket:[10216],LeftArrow:[8592],LeftArrowBar:[8676],LeftArrowRightArrow:[8646],LeftCeiling:[8968],LeftDoubleBracket:[10214],LeftDownTeeVector:[10593],LeftDownVector:[8643],LeftDownVectorBar:[10585],LeftFloor:[8970],LeftRightArrow:[8596],LeftRightVector:[10574],LeftTee:[8867],LeftTeeArrow:[8612],LeftTeeVector:[10586],LeftTriangle:[8882],LeftTriangleBar:[10703],LeftTriangleEqual:[8884],LeftUpDownVector:[10577],LeftUpTeeVector:[10592],LeftUpVector:[8639],LeftUpVectorBar:[10584],LeftVector:[8636],LeftVectorBar:[10578],Leftarrow:[8656],Leftrightarrow:[8660],LessEqualGreater:[8922],LessFullEqual:[8806],LessGreater:[8822],LessLess:[10913],LessSlantEqual:[10877],LessTilde:[8818],Lfr:[120079],Ll:[8920],Lleftarrow:[8666],Lmidot:[319],LongLeftArrow:[10229],LongLeftRightArrow:[10231],LongRightArrow:[10230],Longleftarrow:[10232],Longleftrightarrow:[10234],Longrightarrow:[10233],Lopf:[120131],LowerLeftArrow:[8601],LowerRightArrow:[8600],Lscr:[8466],Lsh:[8624],Lstrok:[321],Lt:[8810],Map:[10501],Mcy:[1052],MediumSpace:[8287],Mellintrf:[8499],Mfr:[120080],MinusPlus:[8723],Mopf:[120132],Mscr:[8499],Mu:[924],NJcy:[1034],Nacute:[323],Ncaron:[327],Ncedil:[325],Ncy:[1053],NegativeMediumSpace:[8203],NegativeThickSpace:[8203],NegativeThinSpace:[8203],NegativeVeryThinSpace:[8203],NestedGreaterGreater:[8811],NestedLessLess:[8810],NewLine:[10],Nfr:[120081],NoBreak:[8288],NonBreakingSpace:[160],Nopf:[8469],Not:[10988],NotCongruent:[8802],NotCupCap:[8813],NotDoubleVerticalBar:[8742],NotElement:[8713],NotEqual:[8800],NotEqualTilde:[8770,824],NotExists:[8708],NotGreater:[8815],NotGreaterEqual:[8817],NotGreaterFullEqual:[8807,824],NotGreaterGreater:[8811,824],NotGreaterLess:[8825],NotGreaterSlantEqual:[10878,824],NotGreaterTilde:[8821],NotHumpDownHump:[8782,824],NotHumpEqual:[8783,824],NotLeftTriangle:[8938],NotLeftTriangleBar:[10703,824],NotLeftTriangleEqual:[8940],NotLess:[8814],NotLessEqual:[8816],NotLessGreater:[8824],NotLessLess:[8810,824],NotLessSlantEqual:[10877,824],NotLessTilde:[8820],NotNestedGreaterGreater:[10914,824],NotNestedLessLess:[10913,824],NotPrecedes:[8832],NotPrecedesEqual:[10927,824],NotPrecedesSlantEqual:[8928],NotReverseElement:[8716],NotRightTriangle:[8939],NotRightTriangleBar:[10704,824],NotRightTriangleEqual:[8941],NotSquareSubset:[8847,824],NotSquareSubsetEqual:[8930],NotSquareSuperset:[8848,824],NotSquareSupersetEqual:[8931],NotSubset:[8834,8402],NotSubsetEqual:[8840],NotSucceeds:[8833],NotSucceedsEqual:[10928,824],NotSucceedsSlantEqual:[8929],NotSucceedsTilde:[8831,824],NotSuperset:[8835,8402],NotSupersetEqual:[8841],NotTilde:[8769],NotTildeEqual:[8772],NotTildeFullEqual:[8775],NotTildeTilde:[8777],NotVerticalBar:[8740],Nscr:[119977],Ntilde:[209],Nu:[925],OElig:[338],Oacute:[211],Ocirc:[212],Ocy:[1054],Odblac:[336],Ofr:[120082],Ograve:[210],Omacr:[332],Omega:[937],Omicron:[927],Oopf:[120134],OpenCurlyDoubleQuote:[8220],OpenCurlyQuote:[8216],Or:[10836],Oscr:[119978],Oslash:[216],Otilde:[213],Otimes:[10807],Ouml:[214],OverBar:[8254],OverBrace:[9182],OverBracket:[9140],OverParenthesis:[9180],PartialD:[8706],Pcy:[1055],Pfr:[120083],Phi:[934],Pi:[928],PlusMinus:[177],Poincareplane:[8460],Popf:[8473],Pr:[10939],Precedes:[8826],PrecedesEqual:[10927],PrecedesSlantEqual:[8828],PrecedesTilde:[8830],Prime:[8243],Product:[8719],Proportion:[8759],Proportional:[8733],Pscr:[119979],Psi:[936],QUOT:[34],Qfr:[120084],Qopf:[8474],Qscr:[119980],RBarr:[10512],REG:[174],Racute:[340],Rang:[10219],Rarr:[8608],Rarrtl:[10518],Rcaron:[344],Rcedil:[342],Rcy:[1056],Re:[8476],ReverseElement:[8715],ReverseEquilibrium:[8651],ReverseUpEquilibrium:[10607],Rfr:[8476],Rho:[929],RightAngleBracket:[10217],RightArrow:[8594],RightArrowBar:[8677],RightArrowLeftArrow:[8644],RightCeiling:[8969],RightDoubleBracket:[10215],RightDownTeeVector:[10589],RightDownVector:[8642],RightDownVectorBar:[10581],RightFloor:[8971],RightTee:[8866],RightTeeArrow:[8614],RightTeeVector:[10587],RightTriangle:[8883],RightTriangleBar:[10704],RightTriangleEqual:[8885],RightUpDownVector:[10575],RightUpTeeVector:[10588],RightUpVector:[8638],RightUpVectorBar:[10580],RightVector:[8640],RightVectorBar:[10579],Rightarrow:[8658],Ropf:[8477],RoundImplies:[10608],Rrightarrow:[8667],Rscr:[8475],Rsh:[8625],RuleDelayed:[10740],SHCHcy:[1065],SHcy:[1064],SOFTcy:[1068],Sacute:[346],Sc:[10940],Scaron:[352],Scedil:[350],Scirc:[348],Scy:[1057],Sfr:[120086],ShortDownArrow:[8595],ShortLeftArrow:[8592],ShortRightArrow:[8594],ShortUpArrow:[8593],Sigma:[931],SmallCircle:[8728],Sopf:[120138],Sqrt:[8730],Square:[9633],SquareIntersection:[8851],SquareSubset:[8847],SquareSubsetEqual:[8849],SquareSuperset:[8848],SquareSupersetEqual:[8850],SquareUnion:[8852],Sscr:[119982],Star:[8902],Sub:[8912],Subset:[8912],SubsetEqual:[8838],Succeeds:[8827],SucceedsEqual:[10928],SucceedsSlantEqual:[8829],SucceedsTilde:[8831],SuchThat:[8715],Sum:[8721],Sup:[8913],Superset:[8835],SupersetEqual:[8839],Supset:[8913],THORN:[222],TRADE:[8482],TSHcy:[1035],TScy:[1062],Tab:[9],Tau:[932],Tcaron:[356],Tcedil:[354],Tcy:[1058],Tfr:[120087],Therefore:[8756],Theta:[920],ThickSpace:[8287,8202],ThinSpace:[8201],Tilde:[8764],TildeEqual:[8771],TildeFullEqual:[8773],TildeTilde:[8776],Topf:[120139],TripleDot:[8411],Tscr:[119983],Tstrok:[358],Uacute:[218],Uarr:[8607],Uarrocir:[10569],Ubrcy:[1038],Ubreve:[364],Ucirc:[219],Ucy:[1059],Udblac:[368],Ufr:[120088],Ugrave:[217],Umacr:[362],UnderBar:[95],UnderBrace:[9183],UnderBracket:[9141],UnderParenthesis:[9181],Union:[8899],UnionPlus:[8846],Uogon:[370],Uopf:[120140],UpArrow:[8593],UpArrowBar:[10514],UpArrowDownArrow:[8645],UpDownArrow:[8597],UpEquilibrium:[10606],UpTee:[8869],UpTeeArrow:[8613],Uparrow:[8657],Updownarrow:[8661],UpperLeftArrow:[8598],UpperRightArrow:[8599],Upsi:[978],Upsilon:[933],Uring:[366],Uscr:[119984],Utilde:[360],Uuml:[220],VDash:[8875],Vbar:[10987],Vcy:[1042],Vdash:[8873],Vdashl:[10982],Vee:[8897],Verbar:[8214],Vert:[8214],VerticalBar:[8739],VerticalLine:[124],VerticalSeparator:[10072],VerticalTilde:[8768],VeryThinSpace:[8202],Vfr:[120089],Vopf:[120141],Vscr:[119985],Vvdash:[8874],Wcirc:[372],Wedge:[8896],Wfr:[120090],Wopf:[120142],Wscr:[119986],Xfr:[120091],Xi:[926],Xopf:[120143],Xscr:[119987],YAcy:[1071],YIcy:[1031],YUcy:[1070],Yacute:[221],Ycirc:[374],Ycy:[1067],Yfr:[120092],Yopf:[120144],Yscr:[119988],Yuml:[376],ZHcy:[1046],Zacute:[377],Zcaron:[381],Zcy:[1047],Zdot:[379],ZeroWidthSpace:[8203],Zeta:[918],Zfr:[8488],Zopf:[8484],Zscr:[119989],aacute:[225],abreve:[259],ac:[8766],acE:[8766,819],acd:[8767],acirc:[226],acute:[180],acy:[1072],aelig:[230],af:[8289],afr:[120094],agrave:[224],alefsym:[8501],aleph:[8501],alpha:[945],amacr:[257],amalg:[10815],amp:[38],and:[8743],andand:[10837],andd:[10844],andslope:[10840],andv:[10842],ang:[8736],ange:[10660],angle:[8736],angmsd:[8737],angmsdaa:[10664],angmsdab:[10665],angmsdac:[10666],angmsdad:[10667],angmsdae:[10668],angmsdaf:[10669],angmsdag:[10670],angmsdah:[10671],angrt:[8735],angrtvb:[8894],angrtvbd:[10653],angsph:[8738],angst:[197],angzarr:[9084],aogon:[261],aopf:[120146],ap:[8776],apE:[10864],apacir:[10863],ape:[8778],apid:[8779],apos:[39],approx:[8776],approxeq:[8778],aring:[229],ascr:[119990],ast:[42],asymp:[8776],asympeq:[8781],atilde:[227],auml:[228],awconint:[8755],awint:[10769],bNot:[10989],backcong:[8780],backepsilon:[1014],backprime:[8245],backsim:[8765],backsimeq:[8909],barvee:[8893],barwed:[8965],barwedge:[8965],bbrk:[9141],bbrktbrk:[9142],bcong:[8780],bcy:[1073],bdquo:[8222],becaus:[8757],because:[8757],bemptyv:[10672],bepsi:[1014],bernou:[8492],beta:[946],beth:[8502],between:[8812],bfr:[120095],bigcap:[8898],bigcirc:[9711],bigcup:[8899],bigodot:[10752],bigoplus:[10753],bigotimes:[10754],bigsqcup:[10758],bigstar:[9733],bigtriangledown:[9661],bigtriangleup:[9651],biguplus:[10756],bigvee:[8897],bigwedge:[8896],bkarow:[10509],blacklozenge:[10731],blacksquare:[9642],blacktriangle:[9652],blacktriangledown:[9662],blacktriangleleft:[9666],blacktriangleright:[9656],blank:[9251],blk12:[9618],blk14:[9617],blk34:[9619],block:[9608],bne:[61,8421],bnequiv:[8801,8421],bnot:[8976],bopf:[120147],bot:[8869],bottom:[8869],bowtie:[8904],boxDL:[9559],boxDR:[9556],boxDl:[9558],boxDr:[9555],boxH:[9552],boxHD:[9574],boxHU:[9577],boxHd:[9572],boxHu:[9575],boxUL:[9565],boxUR:[9562],boxUl:[9564],boxUr:[9561],boxV:[9553],boxVH:[9580],boxVL:[9571],boxVR:[9568],boxVh:[9579],boxVl:[9570],boxVr:[9567],boxbox:[10697],boxdL:[9557],boxdR:[9554],boxdl:[9488],boxdr:[9484],boxh:[9472],boxhD:[9573],boxhU:[9576],boxhd:[9516],boxhu:[9524],boxminus:[8863],boxplus:[8862],boxtimes:[8864],boxuL:[9563],boxuR:[9560],boxul:[9496],boxur:[9492],boxv:[9474],boxvH:[9578],boxvL:[9569],boxvR:[9566],boxvh:[9532],boxvl:[9508],boxvr:[9500],bprime:[8245],breve:[728],brvbar:[166],bscr:[119991],bsemi:[8271],bsim:[8765],bsime:[8909],bsol:[92],bsolb:[10693],bsolhsub:[10184],bull:[8226],bullet:[8226],bump:[8782],bumpE:[10926],bumpe:[8783],bumpeq:[8783],cacute:[263],cap:[8745],capand:[10820],capbrcup:[10825],capcap:[10827],capcup:[10823],capdot:[10816],caps:[8745,65024],caret:[8257],caron:[711],ccaps:[10829],ccaron:[269],ccedil:[231],ccirc:[265],ccups:[10828],ccupssm:[10832],cdot:[267],cedil:[184],cemptyv:[10674],cent:[162],centerdot:[183],cfr:[120096],chcy:[1095],check:[10003],checkmark:[10003],chi:[967],cir:[9675],cirE:[10691],circ:[710],circeq:[8791],circlearrowleft:[8634],circlearrowright:[8635],circledR:[174],circledS:[9416],circledast:[8859],circledcirc:[8858],circleddash:[8861],cire:[8791],cirfnint:[10768],cirmid:[10991],cirscir:[10690],clubs:[9827],clubsuit:[9827],colon:[58],colone:[8788],coloneq:[8788],comma:[44],commat:[64],comp:[8705],compfn:[8728],complement:[8705],complexes:[8450],cong:[8773],congdot:[10861],conint:[8750],copf:[120148],coprod:[8720],copy:[169],copysr:[8471],crarr:[8629],cross:[10007],cscr:[119992],csub:[10959],csube:[10961],csup:[10960],csupe:[10962],ctdot:[8943],cudarrl:[10552],cudarrr:[10549],cuepr:[8926],cuesc:[8927],cularr:[8630],cularrp:[10557],cup:[8746],cupbrcap:[10824],cupcap:[10822],cupcup:[10826],cupdot:[8845],cupor:[10821],cups:[8746,65024],curarr:[8631],curarrm:[10556],curlyeqprec:[8926],curlyeqsucc:[8927],curlyvee:[8910],curlywedge:[8911],curren:[164],curvearrowleft:[8630],curvearrowright:[8631],cuvee:[8910],cuwed:[8911],cwconint:[8754],cwint:[8753],cylcty:[9005],dArr:[8659],dHar:[10597],dagger:[8224],daleth:[8504],darr:[8595],dash:[8208],dashv:[8867],dbkarow:[10511],dblac:[733],dcaron:[271],dcy:[1076],dd:[8518],ddagger:[8225],ddarr:[8650],ddotseq:[10871],deg:[176],delta:[948],demptyv:[10673],dfisht:[10623],dfr:[120097],dharl:[8643],dharr:[8642],diam:[8900],diamond:[8900],diamondsuit:[9830],diams:[9830],die:[168],digamma:[989],disin:[8946],div:[247],divide:[247],divideontimes:[8903],divonx:[8903],djcy:[1106],dlcorn:[8990],dlcrop:[8973],dollar:[36],dopf:[120149],dot:[729],doteq:[8784],doteqdot:[8785],dotminus:[8760],dotplus:[8724],dotsquare:[8865],doublebarwedge:[8966],downarrow:[8595],downdownarrows:[8650],downharpoonleft:[8643],downharpoonright:[8642],drbkarow:[10512],drcorn:[8991],drcrop:[8972],dscr:[119993],dscy:[1109],dsol:[10742],dstrok:[273],dtdot:[8945],dtri:[9663],dtrif:[9662],duarr:[8693],duhar:[10607],dwangle:[10662],dzcy:[1119],dzigrarr:[10239],eDDot:[10871],eDot:[8785],eacute:[233],easter:[10862],ecaron:[283],ecir:[8790],ecirc:[234],ecolon:[8789],ecy:[1101],edot:[279],ee:[8519],efDot:[8786],efr:[120098],eg:[10906],egrave:[232],egs:[10902],egsdot:[10904],el:[10905],elinters:[9191],ell:[8467],els:[10901],elsdot:[10903],emacr:[275],empty:[8709],emptyset:[8709],emptyv:[8709],emsp:[8195],emsp13:[8196],emsp14:[8197],eng:[331],ensp:[8194],eogon:[281],eopf:[120150],epar:[8917],eparsl:[10723],eplus:[10865],epsi:[949],epsilon:[949],epsiv:[1013],eqcirc:[8790],eqcolon:[8789],eqsim:[8770],eqslantgtr:[10902],eqslantless:[10901],equals:[61],equest:[8799],equiv:[8801],equivDD:[10872],eqvparsl:[10725],erDot:[8787],erarr:[10609],escr:[8495],esdot:[8784],esim:[8770],eta:[951],eth:[240],euml:[235],euro:[8364],excl:[33],exist:[8707],expectation:[8496],exponentiale:[8519],fallingdotseq:[8786],fcy:[1092],female:[9792],ffilig:[64259],fflig:[64256],ffllig:[64260],ffr:[120099],filig:[64257],fjlig:[102,106],flat:[9837],fllig:[64258],fltns:[9649],fnof:[402],fopf:[120151],forall:[8704],fork:[8916],forkv:[10969],fpartint:[10765],frac12:[189],frac13:[8531],frac14:[188],frac15:[8533],frac16:[8537],frac18:[8539],frac23:[8532],frac25:[8534],frac34:[190],frac35:[8535],frac38:[8540],frac45:[8536],frac56:[8538],frac58:[8541],frac78:[8542],frasl:[8260],frown:[8994],fscr:[119995],gE:[8807],gEl:[10892],gacute:[501],gamma:[947],gammad:[989],gap:[10886],gbreve:[287],gcirc:[285],gcy:[1075],gdot:[289],ge:[8805],gel:[8923],geq:[8805],geqq:[8807],geqslant:[10878],ges:[10878],gescc:[10921],gesdot:[10880],gesdoto:[10882],gesdotol:[10884],gesl:[8923,65024],gesles:[10900],gfr:[120100],gg:[8811],ggg:[8921],gimel:[8503],gjcy:[1107],gl:[8823],glE:[10898],gla:[10917],glj:[10916],gnE:[8809],gnap:[10890],gnapprox:[10890],gne:[10888],gneq:[10888],gneqq:[8809],gnsim:[8935],gopf:[120152],grave:[96],gscr:[8458],gsim:[8819],gsime:[10894],gsiml:[10896],gt:[62],gtcc:[10919],gtcir:[10874],gtdot:[8919],gtlPar:[10645],gtquest:[10876],gtrapprox:[10886],gtrarr:[10616],gtrdot:[8919],gtreqless:[8923],gtreqqless:[10892],gtrless:[8823],gtrsim:[8819],gvertneqq:[8809,65024],gvnE:[8809,65024],hArr:[8660],hairsp:[8202],half:[189],hamilt:[8459],hardcy:[1098],harr:[8596],harrcir:[10568],harrw:[8621],hbar:[8463],hcirc:[293],hearts:[9829],heartsuit:[9829],hellip:[8230],hercon:[8889],hfr:[120101],hksearow:[10533],hkswarow:[10534],hoarr:[8703],homtht:[8763],hookleftarrow:[8617],hookrightarrow:[8618],hopf:[120153],horbar:[8213],hscr:[119997],hslash:[8463],hstrok:[295],hybull:[8259],hyphen:[8208],iacute:[237],ic:[8291],icirc:[238],icy:[1080],iecy:[1077],iexcl:[161],iff:[8660],ifr:[120102],igrave:[236],ii:[8520],iiiint:[10764],iiint:[8749],iinfin:[10716],iiota:[8489],ijlig:[307],imacr:[299],image:[8465],imagline:[8464],imagpart:[8465],imath:[305],imof:[8887],imped:[437],"in":[8712],incare:[8453],infin:[8734],infintie:[10717],inodot:[305],"int":[8747],intcal:[8890],integers:[8484],intercal:[8890],intlarhk:[10775],intprod:[10812],iocy:[1105],iogon:[303],iopf:[120154],iota:[953],iprod:[10812],iquest:[191],iscr:[119998],isin:[8712],isinE:[8953],isindot:[8949],isins:[8948],isinsv:[8947],isinv:[8712],it:[8290],itilde:[297],iukcy:[1110],iuml:[239],jcirc:[309],jcy:[1081],jfr:[120103],jmath:[567],jopf:[120155],jscr:[119999],jsercy:[1112],jukcy:[1108],kappa:[954],kappav:[1008],kcedil:[311],kcy:[1082],kfr:[120104],kgreen:[312],khcy:[1093],kjcy:[1116],kopf:[120156],kscr:[12e4],lAarr:[8666],lArr:[8656],lAtail:[10523],lBarr:[10510],lE:[8806],lEg:[10891],lHar:[10594],lacute:[314],laemptyv:[10676],lagran:[8466],lambda:[955],lang:[10216],langd:[10641],langle:[10216],lap:[10885],laquo:[171],larr:[8592],larrb:[8676],larrbfs:[10527],larrfs:[10525],larrhk:[8617],larrlp:[8619],larrpl:[10553],larrsim:[10611],larrtl:[8610],lat:[10923],latail:[10521],late:[10925],lates:[10925,65024],lbarr:[10508],lbbrk:[10098],lbrace:[123],lbrack:[91],lbrke:[10635],lbrksld:[10639],lbrkslu:[10637],lcaron:[318],lcedil:[316],lceil:[8968],lcub:[123],lcy:[1083],ldca:[10550],ldquo:[8220],ldquor:[8222],ldrdhar:[10599],ldrushar:[10571],ldsh:[8626],le:[8804],leftarrow:[8592],leftarrowtail:[8610],leftharpoondown:[8637],leftharpoonup:[8636],leftleftarrows:[8647],leftrightarrow:[8596],leftrightarrows:[8646],leftrightharpoons:[8651],leftrightsquigarrow:[8621],leftthreetimes:[8907],leg:[8922],leq:[8804],leqq:[8806],leqslant:[10877],les:[10877],lescc:[10920],lesdot:[10879],lesdoto:[10881],lesdotor:[10883],lesg:[8922,65024],lesges:[10899],lessapprox:[10885],lessdot:[8918],lesseqgtr:[8922],lesseqqgtr:[10891],lessgtr:[8822],lesssim:[8818],lfisht:[10620],lfloor:[8970],lfr:[120105],lg:[8822],lgE:[10897],lhard:[8637],lharu:[8636],lharul:[10602],lhblk:[9604],ljcy:[1113],ll:[8810],llarr:[8647],llcorner:[8990],llhard:[10603],lltri:[9722],lmidot:[320],lmoust:[9136],lmoustache:[9136],lnE:[8808],lnap:[10889],lnapprox:[10889],lne:[10887],lneq:[10887],lneqq:[8808],lnsim:[8934],loang:[10220],loarr:[8701],lobrk:[10214],longleftarrow:[10229],longleftrightarrow:[10231],longmapsto:[10236],longrightarrow:[10230],looparrowleft:[8619],looparrowright:[8620],lopar:[10629],lopf:[120157],loplus:[10797],lotimes:[10804],lowast:[8727],lowbar:[95],loz:[9674],lozenge:[9674],lozf:[10731],lpar:[40],lparlt:[10643],lrarr:[8646],lrcorner:[8991],lrhar:[8651],lrhard:[10605],lrm:[8206],lrtri:[8895],lsaquo:[8249],lscr:[120001],lsh:[8624],lsim:[8818],lsime:[10893],lsimg:[10895],lsqb:[91],lsquo:[8216],lsquor:[8218],lstrok:[322],lt:[60],ltcc:[10918],ltcir:[10873],ltdot:[8918],lthree:[8907],ltimes:[8905],ltlarr:[10614],ltquest:[10875],ltrPar:[10646],ltri:[9667],ltrie:[8884],ltrif:[9666],lurdshar:[10570],luruhar:[10598],lvertneqq:[8808,65024],lvnE:[8808,65024],mDDot:[8762],macr:[175],male:[9794],malt:[10016],maltese:[10016],map:[8614],mapsto:[8614],mapstodown:[8615],mapstoleft:[8612],mapstoup:[8613],marker:[9646],mcomma:[10793],mcy:[1084],mdash:[8212],measuredangle:[8737],mfr:[120106],mho:[8487],micro:[181],mid:[8739],midast:[42],midcir:[10992],middot:[183],minus:[8722],minusb:[8863],minusd:[8760],minusdu:[10794],mlcp:[10971],mldr:[8230],mnplus:[8723],models:[8871],mopf:[120158],mp:[8723],mscr:[120002],mstpos:[8766],mu:[956],multimap:[8888],mumap:[8888],nGg:[8921,824],nGt:[8811,8402],nGtv:[8811,824],nLeftarrow:[8653],nLeftrightarrow:[8654],nLl:[8920,824],nLt:[8810,8402],nLtv:[8810,824],nRightarrow:[8655],nVDash:[8879],nVdash:[8878],nabla:[8711],nacute:[324],nang:[8736,8402],nap:[8777],napE:[10864,824],napid:[8779,824],napos:[329],napprox:[8777],natur:[9838],natural:[9838],naturals:[8469],nbsp:[160],nbump:[8782,824],nbumpe:[8783,824],ncap:[10819],ncaron:[328],ncedil:[326],ncong:[8775],ncongdot:[10861,824],ncup:[10818],ncy:[1085],ndash:[8211],ne:[8800],neArr:[8663],nearhk:[10532],nearr:[8599],nearrow:[8599],nedot:[8784,824],nequiv:[8802],nesear:[10536],nesim:[8770,824],nexist:[8708],nexists:[8708],nfr:[120107],ngE:[8807,824],nge:[8817],ngeq:[8817],ngeqq:[8807,824],ngeqslant:[10878,824],nges:[10878,824],ngsim:[8821],ngt:[8815],ngtr:[8815],nhArr:[8654],nharr:[8622],nhpar:[10994],ni:[8715],nis:[8956],nisd:[8954],niv:[8715],njcy:[1114],nlArr:[8653],nlE:[8806,824],nlarr:[8602],nldr:[8229],nle:[8816],nleftarrow:[8602],nleftrightarrow:[8622],nleq:[8816],nleqq:[8806,824],nleqslant:[10877,824],nles:[10877,824],nless:[8814],nlsim:[8820],nlt:[8814],nltri:[8938],nltrie:[8940],nmid:[8740],nopf:[120159],not:[172],notin:[8713],notinE:[8953,824],notindot:[8949,824],notinva:[8713],notinvb:[8951],notinvc:[8950],notni:[8716],notniva:[8716],notnivb:[8958],notnivc:[8957],npar:[8742],nparallel:[8742],nparsl:[11005,8421],npart:[8706,824],npolint:[10772],npr:[8832],nprcue:[8928],npre:[10927,824],nprec:[8832],npreceq:[10927,824],nrArr:[8655],nrarr:[8603],nrarrc:[10547,824],nrarrw:[8605,824],nrightarrow:[8603],nrtri:[8939],nrtrie:[8941],nsc:[8833],nsccue:[8929],nsce:[10928,824],nscr:[120003],nshortmid:[8740],nshortparallel:[8742],nsim:[8769],nsime:[8772],nsimeq:[8772],nsmid:[8740],nspar:[8742],nsqsube:[8930],nsqsupe:[8931],nsub:[8836],nsubE:[10949,824],nsube:[8840],nsubset:[8834,8402],nsubseteq:[8840],nsubseteqq:[10949,824],nsucc:[8833],nsucceq:[10928,824],nsup:[8837],nsupE:[10950,824],nsupe:[8841],nsupset:[8835,8402],nsupseteq:[8841],nsupseteqq:[10950,824],ntgl:[8825],ntilde:[241],ntlg:[8824],ntriangleleft:[8938],ntrianglelefteq:[8940],ntriangleright:[8939],ntrianglerighteq:[8941],nu:[957],num:[35],numero:[8470],numsp:[8199],nvDash:[8877],nvHarr:[10500],nvap:[8781,8402],nvdash:[8876],nvge:[8805,8402],nvgt:[62,8402],nvinfin:[10718],nvlArr:[10498],nvle:[8804,8402],nvlt:[60,8402],nvltrie:[8884,8402],nvrArr:[10499],nvrtrie:[8885,8402],nvsim:[8764,8402],nwArr:[8662],nwarhk:[10531],nwarr:[8598],nwarrow:[8598],nwnear:[10535],oS:[9416],oacute:[243],oast:[8859],ocir:[8858],ocirc:[244],ocy:[1086],odash:[8861],odblac:[337],odiv:[10808],odot:[8857],odsold:[10684],oelig:[339],ofcir:[10687],ofr:[120108],ogon:[731],ograve:[242],ogt:[10689],ohbar:[10677],ohm:[937],oint:[8750],olarr:[8634],olcir:[10686],olcross:[10683],oline:[8254],olt:[10688],omacr:[333],omega:[969],omicron:[959],omid:[10678],ominus:[8854],oopf:[120160],opar:[10679],operp:[10681],oplus:[8853],or:[8744],orarr:[8635],ord:[10845],order:[8500],orderof:[8500],ordf:[170],ordm:[186],origof:[8886],oror:[10838],orslope:[10839],orv:[10843],oscr:[8500],oslash:[248],osol:[8856],otilde:[245],otimes:[8855],otimesas:[10806],ouml:[246],ovbar:[9021],par:[8741],para:[182],parallel:[8741],parsim:[10995],parsl:[11005],part:[8706],pcy:[1087],percnt:[37],period:[46],permil:[8240],perp:[8869],pertenk:[8241],pfr:[120109],phi:[966],phiv:[981],phmmat:[8499],phone:[9742],pi:[960],pitchfork:[8916],piv:[982],planck:[8463],planckh:[8462],plankv:[8463],plus:[43],plusacir:[10787],plusb:[8862],pluscir:[10786],plusdo:[8724],plusdu:[10789],pluse:[10866],plusmn:[177],plussim:[10790],plustwo:[10791],pm:[177],pointint:[10773],popf:[120161],pound:[163],pr:[8826],prE:[10931],prap:[10935],prcue:[8828],pre:[10927],prec:[8826],precapprox:[10935],preccurlyeq:[8828],preceq:[10927],precnapprox:[10937],precneqq:[10933],precnsim:[8936],precsim:[8830],prime:[8242],primes:[8473],prnE:[10933],prnap:[10937],prnsim:[8936],prod:[8719],profalar:[9006],profline:[8978],profsurf:[8979],prop:[8733],propto:[8733],prsim:[8830],prurel:[8880],pscr:[120005],psi:[968],puncsp:[8200],qfr:[120110],qint:[10764],qopf:[120162],qprime:[8279],qscr:[120006],quaternions:[8461],quatint:[10774],quest:[63],questeq:[8799],quot:[34],rAarr:[8667],rArr:[8658],rAtail:[10524],rBarr:[10511],rHar:[10596],race:[8765,817],racute:[341],radic:[8730],raemptyv:[10675],rang:[10217],rangd:[10642],range:[10661],rangle:[10217],raquo:[187],rarr:[8594],rarrap:[10613],rarrb:[8677],rarrbfs:[10528],rarrc:[10547],rarrfs:[10526],rarrhk:[8618],rarrlp:[8620],rarrpl:[10565],rarrsim:[10612],rarrtl:[8611],rarrw:[8605],ratail:[10522],ratio:[8758],rationals:[8474],rbarr:[10509],rbbrk:[10099],rbrace:[125],rbrack:[93],rbrke:[10636],rbrksld:[10638],rbrkslu:[10640],rcaron:[345],rcedil:[343],rceil:[8969],rcub:[125],rcy:[1088],rdca:[10551],rdldhar:[10601],rdquo:[8221],rdquor:[8221],rdsh:[8627],real:[8476],realine:[8475],realpart:[8476],reals:[8477],rect:[9645],reg:[174],rfisht:[10621],rfloor:[8971],rfr:[120111],rhard:[8641],rharu:[8640],rharul:[10604],rho:[961],rhov:[1009],rightarrow:[8594],rightarrowtail:[8611],rightharpoondown:[8641],rightharpoonup:[8640],rightleftarrows:[8644],rightleftharpoons:[8652],rightrightarrows:[8649],rightsquigarrow:[8605],rightthreetimes:[8908],ring:[730],risingdotseq:[8787],rlarr:[8644],rlhar:[8652],rlm:[8207],rmoust:[9137],rmoustache:[9137],rnmid:[10990],roang:[10221],roarr:[8702],robrk:[10215],ropar:[10630],ropf:[120163],roplus:[10798],rotimes:[10805],rpar:[41],rpargt:[10644],rppolint:[10770],rrarr:[8649],rsaquo:[8250],rscr:[120007],rsh:[8625],rsqb:[93],rsquo:[8217],rsquor:[8217],rthree:[8908],rtimes:[8906],rtri:[9657],rtrie:[8885],rtrif:[9656],rtriltri:[10702],ruluhar:[10600],rx:[8478],sacute:[347],sbquo:[8218],sc:[8827],scE:[10932],scap:[10936],scaron:[353],sccue:[8829],sce:[10928],scedil:[351],scirc:[349],scnE:[10934],scnap:[10938],scnsim:[8937],scpolint:[10771],scsim:[8831],scy:[1089],sdot:[8901],sdotb:[8865],sdote:[10854],seArr:[8664],searhk:[10533],searr:[8600],searrow:[8600],sect:[167],semi:[59],seswar:[10537],setminus:[8726],setmn:[8726],sext:[10038],sfr:[120112],sfrown:[8994],sharp:[9839],shchcy:[1097],shcy:[1096],shortmid:[8739],shortparallel:[8741],shy:[173],sigma:[963],sigmaf:[962],sigmav:[962],sim:[8764],simdot:[10858],sime:[8771],simeq:[8771],simg:[10910],simgE:[10912],siml:[10909],simlE:[10911],simne:[8774],simplus:[10788],simrarr:[10610],slarr:[8592],smallsetminus:[8726],smashp:[10803],smeparsl:[10724],smid:[8739],smile:[8995],smt:[10922],smte:[10924],smtes:[10924,65024],softcy:[1100],sol:[47],solb:[10692],solbar:[9023],sopf:[120164],spades:[9824],spadesuit:[9824],spar:[8741],sqcap:[8851],sqcaps:[8851,65024],sqcup:[8852],sqcups:[8852,65024],sqsub:[8847],sqsube:[8849],sqsubset:[8847],sqsubseteq:[8849],sqsup:[8848],sqsupe:[8850],sqsupset:[8848],sqsupseteq:[8850],squ:[9633],square:[9633],squarf:[9642],squf:[9642],srarr:[8594],sscr:[120008],ssetmn:[8726],ssmile:[8995],sstarf:[8902],star:[9734],starf:[9733],straightepsilon:[1013],straightphi:[981],strns:[175],sub:[8834],subE:[10949],subdot:[10941],sube:[8838],subedot:[10947],submult:[10945],subnE:[10955],subne:[8842],subplus:[10943],subrarr:[10617],subset:[8834],subseteq:[8838],subseteqq:[10949],subsetneq:[8842],subsetneqq:[10955],subsim:[10951],subsub:[10965],subsup:[10963],succ:[8827],succapprox:[10936],succcurlyeq:[8829],succeq:[10928],succnapprox:[10938],succneqq:[10934],succnsim:[8937],succsim:[8831],sum:[8721],sung:[9834],sup:[8835],sup1:[185],sup2:[178],sup3:[179],supE:[10950],supdot:[10942],supdsub:[10968],supe:[8839],supedot:[10948],suphsol:[10185],suphsub:[10967],suplarr:[10619],supmult:[10946],supnE:[10956],supne:[8843],supplus:[10944],supset:[8835],supseteq:[8839],supseteqq:[10950],supsetneq:[8843],supsetneqq:[10956],supsim:[10952],supsub:[10964],supsup:[10966],swArr:[8665],swarhk:[10534],swarr:[8601],swarrow:[8601],swnwar:[10538],szlig:[223],target:[8982],tau:[964],tbrk:[9140],tcaron:[357],tcedil:[355],tcy:[1090],tdot:[8411],telrec:[8981],tfr:[120113],there4:[8756],therefore:[8756],theta:[952],thetasym:[977],thetav:[977],thickapprox:[8776],thicksim:[8764],thinsp:[8201],thkap:[8776],thksim:[8764],thorn:[254],tilde:[732],times:[215],timesb:[8864],timesbar:[10801],timesd:[10800],tint:[8749],toea:[10536],top:[8868],topbot:[9014],topcir:[10993],topf:[120165],topfork:[10970],tosa:[10537],tprime:[8244],trade:[8482],triangle:[9653],triangledown:[9663],triangleleft:[9667],trianglelefteq:[8884],triangleq:[8796],triangleright:[9657],trianglerighteq:[8885],tridot:[9708],trie:[8796],triminus:[10810],triplus:[10809],trisb:[10701],tritime:[10811],trpezium:[9186],tscr:[120009],tscy:[1094],tshcy:[1115],tstrok:[359],twixt:[8812],twoheadleftarrow:[8606],twoheadrightarrow:[8608],uArr:[8657],uHar:[10595],uacute:[250],uarr:[8593],ubrcy:[1118],ubreve:[365],ucirc:[251],ucy:[1091],udarr:[8645],udblac:[369],udhar:[10606],ufisht:[10622],ufr:[120114],ugrave:[249],uharl:[8639],uharr:[8638],uhblk:[9600],ulcorn:[8988],ulcorner:[8988],ulcrop:[8975],ultri:[9720],umacr:[363],uml:[168],uogon:[371],uopf:[120166],uparrow:[8593],updownarrow:[8597],upharpoonleft:[8639],upharpoonright:[8638],uplus:[8846],upsi:[965],upsih:[978],upsilon:[965],upuparrows:[8648],urcorn:[8989],urcorner:[8989],urcrop:[8974],uring:[367],urtri:[9721],uscr:[120010],utdot:[8944],utilde:[361],utri:[9653],utrif:[9652],uuarr:[8648],uuml:[252],uwangle:[10663],vArr:[8661],vBar:[10984],vBarv:[10985],vDash:[8872],vangrt:[10652],varepsilon:[1013],varkappa:[1008],varnothing:[8709],varphi:[981],varpi:[982],varpropto:[8733],varr:[8597],varrho:[1009],varsigma:[962],varsubsetneq:[8842,65024],varsubsetneqq:[10955,65024],varsupsetneq:[8843,65024],varsupsetneqq:[10956,65024],vartheta:[977],vartriangleleft:[8882],vartriangleright:[8883],vcy:[1074],vdash:[8866],vee:[8744],veebar:[8891],veeeq:[8794],vellip:[8942],verbar:[124],vert:[124],vfr:[120115],vltri:[8882],vnsub:[8834,8402],vnsup:[8835,8402],vopf:[120167],vprop:[8733],vrtri:[8883],vscr:[120011],vsubnE:[10955,65024],vsubne:[8842,65024],vsupnE:[10956,65024],vsupne:[8843,65024],vzigzag:[10650],wcirc:[373],wedbar:[10847],wedge:[8743],wedgeq:[8793],weierp:[8472],wfr:[120116],wopf:[120168],wp:[8472],wr:[8768],wreath:[8768],wscr:[120012],xcap:[8898],xcirc:[9711],xcup:[8899],xdtri:[9661],xfr:[120117],xhArr:[10234],xharr:[10231],xi:[958],xlArr:[10232],xlarr:[10229],xmap:[10236],xnis:[8955],xodot:[10752],xopf:[120169],xoplus:[10753],xotime:[10754],xrArr:[10233],xrarr:[10230],xscr:[120013],xsqcup:[10758],xuplus:[10756],xutri:[9651],xvee:[8897],xwedge:[8896],yacute:[253],yacy:[1103],ycirc:[375],ycy:[1099],yen:[165],yfr:[120118],yicy:[1111],yopf:[120170],yscr:[120014],yucy:[1102],yuml:[255],zacute:[378],zcaron:[382],zcy:[1079],zdot:[380],zeetrf:[8488],zeta:[950],zfr:[120119],zhcy:[1078],zigrarr:[8669],zopf:[120171],zscr:[120015],zwj:[8205],zwnj:[8204]}
-}),t("simple-html-tokenizer/char-refs/min",["exports"],function(t){"use strict";t["default"]={quot:[34],amp:[38],apos:[39],lt:[60],gt:[62]}}),t("simple-html-tokenizer/entity-parser",["exports"],function(t){"use strict";function e(t){this.namedCodepoints=t}e.prototype.parse=function(t){var e=t.input.slice(t["char"]),r=e.match(/^#(?:x|X)([0-9A-Fa-f]+);/);if(r)return t["char"]+=r[0].length,String.fromCharCode(parseInt(r[1],16));if(r=e.match(/^#([0-9]+);/))return t["char"]+=r[0].length,String.fromCharCode(parseInt(r[1],10));if(r=e.match(/^([A-Za-z]+);/)){var n=this.namedCodepoints[r[1]];if(n){t["char"]+=r[0].length;for(var i=0,s="";i"'`]/,r=/[&<>"'`]/g,n={"&":"&","<":"<",">":">",'"':""","'":"'","`":"`"};return function(n){return e.test(n)?n.replace(r,t):n}}();e.prototype={generate:function(t){for(var e,r="",n=0;n"},Chars:function(t){return this.escape(t.chars)},Comment:function(t){return""},Attributes:function(t){for(var e,r=[],n=0,i=t.length;i>n;n++)e=t[n],r.push(this.Attribute(e[0],e[1]));return r.join(" ")},Attribute:function(t,e){var r=t;return e&&(e=this.escape(e),r+='="'+e+'"'),r}},t["default"]=e}),t("simple-html-tokenizer/tokenize",["./tokenizer","./entity-parser","./char-refs/full","exports"],function(t,e,r,n){"use strict";var i=t["default"],s=e["default"],o=r["default"];n["default"]=function(t){var e=new i(t,new s(o));return e.tokenize()}}),t("simple-html-tokenizer/tokenizer",["./utils","./tokens","exports"],function(t,e,r){"use strict";function n(t,e){this.input=i(t),this.entityParser=e,this["char"]=0,this.line=1,this.column=0,this.state="data",this.token=null}var i=t.preprocessInput,s=t.isAlpha,o=t.isSpace,a=e.StartTag,l=e.EndTag,c=e.Chars,u=e.Comment;n.prototype={tokenize:function(){for(var t,e=[];;){if(t=this.lex(),"EOF"===t)break;t&&e.push(t)}return this.token&&e.push(this.token),e},tokenizePart:function(t){this.input+=i(t);for(var e,r=[];this["char"]"===t)return this.emitToken();this.addToComment(t),this.state="comment"}},commentStartDash:function(t){if("-"===t)this.state="commentEnd";else{if(">"===t)return this.emitToken();this.addToComment("-"),this.state="comment"}},comment:function(t){"-"===t?this.state="commentEndDash":this.addToComment(t)},commentEndDash:function(t){"-"===t?this.state="commentEnd":(this.addToComment("-"+t),this.state="comment")},commentEnd:function(t){return">"===t?this.emitToken():(this.addToComment("--"+t),void(this.state="comment"))},tagName:function(t){if(o(t))this.state="beforeAttributeName";else if("/"===t)this.state="selfClosingStartTag";else{if(">"===t)return this.emitToken();this.addToTagName(t)}},beforeAttributeName:function(t){if(!o(t))if("/"===t)this.state="selfClosingStartTag";else{if(">"===t)return this.emitToken();this.createAttribute(t)}},attributeName:function(t){if(o(t))this.state="afterAttributeName";else if("/"===t)this.state="selfClosingStartTag";else if("="===t)this.state="beforeAttributeValue";else{if(">"===t)return this.emitToken();this.addToAttributeName(t)}},afterAttributeName:function(t){if(!o(t))if("/"===t)this.state="selfClosingStartTag";else if("="===t)this.state="beforeAttributeValue";else{if(">"===t)return this.emitToken();this.finalizeAttributeValue(),this.createAttribute(t)}},beforeAttributeValue:function(t){if(!o(t))if('"'===t)this.state="attributeValueDoubleQuoted",this.markAttributeQuoted(!0);else if("'"===t)this.state="attributeValueSingleQuoted",this.markAttributeQuoted(!0);else{if(">"===t)return this.emitToken();this.state="attributeValueUnquoted",this.markAttributeQuoted(!1),this.addToAttributeValue(t)}},attributeValueDoubleQuoted:function(t){'"'===t?(this.finalizeAttributeValue(),this.state="afterAttributeValueQuoted"):this.addToAttributeValue("&"===t?this.consumeCharRef('"')||"&":t)},attributeValueSingleQuoted:function(t){"'"===t?(this.finalizeAttributeValue(),this.state="afterAttributeValueQuoted"):this.addToAttributeValue("&"===t?this.consumeCharRef("'")||"&":t)},attributeValueUnquoted:function(t){if(o(t))this.finalizeAttributeValue(),this.state="beforeAttributeName";else if("&"===t)this.addToAttributeValue(this.consumeCharRef(">")||"&");else{if(">"===t)return this.emitToken();this.addToAttributeValue(t)}},afterAttributeValueQuoted:function(t){if(o(t))this.state="beforeAttributeName";else if("/"===t)this.state="selfClosingStartTag";else{if(">"===t)return this.emitToken();this["char"]--,this.state="beforeAttributeName"}},selfClosingStartTag:function(t){return">"===t?(this.selfClosing(),this.emitToken()):(this["char"]--,void(this.state="beforeAttributeName"))},endTagOpen:function(t){s(t)&&this.createTag(l,t.toLowerCase())}}},r["default"]=n}),t("simple-html-tokenizer/tokens",["exports"],function(t){"use strict";function e(t,e,r){this.type="StartTag",this.tagName=t||"",this.attributes=e||[],this.selfClosing=r===!0}function r(t){this.type="EndTag",this.tagName=t||""}function n(t){this.type="Chars",this.chars=t||""}function i(t){this.type="Comment",this.chars=t||""}t.StartTag=e,t.EndTag=r,t.Chars=n,t.Comment=i}),t("simple-html-tokenizer/utils",["exports"],function(t){"use strict";function e(t){return/[\t\n\f ]/.test(t)}function r(t){return/[A-Za-z]/.test(t)}function n(t){return t.replace(/\r\n?/g,"\n")}t.isSpace=e,t.isAlpha=r,t.preprocessInput=n}),e("ember-template-compiler")}(),"object"==typeof exports&&(module.exports=Ember.__loader.require("ember-template-compiler"));
+/*!
+ * @overview Ember - JavaScript Application Framework
+ * @copyright Copyright 2011-2014 Tilde Inc. and contributors
+ * Portions Copyright 2006-2011 Strobe Inc.
+ * Portions Copyright 2008-2011 Apple Inc. All rights reserved.
+ * @license Licensed under MIT license
+ * See https://raw.github.com/emberjs/ember.js/master/LICENSE
+ * @version 1.10.1
+ */
+
+(function() {
+var define, requireModule, require, requirejs, Ember;
+
+(function() {
+ Ember = this.Ember = this.Ember || {};
+ if (typeof Ember === 'undefined') { Ember = {}; };
+ function UNDEFINED() { }
+
+ if (typeof Ember.__loader === 'undefined') {
+ var registry = {}, seen = {};
+
+ define = function(name, deps, callback) {
+ registry[name] = { deps: deps, callback: callback };
+ };
+
+ requirejs = require = requireModule = function(name) {
+ var s = seen[name];
+
+ if (s !== undefined) { return seen[name]; }
+ if (s === UNDEFINED) { return undefined; }
+
+ seen[name] = {};
+
+ if (!registry[name]) {
+ throw new Error('Could not find module ' + name);
+ }
+
+ var mod = registry[name];
+ var deps = mod.deps;
+ var callback = mod.callback;
+ var reified = [];
+ var exports;
+ var length = deps.length;
+
+ for (var i=0; i 0) {
+ this.opcode('repairClonedNode', blankChildTextNodes);
+ }
+ };
+
+ HydrationOpcodeCompiler.prototype.endProgram = function(/* program */) {
+ distributeMorphs(this.morphs, this.opcodes);
+ };
+
+ HydrationOpcodeCompiler.prototype.text = function(/* string, pos, len */) {
+ ++this.currentDOMChildIndex;
+ };
+
+ HydrationOpcodeCompiler.prototype.comment = function(/* string, pos, len */) {
+ ++this.currentDOMChildIndex;
+ };
+
+ HydrationOpcodeCompiler.prototype.openElement = function(element, pos, len, isSingleRoot, mustacheCount, blankChildTextNodes) {
+ distributeMorphs(this.morphs, this.opcodes);
+ ++this.currentDOMChildIndex;
+
+ this.element = this.currentDOMChildIndex;
+
+ if (!isSingleRoot) {
+ this.opcode('consumeParent', this.currentDOMChildIndex);
+
+ // If our parent reference will be used more than once, cache its reference.
+ if (mustacheCount > 1) {
+ this.opcode('shareElement', ++this.elementNum);
+ this.element = null; // Set element to null so we don't cache it twice
+ }
+ }
+ var isElementChecked = detectIsElementChecked(element);
+ if (blankChildTextNodes.length > 0 || isElementChecked) {
+ this.opcode( 'repairClonedNode',
+ blankChildTextNodes,
+ isElementChecked );
+ }
+
+ this.paths.push(this.currentDOMChildIndex);
+ this.currentDOMChildIndex = -1;
+
+ forEach(element.attributes, this.attribute, this);
+ forEach(element.helpers, this.elementHelper, this);
+ };
+
+ HydrationOpcodeCompiler.prototype.closeElement = function(element, pos, len, isSingleRoot) {
+ distributeMorphs(this.morphs, this.opcodes);
+ if (!isSingleRoot) { this.opcode('popParent'); }
+ this.currentDOMChildIndex = this.paths.pop();
+ };
+
+ HydrationOpcodeCompiler.prototype.block = function(block, childIndex, childrenLength) {
+ var sexpr = block.sexpr;
+
+ var currentDOMChildIndex = this.currentDOMChildIndex;
+ var start = (currentDOMChildIndex < 0) ? null : currentDOMChildIndex;
+ var end = (childIndex === childrenLength - 1) ? null : currentDOMChildIndex + 1;
+
+ var morphNum = this.morphNum++;
+ this.morphs.push([morphNum, this.paths.slice(), start, end, true]);
+
+ var templateId = this.templateId++;
+ var inverseId = block.inverse === null ? null : this.templateId++;
+
+ prepareSexpr(this, sexpr);
+ this.opcode('printBlockHook', morphNum, templateId, inverseId);
+ };
+
+ HydrationOpcodeCompiler.prototype.component = function(component, childIndex, childrenLength) {
+ var currentDOMChildIndex = this.currentDOMChildIndex;
+ var program = component.program || {};
+ var blockParams = program.blockParams || [];
+
+ var start = (currentDOMChildIndex < 0 ? null : currentDOMChildIndex),
+ end = (childIndex === childrenLength - 1 ? null : currentDOMChildIndex + 1);
+
+ var morphNum = this.morphNum++;
+ this.morphs.push([morphNum, this.paths.slice(), start, end, true]);
+
+ var attrs = component.attributes;
+ for (var i = attrs.length - 1; i >= 0; i--) {
+ var name = attrs[i].name;
+ var value = attrs[i].value;
+
+ // TODO: Introduce context specific AST nodes to avoid switching here.
+ if (value.type === 'TextNode') {
+ this.opcode('pushLiteral', value.chars);
+ } else if (value.type === 'MustacheStatement') {
+ this.accept(unwrapMustache(value));
+ } else if (value.type === 'ConcatStatement') {
+ prepareParams(this, value.parts);
+ this.opcode('pushConcatHook');
+ }
+
+ this.opcode('pushLiteral', name);
+ }
+
+ this.opcode('prepareObject', attrs.length);
+ this.opcode('pushLiteral', component.tag);
+ this.opcode('printComponentHook', morphNum, this.templateId++, blockParams.length);
+ };
+
+ HydrationOpcodeCompiler.prototype.attribute = function(attr) {
+ var value = attr.value;
+ var escaped = true;
+ var namespace = getAttrNamespace(attr.name);
+
+ // TODO: Introduce context specific AST nodes to avoid switching here.
+ if (value.type === 'TextNode') {
+ return;
+ } else if (value.type === 'MustacheStatement') {
+ escaped = value.escaped;
+ this.accept(unwrapMustache(value));
+ } else if (value.type === 'ConcatStatement') {
+ prepareParams(this, value.parts);
+ this.opcode('pushConcatHook');
+ }
+
+ this.opcode('pushLiteral', attr.name);
+
+ if (this.element !== null) {
+ this.opcode('shareElement', ++this.elementNum);
+ this.element = null;
+ }
+
+ var attrMorphNum = this.attrMorphNum++;
+ this.opcode('createAttrMorph', attrMorphNum, this.elementNum, attr.name, escaped, namespace);
+ this.opcode('printAttributeHook', attrMorphNum, this.elementNum);
+ };
+
+ HydrationOpcodeCompiler.prototype.elementHelper = function(sexpr) {
+ prepareSexpr(this, sexpr);
+
+ // If we have a helper in a node, and this element has not been cached, cache it
+ if (this.element !== null) {
+ this.opcode('shareElement', ++this.elementNum);
+ this.element = null; // Reset element so we don't cache it more than once
+ }
+
+ this.opcode('printElementHook', this.elementNum);
+ };
+
+ HydrationOpcodeCompiler.prototype.mustache = function(mustache, childIndex, childrenLength) {
+ var sexpr = mustache.sexpr;
+ var currentDOMChildIndex = this.currentDOMChildIndex;
+
+ var start = currentDOMChildIndex,
+ end = (childIndex === childrenLength - 1 ? -1 : currentDOMChildIndex + 1);
+
+ var morphNum = this.morphNum++;
+ this.morphs.push([morphNum, this.paths.slice(), start, end, mustache.escaped]);
+
+ if (isHelper(sexpr)) {
+ prepareSexpr(this, sexpr);
+ this.opcode('printInlineHook', morphNum);
+ } else {
+ preparePath(this, sexpr.path);
+ this.opcode('printContentHook', morphNum);
+ }
+ };
+
+ HydrationOpcodeCompiler.prototype.SubExpression = function(sexpr) {
+ prepareSexpr(this, sexpr);
+ this.opcode('pushSexprHook');
+ };
+
+ HydrationOpcodeCompiler.prototype.PathExpression = function(path) {
+ this.opcode('pushGetHook', path.original);
+ };
+
+ HydrationOpcodeCompiler.prototype.StringLiteral = function(node) {
+ this.opcode('pushLiteral', node.value);
+ };
+
+ HydrationOpcodeCompiler.prototype.BooleanLiteral = function(node) {
+ this.opcode('pushLiteral', node.value);
+ };
+
+ HydrationOpcodeCompiler.prototype.NumberLiteral = function(node) {
+ this.opcode('pushLiteral', node.value);
+ };
+
+ function preparePath(compiler, path) {
+ compiler.opcode('pushLiteral', path.original);
+ }
+
+ function prepareParams(compiler, params) {
+ for (var i = params.length - 1; i >= 0; i--) {
+ var param = params[i];
+ compiler[param.type](param);
+ }
+
+ compiler.opcode('prepareArray', params.length);
+ }
+
+ function prepareHash(compiler, hash) {
+ var pairs = hash.pairs;
+
+ for (var i = pairs.length - 1; i >= 0; i--) {
+ var key = pairs[i].key;
+ var value = pairs[i].value;
+
+ compiler[value.type](value);
+ compiler.opcode('pushLiteral', key);
+ }
+
+ compiler.opcode('prepareObject', pairs.length);
+ }
+
+ function prepareSexpr(compiler, sexpr) {
+ prepareHash(compiler, sexpr.hash);
+ prepareParams(compiler, sexpr.params);
+ preparePath(compiler, sexpr.path);
+ }
+
+ function distributeMorphs(morphs, opcodes) {
+ if (morphs.length === 0) {
+ return;
+ }
+
+ // Splice morphs after the most recent shareParent/consumeParent.
+ var o;
+ for (o = opcodes.length - 1; o >= 0; --o) {
+ var opcode = opcodes[o][0];
+ if (opcode === 'shareElement' || opcode === 'consumeParent' || opcode === 'popParent') {
+ break;
+ }
+ }
+
+ var spliceArgs = [o + 1, 0];
+ for (var i = 0; i < morphs.length; ++i) {
+ spliceArgs.push(['createMorph', morphs[i].slice()]);
+ }
+ opcodes.splice.apply(opcodes, spliceArgs);
+ morphs.length = 0;
+ }
+ });
+define("htmlbars-compiler/template-compiler",
+ ["./fragment-opcode-compiler","./fragment-javascript-compiler","./hydration-opcode-compiler","./hydration-javascript-compiler","./template-visitor","./utils","../htmlbars-util/quoting","exports"],
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
+ "use strict";
+ var FragmentOpcodeCompiler = __dependency1__["default"];
+ var FragmentJavaScriptCompiler = __dependency2__["default"];
+ var HydrationOpcodeCompiler = __dependency3__["default"];
+ var HydrationJavaScriptCompiler = __dependency4__["default"];
+ var TemplateVisitor = __dependency5__["default"];
+ var processOpcodes = __dependency6__.processOpcodes;
+ var repeat = __dependency7__.repeat;
+
+ function TemplateCompiler(options) {
+ this.options = options || {};
+ this.fragmentOpcodeCompiler = new FragmentOpcodeCompiler();
+ this.fragmentCompiler = new FragmentJavaScriptCompiler();
+ this.hydrationOpcodeCompiler = new HydrationOpcodeCompiler();
+ this.hydrationCompiler = new HydrationJavaScriptCompiler();
+ this.templates = [];
+ this.childTemplates = [];
+ }
+
+ __exports__["default"] = TemplateCompiler;
+
+ TemplateCompiler.prototype.compile = function(ast) {
+ var templateVisitor = new TemplateVisitor();
+ templateVisitor.visit(ast);
+
+ processOpcodes(this, templateVisitor.actions);
+
+ return this.templates.pop();
+ };
+
+ TemplateCompiler.prototype.startProgram = function(program, childTemplateCount, blankChildTextNodes) {
+ this.fragmentOpcodeCompiler.startProgram(program, childTemplateCount, blankChildTextNodes);
+ this.hydrationOpcodeCompiler.startProgram(program, childTemplateCount, blankChildTextNodes);
+
+ this.childTemplates.length = 0;
+ while(childTemplateCount--) {
+ this.childTemplates.push(this.templates.pop());
+ }
+ };
+
+ TemplateCompiler.prototype.getChildTemplateVars = function(indent) {
+ var vars = '';
+ if (this.childTemplates) {
+ for (var i = 0; i < this.childTemplates.length; i++) {
+ vars += indent + 'var child' + i + ' = ' + this.childTemplates[i] + ';\n';
+ }
+ }
+ return vars;
+ };
+
+ TemplateCompiler.prototype.getHydrationHooks = function(indent, hooks) {
+ var hookVars = [];
+ for (var hook in hooks) {
+ hookVars.push(hook + ' = hooks.' + hook);
+ }
+
+ if (hookVars.length > 0) {
+ return indent + 'var hooks = env.hooks, ' + hookVars.join(', ') + ';\n';
+ } else {
+ return '';
+ }
+ };
+
+ TemplateCompiler.prototype.endProgram = function(program, programDepth) {
+ this.fragmentOpcodeCompiler.endProgram(program);
+ this.hydrationOpcodeCompiler.endProgram(program);
+
+ var indent = repeat(" ", programDepth);
+ var options = {
+ indent: indent + " "
+ };
+
+ // function build(dom) { return fragment; }
+ var fragmentProgram = this.fragmentCompiler.compile(
+ this.fragmentOpcodeCompiler.opcodes,
+ options
+ );
+
+ // function hydrate(fragment) { return mustaches; }
+ var hydrationProgram = this.hydrationCompiler.compile(
+ this.hydrationOpcodeCompiler.opcodes,
+ options
+ );
+
+ var blockParams = program.blockParams || [];
+
+ var templateSignature = 'context, env, contextualElement';
+ if (blockParams.length > 0) {
+ templateSignature += ', blockArguments';
+ }
+
+ var template =
+ '(function() {\n' +
+ this.getChildTemplateVars(indent + ' ') +
+ indent+' return {\n' +
+ indent+' isHTMLBars: true,\n' +
+ indent+' blockParams: ' + blockParams.length + ',\n' +
+ indent+' cachedFragment: null,\n' +
+ indent+' hasRendered: false,\n' +
+ indent+' build: ' + fragmentProgram + ',\n' +
+ indent+' render: function render(' + templateSignature + ') {\n' +
+ indent+' var dom = env.dom;\n' +
+ this.getHydrationHooks(indent + ' ', this.hydrationCompiler.hooks) +
+ indent+' dom.detectNamespace(contextualElement);\n' +
+ indent+' var fragment;\n' +
+ indent+' if (env.useFragmentCache && dom.canClone) {\n' +
+ indent+' if (this.cachedFragment === null) {\n' +
+ indent+' fragment = this.build(dom);\n' +
+ indent+' if (this.hasRendered) {\n' +
+ indent+' this.cachedFragment = fragment;\n' +
+ indent+' } else {\n' +
+ indent+' this.hasRendered = true;\n' +
+ indent+' }\n' +
+ indent+' }\n' +
+ indent+' if (this.cachedFragment) {\n' +
+ indent+' fragment = dom.cloneNode(this.cachedFragment, true);\n' +
+ indent+' }\n' +
+ indent+' } else {\n' +
+ indent+' fragment = this.build(dom);\n' +
+ indent+' }\n' +
+ hydrationProgram +
+ indent+' return fragment;\n' +
+ indent+' }\n' +
+ indent+' };\n' +
+ indent+'}())';
+
+ this.templates.push(template);
+ };
+
+ TemplateCompiler.prototype.openElement = function(element, i, l, r, c, b) {
+ this.fragmentOpcodeCompiler.openElement(element, i, l, r, c, b);
+ this.hydrationOpcodeCompiler.openElement(element, i, l, r, c, b);
+ };
+
+ TemplateCompiler.prototype.closeElement = function(element, i, l, r) {
+ this.fragmentOpcodeCompiler.closeElement(element, i, l, r);
+ this.hydrationOpcodeCompiler.closeElement(element, i, l, r);
+ };
+
+ TemplateCompiler.prototype.component = function(component, i, l) {
+ this.fragmentOpcodeCompiler.component(component, i, l);
+ this.hydrationOpcodeCompiler.component(component, i, l);
+ };
+
+ TemplateCompiler.prototype.block = function(block, i, l) {
+ this.fragmentOpcodeCompiler.block(block, i, l);
+ this.hydrationOpcodeCompiler.block(block, i, l);
+ };
+
+ TemplateCompiler.prototype.text = function(string, i, l, r) {
+ this.fragmentOpcodeCompiler.text(string, i, l, r);
+ this.hydrationOpcodeCompiler.text(string, i, l, r);
+ };
+
+ TemplateCompiler.prototype.comment = function(string, i, l, r) {
+ this.fragmentOpcodeCompiler.comment(string, i, l, r);
+ this.hydrationOpcodeCompiler.comment(string, i, l, r);
+ };
+
+ TemplateCompiler.prototype.mustache = function (mustache, i, l) {
+ this.fragmentOpcodeCompiler.mustache(mustache, i, l);
+ this.hydrationOpcodeCompiler.mustache(mustache, i, l);
+ };
+
+ TemplateCompiler.prototype.setNamespace = function(namespace) {
+ this.fragmentOpcodeCompiler.setNamespace(namespace);
+ };
+ });
+define("htmlbars-compiler/template-visitor",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ var push = Array.prototype.push;
+
+ function Frame() {
+ this.parentNode = null;
+ this.children = null;
+ this.childIndex = null;
+ this.childCount = null;
+ this.childTemplateCount = 0;
+ this.mustacheCount = 0;
+ this.actions = [];
+ }
+
+ /**
+ * Takes in an AST and outputs a list of actions to be consumed
+ * by a compiler. For example, the template
+ *
+ * foo{{bar}}
baz
+ *
+ * produces the actions
+ *
+ * [['startProgram', [programNode, 0]],
+ * ['text', [textNode, 0, 3]],
+ * ['mustache', [mustacheNode, 1, 3]],
+ * ['openElement', [elementNode, 2, 3, 0]],
+ * ['text', [textNode, 0, 1]],
+ * ['closeElement', [elementNode, 2, 3],
+ * ['endProgram', [programNode]]]
+ *
+ * This visitor walks the AST depth first and backwards. As
+ * a result the bottom-most child template will appear at the
+ * top of the actions list whereas the root template will appear
+ * at the bottom of the list. For example,
+ *
+ *
+ ```
+
+ ### `bind-attr` and the `class` attribute
+
+ `bind-attr` supports a special syntax for handling a number of cases unique
+ to the `class` DOM element attribute. The `class` attribute combines
+ multiple discrete values into a single attribute as a space-delimited
+ list of strings. Each string can be:
+
+ * a string return value of an object's property.
+ * a boolean return value of an object's property
+ * a hard-coded value
+
+ A string return value works identically to other uses of `bind-attr`. The
+ return value of the property will become the value of the attribute. For
+ example, the following view and template:
+
+ ```javascript
+ AView = View.extend({
+ someProperty: function() {
+ return "aValue";
+ }.property()
+ })
+ ```
+
+ ```handlebars
+