").append(jQuery.parseHTML(responseText)).find(selector) : responseText);
}).complete(callback && function(jqXHR, status) {
self.each(callback, response || [jqXHR.responseText, status, jqXHR]);
});
}
return this;
};
jQuery.each(["ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend"], function(i, type) {
jQuery.fn[type] = function(fn) {
return this.on(type, fn);
};
});
jQuery.expr.filters.animated = function(elem) {
return jQuery.grep(jQuery.timers, function(fn) {
return elem === fn.elem;
}).length;
};
var docElem = window.document.documentElement;
function getWindow(elem) {
return jQuery.isWindow(elem) ? elem : elem.nodeType === 9 ? elem.defaultView || elem.parentWindow : false;
}
jQuery.offset = {setOffset:function(elem, options, i) {
var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, position = jQuery.css(elem, "position"), curElem = jQuery(elem), props = {};
if (position === "static") {
elem.style.position = "relative";
}
curOffset = curElem.offset();
curCSSTop = jQuery.css(elem, "top");
curCSSLeft = jQuery.css(elem, "left");
calculatePosition = (position === "absolute" || position === "fixed") && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1;
if (calculatePosition) {
curPosition = curElem.position();
curTop = curPosition.top;
curLeft = curPosition.left;
} else {
curTop = parseFloat(curCSSTop) || 0;
curLeft = parseFloat(curCSSLeft) || 0;
}
if (jQuery.isFunction(options)) {
options = options.call(elem, i, curOffset);
}
if (options.top != null) {
props.top = options.top - curOffset.top + curTop;
}
if (options.left != null) {
props.left = options.left - curOffset.left + curLeft;
}
if ("using" in options) {
options.using.call(elem, props);
} else {
curElem.css(props);
}
}};
jQuery.fn.extend({offset:function(options) {
if (arguments.length) {
return options === undefined ? this : this.each(function(i) {
jQuery.offset.setOffset(this, options, i);
});
}
var docElem, win, box = {top:0, left:0}, elem = this[0], doc = elem && elem.ownerDocument;
if (!doc) {
return;
}
docElem = doc.documentElement;
if (!jQuery.contains(docElem, elem)) {
return box;
}
if (typeof elem.getBoundingClientRect !== strundefined) {
box = elem.getBoundingClientRect();
}
win = getWindow(doc);
return{top:box.top + (win.pageYOffset || docElem.scrollTop) - (docElem.clientTop || 0), left:box.left + (win.pageXOffset || docElem.scrollLeft) - (docElem.clientLeft || 0)};
}, position:function() {
if (!this[0]) {
return;
}
var offsetParent, offset, parentOffset = {top:0, left:0}, elem = this[0];
if (jQuery.css(elem, "position") === "fixed") {
offset = elem.getBoundingClientRect();
} else {
offsetParent = this.offsetParent();
offset = this.offset();
if (!jQuery.nodeName(offsetParent[0], "html")) {
parentOffset = offsetParent.offset();
}
parentOffset.top += jQuery.css(offsetParent[0], "borderTopWidth", true);
parentOffset.left += jQuery.css(offsetParent[0], "borderLeftWidth", true);
}
return{top:offset.top - parentOffset.top - jQuery.css(elem, "marginTop", true), left:offset.left - parentOffset.left - jQuery.css(elem, "marginLeft", true)};
}, offsetParent:function() {
return this.map(function() {
var offsetParent = this.offsetParent || docElem;
while (offsetParent && (!jQuery.nodeName(offsetParent, "html") && jQuery.css(offsetParent, "position") === "static")) {
offsetParent = offsetParent.offsetParent;
}
return offsetParent || docElem;
});
}});
jQuery.each({scrollLeft:"pageXOffset", scrollTop:"pageYOffset"}, function(method, prop) {
var top = /Y/.test(prop);
jQuery.fn[method] = function(val) {
return access(this, function(elem, method, val) {
var win = getWindow(elem);
if (val === undefined) {
return win ? prop in win ? win[prop] : win.document.documentElement[method] : elem[method];
}
if (win) {
win.scrollTo(!top ? val : jQuery(win).scrollLeft(), top ? val : jQuery(win).scrollTop());
} else {
elem[method] = val;
}
}, method, val, arguments.length, null);
};
});
jQuery.each(["top", "left"], function(i, prop) {
jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function(elem, computed) {
if (computed) {
computed = curCSS(elem, prop);
return rnumnonpx.test(computed) ? jQuery(elem).position()[prop] + "px" : computed;
}
});
});
jQuery.each({Height:"height", Width:"width"}, function(name, type) {
jQuery.each({padding:"inner" + name, content:type, "":"outer" + name}, function(defaultExtra, funcName) {
jQuery.fn[funcName] = function(margin, value) {
var chainable = arguments.length && (defaultExtra || typeof margin !== "boolean"), extra = defaultExtra || (margin === true || value === true ? "margin" : "border");
return access(this, function(elem, type, value) {
var doc;
if (jQuery.isWindow(elem)) {
return elem.document.documentElement["client" + name];
}
if (elem.nodeType === 9) {
doc = elem.documentElement;
return Math.max(elem.body["scroll" + name], doc["scroll" + name], elem.body["offset" + name], doc["offset" + name], doc["client" + name]);
}
return value === undefined ? jQuery.css(elem, type, extra) : jQuery.style(elem, type, value, extra);
}, type, chainable ? margin : undefined, chainable, null);
};
});
});
jQuery.fn.size = function() {
return this.length;
};
jQuery.fn.andSelf = jQuery.fn.addBack;
if (typeof define === "function" && define.amd) {
define("jquery", [], function() {
return jQuery;
});
}
var _jQuery = window.jQuery, _$ = window.$;
jQuery.noConflict = function(deep) {
if (window.$ === jQuery) {
window.$ = _$;
}
if (deep && window.jQuery === jQuery) {
window.jQuery = _jQuery;
}
return jQuery;
};
if (typeof noGlobal === strundefined) {
window.jQuery = window.$ = jQuery;
}
return jQuery;
});
(function(root, factory) {
if (typeof define === "function" && define.amd) {
define([], factory);
} else {
if (typeof exports === "object") {
module.exports = factory();
} else {
root.Handlebars = root.Handlebars || factory();
}
}
})(this, function() {
var __module4__ = function() {
var __exports__;
function SafeString(string) {
this.string = string;
}
SafeString.prototype.toString = function() {
return "" + this.string;
};
__exports__ = SafeString;
return __exports__;
}();
var __module3__ = function(__dependency1__) {
var __exports__ = {};
var SafeString = __dependency1__;
var escape = {"&":"&", "<":"<", ">":">", '"':""", "'":"'", "`":"`"};
var badChars = /[&<>"'`]/g;
var possible = /[&<>"'`]/;
function escapeChar(chr) {
return escape[chr];
}
function extend(obj) {
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;
var isFunction = function(value) {
return typeof value === "function";
};
if (isFunction(/x/)) {
isFunction = function(value) {
return typeof value === "function" && toString.call(value) === "[object Function]";
};
}
var isFunction;
__exports__.isFunction = isFunction;
var isArray = Array.isArray || function(value) {
return value && typeof value === "object" ? toString.call(value) === "[object Array]" : false;
};
__exports__.isArray = isArray;
function escapeExpression(string) {
if (string instanceof SafeString) {
return string.toString();
} else {
if (string == null) {
return "";
} else {
if (!string) {
return string + "";
}
}
}
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;
return __exports__;
}(__module4__);
var __module5__ = function() {
var __exports__;
var errorProps = ["description", "fileName", "lineNumber", "message", "name", "number", "stack"];
function Exception(message, node) {
var line;
if (node && node.firstLine) {
line = node.firstLine;
message += " - " + line + ":" + node.firstColumn;
}
var tmp = Error.prototype.constructor.call(this, message);
for (var idx = 0;idx < errorProps.length;idx++) {
this[errorProps[idx]] = tmp[errorProps[idx]];
}
if (line) {
this.lineNumber = line;
this.column = node.firstColumn;
}
}
Exception.prototype = new Error;
__exports__ = Exception;
return __exports__;
}();
var __module2__ = function(__dependency1__, __dependency2__) {
var __exports__ = {};
var Utils = __dependency1__;
var Exception = __dependency2__;
var VERSION = "2.0.0";
__exports__.VERSION = VERSION;
var COMPILER_REVISION = 6;
__exports__.COMPILER_REVISION = COMPILER_REVISION;
var REVISION_CHANGES = {1:"<= 1.0.rc.2", 2:"== 1.0.0-rc.3", 3:"== 1.0.0-rc.4", 4:"== 1.x.x", 5:"== 2.0.0-alpha.x", 6:">= 2.0.0-beta.1"};
__exports__.REVISION_CHANGES = REVISION_CHANGES;
var isArray = Utils.isArray, isFunction = Utils.isFunction, toString = Utils.toString, objectType = "[object Object]";
function HandlebarsEnvironment(helpers, partials) {
this.helpers = helpers || {};
this.partials = partials || {};
registerDefaultHelpers(this);
}
__exports__.HandlebarsEnvironment = HandlebarsEnvironment;
HandlebarsEnvironment.prototype = {constructor:HandlebarsEnvironment, logger:logger, log:log, registerHelper:function(name, fn) {
if (toString.call(name) === objectType) {
if (fn) {
throw new Exception("Arg not supported with multiple helpers");
}
Utils.extend(this.helpers, name);
} else {
this.helpers[name] = fn;
}
}, unregisterHelper:function(name) {
delete this.helpers[name];
}, registerPartial:function(name, partial) {
if (toString.call(name) === objectType) {
Utils.extend(this.partials, name);
} else {
this.partials[name] = partial;
}
}, unregisterPartial:function(name) {
delete this.partials[name];
}};
function registerDefaultHelpers(instance) {
instance.registerHelper("helperMissing", function() {
if (arguments.length === 1) {
return undefined;
} else {
throw new Exception("Missing helper: '" + arguments[arguments.length - 1].name + "'");
}
});
instance.registerHelper("blockHelperMissing", function(context, options) {
var inverse = options.inverse, fn = options.fn;
if (context === true) {
return fn(this);
} else {
if (context === false || context == null) {
return inverse(this);
} else {
if (isArray(context)) {
if (context.length > 0) {
if (options.ids) {
options.ids = [options.name];
}
return instance.helpers.each(context, options);
} else {
return inverse(this);
}
} else {
if (options.data && options.ids) {
var data = createFrame(options.data);
data.contextPath = Utils.appendContextPath(options.data.contextPath, options.name);
options = {data:data};
}
return fn(context, options);
}
}
}
});
instance.registerHelper("each", function(context, options) {
if (!options) {
throw new Exception("Must pass iterator to #each");
}
var fn = options.fn, inverse = options.inverse;
var i = 0, ret = "", data;
var contextPath;
if (options.data && options.ids) {
contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]) + ".";
}
if (isFunction(context)) {
context = context.call(this);
}
if (options.data) {
data = createFrame(options.data);
}
if (context && typeof context === "object") {
if (isArray(context)) {
for (var j = context.length;i < j;i++) {
if (data) {
data.index = i;
data.first = i === 0;
data.last = i === context.length - 1;
if (contextPath) {
data.contextPath = contextPath + i;
}
}
ret = ret + fn(context[i], {data:data});
}
} else {
for (var key in context) {
if (context.hasOwnProperty(key)) {
if (data) {
data.key = key;
data.index = i;
data.first = i === 0;
if (contextPath) {
data.contextPath = contextPath + key;
}
}
ret = ret + fn(context[key], {data:data});
i++;
}
}
}
}
if (i === 0) {
ret = inverse(this);
}
return ret;
});
instance.registerHelper("if", function(conditional, options) {
if (isFunction(conditional)) {
conditional = conditional.call(this);
}
if (!options.hash.includeZero && !conditional || Utils.isEmpty(conditional)) {
return options.inverse(this);
} else {
return options.fn(this);
}
});
instance.registerHelper("unless", function(conditional, options) {
return instance.helpers["if"].call(this, conditional, {fn:options.inverse, inverse:options.fn, hash:options.hash});
});
instance.registerHelper("with", function(context, options) {
if (isFunction(context)) {
context = context.call(this);
}
var fn = options.fn;
if (!Utils.isEmpty(context)) {
if (options.data && options.ids) {
var data = createFrame(options.data);
data.contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]);
options = {data:data};
}
return fn(context, options);
} else {
return options.inverse(this);
}
});
instance.registerHelper("log", function(message, options) {
var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
instance.log(level, message);
});
instance.registerHelper("lookup", function(obj, field) {
return obj && obj[field];
});
}
var logger = {methodMap:{0:"debug", 1:"info", 2:"warn", 3:"error"}, DEBUG:0, INFO:1, WARN:2, ERROR:3, level:3, log:function(level, message) {
if (logger.level <= level) {
var method = logger.methodMap[level];
if (typeof console !== "undefined" && console[method]) {
console[method].call(console, message);
}
}
}};
__exports__.logger = logger;
var log = logger.log;
__exports__.log = log;
var createFrame = function(object) {
var frame = Utils.extend({}, object);
frame._parent = object;
return frame;
};
__exports__.createFrame = createFrame;
return __exports__;
}(__module3__, __module5__);
var __module6__ = function(__dependency1__, __dependency2__, __dependency3__) {
var __exports__ = {};
var Utils = __dependency1__;
var Exception = __dependency2__;
var COMPILER_REVISION = __dependency3__.COMPILER_REVISION;
var REVISION_CHANGES = __dependency3__.REVISION_CHANGES;
var createFrame = __dependency3__.createFrame;
function checkRevision(compilerInfo) {
var compilerRevision = compilerInfo && compilerInfo[0] || 1, currentRevision = COMPILER_REVISION;
if (compilerRevision !== currentRevision) {
if (compilerRevision < currentRevision) {
var runtimeVersions = REVISION_CHANGES[currentRevision], compilerVersions = REVISION_CHANGES[compilerRevision];
throw new Exception("Template was precompiled with an older version of Handlebars than the current runtime. " + "Please update your precompiler to a newer version (" + runtimeVersions + ") or downgrade your runtime to an older version (" + compilerVersions + ").");
} else {
throw new Exception("Template was precompiled with a newer version of Handlebars than the current runtime. " + "Please update your runtime to a newer version (" + compilerInfo[1] + ").");
}
}
}
__exports__.checkRevision = checkRevision;
function template(templateSpec, env) {
if (!env) {
throw new Exception("No environment passed to template");
}
if (!templateSpec || !templateSpec.main) {
throw new Exception("Unknown template object: " + typeof templateSpec);
}
env.VM.checkRevision(templateSpec.compiler);
var invokePartialWrapper = function(partial, indent, name, context, hash, helpers, partials, data, depths) {
if (hash) {
context = Utils.extend({}, context, hash);
}
var result = env.VM.invokePartial.call(this, partial, name, context, helpers, partials, data, depths);
if (result == null && env.compile) {
var options = {helpers:helpers, partials:partials, data:data, depths:depths};
partials[name] = env.compile(partial, {data:data !== undefined, compat:templateSpec.compat}, env);
result = partials[name](context, options);
}
if (result != null) {
if (indent) {
var lines = result.split("\n");
for (var i = 0, l = lines.length;i < l;i++) {
if (!lines[i] && i + 1 === l) {
break;
}
lines[i] = indent + lines[i];
}
result = lines.join("\n");
}
return result;
} else {
throw new Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
}
};
var container = {lookup:function(depths, name) {
var len = depths.length;
for (var i = 0;i < len;i++) {
if (depths[i] && depths[i][name] != null) {
return depths[i][name];
}
}
}, lambda:function(current, context) {
return typeof current === "function" ? current.call(context) : current;
}, escapeExpression:Utils.escapeExpression, invokePartial:invokePartialWrapper, fn:function(i) {
return templateSpec[i];
}, programs:[], program:function(i, data, depths) {
var programWrapper = this.programs[i], fn = this.fn(i);
if (data || depths) {
programWrapper = program(this, i, fn, data, depths);
} else {
if (!programWrapper) {
programWrapper = this.programs[i] = program(this, i, fn);
}
}
return programWrapper;
}, data:function(data, depth) {
while (data && depth--) {
data = data._parent;
}
return data;
}, merge:function(param, common) {
var ret = param || common;
if (param && (common && param !== common)) {
ret = Utils.extend({}, common, param);
}
return ret;
}, noop:env.VM.noop, compilerInfo:templateSpec.compiler};
var ret = function(context, options) {
options = options || {};
var data = options.data;
ret._setup(options);
if (!options.partial && templateSpec.useData) {
data = initData(context, data);
}
var depths;
if (templateSpec.useDepths) {
depths = options.depths ? [context].concat(options.depths) : [context];
}
return templateSpec.main.call(container, context, container.helpers, container.partials, data, depths);
};
ret.isTop = true;
ret._setup = function(options) {
if (!options.partial) {
container.helpers = container.merge(options.helpers, env.helpers);
if (templateSpec.usePartial) {
container.partials = container.merge(options.partials, env.partials);
}
} else {
container.helpers = options.helpers;
container.partials = options.partials;
}
};
ret._child = function(i, data, depths) {
if (templateSpec.useDepths && !depths) {
throw new Exception("must pass parent depths");
}
return program(container, i, templateSpec[i], data, depths);
};
return ret;
}
__exports__.template = template;
function program(container, i, fn, data, depths) {
var prog = function(context, options) {
options = options || {};
return fn.call(container, context, container.helpers, container.partials, options.data || data, depths && [context].concat(depths));
};
prog.program = i;
prog.depth = depths ? depths.length : 0;
return prog;
}
__exports__.program = program;
function invokePartial(partial, name, context, helpers, partials, data, depths) {
var options = {partial:true, helpers:helpers, partials:partials, data:data, depths:depths};
if (partial === undefined) {
throw new Exception("The partial " + name + " could not be found");
} else {
if (partial instanceof Function) {
return partial(context, options);
}
}
}
__exports__.invokePartial = invokePartial;
function noop() {
return "";
}
__exports__.noop = noop;
function initData(context, data) {
if (!data || !("root" in data)) {
data = data ? createFrame(data) : {};
data.root = context;
}
return data;
}
return __exports__;
}(__module3__, __module5__, __module2__);
var __module1__ = function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) {
var __exports__;
var base = __dependency1__;
var SafeString = __dependency2__;
var Exception = __dependency3__;
var Utils = __dependency4__;
var runtime = __dependency5__;
var create = function() {
var hb = new base.HandlebarsEnvironment;
Utils.extend(hb, base);
hb.SafeString = SafeString;
hb.Exception = Exception;
hb.Utils = Utils;
hb.escapeExpression = Utils.escapeExpression;
hb.VM = runtime;
hb.template = function(spec) {
return runtime.template(spec, hb);
};
return hb;
};
var Handlebars = create();
Handlebars.create = create;
Handlebars["default"] = Handlebars;
__exports__ = Handlebars;
return __exports__;
}(__module2__, __module4__, __module5__, __module3__, __module6__);
var __module7__ = function(__dependency1__) {
var __exports__;
var Exception = __dependency1__;
function LocationInfo(locInfo) {
locInfo = locInfo || {};
this.firstLine = locInfo.first_line;
this.firstColumn = locInfo.first_column;
this.lastColumn = locInfo.last_column;
this.lastLine = locInfo.last_line;
}
var AST = {ProgramNode:function(statements, strip, locInfo) {
LocationInfo.call(this, locInfo);
this.type = "program";
this.statements = statements;
this.strip = strip;
}, MustacheNode:function(rawParams, hash, open, strip, locInfo) {
LocationInfo.call(this, locInfo);
this.type = "mustache";
this.strip = strip;
if (open != null && open.charAt) {
var escapeFlag = open.charAt(3) || open.charAt(2);
this.escaped = escapeFlag !== "{" && escapeFlag !== "&";
} else {
this.escaped = !!open;
}
if (rawParams instanceof AST.SexprNode) {
this.sexpr = rawParams;
} else {
this.sexpr = new AST.SexprNode(rawParams, hash);
}
this.id = this.sexpr.id;
this.params = this.sexpr.params;
this.hash = this.sexpr.hash;
this.eligibleHelper = this.sexpr.eligibleHelper;
this.isHelper = this.sexpr.isHelper;
}, SexprNode:function(rawParams, hash, locInfo) {
LocationInfo.call(this, locInfo);
this.type = "sexpr";
this.hash = hash;
var id = this.id = rawParams[0];
var params = this.params = rawParams.slice(1);
this.isHelper = !!(params.length || hash);
this.eligibleHelper = this.isHelper || id.isSimple;
}, PartialNode:function(partialName, context, hash, strip, locInfo) {
LocationInfo.call(this, locInfo);
this.type = "partial";
this.partialName = partialName;
this.context = context;
this.hash = hash;
this.strip = strip;
this.strip.inlineStandalone = true;
}, BlockNode:function(mustache, program, inverse, strip, locInfo) {
LocationInfo.call(this, locInfo);
this.type = "block";
this.mustache = mustache;
this.program = program;
this.inverse = inverse;
this.strip = strip;
if (inverse && !program) {
this.isInverse = true;
}
}, RawBlockNode:function(mustache, content, close, locInfo) {
LocationInfo.call(this, locInfo);
if (mustache.sexpr.id.original !== close) {
throw new Exception(mustache.sexpr.id.original + " doesn't match " + close, this);
}
content = new AST.ContentNode(content, locInfo);
this.type = "block";
this.mustache = mustache;
this.program = new AST.ProgramNode([content], {}, locInfo);
}, ContentNode:function(string, locInfo) {
LocationInfo.call(this, locInfo);
this.type = "content";
this.original = this.string = string;
}, HashNode:function(pairs, locInfo) {
LocationInfo.call(this, locInfo);
this.type = "hash";
this.pairs = pairs;
}, IdNode:function(parts, locInfo) {
LocationInfo.call(this, locInfo);
this.type = "ID";
var original = "", dig = [], depth = 0, depthString = "";
for (var i = 0, l = parts.length;i < l;i++) {
var part = parts[i].part;
original += (parts[i].separator || "") + part;
if (part === ".." || (part === "." || part === "this")) {
if (dig.length > 0) {
throw new Exception("Invalid path: " + original, this);
} else {
if (part === "..") {
depth++;
depthString += "../";
} else {
this.isScoped = true;
}
}
} else {
dig.push(part);
}
}
this.original = original;
this.parts = dig;
this.string = dig.join(".");
this.depth = depth;
this.idName = depthString + this.string;
this.isSimple = parts.length === 1 && (!this.isScoped && depth === 0);
this.stringModeValue = this.string;
}, PartialNameNode:function(name, locInfo) {
LocationInfo.call(this, locInfo);
this.type = "PARTIAL_NAME";
this.name = name.original;
}, DataNode:function(id, locInfo) {
LocationInfo.call(this, locInfo);
this.type = "DATA";
this.id = id;
this.stringModeValue = id.stringModeValue;
this.idName = "@" + id.stringModeValue;
}, StringNode:function(string, locInfo) {
LocationInfo.call(this, locInfo);
this.type = "STRING";
this.original = this.string = this.stringModeValue = string;
}, NumberNode:function(number, locInfo) {
LocationInfo.call(this, locInfo);
this.type = "NUMBER";
this.original = this.number = number;
this.stringModeValue = Number(number);
}, BooleanNode:function(bool, locInfo) {
LocationInfo.call(this, locInfo);
this.type = "BOOLEAN";
this.bool = bool;
this.stringModeValue = bool === "true";
}, CommentNode:function(comment, locInfo) {
LocationInfo.call(this, locInfo);
this.type = "comment";
this.comment = comment;
this.strip = {inlineStandalone:true};
}};
__exports__ = AST;
return __exports__;
}(__module5__);
var __module9__ = function() {
var __exports__;
var handlebars = function() {
var parser = {trace:function trace() {
}, 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, "openRawBlock":14, "END_RAW_BLOCK":15, "OPEN_RAW_BLOCK":16, "sexpr":17, "CLOSE_RAW_BLOCK":18, "openBlock":19, "block_option0":20, "closeBlock":21, "openInverse":22, "block_option1":23, "OPEN_BLOCK":24, "CLOSE":25, "OPEN_INVERSE":26, "inverseAndProgram":27, "INVERSE":28, "OPEN_ENDBLOCK":29, "path":30, "OPEN":31,
"OPEN_UNESCAPED":32, "CLOSE_UNESCAPED":33, "OPEN_PARTIAL":34, "partialName":35, "param":36, "partial_option0":37, "partial_option1":38, "sexpr_repetition0":39, "sexpr_option0":40, "dataName":41, "STRING":42, "NUMBER":43, "BOOLEAN":44, "OPEN_SEXPR":45, "CLOSE_SEXPR":46, "hash":47, "hash_repetition_plus0":48, "hashSegment":49, "ID":50, "EQUALS":51, "DATA":52, "pathSegments":53, "SEP":54, "$accept":0, "$end":1}, terminals_:{2:"error", 5:"EOF", 12:"CONTENT", 13:"COMMENT", 15:"END_RAW_BLOCK", 16:"OPEN_RAW_BLOCK",
18:"CLOSE_RAW_BLOCK", 24:"OPEN_BLOCK", 25:"CLOSE", 26:"OPEN_INVERSE", 28:"INVERSE", 29:"OPEN_ENDBLOCK", 31:"OPEN", 32:"OPEN_UNESCAPED", 33:"CLOSE_UNESCAPED", 34:"OPEN_PARTIAL", 42:"STRING", 43:"NUMBER", 44:"BOOLEAN", 45:"OPEN_SEXPR", 46:"CLOSE_SEXPR", 50:"ID", 51:"EQUALS", 52:"DATA", 54:"SEP"}, productions_:[0, [3, 2], [4, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [10, 3], [14, 3], [9, 4], [9, 4], [19, 3], [22, 3], [27, 2], [21, 3], [8, 3], [8, 3], [11, 5], [11, 4], [17, 3], [17,
1], [36, 1], [36, 1], [36, 1], [36, 1], [36, 1], [36, 3], [47, 1], [49, 3], [35, 1], [35, 1], [35, 1], [41, 2], [30, 1], [53, 3], [53, 1], [6, 0], [6, 2], [20, 0], [20, 1], [23, 0], [23, 1], [37, 0], [37, 1], [38, 0], [38, 1], [39, 0], [39, 2], [40, 0], [40, 1], [48, 1], [48, 2]], performAction:function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
var $0 = $$.length - 1;
switch(yystate) {
case 1:
yy.prepareProgram($$[$0 - 1].statements, true);
return $$[$0 - 1];
break;
case 2:
this.$ = new yy.ProgramNode(yy.prepareProgram($$[$0]), {}, this._$);
break;
case 3:
this.$ = $$[$0];
break;
case 4:
this.$ = $$[$0];
break;
case 5:
this.$ = $$[$0];
break;
case 6:
this.$ = $$[$0];
break;
case 7:
this.$ = new yy.ContentNode($$[$0], this._$);
break;
case 8:
this.$ = new yy.CommentNode($$[$0], this._$);
break;
case 9:
this.$ = new yy.RawBlockNode($$[$0 - 2], $$[$0 - 1], $$[$0], this._$);
break;
case 10:
this.$ = new yy.MustacheNode($$[$0 - 1], null, "", "", this._$);
break;
case 11:
this.$ = yy.prepareBlock($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0], false, this._$);
break;
case 12:
this.$ = yy.prepareBlock($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0], true, this._$);
break;
case 13:
this.$ = new yy.MustacheNode($$[$0 - 1], null, $$[$0 - 2], yy.stripFlags($$[$0 - 2], $$[$0]), this._$);
break;
case 14:
this.$ = new yy.MustacheNode($$[$0 - 1], null, $$[$0 - 2], yy.stripFlags($$[$0 - 2], $$[$0]), this._$);
break;
case 15:
this.$ = {strip:yy.stripFlags($$[$0 - 1], $$[$0 - 1]), program:$$[$0]};
break;
case 16:
this.$ = {path:$$[$0 - 1], strip:yy.stripFlags($$[$0 - 2], $$[$0])};
break;
case 17:
this.$ = new yy.MustacheNode($$[$0 - 1], null, $$[$0 - 2], yy.stripFlags($$[$0 - 2], $$[$0]), this._$);
break;
case 18:
this.$ = new yy.MustacheNode($$[$0 - 1], null, $$[$0 - 2], yy.stripFlags($$[$0 - 2], $$[$0]), this._$);
break;
case 19:
this.$ = new yy.PartialNode($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], yy.stripFlags($$[$0 - 4], $$[$0]), this._$);
break;
case 20:
this.$ = new yy.PartialNode($$[$0 - 2], undefined, $$[$0 - 1], yy.stripFlags($$[$0 - 3], $$[$0]), this._$);
break;
case 21:
this.$ = new yy.SexprNode([$$[$0 - 2]].concat($$[$0 - 1]), $$[$0], this._$);
break;
case 22:
this.$ = new yy.SexprNode([$$[$0]], null, this._$);
break;
case 23:
this.$ = $$[$0];
break;
case 24:
this.$ = new yy.StringNode($$[$0], this._$);
break;
case 25:
this.$ = new yy.NumberNode($$[$0], this._$);
break;
case 26:
this.$ = new yy.BooleanNode($$[$0], this._$);
break;
case 27:
this.$ = $$[$0];
break;
case 28:
$$[$0 - 1].isHelper = true;
this.$ = $$[$0 - 1];
break;
case 29:
this.$ = new yy.HashNode($$[$0], this._$);
break;
case 30:
this.$ = [$$[$0 - 2], $$[$0]];
break;
case 31:
this.$ = new yy.PartialNameNode($$[$0], this._$);
break;
case 32:
this.$ = new yy.PartialNameNode(new yy.StringNode($$[$0], this._$), this._$);
break;
case 33:
this.$ = new yy.PartialNameNode(new yy.NumberNode($$[$0], this._$));
break;
case 34:
this.$ = new yy.DataNode($$[$0], this._$);
break;
case 35:
this.$ = new yy.IdNode($$[$0], this._$);
break;
case 36:
$$[$0 - 2].push({part:$$[$0], separator:$$[$0 - 1]});
this.$ = $$[$0 - 2];
break;
case 37:
this.$ = [{part:$$[$0]}];
break;
case 38:
this.$ = [];
break;
case 39:
$$[$0 - 1].push($$[$0]);
break;
case 48:
this.$ = [];
break;
case 49:
$$[$0 - 1].push($$[$0]);
break;
case 52:
this.$ = [$$[$0]];
break;
case 53:
$$[$0 - 1].push($$[$0]);
break;
}
}, table:[{3:1, 4:2, 5:[2, 38], 6:3, 12:[2, 38], 13:[2, 38], 16:[2, 38], 24:[2, 38], 26:[2, 38], 31:[2, 38], 32:[2, 38], 34:[2, 38]}, {1:[3]}, {5:[1, 4]}, {5:[2, 2], 7:5, 8:6, 9:7, 10:8, 11:9, 12:[1, 10], 13:[1, 11], 14:16, 16:[1, 20], 19:14, 22:15, 24:[1, 18], 26:[1, 19], 28:[2, 2], 29:[2, 2], 31:[1, 12], 32:[1, 13], 34:[1, 17]}, {1:[2, 1]}, {5:[2, 39], 12:[2, 39], 13:[2, 39], 16:[2, 39], 24:[2, 39], 26:[2, 39], 28:[2, 39], 29:[2, 39], 31:[2, 39], 32:[2, 39], 34:[2, 39]}, {5:[2, 3], 12:[2,
3], 13:[2, 3], 16:[2, 3], 24:[2, 3], 26:[2, 3], 28:[2, 3], 29:[2, 3], 31:[2, 3], 32:[2, 3], 34:[2, 3]}, {5:[2, 4], 12:[2, 4], 13:[2, 4], 16:[2, 4], 24:[2, 4], 26:[2, 4], 28:[2, 4], 29:[2, 4], 31:[2, 4], 32:[2, 4], 34:[2, 4]}, {5:[2, 5], 12:[2, 5], 13:[2, 5], 16:[2, 5], 24:[2, 5], 26:[2, 5], 28:[2, 5], 29:[2, 5], 31:[2, 5], 32:[2, 5], 34:[2, 5]}, {5:[2, 6], 12:[2, 6], 13:[2, 6], 16:[2, 6], 24:[2, 6], 26:[2, 6], 28:[2, 6], 29:[2, 6], 31:[2, 6], 32:[2, 6], 34:[2, 6]}, {5:[2, 7], 12:[2, 7], 13:[2,
7], 16:[2, 7], 24:[2, 7], 26:[2, 7], 28:[2, 7], 29:[2, 7], 31:[2, 7], 32:[2, 7], 34:[2, 7]}, {5:[2, 8], 12:[2, 8], 13:[2, 8], 16:[2, 8], 24:[2, 8], 26:[2, 8], 28:[2, 8], 29:[2, 8], 31:[2, 8], 32:[2, 8], 34:[2, 8]}, {17:21, 30:22, 41:23, 50:[1, 26], 52:[1, 25], 53:24}, {17:27, 30:22, 41:23, 50:[1, 26], 52:[1, 25], 53:24}, {4:28, 6:3, 12:[2, 38], 13:[2, 38], 16:[2, 38], 24:[2, 38], 26:[2, 38], 28:[2, 38], 29:[2, 38], 31:[2, 38], 32:[2, 38], 34:[2, 38]}, {4:29, 6:3, 12:[2, 38], 13:[2, 38], 16:[2,
38], 24:[2, 38], 26:[2, 38], 28:[2, 38], 29:[2, 38], 31:[2, 38], 32:[2, 38], 34:[2, 38]}, {12:[1, 30]}, {30:32, 35:31, 42:[1, 33], 43:[1, 34], 50:[1, 26], 53:24}, {17:35, 30:22, 41:23, 50:[1, 26], 52:[1, 25], 53:24}, {17:36, 30:22, 41:23, 50:[1, 26], 52:[1, 25], 53:24}, {17:37, 30:22, 41:23, 50:[1, 26], 52:[1, 25], 53:24}, {25:[1, 38]}, {18:[2, 48], 25:[2, 48], 33:[2, 48], 39:39, 42:[2, 48], 43:[2, 48], 44:[2, 48], 45:[2, 48], 46:[2, 48], 50:[2, 48], 52:[2, 48]}, {18:[2, 22], 25:[2, 22], 33:[2,
22], 46:[2, 22]}, {18:[2, 35], 25:[2, 35], 33:[2, 35], 42:[2, 35], 43:[2, 35], 44:[2, 35], 45:[2, 35], 46:[2, 35], 50:[2, 35], 52:[2, 35], 54:[1, 40]}, {30:41, 50:[1, 26], 53:24}, {18:[2, 37], 25:[2, 37], 33:[2, 37], 42:[2, 37], 43:[2, 37], 44:[2, 37], 45:[2, 37], 46:[2, 37], 50:[2, 37], 52:[2, 37], 54:[2, 37]}, {33:[1, 42]}, {20:43, 27:44, 28:[1, 45], 29:[2, 40]}, {23:46, 27:47, 28:[1, 45], 29:[2, 42]}, {15:[1, 48]}, {25:[2, 46], 30:51, 36:49, 38:50, 41:55, 42:[1, 52], 43:[1, 53], 44:[1, 54],
45:[1, 56], 47:57, 48:58, 49:60, 50:[1, 59], 52:[1, 25], 53:24}, {25:[2, 31], 42:[2, 31], 43:[2, 31], 44:[2, 31], 45:[2, 31], 50:[2, 31], 52:[2, 31]}, {25:[2, 32], 42:[2, 32], 43:[2, 32], 44:[2, 32], 45:[2, 32], 50:[2, 32], 52:[2, 32]}, {25:[2, 33], 42:[2, 33], 43:[2, 33], 44:[2, 33], 45:[2, 33], 50:[2, 33], 52:[2, 33]}, {25:[1, 61]}, {25:[1, 62]}, {18:[1, 63]}, {5:[2, 17], 12:[2, 17], 13:[2, 17], 16:[2, 17], 24:[2, 17], 26:[2, 17], 28:[2, 17], 29:[2, 17], 31:[2, 17], 32:[2, 17], 34:[2, 17]},
{18:[2, 50], 25:[2, 50], 30:51, 33:[2, 50], 36:65, 40:64, 41:55, 42:[1, 52], 43:[1, 53], 44:[1, 54], 45:[1, 56], 46:[2, 50], 47:66, 48:58, 49:60, 50:[1, 59], 52:[1, 25], 53:24}, {50:[1, 67]}, {18:[2, 34], 25:[2, 34], 33:[2, 34], 42:[2, 34], 43:[2, 34], 44:[2, 34], 45:[2, 34], 46:[2, 34], 50:[2, 34], 52:[2, 34]}, {5:[2, 18], 12:[2, 18], 13:[2, 18], 16:[2, 18], 24:[2, 18], 26:[2, 18], 28:[2, 18], 29:[2, 18], 31:[2, 18], 32:[2, 18], 34:[2, 18]}, {21:68, 29:[1, 69]}, {29:[2, 41]}, {4:70, 6:3, 12:[2,
38], 13:[2, 38], 16:[2, 38], 24:[2, 38], 26:[2, 38], 29:[2, 38], 31:[2, 38], 32:[2, 38], 34:[2, 38]}, {21:71, 29:[1, 69]}, {29:[2, 43]}, {5:[2, 9], 12:[2, 9], 13:[2, 9], 16:[2, 9], 24:[2, 9], 26:[2, 9], 28:[2, 9], 29:[2, 9], 31:[2, 9], 32:[2, 9], 34:[2, 9]}, {25:[2, 44], 37:72, 47:73, 48:58, 49:60, 50:[1, 74]}, {25:[1, 75]}, {18:[2, 23], 25:[2, 23], 33:[2, 23], 42:[2, 23], 43:[2, 23], 44:[2, 23], 45:[2, 23], 46:[2, 23], 50:[2, 23], 52:[2, 23]}, {18:[2, 24], 25:[2, 24], 33:[2, 24], 42:[2, 24],
43:[2, 24], 44:[2, 24], 45:[2, 24], 46:[2, 24], 50:[2, 24], 52:[2, 24]}, {18:[2, 25], 25:[2, 25], 33:[2, 25], 42:[2, 25], 43:[2, 25], 44:[2, 25], 45:[2, 25], 46:[2, 25], 50:[2, 25], 52:[2, 25]}, {18:[2, 26], 25:[2, 26], 33:[2, 26], 42:[2, 26], 43:[2, 26], 44:[2, 26], 45:[2, 26], 46:[2, 26], 50:[2, 26], 52:[2, 26]}, {18:[2, 27], 25:[2, 27], 33:[2, 27], 42:[2, 27], 43:[2, 27], 44:[2, 27], 45:[2, 27], 46:[2, 27], 50:[2, 27], 52:[2, 27]}, {17:76, 30:22, 41:23, 50:[1, 26], 52:[1, 25], 53:24}, {25:[2,
47]}, {18:[2, 29], 25:[2, 29], 33:[2, 29], 46:[2, 29], 49:77, 50:[1, 74]}, {18:[2, 37], 25:[2, 37], 33:[2, 37], 42:[2, 37], 43:[2, 37], 44:[2, 37], 45:[2, 37], 46:[2, 37], 50:[2, 37], 51:[1, 78], 52:[2, 37], 54:[2, 37]}, {18:[2, 52], 25:[2, 52], 33:[2, 52], 46:[2, 52], 50:[2, 52]}, {12:[2, 13], 13:[2, 13], 16:[2, 13], 24:[2, 13], 26:[2, 13], 28:[2, 13], 29:[2, 13], 31:[2, 13], 32:[2, 13], 34:[2, 13]}, {12:[2, 14], 13:[2, 14], 16:[2, 14], 24:[2, 14], 26:[2, 14], 28:[2, 14], 29:[2, 14], 31:[2,
14], 32:[2, 14], 34:[2, 14]}, {12:[2, 10]}, {18:[2, 21], 25:[2, 21], 33:[2, 21], 46:[2, 21]}, {18:[2, 49], 25:[2, 49], 33:[2, 49], 42:[2, 49], 43:[2, 49], 44:[2, 49], 45:[2, 49], 46:[2, 49], 50:[2, 49], 52:[2, 49]}, {18:[2, 51], 25:[2, 51], 33:[2, 51], 46:[2, 51]}, {18:[2, 36], 25:[2, 36], 33:[2, 36], 42:[2, 36], 43:[2, 36], 44:[2, 36], 45:[2, 36], 46:[2, 36], 50:[2, 36], 52:[2, 36], 54:[2, 36]}, {5:[2, 11], 12:[2, 11], 13:[2, 11], 16:[2, 11], 24:[2, 11], 26:[2, 11], 28:[2, 11], 29:[2, 11],
31:[2, 11], 32:[2, 11], 34:[2, 11]}, {30:79, 50:[1, 26], 53:24}, {29:[2, 15]}, {5:[2, 12], 12:[2, 12], 13:[2, 12], 16:[2, 12], 24:[2, 12], 26:[2, 12], 28:[2, 12], 29:[2, 12], 31:[2, 12], 32:[2, 12], 34:[2, 12]}, {25:[1, 80]}, {25:[2, 45]}, {51:[1, 78]}, {5:[2, 20], 12:[2, 20], 13:[2, 20], 16:[2, 20], 24:[2, 20], 26:[2, 20], 28:[2, 20], 29:[2, 20], 31:[2, 20], 32:[2, 20], 34:[2, 20]}, {46:[1, 81]}, {18:[2, 53], 25:[2, 53], 33:[2, 53], 46:[2, 53], 50:[2, 53]}, {30:51, 36:82, 41:55, 42:[1, 52],
43:[1, 53], 44:[1, 54], 45:[1, 56], 50:[1, 26], 52:[1, 25], 53:24}, {25:[1, 83]}, {5:[2, 19], 12:[2, 19], 13:[2, 19], 16:[2, 19], 24:[2, 19], 26:[2, 19], 28:[2, 19], 29:[2, 19], 31:[2, 19], 32:[2, 19], 34:[2, 19]}, {18:[2, 28], 25:[2, 28], 33:[2, 28], 42:[2, 28], 43:[2, 28], 44:[2, 28], 45:[2, 28], 46:[2, 28], 50:[2, 28], 52:[2, 28]}, {18:[2, 30], 25:[2, 30], 33:[2, 30], 46:[2, 30], 50:[2, 30]}, {5:[2, 16], 12:[2, 16], 13:[2, 16], 16:[2, 16], 24:[2, 16], 26:[2, 16], 28:[2, 16], 29:[2, 16],
31:[2, 16], 32:[2, 16], 34:[2, 16]}], defaultActions:{4:[2, 1], 44:[2, 41], 47:[2, 43], 57:[2, 47], 63:[2, 10], 70:[2, 15], 73:[2, 45]}, parseError:function parseError(str, hash) {
throw new Error(str);
}, parse:function parse(input) {
var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
this.lexer.setInput(input);
this.lexer.yy = this.yy;
this.yy.lexer = this.lexer;
this.yy.parser = this;
if (typeof this.lexer.yylloc == "undefined") {
this.lexer.yylloc = {};
}
var yyloc = this.lexer.yylloc;
lstack.push(yyloc);
var ranges = this.lexer.options && this.lexer.options.ranges;
if (typeof this.yy.parseError === "function") {
this.parseError = this.yy.parseError;
}
function popStack(n) {
stack.length = stack.length - 2 * n;
vstack.length = vstack.length - n;
lstack.length = lstack.length - n;
}
function lex() {
var token;
token = self.lexer.lex() || 1;
if (typeof token !== "number") {
token = self.symbols_[token] || token;
}
return token;
}
var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
while (true) {
state = stack[stack.length - 1];
if (this.defaultActions[state]) {
action = this.defaultActions[state];
} else {
if (symbol === null || typeof symbol == "undefined") {
symbol = lex();
}
action = table[state] && table[state][symbol];
}
if (typeof action === "undefined" || (!action.length || !action[0])) {
var errStr = "";
if (!recovering) {
expected = [];
for (p in table[state]) {
if (this.terminals_[p] && p > 2) {
expected.push("'" + this.terminals_[p] + "'");
}
}
if (this.lexer.showPosition) {
errStr = "Parse error on line " + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'";
} else {
errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == 1 ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'");
}
this.parseError(errStr, {text:this.lexer.match, token:this.terminals_[symbol] || symbol, line:this.lexer.yylineno, loc:yyloc, expected:expected});
}
}
if (action[0] instanceof Array && action.length > 1) {
throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol);
}
switch(action[0]) {
case 1:
stack.push(symbol);
vstack.push(this.lexer.yytext);
lstack.push(this.lexer.yylloc);
stack.push(action[1]);
symbol = null;
if (!preErrorSymbol) {
yyleng = this.lexer.yyleng;
yytext = this.lexer.yytext;
yylineno = this.lexer.yylineno;
yyloc = this.lexer.yylloc;
if (recovering > 0) {
recovering--;
}
} else {
symbol = preErrorSymbol;
preErrorSymbol = null;
}
break;
case 2:
len = this.productions_[action[1]][1];
yyval.$ = vstack[vstack.length - len];
yyval._$ = {first_line:lstack[lstack.length - (len || 1)].first_line, last_line:lstack[lstack.length - 1].last_line, first_column:lstack[lstack.length - (len || 1)].first_column, last_column:lstack[lstack.length - 1].last_column};
if (ranges) {
yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
}
r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack);
if (typeof r !== "undefined") {
return r;
}
if (len) {
stack = stack.slice(0, -1 * len * 2);
vstack = vstack.slice(0, -1 * len);
lstack = lstack.slice(0, -1 * len);
}
stack.push(this.productions_[action[1]][0]);
vstack.push(yyval.$);
lstack.push(yyval._$);
newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
stack.push(newState);
break;
case 3:
return true;
}
}
return true;
}};
var lexer = function() {
var lexer = {EOF:1, parseError:function parseError(str, hash) {
if (this.yy.parser) {
this.yy.parser.parseError(str, hash);
} else {
throw new Error(str);
}
}, setInput:function(input) {
this._input = input;
this._more = this._less = this.done = false;
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};
if (this.options.ranges) {
this.yylloc.range = [0, 0];
}
this.offset = 0;
return this;
}, input:function() {
var ch = this._input[0];
this.yytext += ch;
this.yyleng++;
this.offset++;
this.match += ch;
this.matched += ch;
var lines = ch.match(/(?:\r\n?|\n).*/g);
if (lines) {
this.yylineno++;
this.yylloc.last_line++;
} else {
this.yylloc.last_column++;
}
if (this.options.ranges) {
this.yylloc.range[1]++;
}
this._input = this._input.slice(1);
return ch;
}, unput:function(ch) {
var len = ch.length;
var lines = ch.split(/(?:\r\n?|\n)/g);
this._input = ch + this._input;
this.yytext = this.yytext.substr(0, this.yytext.length - len - 1);
this.offset -= len;
var oldLines = 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);
if (lines.length - 1) {
this.yylineno -= lines.length - 1;
}
var r = this.yylloc.range;
this.yylloc = {first_line:this.yylloc.first_line, last_line:this.yylineno + 1, first_column:this.yylloc.first_column, last_column:lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len};
if (this.options.ranges) {
this.yylloc.range = [r[0], r[0] + this.yyleng - len];
}
return this;
}, more:function() {
this._more = true;
return this;
}, less:function(n) {
this.unput(this.match.slice(n));
}, pastInput:function() {
var past = this.matched.substr(0, this.matched.length - this.match.length);
return(past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, "");
}, upcomingInput:function() {
var next = this.match;
if (next.length < 20) {
next += this._input.substr(0, 20 - next.length);
}
return(next.substr(0, 20) + (next.length > 20 ? "..." : "")).replace(/\n/g, "");
}, showPosition:function() {
var pre = this.pastInput();
var c = (new Array(pre.length + 1)).join("-");
return pre + this.upcomingInput() + "\n" + c + "^";
}, next:function() {
if (this.done) {
return this.EOF;
}
if (!this._input) {
this.done = true;
}
var token, match, tempMatch, index, col, lines;
if (!this._more) {
this.yytext = "";
this.match = "";
}
var rules = this._currentRules();
for (var i = 0;i < rules.length;i++) {
tempMatch = this._input.match(this.rules[rules[i]]);
if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
match = tempMatch;
index = i;
if (!this.options.flex) {
break;
}
}
}
if (match) {
lines = match[0].match(/(?:\r\n?|\n).*/g);
if (lines) {
this.yylineno += lines.length;
}
this.yylloc = {first_line:this.yylloc.last_line, last_line:this.yylineno + 1, first_column:this.yylloc.last_column, last_column:lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length};
this.yytext += match[0];
this.match += match[0];
this.matches = match;
this.yyleng = this.yytext.length;
if (this.options.ranges) {
this.yylloc.range = [this.offset, this.offset += this.yyleng];
}
this._more = false;
this._input = this._input.slice(match[0].length);
this.matched += match[0];
token = this.performAction.call(this, this.yy, this, rules[index], this.conditionStack[this.conditionStack.length - 1]);
if (this.done && this._input) {
this.done = false;
}
if (token) {
return token;
} else {
return;
}
}
if (this._input === "") {
return this.EOF;
} else {
return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), {text:"", token:null, line:this.yylineno});
}
}, lex:function lex() {
var r = this.next();
if (typeof r !== "undefined") {
return r;
} else {
return this.lex();
}
}, begin:function begin(condition) {
this.conditionStack.push(condition);
}, popState:function popState() {
return this.conditionStack.pop();
}, _currentRules:function _currentRules() {
return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
}, topState:function() {
return this.conditionStack[this.conditionStack.length - 2];
}, pushState:function begin(condition) {
this.begin(condition);
}};
lexer.options = {};
lexer.performAction = function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
function strip(start, end) {
return yy_.yytext = yy_.yytext.substr(start, yy_.yyleng - end);
}
var YYSTATE = YY_START;
switch($avoiding_name_collisions) {
case 0:
if (yy_.yytext.slice(-2) === "\\\\") {
strip(0, 1);
this.begin("mu");
} else {
if (yy_.yytext.slice(-1) === "\\") {
strip(0, 1);
this.begin("emu");
} else {
this.begin("mu");
}
}
if (yy_.yytext) {
return 12;
}
break;
case 1:
return 12;
break;
case 2:
this.popState();
return 12;
break;
case 3:
yy_.yytext = yy_.yytext.substr(5, yy_.yyleng - 9);
this.popState();
return 15;
break;
case 4:
return 12;
break;
case 5:
strip(0, 4);
this.popState();
return 13;
break;
case 6:
return 45;
break;
case 7:
return 46;
break;
case 8:
return 16;
break;
case 9:
this.popState();
this.begin("raw");
return 18;
break;
case 10:
return 34;
break;
case 11:
return 24;
break;
case 12:
return 29;
break;
case 13:
this.popState();
return 28;
break;
case 14:
this.popState();
return 28;
break;
case 15:
return 26;
break;
case 16:
return 26;
break;
case 17:
return 32;
break;
case 18:
return 31;
break;
case 19:
this.popState();
this.begin("com");
break;
case 20:
strip(3, 5);
this.popState();
return 13;
break;
case 21:
return 31;
break;
case 22:
return 51;
break;
case 23:
return 50;
break;
case 24:
return 50;
break;
case 25:
return 54;
break;
case 26:
break;
case 27:
this.popState();
return 33;
break;
case 28:
this.popState();
return 25;
break;
case 29:
yy_.yytext = strip(1, 2).replace(/\\"/g, '"');
return 42;
break;
case 30:
yy_.yytext = strip(1, 2).replace(/\\'/g, "'");
return 42;
break;
case 31:
return 52;
break;
case 32:
return 44;
break;
case 33:
return 44;
break;
case 34:
return 43;
break;
case 35:
return 50;
break;
case 36:
yy_.yytext = strip(1, 2);
return 50;
break;
case 37:
return "INVALID";
break;
case 38:
return 5;
break;
}
};
lexer.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)])))/, /^(?:([^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=([=~}\s\/.)]))))/, /^(?:\[[^\]]*\])/, /^(?:.)/, /^(?:$)/];
lexer.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], "inclusive":false}, "emu":{"rules":[2], "inclusive":false}, "com":{"rules":[5], "inclusive":false}, "raw":{"rules":[3, 4], "inclusive":false}, "INITIAL":{"rules":[0, 1, 38], "inclusive":true}};
return lexer;
}();
parser.lexer = lexer;
function Parser() {
this.yy = {};
}
Parser.prototype = parser;
parser.Parser = Parser;
return new Parser;
}();
__exports__ = handlebars;
return __exports__;
}();
var __module10__ = function(__dependency1__) {
var __exports__ = {};
var Exception = __dependency1__;
function stripFlags(open, close) {
return{left:open.charAt(2) === "~", right:close.charAt(close.length - 3) === "~"};
}
__exports__.stripFlags = stripFlags;
function prepareBlock(mustache, program, inverseAndProgram, close, inverted, locInfo) {
if (mustache.sexpr.id.original !== close.path.original) {
throw new Exception(mustache.sexpr.id.original + " doesn't match " + close.path.original, mustache);
}
var inverse = inverseAndProgram && inverseAndProgram.program;
var strip = {left:mustache.strip.left, right:close.strip.right, openStandalone:isNextWhitespace(program.statements), closeStandalone:isPrevWhitespace((inverse || program).statements)};
if (mustache.strip.right) {
omitRight(program.statements, null, true);
}
if (inverse) {
var inverseStrip = inverseAndProgram.strip;
if (inverseStrip.left) {
omitLeft(program.statements, null, true);
}
if (inverseStrip.right) {
omitRight(inverse.statements, null, true);
}
if (close.strip.left) {
omitLeft(inverse.statements, null, true);
}
if (isPrevWhitespace(program.statements) && isNextWhitespace(inverse.statements)) {
omitLeft(program.statements);
omitRight(inverse.statements);
}
} else {
if (close.strip.left) {
omitLeft(program.statements, null, true);
}
}
if (inverted) {
return new this.BlockNode(mustache, inverse, program, strip, locInfo);
} else {
return new this.BlockNode(mustache, program, inverse, strip, locInfo);
}
}
__exports__.prepareBlock = prepareBlock;
function prepareProgram(statements, isRoot) {
for (var i = 0, l = statements.length;i < l;i++) {
var current = statements[i], strip = current.strip;
if (!strip) {
continue;
}
var _isPrevWhitespace = isPrevWhitespace(statements, i, isRoot, current.type === "partial"), _isNextWhitespace = isNextWhitespace(statements, i, isRoot), openStandalone = strip.openStandalone && _isPrevWhitespace, closeStandalone = strip.closeStandalone && _isNextWhitespace, inlineStandalone = strip.inlineStandalone && (_isPrevWhitespace && _isNextWhitespace);
if (strip.right) {
omitRight(statements, i, true);
}
if (strip.left) {
omitLeft(statements, i, true);
}
if (inlineStandalone) {
omitRight(statements, i);
if (omitLeft(statements, i)) {
if (current.type === "partial") {
current.indent = /([ \t]+$)/.exec(statements[i - 1].original) ? RegExp.$1 : "";
}
}
}
if (openStandalone) {
omitRight((current.program || current.inverse).statements);
omitLeft(statements, i);
}
if (closeStandalone) {
omitRight(statements, i);
omitLeft((current.inverse || current.program).statements);
}
}
return statements;
}
__exports__.prepareProgram = prepareProgram;
function isPrevWhitespace(statements, i, isRoot) {
if (i === undefined) {
i = statements.length;
}
var prev = statements[i - 1], sibling = statements[i - 2];
if (!prev) {
return isRoot;
}
if (prev.type === "content") {
return(sibling || !isRoot ? /\r?\n\s*?$/ : /(^|\r?\n)\s*?$/).test(prev.original);
}
}
function isNextWhitespace(statements, i, isRoot) {
if (i === undefined) {
i = -1;
}
var next = statements[i + 1], sibling = statements[i + 2];
if (!next) {
return isRoot;
}
if (next.type === "content") {
return(sibling || !isRoot ? /^\s*?\r?\n/ : /^\s*?(\r?\n|$)/).test(next.original);
}
}
function omitRight(statements, i, multiple) {
var current = statements[i == null ? 0 : i + 1];
if (!current || (current.type !== "content" || !multiple && current.rightStripped)) {
return;
}
var original = current.string;
current.string = current.string.replace(multiple ? /^\s+/ : /^[ \t]*\r?\n?/, "");
current.rightStripped = current.string !== original;
}
function omitLeft(statements, i, multiple) {
var current = statements[i == null ? statements.length - 1 : i - 1];
if (!current || (current.type !== "content" || !multiple && current.leftStripped)) {
return;
}
var original = current.string;
current.string = current.string.replace(multiple ? /\s+$/ : /[ \t]+$/, "");
current.leftStripped = current.string !== original;
return current.leftStripped;
}
return __exports__;
}(__module5__);
var __module8__ = function(__dependency1__, __dependency2__, __dependency3__, __dependency4__) {
var __exports__ = {};
var parser = __dependency1__;
var AST = __dependency2__;
var Helpers = __dependency3__;
var extend = __dependency4__.extend;
__exports__.parser = parser;
var yy = {};
extend(yy, Helpers, AST);
function parse(input) {
if (input.constructor === AST.ProgramNode) {
return input;
}
parser.yy = yy;
return parser.parse(input);
}
__exports__.parse = parse;
return __exports__;
}(__module9__, __module7__, __module10__, __module3__);
var __module11__ = function(__dependency1__, __dependency2__) {
var __exports__ = {};
var Exception = __dependency1__;
var isArray = __dependency2__.isArray;
var slice = [].slice;
function Compiler() {
}
__exports__.Compiler = Compiler;
Compiler.prototype = {compiler:Compiler, equals:function(other) {
var len = this.opcodes.length;
if (other.opcodes.length !== len) {
return false;
}
for (var i = 0;i < len;i++) {
var opcode = this.opcodes[i], otherOpcode = other.opcodes[i];
if (opcode.opcode !== otherOpcode.opcode || !argEquals(opcode.args, otherOpcode.args)) {
return false;
}
}
len = this.children.length;
for (i = 0;i < len;i++) {
if (!this.children[i].equals(other.children[i])) {
return false;
}
}
return true;
}, guid:0, compile:function(program, options) {
this.opcodes = [];
this.children = [];
this.depths = {list:[]};
this.options = options;
this.stringParams = options.stringParams;
this.trackIds = options.trackIds;
var knownHelpers = this.options.knownHelpers;
this.options.knownHelpers = {"helperMissing":true, "blockHelperMissing":true, "each":true, "if":true, "unless":true, "with":true, "log":true, "lookup":true};
if (knownHelpers) {
for (var name in knownHelpers) {
this.options.knownHelpers[name] = knownHelpers[name];
}
}
return this.accept(program);
}, accept:function(node) {
return this[node.type](node);
}, program:function(program) {
var statements = program.statements;
for (var i = 0, l = statements.length;i < l;i++) {
this.accept(statements[i]);
}
this.isSimple = l === 1;
this.depths.list = this.depths.list.sort(function(a, b) {
return a - b;
});
return this;
}, compileProgram:function(program) {
var result = (new this.compiler).compile(program, this.options);
var guid = this.guid++, depth;
this.usePartial = this.usePartial || result.usePartial;
this.children[guid] = result;
for (var i = 0, l = result.depths.list.length;i < l;i++) {
depth = result.depths.list[i];
if (depth < 2) {
continue;
} else {
this.addDepth(depth - 1);
}
}
return guid;
}, block:function(block) {
var mustache = block.mustache, program = block.program, inverse = block.inverse;
if (program) {
program = this.compileProgram(program);
}
if (inverse) {
inverse = this.compileProgram(inverse);
}
var sexpr = mustache.sexpr;
var type = this.classifySexpr(sexpr);
if (type === "helper") {
this.helperSexpr(sexpr, program, inverse);
} else {
if (type === "simple") {
this.simpleSexpr(sexpr);
this.opcode("pushProgram", program);
this.opcode("pushProgram", inverse);
this.opcode("emptyHash");
this.opcode("blockValue", sexpr.id.original);
} else {
this.ambiguousSexpr(sexpr, program, inverse);
this.opcode("pushProgram", program);
this.opcode("pushProgram", inverse);
this.opcode("emptyHash");
this.opcode("ambiguousBlockValue");
}
}
this.opcode("append");
}, hash:function(hash) {
var pairs = hash.pairs, i, l;
this.opcode("pushHash");
for (i = 0, l = pairs.length;i < l;i++) {
this.pushParam(pairs[i][1]);
}
while (i--) {
this.opcode("assignToHash", pairs[i][0]);
}
this.opcode("popHash");
}, partial:function(partial) {
var partialName = partial.partialName;
this.usePartial = true;
if (partial.hash) {
this.accept(partial.hash);
} else {
this.opcode("push", "undefined");
}
if (partial.context) {
this.accept(partial.context);
} else {
this.opcode("getContext", 0);
this.opcode("pushContext");
}
this.opcode("invokePartial", partialName.name, partial.indent || "");
this.opcode("append");
}, content:function(content) {
if (content.string) {
this.opcode("appendContent", content.string);
}
}, mustache:function(mustache) {
this.sexpr(mustache.sexpr);
if (mustache.escaped && !this.options.noEscape) {
this.opcode("appendEscaped");
} else {
this.opcode("append");
}
}, ambiguousSexpr:function(sexpr, program, inverse) {
var id = sexpr.id, name = id.parts[0], isBlock = program != null || inverse != null;
this.opcode("getContext", id.depth);
this.opcode("pushProgram", program);
this.opcode("pushProgram", inverse);
this.ID(id);
this.opcode("invokeAmbiguous", name, isBlock);
}, simpleSexpr:function(sexpr) {
var id = sexpr.id;
if (id.type === "DATA") {
this.DATA(id);
} else {
if (id.parts.length) {
this.ID(id);
} else {
this.addDepth(id.depth);
this.opcode("getContext", id.depth);
this.opcode("pushContext");
}
}
this.opcode("resolvePossibleLambda");
}, helperSexpr:function(sexpr, program, inverse) {
var params = this.setupFullMustacheParams(sexpr, program, inverse), id = sexpr.id, name = id.parts[0];
if (this.options.knownHelpers[name]) {
this.opcode("invokeKnownHelper", params.length, name);
} else {
if (this.options.knownHelpersOnly) {
throw new Exception("You specified knownHelpersOnly, but used the unknown helper " + name, sexpr);
} else {
id.falsy = true;
this.ID(id);
this.opcode("invokeHelper", params.length, id.original, id.isSimple);
}
}
}, sexpr:function(sexpr) {
var type = this.classifySexpr(sexpr);
if (type === "simple") {
this.simpleSexpr(sexpr);
} else {
if (type === "helper") {
this.helperSexpr(sexpr);
} else {
this.ambiguousSexpr(sexpr);
}
}
}, ID:function(id) {
this.addDepth(id.depth);
this.opcode("getContext", id.depth);
var name = id.parts[0];
if (!name) {
this.opcode("pushContext");
} else {
this.opcode("lookupOnContext", id.parts, id.falsy, id.isScoped);
}
}, DATA:function(data) {
this.options.data = true;
this.opcode("lookupData", data.id.depth, data.id.parts);
}, STRING:function(string) {
this.opcode("pushString", string.string);
}, NUMBER:function(number) {
this.opcode("pushLiteral", number.number);
}, BOOLEAN:function(bool) {
this.opcode("pushLiteral", bool.bool);
}, comment:function() {
}, opcode:function(name) {
this.opcodes.push({opcode:name, args:slice.call(arguments, 1)});
}, addDepth:function(depth) {
if (depth === 0) {
return;
}
if (!this.depths[depth]) {
this.depths[depth] = true;
this.depths.list.push(depth);
}
}, classifySexpr:function(sexpr) {
var isHelper = sexpr.isHelper;
var isEligible = sexpr.eligibleHelper;
var options = this.options;
if (isEligible && !isHelper) {
var name = sexpr.id.parts[0];
if (options.knownHelpers[name]) {
isHelper = true;
} else {
if (options.knownHelpersOnly) {
isEligible = false;
}
}
}
if (isHelper) {
return "helper";
} else {
if (isEligible) {
return "ambiguous";
} else {
return "simple";
}
}
}, pushParams:function(params) {
for (var i = 0, l = params.length;i < l;i++) {
this.pushParam(params[i]);
}
}, pushParam:function(val) {
if (this.stringParams) {
if (val.depth) {
this.addDepth(val.depth);
}
this.opcode("getContext", val.depth || 0);
this.opcode("pushStringParam", val.stringModeValue, val.type);
if (val.type === "sexpr") {
this.sexpr(val);
}
} else {
if (this.trackIds) {
this.opcode("pushId", val.type, val.idName || val.stringModeValue);
}
this.accept(val);
}
}, setupFullMustacheParams:function(sexpr, program, inverse) {
var params = sexpr.params;
this.pushParams(params);
this.opcode("pushProgram", program);
this.opcode("pushProgram", inverse);
if (sexpr.hash) {
this.hash(sexpr.hash);
} else {
this.opcode("emptyHash");
}
return params;
}};
function precompile(input, options, env) {
if (input == null || typeof input !== "string" && input.constructor !== env.AST.ProgramNode) {
throw new Exception("You must pass a string or Handlebars AST to Handlebars.precompile. You passed " + input);
}
options = options || {};
if (!("data" in options)) {
options.data = true;
}
if (options.compat) {
options.useDepths = true;
}
var ast = env.parse(input);
var environment = (new env.Compiler).compile(ast, options);
return(new env.JavaScriptCompiler).compile(environment, options);
}
__exports__.precompile = precompile;
function compile(input, options, env) {
if (input == null || typeof input !== "string" && input.constructor !== env.AST.ProgramNode) {
throw new Exception("You must pass a string or Handlebars AST to Handlebars.compile. You passed " + input);
}
options = options || {};
if (!("data" in options)) {
options.data = true;
}
if (options.compat) {
options.useDepths = true;
}
var compiled;
function compileInput() {
var ast = env.parse(input);
var environment = (new env.Compiler).compile(ast, options);
var templateSpec = (new env.JavaScriptCompiler).compile(environment, options, undefined, true);
return env.template(templateSpec);
}
var ret = function(context, options) {
if (!compiled) {
compiled = compileInput();
}
return compiled.call(this, context, options);
};
ret._setup = function(options) {
if (!compiled) {
compiled = compileInput();
}
return compiled._setup(options);
};
ret._child = function(i, data, depths) {
if (!compiled) {
compiled = compileInput();
}
return compiled._child(i, data, depths);
};
return ret;
}
__exports__.compile = compile;
function argEquals(a, b) {
if (a === b) {
return true;
}
if (isArray(a) && (isArray(b) && a.length === b.length)) {
for (var i = 0;i < a.length;i++) {
if (!argEquals(a[i], b[i])) {
return false;
}
}
return true;
}
}
return __exports__;
}(__module5__, __module3__);
var __module12__ = function(__dependency1__, __dependency2__) {
var __exports__;
var COMPILER_REVISION = __dependency1__.COMPILER_REVISION;
var REVISION_CHANGES = __dependency1__.REVISION_CHANGES;
var Exception = __dependency2__;
function Literal(value) {
this.value = value;
}
function JavaScriptCompiler() {
}
JavaScriptCompiler.prototype = {nameLookup:function(parent, name) {
if (JavaScriptCompiler.isValidJavaScriptVariableName(name)) {
return parent + "." + name;
} else {
return parent + "['" + name + "']";
}
}, depthedLookup:function(name) {
this.aliases.lookup = "this.lookup";
return'lookup(depths, "' + name + '")';
}, compilerInfo:function() {
var revision = COMPILER_REVISION, versions = REVISION_CHANGES[revision];
return[revision, versions];
}, appendToBuffer:function(string) {
if (this.environment.isSimple) {
return "return " + string + ";";
} else {
return{appendToBuffer:true, content:string, toString:function() {
return "buffer += " + string + ";";
}};
}
}, initializeBuffer:function() {
return this.quotedString("");
}, namespace:"Handlebars", compile:function(environment, options, context, asObject) {
this.environment = environment;
this.options = options;
this.stringParams = this.options.stringParams;
this.trackIds = this.options.trackIds;
this.precompile = !asObject;
this.name = this.environment.name;
this.isChild = !!context;
this.context = context || {programs:[], environments:[]};
this.preamble();
this.stackSlot = 0;
this.stackVars = [];
this.aliases = {};
this.registers = {list:[]};
this.hashes = [];
this.compileStack = [];
this.inlineStack = [];
this.compileChildren(environment, options);
this.useDepths = this.useDepths || (environment.depths.list.length || this.options.compat);
var opcodes = environment.opcodes, opcode, i, l;
for (i = 0, l = opcodes.length;i < l;i++) {
opcode = opcodes[i];
this[opcode.opcode].apply(this, opcode.args);
}
this.pushSource("");
if (this.stackSlot || (this.inlineStack.length || this.compileStack.length)) {
throw new Exception("Compile completed with content left on stack");
}
var fn = this.createFunctionContext(asObject);
if (!this.isChild) {
var ret = {compiler:this.compilerInfo(), main:fn};
var programs = this.context.programs;
for (i = 0, l = programs.length;i < l;i++) {
if (programs[i]) {
ret[i] = programs[i];
}
}
if (this.environment.usePartial) {
ret.usePartial = true;
}
if (this.options.data) {
ret.useData = true;
}
if (this.useDepths) {
ret.useDepths = true;
}
if (this.options.compat) {
ret.compat = true;
}
if (!asObject) {
ret.compiler = JSON.stringify(ret.compiler);
ret = this.objectLiteral(ret);
}
return ret;
} else {
return fn;
}
}, preamble:function() {
this.lastContext = 0;
this.source = [];
}, createFunctionContext:function(asObject) {
var varDeclarations = "";
var locals = this.stackVars.concat(this.registers.list);
if (locals.length > 0) {
varDeclarations += ", " + locals.join(", ");
}
for (var alias in this.aliases) {
if (this.aliases.hasOwnProperty(alias)) {
varDeclarations += ", " + alias + "=" + this.aliases[alias];
}
}
var params = ["depth0", "helpers", "partials", "data"];
if (this.useDepths) {
params.push("depths");
}
var source = this.mergeSource(varDeclarations);
if (asObject) {
params.push(source);
return Function.apply(this, params);
} else {
return "function(" + params.join(",") + ") {\n " + source + "}";
}
}, mergeSource:function(varDeclarations) {
var source = "", buffer, appendOnly = !this.forceBuffer, appendFirst;
for (var i = 0, len = this.source.length;i < len;i++) {
var line = this.source[i];
if (line.appendToBuffer) {
if (buffer) {
buffer = buffer + "\n + " + line.content;
} else {
buffer = line.content;
}
} else {
if (buffer) {
if (!source) {
appendFirst = true;
source = buffer + ";\n ";
} else {
source += "buffer += " + buffer + ";\n ";
}
buffer = undefined;
}
source += line + "\n ";
if (!this.environment.isSimple) {
appendOnly = false;
}
}
}
if (appendOnly) {
if (buffer || !source) {
source += "return " + (buffer || '""') + ";\n";
}
} else {
varDeclarations += ", buffer = " + (appendFirst ? "" : this.initializeBuffer());
if (buffer) {
source += "return buffer + " + buffer + ";\n";
} else {
source += "return buffer;\n";
}
}
if (varDeclarations) {
source = "var " + varDeclarations.substring(2) + (appendFirst ? "" : ";\n ") + source;
}
return source;
}, blockValue:function(name) {
this.aliases.blockHelperMissing = "helpers.blockHelperMissing";
var params = [this.contextName(0)];
this.setupParams(name, 0, params);
var blockName = this.popStack();
params.splice(1, 0, blockName);
this.push("blockHelperMissing.call(" + params.join(", ") + ")");
}, ambiguousBlockValue:function() {
this.aliases.blockHelperMissing = "helpers.blockHelperMissing";
var params = [this.contextName(0)];
this.setupParams("", 0, params, true);
this.flushInline();
var current = this.topStack();
params.splice(1, 0, current);
this.pushSource("if (!" + this.lastHelper + ") { " + current + " = blockHelperMissing.call(" + params.join(", ") + "); }");
}, appendContent:function(content) {
if (this.pendingContent) {
content = this.pendingContent + content;
}
this.pendingContent = content;
}, append:function() {
this.flushInline();
var local = this.popStack();
this.pushSource("if (" + local + " != null) { " + this.appendToBuffer(local) + " }");
if (this.environment.isSimple) {
this.pushSource("else { " + this.appendToBuffer("''") + " }");
}
}, appendEscaped:function() {
this.aliases.escapeExpression = "this.escapeExpression";
this.pushSource(this.appendToBuffer("escapeExpression(" + this.popStack() + ")"));
}, getContext:function(depth) {
this.lastContext = depth;
}, pushContext:function() {
this.pushStackLiteral(this.contextName(this.lastContext));
}, lookupOnContext:function(parts, falsy, scoped) {
var i = 0, len = parts.length;
if (!scoped && (this.options.compat && !this.lastContext)) {
this.push(this.depthedLookup(parts[i++]));
} else {
this.pushContext();
}
for (;i < len;i++) {
this.replaceStack(function(current) {
var lookup = this.nameLookup(current, parts[i], "context");
if (!falsy) {
return " != null ? " + lookup + " : " + current;
} else {
return " && " + lookup;
}
});
}
}, lookupData:function(depth, parts) {
if (!depth) {
this.pushStackLiteral("data");
} else {
this.pushStackLiteral("this.data(data, " + depth + ")");
}
var len = parts.length;
for (var i = 0;i < len;i++) {
this.replaceStack(function(current) {
return " && " + this.nameLookup(current, parts[i], "data");
});
}
}, resolvePossibleLambda:function() {
this.aliases.lambda = "this.lambda";
this.push("lambda(" + this.popStack() + ", " + this.contextName(0) + ")");
}, pushStringParam:function(string, type) {
this.pushContext();
this.pushString(type);
if (type !== "sexpr") {
if (typeof string === "string") {
this.pushString(string);
} else {
this.pushStackLiteral(string);
}
}
}, emptyHash:function() {
this.pushStackLiteral("{}");
if (this.trackIds) {
this.push("{}");
}
if (this.stringParams) {
this.push("{}");
this.push("{}");
}
}, pushHash:function() {
if (this.hash) {
this.hashes.push(this.hash);
}
this.hash = {values:[], types:[], contexts:[], ids:[]};
}, popHash:function() {
var hash = this.hash;
this.hash = this.hashes.pop();
if (this.trackIds) {
this.push("{" + hash.ids.join(",") + "}");
}
if (this.stringParams) {
this.push("{" + hash.contexts.join(",") + "}");
this.push("{" + hash.types.join(",") + "}");
}
this.push("{\n " + hash.values.join(",\n ") + "\n }");
}, pushString:function(string) {
this.pushStackLiteral(this.quotedString(string));
}, push:function(expr) {
this.inlineStack.push(expr);
return expr;
}, pushLiteral:function(value) {
this.pushStackLiteral(value);
}, pushProgram:function(guid) {
if (guid != null) {
this.pushStackLiteral(this.programExpression(guid));
} else {
this.pushStackLiteral(null);
}
}, invokeHelper:function(paramSize, name, isSimple) {
this.aliases.helperMissing = "helpers.helperMissing";
var nonHelper = this.popStack();
var helper = this.setupHelper(paramSize, name);
var lookup = (isSimple ? helper.name + " || " : "") + nonHelper + " || helperMissing";
this.push("((" + lookup + ").call(" + helper.callParams + "))");
}, invokeKnownHelper:function(paramSize, name) {
var helper = this.setupHelper(paramSize, name);
this.push(helper.name + ".call(" + helper.callParams + ")");
}, invokeAmbiguous:function(name, helperCall) {
this.aliases.functionType = '"function"';
this.aliases.helperMissing = "helpers.helperMissing";
this.useRegister("helper");
var nonHelper = this.popStack();
this.emptyHash();
var helper = this.setupHelper(0, name, helperCall);
var helperName = this.lastHelper = this.nameLookup("helpers", name, "helper");
this.push("((helper = (helper = " + helperName + " || " + nonHelper + ") != null ? helper : helperMissing" + (helper.paramsInit ? "),(" + helper.paramsInit : "") + ")," + "(typeof helper === functionType ? helper.call(" + helper.callParams + ") : helper))");
}, invokePartial:function(name, indent) {
var params = [this.nameLookup("partials", name, "partial"), "'" + indent + "'", "'" + name + "'", this.popStack(), this.popStack(), "helpers", "partials"];
if (this.options.data) {
params.push("data");
} else {
if (this.options.compat) {
params.push("undefined");
}
}
if (this.options.compat) {
params.push("depths");
}
this.push("this.invokePartial(" + params.join(", ") + ")");
}, assignToHash:function(key) {
var value = this.popStack(), context, type, id;
if (this.trackIds) {
id = this.popStack();
}
if (this.stringParams) {
type = this.popStack();
context = this.popStack();
}
var hash = this.hash;
if (context) {
hash.contexts.push("'" + key + "': " + context);
}
if (type) {
hash.types.push("'" + key + "': " + type);
}
if (id) {
hash.ids.push("'" + key + "': " + id);
}
hash.values.push("'" + key + "': (" + value + ")");
}, pushId:function(type, name) {
if (type === "ID" || type === "DATA") {
this.pushString(name);
} else {
if (type === "sexpr") {
this.pushStackLiteral("true");
} else {
this.pushStackLiteral("null");
}
}
}, compiler:JavaScriptCompiler, compileChildren:function(environment, options) {
var children = environment.children, child, compiler;
for (var i = 0, l = children.length;i < l;i++) {
child = children[i];
compiler = new this.compiler;
var index = this.matchExistingProgram(child);
if (index == null) {
this.context.programs.push("");
index = this.context.programs.length;
child.index = index;
child.name = "program" + index;
this.context.programs[index] = compiler.compile(child, options, this.context, !this.precompile);
this.context.environments[index] = child;
this.useDepths = this.useDepths || compiler.useDepths;
} else {
child.index = index;
child.name = "program" + index;
}
}
}, matchExistingProgram:function(child) {
for (var i = 0, len = this.context.environments.length;i < len;i++) {
var environment = this.context.environments[i];
if (environment && environment.equals(child)) {
return i;
}
}
}, programExpression:function(guid) {
var child = this.environment.children[guid], depths = child.depths.list, useDepths = this.useDepths, depth;
var programParams = [child.index, "data"];
if (useDepths) {
programParams.push("depths");
}
return "this.program(" + programParams.join(", ") + ")";
}, useRegister:function(name) {
if (!this.registers[name]) {
this.registers[name] = true;
this.registers.list.push(name);
}
}, pushStackLiteral:function(item) {
return this.push(new Literal(item));
}, pushSource:function(source) {
if (this.pendingContent) {
this.source.push(this.appendToBuffer(this.quotedString(this.pendingContent)));
this.pendingContent = undefined;
}
if (source) {
this.source.push(source);
}
}, pushStack:function(item) {
this.flushInline();
var stack = this.incrStack();
this.pushSource(stack + " = " + item + ";");
this.compileStack.push(stack);
return stack;
}, replaceStack:function(callback) {
var prefix = "", inline = this.isInline(), stack, createdStack, usedLiteral;
if (!this.isInline()) {
throw new Exception("replaceStack on non-inline");
}
var top = this.popStack(true);
if (top instanceof Literal) {
prefix = stack = top.value;
usedLiteral = true;
} else {
createdStack = !this.stackSlot;
var name = !createdStack ? this.topStackName() : this.incrStack();
prefix = "(" + this.push(name) + " = " + top + ")";
stack = this.topStack();
}
var item = callback.call(this, stack);
if (!usedLiteral) {
this.popStack();
}
if (createdStack) {
this.stackSlot--;
}
this.push("(" + prefix + item + ")");
}, incrStack:function() {
this.stackSlot++;
if (this.stackSlot > this.stackVars.length) {
this.stackVars.push("stack" + this.stackSlot);
}
return this.topStackName();
}, topStackName:function() {
return "stack" + this.stackSlot;
}, flushInline:function() {
var inlineStack = this.inlineStack;
if (inlineStack.length) {
this.inlineStack = [];
for (var i = 0, len = inlineStack.length;i < len;i++) {
var entry = inlineStack[i];
if (entry instanceof Literal) {
this.compileStack.push(entry);
} else {
this.pushStack(entry);
}
}
}
}, isInline:function() {
return this.inlineStack.length;
}, popStack:function(wrapped) {
var inline = this.isInline(), item = (inline ? this.inlineStack : this.compileStack).pop();
if (!wrapped && item instanceof Literal) {
return item.value;
} else {
if (!inline) {
if (!this.stackSlot) {
throw new Exception("Invalid stack pop");
}
this.stackSlot--;
}
return item;
}
}, topStack:function() {
var stack = this.isInline() ? this.inlineStack : this.compileStack, item = stack[stack.length - 1];
if (item instanceof Literal) {
return item.value;
} else {
return item;
}
}, contextName:function(context) {
if (this.useDepths && context) {
return "depths[" + context + "]";
} else {
return "depth" + context;
}
}, quotedString:function(str) {
return'"' + str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029") + '"';
}, objectLiteral:function(obj) {
var pairs = [];
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
pairs.push(this.quotedString(key) + ":" + obj[key]);
}
}
return "{" + pairs.join(",") + "}";
}, setupHelper:function(paramSize, name, blockHelper) {
var params = [], paramsInit = this.setupParams(name, paramSize, params, blockHelper);
var foundHelper = this.nameLookup("helpers", name, "helper");
return{params:params, paramsInit:paramsInit, name:foundHelper, callParams:[this.contextName(0)].concat(params).join(", ")};
}, setupOptions:function(helper, paramSize, params) {
var options = {}, contexts = [], types = [], ids = [], param, inverse, program;
options.name = this.quotedString(helper);
options.hash = this.popStack();
if (this.trackIds) {
options.hashIds = this.popStack();
}
if (this.stringParams) {
options.hashTypes = this.popStack();
options.hashContexts = this.popStack();
}
inverse = this.popStack();
program = this.popStack();
if (program || inverse) {
if (!program) {
program = "this.noop";
}
if (!inverse) {
inverse = "this.noop";
}
options.fn = program;
options.inverse = inverse;
}
var i = paramSize;
while (i--) {
param = this.popStack();
params[i] = param;
if (this.trackIds) {
ids[i] = this.popStack();
}
if (this.stringParams) {
types[i] = this.popStack();
contexts[i] = this.popStack();
}
}
if (this.trackIds) {
options.ids = "[" + ids.join(",") + "]";
}
if (this.stringParams) {
options.types = "[" + types.join(",") + "]";
options.contexts = "[" + contexts.join(",") + "]";
}
if (this.options.data) {
options.data = "data";
}
return options;
}, setupParams:function(helperName, paramSize, params, useRegister) {
var options = this.objectLiteral(this.setupOptions(helperName, paramSize, params));
if (useRegister) {
this.useRegister("options");
params.push("options");
return "options=" + options;
} else {
params.push(options);
return "";
}
}};
var reservedWords = ("break else new var" + " case finally return void" + " catch for switch while" + " continue function this with" + " default if throw" + " delete in try" + " do instanceof typeof" + " abstract enum int short" + " boolean export interface static" + " byte extends long super" + " char final native synchronized" + " class float package throws" + " const goto private transient" + " debugger implements protected volatile" + " double import public let yield").split(" ");
var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {};
for (var i = 0, l = reservedWords.length;i < l;i++) {
compilerWords[reservedWords[i]] = true;
}
JavaScriptCompiler.isValidJavaScriptVariableName = function(name) {
return!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(name);
};
__exports__ = JavaScriptCompiler;
return __exports__;
}(__module2__, __module5__);
var __module0__ = function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) {
var __exports__;
var Handlebars = __dependency1__;
var AST = __dependency2__;
var Parser = __dependency3__.parser;
var parse = __dependency3__.parse;
var Compiler = __dependency4__.Compiler;
var compile = __dependency4__.compile;
var precompile = __dependency4__.precompile;
var JavaScriptCompiler = __dependency5__;
var _create = Handlebars.create;
var create = function() {
var hb = _create();
hb.compile = function(input, options) {
return compile(input, options, hb);
};
hb.precompile = function(input, options) {
return precompile(input, options, hb);
};
hb.AST = AST;
hb.Compiler = Compiler;
hb.JavaScriptCompiler = JavaScriptCompiler;
hb.Parser = Parser;
hb.parse = parse;
return hb;
};
Handlebars = create();
Handlebars.create = create;
Handlebars["default"] = Handlebars;
__exports__ = Handlebars;
return __exports__;
}(__module1__, __module7__, __module8__, __module11__, __module12__);
return __module0__;
});
(function() {
var enifed, requireModule, eriuqer, requirejs, Ember;
(function() {
Ember = this.Ember = this.Ember || {};
if (typeof Ember === "undefined") {
Ember = {};
}
function UNDEFINED() {
}
if (typeof Ember.__loader === "undefined") {
var registry = {}, seen = {};
enifed = function(name, deps, callback) {
registry[name] = {deps:deps, callback:callback};
};
requirejs = eriuqer = 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 < length;i++) {
if (deps[i] === "exports") {
reified.push(exports = {});
} else {
reified.push(requireModule(resolve(deps[i], name)));
}
}
var value = length === 0 ? callback.call(this) : callback.apply(this, reified);
return seen[name] = exports || (value === undefined ? UNDEFINED : value);
};
function resolve(child, name) {
if (child.charAt(0) !== ".") {
return child;
}
var parts = child.split("/");
var parentBase = name.split("/").slice(0, -1);
for (var i = 0, l = parts.length;i < l;i++) {
var part = parts[i];
if (part === "..") {
parentBase.pop();
} else {
if (part === ".") {
continue;
} else {
parentBase.push(part);
}
}
}
return parentBase.join("/");
}
requirejs._eak_seen = registry;
Ember.__loader = {define:enifed, require:eriuqer, registry:registry};
} else {
enifed = Ember.__loader.define;
requirejs = eriuqer = requireModule = Ember.__loader.require;
}
})();
enifed("backburner", ["backburner/utils", "backburner/platform", "backburner/binary-search", "backburner/deferred-action-queues", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
var each = __dependency1__.each;
var isString = __dependency1__.isString;
var isFunction = __dependency1__.isFunction;
var isNumber = __dependency1__.isNumber;
var isCoercableNumber = __dependency1__.isCoercableNumber;
var wrapInTryCatch = __dependency1__.wrapInTryCatch;
var now = __dependency1__.now;
var needsIETryCatchFix = __dependency2__.needsIETryCatchFix;
var searchTimer = __dependency3__["default"];
var DeferredActionQueues = __dependency4__["default"];
var slice = [].slice;
var pop = [].pop;
var global = this;
function Backburner(queueNames, options) {
this.queueNames = queueNames;
this.options = options || {};
if (!this.options.defaultQueue) {
this.options.defaultQueue = queueNames[0];
}
this.instanceStack = [];
this._debouncees = [];
this._throttlers = [];
this._timers = [];
}
Backburner.prototype = {begin:function() {
var options = this.options;
var onBegin = options && options.onBegin;
var previousInstance = this.currentInstance;
if (previousInstance) {
this.instanceStack.push(previousInstance);
}
this.currentInstance = new DeferredActionQueues(this.queueNames, options);
if (onBegin) {
onBegin(this.currentInstance, previousInstance);
}
}, end:function() {
var options = this.options;
var onEnd = options && options.onEnd;
var currentInstance = this.currentInstance;
var nextInstance = null;
var finallyAlreadyCalled = false;
try {
currentInstance.flush();
} finally {
if (!finallyAlreadyCalled) {
finallyAlreadyCalled = true;
this.currentInstance = null;
if (this.instanceStack.length) {
nextInstance = this.instanceStack.pop();
this.currentInstance = nextInstance;
}
if (onEnd) {
onEnd(currentInstance, nextInstance);
}
}
}
}, run:function(target, method) {
var onError = getOnError(this.options);
this.begin();
if (!method) {
method = target;
target = null;
}
if (isString(method)) {
method = target[method];
}
var args = slice.call(arguments, 2);
var didFinally = false;
if (onError) {
try {
return method.apply(target, args);
} catch (error) {
onError(error);
} finally {
if (!didFinally) {
didFinally = true;
this.end();
}
}
} else {
try {
return method.apply(target, args);
} finally {
if (!didFinally) {
didFinally = true;
this.end();
}
}
}
}, join:function(target, method) {
if (this.currentInstance) {
if (!method) {
method = target;
target = null;
}
if (isString(method)) {
method = target[method];
}
return method.apply(target, slice.call(arguments, 2));
} else {
return this.run.apply(this, arguments);
}
}, defer:function(queueName, target, method) {
if (!method) {
method = target;
target = null;
}
if (isString(method)) {
method = target[method];
}
var stack = this.DEBUG ? new Error : undefined;
var length = arguments.length;
var args;
if (length > 3) {
args = new Array(length - 3);
for (var i = 3;i < length;i++) {
args[i - 3] = arguments[i];
}
} else {
args = undefined;
}
if (!this.currentInstance) {
createAutorun(this);
}
return this.currentInstance.schedule(queueName, target, method, args, false, stack);
}, deferOnce:function(queueName, target, method) {
if (!method) {
method = target;
target = null;
}
if (isString(method)) {
method = target[method];
}
var stack = this.DEBUG ? new Error : undefined;
var length = arguments.length;
var args;
if (length > 3) {
args = new Array(length - 3);
for (var i = 3;i < length;i++) {
args[i - 3] = arguments[i];
}
} else {
args = undefined;
}
if (!this.currentInstance) {
createAutorun(this);
}
return this.currentInstance.schedule(queueName, target, method, args, true, stack);
}, setTimeout:function() {
var l = arguments.length;
var args = new Array(l);
for (var x = 0;x < l;x++) {
args[x] = arguments[x];
}
var length = args.length, method, wait, target, methodOrTarget, methodOrWait, methodOrArgs;
if (length === 0) {
return;
} else {
if (length === 1) {
method = args.shift();
wait = 0;
} else {
if (length === 2) {
methodOrTarget = args[0];
methodOrWait = args[1];
if (isFunction(methodOrWait) || isFunction(methodOrTarget[methodOrWait])) {
target = args.shift();
method = args.shift();
wait = 0;
} else {
if (isCoercableNumber(methodOrWait)) {
method = args.shift();
wait = args.shift();
} else {
method = args.shift();
wait = 0;
}
}
} else {
var last = args[args.length - 1];
if (isCoercableNumber(last)) {
wait = args.pop();
} else {
wait = 0;
}
methodOrTarget = args[0];
methodOrArgs = args[1];
if (isFunction(methodOrArgs) || isString(methodOrArgs) && (methodOrTarget !== null && methodOrArgs in methodOrTarget)) {
target = args.shift();
method = args.shift();
} else {
method = args.shift();
}
}
}
}
var executeAt = now() + parseInt(wait, 10);
if (isString(method)) {
method = target[method];
}
var onError = getOnError(this.options);
function fn() {
if (onError) {
try {
method.apply(target, args);
} catch (e) {
onError(e);
}
} else {
method.apply(target, args);
}
}
var i = searchTimer(executeAt, this._timers);
this._timers.splice(i, 0, executeAt, fn);
updateLaterTimer(this, executeAt, wait);
return fn;
}, throttle:function(target, method) {
var backburner = this;
var args = arguments;
var immediate = pop.call(args);
var wait, throttler, index, timer;
if (isNumber(immediate) || isString(immediate)) {
wait = immediate;
immediate = true;
} else {
wait = pop.call(args);
}
wait = parseInt(wait, 10);
index = findThrottler(target, method, this._throttlers);
if (index > -1) {
return this._throttlers[index];
}
timer = global.setTimeout(function() {
if (!immediate) {
backburner.run.apply(backburner, args);
}
var index = findThrottler(target, method, backburner._throttlers);
if (index > -1) {
backburner._throttlers.splice(index, 1);
}
}, wait);
if (immediate) {
this.run.apply(this, args);
}
throttler = [target, method, timer];
this._throttlers.push(throttler);
return throttler;
}, debounce:function(target, method) {
var backburner = this;
var args = arguments;
var immediate = pop.call(args);
var wait, index, debouncee, timer;
if (isNumber(immediate) || isString(immediate)) {
wait = immediate;
immediate = false;
} else {
wait = pop.call(args);
}
wait = parseInt(wait, 10);
index = findDebouncee(target, method, this._debouncees);
if (index > -1) {
debouncee = this._debouncees[index];
this._debouncees.splice(index, 1);
clearTimeout(debouncee[2]);
}
timer = global.setTimeout(function() {
if (!immediate) {
backburner.run.apply(backburner, args);
}
var index = findDebouncee(target, method, backburner._debouncees);
if (index > -1) {
backburner._debouncees.splice(index, 1);
}
}, wait);
if (immediate && index === -1) {
backburner.run.apply(backburner, args);
}
debouncee = [target, method, timer];
backburner._debouncees.push(debouncee);
return debouncee;
}, cancelTimers:function() {
var clearItems = function(item) {
clearTimeout(item[2]);
};
each(this._throttlers, clearItems);
this._throttlers = [];
each(this._debouncees, clearItems);
this._debouncees = [];
if (this._laterTimer) {
clearTimeout(this._laterTimer);
this._laterTimer = null;
}
this._timers = [];
if (this._autorun) {
clearTimeout(this._autorun);
this._autorun = null;
}
}, hasTimers:function() {
return!!this._timers.length || (!!this._debouncees.length || (!!this._throttlers.length || this._autorun));
}, cancel:function(timer) {
var timerType = typeof timer;
if (timer && (timerType === "object" && (timer.queue && timer.method))) {
return timer.queue.cancel(timer);
} else {
if (timerType === "function") {
for (var i = 0, l = this._timers.length;i < l;i += 2) {
if (this._timers[i + 1] === timer) {
this._timers.splice(i, 2);
if (i === 0) {
if (this._laterTimer) {
clearTimeout(this._laterTimer);
this._laterTimer = null;
}
if (this._timers.length > 0) {
updateLaterTimer(this, this._timers[0], this._timers[0] - now());
}
}
return true;
}
}
} else {
if (Object.prototype.toString.call(timer) === "[object Array]") {
return this._cancelItem(findThrottler, this._throttlers, timer) || this._cancelItem(findDebouncee, this._debouncees, timer);
} else {
return;
}
}
}
}, _cancelItem:function(findMethod, array, timer) {
var item, index;
if (timer.length < 3) {
return false;
}
index = findMethod(timer[0], timer[1], array);
if (index > -1) {
item = array[index];
if (item[2] === timer[2]) {
array.splice(index, 1);
clearTimeout(timer[2]);
return true;
}
}
return false;
}};
Backburner.prototype.schedule = Backburner.prototype.defer;
Backburner.prototype.scheduleOnce = Backburner.prototype.deferOnce;
Backburner.prototype.later = Backburner.prototype.setTimeout;
if (needsIETryCatchFix) {
var originalRun = Backburner.prototype.run;
Backburner.prototype.run = wrapInTryCatch(originalRun);
var originalEnd = Backburner.prototype.end;
Backburner.prototype.end = wrapInTryCatch(originalEnd);
}
function getOnError(options) {
return options.onError || options.onErrorTarget && options.onErrorTarget[options.onErrorMethod];
}
function createAutorun(backburner) {
backburner.begin();
backburner._autorun = global.setTimeout(function() {
backburner._autorun = null;
backburner.end();
});
}
function updateLaterTimer(backburner, executeAt, wait) {
var n = now();
if (!backburner._laterTimer || (executeAt < backburner._laterTimerExpiresAt || backburner._laterTimerExpiresAt < n)) {
if (backburner._laterTimer) {
clearTimeout(backburner._laterTimer);
if (backburner._laterTimerExpiresAt < n) {
wait = Math.max(0, executeAt - n);
}
}
backburner._laterTimer = global.setTimeout(function() {
backburner._laterTimer = null;
backburner._laterTimerExpiresAt = null;
executeTimers(backburner);
}, wait);
backburner._laterTimerExpiresAt = n + wait;
}
}
function executeTimers(backburner) {
var n = now();
var fns, i, l;
backburner.run(function() {
i = searchTimer(n, backburner._timers);
fns = backburner._timers.splice(0, i);
for (i = 1, l = fns.length;i < l;i += 2) {
backburner.schedule(backburner.options.defaultQueue, null, fns[i]);
}
});
if (backburner._timers.length) {
updateLaterTimer(backburner, backburner._timers[0], backburner._timers[0] - n);
}
}
function findDebouncee(target, method, debouncees) {
return findItem(target, method, debouncees);
}
function findThrottler(target, method, throttlers) {
return findItem(target, method, throttlers);
}
function findItem(target, method, collection) {
var item;
var index = -1;
for (var i = 0, l = collection.length;i < l;i++) {
item = collection[i];
if (item[0] === target && item[1] === method) {
index = i;
break;
}
}
return index;
}
__exports__["default"] = Backburner;
});
enifed("backburner.umd", ["./backburner"], function(__dependency1__) {
var Backburner = __dependency1__["default"];
if (typeof enifed === "function" && enifed.amd) {
enifed(function() {
return Backburner;
});
} else {
if (typeof module !== "undefined" && module.exports) {
module.exports = Backburner;
} else {
if (typeof this !== "undefined") {
this["Backburner"] = Backburner;
}
}
}
});
enifed("backburner/binary-search", ["exports"], function(__exports__) {
__exports__["default"] = function binarySearch(time, timers) {
var start = 0;
var end = timers.length - 2;
var middle, l;
while (start < end) {
l = (end - start) / 2;
middle = start + l - l % 2;
if (time >= timers[middle]) {
start = middle + 2;
} else {
end = middle;
}
}
return time >= timers[start] ? start + 2 : start;
};
});
enifed("backburner/deferred-action-queues", ["./utils", "./queue", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var each = __dependency1__.each;
var Queue = __dependency2__["default"];
function DeferredActionQueues(queueNames, options) {
var queues = this.queues = Object.create(null);
this.queueNames = queueNames = queueNames || [];
this.options = options;
each(queueNames, function(queueName) {
queues[queueName] = new Queue(queueName, options[queueName], options);
});
}
function noSuchQueue(name) {
throw new Error("You attempted to schedule an action in a queue (" + name + ") that doesn't exist");
}
DeferredActionQueues.prototype = {schedule:function(name, target, method, args, onceFlag, stack) {
var queues = this.queues;
var queue = queues[name];
if (!queue) {
noSuchQueue(name);
}
if (onceFlag) {
return queue.pushUnique(target, method, args, stack);
} else {
return queue.push(target, method, args, stack);
}
}, flush:function() {
var queues = this.queues;
var queueNames = this.queueNames;
var queueName, queue, queueItems, priorQueueNameIndex;
var queueNameIndex = 0;
var numberOfQueues = queueNames.length;
var options = this.options;
while (queueNameIndex < numberOfQueues) {
queueName = queueNames[queueNameIndex];
queue = queues[queueName];
var numberOfQueueItems = queue._queue.length;
if (numberOfQueueItems === 0) {
queueNameIndex++;
} else {
queue.flush(false);
queueNameIndex = 0;
}
}
}};
__exports__["default"] = DeferredActionQueues;
});
enifed("backburner/platform", ["exports"], function(__exports__) {
var needsIETryCatchFix = function(e, x) {
try {
x();
} catch (e) {
}
return!!e;
}();
__exports__.needsIETryCatchFix = needsIETryCatchFix;
});
enifed("backburner/queue", ["./utils", "exports"], function(__dependency1__, __exports__) {
var isString = __dependency1__.isString;
function Queue(name, options, globalOptions) {
this.name = name;
this.globalOptions = globalOptions || {};
this.options = options;
this._queue = [];
this.targetQueues = Object.create(null);
this._queueBeingFlushed = undefined;
}
Queue.prototype = {push:function(target, method, args, stack) {
var queue = this._queue;
queue.push(target, method, args, stack);
return{queue:this, target:target, method:method};
}, pushUniqueWithoutGuid:function(target, method, args, stack) {
var queue = this._queue;
for (var i = 0, l = queue.length;i < l;i += 4) {
var currentTarget = queue[i];
var currentMethod = queue[i + 1];
if (currentTarget === target && currentMethod === method) {
queue[i + 2] = args;
queue[i + 3] = stack;
return;
}
}
queue.push(target, method, args, stack);
}, targetQueue:function(targetQueue, target, method, args, stack) {
var queue = this._queue;
for (var i = 0, l = targetQueue.length;i < l;i += 4) {
var currentMethod = targetQueue[i];
var currentIndex = targetQueue[i + 1];
if (currentMethod === method) {
queue[currentIndex + 2] = args;
queue[currentIndex + 3] = stack;
return;
}
}
targetQueue.push(method, queue.push(target, method, args, stack) - 4);
}, pushUniqueWithGuid:function(guid, target, method, args, stack) {
var hasLocalQueue = this.targetQueues[guid];
if (hasLocalQueue) {
this.targetQueue(hasLocalQueue, target, method, args, stack);
} else {
this.targetQueues[guid] = [method, this._queue.push(target, method, args, stack) - 4];
}
return{queue:this, target:target, method:method};
}, pushUnique:function(target, method, args, stack) {
var queue = this._queue, currentTarget, currentMethod, i, l;
var KEY = this.globalOptions.GUID_KEY;
if (target && KEY) {
var guid = target[KEY];
if (guid) {
return this.pushUniqueWithGuid(guid, target, method, args, stack);
}
}
this.pushUniqueWithoutGuid(target, method, args, stack);
return{queue:this, target:target, method:method};
}, invoke:function(target, method, args, _, _errorRecordedForStack) {
if (args && args.length > 0) {
method.apply(target, args);
} else {
method.call(target);
}
}, invokeWithOnError:function(target, method, args, onError, errorRecordedForStack) {
try {
if (args && args.length > 0) {
method.apply(target, args);
} else {
method.call(target);
}
} catch (error) {
onError(error, errorRecordedForStack);
}
}, flush:function(sync) {
var queue = this._queue;
var length = queue.length;
if (length === 0) {
return;
}
var globalOptions = this.globalOptions;
var options = this.options;
var before = options && options.before;
var after = options && options.after;
var onError = globalOptions.onError || globalOptions.onErrorTarget && globalOptions.onErrorTarget[globalOptions.onErrorMethod];
var target, method, args, errorRecordedForStack;
var invoke = onError ? this.invokeWithOnError : this.invoke;
this.targetQueues = Object.create(null);
var queueItems = this._queueBeingFlushed = this._queue.slice();
this._queue = [];
if (before) {
before();
}
for (var i = 0;i < length;i += 4) {
target = queueItems[i];
method = queueItems[i + 1];
args = queueItems[i + 2];
errorRecordedForStack = queueItems[i + 3];
if (isString(method)) {
method = target[method];
}
if (method) {
invoke(target, method, args, onError, errorRecordedForStack);
}
}
if (after) {
after();
}
this._queueBeingFlushed = undefined;
if (sync !== false && this._queue.length > 0) {
this.flush(true);
}
}, cancel:function(actionToCancel) {
var queue = this._queue, currentTarget, currentMethod, i, l;
var target = actionToCancel.target;
var method = actionToCancel.method;
var GUID_KEY = this.globalOptions.GUID_KEY;
if (GUID_KEY && (this.targetQueues && target)) {
var targetQueue = this.targetQueues[target[GUID_KEY]];
if (targetQueue) {
for (i = 0, l = targetQueue.length;i < l;i++) {
if (targetQueue[i] === method) {
targetQueue.splice(i, 1);
}
}
}
}
for (i = 0, l = queue.length;i < l;i += 4) {
currentTarget = queue[i];
currentMethod = queue[i + 1];
if (currentTarget === target && currentMethod === method) {
queue.splice(i, 4);
return true;
}
}
queue = this._queueBeingFlushed;
if (!queue) {
return;
}
for (i = 0, l = queue.length;i < l;i += 4) {
currentTarget = queue[i];
currentMethod = queue[i + 1];
if (currentTarget === target && currentMethod === method) {
queue[i + 1] = null;
return true;
}
}
}};
__exports__["default"] = Queue;
});
enifed("backburner/utils", ["exports"], function(__exports__) {
var NUMBER = /\d+/;
function each(collection, callback) {
for (var i = 0;i < collection.length;i++) {
callback(collection[i]);
}
}
__exports__.each = each;
var now = Date.now || function() {
return(new Date).getTime();
};
__exports__.now = now;
function isString(suspect) {
return typeof suspect === "string";
}
__exports__.isString = isString;
function isFunction(suspect) {
return typeof suspect === "function";
}
__exports__.isFunction = isFunction;
function isNumber(suspect) {
return typeof suspect === "number";
}
__exports__.isNumber = isNumber;
function isCoercableNumber(number) {
return isNumber(number) || NUMBER.test(number);
}
__exports__.isCoercableNumber = isCoercableNumber;
function wrapInTryCatch(func) {
return function() {
try {
return func.apply(this, arguments);
} catch (e) {
throw e;
}
};
}
__exports__.wrapInTryCatch = wrapInTryCatch;
});
enifed("calculateVersion", [], function() {
var fs = eriuqer("fs");
var path = eriuqer("path");
module.exports = function() {
var packageVersion = eriuqer("../package.json").version;
var output = [packageVersion];
var gitPath = path.join(__dirname, "..", ".git");
var headFilePath = path.join(gitPath, "HEAD");
if (packageVersion.indexOf("+") > -1) {
try {
if (fs.existsSync(headFilePath)) {
var headFile = fs.readFileSync(headFilePath, {encoding:"utf8"});
var branchName = headFile.split("/").slice(-1)[0].trim();
var refPath = headFile.split(" ")[1];
var branchSHA;
if (refPath) {
var branchPath = path.join(gitPath, refPath.trim());
branchSHA = fs.readFileSync(branchPath);
} else {
branchSHA = branchName;
}
output.push(branchSHA.slice(0, 10));
}
} catch (err) {
console.error(err.stack);
}
return output.join(".");
} else {
return packageVersion;
}
};
});
enifed("container", ["container/container", "exports"], function(__dependency1__, __exports__) {
Ember.MODEL_FACTORY_INJECTIONS = false;
if (Ember.ENV && typeof Ember.ENV.MODEL_FACTORY_INJECTIONS !== "undefined") {
Ember.MODEL_FACTORY_INJECTIONS = !!Ember.ENV.MODEL_FACTORY_INJECTIONS;
}
var Container = __dependency1__["default"];
__exports__["default"] = Container;
});
enifed("container/container", ["ember-metal/core", "ember-metal/keys", "ember-metal/dictionary", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
var Ember = __dependency1__["default"];
var emberKeys = __dependency2__["default"];
var dictionary = __dependency3__["default"];
function Container(parent) {
this.parent = parent;
this.children = [];
this.resolver = parent && parent.resolver || function() {
};
this.registry = dictionary(parent ? parent.registry : null);
this.cache = dictionary(parent ? parent.cache : null);
this.factoryCache = dictionary(parent ? parent.factoryCache : null);
this.resolveCache = dictionary(parent ? parent.resolveCache : null);
this.typeInjections = dictionary(parent ? parent.typeInjections : null);
this.injections = dictionary(null);
this.normalizeCache = dictionary(null);
this.factoryTypeInjections = dictionary(parent ? parent.factoryTypeInjections : null);
this.factoryInjections = dictionary(null);
this._options = dictionary(parent ? parent._options : null);
this._typeOptions = dictionary(parent ? parent._typeOptions : null);
}
Container.prototype = {parent:null, children:null, resolver:null, registry:null, cache:null, typeInjections:null, injections:null, _options:null, _typeOptions:null, child:function() {
var container = new Container(this);
this.children.push(container);
return container;
}, register:function(fullName, factory, options) {
Ember.assert("fullName must be a proper full name", validateFullName(fullName));
if (factory === undefined) {
throw new TypeError("Attempting to register an unknown factory: `" + fullName + "`");
}
var normalizedName = this.normalize(fullName);
if (normalizedName in this.cache) {
throw new Error("Cannot re-register: `" + fullName + "`, as it has already been looked up.");
}
this.registry[normalizedName] = factory;
this._options[normalizedName] = options || {};
}, unregister:function(fullName) {
Ember.assert("fullName must be a proper full name", validateFullName(fullName));
var normalizedName = this.normalize(fullName);
delete this.registry[normalizedName];
delete this.cache[normalizedName];
delete this.factoryCache[normalizedName];
delete this.resolveCache[normalizedName];
delete this._options[normalizedName];
}, resolve:function(fullName) {
Ember.assert("fullName must be a proper full name", validateFullName(fullName));
return resolve(this, this.normalize(fullName));
}, describe:function(fullName) {
return fullName;
}, normalizeFullName:function(fullName) {
return fullName;
}, normalize:function(fullName) {
return this.normalizeCache[fullName] || (this.normalizeCache[fullName] = this.normalizeFullName(fullName));
}, makeToString:function(factory, fullName) {
return factory.toString();
}, lookup:function(fullName, options) {
Ember.assert("fullName must be a proper full name", validateFullName(fullName));
return lookup(this, this.normalize(fullName), options);
}, lookupFactory:function(fullName) {
Ember.assert("fullName must be a proper full name", validateFullName(fullName));
return factoryFor(this, this.normalize(fullName));
}, has:function(fullName) {
Ember.assert("fullName must be a proper full name", validateFullName(fullName));
return has(this, this.normalize(fullName));
}, optionsForType:function(type, options) {
if (this.parent) {
illegalChildOperation("optionsForType");
}
this._typeOptions[type] = options;
}, options:function(fullName, options) {
options = options || {};
var normalizedName = this.normalize(fullName);
this._options[normalizedName] = options;
}, typeInjection:function(type, property, fullName) {
Ember.assert("fullName must be a proper full name", validateFullName(fullName));
if (this.parent) {
illegalChildOperation("typeInjection");
}
var fullNameType = fullName.split(":")[0];
if (fullNameType === type) {
throw new Error("Cannot inject a `" + fullName + "` on other " + type + "(s). Register the `" + fullName + "` as a different type and perform the typeInjection.");
}
addTypeInjection(this.typeInjections, type, property, fullName);
}, injection:function(fullName, property, injectionName) {
if (this.parent) {
illegalChildOperation("injection");
}
validateFullName(injectionName);
var normalizedInjectionName = this.normalize(injectionName);
if (fullName.indexOf(":") === -1) {
return this.typeInjection(fullName, property, normalizedInjectionName);
}
Ember.assert("fullName must be a proper full name", validateFullName(fullName));
var normalizedName = this.normalize(fullName);
if (this.cache[normalizedName]) {
throw new Error("Attempted to register an injection for a type that has already been looked up. ('" + normalizedName + "', '" + property + "', '" + injectionName + "')");
}
addInjection(initRules(this.injections, normalizedName), property, normalizedInjectionName);
}, factoryTypeInjection:function(type, property, fullName) {
if (this.parent) {
illegalChildOperation("factoryTypeInjection");
}
addTypeInjection(this.factoryTypeInjections, type, property, this.normalize(fullName));
}, factoryInjection:function(fullName, property, injectionName) {
if (this.parent) {
illegalChildOperation("injection");
}
var normalizedName = this.normalize(fullName);
var normalizedInjectionName = this.normalize(injectionName);
validateFullName(injectionName);
if (fullName.indexOf(":") === -1) {
return this.factoryTypeInjection(normalizedName, property, normalizedInjectionName);
}
Ember.assert("fullName must be a proper full name", validateFullName(fullName));
if (this.factoryCache[normalizedName]) {
throw new Error("Attempted to register a factoryInjection for a type that has already " + "been looked up. ('" + normalizedName + "', '" + property + "', '" + injectionName + "')");
}
addInjection(initRules(this.factoryInjections, normalizedName), property, normalizedInjectionName);
}, destroy:function() {
for (var i = 0, length = this.children.length;i < length;i++) {
this.children[i].destroy();
}
this.children = [];
eachDestroyable(this, function(item) {
item.destroy();
});
this.parent = undefined;
this.isDestroyed = true;
}, reset:function() {
for (var i = 0, length = this.children.length;i < length;i++) {
resetCache(this.children[i]);
}
resetCache(this);
}};
function resolve(container, normalizedName) {
var cached = container.resolveCache[normalizedName];
if (cached) {
return cached;
}
var resolved = container.resolver(normalizedName) || container.registry[normalizedName];
container.resolveCache[normalizedName] = resolved;
return resolved;
}
function has(container, fullName) {
if (container.cache[fullName]) {
return true;
}
return container.resolve(fullName) !== undefined;
}
function lookup(container, fullName, options) {
options = options || {};
if (container.cache[fullName] && options.singleton !== false) {
return container.cache[fullName];
}
var value = instantiate(container, fullName);
if (value === undefined) {
return;
}
if (isSingleton(container, fullName) && options.singleton !== false) {
container.cache[fullName] = value;
}
return value;
}
function illegalChildOperation(operation) {
throw new Error(operation + " is not currently supported on child containers");
}
function isSingleton(container, fullName) {
var singleton = option(container, fullName, "singleton");
return singleton !== false;
}
function buildInjections(container, injections) {
var hash = {};
if (!injections) {
return hash;
}
validateInjections(container, injections);
var injection;
for (var i = 0, length = injections.length;i < length;i++) {
injection = injections[i];
hash[injection.property] = lookup(container, injection.fullName);
}
return hash;
}
function validateInjections(container, injections) {
if (!injections) {
return;
}
var fullName;
for (var i = 0, length = injections.length;i < length;i++) {
fullName = injections[i].fullName;
if (!container.has(fullName)) {
throw new Error("Attempting to inject an unknown injection: `" + fullName + "`");
}
}
}
function option(container, fullName, optionName) {
var options = container._options[fullName];
if (options && options[optionName] !== undefined) {
return options[optionName];
}
var type = fullName.split(":")[0];
options = container._typeOptions[type];
if (options) {
return options[optionName];
}
}
function factoryFor(container, fullName) {
var cache = container.factoryCache;
if (cache[fullName]) {
return cache[fullName];
}
var factory = container.resolve(fullName);
if (factory === undefined) {
return;
}
var type = fullName.split(":")[0];
if (!factory || (typeof factory.extend !== "function" || !Ember.MODEL_FACTORY_INJECTIONS && type === "model")) {
cache[fullName] = factory;
return factory;
} else {
var injections = injectionsFor(container, fullName);
var factoryInjections = factoryInjectionsFor(container, fullName);
factoryInjections._toString = container.makeToString(factory, fullName);
var injectedFactory = factory.extend(injections);
injectedFactory.reopenClass(factoryInjections);
cache[fullName] = injectedFactory;
return injectedFactory;
}
}
function injectionsFor(container, fullName) {
var splitName = fullName.split(":");
var type = splitName[0];
var injections = [];
injections = injections.concat(container.typeInjections[type] || []);
injections = injections.concat(container.injections[fullName] || []);
injections = buildInjections(container, injections);
injections._debugContainerKey = fullName;
injections.container = container;
return injections;
}
function factoryInjectionsFor(container, fullName) {
var splitName = fullName.split(":");
var type = splitName[0];
var factoryInjections = [];
factoryInjections = factoryInjections.concat(container.factoryTypeInjections[type] || []);
factoryInjections = factoryInjections.concat(container.factoryInjections[fullName] || []);
factoryInjections = buildInjections(container, factoryInjections);
factoryInjections._debugContainerKey = fullName;
return factoryInjections;
}
function normalizeInjectionsHash(hash) {
var injections = [];
for (var key in hash) {
if (hash.hasOwnProperty(key)) {
Ember.assert("Expected a proper full name, given '" + hash[key] + "'", validateFullName(hash[key]));
addInjection(injections, key, hash[key]);
}
}
return injections;
}
function instantiate(container, fullName) {
var factory = factoryFor(container, fullName);
var lazyInjections;
if (option(container, fullName, "instantiate") === false) {
return factory;
}
if (factory) {
if (typeof factory.create !== "function") {
throw new Error("Failed to create an instance of '" + fullName + "'. " + "Most likely an improperly defined class or an invalid module export.");
}
if (typeof factory.extend === "function") {
return factory.create();
} else {
return factory.create(injectionsFor(container, fullName));
}
}
}
function eachDestroyable(container, callback) {
var cache = container.cache;
var keys = emberKeys(cache);
var key, value;
for (var i = 0, l = keys.length;i < l;i++) {
key = keys[i];
value = cache[key];
if (option(container, key, "instantiate") !== false) {
callback(value);
}
}
}
function resetCache(container) {
eachDestroyable(container, function(value) {
value.destroy();
});
container.cache.dict = dictionary(null);
}
function addTypeInjection(rules, type, property, fullName) {
var injections = rules[type];
if (!injections) {
injections = [];
rules[type] = injections;
}
injections.push({property:property, fullName:fullName});
}
var VALID_FULL_NAME_REGEXP = /^[^:]+.+:[^:]+$/;
function validateFullName(fullName) {
if (!VALID_FULL_NAME_REGEXP.test(fullName)) {
throw new TypeError("Invalid Fullname, expected: `type:name` got: " + fullName);
}
return true;
}
function initRules(rules, factoryName) {
return rules[factoryName] || (rules[factoryName] = []);
}
function addInjection(injections, property, injectionName) {
injections.push({property:property, fullName:injectionName});
}
__exports__["default"] = Container;
});
enifed("dag-map", ["exports"], function(__exports__) {
function visit(vertex, fn, visited, path) {
var name = vertex.name;
var vertices = vertex.incoming;
var names = vertex.incomingNames;
var len = names.length;
var i;
if (!visited) {
visited = {};
}
if (!path) {
path = [];
}
if (visited.hasOwnProperty(name)) {
return;
}
path.push(name);
visited[name] = true;
for (i = 0;i < len;i++) {
visit(vertices[names[i]], fn, visited, path);
}
fn(vertex, path);
path.pop();
}
function DAG() {
this.names = [];
this.vertices = Object.create(null);
}
function Vertex(name) {
this.name = name;
this.incoming = {};
this.incomingNames = [];
this.hasOutgoing = false;
this.value = null;
}
DAG.prototype.add = function(name) {
if (!name) {
throw new Error("Can't add Vertex without name");
}
if (this.vertices[name] !== undefined) {
return this.vertices[name];
}
var vertex = new Vertex(name);
this.vertices[name] = vertex;
this.names.push(name);
return vertex;
};
DAG.prototype.map = function(name, value) {
this.add(name).value = value;
};
DAG.prototype.addEdge = function(fromName, toName) {
if (!fromName || (!toName || fromName === toName)) {
return;
}
var from = this.add(fromName);
var to = this.add(toName);
if (to.incoming.hasOwnProperty(fromName)) {
return;
}
function checkCycle(vertex, path) {
if (vertex.name === toName) {
throw new Error("cycle detected: " + toName + " <- " + path.join(" <- "));
}
}
visit(from, checkCycle);
from.hasOutgoing = true;
to.incoming[fromName] = from;
to.incomingNames.push(fromName);
};
DAG.prototype.topsort = function(fn) {
var visited = {};
var vertices = this.vertices;
var names = this.names;
var len = names.length;
var i, vertex;
for (i = 0;i < len;i++) {
vertex = vertices[names[i]];
if (!vertex.hasOutgoing) {
visit(vertex, fn, visited);
}
}
};
DAG.prototype.addEdges = function(name, value, before, after) {
var i;
this.map(name, value);
if (before) {
if (typeof before === "string") {
this.addEdge(name, before);
} else {
for (i = 0;i < before.length;i++) {
this.addEdge(name, before[i]);
}
}
}
if (after) {
if (typeof after === "string") {
this.addEdge(after, name);
} else {
for (i = 0;i < after.length;i++) {
this.addEdge(after[i], name);
}
}
}
};
__exports__["default"] = DAG;
});
enifed("dag-map.umd", ["./dag-map"], function(__dependency1__) {
var DAG = __dependency1__["default"];
if (typeof enifed === "function" && enifed.amd) {
enifed(function() {
return DAG;
});
} else {
if (typeof module !== "undefined" && module.exports) {
module.exports = DAG;
} else {
if (typeof this !== "undefined") {
this["DAG"] = DAG;
}
}
}
});
enifed("ember-application", ["ember-metal/core", "ember-runtime/system/lazy_load", "ember-application/system/resolver", "ember-application/system/application", "ember-application/ext/controller"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) {
var Ember = __dependency1__["default"];
var runLoadHooks = __dependency2__.runLoadHooks;
var Resolver = __dependency3__.Resolver;
var DefaultResolver = __dependency3__["default"];
var Application = __dependency4__["default"];
Ember.Application = Application;
Ember.Resolver = Resolver;
Ember.DefaultResolver = DefaultResolver;
runLoadHooks("Ember.Application", Application);
});
enifed("ember-application/ext/controller", ["ember-metal/core", "ember-metal/property_get", "ember-metal/error", "ember-metal/utils", "ember-metal/computed", "ember-runtime/mixins/controller", "ember-routing/system/controller_for", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
var Ember = __dependency1__["default"];
var get = __dependency2__.get;
var EmberError = __dependency3__["default"];
var inspect = __dependency4__.inspect;
var computed = __dependency5__.computed;
var ControllerMixin = __dependency6__["default"];
var meta = __dependency4__.meta;
var controllerFor = __dependency7__["default"];
function verifyNeedsDependencies(controller, container, needs) {
var dependency, i, l;
var missing = [];
for (i = 0, l = needs.length;i < l;i++) {
dependency = needs[i];
Ember.assert(inspect(controller) + "#needs must not specify dependencies with periods in their names (" + dependency + ")", dependency.indexOf(".") === -1);
if (dependency.indexOf(":") === -1) {
dependency = "controller:" + dependency;
}
if (!container.has(dependency)) {
missing.push(dependency);
}
}
if (missing.length) {
throw new EmberError(inspect(controller) + " needs [ " + missing.join(", ") + " ] but " + (missing.length > 1 ? "they" : "it") + " could not be found");
}
}
var defaultControllersComputedProperty = computed(function() {
var controller = this;
return{needs:get(controller, "needs"), container:get(controller, "container"), unknownProperty:function(controllerName) {
var needs = this.needs;
var dependency, i, l;
for (i = 0, l = needs.length;i < l;i++) {
dependency = needs[i];
if (dependency === controllerName) {
return this.container.lookup("controller:" + controllerName);
}
}
var errorMessage = inspect(controller) + "#needs does not include `" + controllerName + "`. To access the " + controllerName + " controller from " + inspect(controller) + ", " + inspect(controller) + " should have a `needs` property that is an array of the controllers it has access to.";
throw new ReferenceError(errorMessage);
}, setUnknownProperty:function(key, value) {
throw new Error("You cannot overwrite the value of `controllers." + key + "` of " + inspect(controller));
}};
});
ControllerMixin.reopen({concatenatedProperties:["needs"], needs:[], init:function() {
var needs = get(this, "needs");
var length = get(needs, "length");
if (length > 0) {
Ember.assert(" `" + inspect(this) + " specifies `needs`, but does " + "not have a container. Please ensure this controller was " + "instantiated with a container.", this.container || meta(this, false).descs.controllers !== defaultControllersComputedProperty);
if (this.container) {
verifyNeedsDependencies(this, this.container, needs);
}
get(this, "controllers");
}
this._super.apply(this, arguments);
}, controllerFor:function(controllerName) {
Ember.deprecate("Controller#controllerFor is deprecated, please use Controller#needs instead");
return controllerFor(get(this, "container"), controllerName);
}, controllers:defaultControllersComputedProperty});
__exports__["default"] = ControllerMixin;
});
enifed("ember-application/system/application", ["dag-map", "container/container", "ember-metal", "ember-metal/property_get", "ember-metal/property_set", "ember-runtime/system/lazy_load", "ember-runtime/system/namespace", "ember-runtime/mixins/deferred", "ember-application/system/resolver", "ember-metal/platform", "ember-metal/run_loop", "ember-metal/utils", "ember-runtime/controllers/controller", "ember-metal/enumerable_utils", "ember-runtime/controllers/object_controller", "ember-runtime/controllers/array_controller",
"ember-handlebars/controls/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", "ember-handlebars-compiler", "exports"], function(__dependency1__, __dependency2__,
__dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __dependency21__, __dependency22__, __dependency23__, __dependency24__, __dependency25__, __dependency26__, __dependency27__, __dependency28__, __dependency29__, __exports__) {
var DAG = __dependency1__["default"];
var Container = __dependency2__["default"];
var Ember = __dependency3__["default"];
var get = __dependency4__.get;
var set = __dependency5__.set;
var runLoadHooks = __dependency6__.runLoadHooks;
var Namespace = __dependency7__["default"];
var DeferredMixin = __dependency8__["default"];
var DefaultResolver = __dependency9__["default"];
var create = __dependency10__.create;
var run = __dependency11__["default"];
var canInvoke = __dependency12__.canInvoke;
var Controller = __dependency13__["default"];
var EnumerableUtils = __dependency14__["default"];
var ObjectController = __dependency15__["default"];
var ArrayController = __dependency16__["default"];
var SelectView = __dependency17__["default"];
var EventDispatcher = __dependency18__["default"];
var jQuery = __dependency19__["default"];
var Route = __dependency20__["default"];
var Router = __dependency21__["default"];
var HashLocation = __dependency22__["default"];
var HistoryLocation = __dependency23__["default"];
var AutoLocation = __dependency24__["default"];
var NoneLocation = __dependency25__["default"];
var BucketCache = __dependency26__["default"];
var ContainerDebugAdapter = __dependency27__["default"];
var K = __dependency28__.K;
var EmberHandlebars = __dependency29__["default"];
function props(obj) {
var properties = [];
for (var key in obj) {
properties.push(key);
}
return properties;
}
var Application = Namespace.extend(DeferredMixin, {_suppressDeferredDeprecation:true, rootElement:"body", eventDispatcher:null, customEvents:null, _readinessDeferrals:1, init:function() {
if (!this.$) {
this.$ = jQuery;
}
this.__container__ = this.buildContainer();
this.Router = this.defaultRouter();
this._super();
this.scheduleInitialize();
Ember.libraries.registerCoreLibrary("Handlebars" + (EmberHandlebars.compile ? "" : "-runtime"), EmberHandlebars.VERSION);
Ember.libraries.registerCoreLibrary("jQuery", jQuery().jquery);
if (Ember.LOG_VERSION) {
Ember.LOG_VERSION = false;
var nameLengths = EnumerableUtils.map(Ember.libraries, function(item) {
return get(item, "name.length");
});
var maxNameLength = Math.max.apply(this, nameLengths);
Ember.debug("-------------------------------");
Ember.libraries.each(function(name, version) {
var spaces = (new Array(maxNameLength - name.length + 1)).join(" ");
Ember.debug([name, spaces, " : ", version].join(""));
});
Ember.debug("-------------------------------");
}
}, buildContainer:function() {
var container = this.__container__ = Application.buildContainer(this);
return container;
}, defaultRouter:function() {
if (this.Router === false) {
return;
}
var container = this.__container__;
if (this.Router) {
container.unregister("router:main");
container.register("router:main", this.Router);
}
return container.lookupFactory("router:main");
}, scheduleInitialize:function() {
var self = this;
if (!this.$ || this.$.isReady) {
run.schedule("actions", self, "_initialize");
} else {
this.$().ready(function runInitialize() {
run(self, "_initialize");
});
}
}, deferReadiness:function() {
Ember.assert("You must call deferReadiness on an instance of Ember.Application", this instanceof Application);
Ember.assert("You cannot defer readiness since the `ready()` hook has already been called.", this._readinessDeferrals > 0);
this._readinessDeferrals++;
}, advanceReadiness:function() {
Ember.assert("You must call advanceReadiness on an instance of Ember.Application", this instanceof Application);
this._readinessDeferrals--;
if (this._readinessDeferrals === 0) {
run.once(this, this.didBecomeReady);
}
}, register:function() {
var container = this.__container__;
container.register.apply(container, arguments);
}, inject:function() {
var container = this.__container__;
container.injection.apply(container, arguments);
}, initialize:function() {
Ember.deprecate("Calling initialize manually is not supported. Please see Ember.Application#advanceReadiness and Ember.Application#deferReadiness");
}, _initialize:function() {
if (this.isDestroyed) {
return;
}
if (this.Router) {
var container = this.__container__;
container.unregister("router:main");
container.register("router:main", this.Router);
}
this.runInitializers();
runLoadHooks("application", this);
this.advanceReadiness();
return this;
}, reset:function() {
this._readinessDeferrals = 1;
function handleReset() {
var router = this.__container__.lookup("router:main");
router.reset();
run(this.__container__, "destroy");
this.buildContainer();
run.schedule("actions", this, function() {
this._initialize();
});
}
run.join(this, handleReset);
}, runInitializers:function() {
var initializersByName = get(this.constructor, "initializers");
var initializers = props(initializersByName);
var container = this.__container__;
var graph = new DAG;
var namespace = this;
var initializer;
for (var i = 0;i < initializers.length;i++) {
initializer = initializersByName[initializers[i]];
graph.addEdges(initializer.name, initializer.initialize, initializer.before, initializer.after);
}
graph.topsort(function(vertex) {
var initializer = vertex.value;
Ember.assert("No application initializer named '" + vertex.name + "'", initializer);
initializer(container, namespace);
});
}, didBecomeReady:function() {
this.setupEventDispatcher();
this.ready();
this.startRouting();
if (!Ember.testing) {
Ember.Namespace.processAll();
Ember.BOOTED = true;
}
this.resolve(this);
}, setupEventDispatcher:function() {
var customEvents = get(this, "customEvents");
var rootElement = get(this, "rootElement");
var dispatcher = this.__container__.lookup("event_dispatcher:main");
set(this, "eventDispatcher", dispatcher);
dispatcher.setup(customEvents, rootElement);
}, startRouting:function() {
var router = this.__container__.lookup("router:main");
if (!router) {
return;
}
router.startRouting();
}, handleURL:function(url) {
var router = this.__container__.lookup("router:main");
router.handleURL(url);
}, ready:K, resolver:null, Resolver:null, willDestroy:function() {
Ember.BOOTED = false;
this.__container__.lookup("router:main").reset();
this.__container__.destroy();
}, initializer:function(options) {
this.constructor.initializer(options);
}, then:function() {
Ember.deprecate("Do not use `.then` on an instance of Ember.Application. Please use the `.ready` hook instead.");
this._super.apply(this, arguments);
}});
Application.reopenClass({initializers:create(null), initializer:function(initializer) {
if (this.superclass.initializers !== undefined && this.superclass.initializers === this.initializers) {
this.reopenClass({initializers:create(this.initializers)});
}
Ember.assert("The initializer '" + initializer.name + "' has already been registered", !this.initializers[initializer.name]);
Ember.assert("An initializer cannot be registered without an initialize function", canInvoke(initializer, "initialize"));
Ember.assert("An initializer cannot be registered without a name property", initializer.name !== undefined);
this.initializers[initializer.name] = initializer;
}, buildContainer:function(namespace) {
var container = new Container;
container.set = set;
container.resolver = resolverFor(namespace);
container.normalizeFullName = container.resolver.normalize;
container.describe = container.resolver.describe;
container.makeToString = container.resolver.makeToString;
container.optionsForType("component", {singleton:false});
container.optionsForType("view", {singleton:false});
container.optionsForType("template", {instantiate:false});
container.optionsForType("helper", {instantiate:false});
container.register("application:main", namespace, {instantiate:false});
container.register("controller:basic", Controller, {instantiate:false});
container.register("controller:object", ObjectController, {instantiate:false});
container.register("controller:array", ArrayController, {instantiate:false});
container.register("view:select", SelectView);
container.register("route:basic", Route, {instantiate:false});
container.register("event_dispatcher:main", EventDispatcher);
container.register("router:main", Router);
container.injection("router:main", "namespace", "application:main");
container.register("location:auto", AutoLocation);
container.register("location:hash", HashLocation);
container.register("location:history", HistoryLocation);
container.register("location:none", NoneLocation);
container.injection("controller", "target", "router:main");
container.injection("controller", "namespace", "application:main");
container.register("-bucket-cache:main", BucketCache);
container.injection("router", "_bucketCache", "-bucket-cache:main");
container.injection("route", "_bucketCache", "-bucket-cache:main");
container.injection("controller", "_bucketCache", "-bucket-cache:main");
container.injection("route", "router", "router:main");
container.injection("location", "rootURL", "-location-setting:root-url");
container.register("resolver-for-debugging:main", container.resolver.__resolver__, {instantiate:false});
container.injection("container-debug-adapter:main", "resolver", "resolver-for-debugging:main");
container.injection("data-adapter:main", "containerDebugAdapter", "container-debug-adapter:main");
container.register("container-debug-adapter:main", ContainerDebugAdapter);
return container;
}});
function resolverFor(namespace) {
if (namespace.get("resolver")) {
Ember.deprecate("Application.resolver is deprecated in favor of Application.Resolver", false);
}
var ResolverClass = namespace.get("resolver") || (namespace.get("Resolver") || DefaultResolver);
var resolver = ResolverClass.create({namespace:namespace});
function resolve(fullName) {
return resolver.resolve(fullName);
}
resolve.describe = function(fullName) {
return resolver.lookupDescription(fullName);
};
resolve.makeToString = function(factory, fullName) {
return resolver.makeToString(factory, fullName);
};
resolve.normalize = function(fullName) {
if (resolver.normalize) {
return resolver.normalize(fullName);
} else {
Ember.deprecate("The Resolver should now provide a 'normalize' function", false);
return fullName;
}
};
resolve.__resolver__ = resolver;
return resolve;
}
__exports__["default"] = Application;
});
enifed("ember-application/system/resolver", ["ember-metal/core", "ember-metal/property_get", "ember-metal/logger", "ember-runtime/system/string", "ember-runtime/system/object", "ember-runtime/system/namespace", "ember-handlebars", "ember-metal/dictionary", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
var Ember = __dependency1__["default"];
var get = __dependency2__.get;
var Logger = __dependency3__["default"];
var classify = __dependency4__.classify;
var capitalize = __dependency4__.capitalize;
var decamelize = __dependency4__.decamelize;
var EmberObject = __dependency5__["default"];
var Namespace = __dependency6__["default"];
var EmberHandlebars = __dependency7__["default"];
var Resolver = EmberObject.extend({namespace:null, normalize:Ember.required(Function), resolve:Ember.required(Function), parseName:Ember.required(Function), lookupDescription:Ember.required(Function), makeToString:Ember.required(Function), resolveOther:Ember.required(Function), _logLookup:Ember.required(Function)});
__exports__.Resolver = Resolver;
var dictionary = __dependency8__["default"];
__exports__["default"] = EmberObject.extend({namespace:null, init:function() {
this._parseNameCache = dictionary(null);
}, normalize:function(fullName) {
var split = fullName.split(":", 2);
var type = split[0];
var name = split[1];
Ember.assert("Tried to normalize a container name without a colon (:) in it." + " You probably tried to lookup a name that did not contain a type," + " a colon, and a name. A proper lookup name would be `view:post`.", split.length === 2);
if (type !== "template") {
var result = name;
if (result.indexOf(".") > -1) {
result = result.replace(/\.(.)/g, function(m) {
return m.charAt(1).toUpperCase();
});
}
if (name.indexOf("_") > -1) {
result = result.replace(/_(.)/g, function(m) {
return m.charAt(1).toUpperCase();
});
}
return type + ":" + result;
} else {
return fullName;
}
}, resolve:function(fullName) {
var parsedName = this.parseName(fullName);
var resolveMethodName = parsedName.resolveMethodName;
var resolved;
if (!(parsedName.name && parsedName.type)) {
throw new TypeError("Invalid fullName: `" + fullName + "`, must be of the form `type:name` ");
}
if (this[resolveMethodName]) {
resolved = this[resolveMethodName](parsedName);
}
if (!resolved) {
resolved = this.resolveOther(parsedName);
}
if (parsedName.root && parsedName.root.LOG_RESOLVER) {
this._logLookup(resolved, parsedName);
}
return resolved;
}, parseName:function(fullName) {
return this._parseNameCache[fullName] || (this._parseNameCache[fullName] = this._parseName(fullName));
}, _parseName:function(fullName) {
var nameParts = fullName.split(":");
var type = nameParts[0], fullNameWithoutType = nameParts[1];
var name = fullNameWithoutType;
var namespace = get(this, "namespace");
var root = namespace;
if (type !== "template" && name.indexOf("/") !== -1) {
var parts = name.split("/");
name = parts[parts.length - 1];
var namespaceName = capitalize(parts.slice(0, -1).join("."));
root = Namespace.byName(namespaceName);
Ember.assert("You are looking for a " + name + " " + type + " in the " + namespaceName + " namespace, but the namespace could not be found", root);
}
return{fullName:fullName, type:type, fullNameWithoutType:fullNameWithoutType, name:name, root:root, resolveMethodName:"resolve" + classify(type)};
}, lookupDescription:function(fullName) {
var parsedName = this.parseName(fullName);
if (parsedName.type === "template") {
return "template at " + parsedName.fullNameWithoutType.replace(/\./g, "/");
}
var description = parsedName.root + "." + classify(parsedName.name);
if (parsedName.type !== "model") {
description += classify(parsedName.type);
}
return description;
}, makeToString:function(factory, fullName) {
return factory.toString();
}, useRouterNaming:function(parsedName) {
parsedName.name = parsedName.name.replace(/\./g, "_");
if (parsedName.name === "basic") {
parsedName.name = "";
}
}, resolveTemplate:function(parsedName) {
var templateName = parsedName.fullNameWithoutType.replace(/\./g, "/");
if (Ember.TEMPLATES[templateName]) {
return Ember.TEMPLATES[templateName];
}
templateName = decamelize(templateName);
if (Ember.TEMPLATES[templateName]) {
return Ember.TEMPLATES[templateName];
}
}, resolveView:function(parsedName) {
this.useRouterNaming(parsedName);
return this.resolveOther(parsedName);
}, resolveController:function(parsedName) {
this.useRouterNaming(parsedName);
return this.resolveOther(parsedName);
}, resolveRoute:function(parsedName) {
this.useRouterNaming(parsedName);
return this.resolveOther(parsedName);
}, resolveModel:function(parsedName) {
var className = classify(parsedName.name);
var factory = get(parsedName.root, className);
if (factory) {
return factory;
}
}, resolveHelper:function(parsedName) {
return this.resolveOther(parsedName) || EmberHandlebars.helpers[parsedName.fullNameWithoutType];
}, resolveOther:function(parsedName) {
var className = classify(parsedName.name) + classify(parsedName.type);
var factory = get(parsedName.root, className);
if (factory) {
return factory;
}
}, _logLookup:function(found, parsedName) {
var symbol, padding;
if (found) {
symbol = "[\u2713]";
} else {
symbol = "[ ]";
}
if (parsedName.fullName.length > 60) {
padding = ".";
} else {
padding = (new Array(60 - parsedName.fullName.length)).join(".");
}
Logger.info(symbol, parsedName.fullName, padding, this.lookupDescription(parsedName.fullName));
}});
});
enifed("ember-debug", ["ember-metal/core", "ember-metal/error", "ember-metal/logger", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
var Ember = __dependency1__["default"];
var EmberError = __dependency2__["default"];
var Logger = __dependency3__["default"];
Ember.assert = function(desc, test) {
if (!test) {
throw new EmberError("Assertion Failed: " + desc);
}
};
Ember.warn = function(message, test) {
if (!test) {
Logger.warn("WARNING: " + message);
if ("trace" in Logger) {
Logger.trace();
}
}
};
Ember.debug = function(message) {
Logger.debug("DEBUG: " + message);
};
Ember.deprecate = function(message, test) {
if (test) {
return;
}
if (Ember.ENV.RAISE_ON_DEPRECATION) {
throw new EmberError(message);
}
var error;
try {
__fail__.fail();
} catch (e) {
error = e;
}
if (Ember.LOG_STACKTRACE_ON_DEPRECATION && error.stack) {
var stack;
var stackStr = "";
if (error["arguments"]) {
stack = error.stack.replace(/^\s+at\s+/gm, "").replace(/^([^\(]+?)([\n$])/gm, "{anonymous}($1)$2").replace(/^Object.
\s*\(([^\)]+)\)/gm, "{anonymous}($1)").split("\n");
stack.shift();
} else {
stack = error.stack.replace(/(?:\n@:0)?\s+$/m, "").replace(/^\(/gm, "{anonymous}(").split("\n");
}
stackStr = "\n " + stack.slice(2).join("\n ");
message = message + stackStr;
}
Logger.warn("DEPRECATION: " + message);
};
Ember.deprecateFunc = function(message, func) {
return function() {
Ember.deprecate(message);
return func.apply(this, arguments);
};
};
Ember.runInDebug = function(func) {
func();
};
function _warnIfUsingStrippedFeatureFlags(FEATURES, featuresWereStripped) {
if (featuresWereStripped) {
Ember.warn("Ember.ENV.ENABLE_ALL_FEATURES is only available in canary builds.", !Ember.ENV.ENABLE_ALL_FEATURES);
Ember.warn("Ember.ENV.ENABLE_OPTIONAL_FEATURES is only available in canary builds.", !Ember.ENV.ENABLE_OPTIONAL_FEATURES);
for (var key in FEATURES) {
if (FEATURES.hasOwnProperty(key) && key !== "isEnabled") {
Ember.warn('FEATURE["' + key + '"] is set as enabled, but FEATURE flags are only available in canary builds.', !FEATURES[key]);
}
}
}
}
__exports__._warnIfUsingStrippedFeatureFlags = _warnIfUsingStrippedFeatureFlags;
if (!Ember.testing) {
Ember.FEATURES["features-stripped-test"] = true;
var featuresWereStripped = true;
delete Ember.FEATURES["features-stripped-test"];
_warnIfUsingStrippedFeatureFlags(Ember.ENV.FEATURES, featuresWereStripped);
var isFirefox = typeof InstallTrigger !== "undefined";
var isChrome = !!window.chrome && !window.opera;
if (typeof window !== "undefined" && ((isFirefox || isChrome) && window.addEventListener)) {
window.addEventListener("load", function() {
if (document.documentElement && (document.documentElement.dataset && !document.documentElement.dataset.emberExtension)) {
var downloadURL;
if (isChrome) {
downloadURL = "https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi";
} else {
if (isFirefox) {
downloadURL = "https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/";
}
}
Ember.debug("For more advanced debugging, install the Ember Inspector from " + downloadURL);
}
}, false);
}
}
});
enifed("ember-extension-support", ["ember-metal/core", "ember-extension-support/data_adapter", "ember-extension-support/container_debug_adapter"], function(__dependency1__, __dependency2__, __dependency3__) {
var Ember = __dependency1__["default"];
var DataAdapter = __dependency2__["default"];
var ContainerDebugAdapter = __dependency3__["default"];
Ember.DataAdapter = DataAdapter;
Ember.ContainerDebugAdapter = ContainerDebugAdapter;
});
enifed("ember-extension-support/container_debug_adapter", ["ember-metal/core", "ember-runtime/system/native_array", "ember-metal/utils", "ember-runtime/system/string", "ember-runtime/system/namespace", "ember-runtime/system/object", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
var Ember = __dependency1__["default"];
var emberA = __dependency2__.A;
var typeOf = __dependency3__.typeOf;
var dasherize = __dependency4__.dasherize;
var classify = __dependency4__.classify;
var Namespace = __dependency5__["default"];
var EmberObject = __dependency6__["default"];
__exports__["default"] = EmberObject.extend({container:null, resolver:null, canCatalogEntriesByType:function(type) {
if (type === "model" || type === "template") {
return false;
}
return true;
}, catalogEntriesByType:function(type) {
var namespaces = emberA(Namespace.NAMESPACES), types = emberA();
var typeSuffixRegex = new RegExp(classify(type) + "$");
namespaces.forEach(function(namespace) {
if (namespace !== Ember) {
for (var key in namespace) {
if (!namespace.hasOwnProperty(key)) {
continue;
}
if (typeSuffixRegex.test(key)) {
var klass = namespace[key];
if (typeOf(klass) === "class") {
types.push(dasherize(key.replace(typeSuffixRegex, "")));
}
}
}
}
});
return types;
}});
});
enifed("ember-extension-support/data_adapter", ["ember-metal/core", "ember-metal/property_get", "ember-metal/run_loop", "ember-runtime/system/string", "ember-runtime/system/namespace", "ember-runtime/system/object", "ember-runtime/system/native_array", "ember-application/system/application", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
var Ember = __dependency1__["default"];
var get = __dependency2__.get;
var run = __dependency3__["default"];
var dasherize = __dependency4__.dasherize;
var Namespace = __dependency5__["default"];
var EmberObject = __dependency6__["default"];
var emberA = __dependency7__.A;
var Application = __dependency8__["default"];
__exports__["default"] = EmberObject.extend({init:function() {
this._super();
this.releaseMethods = emberA();
}, container:null, containerDebugAdapter:undefined, attributeLimit:3, releaseMethods:emberA(), getFilters:function() {
return emberA();
}, watchModelTypes:function(typesAdded, typesUpdated) {
var modelTypes = this.getModelTypes();
var self = this;
var releaseMethods = emberA();
var typesToSend;
typesToSend = modelTypes.map(function(type) {
var klass = type.klass;
var wrapped = self.wrapModelType(klass, type.name);
releaseMethods.push(self.observeModelType(klass, typesUpdated));
return wrapped;
});
typesAdded(typesToSend);
var release = function() {
releaseMethods.forEach(function(fn) {
fn();
});
self.releaseMethods.removeObject(release);
};
this.releaseMethods.pushObject(release);
return release;
}, _nameToClass:function(type) {
if (typeof type === "string") {
type = this.container.lookupFactory("model:" + type);
}
return type;
}, watchRecords:function(type, recordsAdded, recordsUpdated, recordsRemoved) {
var self = this, releaseMethods = emberA(), records = this.getRecords(type), release;
var recordUpdated = function(updatedRecord) {
recordsUpdated([updatedRecord]);
};
var recordsToSend = records.map(function(record) {
releaseMethods.push(self.observeRecord(record, recordUpdated));
return self.wrapRecord(record);
});
var contentDidChange = function(array, idx, removedCount, addedCount) {
for (var i = idx;i < idx + addedCount;i++) {
var record = array.objectAt(i);
var wrapped = self.wrapRecord(record);
releaseMethods.push(self.observeRecord(record, recordUpdated));
recordsAdded([wrapped]);
}
if (removedCount) {
recordsRemoved(idx, removedCount);
}
};
var observer = {didChange:contentDidChange, willChange:Ember.K};
records.addArrayObserver(self, observer);
release = function() {
releaseMethods.forEach(function(fn) {
fn();
});
records.removeArrayObserver(self, observer);
self.releaseMethods.removeObject(release);
};
recordsAdded(recordsToSend);
this.releaseMethods.pushObject(release);
return release;
}, willDestroy:function() {
this._super();
this.releaseMethods.forEach(function(fn) {
fn();
});
}, detect:function(klass) {
return false;
}, columnsForType:function(type) {
return emberA();
}, observeModelType:function(type, typesUpdated) {
var self = this;
var records = this.getRecords(type);
var onChange = function() {
typesUpdated([self.wrapModelType(type)]);
};
var observer = {didChange:function() {
run.scheduleOnce("actions", this, onChange);
}, willChange:Ember.K};
records.addArrayObserver(this, observer);
var release = function() {
records.removeArrayObserver(self, observer);
};
return release;
}, wrapModelType:function(type, name) {
var records = this.getRecords(type);
var typeToSend;
typeToSend = {name:name || type.toString(), count:get(records, "length"), columns:this.columnsForType(type), object:type};
return typeToSend;
}, getModelTypes:function() {
var self = this;
var containerDebugAdapter = this.get("containerDebugAdapter");
var types;
if (containerDebugAdapter.canCatalogEntriesByType("model")) {
types = containerDebugAdapter.catalogEntriesByType("model");
} else {
types = this._getObjectsOnNamespaces();
}
types = emberA(types).map(function(name) {
return{klass:self._nameToClass(name), name:name};
});
types = emberA(types).filter(function(type) {
return self.detect(type.klass);
});
return emberA(types);
}, _getObjectsOnNamespaces:function() {
var namespaces = emberA(Namespace.NAMESPACES);
var types = emberA();
var self = this;
namespaces.forEach(function(namespace) {
for (var key in namespace) {
if (!namespace.hasOwnProperty(key)) {
continue;
}
if (!self.detect(namespace[key])) {
continue;
}
var name = dasherize(key);
if (!(namespace instanceof Application) && namespace.toString()) {
name = namespace + "/" + name;
}
types.push(name);
}
});
return types;
}, getRecords:function(type) {
return emberA();
}, wrapRecord:function(record) {
var recordToSend = {object:record};
recordToSend.columnValues = this.getRecordColumnValues(record);
recordToSend.searchKeywords = this.getRecordKeywords(record);
recordToSend.filterValues = this.getRecordFilterValues(record);
recordToSend.color = this.getRecordColor(record);
return recordToSend;
}, getRecordColumnValues:function(record) {
return{};
}, getRecordKeywords:function(record) {
return emberA();
}, getRecordFilterValues:function(record) {
return{};
}, getRecordColor:function(record) {
return null;
}, observeRecord:function(record, recordUpdated) {
return function() {
};
}});
});
enifed("ember-extension-support/initializers", [], function() {
});
enifed("ember-handlebars-compiler", ["ember-metal/core", "exports"], function(__dependency1__, __exports__) {
var Ember = __dependency1__["default"];
if (typeof Ember.assert === "undefined") {
Ember.assert = function() {
};
}
if (typeof Ember.FEATURES === "undefined") {
Ember.FEATURES = {isEnabled:function() {
}};
}
var objectCreate = Object.create || function(parent) {
function F() {
}
F.prototype = parent;
return new F;
};
var View, Component;
var Handlebars = Ember.imports && Ember.imports.Handlebars || this && this.Handlebars;
if (!Handlebars && typeof eriuqer === "function") {
Handlebars = eriuqer("handlebars");
}
Ember.assert("Ember Handlebars requires Handlebars version 2.0. Include " + "a SCRIPT tag in the HTML HEAD linking to the Handlebars file " + "before you link to Ember.", Handlebars);
Ember.assert("Ember Handlebars requires Handlebars version 2.0. " + "Please see more details at http://emberjs.com/blog/2014/10/16/handlebars-update.html.", Handlebars.COMPILER_REVISION === 6);
var EmberHandlebars = Ember.Handlebars = Handlebars.create();
EmberHandlebars.helper = function(name, value) {
if (!View) {
View = requireModule("ember-views/views/view")["default"];
}
if (!Component) {
Component = requireModule("ember-views/views/component")["default"];
}
Ember.assert("You tried to register a component named '" + name + "', but component names must include a '-'", !Component.detect(value) || name.match(/-/));
if (View.detect(value)) {
EmberHandlebars.registerHelper(name, EmberHandlebars.makeViewHelper(value));
} else {
EmberHandlebars.registerBoundHelper.apply(null, arguments);
}
};
EmberHandlebars.makeViewHelper = function(ViewClass) {
return function(options) {
Ember.assert("You can only pass attributes (such as name=value) not bare " + "values to a helper for a View found in '" + ViewClass.toString() + "'", arguments.length < 2);
return EmberHandlebars.helpers.view.call(this, ViewClass, options);
};
};
EmberHandlebars.helpers = objectCreate(Handlebars.helpers);
EmberHandlebars.Compiler = function() {
};
if (Handlebars.Compiler) {
EmberHandlebars.Compiler.prototype = objectCreate(Handlebars.Compiler.prototype);
}
EmberHandlebars.Compiler.prototype.compiler = EmberHandlebars.Compiler;
EmberHandlebars.JavaScriptCompiler = function() {
};
if (Handlebars.JavaScriptCompiler) {
EmberHandlebars.JavaScriptCompiler.prototype = objectCreate(Handlebars.JavaScriptCompiler.prototype);
EmberHandlebars.JavaScriptCompiler.prototype.compiler = EmberHandlebars.JavaScriptCompiler;
}
EmberHandlebars.JavaScriptCompiler.prototype.namespace = "Ember.Handlebars";
EmberHandlebars.JavaScriptCompiler.prototype.initializeBuffer = function() {
return "''";
};
EmberHandlebars.JavaScriptCompiler.prototype.appendToBuffer = function(string) {
return "data.buffer.push(" + string + ");";
};
EmberHandlebars.Compiler.prototype.mustache = function(mustache) {
if (!(mustache.params.length || mustache.hash)) {
var id = new Handlebars.AST.IdNode([{part:"_triageMustache"}]);
if (!mustache.escaped) {
mustache.hash = mustache.hash || new Handlebars.AST.HashNode([]);
mustache.hash.pairs.push(["unescaped", new Handlebars.AST.StringNode("true")]);
}
mustache = new Handlebars.AST.MustacheNode([id].concat([mustache.id]), mustache.hash, !mustache.escaped);
}
return Handlebars.Compiler.prototype.mustache.call(this, mustache);
};
EmberHandlebars.precompile = function(value, asObject) {
var ast = Handlebars.parse(value);
var options = {knownHelpers:{action:true, unbound:true, "bind-attr":true, template:true, view:true, _triageMustache:true}, data:true, stringParams:true};
asObject = asObject === undefined ? true : asObject;
var environment = (new EmberHandlebars.Compiler).compile(ast, options);
return(new EmberHandlebars.JavaScriptCompiler).compile(environment, options, undefined, asObject);
};
if (Handlebars.compile) {
EmberHandlebars.compile = function(string) {
var ast = Handlebars.parse(string);
var options = {data:true, stringParams:true};
var environment = (new EmberHandlebars.Compiler).compile(ast, options);
var templateSpec = (new EmberHandlebars.JavaScriptCompiler).compile(environment, options, undefined, true);
var template = EmberHandlebars.template(templateSpec);
template.isMethod = false;
return template;
};
}
__exports__["default"] = EmberHandlebars;
});
enifed("ember-handlebars", ["ember-handlebars-compiler", "ember-metal/core", "ember-runtime/system/lazy_load", "ember-handlebars/loader", "ember-handlebars/ext", "ember-handlebars/string", "ember-handlebars/helpers/binding", "ember-handlebars/helpers/if_unless", "ember-handlebars/helpers/with", "ember-handlebars/helpers/bind_attr", "ember-handlebars/helpers/collection", "ember-handlebars/helpers/view", "ember-handlebars/helpers/unbound", "ember-handlebars/helpers/debug", "ember-handlebars/helpers/each",
"ember-handlebars/helpers/template", "ember-handlebars/helpers/partial", "ember-handlebars/helpers/yield", "ember-handlebars/helpers/loc", "ember-handlebars/controls/checkbox", "ember-handlebars/controls/select", "ember-handlebars/controls/text_area", "ember-handlebars/controls/text_field", "ember-handlebars/controls/text_support", "ember-handlebars/controls", "ember-handlebars/component_lookup", "ember-handlebars/views/handlebars_bound_view", "ember-handlebars/views/metamorph_view", "exports"],
function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __dependency21__, __dependency22__, __dependency23__, __dependency24__, __dependency25__, __dependency26__, __dependency27__, __dependency28__,
__exports__) {
var EmberHandlebars = __dependency1__["default"];
var Ember = __dependency2__["default"];
var runLoadHooks = __dependency3__.runLoadHooks;
var bootstrap = __dependency4__["default"];
var makeBoundHelper = __dependency5__.makeBoundHelper;
var registerBoundHelper = __dependency5__.registerBoundHelper;
var helperMissingHelper = __dependency5__.helperMissingHelper;
var blockHelperMissingHelper = __dependency5__.blockHelperMissingHelper;
var handlebarsGet = __dependency5__.handlebarsGet;
var bind = __dependency7__.bind;
var _triageMustacheHelper = __dependency7__._triageMustacheHelper;
var resolveHelper = __dependency7__.resolveHelper;
var bindHelper = __dependency7__.bindHelper;
var ifHelper = __dependency8__.ifHelper;
var boundIfHelper = __dependency8__.boundIfHelper;
var unboundIfHelper = __dependency8__.unboundIfHelper;
var unlessHelper = __dependency8__.unlessHelper;
var withHelper = __dependency9__["default"];
var bindAttrHelper = __dependency10__.bindAttrHelper;
var bindAttrHelperDeprecated = __dependency10__.bindAttrHelperDeprecated;
var bindClasses = __dependency10__.bindClasses;
var collectionHelper = __dependency11__["default"];
var ViewHelper = __dependency12__.ViewHelper;
var viewHelper = __dependency12__.viewHelper;
var unboundHelper = __dependency13__["default"];
var logHelper = __dependency14__.logHelper;
var debuggerHelper = __dependency14__.debuggerHelper;
var EachView = __dependency15__.EachView;
var eachHelper = __dependency15__.eachHelper;
var templateHelper = __dependency16__["default"];
var partialHelper = __dependency17__["default"];
var yieldHelper = __dependency18__["default"];
var locHelper = __dependency19__["default"];
var Checkbox = __dependency20__["default"];
var Select = __dependency21__.Select;
var SelectOption = __dependency21__.SelectOption;
var SelectOptgroup = __dependency21__.SelectOptgroup;
var TextArea = __dependency22__["default"];
var TextField = __dependency23__["default"];
var TextSupport = __dependency24__["default"];
var inputHelper = __dependency25__.inputHelper;
var textareaHelper = __dependency25__.textareaHelper;
var ComponentLookup = __dependency26__["default"];
var _HandlebarsBoundView = __dependency27__._HandlebarsBoundView;
var SimpleHandlebarsView = __dependency27__.SimpleHandlebarsView;
var _MetamorphView = __dependency28__["default"];
var _SimpleMetamorphView = __dependency28__._SimpleMetamorphView;
var _Metamorph = __dependency28__._Metamorph;
EmberHandlebars.bootstrap = bootstrap;
EmberHandlebars.makeBoundHelper = makeBoundHelper;
EmberHandlebars.registerBoundHelper = registerBoundHelper;
EmberHandlebars.resolveHelper = resolveHelper;
EmberHandlebars.bind = bind;
EmberHandlebars.bindClasses = bindClasses;
EmberHandlebars.EachView = EachView;
EmberHandlebars.ViewHelper = ViewHelper;
Ember.Handlebars = EmberHandlebars;
EmberHandlebars.get = handlebarsGet;
Ember.ComponentLookup = ComponentLookup;
Ember._SimpleHandlebarsView = SimpleHandlebarsView;
Ember._HandlebarsBoundView = _HandlebarsBoundView;
Ember._SimpleMetamorphView = _SimpleMetamorphView;
Ember._MetamorphView = _MetamorphView;
Ember._Metamorph = _Metamorph;
Ember.TextSupport = TextSupport;
Ember.Checkbox = Checkbox;
Ember.Select = Select;
Ember.SelectOption = SelectOption;
Ember.SelectOptgroup = SelectOptgroup;
Ember.TextArea = TextArea;
Ember.TextField = TextField;
Ember.TextSupport = TextSupport;
EmberHandlebars.registerHelper("helperMissing", helperMissingHelper);
EmberHandlebars.registerHelper("blockHelperMissing", blockHelperMissingHelper);
EmberHandlebars.registerHelper("bind", bindHelper);
EmberHandlebars.registerHelper("boundIf", boundIfHelper);
EmberHandlebars.registerHelper("_triageMustache", _triageMustacheHelper);
EmberHandlebars.registerHelper("unboundIf", unboundIfHelper);
EmberHandlebars.registerHelper("with", withHelper);
EmberHandlebars.registerHelper("if", ifHelper);
EmberHandlebars.registerHelper("unless", unlessHelper);
EmberHandlebars.registerHelper("bind-attr", bindAttrHelper);
EmberHandlebars.registerHelper("bindAttr", bindAttrHelperDeprecated);
EmberHandlebars.registerHelper("collection", collectionHelper);
EmberHandlebars.registerHelper("log", logHelper);
EmberHandlebars.registerHelper("debugger", debuggerHelper);
EmberHandlebars.registerHelper("each", eachHelper);
EmberHandlebars.registerHelper("loc", locHelper);
EmberHandlebars.registerHelper("partial", partialHelper);
EmberHandlebars.registerHelper("template", templateHelper);
EmberHandlebars.registerHelper("yield", yieldHelper);
EmberHandlebars.registerHelper("view", viewHelper);
EmberHandlebars.registerHelper("unbound", unboundHelper);
EmberHandlebars.registerHelper("input", inputHelper);
EmberHandlebars.registerHelper("textarea", textareaHelper);
runLoadHooks("Ember.Handlebars", EmberHandlebars);
__exports__["default"] = EmberHandlebars;
});
enifed("ember-handlebars/component_lookup", ["ember-runtime/system/object", "exports"], function(__dependency1__, __exports__) {
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);
if (templateRegistered || Component) {
if (!Component) {
container.register(fullName, Ember.Component);
Component = container.lookupFactory(fullName);
}
return Component;
}
}});
});
enifed("ember-handlebars/controls", ["ember-handlebars/controls/checkbox", "ember-handlebars/controls/text_field", "ember-handlebars/controls/text_area", "ember-metal/core", "ember-handlebars-compiler", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
var Checkbox = __dependency1__["default"];
var TextField = __dependency2__["default"];
var TextArea = __dependency3__["default"];
var Ember = __dependency4__["default"];
var EmberHandlebars = __dependency5__["default"];
function inputHelper(options) {
Ember.assert("You can only pass attributes to the `input` helper, not arguments", arguments.length < 2);
var view = options.data.view;
var hash = options.hash;
var types = options.hashTypes;
var onEvent = hash.on;
var inputType;
if (types.type === "ID") {
inputType = view.getStream(hash.type).value();
} else {
inputType = hash.type;
}
if (inputType === "checkbox") {
delete hash.type;
delete types.type;
Ember.assert("{{input type='checkbox'}} does not support setting `value=someBooleanValue`;" + " you must use `checked=someBooleanValue` instead.", options.hashTypes.value !== "ID");
return EmberHandlebars.helpers.view.call(this, Checkbox, options);
} else {
delete hash.on;
hash.onEvent = onEvent || "enter";
return EmberHandlebars.helpers.view.call(this, TextField, options);
}
}
__exports__.inputHelper = inputHelper;
function textareaHelper(options) {
Ember.assert("You can only pass attributes to the `textarea` helper, not arguments", arguments.length < 2);
return EmberHandlebars.helpers.view.call(this, TextArea, options);
}
__exports__.textareaHelper = textareaHelper;
});
enifed("ember-handlebars/controls/checkbox", ["ember-metal/property_get", "ember-metal/property_set", "ember-views/views/view", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
var get = __dependency1__.get;
var set = __dependency2__.set;
var View = __dependency3__["default"];
__exports__["default"] = View.extend({instrumentDisplay:'{{input type="checkbox"}}', classNames:["ember-checkbox"], tagName:"input", attributeBindings:["type", "checked", "indeterminate", "disabled", "tabindex", "name", "autofocus", "required", "form"], type:"checkbox", checked:false, disabled:false, indeterminate:false, init:function() {
this._super();
this.on("change", this, this._updateElementValue);
}, didInsertElement:function() {
this._super();
get(this, "element").indeterminate = !!get(this, "indeterminate");
}, _updateElementValue:function() {
set(this, "checked", this.$().prop("checked"));
}});
});
enifed("ember-handlebars/controls/select", ["ember-handlebars-compiler", "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", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__,
__dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __exports__) {
var EmberHandlebars = __dependency1__["default"];
var forEach = __dependency2__.forEach;
var indexOf = __dependency2__.indexOf;
var indexesOf = __dependency2__.indexesOf;
var replace = __dependency2__.replace;
var get = __dependency3__.get;
var set = __dependency4__.set;
var View = __dependency5__["default"];
var CollectionView = __dependency6__["default"];
var isArray = __dependency7__.isArray;
var isNone = __dependency8__["default"];
var computed = __dependency9__.computed;
var emberA = __dependency10__.A;
var observer = __dependency11__.observer;
var defineProperty = __dependency12__.defineProperty;
var SelectOption = View.extend({instrumentDisplay:"Ember.SelectOption", tagName:"option", attributeBindings:["value", "selected"], defaultTemplate:function(context, options) {
options = {data:options.data, hash:{}};
EmberHandlebars.helpers.bind.call(context, "view.label", options);
}, init:function() {
this.labelPathDidChange();
this.valuePathDidChange();
this._super();
}, selected:computed(function() {
var content = get(this, "content");
var selection = get(this, "parentView.selection");
if (get(this, "parentView.multiple")) {
return selection && indexOf(selection, content.valueOf()) > -1;
} else {
return content == selection;
}
}).property("content", "parentView.selection"), labelPathDidChange:observer("parentView.optionLabelPath", function() {
var labelPath = get(this, "parentView.optionLabelPath");
if (!labelPath) {
return;
}
defineProperty(this, "label", computed(function() {
return get(this, labelPath);
}).property(labelPath));
}), valuePathDidChange:observer("parentView.optionValuePath", function() {
var valuePath = get(this, "parentView.optionValuePath");
if (!valuePath) {
return;
}
defineProperty(this, "value", computed(function() {
return get(this, valuePath);
}).property(valuePath));
})});
var SelectOptgroup = CollectionView.extend({instrumentDisplay:"Ember.SelectOptgroup", tagName:"optgroup", attributeBindings:["label"], selectionBinding:"parentView.selection", multipleBinding:"parentView.multiple", optionLabelPathBinding:"parentView.optionLabelPath", optionValuePathBinding:"parentView.optionValuePath", itemViewClassBinding:"parentView.optionView"});
var Select = View.extend({instrumentDisplay:"Ember.Select", tagName:"select", classNames:["ember-select"], defaultTemplate:Ember.Handlebars.template({1:function(depth0, helpers, partials, data) {
var stack1, buffer = "";
data.buffer.push('");
return buffer;
}, 3:function(depth0, helpers, partials, data) {
var stack1;
stack1 = helpers.each.call(depth0, "group", "in", "view.groupedContent", {"name":"each", "hash":{}, "hashTypes":{}, "hashContexts":{}, "fn":this.program(4, data), "inverse":this.noop, "types":["ID", "ID", "ID"], "contexts":[depth0, depth0, depth0], "data":data});
if (stack1 != null) {
data.buffer.push(stack1);
} else {
data.buffer.push("");
}
}, 4:function(depth0, helpers, partials, data) {
var escapeExpression = this.escapeExpression;
data.buffer.push(escapeExpression(helpers.view.call(depth0, "view.groupView", {"name":"view", "hash":{"label":"group.label", "content":"group.content"}, "hashTypes":{"label":"ID", "content":"ID"}, "hashContexts":{"label":depth0, "content":depth0}, "types":["ID"], "contexts":[depth0], "data":data})));
}, 6:function(depth0, helpers, partials, data) {
var stack1;
stack1 = helpers.each.call(depth0, "item", "in", "view.content", {"name":"each", "hash":{}, "hashTypes":{}, "hashContexts":{}, "fn":this.program(7, data), "inverse":this.noop, "types":["ID", "ID", "ID"], "contexts":[depth0, depth0, depth0], "data":data});
if (stack1 != null) {
data.buffer.push(stack1);
} else {
data.buffer.push("");
}
}, 7:function(depth0, helpers, partials, data) {
var escapeExpression = this.escapeExpression;
data.buffer.push(escapeExpression(helpers.view.call(depth0, "view.optionView", {"name":"view", "hash":{"content":"item"}, "hashTypes":{"content":"ID"}, "hashContexts":{"content":depth0}, "types":["ID"], "contexts":[depth0], "data":data})));
}, "compiler":[6, ">= 2.0.0-beta.1"], "main":function(depth0, helpers, partials, data) {
var stack1, buffer = "";
stack1 = helpers["if"].call(depth0, "view.prompt", {"name":"if", "hash":{}, "hashTypes":{}, "hashContexts":{}, "fn":this.program(1, data), "inverse":this.noop, "types":["ID"], "contexts":[depth0], "data":data});
if (stack1 != null) {
data.buffer.push(stack1);
}
stack1 = helpers["if"].call(depth0, "view.optionGroupPath", {"name":"if", "hash":{}, "hashTypes":{}, "hashContexts":{}, "fn":this.program(3, data), "inverse":this.program(6, data), "types":["ID"], "contexts":[depth0], "data":data});
if (stack1 != null) {
data.buffer.push(stack1);
}
return buffer;
}, "useData":true}), attributeBindings:["multiple", "disabled", "tabindex", "name", "required", "autofocus", "form", "size"], multiple:false, disabled:false, required:false, content:null, selection:null, value:computed(function(key, value) {
if (arguments.length === 2) {
return value;
}
var valuePath = get(this, "optionValuePath").replace(/^content\.?/, "");
return valuePath ? get(this, "selection." + valuePath) : get(this, "selection");
}).property("selection"), prompt:null, optionLabelPath:"content", optionValuePath:"content", optionGroupPath:null, groupView:SelectOptgroup, groupedContent:computed(function() {
var groupPath = get(this, "optionGroupPath");
var groupedContent = emberA();
var content = get(this, "content") || [];
forEach(content, function(item) {
var label = get(item, groupPath);
if (get(groupedContent, "lastObject.label") !== label) {
groupedContent.pushObject({label:label, content:emberA()});
}
get(groupedContent, "lastObject.content").push(item);
});
return groupedContent;
}).property("optionGroupPath", "content.@each"), optionView:SelectOption, _change:function() {
if (get(this, "multiple")) {
this._changeMultiple();
} else {
this._changeSingle();
}
}, selectionDidChange:observer("selection.@each", function() {
var selection = get(this, "selection");
if (get(this, "multiple")) {
if (!isArray(selection)) {
set(this, "selection", emberA([selection]));
return;
}
this._selectionDidChangeMultiple();
} else {
this._selectionDidChangeSingle();
}
}), valueDidChange:observer("value", function() {
var content = get(this, "content");
var value = get(this, "value");
var valuePath = get(this, "optionValuePath").replace(/^content\.?/, "");
var selectedValue = valuePath ? get(this, "selection." + valuePath) : get(this, "selection");
var selection;
if (value !== selectedValue) {
selection = content ? content.find(function(obj) {
return value === (valuePath ? get(obj, valuePath) : obj);
}) : null;
this.set("selection", selection);
}
}), _triggerChange:function() {
var selection = get(this, "selection");
var value = get(this, "value");
if (!isNone(selection)) {
this.selectionDidChange();
}
if (!isNone(value)) {
this.valueDidChange();
}
this._change();
}, _changeSingle:function() {
var selectedIndex = this.$()[0].selectedIndex;
var content = get(this, "content");
var prompt = get(this, "prompt");
if (!content || !get(content, "length")) {
return;
}
if (prompt && selectedIndex === 0) {
set(this, "selection", null);
return;
}
if (prompt) {
selectedIndex -= 1;
}
set(this, "selection", content.objectAt(selectedIndex));
}, _changeMultiple:function() {
var options = this.$("option:selected");
var prompt = get(this, "prompt");
var offset = prompt ? 1 : 0;
var content = get(this, "content");
var selection = get(this, "selection");
if (!content) {
return;
}
if (options) {
var selectedIndexes = options.map(function() {
return this.index - offset;
}).toArray();
var newSelection = content.objectsAt(selectedIndexes);
if (isArray(selection)) {
replace(selection, 0, get(selection, "length"), newSelection);
} else {
set(this, "selection", newSelection);
}
}
}, _selectionDidChangeSingle:function() {
var el = this.get("element");
if (!el) {
return;
}
var content = get(this, "content");
var selection = get(this, "selection");
var selectionIndex = content ? indexOf(content, selection) : -1;
var prompt = get(this, "prompt");
if (prompt) {
selectionIndex += 1;
}
if (el) {
el.selectedIndex = selectionIndex;
}
}, _selectionDidChangeMultiple:function() {
var content = get(this, "content");
var selection = get(this, "selection");
var selectedIndexes = content ? indexesOf(content, selection) : [-1];
var prompt = get(this, "prompt");
var offset = prompt ? 1 : 0;
var options = this.$("option");
var adjusted;
if (options) {
options.each(function() {
adjusted = this.index > -1 ? this.index - offset : -1;
this.selected = indexOf(selectedIndexes, adjusted) > -1;
});
}
}, init:function() {
this._super();
this.on("didInsertElement", this, this._triggerChange);
this.on("change", this, this._change);
}});
__exports__["default"] = Select;
__exports__.Select = Select;
__exports__.SelectOption = SelectOption;
__exports__.SelectOptgroup = SelectOptgroup;
});
enifed("ember-handlebars/controls/text_area", ["ember-metal/property_get", "ember-views/views/component", "ember-handlebars/controls/text_support", "ember-metal/mixin", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
var get = __dependency1__.get;
var Component = __dependency2__["default"];
var TextSupport = __dependency3__["default"];
var observer = __dependency4__.observer;
__exports__["default"] = Component.extend(TextSupport, {instrumentDisplay:"{{textarea}}", classNames:["ember-text-area"], tagName:"textarea", attributeBindings:["rows", "cols", "name", "selectionEnd", "selectionStart", "wrap", "lang", "dir"], rows:null, cols:null, _updateElementValue:observer("value", function() {
var value = get(this, "value");
var $el = this.$();
if ($el && value !== $el.val()) {
$el.val(value);
}
}), init:function() {
this._super();
this.on("didInsertElement", this, this._updateElementValue);
}});
});
enifed("ember-handlebars/controls/text_field", ["ember-views/views/component", "ember-handlebars/controls/text_support", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var Component = __dependency1__["default"];
var TextSupport = __dependency2__["default"];
__exports__["default"] = Component.extend(TextSupport, {instrumentDisplay:'{{input type="text"}}', classNames:["ember-text-field"], tagName:"input", attributeBindings:["accept", "autocomplete", "autosave", "dir", "formaction", "formenctype", "formmethod", "formnovalidate", "formtarget", "height", "inputmode", "lang", "list", "max", "min", "multiple", "name", "pattern", "size", "step", "type", "value", "width"], value:"", type:"text", size:null, pattern:null, min:null, max:null});
});
enifed("ember-handlebars/controls/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__) {
var get = __dependency1__.get;
var set = __dependency2__.set;
var Mixin = __dependency3__.Mixin;
var TargetActionSupport = __dependency4__["default"];
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);
}, action:null, onEvent:"enter", 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());
}, insertNewline:function(event) {
sendAction("enter", this, event);
sendAction("insert-newline", this, event);
}, cancel:function(event) {
sendAction("escape-press", this, event);
}, change:function(event) {
this._elementValueDidChange(event);
}, focusIn:function(event) {
sendAction("focus-in", this, event);
}, focusOut:function(event) {
this._elementValueDidChange(event);
sendAction("focus-out", this, event);
}, keyPress:function(event) {
sendAction("key-press", this, event);
}, keyUp:function(event) {
this.interpretKeyEvents(event);
this.sendAction("key-up", get(this, "value"), event);
}, keyDown:function(event) {
this.sendAction("key-down", get(this, "value"), event);
}});
TextSupport.KEY_EVENTS = {13:"insertNewline", 27:"cancel"};
function sendAction(eventName, view, event) {
var action = get(view, eventName);
var on = get(view, "onEvent");
var value = get(view, "value");
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-handlebars/ext", ["ember-metal/core", "ember-runtime/system/string", "ember-handlebars-compiler", "ember-metal/property_get", "ember-metal/error", "ember-metal/mixin", "ember-views/views/view", "ember-metal/path_cache", "ember-metal/streams/stream", "ember-metal/streams/read", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __exports__) {
var Ember = __dependency1__["default"];
var fmt = __dependency2__.fmt;
var EmberHandlebars = __dependency3__["default"];
var get = __dependency4__.get;
var EmberError = __dependency5__["default"];
var IS_BINDING = __dependency6__.IS_BINDING;
var View = __dependency7__["default"];
var detectIsGlobal = __dependency8__.isGlobal;
var resolveHelper, SimpleHandlebarsView;
var Stream = __dependency9__["default"];
var readArray = __dependency10__.readArray;
var readHash = __dependency10__.readHash;
var slice = [].slice;
function handlebarsGet(root, path, options) {
Ember.deprecate("Usage of Ember.Handlebars.get is deprecated, use a Component or Ember.Handlebars.makeBoundHelper instead.");
return options.data.view.getStream(path).value();
}
function handlebarsGetView(context, path, container, data) {
var viewClass;
if ("string" === typeof path) {
if (!data) {
throw new Error("handlebarsGetView: must pass data");
}
var lazyValue = data.view.getStream(path);
viewClass = lazyValue.value();
var isGlobal = detectIsGlobal(path);
if (!viewClass && !isGlobal) {
Ember.assert("View requires a container to resolve views not passed in through the context", !!container);
viewClass = container.lookupFactory("view:" + path);
}
if (!viewClass && isGlobal) {
var globalViewClass = get(path);
Ember.deprecate('Resolved the view "' + path + '" on the global context. Pass a view name to be looked' + ' up on the container instead, such as {{view "select"}}.' + " http://emberjs.com/guides/deprecations#toc_global-lookup-of-views", !globalViewClass);
if (globalViewClass) {
viewClass = globalViewClass;
}
}
} else {
viewClass = path;
}
if ("string" === typeof viewClass && (data && data.view)) {
viewClass = handlebarsGetView(data.view, viewClass, container, data);
}
Ember.assert(fmt(path + " must be a subclass of Ember.View, not %@", [viewClass]), View.detect(viewClass));
return viewClass;
}
function stringifyValue(value, shouldEscape) {
if (value === null || value === undefined) {
value = "";
} else {
if (!(value instanceof Handlebars.SafeString)) {
value = String(value);
}
}
if (shouldEscape) {
value = Handlebars.Utils.escapeExpression(value);
}
return value;
}
__exports__.stringifyValue = stringifyValue;
function helperMissingHelper(path) {
if (!resolveHelper) {
resolveHelper = requireModule("ember-handlebars/helpers/binding")["resolveHelper"];
}
var error, fmtError, view = "";
var options = arguments[arguments.length - 1];
var helper = resolveHelper(options.data.view.container, options.name);
if (helper) {
return helper.apply(this, arguments);
}
if (options.data) {
view = options.data.view;
}
if (options.name.match(/-/)) {
error = "%@ Handlebars error: Could not find component or helper named '%@'";
fmtError = fmt(error, [view, options.name]);
} else {
error = "%@ Handlebars error: Could not find property '%@' on object %@.";
fmtError = fmt(error, [view, options.name, this]);
}
throw new EmberError(fmtError);
}
__exports__.helperMissingHelper = helperMissingHelper;
function blockHelperMissingHelper() {
return;
}
__exports__.blockHelperMissingHelper = blockHelperMissingHelper;
function registerBoundHelper(name, fn) {
var boundHelperArgs = slice.call(arguments, 1);
var boundFn = makeBoundHelper.apply(this, boundHelperArgs);
EmberHandlebars.registerHelper(name, boundFn);
}
__exports__.registerBoundHelper = registerBoundHelper;
function makeBoundHelper(fn) {
if (!SimpleHandlebarsView) {
SimpleHandlebarsView = requireModule("ember-handlebars/views/handlebars_bound_view")["SimpleHandlebarsView"];
}
var dependentKeys = [];
for (var i = 1;i < arguments.length;i++) {
dependentKeys.push(arguments[i]);
}
function helper() {
var numParams = arguments.length - 1;
var options = arguments[numParams];
var data = options.data;
var view = data.view;
var types = options.types;
var hash = options.hash;
var hashTypes = options.hashTypes;
var context = this;
Ember.assert("registerBoundHelper-generated helpers do not support use with Handlebars blocks.", !options.fn);
var properties = new Array(numParams);
var params = new Array(numParams);
for (var i = 0;i < numParams;i++) {
properties[i] = arguments[i];
if (types[i] === "ID") {
params[i] = view.getStream(arguments[i]);
} else {
params[i] = arguments[i];
}
}
for (var prop in hash) {
if (IS_BINDING.test(prop)) {
hash[prop.slice(0, -7)] = view.getStream(hash[prop]);
hash[prop] = undefined;
} else {
if (hashTypes[prop] === "ID") {
hash[prop] = view.getStream(hash[prop]);
}
}
}
var valueFn = function() {
var args = readArray(params);
args.push({hash:readHash(hash), data:{properties:properties}});
return fn.apply(context, args);
};
if (data.isUnbound) {
return valueFn();
} else {
var lazyValue = new Stream(valueFn);
var bindView = new SimpleHandlebarsView(lazyValue, !options.hash.unescaped);
view.appendChild(bindView);
var scheduledRerender = view._wrapAsScheduled(bindView.rerender);
lazyValue.subscribe(scheduledRerender, bindView);
var param;
for (i = 0;i < numParams;i++) {
param = params[i];
if (param && param.isStream) {
param.subscribe(lazyValue.notify, lazyValue);
}
}
for (prop in hash) {
param = hash[prop];
if (param && param.isStream) {
param.subscribe(lazyValue.notify, lazyValue);
}
}
if (numParams > 0) {
var firstParam = params[0];
if (firstParam && firstParam.isStream) {
var onDependentKeyNotify = function onDependentKeyNotify(stream) {
stream.value();
lazyValue.notify();
};
for (i = 0;i < dependentKeys.length;i++) {
var childParam = firstParam.get(dependentKeys[i]);
childParam.value();
childParam.subscribe(onDependentKeyNotify);
}
}
}
}
}
return helper;
}
__exports__.makeBoundHelper = makeBoundHelper;
__exports__.handlebarsGetView = handlebarsGetView;
__exports__.handlebarsGet = handlebarsGet;
});
enifed("ember-handlebars/helpers/bind_attr", ["ember-metal/core", "ember-handlebars-compiler", "ember-metal/utils", "ember-runtime/system/string", "ember-metal/array", "ember-views/views/view", "ember-metal/keys", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
var Ember = __dependency1__["default"];
var EmberHandlebars = __dependency2__["default"];
var uuid = __dependency3__.uuid;
var fmt = __dependency4__.fmt;
var typeOf = __dependency3__.typeOf;
var forEach = __dependency5__.forEach;
var View = __dependency6__["default"];
var keys = __dependency7__["default"];
var helpers = EmberHandlebars.helpers;
var SafeString = EmberHandlebars.SafeString;
function bindAttrHelper(options) {
var attrs = options.hash;
Ember.assert("You must specify at least one hash argument to bind-attr", !!keys(attrs).length);
var view = options.data.view;
var ret = [];
var ctx = this || window;
var dataId = uuid();
var classBindings = attrs["class"];
if (classBindings != null) {
var classResults = bindClasses(ctx, classBindings, view, dataId, options);
ret.push('class="' + Handlebars.Utils.escapeExpression(classResults.join(" ")) + '"');
delete attrs["class"];
}
var attrKeys = keys(attrs);
forEach.call(attrKeys, function(attr) {
var path = attrs[attr];
Ember.assert(fmt("You must provide an expression as the value of bound attribute." + " You specified: %@=%@", [attr, path]), typeof path === "string");
var lazyValue = view.getStream(path);
var value = lazyValue.value();
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"))));
lazyValue.subscribe(view._wrapAsScheduled(function applyAttributeBindings() {
var result = lazyValue.value();
Ember.assert(fmt("Attributes must be numbers, strings or booleans, not %@", [result]), result === null || (result === undefined || (typeof result === "number" || (typeof result === "string" || typeof result === "boolean"))));
var elem = view.$("[data-bindattr-" + dataId + "='" + dataId + "']");
Ember.assert("An attribute binding was triggered when the element was not in the DOM", elem && elem.length !== 0);
View.applyAttributeBindings(elem, attr, result);
}));
if (type === "string" || type === "number" && !isNaN(value)) {
ret.push(attr + '="' + Handlebars.Utils.escapeExpression(value) + '"');
} else {
if (value && type === "boolean") {
ret.push(attr + '="' + attr + '"');
}
}
}, this);
ret.push("data-bindattr-" + dataId + '="' + dataId + '"');
return new SafeString(ret.join(" "));
}
function bindAttrHelperDeprecated() {
Ember.deprecate("The 'bindAttr' view helper is deprecated in favor of 'bind-attr'");
return helpers["bind-attr"].apply(this, arguments);
}
function bindClasses(context, classBindings, view, bindAttrId, options) {
var ret = [];
var newClass, value, elem;
forEach.call(classBindings.split(" "), function(binding) {
var oldClass;
var parsedPath = View._parsePropertyPath(binding);
var path = parsedPath.path;
var initialValue;
if (path === "") {
initialValue = true;
} else {
var lazyValue = view.getStream(path);
initialValue = lazyValue.value();
lazyValue.subscribe(view._wrapAsScheduled(function applyClassNameBindings() {
var value = lazyValue.value();
newClass = classStringForParsedPath(parsedPath, value);
elem = bindAttrId ? view.$("[data-bindattr-" + bindAttrId + "='" + bindAttrId + "']") : view.$();
Ember.assert("A class name binding was triggered when the element was not in the DOM", elem && elem.length !== 0);
if (oldClass) {
elem.removeClass(oldClass);
}
if (newClass) {
elem.addClass(newClass);
oldClass = newClass;
} else {
oldClass = null;
}
}));
}
value = classStringForParsedPath(parsedPath, initialValue);
if (value) {
ret.push(value);
oldClass = value;
}
});
return ret;
}
function classStringForParsedPath(parsedPath, value) {
return View._classStringForValue(parsedPath.path, value, parsedPath.className, parsedPath.falsyClassName);
}
__exports__["default"] = bindAttrHelper;
__exports__.bindAttrHelper = bindAttrHelper;
__exports__.bindAttrHelperDeprecated = bindAttrHelperDeprecated;
__exports__.bindClasses = bindClasses;
});
enifed("ember-handlebars/helpers/binding", ["ember-metal/core", "ember-handlebars-compiler", "ember-metal/is_none", "ember-metal/run_loop", "ember-metal/cache", "ember-metal/streams/simple", "ember-handlebars/views/handlebars_bound_view", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
var Ember = __dependency1__["default"];
var EmberHandlebars = __dependency2__["default"];
var isNone = __dependency3__["default"];
var run = __dependency4__["default"];
var Cache = __dependency5__["default"];
var SimpleStream = __dependency6__["default"];
var _HandlebarsBoundView = __dependency7__._HandlebarsBoundView;
var SimpleHandlebarsView = __dependency7__.SimpleHandlebarsView;
var helpers = EmberHandlebars.helpers;
function exists(value) {
return!isNone(value);
}
function bind(property, options, preserveContext, shouldDisplay, valueNormalizer, childProperties, _viewClass) {
var data = options.data;
var view = data.view;
var currentContext = this || window;
var valueStream = view.getStream(property);
var lazyValue;
if (childProperties) {
lazyValue = new SimpleStream(valueStream);
var subscriber = function(childStream) {
childStream.value();
lazyValue.notify();
};
for (var i = 0;i < childProperties.length;i++) {
var childStream = valueStream.get(childProperties[i]);
childStream.value();
childStream.subscribe(subscriber);
}
} else {
lazyValue = valueStream;
}
var viewClass = _viewClass || _HandlebarsBoundView;
var viewOptions = {preserveContext:preserveContext, shouldDisplayFunc:shouldDisplay, valueNormalizerFunc:valueNormalizer, displayTemplate:options.fn, inverseTemplate:options.inverse, lazyValue:lazyValue, previousContext:currentContext, isEscaped:!options.hash.unescaped, templateData:options.data, templateHash:options.hash, helperName:options.helperName};
if (options.keywords) {
viewOptions._keywords = options.keywords;
}
var bindView = view.createChildView(viewClass, viewOptions);
view.appendChild(bindView);
lazyValue.subscribe(view._wrapAsScheduled(function() {
run.scheduleOnce("render", bindView, "rerenderIfNeeded");
}));
}
function simpleBind(currentContext, lazyValue, options) {
var data = options.data;
var view = data.view;
var bindView = new SimpleHandlebarsView(lazyValue, !options.hash.unescaped);
bindView._parentView = view;
view.appendChild(bindView);
lazyValue.subscribe(view._wrapAsScheduled(function() {
run.scheduleOnce("render", bindView, "rerender");
}));
}
function _triageMustacheHelper(property, options) {
Ember.assert("You cannot pass more than one argument to the _triageMustache helper", arguments.length <= 2);
var helper = EmberHandlebars.resolveHelper(options.data.view.container, property);
if (helper) {
return helper.call(this, options);
}
return helpers.bind.call(this, property, options);
}
var ISNT_HELPER_CACHE = new Cache(1E3, function(key) {
return key.indexOf("-") === -1;
});
__exports__.ISNT_HELPER_CACHE = ISNT_HELPER_CACHE;
function resolveHelper(container, name) {
if (helpers[name]) {
return helpers[name];
}
if (!container || ISNT_HELPER_CACHE.get(name)) {
return;
}
var helper = container.lookup("helper:" + name);
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 = EmberHandlebars.makeViewHelper(Component);
container.register("helper:" + name, helper);
}
}
return helper;
}
function bindHelper(property, options) {
Ember.assert("You cannot pass more than one argument to the bind helper", arguments.length <= 2);
var context = options.contexts && options.contexts.length ? options.contexts[0] : this;
if (!options.fn) {
var lazyValue = options.data.view.getStream(property);
return simpleBind(context, lazyValue, options);
}
options.helperName = "bind";
return bind.call(context, property, options, false, exists);
}
__exports__.bind = bind;
__exports__._triageMustacheHelper = _triageMustacheHelper;
__exports__.resolveHelper = resolveHelper;
__exports__.bindHelper = bindHelper;
});
enifed("ember-handlebars/helpers/collection", ["ember-metal/core", "ember-handlebars-compiler", "ember-metal/mixin", "ember-runtime/system/string", "ember-metal/property_get", "ember-metal/streams/simple", "ember-handlebars/ext", "ember-handlebars/helpers/view", "ember-views/views/view", "ember-views/views/collection_view", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__,
__dependency10__, __exports__) {
var Ember = __dependency1__["default"];
var EmberHandlebars = __dependency2__["default"];
var IS_BINDING = __dependency3__.IS_BINDING;
var fmt = __dependency4__.fmt;
var get = __dependency5__.get;
var SimpleStream = __dependency6__["default"];
var handlebarsGetView = __dependency7__.handlebarsGetView;
var ViewHelper = __dependency8__.ViewHelper;
var View = __dependency9__["default"];
var CollectionView = __dependency10__["default"];
function collectionHelper(path, options) {
Ember.deprecate("Using the {{collection}} helper without specifying a class has been" + " deprecated as the {{each}} helper now supports the same functionality.", path !== "collection");
if (path && (path.data && path.data.isRenderData)) {
options = path;
path = undefined;
Ember.assert("You cannot pass more than one argument to the collection helper", arguments.length === 1);
} else {
Ember.assert("You cannot pass more than one argument to the collection helper", arguments.length === 2);
}
var fn = options.fn, data = options.data, inverse = options.inverse, view = options.data.view, container = view.controller && view.controller.container ? view.controller.container : view.container;
var collectionClass;
if (path) {
collectionClass = handlebarsGetView(this, path, container, options.data);
Ember.assert(fmt("%@ #collection: Could not find collection class %@", [data.view, path]), !!collectionClass);
} else {
collectionClass = CollectionView;
}
var hash = options.hash;
var hashTypes = options.hashTypes;
var itemHash = {};
var match;
var collectionPrototype = collectionClass.proto();
var itemViewClass;
if (hash.itemView) {
itemViewClass = hash.itemView;
} else {
if (hash.itemViewClass) {
if (hashTypes.itemViewClass === "ID") {
var itemViewClassStream = view.getStream(hash.itemViewClass);
Ember.deprecate('Resolved the view "' + hash.itemViewClass + '" on the global context. Pass a view name to be looked up on the container instead, such as {{view "select"}}. http://emberjs.com/guides/deprecations#toc_global-lookup-of-views', !itemViewClassStream.isGlobal());
itemViewClass = itemViewClassStream.value();
} else {
itemViewClass = hash.itemViewClass;
}
} 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;
delete hashTypes.itemViewClass;
delete hashTypes.itemView;
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 (hashTypes[prop] === "ID" || IS_BINDING.test(prop)) {
itemHash[childProp] = view._getBindingForStream(hash[prop]);
} else {
itemHash[childProp] = hash[prop];
}
delete hash[prop];
}
}
}
if (fn) {
itemHash.template = fn;
delete options.fn;
}
var emptyViewClass;
if (inverse && inverse !== EmberHandlebars.VM.noop) {
emptyViewClass = get(collectionPrototype, "emptyViewClass");
emptyViewClass = emptyViewClass.extend({template:inverse, tagName:itemHash.tagName});
} else {
if (hash.emptyViewClass) {
emptyViewClass = handlebarsGetView(this, hash.emptyViewClass, container, options.data);
}
}
if (emptyViewClass) {
hash.emptyView = emptyViewClass;
}
if (hash.keyword) {
itemHash._contextBinding = "_parentView.context";
} else {
itemHash._contextBinding = "content";
}
var viewOptions = ViewHelper.propertiesFromHTMLOptions({data:data, hash:itemHash}, this);
if (hash.itemClassBinding) {
var itemClassBindings = hash.itemClassBinding.split(" ");
for (var i = 0;i < itemClassBindings.length;i++) {
var parsedPath = View._parsePropertyPath(itemClassBindings[i]);
if (parsedPath.path === "") {
parsedPath.stream = new SimpleStream(true);
} else {
parsedPath.stream = view.getStream(parsedPath.path);
}
itemClassBindings[i] = parsedPath;
}
viewOptions.classNameBindings = itemClassBindings;
}
hash.itemViewClass = itemViewClass;
hash._itemViewProps = viewOptions;
options.helperName = options.helperName || "collection";
return EmberHandlebars.helpers.view.call(this, collectionClass, options);
}
__exports__["default"] = collectionHelper;
});
enifed("ember-handlebars/helpers/debug", ["ember-metal/core", "ember-metal/utils", "ember-metal/logger", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
var Ember = __dependency1__["default"];
var inspect = __dependency2__.inspect;
var Logger = __dependency3__["default"];
var a_slice = [].slice;
function logHelper() {
var params = a_slice.call(arguments, 0, -1);
var options = arguments[arguments.length - 1];
var view = options.data.view;
var logger = Logger.log;
var values = [];
for (var i = 0;i < params.length;i++) {
if (options.types[i] === "ID") {
var stream = view.getStream(params[i]);
values.push(stream.value());
} else {
values.push(params[i]);
}
}
logger.apply(logger, values);
}
function debuggerHelper(options) {
var templateContext = this;
var typeOfTemplateContext = inspect(templateContext);
Ember.Logger.info("Use `this` to access the context of the calling template.");
debugger;
}
__exports__.logHelper = logHelper;
__exports__.debuggerHelper = debuggerHelper;
});
enifed("ember-handlebars/helpers/each", ["ember-metal/core", "ember-handlebars-compiler", "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-handlebars/views/metamorph_view", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__,
__dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __exports__) {
var Ember = __dependency1__["default"];
var EmberHandlebars = __dependency2__["default"];
var fmt = __dependency3__.fmt;
var get = __dependency4__.get;
var set = __dependency5__.set;
var CollectionView = __dependency6__["default"];
var Binding = __dependency7__.Binding;
var ControllerMixin = __dependency8__["default"];
var ArrayController = __dependency9__["default"];
var EmberArray = __dependency10__["default"];
var addObserver = __dependency11__.addObserver;
var removeObserver = __dependency11__.removeObserver;
var addBeforeObserver = __dependency11__.addBeforeObserver;
var removeBeforeObserver = __dependency11__.removeBeforeObserver;
var _MetamorphView = __dependency12__["default"];
var _Metamorph = __dependency12__._Metamorph;
var EachView = CollectionView.extend(_Metamorph, {init:function() {
var itemController = get(this, "itemController");
var binding;
if (itemController) {
var controller = get(this, "controller.container").lookupFactory("controller:array").create({_isVirtual:true, parentController:get(this, "controller"), itemController:itemController, target:get(this, "controller"), _eachView:this});
this.disableContentObservers(function() {
set(this, "content", controller);
binding = (new Binding("content", "_eachView.dataSource")).oneWay();
binding.connect(controller);
});
set(this, "_arrayController", controller);
} else {
this.disableContentObservers(function() {
binding = (new Binding("content", "dataSource")).oneWay();
binding.connect(this);
});
}
return this._super();
}, _assertArrayLike:function(content) {
Ember.assert(fmt("The value that #each loops over must be an Array. You " + "passed %@, but it should have been an ArrayController", [content.constructor]), !ControllerMixin.detect(content) || (content && content.isGenerated || content instanceof ArrayController));
Ember.assert(fmt("The value that #each loops over must be an Array. You passed %@", [ControllerMixin.detect(content) && content.get("model") !== undefined ? fmt("'%@' (wrapped in %@)", [content.get("model"), content]) : content]), EmberArray.detect(content));
}, disableContentObservers:function(callback) {
removeBeforeObserver(this, "content", null, "_contentWillChange");
removeObserver(this, "content", null, "_contentDidChange");
callback.call(this);
addBeforeObserver(this, "content", null, "_contentWillChange");
addObserver(this, "content", null, "_contentDidChange");
}, itemViewClass:_MetamorphView, emptyViewClass:_MetamorphView, createChildView:function(view, attrs) {
view = this._super(view, attrs);
var content = get(view, "content");
var keyword = get(this, "keyword");
if (keyword) {
view._keywords[keyword] = content;
}
if (content && content.isController) {
set(view, "controller", content);
}
return view;
}, destroy:function() {
if (!this._super()) {
return;
}
var arrayController = get(this, "_arrayController");
if (arrayController) {
arrayController.destroy();
}
return this;
}});
function eachHelper(path) {
var options = arguments[arguments.length - 1];
var helperName = "each";
var keywordName;
if (arguments.length === 4) {
Ember.assert("If you pass more than one argument to the each helper," + " it must be in the form #each foo in bar", arguments[1] === "in");
keywordName = arguments[0];
path = arguments[2];
helperName += " " + keywordName + " in " + path;
options.hash.keyword = keywordName;
} else {
if (arguments.length === 1) {
path = "";
} else {
helperName += " " + path;
}
}
Ember.deprecate("Using the context switching form of {{each}} is deprecated. Please use the keyword form (`{{#each foo in bar}}`) instead. See http://emberjs.com/guides/deprecations/#toc_more-consistent-handlebars-scope for more details.", keywordName);
options.hash.emptyViewClass = Ember._MetamorphView;
options.hash.dataSourceBinding = path;
options.hashTypes.dataSourceBinding = "STRING";
options.helperName = options.helperName || helperName;
return EmberHandlebars.helpers.collection.call(this, EmberHandlebars.EachView, options);
}
__exports__.EachView = EachView;
__exports__.eachHelper = eachHelper;
});
enifed("ember-handlebars/helpers/if_unless", ["ember-metal/core", "ember-handlebars-compiler", "ember-handlebars/helpers/binding", "ember-metal/property_get", "ember-metal/utils", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
var Ember = __dependency1__["default"];
var EmberHandlebars = __dependency2__["default"];
var bind = __dependency3__.bind;
var get = __dependency4__.get;
var isArray = __dependency5__.isArray;
var helpers = EmberHandlebars.helpers;
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;
}
}
function boundIfHelper(property, fn) {
var context = fn.contexts && fn.contexts.length ? fn.contexts[0] : this;
fn.helperName = fn.helperName || "boundIf";
return bind.call(context, property, fn, true, shouldDisplayIfHelperContent, shouldDisplayIfHelperContent, ["isTruthy", "length"]);
}
function unboundIfHelper(property, fn) {
var context = fn.contexts && fn.contexts.length ? fn.contexts[0] : this;
var data = fn.data;
var view = data.view;
var template = fn.fn;
var inverse = fn.inverse;
var propertyValue = view.getStream(property).value();
if (!shouldDisplayIfHelperContent(propertyValue)) {
template = inverse;
}
template(context, {data:data});
}
function ifHelper(context, options) {
Ember.assert("You must pass exactly one argument to the if helper", arguments.length === 2);
Ember.assert("You must pass a block to the if helper", options.fn && options.fn !== Handlebars.VM.noop);
options.helperName = options.helperName || "if " + context;
if (options.data.isUnbound) {
return helpers.unboundIf.call(options.contexts[0], context, options);
} else {
return helpers.boundIf.call(options.contexts[0], context, options);
}
}
function unlessHelper(context, options) {
Ember.assert("You must pass exactly one argument to the unless helper", arguments.length === 2);
Ember.assert("You must pass a block to the unless helper", options.fn && options.fn !== Handlebars.VM.noop);
var fn = options.fn;
var inverse = options.inverse;
var helperName = "unless";
if (context) {
helperName += " " + context;
}
options.fn = inverse;
options.inverse = fn;
options.helperName = options.helperName || helperName;
if (options.data.isUnbound) {
return helpers.unboundIf.call(options.contexts[0], context, options);
} else {
return helpers.boundIf.call(options.contexts[0], context, options);
}
}
__exports__.ifHelper = ifHelper;
__exports__.boundIfHelper = boundIfHelper;
__exports__.unboundIfHelper = unboundIfHelper;
__exports__.unlessHelper = unlessHelper;
});
enifed("ember-handlebars/helpers/loc", ["ember-runtime/system/string", "exports"], function(__dependency1__, __exports__) {
var loc = __dependency1__.loc;
__exports__["default"] = loc;
});
enifed("ember-handlebars/helpers/partial", ["ember-metal/core", "ember-metal/is_none", "ember-handlebars/helpers/binding", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
var Ember = __dependency1__["default"];
var isNone = __dependency2__["default"];
var bind = __dependency3__.bind;
__exports__["default"] = function partialHelper(name, options) {
var view = options.data.view;
var context = options.contexts && options.contexts.length ? options.contexts[0] : this;
options.helperName = options.helperName || "partial";
if (options.types[0] === "ID") {
var partialNameStream = view.getStream(name);
options.fn = function(context, fnOptions) {
renderPartial(context, partialNameStream.value(), fnOptions);
};
return bind.call(context, name, options, true, exists);
} else {
renderPartial(context, name, options);
}
};
function exists(value) {
return!isNone(value);
}
function renderPartial(context, name, options) {
var nameParts = name.split("/");
var lastPart = nameParts[nameParts.length - 1];
nameParts[nameParts.length - 1] = "_" + lastPart;
var view = options.data.view;
var underscoredName = nameParts.join("/");
var template = view.templateForName(underscoredName);
var deprecatedTemplate = !template && view.templateForName(name);
Ember.assert("Unable to find partial with name '" + name + "'.", template || deprecatedTemplate);
template = template || deprecatedTemplate;
template(context, {data:options.data});
}
});
enifed("ember-handlebars/helpers/template", ["ember-metal/core", "ember-handlebars-compiler", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var Ember = __dependency1__["default"];
var EmberHandlebars = __dependency2__["default"];
__exports__["default"] = function templateHelper(name, options) {
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 EmberHandlebars.helpers.partial.apply(this, arguments);
};
});
enifed("ember-handlebars/helpers/unbound", ["ember-handlebars-compiler", "ember-handlebars/helpers/binding", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var EmberHandlebars = __dependency1__["default"];
var resolveHelper = __dependency2__.resolveHelper;
__exports__["default"] = function unboundHelper(property) {
var argsLength = arguments.length;
var options = arguments[argsLength - 1];
var view = options.data.view;
var container = view.container;
if (argsLength <= 2) {
return view.getStream(property).value();
} else {
options.data.isUnbound = true;
options.types.shift();
var args = new Array(argsLength - 1);
for (var i = 1;i < argsLength;i++) {
args[i - 1] = arguments[i];
}
var helper = resolveHelper(container, property) || EmberHandlebars.helpers.helperMissing;
options.name = arguments[0];
var result = helper.apply(this, args);
delete options.data.isUnbound;
return result;
}
};
});
enifed("ember-handlebars/helpers/view", ["ember-metal/core", "ember-runtime/system/object", "ember-metal/property_get", "ember-metal/keys", "ember-metal/mixin", "ember-views/streams/read", "ember-views/views/view", "ember-metal/streams/simple", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
var Ember = __dependency1__["default"];
var EmberObject = __dependency2__["default"];
var get = __dependency3__.get;
var keys = __dependency4__["default"];
var IS_BINDING = __dependency5__.IS_BINDING;
var readViewFactory = __dependency6__.readViewFactory;
var View = __dependency7__["default"];
var SimpleStream = __dependency8__["default"];
function makeBindings(options) {
var hash = options.hash;
var hashTypes = options.hashTypes;
var view = options.data.view;
for (var prop in hash) {
var hashType = hashTypes[prop];
var value = hash[prop];
if (IS_BINDING.test(prop)) {
if (prop === "classBinding") {
continue;
}
if (hashType === "ID") {
Ember.warn("You're attempting to render a view by passing " + prop + "=" + value + " to a view helper, but this syntax is ambiguous. You should either surround " + value + " in quotes or remove `Binding` from " + prop + ".");
hash[prop] = view._getBindingForStream(value);
} else {
if (typeof value === "string") {
hash[prop] = view._getBindingForStream(value);
}
}
} else {
if (hashType === "ID") {
if (prop === "class") {
hash.classBinding = value;
} else {
hash[prop + "Binding"] = view._getBindingForStream(value);
}
delete hash[prop];
delete hashTypes[prop];
}
}
}
if (hash.idBinding) {
hash.id = hash.idBinding.value();
hashTypes.id = "STRING";
delete hash.idBinding;
delete hashTypes.idBinding;
}
}
var ViewHelper = EmberObject.create({propertiesFromHTMLOptions:function(options) {
var view = options.data.view;
var hash = options.hash;
var classes = hash["class"];
var extensions = {helperName:options.helperName || ""};
if (hash.id) {
extensions.elementId = 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 Handlebars is not allowed." + " Please subclass Ember.View and set it there instead.");
extensions.attributeBindings = null;
}
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];
}
}
var classNameBindings = extensions.classNameBindings;
if (classNameBindings) {
for (var j = 0;j < classNameBindings.length;j++) {
var parsedPath = View._parsePropertyPath(classNameBindings[j]);
if (parsedPath.path === "") {
parsedPath.stream = new SimpleStream(true);
} else {
parsedPath.stream = view.getStream(parsedPath.path);
}
classNameBindings[j] = parsedPath;
}
}
return extensions;
}, helper:function(thisContext, newView, options) {
var data = options.data;
var fn = options.fn;
makeBindings(options);
var viewOptions = this.propertiesFromHTMLOptions(options, thisContext);
var currentView = data.view;
viewOptions.templateData = data;
var newViewProto = newView.proto();
if (fn) {
Ember.assert("You cannot provide a template block if you also specified a templateName", !get(viewOptions, "templateName") && !get(newViewProto, "templateName"));
viewOptions.template = fn;
}
if (!newViewProto.controller && (!newViewProto.controllerBinding && (!viewOptions.controller && !viewOptions.controllerBinding))) {
viewOptions._context = thisContext;
}
currentView.appendChild(newView, viewOptions);
}, instanceHelper:function(thisContext, newView, options) {
var data = options.data;
var fn = options.fn;
makeBindings(options);
Ember.assert("Only a instance of a view may be passed to the ViewHelper.instanceHelper", View.detectInstance(newView));
var viewOptions = this.propertiesFromHTMLOptions(options, thisContext);
var currentView = data.view;
viewOptions.templateData = data;
if (fn) {
Ember.assert("You cannot provide a template block if you also specified a templateName", !get(viewOptions, "templateName") && !get(newView, "templateName"));
viewOptions.template = fn;
}
if (!newView.controller && (!newView.controllerBinding && (!viewOptions.controller && !viewOptions.controllerBinding))) {
viewOptions._context = thisContext;
}
currentView.appendChild(newView, viewOptions);
}});
__exports__.ViewHelper = ViewHelper;
function viewHelper(path) {
Ember.assert("The view helper only takes a single argument", arguments.length <= 2);
var options = arguments[arguments.length - 1];
var types = options.types;
var view = options.data.view;
var container = view.container || view._keywords.view.value().container;
var viewClass;
if (arguments.length === 1) {
if (container) {
viewClass = container.lookupFactory("view:toplevel");
} else {
viewClass = View;
}
} else {
var pathStream;
if (typeof path === "string" && types[0] === "ID") {
pathStream = view.getStream(path);
Ember.deprecate('Resolved the view "' + path + '" on the global context. Pass a view name to be looked up on the container instead, such as {{view "select"}}. http://emberjs.com/guides/deprecations#toc_global-lookup-of-views', !pathStream.isGlobal());
} else {
pathStream = path;
}
viewClass = readViewFactory(pathStream, container);
}
options.helperName = options.helperName || "view";
return ViewHelper.helper(this, viewClass, options);
}
__exports__.viewHelper = viewHelper;
});
enifed("ember-handlebars/helpers/with", ["ember-metal/core", "ember-metal/property_set", "ember-metal/utils", "ember-metal/platform", "ember-metal/is_none", "ember-handlebars/helpers/binding", "ember-handlebars/views/handlebars_bound_view", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
var Ember = __dependency1__["default"];
var set = __dependency2__.set;
var apply = __dependency3__.apply;
var o_create = __dependency4__.create;
var isNone = __dependency5__["default"];
var bind = __dependency6__.bind;
var _HandlebarsBoundView = __dependency7__._HandlebarsBoundView;
function exists(value) {
return!isNone(value);
}
var WithView = _HandlebarsBoundView.extend({init:function() {
apply(this, this._super, arguments);
var keywordName = this.templateHash.keywordName;
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._keywords[keywordName] = 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());
}
}, willDestroy:function() {
this._super();
if (this._generatedController) {
this._generatedController.destroy();
}
}});
__exports__["default"] = function withHelper(contextPath) {
var options = arguments[arguments.length - 1];
var view = options.data.view;
var bindContext, preserveContext;
var helperName = "with";
if (arguments.length === 4) {
Ember.assert("If you pass more than one argument to the with helper," + " it must be in the form #with foo as bar", arguments[1] === "as");
var keywordName = arguments[2];
if (contextPath) {
helperName += " " + contextPath + " as " + keywordName;
}
Ember.assert("You must pass a block to the with helper", options.fn && options.fn !== Handlebars.VM.noop);
var localizedOptions = o_create(options);
localizedOptions.data = o_create(options.data);
localizedOptions.keywords = {};
localizedOptions.keywords[keywordName] = view.getStream(contextPath);
localizedOptions.hash.keywordName = keywordName;
bindContext = this;
options = localizedOptions;
preserveContext = true;
} else {
Ember.deprecate("Using the context switching form of `{{with}}` is deprecated. Please use the keyword form (`{{with foo as bar}}`) instead. See http://emberjs.com/guides/deprecations/#toc_more-consistent-handlebars-scope for more details.");
Ember.assert("You must pass exactly one argument to the with helper", arguments.length === 2);
Ember.assert("You must pass a block to the with helper", options.fn && options.fn !== Handlebars.VM.noop);
helperName += " " + contextPath;
bindContext = options.contexts[0];
preserveContext = false;
}
options.helperName = helperName;
return bind.call(bindContext, contextPath, options, preserveContext, exists, undefined, undefined, WithView);
};
});
enifed("ember-handlebars/helpers/yield", ["ember-metal/core", "ember-metal/property_get", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var Ember = __dependency1__["default"];
var get = __dependency2__.get;
__exports__["default"] = function yieldHelper(options) {
var view = options.data.view;
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);
view._yield(this, options);
};
});
enifed("ember-handlebars/loader", ["ember-handlebars/component_lookup", "ember-views/system/jquery", "ember-metal/error", "ember-runtime/system/lazy_load", "ember-handlebars-compiler", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
var ComponentLookup = __dependency1__["default"];
var jQuery = __dependency2__["default"];
var EmberError = __dependency3__["default"];
var onLoad = __dependency4__.onLoad;
var EmberHandlebars = __dependency5__["default"];
function bootstrap(ctx) {
var selectors = 'script[type="text/x-handlebars"], script[type="text/x-raw-handlebars"]';
jQuery(selectors, ctx).each(function() {
var script = jQuery(this);
var compile = script.attr("type") === "text/x-raw-handlebars" ? jQuery.proxy(Handlebars.compile, Handlebars) : jQuery.proxy(EmberHandlebars.compile, EmberHandlebars);
var templateName = script.attr("data-template-name") || (script.attr("id") || "application");
var template = compile(script.html());
if (Ember.TEMPLATES[templateName] !== undefined) {
throw new EmberError('Template named "' + templateName + '" already exists.');
}
Ember.TEMPLATES[templateName] = template;
script.remove();
});
}
function _bootstrap() {
bootstrap(jQuery(document));
}
function registerComponentLookup(container) {
container.register("component-lookup:main", ComponentLookup);
}
onLoad("Ember.Application", function(Application) {
Application.initializer({name:"domTemplates", initialize:_bootstrap});
Application.initializer({name:"registerComponentLookup", after:"domTemplates", initialize:registerComponentLookup});
});
__exports__["default"] = bootstrap;
});
enifed("ember-handlebars/string", ["ember-runtime/system/string", "exports"], function(__dependency1__, __exports__) {
var EmberStringUtils = __dependency1__["default"];
function htmlSafe(str) {
if (str === null || str === undefined) {
return "";
}
if (typeof str !== "string") {
str = "" + str;
}
return new Handlebars.SafeString(str);
}
EmberStringUtils.htmlSafe = htmlSafe;
if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) {
String.prototype.htmlSafe = function() {
return htmlSafe(this);
};
}
__exports__["default"] = htmlSafe;
});
enifed("ember-handlebars/views/handlebars_bound_view", ["ember-handlebars-compiler", "ember-metal/core", "ember-metal/error", "ember-metal/property_get", "ember-metal/property_set", "ember-metal/merge", "ember-metal/run_loop", "ember-handlebars/string", "ember-views/views/states", "ember-handlebars/views/metamorph_view", "ember-metal/utils", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__,
__dependency9__, __dependency10__, __dependency11__, __exports__) {
var EmberHandlebars = __dependency1__["default"];
var Ember = __dependency2__["default"];
var K = Ember.K;
var EmberError = __dependency3__["default"];
var get = __dependency4__.get;
var set = __dependency5__.set;
var merge = __dependency6__["default"];
var run = __dependency7__["default"];
var htmlSafe = __dependency8__["default"];
var cloneStates = __dependency9__.cloneStates;
var viewStates = __dependency9__.states;
var _MetamorphView = __dependency10__["default"];
var uuid = __dependency11__.uuid;
function SimpleHandlebarsView(lazyValue, isEscaped) {
this.lazyValue = lazyValue;
this.isEscaped = isEscaped;
this[Ember.GUID_KEY] = uuid();
this._lastNormalizedValue = undefined;
this.state = "preRender";
this.updateId = null;
this._parentView = null;
this.buffer = null;
this._morph = null;
}
SimpleHandlebarsView.prototype = {isVirtual:true, isView:true, destroy:function() {
if (this.updateId) {
run.cancel(this.updateId);
this.updateId = null;
}
if (this._parentView) {
this._parentView.removeChild(this);
}
this.morph = null;
this.state = "destroyed";
}, propertyWillChange:K, propertyDidChange:K, normalizedValue:function() {
var result = this.lazyValue.value();
if (result === null || result === undefined) {
result = "";
} else {
if (!this.isEscaped && !(result instanceof EmberHandlebars.SafeString)) {
result = htmlSafe(result);
}
}
return result;
}, render:function(buffer) {
var value = this.normalizedValue();
this._lastNormalizedValue = value;
buffer._element = value;
}, rerender:function() {
switch(this.state) {
case "preRender":
;
case "destroyed":
break;
case "inBuffer":
throw new EmberError("Something you did tried to replace an {{expression}} before it was inserted into the DOM.");;
case "hasElement":
;
case "inDOM":
this.updateId = run.scheduleOnce("render", this, "update");
break;
}
return this;
}, update:function() {
this.updateId = null;
var value = this.normalizedValue();
if (value !== this._lastNormalizedValue) {
this._lastNormalizedValue = value;
this._morph.update(value);
}
}, _transitionTo:function(state) {
this.state = state;
}};
var states = cloneStates(viewStates);
merge(states._default, {rerenderIfNeeded:K});
merge(states.inDOM, {rerenderIfNeeded:function(view) {
if (view.normalizedValue() !== view._lastNormalizedValue) {
view.rerender();
}
}});
var _HandlebarsBoundView = _MetamorphView.extend({instrumentName:"boundHandlebars", _states:states, shouldDisplayFunc:null, preserveContext:false, previousContext:null, displayTemplate:null, inverseTemplate:null, lazyValue:null, normalizedValue:function() {
var value = this.lazyValue.value();
var valueNormalizer = get(this, "valueNormalizerFunc");
return valueNormalizer ? valueNormalizer(value) : value;
}, rerenderIfNeeded:function() {
this.currentState.rerenderIfNeeded(this);
}, render:function(buffer) {
var escape = get(this, "isEscaped");
var shouldDisplay = get(this, "shouldDisplayFunc");
var preserveContext = get(this, "preserveContext");
var context = get(this, "previousContext");
var inverseTemplate = get(this, "inverseTemplate");
var displayTemplate = get(this, "displayTemplate");
var result = this.normalizedValue();
this._lastNormalizedValue = result;
if (shouldDisplay(result)) {
set(this, "template", displayTemplate);
if (preserveContext) {
set(this, "_context", context);
} else {
if (displayTemplate) {
set(this, "_context", result);
} else {
if (result === null || result === undefined) {
result = "";
} else {
if (!(result instanceof EmberHandlebars.SafeString)) {
result = String(result);
}
}
if (escape) {
result = Handlebars.Utils.escapeExpression(result);
}
buffer.push(result);
return;
}
}
} else {
if (inverseTemplate) {
set(this, "template", inverseTemplate);
if (preserveContext) {
set(this, "_context", context);
} else {
set(this, "_context", result);
}
} else {
set(this, "template", function() {
return "";
});
}
}
return this._super(buffer);
}});
__exports__._HandlebarsBoundView = _HandlebarsBoundView;
__exports__.SimpleHandlebarsView = SimpleHandlebarsView;
});
enifed("ember-handlebars/views/metamorph_view", ["ember-metal/core", "ember-views/views/core_view", "ember-views/views/view", "ember-metal/mixin", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
var Ember = __dependency1__["default"];
var CoreView = __dependency2__["default"];
var View = __dependency3__["default"];
var Mixin = __dependency4__.Mixin;
var _Metamorph = Mixin.create({isVirtual:true, tagName:"", instrumentName:"metamorph", init:function() {
this._super();
Ember.deprecate("Supplying a tagName to Metamorph views is unreliable and is deprecated." + " You may be setting the tagName on a Handlebars helper that creates a Metamorph.", !this.tagName);
}});
__exports__._Metamorph = _Metamorph;
__exports__["default"] = View.extend(_Metamorph);
var _SimpleMetamorphView = CoreView.extend(_Metamorph);
__exports__._SimpleMetamorphView = _SimpleMetamorphView;
});
enifed("ember-metal-views", ["ember-metal-views/renderer", "exports"], function(__dependency1__, __exports__) {
var Renderer = __dependency1__["default"];
__exports__.Renderer = Renderer;
});
enifed("ember-metal-views/renderer", ["morph", "exports"], function(__dependency1__, __exports__) {
var DOMHelper = __dependency1__.DOMHelper;
function Renderer() {
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 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;
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) {
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) {
contextualElement = document.body;
}
Ember.assert("Required contextualElement for view " + _view + " is missing", contextualElement);
element = this.createElement(view, contextualElement);
parents[level++] = parentIndex;
parentIndex = index;
parent = view;
queue[length++] = index;
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;
}
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 < removeQueue.length;idx++) {
view = removeQueue[idx];
if (!shouldDestroy && view._childViewsMorph) {
queue = removeQueue;
} else {
queue = destroyQueue;
}
this.beforeRemove(removeQueue[idx]);
childViews = view._childViews;
if (childViews) {
for (i = 0, l = childViews.length;i < l;i++) {
queue.push(childViews[i]);
}
}
}
for (idx = 0;idx < destroyQueue.length;idx++) {
view = destroyQueue[idx];
this.beforeRemove(destroyQueue[idx]);
childViews = view._childViews;
if (childViews) {
for (i = 0, l = childViews.length;i < l;i++) {
destroyQueue.push(childViews[i]);
}
}
}
if (morph && !reset) {
morph.destroy();
}
for (idx = 0, len = removeQueue.length;idx < len;idx++) {
this.afterRemove(removeQueue[idx], false);
}
for (idx = 0, len = destroyQueue.length;idx < len;idx++) {
this.afterRemove(destroyQueue[idx], true);
}
if (reset) {
_view._morph = morph;
}
}
function Renderer_insertElement(view, parentView, element, index) {
if (element === null || element === undefined) {
return;
}
if (view._morph) {
view._morph.update(element);
} else {
if (parentView) {
if (index === -1) {
view._morph = parentView._childViewsMorph.append(element);
} else {
view._morph = parentView._childViewsMorph.insert(index, element);
}
}
}
}
function Renderer_beforeRemove(view) {
if (view._elementCreated) {
this.willDestroyElement(view);
}
if (view._elementInserted) {
this.willRemoveElement(view);
}
}
function Renderer_afterRemove(view, shouldDestroy) {
view._elementInserted = false;
view._morph = null;
view._childViewsMorph = null;
if (view._elementCreated) {
view._elementCreated = false;
this.didDestroyElement(view);
}
if (shouldDestroy) {
this.destroyView(view);
}
}
Renderer.prototype.remove = Renderer_remove;
Renderer.prototype.destroy = function(view) {
this.remove(view, true);
};
Renderer.prototype.renderTree = Renderer_renderTree;
Renderer.prototype.insertElement = Renderer_insertElement;
Renderer.prototype.beforeRemove = Renderer_beforeRemove;
Renderer.prototype.afterRemove = Renderer_afterRemove;
var noop = function() {
};
Renderer.prototype.willCreateElement = noop;
Renderer.prototype.createElement = noop;
Renderer.prototype.didCreateElement = noop;
Renderer.prototype.willInsertElement = noop;
Renderer.prototype.didInsertElement = noop;
Renderer.prototype.willRemoveElement = noop;
Renderer.prototype.willDestroyElement = noop;
Renderer.prototype.didDestroyElement = noop;
Renderer.prototype.destroyView = noop;
Renderer.prototype.childViews = noop;
__exports__["default"] = Renderer;
});
enifed("ember-metal", ["ember-metal/core", "ember-metal/merge", "ember-metal/instrumentation", "ember-metal/utils", "ember-metal/error", "ember-metal/enumerable_utils", "ember-metal/cache", "ember-metal/platform", "ember-metal/array", "ember-metal/logger", "ember-metal/property_get", "ember-metal/events", "ember-metal/observer_set", "ember-metal/property_events", "ember-metal/properties", "ember-metal/property_set", "ember-metal/map", "ember-metal/get_properties", "ember-metal/set_properties",
"ember-metal/watch_key", "ember-metal/chains", "ember-metal/watch_path", "ember-metal/watching", "ember-metal/expand_properties", "ember-metal/computed", "ember-metal/computed_macros", "ember-metal/observer", "ember-metal/mixin", "ember-metal/binding", "ember-metal/run_loop", "ember-metal/libraries", "ember-metal/is_none", "ember-metal/is_empty", "ember-metal/is_blank", "ember-metal/is_present", "ember-metal/keys", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__,
__dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __dependency21__, __dependency22__, __dependency23__, __dependency24__, __dependency25__, __dependency26__, __dependency27__, __dependency28__, __dependency29__, __dependency30__, __dependency31__, __dependency32__,
__dependency33__, __dependency34__, __dependency35__, __dependency36__, __exports__) {
var Ember = __dependency1__["default"];
var merge = __dependency2__["default"];
var instrument = __dependency3__.instrument;
var reset = __dependency3__.reset;
var subscribe = __dependency3__.subscribe;
var unsubscribe = __dependency3__.unsubscribe;
var EMPTY_META = __dependency4__.EMPTY_META;
var GUID_KEY = __dependency4__.GUID_KEY;
var META_DESC = __dependency4__.META_DESC;
var apply = __dependency4__.apply;
var applyStr = __dependency4__.applyStr;
var canInvoke = __dependency4__.canInvoke;
var generateGuid = __dependency4__.generateGuid;
var getMeta = __dependency4__.getMeta;
var guidFor = __dependency4__.guidFor;
var inspect = __dependency4__.inspect;
var isArray = __dependency4__.isArray;
var makeArray = __dependency4__.makeArray;
var meta = __dependency4__.meta;
var metaPath = __dependency4__.metaPath;
var setMeta = __dependency4__.setMeta;
var tryCatchFinally = __dependency4__.tryCatchFinally;
var tryFinally = __dependency4__.tryFinally;
var tryInvoke = __dependency4__.tryInvoke;
var typeOf = __dependency4__.typeOf;
var uuid = __dependency4__.uuid;
var wrap = __dependency4__.wrap;
var EmberError = __dependency5__["default"];
var EnumerableUtils = __dependency6__["default"];
var Cache = __dependency7__["default"];
var create = __dependency8__.create;
var hasPropertyAccessors = __dependency8__.hasPropertyAccessors;
var filter = __dependency9__.filter;
var forEach = __dependency9__.forEach;
var indexOf = __dependency9__.indexOf;
var map = __dependency9__.map;
var Logger = __dependency10__["default"];
var _getPath = __dependency11__._getPath;
var get = __dependency11__.get;
var getWithDefault = __dependency11__.getWithDefault;
var normalizeTuple = __dependency11__.normalizeTuple;
var addListener = __dependency12__.addListener;
var hasListeners = __dependency12__.hasListeners;
var listenersDiff = __dependency12__.listenersDiff;
var listenersFor = __dependency12__.listenersFor;
var listenersUnion = __dependency12__.listenersUnion;
var on = __dependency12__.on;
var removeListener = __dependency12__.removeListener;
var sendEvent = __dependency12__.sendEvent;
var suspendListener = __dependency12__.suspendListener;
var suspendListeners = __dependency12__.suspendListeners;
var watchedEvents = __dependency12__.watchedEvents;
var ObserverSet = __dependency13__["default"];
var beginPropertyChanges = __dependency14__.beginPropertyChanges;
var changeProperties = __dependency14__.changeProperties;
var endPropertyChanges = __dependency14__.endPropertyChanges;
var overrideChains = __dependency14__.overrideChains;
var propertyDidChange = __dependency14__.propertyDidChange;
var propertyWillChange = __dependency14__.propertyWillChange;
var Descriptor = __dependency15__.Descriptor;
var defineProperty = __dependency15__.defineProperty;
var set = __dependency16__.set;
var trySet = __dependency16__.trySet;
var Map = __dependency17__.Map;
var MapWithDefault = __dependency17__.MapWithDefault;
var OrderedSet = __dependency17__.OrderedSet;
var getProperties = __dependency18__["default"];
var setProperties = __dependency19__["default"];
var watchKey = __dependency20__.watchKey;
var unwatchKey = __dependency20__.unwatchKey;
var ChainNode = __dependency21__.ChainNode;
var finishChains = __dependency21__.finishChains;
var flushPendingChains = __dependency21__.flushPendingChains;
var removeChainWatcher = __dependency21__.removeChainWatcher;
var watchPath = __dependency22__.watchPath;
var unwatchPath = __dependency22__.unwatchPath;
var destroy = __dependency23__.destroy;
var isWatching = __dependency23__.isWatching;
var rewatch = __dependency23__.rewatch;
var unwatch = __dependency23__.unwatch;
var watch = __dependency23__.watch;
var expandProperties = __dependency24__["default"];
var ComputedProperty = __dependency25__.ComputedProperty;
var computed = __dependency25__.computed;
var cacheFor = __dependency25__.cacheFor;
var _suspendBeforeObserver = __dependency27__._suspendBeforeObserver;
var _suspendBeforeObservers = __dependency27__._suspendBeforeObservers;
var _suspendObserver = __dependency27__._suspendObserver;
var _suspendObservers = __dependency27__._suspendObservers;
var addBeforeObserver = __dependency27__.addBeforeObserver;
var addObserver = __dependency27__.addObserver;
var beforeObserversFor = __dependency27__.beforeObserversFor;
var observersFor = __dependency27__.observersFor;
var removeBeforeObserver = __dependency27__.removeBeforeObserver;
var removeObserver = __dependency27__.removeObserver;
var IS_BINDING = __dependency28__.IS_BINDING;
var Mixin = __dependency28__.Mixin;
var aliasMethod = __dependency28__.aliasMethod;
var beforeObserver = __dependency28__.beforeObserver;
var immediateObserver = __dependency28__.immediateObserver;
var mixin = __dependency28__.mixin;
var observer = __dependency28__.observer;
var required = __dependency28__.required;
var Binding = __dependency29__.Binding;
var bind = __dependency29__.bind;
var isGlobalPath = __dependency29__.isGlobalPath;
var oneWay = __dependency29__.oneWay;
var run = __dependency30__["default"];
var libraries = __dependency31__["default"];
var isNone = __dependency32__["default"];
var isEmpty = __dependency33__["default"];
var isBlank = __dependency34__["default"];
var isPresent = __dependency35__["default"];
var keys = __dependency36__["default"];
var EmberInstrumentation = Ember.Instrumentation = {};
EmberInstrumentation.instrument = instrument;
EmberInstrumentation.subscribe = subscribe;
EmberInstrumentation.unsubscribe = unsubscribe;
EmberInstrumentation.reset = reset;
Ember.instrument = instrument;
Ember.subscribe = subscribe;
Ember._Cache = Cache;
Ember.generateGuid = generateGuid;
Ember.GUID_KEY = GUID_KEY;
Ember.create = create;
Ember.keys = keys;
Ember.platform = {defineProperty:defineProperty, hasPropertyAccessors:hasPropertyAccessors};
var EmberArrayPolyfills = Ember.ArrayPolyfills = {};
EmberArrayPolyfills.map = map;
EmberArrayPolyfills.forEach = forEach;
EmberArrayPolyfills.filter = filter;
EmberArrayPolyfills.indexOf = indexOf;
Ember.Error = EmberError;
Ember.guidFor = guidFor;
Ember.META_DESC = META_DESC;
Ember.EMPTY_META = EMPTY_META;
Ember.meta = meta;
Ember.getMeta = getMeta;
Ember.setMeta = setMeta;
Ember.metaPath = metaPath;
Ember.inspect = inspect;
Ember.typeOf = typeOf;
Ember.tryCatchFinally = tryCatchFinally;
Ember.isArray = isArray;
Ember.makeArray = makeArray;
Ember.canInvoke = canInvoke;
Ember.tryInvoke = tryInvoke;
Ember.tryFinally = tryFinally;
Ember.wrap = wrap;
Ember.apply = apply;
Ember.applyStr = applyStr;
Ember.uuid = uuid;
Ember.Logger = Logger;
Ember.get = get;
Ember.getWithDefault = getWithDefault;
Ember.normalizeTuple = normalizeTuple;
Ember._getPath = _getPath;
Ember.EnumerableUtils = EnumerableUtils;
Ember.on = on;
Ember.addListener = addListener;
Ember.removeListener = removeListener;
Ember._suspendListener = suspendListener;
Ember._suspendListeners = suspendListeners;
Ember.sendEvent = sendEvent;
Ember.hasListeners = hasListeners;
Ember.watchedEvents = watchedEvents;
Ember.listenersFor = listenersFor;
Ember.listenersDiff = listenersDiff;
Ember.listenersUnion = listenersUnion;
Ember._ObserverSet = ObserverSet;
Ember.propertyWillChange = propertyWillChange;
Ember.propertyDidChange = propertyDidChange;
Ember.overrideChains = overrideChains;
Ember.beginPropertyChanges = beginPropertyChanges;
Ember.endPropertyChanges = endPropertyChanges;
Ember.changeProperties = changeProperties;
Ember.Descriptor = Descriptor;
Ember.defineProperty = defineProperty;
Ember.set = set;
Ember.trySet = trySet;
Ember.OrderedSet = OrderedSet;
Ember.Map = Map;
Ember.MapWithDefault = MapWithDefault;
Ember.getProperties = getProperties;
Ember.setProperties = setProperties;
Ember.watchKey = watchKey;
Ember.unwatchKey = unwatchKey;
Ember.flushPendingChains = flushPendingChains;
Ember.removeChainWatcher = removeChainWatcher;
Ember._ChainNode = ChainNode;
Ember.finishChains = finishChains;
Ember.watchPath = watchPath;
Ember.unwatchPath = unwatchPath;
Ember.watch = watch;
Ember.isWatching = isWatching;
Ember.unwatch = unwatch;
Ember.rewatch = rewatch;
Ember.destroy = destroy;
Ember.expandProperties = expandProperties;
Ember.ComputedProperty = ComputedProperty;
Ember.computed = computed;
Ember.cacheFor = cacheFor;
Ember.addObserver = addObserver;
Ember.observersFor = observersFor;
Ember.removeObserver = removeObserver;
Ember.addBeforeObserver = addBeforeObserver;
Ember._suspendBeforeObserver = _suspendBeforeObserver;
Ember._suspendBeforeObservers = _suspendBeforeObservers;
Ember._suspendObserver = _suspendObserver;
Ember._suspendObservers = _suspendObservers;
Ember.beforeObserversFor = beforeObserversFor;
Ember.removeBeforeObserver = removeBeforeObserver;
Ember.IS_BINDING = IS_BINDING;
Ember.required = required;
Ember.aliasMethod = aliasMethod;
Ember.observer = observer;
Ember.immediateObserver = immediateObserver;
Ember.beforeObserver = beforeObserver;
Ember.mixin = mixin;
Ember.Mixin = Mixin;
Ember.oneWay = oneWay;
Ember.bind = bind;
Ember.Binding = Binding;
Ember.isGlobalPath = isGlobalPath;
Ember.run = run;
Ember.libraries = libraries;
Ember.libraries.registerCoreLibrary("Ember", Ember.VERSION);
Ember.isNone = isNone;
Ember.isEmpty = isEmpty;
Ember.isBlank = isBlank;
Ember.isPresent = isPresent;
Ember.merge = merge;
Ember.onerror = null;
if (Ember.__loader.registry["ember-debug"]) {
requireModule("ember-debug");
}
__exports__["default"] = Ember;
});
enifed("ember-metal/alias", ["ember-metal/property_get", "ember-metal/property_set", "ember-metal/core", "ember-metal/error", "ember-metal/properties", "ember-metal/computed", "ember-metal/platform", "ember-metal/utils", "ember-metal/dependent_keys", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __exports__) {
var get = __dependency1__.get;
var set = __dependency2__.set;
var Ember = __dependency3__["default"];
var EmberError = __dependency4__["default"];
var Descriptor = __dependency5__.Descriptor;
var defineProperty = __dependency5__.defineProperty;
var ComputedProperty = __dependency6__.ComputedProperty;
var create = __dependency7__.create;
var meta = __dependency8__.meta;
var inspect = __dependency8__.inspect;
var addDependentKeys = __dependency9__.addDependentKeys;
var removeDependentKeys = __dependency9__.removeDependentKeys;
__exports__["default"] = function alias(altKey) {
return new AliasedProperty(altKey);
};
function AliasedProperty(altKey) {
this.altKey = altKey;
this._dependentKeys = [altKey];
}
__exports__.AliasedProperty = AliasedProperty;
AliasedProperty.prototype = create(Descriptor.prototype);
AliasedProperty.prototype.get = function AliasedProperty_get(obj, keyName) {
return get(obj, this.altKey);
};
AliasedProperty.prototype.set = function AliasedProperty_set(obj, keyName, value) {
return set(obj, this.altKey, value);
};
AliasedProperty.prototype.willWatch = function(obj, keyName) {
addDependentKeys(this, obj, keyName, meta(obj));
};
AliasedProperty.prototype.didUnwatch = function(obj, keyName) {
removeDependentKeys(this, obj, keyName, meta(obj));
};
AliasedProperty.prototype.setup = function(obj, keyName) {
Ember.assert("Setting alias '" + keyName + "' on self", this.altKey !== keyName);
var m = meta(obj);
if (m.watching[keyName]) {
addDependentKeys(this, obj, keyName, m);
}
};
AliasedProperty.prototype.teardown = function(obj, keyName) {
var m = meta(obj);
if (m.watching[keyName]) {
removeDependentKeys(this, obj, keyName, m);
}
};
AliasedProperty.prototype.readOnly = function() {
this.set = AliasedProperty_readOnlySet;
return this;
};
function AliasedProperty_readOnlySet(obj, keyName, value) {
throw new EmberError('Cannot set read-only property "' + keyName + '" on object: ' + inspect(obj));
}
AliasedProperty.prototype.oneWay = function() {
this.set = AliasedProperty_oneWaySet;
return this;
};
function AliasedProperty_oneWaySet(obj, keyName, value) {
defineProperty(obj, keyName, null);
return set(obj, keyName, value);
}
AliasedProperty.prototype._meta = undefined;
AliasedProperty.prototype.meta = ComputedProperty.prototype.meta;
});
enifed("ember-metal/array", ["exports"], function(__exports__) {
var ArrayPrototype = Array.prototype;
var isNativeFunc = function(func) {
return func && Function.prototype.toString.call(func).indexOf("[native code]") > -1;
};
var defineNativeShim = function(nativeFunc, shim) {
if (isNativeFunc(nativeFunc)) {
return nativeFunc;
}
return shim;
};
var map = defineNativeShim(ArrayPrototype.map, function(fun) {
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;
});
var forEach = defineNativeShim(ArrayPrototype.forEach, function(fun) {
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;
}
__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__) {
var Ember = __dependency1__["default"];
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;
Ember.LOG_BINDINGS = false || !!Ember.ENV.LOG_BINDINGS;
function getWithGlobals(obj, path) {
return get(isGlobalPath(path) ? Ember.lookup : obj, path);
}
function Binding(toPath, fromPath) {
this._direction = undefined;
this._from = fromPath;
this._to = toPath;
this._readyToSync = undefined;
this._oneWay = undefined;
}
Binding.prototype = {copy:function() {
var copy = new Binding(this._to, this._from);
if (this._oneWay) {
copy._oneWay = true;
}
return copy;
}, from:function(path) {
this._from = path;
return this;
}, to:function(path) {
this._to = path;
return this;
}, oneWay:function() {
this._oneWay = true;
return this;
}, toString:function() {
var oneWay = this._oneWay ? "[oneWay]" : "";
return "Ember.Binding<" + guidFor(this) + ">(" + this._from + " -> " + this._to + ")" + oneWay;
}, 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));
addObserver(obj, fromPath, this, this.fromDidChange);
if (!this._oneWay) {
addObserver(obj, toPath, this, this.toDidChange);
}
this._readyToSync = true;
return this;
}, disconnect:function(obj) {
Ember.assert("Must pass a valid object to Ember.Binding.disconnect()", !!obj);
var twoWay = !this._oneWay;
removeObserver(obj, this._from, this, this.fromDidChange);
if (twoWay) {
removeObserver(obj, this._to, this, this.toDidChange);
}
this._readyToSync = false;
return this;
}, fromDidChange:function(target) {
this._scheduleSync(target, "fwd");
}, toDidChange:function(target) {
this._scheduleSync(target, "back");
}, _scheduleSync:function(obj, dir) {
var existingDir = this._direction;
if (existingDir === undefined) {
run.schedule("sync", this, this._sync, obj);
this._direction = dir;
}
if (existingDir === "back" && dir === "fwd") {
this._direction = "fwd";
}
}, _sync:function(obj) {
var log = Ember.LOG_BINDINGS;
if (obj.isDestroyed || !this._readyToSync) {
return;
}
var direction = this._direction;
var fromPath = this._from;
var toPath = this._to;
this._direction = undefined;
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);
});
}
} 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, {from:function(from) {
var C = this;
return new C(undefined, from);
}, to:function(to) {
var C = this;
return new C(to, undefined);
}, oneWay:function(from, flag) {
var C = this;
return(new C(undefined, from)).oneWay(flag);
}});
function bind(obj, to, from) {
return(new Binding(to, from)).connect(obj);
}
__exports__.bind = bind;
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__) {
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++;
}
}
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__) {
var Ember = __dependency1__["default"];
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 = [];
function flushPendingChains() {
if (pendingQueue.length === 0) {
return;
}
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;
}
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;
}
var m = obj["__ember_meta__"];
if (m && !m.hasOwnProperty("chainWatchers")) {
return;
}
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);
}
function ChainNode(parent, key, value) {
this._parent = parent;
this._key = key;
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);
}
}
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__"];
if (meta && meta.proto === obj) {
return undefined;
}
if (key === "@each") {
return get(obj, key);
}
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;
}
};
ChainNodePrototype.copy = function(obj) {
var ret = new ChainNode(null, null, obj);
var paths = this._paths;
var path;
for (path in paths) {
if (paths[path] <= 0) {
continue;
}
ret.add(path);
}
return ret;
};
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);
if (tuple[0] && tuple[0] === obj) {
path = tuple[1];
key = firstKey(path);
path = path.slice(key.length + 1);
} else {
if (!tuple[0]) {
pendingQueue.push([this, path]);
tuple.length = 0;
return;
} else {
src = tuple[0];
key = path.slice(0, 0 - (tuple[1].length + 1));
path = tuple[1];
}
}
tuple.length = 0;
this.chain(key, path, src);
};
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++;
if (path) {
key = firstKey(path);
path = path.slice(key.length + 1);
node.chain(key, path);
}
};
ChainNodePrototype.unchain = function(key, path) {
var chains = this._chains;
var node = chains[key];
if (path && path.length > 1) {
var nextKey = firstKey(path);
var nextPath = path.slice(nextKey.length + 1);
node.unchain(nextKey, nextPath);
}
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) {
if (this._watching) {
var obj = this._parent.value();
if (obj !== this._object) {
removeChainWatcher(this._object, this._key, this);
this._object = obj;
addChainWatcher(obj, this._key, this);
}
this._value = undefined;
if (this._parent && this._parent._key === "@each") {
this.value();
}
}
var chains = this._chains;
if (chains) {
for (var key in chains) {
if (!chains.hasOwnProperty(key)) {
continue;
}
chains[key].didChange(events);
}
}
if (events === null) {
return;
}
if (this._parent) {
this._parent.chainDidChange(this, this._key, 1, events);
}
};
function finishChains(obj) {
var m = obj["__ember_meta__"];
var chains, chainWatchers, chainNodes;
if (m) {
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 < l;i++) {
chainNodes[i].didChange(null);
}
}
}
}
chains = m.chains;
if (chains && chains.value() !== obj) {
metaFor(obj).chains = chains = chains.copy(obj);
}
}
}
__exports__.finishChains = finishChains;
__exports__.removeChainWatcher = removeChainWatcher;
__exports__.ChainNode = ChainNode;
});
enifed("ember-metal/computed", ["ember-metal/property_set", "ember-metal/utils", "ember-metal/expand_properties", "ember-metal/error", "ember-metal/properties", "ember-metal/property_events", "ember-metal/dependent_keys", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
var set = __dependency1__.set;
var meta = __dependency2__.meta;
var inspect = __dependency2__.inspect;
var expandProperties = __dependency3__["default"];
var EmberError = __dependency4__["default"];
var Descriptor = __dependency5__.Descriptor;
var defineProperty = __dependency5__.defineProperty;
var propertyWillChange = __dependency6__.propertyWillChange;
var propertyDidChange = __dependency6__.propertyDidChange;
var addDependentKeys = __dependency7__.addDependentKeys;
var removeDependentKeys = __dependency7__.removeDependentKeys;
Ember.warn("The CP_DEFAULT_CACHEABLE flag has been removed and computed properties" + "are always cached by default. Use `volatile` if you don't want caching.", Ember.ENV.CP_DEFAULT_CACHEABLE !== false);
var metaFor = meta;
var a_slice = [].slice;
function UNDEFINED() {
}
function ComputedProperty(func, opts) {
func.__ember_arity__ = func.length;
this.func = func;
this._dependentKeys = undefined;
this._suspended = undefined;
this._meta = undefined;
this._cacheable = opts && opts.cacheable !== undefined ? opts.cacheable : true;
this._dependentKeys = opts && opts.dependentKeys;
this._readOnly = opts && (opts.readOnly !== undefined || !!opts.readOnly) || false;
}
ComputedProperty.prototype = new Descriptor;
var ComputedPropertyPrototype = ComputedProperty.prototype;
ComputedPropertyPrototype.cacheable = function(aFlag) {
this._cacheable = aFlag !== false;
return this;
};
ComputedPropertyPrototype["volatile"] = function() {
return this.cacheable(false);
};
ComputedPropertyPrototype.readOnly = function(readOnly) {
this._readOnly = readOnly === undefined || !!readOnly;
return this;
};
ComputedPropertyPrototype.property = function() {
var args;
var addArg = function(property) {
args.push(property);
};
args = [];
for (var i = 0, l = arguments.length;i < l;i++) {
expandProperties(arguments[i], addArg);
}
this._dependentKeys = args;
return this;
};
ComputedPropertyPrototype.meta = function(meta) {
if (arguments.length === 0) {
return this._meta || {};
} else {
this._meta = meta;
return this;
}
};
ComputedPropertyPrototype.didChange = function(obj, keyName) {
if (this._cacheable && this._suspended !== obj) {
var meta = metaFor(obj);
if (meta.cache[keyName] !== undefined) {
meta.cache[keyName] = undefined;
removeDependentKeys(this, obj, keyName, meta);
}
}
};
function finishChains(chainNodes) {
for (var i = 0, l = chainNodes.length;i < l;i++) {
chainNodes[i].didChange(null);
}
}
ComputedPropertyPrototype.get = function(obj, keyName) {
var ret, cache, meta, chainNodes;
if (this._cacheable) {
meta = metaFor(obj);
cache = meta.cache;
var result = cache[keyName];
if (result === UNDEFINED) {
return undefined;
} else {
if (result !== undefined) {
return result;
}
}
ret = this.func.call(obj, keyName);
if (ret === undefined) {
cache[keyName] = UNDEFINED;
} else {
cache[keyName] = ret;
}
chainNodes = meta.chainWatchers && meta.chainWatchers[keyName];
if (chainNodes) {
finishChains(chainNodes);
}
addDependentKeys(this, obj, keyName, meta);
} else {
ret = this.func.call(obj, keyName);
}
return ret;
};
ComputedPropertyPrototype.set = function computedPropertySetWithSuspend(obj, keyName, value) {
var oldSuspended = this._suspended;
this._suspended = obj;
try {
this._set(obj, keyName, value);
} finally {
this._suspended = oldSuspended;
}
};
ComputedPropertyPrototype._set = function computedPropertySet(obj, keyName, value) {
var cacheable = this._cacheable;
var func = this.func;
var meta = metaFor(obj, cacheable);
var cache = meta.cache;
var hadCachedValue = false;
var funcArgLength, cachedValue, ret;
if (this._readOnly) {
throw new EmberError('Cannot set read-only property "' + keyName + '" on object: ' + inspect(obj));
}
if (cacheable && cache[keyName] !== undefined) {
if (cache[keyName] !== UNDEFINED) {
cachedValue = cache[keyName];
}
hadCachedValue = true;
}
funcArgLength = func.wrappedFunction ? func.wrappedFunction.__ember_arity__ : func.__ember_arity__;
if (funcArgLength === 3) {
ret = func.call(obj, keyName, value, cachedValue);
} else {
if (funcArgLength === 2) {
ret = func.call(obj, keyName, value);
} else {
defineProperty(obj, keyName, null, cachedValue);
set(obj, keyName, value);
return;
}
}
if (hadCachedValue && cachedValue === ret) {
return;
}
var watched = meta.watching[keyName];
if (watched) {
propertyWillChange(obj, keyName);
}
if (hadCachedValue) {
cache[keyName] = undefined;
}
if (cacheable) {
if (!hadCachedValue) {
addDependentKeys(this, obj, keyName, meta);
}
if (ret === undefined) {
cache[keyName] = UNDEFINED;
} else {
cache[keyName] = ret;
}
}
if (watched) {
propertyDidChange(obj, keyName);
}
return ret;
};
ComputedPropertyPrototype.teardown = function(obj, keyName) {
var meta = metaFor(obj);
if (keyName in meta.cache) {
removeDependentKeys(this, obj, keyName, meta);
}
if (this._cacheable) {
delete meta.cache[keyName];
}
return null;
};
function computed(func) {
var args;
if (arguments.length > 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;
}
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__) {
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"];
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);
};
}
computed.empty = function(dependentKey) {
return computed(dependentKey + ".length", function() {
return isEmpty(get(this, dependentKey));
});
};
computed.notEmpty = function(dependentKey) {
return computed(dependentKey + ".length", function() {
return!isEmpty(get(this, dependentKey));
});
};
registerComputed("none", function(dependentKey) {
return isNone(get(this, dependentKey));
});
registerComputed("not", function(dependentKey) {
return!get(this, dependentKey);
});
registerComputed("bool", function(dependentKey) {
return!!get(this, dependentKey);
});
registerComputed("match", function(dependentKey, regexp) {
var value = get(this, dependentKey);
return typeof value === "string" ? regexp.test(value) : false;
});
registerComputed("equal", function(dependentKey, value) {
return get(this, dependentKey) === value;
});
registerComputed("gt", function(dependentKey, value) {
return get(this, dependentKey) > value;
});
registerComputed("gte", function(dependentKey, value) {
return get(this, dependentKey) >= value;
});
registerComputed("lt", function(dependentKey, value) {
return get(this, dependentKey) < value;
});
registerComputed("lte", function(dependentKey, value) {
return get(this, dependentKey) <= value;
});
registerComputedWithProperties("and", function(properties) {
for (var key in properties) {
if (properties.hasOwnProperty(key) && !properties[key]) {
return false;
}
}
return true;
});
registerComputedWithProperties("or", function(properties) {
for (var key in properties) {
if (properties.hasOwnProperty(key) && properties[key]) {
return true;
}
}
return false;
});
registerComputedWithProperties("any", function(properties) {
for (var key in properties) {
if (properties.hasOwnProperty(key) && properties[key]) {
return properties[key];
}
}
return null;
});
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;
});
computed.alias = alias;
computed.oneWay = function(dependentKey) {
return alias(dependentKey).oneWay();
};
computed.reads = computed.oneWay;
computed.readOnly = function(dependentKey) {
return alias(dependentKey).readOnly();
};
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);
});
};
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__) {
if ("undefined" === typeof Ember) {
Ember = {};
}
Ember.imports = Ember.imports || this;
Ember.lookup = Ember.lookup || this;
var exports = Ember.exports = Ember.exports || this;
exports.Em = exports.Ember = Ember;
Ember.isNamespace = true;
Ember.toString = function() {
return "Ember";
};
Ember.VERSION = "1.9.0";
if (Ember.ENV) {
} else {
if ("undefined" !== typeof EmberENV) {
Ember.ENV = EmberENV;
} else {
if ("undefined" !== typeof ENV) {
Ember.ENV = ENV;
} else {
Ember.ENV = {};
}
}
}
Ember.config = Ember.config || {};
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;
Ember.FEATURES = Ember.ENV.FEATURES || {};
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;
}
}
}
};
Ember.EXTEND_PROTOTYPES = Ember.ENV.EXTEND_PROTOTYPES;
if (typeof Ember.EXTEND_PROTOTYPES === "undefined") {
Ember.EXTEND_PROTOTYPES = true;
}
Ember.LOG_STACKTRACE_ON_DEPRECATION = Ember.ENV.LOG_STACKTRACE_ON_DEPRECATION !== false;
Ember.SHIM_ES5 = Ember.ENV.SHIM_ES5 === false ? false : Ember.EXTEND_PROTOTYPES;
Ember.LOG_VERSION = Ember.ENV.LOG_VERSION === false ? false : true;
function K() {
return this;
}
__exports__.K = K;
Ember.K = K;
if ("undefined" === typeof Ember.assert) {
Ember.assert = Ember.K;
}
if ("undefined" === typeof Ember.warn) {
Ember.warn = Ember.K;
}
if ("undefined" === typeof Ember.debug) {
Ember.debug = Ember.K;
}
if ("undefined" === typeof Ember.runInDebug) {
Ember.runInDebug = Ember.K;
}
if ("undefined" === typeof Ember.deprecate) {
Ember.deprecate = Ember.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__) {
var o_create = __dependency1__.create;
var watch = __dependency2__.watch;
var unwatch = __dependency2__.unwatch;
function keysForDep(depsMeta, depKey) {
var keys = depsMeta[depKey];
if (!keys) {
keys = depsMeta[depKey] = {};
} else {
if (!depsMeta.hasOwnProperty(depKey)) {
keys = depsMeta[depKey] = o_create(keys);
}
}
return keys;
}
function metaForDeps(meta) {
return keysForDep(meta, "deps");
}
function addDependentKeys(desc, obj, keyName, meta) {
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];
keys = keysForDep(depsMeta, depKey);
keys[keyName] = (keys[keyName] || 0) + 1;
watch(obj, depKey, meta);
}
}
__exports__.addDependentKeys = addDependentKeys;
function removeDependentKeys(desc, obj, keyName, meta) {
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];
keys = keysForDep(depsMeta, depKey);
keys[keyName] = (keys[keyName] || 0) - 1;
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__) {
var Ember = __dependency1__["default"];
var hasPropertyAccessors = __dependency2__.hasPropertyAccessors;
var defineProperty = __dependency3__.defineProperty;
var get = __dependency4__.get;
var set = __dependency5__.set;
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__) {
var create = __dependency1__.create;
__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__) {
var _filter = __dependency1__.filter;
var a_forEach = __dependency1__.forEach;
var _indexOf = __dependency1__.indexOf;
var _map = __dependency1__.map;
var splice = Array.prototype.splice;
function map(obj, callback, thisArg) {
return obj.map ? obj.map(callback, thisArg) : _map.call(obj, callback, thisArg);
}
__exports__.map = map;
function forEach(obj, callback, thisArg) {
return obj.forEach ? obj.forEach(callback, thisArg) : a_forEach.call(obj, callback, thisArg);
}
__exports__.forEach = forEach;
function filter(obj, callback, thisArg) {
return obj.filter ? obj.filter(callback, thisArg) : _filter.call(obj, callback, thisArg);
}
__exports__.filter = filter;
function indexOf(obj, element, index) {
return obj.indexOf ? obj.indexOf(element, index) : _indexOf.call(obj, element, index);
}
__exports__.indexOf = indexOf;
function indexesOf(obj, elements) {
return elements === undefined ? [] : map(elements, function(item) {
return indexOf(obj, item);
});
}
__exports__.indexesOf = indexesOf;
function addObject(array, item) {
var index = indexOf(array, item);
if (index === -1) {
array.push(item);
}
}
__exports__.addObject = addObject;
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 = [];
var size = 6E4;
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;
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;
function intersection(array1, array2) {
var result = [];
forEach(array1, function(element) {
if (indexOf(array2, element) >= 0) {
result.push(element);
}
});
return result;
}
__exports__.intersection = intersection;
__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__) {
var create = __dependency1__.create;
var errorProps = ["description", "fileName", "lineNumber", "message", "name", "number", "stack"];
function EmberError() {
var tmp = Error.apply(this, arguments);
if (Error.captureStackTrace) {
Error.captureStackTrace(this, Ember.Error);
}
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__) {
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;
var ONCE = 1;
var SUSPENDED = 2;
function indexOf(array, target, method) {
var index = -1;
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) {
listeners = meta.listeners = create(listeners);
listeners.__source__ = obj;
}
}
actions = listeners[eventName];
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 listenersUnion(obj, eventName, otherActions) {
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) {
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);
}
}
}
__exports__.listenersUnion = listenersUnion;
function listenersDiff(obj, eventName, otherActions) {
var meta = obj["__ember_meta__"];
var actions = meta && (meta.listeners && meta.listeners[eventName]);
var diffActions = [];
if (!actions) {
return;
}
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) {
continue;
}
otherActions.push(target, method, flags);
diffActions.push(target, method, flags);
}
return diffActions;
}
__exports__.listenersDiff = listenersDiff;
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;
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);
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]);
}
}
}
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;
}
function tryable() {
return callback.call(target);
}
function finalizer() {
if (actionIndex !== -1) {
actions[actionIndex + 2] &= ~SUSPENDED;
}
}
return tryFinally(tryable, finalizer);
}
__exports__.suspendListener = suspendListener;
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 < l;i++) {
eventName = eventNames[i];
actions = actionsFor(obj, eventName);
var actionIndex = indexOf(actions, target, method);
if (actionIndex !== -1) {
actions[actionIndex + 2] |= SUSPENDED;
suspendedActions.push(actionIndex);
actionsList.push(actions);
}
}
function tryable() {
return callback.call(target);
}
function finalizer() {
for (var i = 0, l = suspendedActions.length;i < l;i++) {
var actionIndex = suspendedActions[i];
actionsList[i][actionIndex + 2] &= ~SUSPENDED;
}
}
return tryFinally(tryable, finalizer);
}
__exports__.suspendListeners = suspendListeners;
function watchedEvents(obj) {
var listeners = obj["__ember_meta__"].listeners, ret = [];
if (listeners) {
for (var eventName in listeners) {
if (eventName !== "__source__" && listeners[eventName]) {
ret.push(eventName);
}
}
}
return ret;
}
__exports__.watchedEvents = watchedEvents;
function sendEvent(obj, eventName, params, actions) {
if (obj !== Ember && "function" === typeof obj.sendEvent) {
obj.sendEvent(eventName, params);
}
if (!actions) {
var meta = obj["__ember_meta__"];
actions = meta && (meta.listeners && meta.listeners[eventName]);
}
if (!actions) {
return;
}
for (var i = actions.length - 3;i >= 0;i -= 3) {
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;
function hasListeners(obj, eventName) {
var meta = obj["__ember_meta__"];
var actions = meta && (meta.listeners && meta.listeners[eventName]);
return!!(actions && actions.length);
}
__exports__.hasListeners = hasListeners;
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;
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__) {
var Ember = __dependency1__["default"];
var EmberError = __dependency2__["default"];
var forEach = __dependency3__.forEach;
var BRACE_EXPANSION = /^((?:[^\.]*\.)*)\{(.*)\}$/;
var SPLIT_REGEX = /\{|\}/;
__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__) {
var get = __dependency1__.get;
var typeOf = __dependency2__.typeOf;
__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/properties", "ember-metal/platform", "ember-metal/utils", "ember-metal/error", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
var Ember = __dependency1__["default"];
var ComputedProperty = __dependency2__.ComputedProperty;
var Descriptor = __dependency3__.Descriptor;
var create = __dependency4__.create;
var inspect = __dependency5__.inspect;
var EmberError = __dependency6__["default"];
function InjectedProperty(type, name) {
this.type = type;
this.name = name;
this._super$Constructor(function(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(type + ":" + (name || keyName));
}, {readOnly:true});
}
InjectedProperty.prototype = create(Descriptor.prototype);
var InjectedPropertyPrototype = InjectedProperty.prototype;
var ComputedPropertyPrototype = ComputedProperty.prototype;
InjectedPropertyPrototype._super$Constructor = ComputedProperty;
InjectedPropertyPrototype.get = ComputedPropertyPrototype.get;
InjectedPropertyPrototype.set = function(obj, keyName) {
throw new EmberError("Cannot set injected property '" + keyName + "' on object: " + inspect(obj));
};
InjectedPropertyPrototype.teardown = ComputedPropertyPrototype.teardown;
__exports__["default"] = InjectedProperty;
});
enifed("ember-metal/instrumentation", ["ember-metal/core", "ember-metal/utils", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var Ember = __dependency1__["default"];
var tryCatchFinally = __dependency2__.tryCatchFinally;
var subscribers = [];
__exports__.subscribers = subscribers;
var cache = {};
var populateListeners = function(name) {
var listeners = [];
var subscriber;
for (var i = 0, l = subscribers.length;i < l;i++) {
subscriber = subscribers[i];
if (subscriber.regex.test(name)) {
listeners.push(subscriber.object);
}
}
cache[name] = listeners;
return listeners;
};
var time = function() {
var perf = "undefined" !== typeof window ? window.performance || {} : {};
var fn = perf.now || (perf.mozNow || (perf.webkitNow || (perf.msNow || perf.oNow)));
return fn ? fn.bind(perf) : function() {
return+new Date;
};
}();
function instrument(name, _payload, callback, binding) {
if (subscribers.length === 0) {
return callback.call(binding);
}
var payload = _payload || {};
var finalizer = _instrumentStart(name, function() {
return payload;
});
if (finalizer) {
var tryable = function _instrumenTryable() {
return callback.call(binding);
};
var catchable = function _instrumentCatchable(e) {
payload.exception = e;
};
return tryCatchFinally(tryable, catchable, finalizer);
} else {
return callback.call(binding);
}
}
__exports__.instrument = instrument;
function _instrumentStart(name, _payload) {
var listeners = cache[name];
if (!listeners) {
listeners = populateListeners(name);
}
if (listeners.length === 0) {
return;
}
var payload = _payload();
var STRUCTURED_PROFILE = Ember.STRUCTURED_PROFILE;
var timeName;
if (STRUCTURED_PROFILE) {
timeName = name + ": " + payload.object;
console.time(timeName);
}
var l = listeners.length;
var beforeValues = new Array(l);
var i, listener;
var timestamp = time();
for (i = 0;i < l;i++) {
listener = listeners[i];
beforeValues[i] = listener.before(name, timestamp, payload);
}
return function _instrumentEnd() {
var i, l, listener;
var timestamp = time();
for (i = 0, l = listeners.length;i < l;i++) {
listener = listeners[i];
listener.after(name, timestamp, payload, beforeValues[i]);
}
if (STRUCTURED_PROFILE) {
console.timeEnd(timeName);
}
};
}
__exports__._instrumentStart = _instrumentStart;
function subscribe(pattern, object) {
var paths = pattern.split("."), path, regex = [];
for (var i = 0, l = paths.length;i < l;i++) {
path = paths[i];
if (path === "*") {
regex.push("[^\\.]*");
} else {
regex.push(path);
}
}
regex = regex.join("\\.");
regex = regex + "(\\..*)?";
var subscriber = {pattern:pattern, regex:new RegExp("^" + regex + "$"), object:object};
subscribers.push(subscriber);
cache = {};
return subscriber;
}
__exports__.subscribe = subscribe;
function unsubscribe(subscriber) {
var index;
for (var i = 0, l = subscribers.length;i < l;i++) {
if (subscribers[i] === subscriber) {
index = i;
}
}
subscribers.splice(index, 1);
cache = {};
}
__exports__.unsubscribe = unsubscribe;
function reset() {
subscribers.length = 0;
cache = {};
}
__exports__.reset = reset;
});
enifed("ember-metal/is_blank", ["ember-metal/is_empty", "exports"], function(__dependency1__, __exports__) {
var isEmpty = __dependency1__["default"];
__exports__["default"] = function isBlank(obj) {
return isEmpty(obj) || typeof obj === "string" && obj.match(/\S/) === null;
};
});
enifed("ember-metal/is_empty", ["ember-metal/property_get", "ember-metal/is_none", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var get = __dependency1__.get;
var isNone = __dependency2__["default"];
function isEmpty(obj) {
var none = isNone(obj);
if (none) {
return none;
}
if (typeof obj.size === "number") {
return!obj.size;
}
var objectType = typeof obj;
if (objectType === "object") {
var size = get(obj, "size");
if (typeof size === "number") {
return!size;
}
}
if (typeof obj.length === "number" && objectType !== "function") {
return!obj.length;
}
if (objectType === "object") {
var length = get(obj, "length");
if (typeof length === "number") {
return!length;
}
}
return false;
}
__exports__["default"] = isEmpty;
});
enifed("ember-metal/is_none", ["exports"], function(__exports__) {
function isNone(obj) {
return obj === null || obj === undefined;
}
__exports__["default"] = isNone;
});
enifed("ember-metal/is_present", ["ember-metal/is_blank", "exports"], function(__dependency1__, __exports__) {
var isBlank = __dependency1__["default"];
var isPresent;
isPresent = function isPresent(obj) {
return!isBlank(obj);
};
__exports__["default"] = isPresent;
});
enifed("ember-metal/keys", ["ember-metal/platform", "exports"], function(__dependency1__, __exports__) {
var canDefineNonEnumerableProperties = __dependency1__.canDefineNonEnumerableProperties;
var keys = Object.keys;
if (!keys || !canDefineNonEnumerableProperties) {
keys = function() {
var hasOwnProperty = Object.prototype.hasOwnProperty, hasDontEnumBug = !{toString:null}.propertyIsEnumerable("toString"), dontEnums = ["toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "constructor"], dontEnumsLength = dontEnums.length;
return function keys(obj) {
if (typeof obj !== "object" && (typeof obj !== "function" || obj === null)) {
throw new TypeError("Object.keys called on non-object");
}
var result = [];
var prop, i;
for (prop in obj) {
if (prop !== "_super" && (prop.lastIndexOf("__", 0) !== 0 && hasOwnProperty.call(obj, prop))) {
result.push(prop);
}
}
if (hasDontEnumBug) {
for (i = 0;i < dontEnumsLength;i++) {
if (hasOwnProperty.call(obj, dontEnums[i])) {
result.push(dontEnums[i]);
}
}
}
return result;
};
}();
}
__exports__["default"] = keys;
});
enifed("ember-metal/libraries", ["ember-metal/enumerable_utils", "exports"], function(__dependency1__, __exports__) {
var forEach = __dependency1__.forEach;
var indexOf = __dependency1__.indexOf;
var libraries = function() {
var _libraries = [];
var coreLibIndex = 0;
var getLibrary = function(name) {
for (var i = 0;i < _libraries.length;i++) {
if (_libraries[i].name === name) {
return _libraries[i];
}
}
};
_libraries.register = function(name, version) {
if (!getLibrary(name)) {
_libraries.push({name:name, version:version});
}
};
_libraries.registerCoreLibrary = function(name, version) {
if (!getLibrary(name)) {
_libraries.splice(coreLibIndex++, 0, {name:name, version:version});
}
};
_libraries.deRegister = function(name) {
var lib = getLibrary(name);
if (lib) {
_libraries.splice(indexOf(_libraries, lib), 1);
}
};
_libraries.each = function(callback) {
forEach(_libraries, function(lib) {
callback(lib.name, lib.version);
});
};
return _libraries;
}();
__exports__["default"] = libraries;
});
enifed("ember-metal/logger", ["ember-metal/core", "ember-metal/error", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var Ember = __dependency1__["default"];
var EmberError = __dependency2__["default"];
function consoleMethod(name) {
var consoleObj, logToConsole;
if (Ember.imports.console) {
consoleObj = Ember.imports.console;
} else {
if (typeof console !== "undefined") {
consoleObj = console;
}
}
var method = typeof consoleObj === "object" ? consoleObj[name] : null;
if (method) {
if (typeof method.bind === "function") {
logToConsole = method.bind(consoleObj);
logToConsole.displayName = "console." + name;
return logToConsole;
} else {
if (typeof method.apply === "function") {
logToConsole = function() {
method.apply(consoleObj, arguments);
};
logToConsole.displayName = "console." + name;
return logToConsole;
} else {
return function() {
var message = Array.prototype.join.call(arguments, ", ");
method(message);
};
}
}
}
}
function assertPolyfill(test, message) {
if (!test) {
try {
throw new EmberError("assertion failed: " + message);
} catch (error) {
setTimeout(function() {
throw error;
}, 0);
}
}
}
__exports__["default"] = {log:consoleMethod("log") || Ember.K, warn:consoleMethod("warn") || Ember.K, error:consoleMethod("error") || Ember.K, info:consoleMethod("info") || Ember.K, debug:consoleMethod("debug") || (consoleMethod("info") || Ember.K), assert:consoleMethod("assert") || assertPolyfill};
});
enifed("ember-metal/map", ["ember-metal/utils", "ember-metal/array", "ember-metal/platform", "ember-metal/deprecate_property", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
var guidFor = __dependency1__.guidFor;
var indexOf = __dependency2__.indexOf;
var create = __dependency3__.create;
var deprecateProperty = __dependency4__.deprecateProperty;
function missingFunction(fn) {
throw new TypeError("" + Object.prototype.toString.call(fn) + " is not a function");
}
function missingNew(name) {
throw new TypeError("Constructor " + name + "requires 'new'");
}
function copyNull(obj) {
var output = create(null);
for (var prop in obj) {
output[prop] = obj[prop];
}
return output;
}
function copyMap(original, newObject) {
var keys = original.keys.copy();
var values = copyNull(original.values);
newObject.keys = keys;
newObject.values = values;
newObject.size = original.size;
return newObject;
}
function OrderedSet() {
if (this instanceof OrderedSet) {
this.clear();
this._silenceRemoveDeprecation = false;
} else {
missingNew("OrderedSet");
}
}
OrderedSet.create = function() {
var Constructor = this;
return new Constructor;
};
OrderedSet.prototype = {constructor:OrderedSet, clear:function() {
this.presenceSet = create(null);
this.list = [];
this.size = 0;
}, add:function(obj, _guid) {
var guid = _guid || guidFor(obj);
var presenceSet = this.presenceSet;
var list = this.list;
if (presenceSet[guid] === true) {
return;
}
presenceSet[guid] = true;
this.size = list.push(obj);
return this;
}, remove:function(obj, _guid) {
Ember.deprecate("Calling `OrderedSet.prototype.remove` has been deprecated, please use `OrderedSet.prototype.delete` instead.", this._silenceRemoveDeprecation);
return this["delete"](obj, _guid);
}, "delete":function(obj, _guid) {
var guid = _guid || guidFor(obj);
var presenceSet = this.presenceSet;
var list = this.list;
if (presenceSet[guid] === true) {
delete presenceSet[guid];
var index = indexOf.call(list, obj);
if (index > -1) {
list.splice(index, 1);
}
this.size = list.length;
return true;
} else {
return false;
}
}, isEmpty:function() {
return this.size === 0;
}, has:function(obj) {
if (this.size === 0) {
return false;
}
var guid = guidFor(obj);
var presenceSet = this.presenceSet;
return presenceSet[guid] === true;
}, forEach:function(fn) {
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]);
}
}
}, toArray:function() {
return this.list.slice();
}, 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");
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;
Map.create = function() {
var Constructor = this;
return new Constructor;
};
Map.prototype = {constructor:Map, size:0, get:function(key) {
if (this.size === 0) {
return;
}
var values = this.values;
var guid = guidFor(key);
return values[guid];
}, set:function(key, value) {
var keys = this.keys;
var values = this.values;
var guid = guidFor(key);
var k = key === -0 ? 0 : key;
keys.add(k, guid);
values[guid] = value;
this.size = keys.size;
return this;
}, remove:function(key) {
Ember.deprecate("Calling `Map.prototype.remove` has been deprecated, please use `Map.prototype.delete` instead.");
return this["delete"](key);
}, "delete":function(key) {
if (this.size === 0) {
return false;
}
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;
}
}, has:function(key) {
return this.keys.has(key);
}, forEach:function(callback) {
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);
}, clear:function() {
this.keys.clear();
this.values = create(null);
this.size = 0;
}, copy:function() {
return copyMap(this, new Map);
}};
deprecateProperty(Map.prototype, "length", "size");
function MapWithDefault(options) {
this._super$constructor();
this.defaultValue = options.defaultValue;
}
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;
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;
}
};
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__) {
var keys = __dependency1__["default"];
__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", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__,
__dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __exports__) {
var Ember = __dependency1__["default"];
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 apply = __dependency7__.apply;
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 REQUIRED;
var a_slice = [].slice;
function superFunction() {
var func = this.__nextSuper;
var ret;
if (func) {
var args = new Array(arguments.length);
for (var i = 0, l = args.length;i < l;i++) {
args[i] = arguments[i];
}
this.__nextSuper = null;
ret = apply(this, func, args);
this.__nextSuper = func;
}
return ret;
}
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;
}
}
function concatenatedMixinProperties(concatProp, props, values, base) {
var concats;
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;
if (values[key] === undefined) {
superProperty = descs[key];
}
superProperty = superProperty || meta.descs[key];
if (superProperty === undefined || !(superProperty instanceof ComputedProperty)) {
return property;
}
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;
if (descs[key] === undefined) {
superMethod = values[key];
}
superMethod = superMethod || obj[key];
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)) {
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;
}
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 < l;i++) {
mixin = mixins[i];
Ember.assert("Expected hash or Mixin instance, got " + Object.prototype.toString.call(mixin), typeof mixin === "object" && (mixin !== null && Object.prototype.toString.call(mixin) !== "[object Array]"));
props = mixinProperties(m, mixin);
if (props === CONTINUE) {
continue;
}
if (props) {
meta = metaFor(base);
if (base.willMergeMixin) {
base.willMergeMixin(props);
}
concats = concatenatedMixinProperties("concatenatedProperties", props, values, base);
mergings = concatenatedMixinProperties("mergedProperties", props, values, base);
for (key in props) {
if (!props.hasOwnProperty(key)) {
continue;
}
keys.push(key);
addNormalizedProperty(base, key, props[key], meta, descs, values, concats, mergings);
}
if (props.hasOwnProperty("toString")) {
base.toString = props.toString;
}
} else {
if (mixin.mixins) {
mergeMixins(mixin.mixins, m, descs, values, base, keys);
if (mixin._without) {
a_forEach.call(mixin._without, removeKeys);
}
}
}
}
}
var IS_BINDING = /^.+Binding$/;
function detectBinding(obj, key, value, m) {
if (IS_BINDING.test(key)) {
var bindings = m.bindings;
if (!bindings) {
bindings = m.bindings = {};
} else {
if (!m.hasOwnProperty("bindings")) {
bindings = m.bindings = o_create(m.bindings);
}
}
bindings[key] = value;
}
}
function connectStreamBinding(obj, key, stream) {
var onNotify = function(stream) {
_suspendObserver(obj, key, null, didChange, function() {
trySet(obj, key, stream.value());
});
};
var didChange = function() {
stream.setValue(get(obj, key), onNotify);
};
set(obj, key, stream.value());
addObserver(obj, key, null, didChange);
stream.subscribe(onNotify);
if (obj._streamBindingSubscriptions === undefined) {
obj._streamBindingSubscriptions = o_create(null);
}
obj._streamBindingSubscriptions[key] = onNotify;
}
function connectBindings(obj, m) {
var bindings = m.bindings;
var key, binding, to;
if (bindings) {
for (key in bindings) {
binding = bindings[key];
if (binding) {
to = key.slice(0, -7);
if (binding.isStream) {
connectStreamBinding(obj, to, binding);
continue;
} else {
if (binding instanceof Binding) {
binding = binding.copy();
binding.to(to);
} else {
binding = new Binding(to, binding);
}
}
binding.connect(obj);
obj[key] = binding;
}
}
m.bindings = {};
}
}
function finishPartial(obj, m) {
connectBindings(obj, m || metaFor(obj));
return obj;
}
function followAlias(obj, desc, m, descs, values) {
var altKey = desc.methodName;
var value;
if (descs[altKey] || values[altKey]) {
value = values[altKey];
desc = descs[altKey];
} else {
if (m.descs[altKey]) {
desc = m.descs[altKey];
value = undefined;
} else {
desc = undefined;
value = obj[altKey];
}
}
return{desc:desc, value:value};
}
function updateObserversAndListeners(obj, key, observerOrListener, pathsKey, updateMethod) {
var paths = observerOrListener[pathsKey];
if (paths) {
for (var i = 0, l = paths.length;i < l;i++) {
updateMethod(obj, paths[i], null, key);
}
}
}
function replaceObserversAndListeners(obj, key, observerOrListener) {
var prev = obj[key];
if ("function" === typeof prev) {
updateObserversAndListeners(obj, key, prev, "__ember_observesBefore__", removeBeforeObserver);
updateObserversAndListeners(obj, key, prev, "__ember_observes__", removeObserver);
updateObserversAndListeners(obj, key, prev, "__ember_listens__", removeListener);
}
if ("function" === typeof observerOrListener) {
updateObserversAndListeners(obj, key, observerOrListener, "__ember_observesBefore__", addBeforeObserver);
updateObserversAndListeners(obj, key, observerOrListener, "__ember_observes__", addObserver);
updateObserversAndListeners(obj, key, observerOrListener, "__ember_listens__", addListener);
}
}
function applyMixin(obj, mixins, partial) {
var descs = {};
var values = {};
var m = metaFor(obj);
var keys = [];
var key, value, desc;
obj._super = superFunction;
mergeMixins(mixins, mixinsMeta(obj), descs, values, obj, keys);
for (var i = 0, l = keys.length;i < l;i++) {
key = keys[i];
if (key === "constructor" || !values.hasOwnProperty(key)) {
continue;
}
desc = descs[key];
value = values[key];
if (desc === REQUIRED) {
continue;
}
while (desc && desc instanceof Alias) {
var followed = followAlias(obj, desc, m, descs, values);
desc = followed.desc;
value = followed.value;
}
if (desc === undefined && value === undefined) {
continue;
}
replaceObserversAndListeners(obj, key, value);
detectBinding(obj, key, value, m);
defineProperty(obj, key, desc, value, m);
}
if (!partial) {
finishPartial(obj, m);
}
return obj;
}
function mixin(obj) {
var args = a_slice.call(arguments, 1);
applyMixin(obj, args, false);
return obj;
}
__exports__.mixin = mixin;
__exports__["default"] = Mixin;
function Mixin(args, properties) {
this.properties = properties;
var length = args && args.length;
if (length > 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;
Ember.anyUnprocessedMixins = false;
Mixin.create = function() {
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;
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;
};
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;
}
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;
};
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];
if (!mixin.properties) {
ret.push(mixin);
}
}
return ret;
};
REQUIRED = new Descriptor;
REQUIRED.toString = function() {
return "(Required Property)";
};
function required() {
return REQUIRED;
}
__exports__.required = required;
function Alias(methodName) {
this.methodName = methodName;
}
Alias.prototype = new Descriptor;
function aliasMethod(methodName) {
return new Alias(methodName);
}
__exports__.aliasMethod = aliasMethod;
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") {
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;
function immediateObserver() {
for (var i = 0, l = arguments.length;i < l;i++) {
var arg = arguments[i];
Ember.assert("Immediate observers must observe internal properties only, not properties on other objects.", typeof arg !== "string" || arg.indexOf(".") === -1);
}
return observer.apply(this, arguments);
}
__exports__.immediateObserver = immediateObserver;
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") {
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__) {
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;
var AFTER_OBSERVERS = ":change";
var BEFORE_OBSERVERS = ":before";
function changeEvent(keyName) {
return keyName + AFTER_OBSERVERS;
}
function beforeEvent(keyName) {
return keyName + BEFORE_OBSERVERS;
}
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;
function removeObserver(obj, path, target, method) {
unwatch(obj, path);
removeListener(obj, changeEvent(path), target, method);
return this;
}
__exports__.removeObserver = removeObserver;
function addBeforeObserver(obj, path, target, method) {
addListener(obj, beforeEvent(path), target, method);
watch(obj, path);
return this;
}
__exports__.addBeforeObserver = addBeforeObserver;
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;
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__) {
var guidFor = __dependency1__.guidFor;
var sendEvent = __dependency2__.sendEvent;
__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__) {
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(1E3, function(key) {
return IS_GLOBAL.test(key);
});
var isGlobalPathCache = new Cache(1E3, function(key) {
return IS_GLOBAL_PATH.test(key);
});
var hasThisCache = new Cache(1E3, function(key) {
return key.indexOf(HAS_THIS) !== -1;
});
var firstDotIndexCache = new Cache(1E3, function(key) {
return key.indexOf(".");
});
var firstKeyCache = new Cache(1E3, function(path) {
var index = firstDotIndexCache.get(path);
if (index === -1) {
return path;
} else {
return path.slice(0, index);
}
});
var tailPathCache = new Cache(1E3, 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__) {
var hasES5CompliantDefineProperty = __dependency1__.hasES5CompliantDefineProperty;
var defineProperty = __dependency1__.defineProperty;
var defineProperties = __dependency2__["default"];
var create = __dependency3__["default"];
var hasPropertyAccessors = hasES5CompliantDefineProperty;
var canDefineNonEnumerableProperties = hasES5CompliantDefineProperty;
__exports__.create = create;
__exports__.defineProperty = defineProperty;
__exports__.defineProperties = defineProperties;
__exports__.hasPropertyAccessors = hasPropertyAccessors;
__exports__.canDefineNonEnumerableProperties = canDefineNonEnumerableProperties;
});
enifed("ember-metal/platform/create", ["exports"], function(__exports__) {
var create;
if (!(Object.create && !Object.create(null).hasOwnProperty)) {
var createEmpty;
var supportsProto = !({"__proto__":null} instanceof Object);
if (supportsProto || typeof document === "undefined") {
createEmpty = function() {
return{"__proto__":null};
};
} else {
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;
createEmpty = function() {
return new Empty;
};
return new Empty;
};
}
create = Object.create = function create(prototype, properties) {
var object;
function Type() {
}
if (prototype === null) {
object = createEmpty();
} else {
if (typeof prototype !== "object" && typeof prototype !== "function") {
throw new TypeError("Object prototype may only be an Object or null");
}
Type.prototype = prototype;
object = new Type;
}
if (properties !== undefined) {
Object.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__) {
var defineProperty = __dependency1__.defineProperty;
var defineProperties = Object.defineProperties;
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__) {
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;
}
defineProperty(obj, "a", {configurable:true, enumerable:false, writable:true, value:true});
for (var key in obj) {
if (key === "a") {
return;
}
}
if (obj.a !== true) {
return;
}
return defineProperty;
} catch (e) {
return;
}
}(Object.defineProperty);
var hasES5CompliantDefineProperty = !!defineProperty;
if (hasES5CompliantDefineProperty && typeof document !== "undefined") {
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) {
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__) {
var Ember = __dependency1__["default"];
var metaFor = __dependency2__.meta;
var objectDefineProperty = __dependency3__.defineProperty;
var hasPropertyAccessors = __dependency3__.hasPropertyAccessors;
var overrideChains = __dependency4__.overrideChains;
function Descriptor() {
}
__exports__.Descriptor = Descriptor;
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;
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});
} else {
obj[keyName] = undefined;
}
if (desc.setup) {
desc.setup(obj, keyName);
}
} else {
descs[keyName] = undefined;
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;
objectDefineProperty(obj, keyName, desc);
}
}
if (watching) {
overrideChains(obj, keyName, meta);
}
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__) {
var guidFor = __dependency1__.guidFor;
var tryFinally = __dependency1__.tryFinally;
var sendEvent = __dependency2__.sendEvent;
var listenersUnion = __dependency2__.listenersUnion;
var listenersDiff = __dependency2__.listenersDiff;
var ObserverSet = __dependency3__["default"];
var beforeObserverSet = new ObserverSet;
var observerSet = new ObserverSet;
var deferred = 0;
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);
}
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;
}
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;
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;
}
}
}
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 < keys.length;i++) {
key = keys[i];
desc = descs[key];
if (desc && desc._suspended === obj) {
continue;
}
method(obj, key);
}
}
}
function chainsWillChange(obj, keyName, m) {
if (!(m.hasOwnProperty("chainWatchers") && m.chainWatchers[keyName])) {
return;
}
var nodes = m.chainWatchers[keyName];
var events = [];
var i, l;
for (i = 0, l = nodes.length;i < l;i++) {
nodes[i].willChange(events);
}
for (i = 0, l = events.length;i < l;i += 2) {
propertyWillChange(events[i], events[i + 1]);
}
}
function chainsDidChange(obj, keyName, m, suppressEvents) {
if (!(m && (m.hasOwnProperty("chainWatchers") && m.chainWatchers[keyName]))) {
return;
}
var nodes = m.chainWatchers[keyName];
var events = suppressEvents ? null : [];
var i, l;
for (i = 0, l = nodes.length;i < l;i++) {
nodes[i].didChange(events);
}
if (suppressEvents) {
return;
}
for (i = 0, l = events.length;i < l;i += 2) {
propertyDidChange(events[i], events[i + 1]);
}
}
function overrideChains(obj, keyName, m) {
chainsDidChange(obj, keyName, m, true);
}
function beginPropertyChanges() {
deferred++;
}
function endPropertyChanges() {
deferred--;
if (deferred <= 0) {
beforeObserverSet.clear();
observerSet.flush();
}
}
function changeProperties(cb, binding) {
beginPropertyChanges();
tryFinally(cb, endPropertyChanges, binding);
}
function notifyBeforeObservers(obj, keyName) {
if (obj.isDestroying) {
return;
}
var eventName = keyName + ":before";
var listeners, diff;
if (deferred) {
listeners = beforeObserverSet.add(obj, keyName, eventName);
diff = listenersDiff(obj, eventName, listeners);
sendEvent(obj, eventName, [obj, keyName], diff);
} else {
sendEvent(obj, eventName, [obj, keyName]);
}
}
function notifyObservers(obj, keyName) {
if (obj.isDestroying) {
return;
}
var eventName = keyName + ":change";
var listeners;
if (deferred) {
listeners = observerSet.add(obj, keyName, eventName);
listenersUnion(obj, eventName, listeners);
} else {
sendEvent(obj, eventName, [obj, keyName]);
}
}
__exports__.propertyWillChange = propertyWillChange;
__exports__.propertyDidChange = propertyDidChange;
__exports__.overrideChains = overrideChains;
__exports__.beginPropertyChanges = beginPropertyChanges;
__exports__.endPropertyChanges = endPropertyChanges;
__exports__.changeProperties = changeProperties;
});
enifed("ember-metal/property_get", ["ember-metal/core", "ember-metal/error", "ember-metal/path_cache", "ember-metal/platform", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
var Ember = __dependency1__["default"];
var EmberError = __dependency2__["default"];
var isGlobalPath = __dependency3__.isGlobalPath;
var isPath = __dependency3__.isPath;
var pathHasThis = __dependency3__.hasThis;
var hasPropertyAccessors = __dependency4__.hasPropertyAccessors;
var FIRST_KEY = /^([^\.]+)/;
var get = function get(obj, keyName) {
if (keyName === "") {
return obj;
}
if (!keyName && "string" === typeof obj) {
keyName = obj;
obj = null;
}
Ember.assert("Cannot call get with " + keyName + " key.", !!keyName);
Ember.assert("Cannot call get with '" + keyName + "' on an undefined object.", obj !== undefined);
if (obj === null) {
var value = _getPath(obj, keyName);
Ember.deprecate("Ember.get fetched '" + keyName + "' from the global context. This behavior will change in the future (issue #3852)", !value || (obj && obj !== Ember.lookup || (isPath(keyName) || isGlobalPath(keyName + "."))));
return value;
}
var meta = obj["__ember_meta__"];
var desc = meta && meta.descs[keyName];
var ret;
if (desc === undefined && isPath(keyName)) {
return _getPath(obj, keyName);
}
if (desc) {
return desc.get(obj, keyName);
} else {
if (hasPropertyAccessors && (meta && meta.watching[keyName] > 0)) {
ret = meta.values[keyName];
} else {
ret = obj[keyName];
}
if (ret === undefined && ("object" === typeof obj && (!(keyName in obj) && "function" === typeof obj.unknownProperty))) {
return obj.unknownProperty(keyName);
}
return ret;
}
};
if (Ember.config.overrideAccessors) {
Ember.get = get;
Ember.config.overrideAccessors();
get = Ember.get;
}
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);
}
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 (root === null && !isPath(path)) {
return get(Ember.lookup, path);
}
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__) {
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$]))/;
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);
if (isUnknown && "function" === typeof obj.setUnknownProperty) {
obj.setUnknownProperty(keyName, value);
} else {
if (meta && meta.watching[keyName] > 0) {
if (hasPropertyAccessors) {
currentValue = meta.values[keyName];
} else {
currentValue = obj[keyName];
}
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);
} else {
meta.values[keyName] = value;
}
} else {
obj[keyName] = value;
}
propertyDidChange(obj, keyName);
}
} else {
obj[keyName] = value;
}
}
}
return value;
};
if (Ember.config.overrideAccessors) {
Ember.set = set;
Ember.config.overrideAccessors();
set = Ember.set;
}
function setPath(root, path, value, tolerant) {
var keyName;
keyName = path.slice(path.lastIndexOf(".") + 1);
path = path === keyName ? keyName : path.slice(0, path.length - (keyName.length + 1));
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);
}
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__) {
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;
}
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;
__exports__["default"] = run;
function run() {
return backburner.run.apply(backburner, arguments);
}
run.join = function() {
return backburner.join.apply(backburner, arguments);
};
run.bind = function(target, method) {
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;
run.begin = function() {
backburner.begin();
};
run.end = function() {
backburner.end();
};
run.schedule = function(queue, target, method) {
checkAutoRun();
backburner.schedule.apply(backburner, arguments);
};
run.hasScheduledTimers = function() {
return backburner.hasTimers();
};
run.cancelTimers = function() {
backburner.cancelTimers();
};
run.sync = function() {
if (backburner.currentInstance) {
backburner.currentInstance.queues.sync.flush();
}
};
run.later = function() {
return backburner.later.apply(backburner, arguments);
};
run.once = function() {
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);
};
run.scheduleOnce = function() {
checkAutoRun();
return backburner.scheduleOnce.apply(backburner, arguments);
};
run.next = function() {
var args = slice.call(arguments);
args.push(1);
return apply(backburner, backburner.later, args);
};
run.cancel = function(timer) {
return backburner.cancel(timer);
};
run.debounce = function() {
return backburner.debounce.apply(backburner, arguments);
};
run.throttle = function() {
return backburner.throttle.apply(backburner, arguments);
};
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 an run", !Ember.testing);
}
}
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__) {
var changeProperties = __dependency1__.changeProperties;
var set = __dependency2__.set;
var keys = __dependency3__["default"];
__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/read", ["exports"], function(__exports__) {
function read(object) {
if (object && object.isStream) {
return object.value();
} else {
return object;
}
}
__exports__.read = read;
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;
function readHash(object) {
var ret = {};
for (var key in object) {
ret[key] = read(object[key]);
}
return ret;
}
__exports__.readHash = readHash;
});
enifed("ember-metal/streams/simple", ["ember-metal/merge", "ember-metal/streams/stream", "ember-metal/platform", "ember-metal/streams/read", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
var merge = __dependency1__["default"];
var Stream = __dependency2__["default"];
var create = __dependency3__.create;
var read = __dependency4__.read;
function SimpleStream(source) {
this.source = source;
if (source && source.isStream) {
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 (source && source.isStream) {
source.setValue(value);
}
}, setSource:function(nextSource) {
var prevSource = this.source;
if (nextSource !== prevSource) {
if (prevSource && prevSource.isStream) {
prevSource.unsubscribe(this._didChange, this);
}
if (nextSource && nextSource.isStream) {
nextSource.subscribe(this._didChange, this);
}
this.source = nextSource;
this.notify();
}
}, _didChange:function() {
this.notify();
}, destroy:function() {
if (this.source && this.source.isStream) {
this.source.unsubscribe(this._didChange, this);
}
this.source = undefined;
Stream.prototype.destroy.call(this);
}});
__exports__["default"] = SimpleStream;
});
enifed("ember-metal/streams/stream", ["ember-metal/platform", "ember-metal/path_cache", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var create = __dependency1__.create;
var getFirstKey = __dependency2__.getFirstKey;
var getTailPath = __dependency2__.getTailPath;
var NIL = function NIL() {
};
function Stream(fn) {
this.valueFn = fn;
this.cache = NIL;
this.subscribers = undefined;
this.children = undefined;
this.destroyed = false;
}
Stream.prototype = {isStream:true, cache:NIL, 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.cache !== NIL) {
return this.cache;
} else {
return this.cache = this.valueFn();
}
}, setValue:function() {
throw new Error("Stream error: setValue not implemented");
}, notify:function() {
this.notifyExcept();
}, notifyExcept:function(callbackToSkip, contextToSkip) {
if (this.cache !== NIL) {
this.cache = NIL;
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.destroyed) {
return;
}
this.destroyed = true;
var children = this.children;
for (var key in children) {
children[key].destroy();
}
}, 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__) {
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.stream = stream;
this.senderCallback = undefined;
this.senderContext = undefined;
this.senderValue = undefined;
this.destroyed = false;
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.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;
this.cache = undefined;
this.notifyExcept(senderCallback, senderContext);
}, destroy:function() {
if (this.destroyed) {
return;
}
this.destroyed = true;
this.stream.unsubscribe(this._onNotify, this);
}});
__exports__["default"] = StreamBinding;
});
enifed("ember-metal/utils", ["ember-metal/core", "ember-metal/platform", "ember-metal/array", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
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;
var _uuid = 0;
function uuid() {
return++_uuid;
}
__exports__.uuid = uuid;
var GUID_PREFIX = "ember";
var numberCache = [];
var stringCache = {};
function intern(str) {
var obj = {};
obj[str] = 1;
for (var key in obj) {
if (key === str) {
return key;
}
}
return str;
}
var GUID_KEY = intern("__ember" + +new Date);
var GUID_DESC = {writable:false, configurable:false, enumerable:false, value:null};
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;
function guidFor(obj) {
if (obj === undefined) {
return "(undefined)";
}
if (obj === null) {
return "(null)";
}
var ret;
var type = typeof obj;
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;
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) {
Meta.prototype.__preventPlainObject__ = true;
Meta.prototype.toJSON = function() {
};
}
var EMPTY_META = new Meta(null);
if (hasPropertyAccessors) {
EMPTY_META.values = {};
}
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;
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;
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 < l;i++) {
keyName = path[i];
value = _meta[keyName];
if (!value) {
if (!writable) {
return undefined;
}
value = _meta[keyName] = {__ember_source__:obj};
} else {
if (value.__ember_source__ !== obj) {
if (!writable) {
return undefined;
}
value = _meta[keyName] = o_create(value);
value.__ember_source__ = obj;
}
}
_meta = value;
}
return value;
}
__exports__.metaPath = metaPath;
function wrap(func, superFunc) {
function superWrapper() {
var ret;
var sup = this && this.__nextSuper;
var args = new Array(arguments.length);
for (var i = 0, l = args.length;i < l;i++) {
args[i] = arguments[i];
}
if (this) {
this.__nextSuper = superFunc;
}
ret = apply(this, func, args);
if (this) {
this.__nextSuper = sup;
}
return ret;
}
superWrapper.wrappedFunction = func;
superWrapper.wrappedFunction.__ember_arity__ = func.length;
superWrapper.__ember_observes__ = func.__ember_observes__;
superWrapper.__ember_observesBefore__ = func.__ember_observesBefore__;
superWrapper.__ember_listens__ = func.__ember_listens__;
return superWrapper;
}
__exports__.wrap = wrap;
var EmberArray;
function isArray(obj) {
var modulePath, type;
if (typeof EmberArray === "undefined") {
modulePath = "ember-runtime/mixins/array";
if (Ember.__loader.registry[modulePath]) {
EmberArray = Ember.__loader.require(modulePath)["default"];
}
}
if (!obj || obj.setInterval) {
return false;
}
if (Array.isArray && Array.isArray(obj)) {
return true;
}
if (EmberArray && EmberArray.detect(obj)) {
return true;
}
type = typeOf(obj);
if ("array" === type) {
return true;
}
if (obj.length !== undefined && "object" === type) {
return true;
}
return false;
}
function makeArray(obj) {
if (obj === null || obj === undefined) {
return[];
}
return isArray(obj) ? obj : [obj];
}
__exports__.makeArray = makeArray;
function canInvoke(obj, methodName) {
return!!(obj && typeof obj[methodName] === "function");
}
function tryInvoke(obj, methodName, args) {
if (canInvoke(obj, methodName)) {
return args ? applyStr(obj, methodName, args) : applyStr(obj, methodName);
}
}
__exports__.tryInvoke = tryInvoke;
var needsFinallyFix = function() {
var count = 0;
try {
try {
} finally {
count++;
throw new Error("needsFinallyFixTest");
}
} catch (e) {
}
return count !== 1;
}();
var tryFinally;
if (needsFinallyFix) {
tryFinally = function(tryable, finalizer, binding) {
var result, finalResult, finalError;
binding = binding || this;
try {
result = tryable.call(binding);
} finally {
try {
finalResult = finalizer.call(binding);
} catch (e) {
finalError = e;
}
}
if (finalError) {
throw finalError;
}
return finalResult === undefined ? result : finalResult;
};
} else {
tryFinally = function(tryable, finalizer, binding) {
var result, finalResult;
binding = binding || this;
try {
result = tryable.call(binding);
} finally {
finalResult = finalizer.call(binding);
}
return finalResult === undefined ? result : finalResult;
};
}
var tryCatchFinally;
if (needsFinallyFix) {
tryCatchFinally = function(tryable, catchable, finalizer, binding) {
var result, finalResult, finalError;
binding = binding || this;
try {
result = tryable.call(binding);
} catch (error) {
result = catchable.call(binding, error);
} finally {
try {
finalResult = finalizer.call(binding);
} catch (e) {
finalError = e;
}
}
if (finalError) {
throw finalError;
}
return finalResult === undefined ? result : finalResult;
};
} else {
tryCatchFinally = function(tryable, catchable, finalizer, binding) {
var result, finalResult;
binding = binding || this;
try {
result = tryable.call(binding);
} catch (error) {
result = catchable.call(binding, error);
} finally {
finalResult = finalizer.call(binding);
}
return finalResult === undefined ? result : finalResult;
};
}
var TYPE_MAP = {};
var t = "Boolean Number String Function Array Date RegExp Object".split(" ");
forEach.call(t, function(name) {
TYPE_MAP["[object " + name + "]"] = name.toLowerCase();
});
var toString = Object.prototype.toString;
var EmberObject;
function typeOf(item) {
var ret, modulePath;
if (typeof EmberObject === "undefined") {
modulePath = "ember-runtime/system/object";
if (Ember.__loader.registry[modulePath]) {
EmberObject = Ember.__loader.require(modulePath)["default"];
}
}
ret = item === null || item === undefined ? String(item) : TYPE_MAP[toString.call(item)] || "object";
if (ret === "function") {
if (EmberObject && EmberObject.detect(item)) {
ret = "class";
}
} else {
if (ret === "object") {
if (item instanceof Error) {
ret = "error";
} else {
if (EmberObject && item instanceof EmberObject) {
ret = "instance";
} else {
if (item instanceof Date) {
ret = "date";
}
}
}
}
}
return ret;
}
function inspect(obj) {
var type = typeOf(obj);
if (type === "array") {
return "[" + obj + "]";
}
if (type !== "object") {
return obj + "";
}
var v;
var ret = [];
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
v = obj[key];
if (v === "toString") {
continue;
}
if (typeOf(v) === "function") {
v = "function() { ... }";
}
if (v && typeof v.toString !== "function") {
ret.push(key + ": " + toString.call(v));
} else {
ret.push(key + ": " + v);
}
}
}
return "{" + ret.join(", ") + "}";
}
__exports__.inspect = inspect;
function apply(t, m, a) {
var l = a && a.length;
if (!a || !l) {
return m.call(t);
}
switch(l) {
case 1:
return m.call(t, a[0]);
case 2:
return m.call(t, a[0], a[1]);
case 3:
return m.call(t, a[0], a[1], a[2]);
case 4:
return m.call(t, a[0], a[1], a[2], a[3]);
case 5:
return m.call(t, a[0], a[1], a[2], a[3], a[4]);
default:
return m.apply(t, a);
}
}
__exports__.apply = apply;
function applyStr(t, m, a) {
var l = a && a.length;
if (!a || !l) {
return t[m]();
}
switch(l) {
case 1:
return t[m](a[0]);
case 2:
return t[m](a[0], a[1]);
case 3:
return t[m](a[0], a[1], a[2]);
case 4:
return t[m](a[0], a[1], a[2], a[3]);
case 5:
return t[m](a[0], a[1], a[2], a[3], a[4]);
default:
return t[m].apply(t, a);
}
}
__exports__.applyStr = applyStr;
__exports__.GUID_KEY = GUID_KEY;
__exports__.META_DESC = META_DESC;
__exports__.EMPTY_META = EMPTY_META;
__exports__.meta = meta;
__exports__.typeOf = typeOf;
__exports__.tryCatchFinally = tryCatchFinally;
__exports__.isArray = isArray;
__exports__.canInvoke = canInvoke;
__exports__.tryFinally = tryFinally;
});
enifed("ember-metal/watch_key", ["ember-metal/core", "ember-metal/utils", "ember-metal/platform", "ember-metal/properties", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
var Ember = __dependency1__["default"];
var metaFor = __dependency2__.meta;
var typeOf = __dependency2__.typeOf;
var o_defineProperty = __dependency3__.defineProperty;
var hasPropertyAccessors = __dependency3__.hasPropertyAccessors;
var MANDATORY_SETTER_FUNCTION = __dependency4__.MANDATORY_SETTER_FUNCTION;
var DEFAULT_GETTER_FUNCTION = __dependency4__.DEFAULT_GETTER_FUNCTION;
function watchKey(obj, keyName, meta) {
if (keyName === "length" && typeOf(obj) === "array") {
return;
}
var m = meta || metaFor(obj), watching = m.watching;
if (!watching[keyName]) {
watching[keyName] = 1;
var desc = m.descs[keyName];
if (desc && desc.willWatch) {
desc.willWatch(obj, keyName);
}
if ("function" === typeof obj.willWatchProperty) {
obj.willWatchProperty(keyName);
}
if (hasPropertyAccessors) {
handleMandatorySetter(m, obj, keyName);
}
} else {
watching[keyName] = (watching[keyName] || 0) + 1;
}
}
__exports__.watchKey = watchKey;
var handleMandatorySetter = function handleMandatorySetter(m, obj, keyName) {
var descriptor = Object.getOwnPropertyDescriptor && Object.getOwnPropertyDescriptor(obj, keyName);
var configurable = descriptor ? descriptor.configurable : true;
if (configurable && keyName in obj) {
m.values[keyName] = obj[keyName];
o_defineProperty(obj, keyName, {configurable:true, enumerable:Object.prototype.propertyIsEnumerable.call(obj, keyName), set:MANDATORY_SETTER_FUNCTION(keyName), get:DEFAULT_GETTER_FUNCTION(keyName)});
}
};
function unwatchKey(obj, keyName, meta) {
var m = meta || metaFor(obj);
var watching = m.watching;
if (watching[keyName] === 1) {
watching[keyName] = 0;
var desc = m.descs[keyName];
if (desc && desc.didUnwatch) {
desc.didUnwatch(obj, keyName);
}
if ("function" === typeof obj.didUnwatchProperty) {
obj.didUnwatchProperty(keyName);
}
if (hasPropertyAccessors && keyName in obj) {
o_defineProperty(obj, keyName, {configurable:true, enumerable:Object.prototype.propertyIsEnumerable.call(obj, keyName), set:function(val) {
o_defineProperty(obj, keyName, {configurable:true, writable:true, enumerable:true, value:val});
delete m.values[keyName];
}, get:DEFAULT_GETTER_FUNCTION(keyName)});
}
} else {
if (watching[keyName] > 1) {
watching[keyName]--;
}
}
}
__exports__.unwatchKey = unwatchKey;
});
enifed("ember-metal/watch_path", ["ember-metal/utils", "ember-metal/chains", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var metaFor = __dependency1__.meta;
var typeOf = __dependency1__.typeOf;
var ChainNode = __dependency2__.ChainNode;
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) {
if (keyPath === "length" && typeOf(obj) === "array") {
return;
}
var m = meta || metaFor(obj);
var watching = m.watching;
if (!watching[keyPath]) {
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__) {
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;
function watch(obj, _keyPath, m) {
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) {
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 = [];
function destroy(obj) {
var meta = obj["__ember_meta__"], node, nodes, key, nodeObject;
if (meta) {
obj["__ember_meta__"] = null;
node = meta.chains;
if (node) {
NODE_STACK.push(node);
while (NODE_STACK.length > 0) {
node = NODE_STACK.pop();
nodes = node._chains;
if (nodes) {
for (key in nodes) {
if (nodes.hasOwnProperty(key)) {
NODE_STACK.push(nodes[key]);
}
}
}
if (node._watching) {
nodeObject = node._object;
if (nodeObject) {
removeChainWatcher(nodeObject, node._key, node);
}
}
}
}
}
}
__exports__.destroy = destroy;
});
enifed("ember-routing-handlebars", ["ember-metal/core", "ember-handlebars", "ember-routing-handlebars/helpers/link_to", "ember-routing-handlebars/helpers/outlet", "ember-routing-handlebars/helpers/render", "ember-routing-handlebars/helpers/action", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __exports__) {
var Ember = __dependency1__["default"];
var EmberHandlebars = __dependency2__["default"];
var deprecatedLinkToHelper = __dependency3__.deprecatedLinkToHelper;
var linkToHelper = __dependency3__.linkToHelper;
var LinkView = __dependency3__.LinkView;
var queryParamsHelper = __dependency3__.queryParamsHelper;
var outletHelper = __dependency4__.outletHelper;
var OutletView = __dependency4__.OutletView;
var renderHelper = __dependency5__["default"];
var ActionHelper = __dependency6__.ActionHelper;
var actionHelper = __dependency6__.actionHelper;
Ember.LinkView = LinkView;
EmberHandlebars.ActionHelper = ActionHelper;
EmberHandlebars.OutletView = OutletView;
EmberHandlebars.registerHelper("render", renderHelper);
EmberHandlebars.registerHelper("action", actionHelper);
EmberHandlebars.registerHelper("outlet", outletHelper);
EmberHandlebars.registerHelper("link-to", linkToHelper);
EmberHandlebars.registerHelper("linkTo", deprecatedLinkToHelper);
EmberHandlebars.registerHelper("query-params", queryParamsHelper);
__exports__["default"] = Ember;
});
enifed("ember-routing-handlebars/helpers/action", ["ember-metal/core", "ember-metal/array", "ember-metal/utils", "ember-metal/run_loop", "ember-views/streams/read", "ember-views/system/utils", "ember-views/system/action_manager", "ember-handlebars", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
var Ember = __dependency1__["default"];
var forEach = __dependency2__.forEach;
var uuid = __dependency3__.uuid;
var run = __dependency4__["default"];
var readUnwrappedModel = __dependency5__.readUnwrappedModel;
var isSimpleClick = __dependency6__.isSimpleClick;
var ActionManager = __dependency7__["default"];
var EmberHandlebars = __dependency8__["default"];
function actionArgs(parameters, actionName) {
var ret, i;
if (actionName === undefined) {
ret = new Array(parameters.length);
for (i = 0;i < parameters.length;i++) {
ret[i] = readUnwrappedModel(parameters[i]);
}
} else {
ret = new Array(parameters.length + 1);
ret[0] = actionName;
for (i = 0;i < parameters.length;i++) {
ret[i + 1] = readUnwrappedModel(parameters[i]);
}
}
return ret;
}
var ActionHelper = {};
ActionHelper.registeredActions = ActionManager.registeredActions;
__exports__.ActionHelper = ActionHelper;
var keys = ["alt", "shift", "meta", "ctrl"];
var POINTER_EVENT_TYPE_REGEX = /^click|mouse|touch/;
var isAllowedEvent = function(event, allowedKeys) {
if (typeof allowedKeys === "undefined") {
if (POINTER_EVENT_TYPE_REGEX.test(event.type)) {
return isSimpleClick(event);
} else {
allowedKeys = "";
}
}
if (allowedKeys.indexOf("any") >= 0) {
return true;
}
var allowed = true;
forEach.call(keys, function(key) {
if (event[key + "Key"] && allowedKeys.indexOf(key) === -1) {
allowed = false;
}
});
return allowed;
};
function isKeyEvent(eventName) {
return["keyUp", "keyPress", "keyDown"].indexOf(eventName) !== -1;
}
function ignoreKeyEvent(eventName, event, keyCode) {
var any = "any";
keyCode = keyCode || any;
return isKeyEvent(eventName) && (keyCode !== any && keyCode !== event.which.toString());
}
ActionHelper.registerAction = function(actionNameOrStream, options, allowedKeys) {
var actionId = uuid();
var eventName = options.eventName;
var parameters = options.parameters;
ActionManager.registeredActions[actionId] = {eventName:eventName, handler:function handleRegisteredAction(event) {
if (!isAllowedEvent(event, allowedKeys)) {
return true;
}
if (options.preventDefault !== false) {
event.preventDefault();
}
if (options.bubbles === false) {
event.stopPropagation();
}
var target = options.target.value();
var actionName;
if (actionNameOrStream.isStream) {
actionName = actionNameOrStream.value();
if (typeof actionName === "undefined" || typeof actionName === "function") {
actionName = actionNameOrStream._originalPath;
Ember.deprecate("You specified a quoteless path to the {{action}} helper '" + actionName + "' which did not resolve to an actionName." + " Perhaps you meant to use a quoted actionName? (e.g. {{action '" + actionName + "'}}).");
}
}
if (!actionName) {
actionName = actionNameOrStream;
}
run(function runRegisteredAction() {
if (target.send) {
target.send.apply(target, actionArgs(parameters, actionName));
} else {
Ember.assert("The action '" + actionName + "' did not exist on " + target, typeof target[actionName] === "function");
target[actionName].apply(target, actionArgs(parameters));
}
});
}};
options.view.on("willClearRender", function() {
delete ActionManager.registeredActions[actionId];
});
return actionId;
};
function actionHelper(actionName) {
var length = arguments.length;
var options = arguments[length - 1];
var view = options.data.view;
var hash = options.hash;
var types = options.types;
var parameters = [];
var actionOptions = {eventName:hash.on || "click", parameters:parameters, view:options.data.view, bubbles:hash.bubbles, preventDefault:hash.preventDefault, target:view.getStream(hash.target || "controller"), withKeyCode:hash.withKeyCode};
var actionNameStream;
if (types[0] === "ID") {
actionNameStream = view.getStream(actionName);
actionNameStream._originalPath = actionName;
} else {
actionNameStream = actionName;
}
for (var i = 1;i < length - 1;i++) {
if (types[i] === "ID") {
parameters.push(view.getStream(arguments[i]));
} else {
parameters.push(arguments[i]);
}
}
var actionId = ActionHelper.registerAction(actionNameStream, actionOptions, hash.allowedKeys);
return new EmberHandlebars.SafeString('data-ember-action="' + actionId + '"');
}
__exports__.actionHelper = actionHelper;
});
enifed("ember-routing-handlebars/helpers/link_to", ["ember-metal/core", "ember-metal/property_get", "ember-metal/merge", "ember-metal/run_loop", "ember-metal/computed", "ember-runtime/system/string", "ember-runtime/system/object", "ember-runtime/mixins/controller", "ember-metal/keys", "ember-views/system/utils", "ember-views/views/component", "ember-handlebars/helpers/view", "ember-routing/utils", "ember-handlebars/ext", "ember-metal/streams/read", "ember-handlebars", "exports"], function(__dependency1__,
__dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __exports__) {
var Ember = __dependency1__["default"];
var get = __dependency2__.get;
var merge = __dependency3__["default"];
var run = __dependency4__["default"];
var computed = __dependency5__.computed;
var fmt = __dependency6__.fmt;
var EmberObject = __dependency7__["default"];
var ControllerMixin = __dependency8__["default"];
var keys = __dependency9__["default"];
var isSimpleClick = __dependency10__.isSimpleClick;
var EmberComponent = __dependency11__["default"];
var viewHelper = __dependency12__.viewHelper;
var routeArgs = __dependency13__.routeArgs;
var stringifyValue = __dependency14__.stringifyValue;
var read = __dependency15__.read;
var slice = [].slice;
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;
};
var QueryParams = EmberObject.extend({values:null});
var LinkView = Ember.LinkView = EmberComponent.extend({tagName:"a", currentWhen:null, "current-when":null, title:null, rel:null, activeClass:"active", loadingClass:"loading", disabledClass:"disabled", _isDisabled:false, replace:false, attributeBindings:["href", "title", "rel", "tabindex"], classNameBindings:["active", "loading", "disabled"], eventName:"click", init:function() {
this._super.apply(this, arguments);
Ember.deprecate("Using currentWhen with {{link-to}} is deprecated in favor of `current-when`.", !this.currentWhen);
var eventName = get(this, "eventName");
this.on(eventName, this, this._invoke);
}, _paramsChanged:function() {
this.notifyPropertyChange("resolvedParams");
}, _setupPathObservers:function() {
var params = this.params;
var scheduledRerender = this._wrapAsScheduled(this.rerender);
var scheduledParamsChanged = this._wrapAsScheduled(this._paramsChanged);
if (this.linkTitle) {
this.linkTitle.subscribe(scheduledRerender, this);
}
for (var i = 0;i < params.length;i++) {
var param = params[i];
if (param && param.isStream) {
param.subscribe(scheduledParamsChanged, this);
}
}
var queryParamsObject = this.queryParamsObject;
if (queryParamsObject) {
var values = queryParamsObject.values;
for (var k in values) {
if (!values.hasOwnProperty(k)) {
continue;
}
var value = values[k];
if (value && value.isStream) {
value.subscribe(scheduledParamsChanged, this);
}
}
}
}, afterRender:function() {
this._super.apply(this, arguments);
this._setupPathObservers();
}, disabled:computed(function computeLinkViewDisabled(key, value) {
if (value !== undefined) {
this.set("_isDisabled", value);
}
return value ? get(this, "disabledClass") : false;
}), 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);
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");
}
}
}), loading:computed("loadedParams", function computeLinkViewLoading() {
if (!get(this, "loadedParams")) {
return get(this, "loadingClass");
}
}), router:computed(function() {
var controller = get(this, "controller");
if (controller && controller.container) {
return controller.container.lookup("router:main");
}
}), _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");
}
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);
}, _eagerUpdateUrl:function(transition, href) {
if (!transition.isActive || !transition.urlMethod) {
return;
}
if (href.indexOf("#") === 0) {
href = href.slice(1);
}
var routerjs = get(this, "router.router");
if (transition.urlMethod === "update") {
routerjs.updateURL(href);
} else {
if (transition.urlMethod === "replace") {
routerjs.replaceURL(href);
}
}
transition.method(null);
}, 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};
}), 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, 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;
}), loadingHref:"#"});
LinkView.toString = function() {
return "LinkView";
};
LinkView.reopen({attributeBindings:["target"], target:null});
function linkToHelper(name) {
var options = slice.call(arguments, -1)[0];
var params = slice.call(arguments, 0, -1);
var view = options.data.view;
var hash = options.hash;
var hashTypes = options.hashTypes;
var types = options.types;
var shouldEscape = !hash.unescaped;
var queryParamsObject;
Ember.assert("You must provide one or more parameters to the link-to helper.", params.length);
if (params[params.length - 1] instanceof QueryParams) {
hash.queryParamsObject = queryParamsObject = params.pop();
}
if (hash.disabledWhen) {
hash.disabledBinding = hash.disabledWhen;
hashTypes.disabledBinding = hashTypes.disabledWhen;
delete hash.disabledWhen;
delete hashTypes.disabledWhen;
}
if (!options.fn) {
var linkTitle = params.shift();
var linkTitleType = types.shift();
if (linkTitleType === "ID") {
hash.linkTitle = linkTitle = view.getStream(linkTitle);
options.fn = function() {
return stringifyValue(linkTitle.value(), shouldEscape);
};
} else {
options.fn = function() {
return linkTitle;
};
}
}
for (var i = 0;i < params.length;i++) {
var paramPath = params[i];
if (types[i] === "ID") {
var lazyValue = view.getStream(paramPath);
if (paramPath !== "controller") {
while (ControllerMixin.detect(lazyValue.value())) {
paramPath = paramPath === "" ? "model" : paramPath + ".model";
lazyValue = view.getStream(paramPath);
}
}
params[i] = lazyValue;
}
}
hash.params = params;
options.helperName = options.helperName || "link-to";
return viewHelper.call(this, LinkView, options);
}
function queryParamsHelper(options) {
Ember.assert(fmt("The `query-params` helper only accepts hash parameters, e.g. (query-params queryParamPropertyName='%@') as opposed to just (query-params '%@')", [options, options]), arguments.length === 1);
var view = options.data.view;
var hash = options.hash;
var hashTypes = options.hashTypes;
for (var k in hash) {
if (hashTypes[k] === "ID") {
hash[k] = view.getStream(hash[k]);
}
}
return QueryParams.create({values:options.hash});
}
__exports__.queryParamsHelper = queryParamsHelper;
function deprecatedLinkToHelper() {
Ember.deprecate("The 'linkTo' view helper is deprecated in favor of 'link-to'");
return linkToHelper.apply(this, arguments);
}
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;
__exports__.deprecatedLinkToHelper = deprecatedLinkToHelper;
__exports__.linkToHelper = linkToHelper;
});
enifed("ember-routing-handlebars/helpers/outlet", ["ember-metal/core", "ember-metal/property_set", "ember-views/views/container_view", "ember-handlebars/views/metamorph_view", "ember-handlebars/helpers/view", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
var Ember = __dependency1__["default"];
var set = __dependency2__.set;
var ContainerView = __dependency3__["default"];
var _Metamorph = __dependency4__._Metamorph;
var viewHelper = __dependency5__.viewHelper;
var OutletView = ContainerView.extend(_Metamorph);
__exports__.OutletView = OutletView;
function outletHelper(property, options) {
var outletSource;
var viewName;
var viewClass;
var viewFullName;
if (property && (property.data && property.data.isRenderData)) {
options = property;
property = "main";
}
Ember.deprecate("Using {{outlet}} with an unquoted name is not supported. " + "Please update to quoted usage '{{outlet \"" + property + "\"}}'.", arguments.length === 1 || options.types[0] === "STRING");
var view = options.data.view;
var container = view.container;
outletSource = view;
while (!outletSource.get("template.isTop")) {
outletSource = outletSource.get("_parentView");
}
set(view, "outletSource", outletSource);
viewName = options.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 + '"}}.', options.hashTypes.view !== "ID");
Ember.assert("The view name you supplied '" + viewName + "' did not resolve to a view.", container.has(viewFullName));
}
viewClass = viewName ? container.lookupFactory(viewFullName) : options.hash.viewClass || OutletView;
options.types = ["ID"];
options.hash.currentViewBinding = "_view.outletSource._outlets." + property;
options.hashTypes.currentViewBinding = "STRING";
options.helperName = options.helperName || "outlet";
return viewHelper.call(this, viewClass, options);
}
__exports__.outletHelper = outletHelper;
});
enifed("ember-routing-handlebars/helpers/render", ["ember-metal/core", "ember-metal/error", "ember-runtime/system/string", "ember-routing/system/generate_controller", "ember-handlebars/helpers/view", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
var Ember = __dependency1__["default"];
var EmberError = __dependency2__["default"];
var camelize = __dependency3__.camelize;
var generateControllerFactory = __dependency4__.generateControllerFactory;
var generateController = __dependency4__["default"];
var ViewHelper = __dependency5__.ViewHelper;
__exports__["default"] = function renderHelper(name, contextString, options) {
var length = arguments.length;
var container, router, controller, view, initialContext;
container = (options || contextString).data.view._keywords.controller.value().container;
router = container.lookup("router:main");
if (length === 2) {
options = contextString;
contextString = undefined;
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 (length === 3) {
initialContext = options.data.view.getStream(contextString).value();
} else {
throw new EmberError("You must pass a templateName to render");
}
}
Ember.deprecate("Using a quoteless parameter with {{render}} is deprecated. Please update to" + " quoted usage '{{render \"" + name + '"}}.', options.types[0] !== "ID");
name = name.replace(/\//g, ".");
view = container.lookup("view:" + name) || container.lookup("view:default");
var controllerName = options.hash.controller || name;
var controllerFullName = "controller:" + controllerName;
if (options.hash.controller) {
Ember.assert("The controller name you supplied '" + controllerName + "' did not resolve to a controller.", container.has(controllerFullName));
}
var parentController = options.data.view._keywords.controller.value();
if (length > 2) {
var factory = container.lookupFactory(controllerFullName) || generateControllerFactory(container, controllerName, initialContext);
controller = factory.create({modelBinding:options.data.view._getBindingForStream(contextString), parentController:parentController, target:parentController});
view.one("willDestroyElement", function() {
controller.destroy();
});
} else {
controller = container.lookup(controllerFullName) || generateController(container, controllerName);
controller.setProperties({target:parentController, parentController:parentController});
}
options.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.fn));
options.hash.template = container.lookup(templateName);
options.hash.controller = controller;
if (router && !initialContext) {
router._connectActiveView(name, view);
}
options.helperName = options.helperName || 'render "' + name + '"';
ViewHelper.instanceHelper(this, view, options);
};
});
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__) {
var Ember = __dependency1__["default"];
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__) {
var Ember = __dependency1__["default"];
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"];
ControllerMixin.reopen({concatenatedProperties:["queryParams", "_pCacheMeta"], init:function() {
this._super.apply(this, arguments);
listenForQueryParamChanges(this);
}, queryParams:null, _qpDelegate:null, _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;
}), _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, values:null, scope:scope, prefix:"", def:get(this, prop)};
}
return cacheMeta;
}), _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);
}
}
}, _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);
var cache = this._bucketCache;
if (cache) {
controller._bucketCache.stash(cacheKey, prop, value);
}
var delegate = controller._qpDelegate;
if (delegate) {
delegate(controller, prop);
}
}, _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, "-");
}, transitionToRoute:function() {
var target = get(this, "target");
var method = target.transitionToRoute || target.transitionTo;
return method.apply(target, arguments);
}, transitionTo:function() {
Ember.deprecate("transitionTo is deprecated. Please use transitionToRoute.");
return this.transitionToRoute.apply(this, arguments);
}, replaceRoute:function() {
var target = get(this, "target");
var method = target.replaceRoute || target.replaceWith;
return method.apply(target, arguments);
}, 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, 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__) {
var run = __dependency1__["default"];
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__) {
var get = __dependency1__.get;
var set = __dependency2__.set;
var run = __dependency3__["default"];
var EmberView = __dependency4__["default"];
EmberView.reopen({init:function() {
this._outlets = {};
this._super();
}, 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);
}
}, _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")));
}, disconnectOutlet:function(outletName) {
if (!this._pendingDisconnections) {
this._pendingDisconnections = {};
}
this._pendingDisconnections[outletName] = true;
run.once(this, "_finishDisconnections");
}, _finishDisconnections:function() {
if (this.isDestroyed) {
return;
}
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__) {
var Ember = __dependency1__["default"];
__exports__["default"] = {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);
}, 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, _getHash:function() {
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__) {
var Ember = __dependency1__["default"];
var set = __dependency2__.set;
var EmberLocation = __dependency3__["default"];
var HistoryLocation = __dependency4__["default"];
var HashLocation = __dependency5__["default"];
var NoneLocation = __dependency6__["default"];
__exports__["default"] = {cancelRouterSetup:false, rootURL:"/", _window:window, _location:window.location, _history:window.history, _HistoryLocation:HistoryLocation, _HashLocation:HashLocation, _NoneLocation:NoneLocation, _getOrigin:function() {
var location = this._location;
var origin = location.origin;
if (!origin) {
origin = location.protocol + "//" + location.hostname;
if (location.port) {
origin += ":" + location.port;
}
}
return origin;
}, _getSupportsHistory:function() {
var userAgent = this._window.navigator.userAgent;
if (userAgent.indexOf("Android 2") !== -1 && (userAgent.indexOf("Mobile Safari") !== -1 && userAgent.indexOf("Chrome") === -1)) {
return false;
}
return!!(this._history && "pushState" in this._history);
}, _getSupportsHashChange:function() {
var _window = this._window;
var documentMode = _window.document.documentMode;
return "onhashchange" in _window && (documentMode === undefined || documentMode > 7);
}, _replacePath:function(path) {
this._location.replace(this._getOrigin() + path);
}, _getRootURL:function() {
return this.rootURL;
}, _getPath:function() {
var pathname = this._location.pathname;
if (pathname.charAt(0) !== "/") {
pathname = "/" + pathname;
}
return pathname;
}, _getHash:EmberLocation._getHash, _getQuery:function() {
return this._location.search;
}, _getFullPath:function() {
return this._getPath() + this._getQuery() + this._getHash();
}, _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);
if (hash.substr(0, 2) === "#/") {
hashParts = hash.substr(1).split("#");
routeHash = hashParts.shift();
if (path.slice(-1) === "/") {
routeHash = routeHash.substr(1);
}
path += routeHash;
path += query;
if (hashParts.length) {
path += "#" + hashParts.join("#");
}
} else {
path += query;
path += hash;
}
return path;
}, _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;
}, 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();
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();
if (currentPath === hashPath || currentPath === "/" && hashPath === "/#/") {
implementationClass = this._HashLocation;
} else {
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__) {
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"];
__exports__["default"] = EmberObject.extend({implementation:"hash", init:function() {
set(this, "location", get(this, "_location") || window.location);
}, getHash:EmberLocation._getHash, getURL:function() {
var originalPath = this.getHash().substr(1);
var outPath = originalPath;
if (outPath.charAt(0) !== "/") {
outPath = "/";
if (originalPath) {
outPath += "#" + originalPath;
}
}
return outPath;
}, setURL:function(path) {
get(this, "location").hash = path;
set(this, "lastSetURL", path);
}, replaceURL:function(path) {
get(this, "location").replace("#" + path);
set(this, "lastSetURL", path);
}, 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);
});
});
}, formatURL:function(url) {
return "#" + url;
}, 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__) {
var get = __dependency1__.get;
var set = __dependency2__.set;
var guidFor = __dependency3__.guidFor;
var EmberObject = __dependency4__["default"];
var EmberLocation = __dependency5__["default"];
var jQuery = __dependency6__["default"];
var popstateFired = false;
var supportsHistoryState = window.history && "state" in window.history;
__exports__["default"] = EmberObject.extend({implementation:"history", init:function() {
set(this, "location", get(this, "location") || window.location);
set(this, "baseURL", jQuery("base").attr("href") || "");
}, initState:function() {
set(this, "history", get(this, "history") || window.history);
this.replaceState(this.formatURL(this.getURL()));
}, rootURL:"/", 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;
}, setURL:function(path) {
var state = this.getState();
path = this.formatURL(path);
if (!state || state.path !== path) {
this.pushState(path);
}
}, replaceURL:function(path) {
var state = this.getState();
path = this.formatURL(path);
if (!state || state.path !== path) {
this.replaceState(path);
}
}, getState:function() {
return supportsHistoryState ? get(this, "history").state : this._historyState;
}, pushState:function(path) {
var state = {path:path};
get(this, "history").pushState(state, null, path);
if (!supportsHistoryState) {
this._historyState = state;
}
this._previousURL = this.getURL();
}, replaceState:function(path) {
var state = {path:path};
get(this, "history").replaceState(state, null, path);
if (!supportsHistoryState) {
this._historyState = state;
}
this._previousURL = this.getURL();
}, onUpdateURL:function(callback) {
var guid = guidFor(this);
var self = this;
jQuery(window).on("popstate.ember-location-" + guid, function(e) {
if (!popstateFired) {
popstateFired = true;
if (self.getURL() === self._previousURL) {
return;
}
}
callback(self.getURL());
});
}, 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;
}, willDestroy:function() {
var guid = guidFor(this);
jQuery(window).off("popstate.ember-location-" + guid);
}, 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__) {
var get = __dependency1__.get;
var set = __dependency2__.set;
var EmberObject = __dependency3__["default"];
__exports__["default"] = EmberObject.extend({implementation:"none", path:"", getURL:function() {
return get(this, "path");
}, setURL:function(path) {
set(this, "path", path);
}, onUpdateURL:function(callback) {
this.updateCallback = callback;
}, handleURL:function(url) {
set(this, "path", url);
this.updateCallback(url);
}, formatURL:function(url) {
return url;
}});
});
enifed("ember-routing/system/cache", ["ember-runtime/system/object", "exports"], function(__dependency1__, __exports__) {
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__) {
__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__) {
var Ember = __dependency1__["default"];
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 < l;i++) {
var dslMatch = dslMatches[i];
match(dslMatch[0]).to(dslMatch[1], dslMatch[2]);
}
};
}};
function canNest(dsl) {
return dsl.parent && dsl.parent !== "application";
}
function getFullName(dsl, name, resetNamespace) {
if (canNest(dsl) && resetNamespace !== true) {
return dsl.parent + "." + name;
} else {
return name;
}
}
function createRoute(dsl, name, options, callback) {
options = options || {};
var fullName = getFullName(dsl, name, options.resetNamespace);
if (typeof options.path !== "string") {
options.path = "/" + name;
}
dsl.push(options.path, fullName, callback);
}
DSL.map = function(callback) {
var dsl = new DSL;
callback.call(dsl);
return dsl;
};
});
enifed("ember-routing/system/generate_controller", ["ember-metal/core", "ember-metal/property_get", "ember-metal/utils", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
var Ember = __dependency1__["default"];
var get = __dependency2__.get;
var isArray = __dependency3__.isArray;
function generateControllerFactory(container, controllerName, context) {
var Factory, fullName, factoryName, controllerType;
if (context && isArray(context)) {
controllerType = "array";
} else {
if (context) {
controllerType = "object";
} else {
controllerType = "basic";
}
}
factoryName = "controller:" + controllerType;
Factory = container.lookupFactory(factoryName).extend({isGenerated:true, toString:function() {
return "(generated " + controllerName + " controller)";
}});
fullName = "controller:" + controllerName;
container.register(fullName, Factory);
return Factory;
}
__exports__.generateControllerFactory = generateControllerFactory;
__exports__["default"] = function generateController(container, controllerName, context) {
generateControllerFactory(container, controllerName, context);
var fullName = "controller:" + controllerName;
var instance = container.lookup(fullName);
if (get(instance, "namespace.LOG_ACTIVE_GENERATION")) {
Ember.Logger.info("generated -> " + fullName, {fullName:fullName});
}
return instance;
};
});
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__) {
var Ember = __dependency1__["default"];
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;
var Route = EmberObject.extend(ActionHandler, {queryParams:{}, _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]);
}}};
}), _names:null, _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;
}
}, _updateSerializedQPValue:function(controller, qp) {
var value = get(controller, qp.prop);
qp.svalue = this.serializeQueryParam(value, qp.urlKey, qp.type);
}, _activeQPChanged:function(controller, qp) {
var value = get(controller, qp.prop);
this.router._queuedQPChanges[qp.fprop] = value;
run.once(this, this._fireQueryParamTransition);
}, _updatingQPChanged:function(controller, qp) {
var router = this.router;
if (!router._qpUpdates) {
router._qpUpdates = {};
}
router._qpUpdates[qp.urlKey] = true;
}, mergedProperties:["events", "queryParams"], 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;
}, serializeQueryParamKey:function(controllerPropertyName) {
return controllerPropertyName;
}, serializeQueryParam:function(value, urlKey, defaultValueType) {
if (defaultValueType === "array") {
return JSON.stringify(value);
}
return "" + value;
}, deserializeQueryParam:function(value, urlKey, defaultValueType) {
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;
}, _fireQueryParamTransition:function() {
this.transitionTo({queryParams:this.router._queuedQPChanges});
this.router._queuedQPChanges = {};
}, _optionsForQueryParam:function(qp) {
return get(this, "queryParams." + qp.urlKey) || (get(this, "queryParams." + qp.prop) || {});
}, resetController:Ember.K, exit:function() {
this.deactivate();
this.trigger("deactivate");
this.teardownViews();
}, _reset:function(isExiting, transition) {
var controller = this.controller;
controller._qpDelegate = get(this, "_qp.states.inactive");
this.resetController(controller, isExiting, transition);
}, enter:function() {
this.activate();
this.trigger("activate");
}, viewName:null, templateName:null, controllerName:null, _actions:{queryParamsDidChange:function(changed, totalPresent, removed) {
var qpMap = this.get("_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;
}
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;
var value, svalue;
if (changes && qp.urlKey in changes) {
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 {
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) {
replaceUrl = false;
}
}
}
set(controller, qp.prop, value);
}
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;
}}, events:null, deactivate:Ember.K, activate:Ember.K, transitionTo:function(name, context) {
var router = this.router;
return router.transitionTo.apply(router, arguments);
}, intermediateTransitionTo:function() {
var router = this.router;
router.intermediateTransitionTo.apply(router, arguments);
}, refresh:function() {
return this.router.router.refresh(this);
}, replaceWith:function() {
var router = this.router;
return router.replaceWith.apply(router, arguments);
}, 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);
}
}
}, setup:function(context, transition) {
var controllerName = this.controllerName || this.routeName;
var controller = this.controllerFor(controllerName, true);
if (!controller) {
controller = this.generateController(controllerName, context);
}
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) {
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);
}
}, beforeModel:Ember.K, afterModel:Ember.K, redirect:Ember.K, contextDidChange:function() {
this.currentModel = this.context;
}, 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);
}, deserialize:function(params, transition) {
return this.model(this.paramsFor(this.routeName), transition);
}, findModel:function() {
var store = get(this, "store");
return store.find.apply(store, arguments);
}, 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);
}};
}), serialize:function(model, params) {
if (params.length < 1) {
return;
}
if (!model) {
return;
}
var name = params[0], object = {};
if (/_id$/.test(name) && params.length === 1) {
object[name] = get(model, "id");
} else {
object = getProperties(model, params);
}
return object;
}, setupController:function(controller, context, transition) {
if (controller && context !== undefined) {
set(controller, "model", context);
}
}, 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);
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;
}, generateController:function(name, model) {
var container = this.container;
model = model || this.modelFor(name);
return generateController(container, name, model);
}, modelFor:function(name) {
var route = this.container.lookup("route:" + name);
var transition = this.router ? this.router.router.activeTransition : null;
if (transition) {
var modelLookupName = route && route.routeName || name;
if (transition.resolvedModels.hasOwnProperty(modelLookupName)) {
return transition.resolvedModels[modelLookupName];
}
}
return route && route.currentModel;
}, renderTemplate:function(controller, model) {
this.render();
}, 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;
if (typeof name === "object" && !options) {
options = name;
name = this.routeName;
}
options = options || {};
options.namePassed = namePassed;
var templateName;
if (name) {
name = name.replace(/\//g, ".");
templateName = name;
} else {
name = this.routeName;
templateName = this.templateName || name;
}
var viewName = options.view || (namePassed && name || (this.viewName || name));
var container = this.container;
var view = container.lookup("view:" + viewName);
var template = view ? view.get("template") : null;
if (!template) {
template = container.lookup("template:" + templateName);
}
if (!view && !template) {
Ember.assert('Could not find "' + name + '" template or view.', Ember.isEmpty(arguments[0]));
if (get(this.router, "namespace.LOG_VIEW_LOOKUPS")) {
Ember.Logger.info('Could not find "' + name + '" template or view. Nothing will be rendered', {fullName:"template:" + name});
}
return;
}
options = normalizeOptions(this, name, template, options);
view = setupView(view, container, options);
if (options.outlet === "main") {
this.lastRenderedTemplate = name;
}
appendView(this, view, options);
}, 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();
}, teardownViews:function() {
if (this.teardownTopLevelView) {
this.teardownTopLevelView();
}
var teardownOutletViews = this.teardownOutletViews || [];
forEach(teardownOutletViews, function(teardownOutletView) {
teardownOutletView();
});
delete this.teardownTopLevelView;
delete this.teardownOutletViews;
delete this.lastRenderedTemplate;
}});
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, current;
for (var i = 0, l = handlerInfos.length;i < l;i++) {
current = handlerInfos[i].handler;
if (current === route) {
return handlerInfos[i + offset];
}
}
}
function parentTemplate(route) {
var parent = parentRoute(route), template;
if (!parent) {
return;
}
if (template = parent.lastRenderedTemplate) {
return template;
} else {
return parentTemplate(parent);
}
}
function normalizeOptions(route, name, template, options) {
options = options || {};
options.into = options.into ? options.into.replace(/\//g, ".") : parentTemplate(route);
options.outlet = options.outlet || "main";
options.name = name;
options.template = template;
options.LOG_VIEW_LOOKUPS = get(route.router, "namespace.LOG_VIEW_LOOKUPS");
Ember.assert("An outlet (" + options.outlet + ") was specified but was not found.", options.outlet === "main" || options.into);
var controller = options.controller;
var model = options.model;
if (options.controller) {
controller = options.controller;
} else {
if (options.namePassed) {
controller = route.container.lookup("controller:" + name) || (route.controllerName || route.routeName);
} else {
controller = route.controllerName || route.container.lookup("controller:" + name);
}
}
if (typeof controller === "string") {
var controllerName = controller;
controller = route.container.lookup("controller:" + controllerName);
if (!controller) {
throw new EmberError("You passed `controller: '" + controllerName + "'` into the `render` method, but no such controller could be found.");
}
}
if (model) {
controller.set("model", model);
}
options.controller = controller;
return options;
}
function setupView(view, container, options) {
if (view) {
if (options.LOG_VIEW_LOOKUPS) {
Ember.Logger.info("Rendering " + options.name + " with " + view, {fullName:"view:" + options.name});
}
} else {
var defaultView = options.into ? "view:default" : "view:toplevel";
view = container.lookup(defaultView);
if (options.LOG_VIEW_LOOKUPS) {
Ember.Logger.info("Rendering " + options.name + " with default view " + view, {fullName:"view:" + options.name});
}
}
if (!get(view, "templateName")) {
set(view, "template", options.template);
set(view, "_debugTemplateName", options.name);
}
set(view, "renderedName", options.name);
set(view, "controller", options.controller);
return view;
}
function appendView(route, view, options) {
if (options.into) {
var parentView = route.router._lookupActiveView(options.into);
var teardownOutletView = generateOutletTeardown(parentView, options.outlet);
if (!route.teardownOutletViews) {
route.teardownOutletViews = [];
}
replace(route.teardownOutletViews, 0, 0, [teardownOutletView]);
parentView.connectOutlet(options.outlet, view);
} else {
var rootElement = get(route, "router.namespace.rootElement");
if (route.teardownTopLevelView) {
route.teardownTopLevelView();
}
route.router._connectActiveView(options.name, view);
route.teardownTopLevelView = generateTopLevelTeardown(view);
view.appendTo(rootElement);
}
}
function generateTopLevelTeardown(view) {
return function() {
view.destroy();
};
}
function generateOutletTeardown(parentView, outlet) {
return function() {
parentView.disconnectOutlet(outlet);
};
}
function getFullQueryParams(router, state) {
if (state.fullQueryParams) {
return state.fullQueryParams;
}
state.fullQueryParams = {};
merge(state.fullQueryParams, state.queryParams);
var targetRouteName = state.handlerInfos[state.handlerInfos.length - 1].name;
router._deserializeQueryParams(targetRouteName, state.fullQueryParams);
return state.fullQueryParams;
}
function getQueryParamsFor(route, state) {
state.queryParamsFor = state.queryParamsFor || {};
var name = route.routeName;
if (state.queryParamsFor[name]) {
return state.queryParamsFor[name];
}
var fullQueryParams = getFullQueryParams(route.router, state);
var params = state.queryParamsFor[name] = {};
var qpMeta = get(route, "_qp");
var qps = qpMeta.qps;
for (var i = 0, len = qps.length;i < len;++i) {
var qp = qps[i];
var qpValueWasPassedIn = qp.prop in fullQueryParams;
params[qp.prop] = qpValueWasPassedIn ? fullQueryParams[qp.prop] : copyDefaultValue(qp.def);
}
return params;
}
function copyDefaultValue(value) {
if (isArray(value)) {
return Ember.A(value.slice());
}
return value;
}
__exports__["default"] = Route;
});
enifed("ember-routing/system/router", ["ember-metal/core", "ember-metal/error", "ember-metal/property_get", "ember-metal/property_set", "ember-metal/properties", "ember-metal/computed", "ember-metal/merge", "ember-metal/run_loop", "ember-runtime/system/string", "ember-runtime/system/object", "ember-runtime/mixins/evented", "ember-routing/system/dsl", "ember-views/views/view", "ember-routing/location/api", "ember-handlebars/views/metamorph_view", "ember-routing/utils", "ember-metal/platform", "router",
"router/transition", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __exports__) {
var Ember = __dependency1__["default"];
var EmberError = __dependency2__["default"];
var get = __dependency3__.get;
var set = __dependency4__.set;
var defineProperty = __dependency5__.defineProperty;
var computed = __dependency6__.computed;
var merge = __dependency7__["default"];
var run = __dependency8__["default"];
var fmt = __dependency9__.fmt;
var EmberObject = __dependency10__["default"];
var Evented = __dependency11__["default"];
var EmberRouterDSL = __dependency12__["default"];
var EmberView = __dependency13__["default"];
var EmberLocation = __dependency14__["default"];
var _MetamorphView = __dependency15__["default"];
var routeArgs = __dependency16__.routeArgs;
var getActiveTargetName = __dependency16__.getActiveTargetName;
var stashParamNames = __dependency16__.stashParamNames;
var create = __dependency17__.create;
var Router = __dependency18__["default"];
var slice = [].slice;
var EmberRouter = EmberObject.extend(Evented, {location:"hash", rootURL:"/", init:function() {
this.router = this.constructor.router || this.constructor.map(Ember.K);
this._activeViews = {};
this._setupLocation();
this._qpCache = {};
this._queuedQPChanges = {};
if (get(this, "namespace.LOG_TRANSITIONS_INTERNAL")) {
this.router.log = Ember.Logger.debug;
}
}, url:computed(function() {
return get(this, "location").getURL();
}), startRouting:function() {
this.router = this.router || this.constructor.map(Ember.K);
var router = this.router;
var location = get(this, "location");
var container = this.container;
var self = this;
var initialURL = get(this, "initialURL");
var initialTransition;
if (get(location, "cancelRouterSetup")) {
return;
}
this._setupRouter(router, location);
container.register("view:default", _MetamorphView);
container.register("view:toplevel", EmberView.extend());
location.onUpdateURL(function(url) {
self.handleURL(url);
});
if (typeof initialURL === "undefined") {
initialURL = location.getURL();
}
initialTransition = this.handleURL(initialURL);
if (initialTransition && initialTransition.error) {
throw initialTransition.error;
}
}, didTransition:function(infos) {
updatePaths(this);
this._cancelLoadingEvent();
this.notifyPropertyChange("url");
run.once(this, this.trigger, "didTransition");
if (get(this, "namespace").LOG_TRANSITIONS) {
Ember.Logger.log("Transitioned into '" + EmberRouter._routePath(infos) + "'");
}
}, handleURL:function(url) {
url = url.split(/#(.+)?/)[0];
return this._doURLTransition("handleURL", url);
}, _doURLTransition:function(routerJsMethod, url) {
var transition = this.router[routerJsMethod](url || "/");
listenForTransitionErrors(transition);
return transition;
}, transitionTo:function() {
var args = slice.call(arguments), queryParams;
if (resemblesURL(args[0])) {
return this._doURLTransition("transitionTo", args[0]);
}
var possibleQueryParams = args[args.length - 1];
if (possibleQueryParams && possibleQueryParams.hasOwnProperty("queryParams")) {
queryParams = args.pop().queryParams;
} else {
queryParams = {};
}
var targetRouteName = args.shift();
return this._doTransition(targetRouteName, args, queryParams);
}, intermediateTransitionTo:function() {
this.router.intermediateTransitionTo.apply(this.router, arguments);
updatePaths(this);
var infos = this.router.currentHandlerInfos;
if (get(this, "namespace").LOG_TRANSITIONS) {
Ember.Logger.log("Intermediate-transitioned into '" + EmberRouter._routePath(infos) + "'");
}
}, replaceWith:function() {
return this.transitionTo.apply(this, arguments).method("replace");
}, generate:function() {
var url = this.router.generate.apply(this.router, arguments);
return this.location.formatURL(url);
}, isActive:function(routeName) {
var router = this.router;
return router.isActive.apply(router, arguments);
}, isActiveIntent:function(routeName, models, queryParams) {
var router = this.router;
return router.isActive.apply(router, arguments);
}, send:function(name, context) {
this.router.trigger.apply(this.router, arguments);
}, hasRoute:function(route) {
return this.router.hasRoute(route);
}, reset:function() {
this.router.reset();
}, _lookupActiveView:function(templateName) {
var active = this._activeViews[templateName];
return active && active[0];
}, _connectActiveView:function(templateName, view) {
var existing = this._activeViews[templateName];
if (existing) {
existing[0].off("willDestroyElement", this, existing[1]);
}
function disconnectActiveView() {
delete this._activeViews[templateName];
}
this._activeViews[templateName] = [view, disconnectActiveView];
view.one("willDestroyElement", this, disconnectActiveView);
}, _setupLocation:function() {
var location = get(this, "location");
var rootURL = get(this, "rootURL");
if (rootURL && (this.container && !this.container.has("-location-setting:root-url"))) {
this.container.register("-location-setting:root-url", rootURL, {instantiate:false});
}
if ("string" === typeof location && this.container) {
var resolvedLocation = this.container.lookup("location:" + location);
if ("undefined" !== typeof resolvedLocation) {
location = set(this, "location", resolvedLocation);
} else {
var options = {implementation:location};
location = set(this, "location", EmberLocation.create(options));
}
}
if (location !== null && typeof location === "object") {
if (rootURL && typeof rootURL === "string") {
location.rootURL = rootURL;
}
if (typeof location.initState === "function") {
location.initState();
}
}
}, _getHandlerFunction:function() {
var seen = create(null);
var container = this.container;
var DefaultRoute = container.lookupFactory("route:basic");
var self = this;
return function(name) {
var routeName = "route:" + name;
var handler = container.lookup(routeName);
if (seen[name]) {
return handler;
}
seen[name] = true;
if (!handler) {
container.register(routeName, DefaultRoute.extend());
handler = container.lookup(routeName);
if (get(self, "namespace.LOG_ACTIVE_GENERATION")) {
Ember.Logger.info("generated -> " + 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];
if (qps.length > 1) {
var qp0 = qps[0].qp, qp1 = qps[1].qp;
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-%@' }`", [qp0.fprop, qp1.fprop, qp0.urlKey, qp0.prop, qp0.prop]), false);
}
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);
}, _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};
}, _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) {
return;
}
transition.trigger(true, "loading", transition, originRoute);
}, _cancelLoadingEvent:function() {
if (this._loadingStateTimer) {
run.cancel(this._loadingStateTimer);
}
this._loadingStateTimer = null;
}});
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;
}
var defaultActionHandlers = {willResolveModel:function(transition, originRoute) {
originRoute.router._scheduleLoadingEvent(transition, originRoute);
}, error:function(error, transition, originRoute) {
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) {
if (routeHasBeenDefined(originRoute.router, "application_error")) {
router.intermediateTransitionTo("application_error", error);
return;
}
}
logError(error, "Error while processing route: " + transition.targetName);
}, loading:function(transition, originRoute) {
var router = originRoute.router;
var tryTopLevel = forEachRouteAbove(originRoute, transition, function(route, childRoute) {
var childLoadingRouteName = findChildRouteName(route, childRoute, "loading");
if (childLoadingRouteName) {
router.intermediateTransitionTo(childLoadingRouteName);
return;
}
if (transition.pivotHandler !== route) {
return true;
}
});
if (tryTopLevel) {
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 + ".";
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) {
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, map:function(callback) {
var router = this.router;
if (!router) {
router = new Router;
router._triggerWillChangeContext = Ember.K;
router._triggerWillLeave = Ember.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 = [];
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 < l;i++) {
name = handlerInfos[i].name;
nameParts = name.split(".");
oldNameParts = slice.call(path);
while (oldNameParts.length) {
if (intersectionMatches(oldNameParts, nameParts)) {
break;
}
oldNameParts.shift();
}
path.push.apply(path, nameParts.slice(oldNameParts.length));
}
return path.join(".");
}});
function listenForTransitionErrors(transition) {
transition.then(null, function(error) {
if (!error || !error.name) {
return;
}
if (error.name === "UnrecognizedURLError") {
Ember.assert("The URL '" + error.message + "' did not match any routes in your application");
}
return error;
}, "Ember: Process errors from Router");
}
function resemblesURL(str) {
return typeof str === "string" && (str === "" || str.charAt(0) === "/");
}
function forEachQueryParam(router, targetRouteName, queryParams, callback) {
var qpCache = router._queryParamsFor(targetRouteName);
for (var key in queryParams) {
if (!queryParams.hasOwnProperty(key)) {
continue;
}
var value = queryParams[key];
var qp = qpCache.map[key];
if (qp) {
callback(key, value, qp);
}
}
}
__exports__["default"] = EmberRouter;
});
enifed("ember-routing/utils", ["ember-metal/utils", "exports"], function(__dependency1__, __exports__) {
var typeOf = __dependency1__.typeOf;
function routeArgs(targetRouteName, models, queryParams) {
var args = [];
if (typeOf(targetRouteName) === "string") {
args.push("" + targetRouteName);
}
args.push.apply(args, models);
args.push({queryParams:queryParams});
return args;
}
__exports__.routeArgs = routeArgs;
function getActiveTargetName(router) {
var handlerInfos = router.activeTransition ? router.activeTransition.state.handlerInfos : router.state.handlerInfos;
return handlerInfos[handlerInfos.length - 1].name;
}
__exports__.getActiveTargetName = getActiveTargetName;
function stashParamNames(router, handlerInfos) {
if (handlerInfos._namesStashed) {
return;
}
var targetRouteName = handlerInfos[handlerInfos.length - 1].name;
var recogHandlers = router.router.recognizer.handlersFor(targetRouteName);
var dynamicParent = null;
for (var i = 0, len = handlerInfos.length;i < len;++i) {
var handlerInfo = handlerInfos[i];
var names = recogHandlers[i].names;
if (names.length) {
dynamicParent = handlerInfo;
}
handlerInfo._names = names;
var route = handlerInfo.handler;
route._stashNames(handlerInfo, dynamicParent);
}
handlerInfos._namesStashed = true;
}
__exports__.stashParamNames = stashParamNames;
});
enifed("ember-runtime", ["ember-metal", "ember-runtime/core", "ember-runtime/compare", "ember-runtime/copy", "ember-runtime/inject", "ember-runtime/system/namespace", "ember-runtime/system/object", "ember-runtime/system/tracked_array", "ember-runtime/system/subarray", "ember-runtime/system/container", "ember-runtime/system/array_proxy", "ember-runtime/system/object_proxy", "ember-runtime/system/core_object", "ember-runtime/system/each_proxy", "ember-runtime/system/native_array", "ember-runtime/system/set",
"ember-runtime/system/string", "ember-runtime/system/deferred", "ember-runtime/system/lazy_load", "ember-runtime/mixins/array", "ember-runtime/mixins/comparable", "ember-runtime/mixins/copyable", "ember-runtime/mixins/enumerable", "ember-runtime/mixins/freezable", "ember-runtime/mixins/-proxy", "ember-runtime/mixins/observable", "ember-runtime/mixins/action_handler", "ember-runtime/mixins/deferred", "ember-runtime/mixins/mutable_enumerable", "ember-runtime/mixins/mutable_array", "ember-runtime/mixins/target_action_support",
"ember-runtime/mixins/evented", "ember-runtime/mixins/promise_proxy", "ember-runtime/mixins/sortable", "ember-runtime/computed/array_computed", "ember-runtime/computed/reduce_computed", "ember-runtime/computed/reduce_computed_macros", "ember-runtime/controllers/array_controller", "ember-runtime/controllers/object_controller", "ember-runtime/controllers/controller", "ember-runtime/mixins/controller", "ember-runtime/system/service", "ember-runtime/ext/rsvp", "ember-runtime/ext/string", "ember-runtime/ext/function",
"exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __dependency21__, __dependency22__, __dependency23__, __dependency24__, __dependency25__, __dependency26__, __dependency27__, __dependency28__,
__dependency29__, __dependency30__, __dependency31__, __dependency32__, __dependency33__, __dependency34__, __dependency35__, __dependency36__, __dependency37__, __dependency38__, __dependency39__, __dependency40__, __dependency41__, __dependency42__, __dependency43__, __dependency44__, __dependency45__, __exports__) {
var Ember = __dependency1__["default"];
var isEqual = __dependency2__.isEqual;
var compare = __dependency3__["default"];
var copy = __dependency4__["default"];
var inject = __dependency5__["default"];
var Namespace = __dependency6__["default"];
var EmberObject = __dependency7__["default"];
var TrackedArray = __dependency8__["default"];
var SubArray = __dependency9__["default"];
var Container = __dependency10__["default"];
var ArrayProxy = __dependency11__["default"];
var ObjectProxy = __dependency12__["default"];
var CoreObject = __dependency13__["default"];
var EachArray = __dependency14__.EachArray;
var EachProxy = __dependency14__.EachProxy;
var NativeArray = __dependency15__["default"];
var Set = __dependency16__["default"];
var EmberStringUtils = __dependency17__["default"];
var Deferred = __dependency18__["default"];
var onLoad = __dependency19__.onLoad;
var runLoadHooks = __dependency19__.runLoadHooks;
var EmberArray = __dependency20__["default"];
var Comparable = __dependency21__["default"];
var Copyable = __dependency22__["default"];
var Enumerable = __dependency23__["default"];
var Freezable = __dependency24__.Freezable;
var FROZEN_ERROR = __dependency24__.FROZEN_ERROR;
var _ProxyMixin = __dependency25__["default"];
var Observable = __dependency26__["default"];
var ActionHandler = __dependency27__["default"];
var DeferredMixin = __dependency28__["default"];
var MutableEnumerable = __dependency29__["default"];
var MutableArray = __dependency30__["default"];
var TargetActionSupport = __dependency31__["default"];
var Evented = __dependency32__["default"];
var PromiseProxyMixin = __dependency33__["default"];
var SortableMixin = __dependency34__["default"];
var arrayComputed = __dependency35__.arrayComputed;
var ArrayComputedProperty = __dependency35__.ArrayComputedProperty;
var reduceComputed = __dependency36__.reduceComputed;
var ReduceComputedProperty = __dependency36__.ReduceComputedProperty;
var sum = __dependency37__.sum;
var min = __dependency37__.min;
var max = __dependency37__.max;
var map = __dependency37__.map;
var sort = __dependency37__.sort;
var setDiff = __dependency37__.setDiff;
var mapBy = __dependency37__.mapBy;
var mapProperty = __dependency37__.mapProperty;
var filter = __dependency37__.filter;
var filterBy = __dependency37__.filterBy;
var filterProperty = __dependency37__.filterProperty;
var uniq = __dependency37__.uniq;
var union = __dependency37__.union;
var intersect = __dependency37__.intersect;
var ArrayController = __dependency38__["default"];
var ObjectController = __dependency39__["default"];
var Controller = __dependency40__["default"];
var ControllerMixin = __dependency41__["default"];
var Service = __dependency42__["default"];
var RSVP = __dependency43__["default"];
Ember.compare = compare;
Ember.copy = copy;
Ember.isEqual = isEqual;
Ember.Array = EmberArray;
Ember.Comparable = Comparable;
Ember.Copyable = Copyable;
Ember.SortableMixin = SortableMixin;
Ember.Freezable = Freezable;
Ember.FROZEN_ERROR = FROZEN_ERROR;
Ember.DeferredMixin = DeferredMixin;
Ember.MutableEnumerable = MutableEnumerable;
Ember.MutableArray = MutableArray;
Ember.TargetActionSupport = TargetActionSupport;
Ember.Evented = Evented;
Ember.PromiseProxyMixin = PromiseProxyMixin;
Ember.Observable = Observable;
Ember.arrayComputed = arrayComputed;
Ember.ArrayComputedProperty = ArrayComputedProperty;
Ember.reduceComputed = reduceComputed;
Ember.ReduceComputedProperty = ReduceComputedProperty;
var EmComputed = Ember.computed;
EmComputed.sum = sum;
EmComputed.min = min;
EmComputed.max = max;
EmComputed.map = map;
EmComputed.sort = sort;
EmComputed.setDiff = setDiff;
EmComputed.mapBy = mapBy;
EmComputed.mapProperty = mapProperty;
EmComputed.filter = filter;
EmComputed.filterBy = filterBy;
EmComputed.filterProperty = filterProperty;
EmComputed.uniq = uniq;
EmComputed.union = union;
EmComputed.intersect = intersect;
Ember.String = EmberStringUtils;
Ember.Object = EmberObject;
Ember.TrackedArray = TrackedArray;
Ember.SubArray = SubArray;
Ember.Container = Container;
Ember.Namespace = Namespace;
Ember.Enumerable = Enumerable;
Ember.ArrayProxy = ArrayProxy;
Ember.ObjectProxy = ObjectProxy;
Ember.ActionHandler = ActionHandler;
Ember.CoreObject = CoreObject;
Ember.EachArray = EachArray;
Ember.EachProxy = EachProxy;
Ember.NativeArray = NativeArray;
Ember.Set = Set;
Ember.Deferred = Deferred;
Ember.onLoad = onLoad;
Ember.runLoadHooks = runLoadHooks;
Ember.ArrayController = ArrayController;
Ember.ObjectController = ObjectController;
Ember.Controller = Controller;
Ember.ControllerMixin = ControllerMixin;
Ember._ProxyMixin = _ProxyMixin;
Ember.RSVP = RSVP;
__exports__["default"] = Ember;
});
enifed("ember-runtime/compare", ["ember-metal/utils", "ember-runtime/mixins/comparable", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var typeOf = __dependency1__.typeOf;
var Comparable = __dependency2__["default"];
var TYPE_ORDER = {"undefined":0, "null":1, "boolean":2, "number":3, "string":4, "array":5, "object":6, "instance":7, "function":8, "class":9, "date":10};
function spaceship(a, b) {
var diff = a - b;
return(diff > 0) - (diff < 0);
}
__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.constructor)) {
return v.constructor.compare(v, w);
}
if (type2 === "instance" && Comparable.detect(w.constructor)) {
return 1 - w.constructor.compare(w, v);
}
}
var res = spaceship(TYPE_ORDER[type1], TYPE_ORDER[type2]);
if (res !== 0) {
return res;
}
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;
}
}
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__) {
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)) {
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;
};
ArrayComputedProperty.prototype.didChange = function(obj, keyName) {
return;
};
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__) {
var Ember = __dependency1__["default"];
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;
var eachPropertyPattern = /^(.*)\.@each\.(.*)/;
var doubleEachPropertyPattern = /(.*\.@each){2,}/;
var arrayBracketPattern = /\.\[\]$/;
function get(obj, key) {
if (key === "@this") {
return obj;
}
return e_get(obj, key);
}
function DependentArraysObserver(callbacks, cp, instanceMeta, context, propertyName, sugarMeta) {
this.callbacks = callbacks;
this.cp = cp;
this.instanceMeta = instanceMeta;
this.dependentKeysByGuid = {};
this.trackedArraysByGuid = {};
this.suspended = false;
this.changedItems = {};
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");
trackedArray.apply(function(observerContexts, offset, operation, operationIndex) {
if (operation === TrackedArray.DELETE) {
return;
}
if (operationIndex === 0 && (operation === TrackedArray.RETAIN && (observerContexts.length === length && offset === 0))) {
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 {
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) {
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) {
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);
}
}};
__exports__.ReduceComputedProperty = ReduceComputedProperty;
function ReduceComputedProperty(options) {
var cp = this;
this.options = options;
this._dependentKeys = null;
this._itemPropertyKeys = {};
this._previousItemPropertyKeys = {};
this.readOnly();
this.cacheable();
this.recomputeOnce = function(propertyName) {
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) {
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);
};
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__) {
var Ember = __dependency1__["default"];
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;
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;
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;
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;
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;
function mapBy(dependentKey, propertyKey) {
var callback = function(item) {
return get(item, propertyKey);
};
return map(dependentKey + ".@each." + propertyKey, callback);
}
__exports__.mapBy = mapBy;
var mapProperty = mapBy;
__exports__.mapProperty = mapProperty;
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);
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;
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;
var filterProperty = filterBy;
__exports__.filterProperty = filterProperty;
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;
var union = uniq;
__exports__.union = union;
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;
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;
}
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 < waiting.length;i++) {
item = waiting[i];
index = instanceMeta.binarySearch(array, item);
array.insertAt(index, item);
}
};
instanceMeta.insertLater = function(item) {
this.waitingInsertions.push(item);
};
}, addedItem:function(array, item, changeMeta, instanceMeta) {
instanceMeta.insertLater(item);
return array;
}, removedItem:function(array, item, changeMeta, instanceMeta) {
array.removeObject(item);
return array;
}, flushedChanges:function(array, instanceMeta) {
instanceMeta.insertWaiting();
}});
}
function propertySort(itemsKey, sortPropertiesKey) {
return arrayComputed(itemsKey, {initialize:function(array, changeMeta, instanceMeta) {
function setupSortProperties() {
var sortPropertyDefinitions = get(this, sortPropertiesKey);
var sortProperties = instanceMeta.sortProperties = [];
var sortPropertyAscending = instanceMeta.sortPropertyAscending = {};
var sortProperty, idx, asc;
Ember.assert("Cannot sort: '" + sortPropertiesKey + "' is not an array.", isArray(sortPropertyDefinitions));
changeMeta.property.clearItemPropertyKeys(itemsKey);
forEach(sortPropertyDefinitions, function(sortPropertyDefinition) {
if ((idx = sortPropertyDefinition.indexOf(":")) !== -1) {
sortProperty = sortPropertyDefinition.substring(0, idx);
asc = sortPropertyDefinition.substring(idx + 1).toLowerCase() !== "desc";
} else {
sortProperty = sortPropertyDefinition;
asc = true;
}
sortProperties.push(sortProperty);
sortPropertyAscending[sortProperty] = asc;
changeMeta.property.itemPropertyKey(itemsKey, sortProperty);
});
sortPropertyDefinitions.addObserver("@each", this, updateSortPropertiesOnce);
}
function updateSortPropertiesOnce() {
run.once(this, updateSortProperties, changeMeta.propertyName);
}
function updateSortProperties(propertyName) {
setupSortProperties.call(this);
changeMeta.property.recomputeOnce.call(this, propertyName);
}
addObserver(this, sortPropertiesKey, updateSortPropertiesOnce);
setupSortProperties.call(this);
instanceMeta.order = function(itemA, itemB) {
var sortProperty, result, asc;
var keyA = this.keyFor(itemA);
var keyB = this.keyFor(itemB);
for (var i = 0;i < this.sortProperties.length;++i) {
sortProperty = this.sortProperties[i];
result = compare(keyA[sortProperty], keyB[sortProperty]);
if (result !== 0) {
asc = this.sortPropertyAscending[sortProperty];
return asc ? result : -1 * result;
}
}
return 0;
};
instanceMeta.binarySearch = binarySearch;
setupKeyCache(instanceMeta);
}, addedItem:function(array, item, changeMeta, instanceMeta) {
var index = instanceMeta.binarySearch(array, item);
array.insertAt(index, item);
return array;
}, removedItem:function(array, item, changeMeta, instanceMeta) {
var index = instanceMeta.binarySearch(array, item);
array.removeAt(index);
instanceMeta.dropKeyFor(item);
return array;
}});
}
function setupKeyCache(instanceMeta) {
instanceMeta.keyFor = function(item) {
var guid = guidFor(item);
if (this.keyCache[guid]) {
return this.keyCache[guid];
}
var sortProperty;
var key = {};
for (var i = 0;i < this.sortProperties.length;++i) {
sortProperty = this.sortProperties[i];
key[sortProperty] = get(item, sortProperty);
}
return this.keyCache[guid] = key;
};
instanceMeta.dropKeyFor = function(item) {
var guid = guidFor(item);
this.keyCache[guid] = null;
};
instanceMeta.keyCache = {};
}
});
enifed("ember-runtime/controllers/array_controller", ["ember-metal/core", "ember-metal/property_get", "ember-metal/enumerable_utils", "ember-runtime/system/array_proxy", "ember-runtime/mixins/sortable", "ember-runtime/mixins/controller", "ember-metal/computed", "ember-metal/error", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
var Ember = __dependency1__["default"];
var get = __dependency2__.get;
var forEach = __dependency3__.forEach;
var replace = __dependency3__.replace;
var ArrayProxy = __dependency4__["default"];
var SortableMixin = __dependency5__["default"];
var ControllerMixin = __dependency6__["default"];
var computed = __dependency7__.computed;
var EmberError = __dependency8__["default"];
__exports__["default"] = ArrayProxy.extend(ControllerMixin, SortableMixin, {itemController:null, 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);
}
}
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));
}
this._super(idx, removedCnt, addedCnt);
}, init:function() {
this._super();
this._subControllers = [];
}, model:computed(function() {
return Ember.A();
}), _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__) {
var Ember = __dependency1__["default"];
var EmberObject = __dependency2__["default"];
var Mixin = __dependency3__["default"];
var createInjectionHelper = __dependency4__.createInjectionHelper;
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));
}
__exports__["default"] = Controller;
});
enifed("ember-runtime/controllers/object_controller", ["ember-runtime/mixins/controller", "ember-runtime/system/object_proxy", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var ControllerMixin = __dependency1__["default"];
var ObjectProxy = __dependency2__["default"];
__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__) {
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;
if (typeof obj !== "object" || obj === null) {
return obj;
}
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));
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) {
if (!Object.prototype.hasOwnProperty.call(obj, key)) {
continue;
}
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;
}
__exports__["default"] = function copy(obj, deep) {
if ("object" !== typeof obj || obj === null) {
return obj;
}
if (Copyable && Copyable.detect(obj)) {
return obj.copy(deep);
}
return _copy(obj, deep, deep ? [] : null, deep ? [] : null);
};
});
enifed("ember-runtime/core", ["exports"], function(__exports__) {
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__) {
var Ember = __dependency1__["default"];
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) {
FunctionPrototype.property = function() {
var ret = computed(this);
return ret.property.apply(ret, arguments);
};
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));
};
FunctionPrototype.observesImmediately = function() {
for (var i = 0, l = arguments.length;i < l;i++) {
var arg = arguments[i];
Ember.assert("Immediate observers must observe internal properties only, " + "not properties on other objects.", arg.indexOf(".") === -1);
}
return this.observes.apply(this, arguments);
};
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;
};
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__) {
var Ember = __dependency1__["default"];
var Logger = __dependency2__["default"];
var run = __dependency3__["default"];
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(error) {
if (error && error.name !== "TransitionAborted") {
if (Ember.testing) {
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);
Ember.assert(error, false);
}
}
}
};
RSVP.on("error", RSVP.onerrorDefault);
__exports__["default"] = RSVP;
});
enifed("ember-runtime/ext/string", ["ember-metal/core", "ember-runtime/system/string"], function(__dependency1__, __dependency2__) {
var Ember = __dependency1__["default"];
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) {
StringPrototype.fmt = function() {
return fmt(this, arguments);
};
StringPrototype.w = function() {
return w(this);
};
StringPrototype.loc = function() {
return loc(this, arguments);
};
StringPrototype.camelize = function() {
return camelize(this);
};
StringPrototype.decamelize = function() {
return decamelize(this);
};
StringPrototype.dasherize = function() {
return dasherize(this);
};
StringPrototype.underscore = function() {
return underscore(this);
};
StringPrototype.classify = function() {
return classify(this);
};
StringPrototype.capitalize = function() {
return capitalize(this);
};
}
});
enifed("ember-runtime/inject", ["ember-metal/core", "ember-metal/enumerable_utils", "ember-metal/injected_property", "ember-metal/keys", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
var Ember = __dependency1__["default"];
var indexOf = __dependency2__.indexOf;
var InjectedProperty = __dependency3__["default"];
var keys = __dependency4__["default"];
function inject() {
Ember.assert("Injected properties must be created through helpers, see `" + keys(inject).join("`, `") + "`");
}
var typeValidators = {};
function createInjectionHelper(type, validator) {
typeValidators[type] = validator;
inject[type] = function(name) {
return new InjectedProperty(type, name);
};
}
__exports__.createInjectionHelper = createInjectionHelper;
function validatePropertyInjections(factory, props) {
var types = [];
var key, desc, validator, i, l;
for (key in props) {
desc = props[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__) {
var Ember = __dependency1__["default"];
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);
if (key in this) {
return;
}
propertyWillChange(this, key);
}
function contentPropertyDidChange(content, contentKey) {
var key = contentKey.slice(8);
if (key in this) {
return;
}
propertyDidChange(this, key);
}
__exports__["default"] = Mixin.create({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) {
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__) {
var merge = __dependency1__["default"];
var Mixin = __dependency2__.Mixin;
var get = __dependency3__.get;
var typeOf = __dependency4__.typeOf;
var ActionHandler = Mixin.create({mergedProperties:["_actions"], 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];
}
}, 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) {
} 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__) {
var Ember = __dependency1__["default"];
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;
}
__exports__["default"] = Mixin.create(Enumerable, {length:required(), objectAt:function(idx) {
if (idx < 0 || idx >= get(this, "length")) {
return undefined;
}
return get(this, idx);
}, objectsAt:function(indexes) {
var self = this;
return map(indexes, function(idx) {
return self.objectAt(idx);
});
}, nextObject:function(idx) {
return this.objectAt(idx);
}, "[]":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);
}), contains:function(obj) {
return this.indexOf(obj) >= 0;
}, 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;
}, 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;
}, 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;
}, addArrayObserver:function(target, opts) {
return arrayObserversHelper(this, target, opts, addListener, false);
}, removeArrayObserver:function(target, opts) {
return arrayObserversHelper(this, target, opts, removeListener, true);
}, hasArrayObservers:computed(function() {
return hasListeners(this, "@array:change") || hasListeners(this, "@array:before");
}), arrayContentWillChange:function(startIdx, removeAmt, addAmt) {
var removing, lim;
if (startIdx === undefined) {
startIdx = 0;
removeAmt = addAmt = -1;
} else {
if (removeAmt === undefined) {
removeAmt = -1;
}
if (addAmt === undefined) {
addAmt = -1;
}
}
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;
}, arrayContentDidChange:function(startIdx, removeAmt, addAmt) {
var adding, lim;
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;
}, "@each":computed(function() {
if (!this.__each) {
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__) {
var Mixin = __dependency1__.Mixin;
var required = __dependency1__.required;
__exports__["default"] = Mixin.create({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__) {
var Mixin = __dependency1__.Mixin;
var computed = __dependency2__.computed;
var ActionHandler = __dependency3__["default"];
var ControllerContentModelAliasDeprecation = __dependency4__["default"];
__exports__["default"] = Mixin.create(ActionHandler, ControllerContentModelAliasDeprecation, {isController:true, target:null, container:null, parentController:null, store:null, model:null, content:computed.alias("model")});
});
enifed("ember-runtime/mixins/controller_content_model_alias_deprecation", ["ember-metal/core", "ember-metal/mixin", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var Ember = __dependency1__["default"];
var Mixin = __dependency2__.Mixin;
__exports__["default"] = Mixin.create({willMergeMixin:function(props) {
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__) {
var get = __dependency1__.get;
var required = __dependency2__.required;
var Freezable = __dependency3__.Freezable;
var Mixin = __dependency2__.Mixin;
var fmt = __dependency4__.fmt;
var EmberError = __dependency5__["default"];
__exports__["default"] = Mixin.create({copy:required(Function), 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__) {
var Ember = __dependency1__["default"];
var get = __dependency2__.get;
var Mixin = __dependency3__.Mixin;
var computed = __dependency4__.computed;
var RSVP = __dependency5__["default"];
__exports__["default"] = Mixin.create({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:function(value) {
var deferred, promise;
deferred = get(this, "_deferred");
promise = deferred.promise;
if (value === this) {
deferred.resolve(promise);
} else {
deferred.resolve(value);
}
}, reject:function(value) {
get(this, "_deferred").reject(value);
}, _deferred:computed(function() {
Ember.deprecate("Usage of Ember.DeferredMixin or Ember.Deferred is deprecated.", this._suppressDeferredDeprecation);
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__) {
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;
}
__exports__["default"] = Mixin.create({nextObject:required(Function), firstObject:computed("[]", function() {
if (get(this, "length") === 0) {
return undefined;
}
var context = popCtx();
var ret = this.nextObject(0, null, context);
pushCtx(context);
return ret;
}), 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;
}), contains:function(obj) {
var found = this.find(function(item) {
return item === obj;
});
return found !== undefined;
}, 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;
}, getEach:function(key) {
return this.mapBy(key);
}, setEach:function(key, value) {
return this.forEach(function(item) {
set(item, key, value);
});
}, map:function(callback, target) {
var ret = Ember.A();
this.forEach(function(x, idx, i) {
ret[idx] = callback.call(target, x, idx, i);
});
return ret;
}, mapBy:function(key) {
return this.map(function(next) {
return get(next, key);
});
}, mapProperty:aliasMethod("mapBy"), 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;
}, reject:function(callback, target) {
return this.filter(function() {
return!apply(target, callback, arguments);
});
}, filterBy:function(key, value) {
return this.filter(apply(this, iter, arguments));
}, filterProperty:aliasMethod("filterBy"), 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);
}, rejectProperty:aliasMethod("rejectBy"), 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;
}, findBy:function(key, value) {
return this.find(apply(this, iter, arguments));
}, findProperty:aliasMethod("findBy"), every:function(callback, target) {
return!this.find(function(x, idx, i) {
return!callback.call(target, x, idx, i);
});
}, everyBy:aliasMethod("isEvery"), everyProperty:aliasMethod("isEvery"), isEvery:function(key, value) {
return this.every(apply(this, iter, arguments));
}, 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;
}, some:aliasMethod("any"), isAny:function(key, value) {
return this.any(apply(this, iter, arguments));
}, anyBy:aliasMethod("isAny"), someProperty:aliasMethod("isAny"), 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;
}, 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;
}, toArray:function() {
var ret = Ember.A();
this.forEach(function(o, idx) {
ret[idx] = o;
});
return ret;
}, compact:function() {
return this.filter(function(value) {
return value != null;
});
}, without:function(value) {
if (!this.contains(value)) {
return this;
}
var ret = Ember.A();
this.forEach(function(k) {
if (k !== value) {
ret[ret.length] = k;
}
});
return ret;
}, uniq:function() {
var ret = Ember.A();
this.forEach(function(k) {
if (indexOf(ret, k) < 0) {
ret.push(k);
}
});
return ret;
}, "[]":computed(function(key, value) {
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;
}, 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;
}, hasEnumerableObservers:computed(function() {
return hasListeners(this, "@enumerable:change") || hasListeners(this, "@enumerable:before");
}), 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;
}, 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;
}, 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);
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__) {
var Mixin = __dependency1__.Mixin;
var addListener = __dependency2__.addListener;
var removeListener = __dependency2__.removeListener;
var hasListeners = __dependency2__.hasListeners;
var sendEvent = __dependency2__.sendEvent;
__exports__["default"] = Mixin.create({on:function(name, target, method) {
addListener(this, name, target, method);
return this;
}, one:function(name, target, method) {
if (!method) {
method = target;
target = null;
}
addListener(this, name, target, method, true);
return this;
}, 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);
}, off:function(name, target, method) {
removeListener(this, name, target, method);
return this;
}, 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__) {
var Mixin = __dependency1__.Mixin;
var get = __dependency2__.get;
var set = __dependency3__.set;
var Freezable = Mixin.create({isFrozen:false, 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__) {
var OUT_OF_RANGE_EXCEPTION = "Index out of range";
var EMPTY = [];
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"];
__exports__["default"] = Mixin.create(EmberArray, MutableEnumerable, {replace:required(), clear:function() {
var len = get(this, "length");
if (len === 0) {
return this;
}
this.replace(0, len, EMPTY);
return this;
}, insertAt:function(idx, object) {
if (idx > get(this, "length")) {
throw new EmberError(OUT_OF_RANGE_EXCEPTION);
}
this.replace(idx, 0, [object]);
return this;
}, removeAt:function(start, len) {
if ("number" === typeof start) {
if (start < 0 || start >= get(this, "length")) {
throw new EmberError(OUT_OF_RANGE_EXCEPTION);
}
if (len === undefined) {
len = 1;
}
this.replace(start, len, EMPTY);
}
return this;
}, pushObject:function(obj) {
this.insertAt(get(this, "length"), obj);
return obj;
}, 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;
}, 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;
}, shiftObject:function() {
if (get(this, "length") === 0) {
return null;
}
var ret = this.objectAt(0);
this.removeAt(0);
return ret;
}, unshiftObject:function(obj) {
this.insertAt(0, obj);
return obj;
}, unshiftObjects:function(objects) {
this.replace(0, 0, objects);
return this;
}, reverseObjects:function() {
var len = get(this, "length");
if (len === 0) {
return this;
}
var objects = this.toArray().reverse();
this.replace(0, len, objects);
return this;
}, setObjects:function(objects) {
if (objects.length === 0) {
return this.clear();
}
var len = get(this, "length");
this.replace(0, len, objects);
return this;
}, 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;
}, 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__) {
var forEach = __dependency1__.forEach;
var Enumerable = __dependency2__["default"];
var Mixin = __dependency3__.Mixin;
var required = __dependency3__.required;
var beginPropertyChanges = __dependency4__.beginPropertyChanges;
var endPropertyChanges = __dependency4__.endPropertyChanges;
__exports__["default"] = Mixin.create(Enumerable, {addObject:required(Function), addObjects:function(objects) {
beginPropertyChanges(this);
forEach(objects, function(obj) {
this.addObject(obj);
}, this);
endPropertyChanges(this);
return this;
}, removeObject:required(Function), 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__) {
var Ember = __dependency1__["default"];
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;
__exports__["default"] = Mixin.create({get:function(keyName) {
return get(this, keyName);
}, getProperties:function() {
return apply(null, getProperties, [this].concat(slice.call(arguments)));
}, set:function(keyName, value) {
set(this, keyName, value);
return this;
}, setProperties:function(hash) {
return setProperties(this, hash);
}, beginPropertyChanges:function() {
beginPropertyChanges();
return this;
}, endPropertyChanges:function() {
endPropertyChanges();
return this;
}, propertyWillChange:function(keyName) {
propertyWillChange(this, keyName);
return this;
}, propertyDidChange:function(keyName) {
propertyDidChange(this, keyName);
return this;
}, notifyPropertyChange:function(keyName) {
this.propertyWillChange(keyName);
this.propertyDidChange(keyName);
return this;
}, addBeforeObserver:function(key, target, method) {
addBeforeObserver(this, key, target, method);
}, addObserver:function(key, target, method) {
addObserver(this, key, target, method);
}, removeObserver:function(key, target, method) {
removeObserver(this, key, target, method);
}, hasObserverFor:function(key) {
return hasListeners(this, key + ":change");
}, getWithDefault:function(keyName, defaultValue) {
return getWithDefault(this, keyName, defaultValue);
}, 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);
}, 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);
}, toggleProperty:function(keyName) {
set(this, keyName, !get(this, keyName));
return get(this, keyName);
}, cacheFor:function(keyName) {
return cacheFor(this, keyName);
}, 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__) {
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;
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");
}
__exports__["default"] = Mixin.create({reason:null, isPending:not("isSettled").readOnly(), isSettled:or("isRejected", "isFulfilled").readOnly(), isRejected:false, isFulfilled:false, promise:computed(function(key, promise) {
if (arguments.length === 2) {
return tap(this, promise);
} else {
throw new EmberError("PromiseProxy's promise must be set");
}
}), then:promiseAlias("then"), "catch":promiseAlias("catch"), "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__) {
var Ember = __dependency1__["default"];
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;
__exports__["default"] = Mixin.create(MutableEnumerable, {sortProperties:null, sortAscending:true, 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"), 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__) {
var Ember = __dependency1__["default"];
var get = __dependency2__.get;
var typeOf = __dependency3__.typeOf;
var Mixin = __dependency4__.Mixin;
var computed = __dependency5__.computed;
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"), 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__) {
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__) {
var Ember = __dependency1__["default"];
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"];
var OUT_OF_RANGE_EXCEPTION = "Index out of range";
var EMPTY = [];
var K = Ember.K;
var ArrayProxy = EmberObject.extend(MutableArray, {content:null, arrangedContent:alias("content"), objectAtContent:function(idx) {
return get(this, "arrangedContent").objectAt(idx);
}, replaceContent:function(idx, amt, objects) {
get(this, "content").replace(idx, amt, objects);
}, _contentWillChange:beforeObserver("content", function() {
this._teardownContent();
}), _teardownContent:function() {
var content = get(this, "content");
if (content) {
content.removeArrayObserver(this, {willChange:"contentArrayWillChange", didChange:"contentArrayDidChange"});
}
}, contentArrayWillChange:K, contentArrayDidChange:K, _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;
}), _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;
}
for (i = start;i < start + len;i++) {
indices.push(content.indexOf(arrangedContent.objectAt(i)));
}
indices.sort(function(a, b) {
return b - a;
});
beginPropertyChanges();
for (i = 0;i < indices.length;i++) {
this._replace(indices[i], 1, EMPTY);
}
endPropertyChanges();
}
return this;
}, pushObject:function(obj) {
this._insertAt(get(this, "content.length"), obj);
return obj;
}, 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;
}, setObjects:function(objects) {
if (objects.length === 0) {
return this.clear();
}
var len = get(this, "length");
this._replace(0, len, objects);
return this;
}, unshiftObject:function(obj) {
this._insertAt(0, obj);
return obj;
}, unshiftObjects:function(objects) {
this._replace(0, 0, objects);
return this;
}, slice:function() {
var arr = this.toArray();
return arr.slice.apply(arr, arguments);
}, arrangedContentArrayWillChange:function(item, idx, removedCnt, addedCnt) {
this.arrayContentWillChange(idx, removedCnt, addedCnt);
}, arrangedContentArrayDidChange:function(item, idx, removedCnt, addedCnt) {
this.arrayContentDidChange(idx, removedCnt, addedCnt);
}, init:function() {
this._super();
this._setupContent();
this._setupArrangedContent();
}, willDestroy:function() {
this._teardownArrangedContent();
this._teardownContent();
}});
__exports__["default"] = ArrayProxy;
});
enifed("ember-runtime/system/container", ["ember-metal/property_set", "container", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var set = __dependency1__.set;
var Container = __dependency2__["default"];
Container.set = set;
__exports__["default"] = Container;
});
enifed("ember-runtime/system/core_object", ["ember-metal/core", "ember-metal/property_get", "ember-metal/utils", "ember-metal/platform", "ember-metal/chains", "ember-metal/events", "ember-metal/mixin", "ember-metal/enumerable_utils", "ember-metal/error", "ember-metal/keys", "ember-runtime/mixins/action_handler", "ember-metal/properties", "ember-metal/binding", "ember-metal/computed", "ember-metal/injected_property", "ember-metal/run_loop", "ember-metal/watching", "exports"], function(__dependency1__,
__dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __exports__) {
var Ember = __dependency1__["default"];
var get = __dependency2__.get;
var guidFor = __dependency3__.guidFor;
var apply = __dependency3__.apply;
var o_create = __dependency4__.create;
var generateGuid = __dependency3__.generateGuid;
var GUID_KEY = __dependency3__.GUID_KEY;
var meta = __dependency3__.meta;
var makeArray = __dependency3__.makeArray;
var finishChains = __dependency5__.finishChains;
var sendEvent = __dependency6__.sendEvent;
var IS_BINDING = __dependency7__.IS_BINDING;
var Mixin = __dependency7__.Mixin;
var required = __dependency7__.required;
var indexOf = __dependency8__.indexOf;
var EmberError = __dependency9__["default"];
var o_defineProperty = __dependency4__.defineProperty;
var keys = __dependency10__["default"];
var ActionHandler = __dependency11__["default"];
var defineProperty = __dependency12__.defineProperty;
var Binding = __dependency13__.Binding;
var ComputedProperty = __dependency14__.ComputedProperty;
var computed = __dependency14__.computed;
var InjectedProperty = __dependency15__["default"];
var run = __dependency16__["default"];
var destroy = __dependency17__.destroy;
var K = __dependency1__.K;
var hasPropertyAccessors = __dependency4__.hasPropertyAccessors;
var schedule = run.schedule;
var applyMixin = Mixin._apply;
var finishPartial = Mixin.finishPartial;
var reopen = Mixin.prototype.reopen;
var hasCachedComputedProperties = false;
var undefinedDescriptor = {configurable:true, writable:true, enumerable:false, value:undefined};
var nullDescriptor = {configurable:true, writable:true, enumerable:false, value:null};
function makeCtor() {
var wasApplied = false;
var initMixins, initProperties;
var Class = function() {
if (!wasApplied) {
Class.proto();
}
o_defineProperty(this, GUID_KEY, nullDescriptor);
o_defineProperty(this, "__nextSuper", undefinedDescriptor);
var m = meta(this);
var proto = m.proto;
m.proto = this;
if (initMixins) {
var mixins = initMixins;
initMixins = null;
apply(this, this.reopen, mixins);
}
if (initProperties) {
var props = initProperties;
initProperties = null;
var concatenatedProperties = this.concatenatedProperties;
for (var i = 0, l = props.length;i < l;i++) {
var properties = props[i];
Ember.assert("Ember.Object.create no longer supports mixing in other definitions, use createWithMixins instead.", !(properties instanceof Mixin));
if (typeof properties !== "object" && properties !== undefined) {
throw new EmberError("Ember.Object.create only accepts objects.");
}
if (!properties) {
continue;
}
var keyNames = keys(properties);
for (var j = 0, ll = keyNames.length;j < ll;j++) {
var keyName = keyNames[j];
var value = properties[keyName];
if (IS_BINDING.test(keyName)) {
var bindings = m.bindings;
if (!bindings) {
bindings = m.bindings = {};
} else {
if (!m.hasOwnProperty("bindings")) {
bindings = m.bindings = o_create(m.bindings);
}
}
bindings[keyName] = value;
}
var desc = m.descs[keyName];
Ember.assert("Ember.Object.create no longer supports defining computed properties. Define computed properties using extend() or reopen() before calling create().", !(value instanceof ComputedProperty));
Ember.assert("Ember.Object.create no longer supports defining methods that call _super.", !(typeof value === "function" && value.toString().indexOf("._super") !== -1));
Ember.assert("`actions` must be provided at extend time, not at create " + "time, when Ember.ActionHandler is used (i.e. views, " + "controllers & routes).", !(keyName === "actions" && ActionHandler.detect(this)));
if (concatenatedProperties && (concatenatedProperties.length > 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 (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);
} else {
this[keyName] = value;
}
}
}
}
}
}
finishPartial(this, m);
var length = arguments.length;
var args = new Array(length);
for (var x = 0;x < length;x++) {
args[x] = arguments[x];
}
apply(this, this.init, 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;
}
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;
}, init:function() {
}, concatenatedProperties:null, isDestroyed:false, isDestroying:false, destroy:function() {
if (this.isDestroying) {
return;
}
this.isDestroying = true;
schedule("actions", this, this.willDestroy);
schedule("destroy", this, this._scheduledDestroy);
return this;
}, willDestroy:K, _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;
}, 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;
};
}
if (Ember.config.overridePrototypeMixin) {
Ember.config.overridePrototypeMixin(CoreObject.PrototypeMixin);
}
CoreObject.__super__ = null;
var ClassMixinProps = {ClassMixin:required(), PrototypeMixin:required(), isClass:true, isMethod:false, 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;
Class.ClassMixin.apply(Class);
return Class;
}, 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;
}, 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;
}, 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;
}, 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;
}, 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(), 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);
}
}};
var ClassMixin = Mixin.create(ClassMixinProps);
ClassMixin.ownerConstructor = CoreObject;
if (Ember.config.overrideClassMixin) {
Ember.config.overrideClassMixin(ClassMixin);
}
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__) {
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.");
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__) {
var Ember = __dependency1__["default"];
var get = __dependency2__.get;
var guidFor = __dependency3__.guidFor;
var forEach = __dependency4__.forEach;
var indexOf = __dependency5__.indexOf;
var EmberArray = __dependency6__["default"];
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");
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;
}
}
}
var EachProxy = EmberObject.extend({init:function(content) {
this._super();
this._content = content;
content.addArrayObserver(this);
forEach(watchedEvents(this), function(eventName) {
this.didAddListener(eventName);
}, this);
}, unknownProperty:function(keyName, value) {
var ret;
ret = new EachArray(this._content, keyName, this);
defineProperty(this, keyName, null, ret);
this.beginObservingContentKey(keyName);
return ret;
}, 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);
}, 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));
}
}, 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__) {
var Ember = __dependency1__["default"];
var forEach = __dependency2__.forEach;
var loadHooks = Ember.ENV.EMBER_LOAD_HOOKS || {};
var loaded = {};
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;
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__) {
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"];
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;
for (var key in root) {
if (!hasOwnProp.call(root, key)) {
continue;
}
var obj = root[key];
paths[idx] = key;
if (obj && obj.toString === classToString) {
obj.toString = makeToString(paths.join("."));
obj[NAME_KEY] = paths.join(".");
} else {
if (obj && obj.isNamespace) {
if (seen[guidFor(obj)]) {
continue;
}
seen[guidFor(obj)] = true;
processNamespace(paths, obj, seen);
}
}
}
paths.length = idx;
}
var STARTS_WITH_UPPERCASE = /^[A-Z]/;
function tryIsNamespace(lookup, prop) {
try {
var obj = lookup[prop];
return obj && (obj.isNamespace && obj);
} catch (e) {
}
}
function findNamespaces() {
var lookup = Ember.lookup;
var obj;
if (Namespace.PROCESSED) {
return;
}
for (var prop in lookup) {
if (!STARTS_WITH_UPPERCASE.test(prop)) {
continue;
}
if (lookup.hasOwnProperty && !lookup.hasOwnProperty(prop)) {
continue;
}
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 < l;i++) {
namespace = namespaces[i];
processNamespace([namespace.toString()], namespace, {});
}
Ember.anyUnprocessedMixins = false;
}
}
function makeToString(ret) {
return function() {
return ret;
};
}
Mixin.prototype.toString = classToString;
__exports__["default"] = Namespace;
});
enifed("ember-runtime/system/native_array", ["ember-metal/core", "ember-metal/property_get", "ember-metal/enumerable_utils", "ember-metal/mixin", "ember-metal/array", "ember-runtime/mixins/array", "ember-runtime/mixins/mutable_array", "ember-runtime/mixins/observable", "ember-runtime/mixins/copyable", "ember-runtime/mixins/freezable", "ember-runtime/copy", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__,
__dependency8__, __dependency9__, __dependency10__, __dependency11__, __exports__) {
var Ember = __dependency1__["default"];
var get = __dependency2__.get;
var replace = __dependency3__._replace;
var forEach = __dependency3__.forEach;
var Mixin = __dependency4__.Mixin;
var indexOf = __dependency5__.indexOf;
var lastIndexOf = __dependency5__.lastIndexOf;
var EmberArray = __dependency6__["default"];
var MutableArray = __dependency7__["default"];
var Observable = __dependency8__["default"];
var Copyable = __dependency9__["default"];
var FROZEN_ERROR = __dependency10__.FROZEN_ERROR;
var copy = __dependency11__["default"];
var NativeArray = Mixin.create(MutableArray, Observable, Copyable, {get:function(key) {
if (key === "length") {
return this.length;
} else {
if ("number" === typeof key) {
return this[key];
} else {
return this._super(key);
}
}
}, objectAt:function(idx) {
return this[idx];
}, replace:function(idx, amt, objects) {
if (this.isFrozen) {
throw FROZEN_ERROR;
}
var len = objects ? get(objects, "length") : 0;
this.arrayContentWillChange(idx, amt, len);
if (len === 0) {
this.splice(idx, amt);
} else {
replace(this, idx, amt, objects);
}
this.arrayContentDidChange(idx, amt, len);
return this;
}, unknownProperty:function(key, value) {
var ret;
if (value !== undefined && ret === undefined) {
ret = this[key] = value;
}
return ret;
}, indexOf:indexOf, lastIndexOf:lastIndexOf, copy:function(deep) {
if (deep) {
return this.map(function(item) {
return copy(item, true);
});
}
return this.slice();
}});
var ignore = ["length"];
forEach(NativeArray.keys(), function(methodName) {
if (Array.prototype[methodName]) {
ignore.push(methodName);
}
});
if (ignore.length > 0) {
NativeArray = NativeArray.without.apply(NativeArray, ignore);
}
var A = function(arr) {
if (arr === undefined) {
arr = [];
}
return EmberArray.detect(arr) ? arr : NativeArray.apply(arr);
};
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;
__exports__.A = A;
__exports__.NativeArray = NativeArray;
__exports__["default"] = NativeArray;
});
enifed("ember-runtime/system/object", ["ember-metal/core", "ember-runtime/system/core_object", "ember-runtime/mixins/observable", "ember-runtime/inject", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
var Ember = __dependency1__["default"];
var CoreObject = __dependency2__["default"];
var Observable = __dependency3__["default"];
var validatePropertyInjections = __dependency4__.validatePropertyInjections;
var EmberObject = CoreObject.extend(Observable);
EmberObject.toString = function() {
return "Ember.Object";
};
function injectedPropertyAssertion(props) {
Ember.assert("Injected properties are invalid", validatePropertyInjections(this.constructor, props));
}
__exports__["default"] = EmberObject;
});
enifed("ember-runtime/system/object_proxy", ["ember-runtime/system/object", "ember-runtime/mixins/-proxy", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var EmberObject = __dependency1__["default"];
var _ProxyMixin = __dependency2__["default"];
__exports__["default"] = EmberObject.extend(_ProxyMixin);
});
enifed("ember-runtime/system/service", ["ember-runtime/system/object", "ember-runtime/inject", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var Object = __dependency1__["default"];
var createInjectionHelper = __dependency2__.createInjectionHelper;
var 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__) {
var Ember = __dependency1__["default"];
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;
__exports__["default"] = CoreObject.extend(MutableEnumerable, Copyable, Freezable, {length:0, 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;
}, isEqual:function(obj) {
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;
}, add:aliasMethod("addObject"), remove:aliasMethod("removeObject"), 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;
}, push:aliasMethod("addObject"), shift:aliasMethod("pop"), unshift:aliasMethod("push"), addEach:aliasMethod("addObjects"), removeEach:aliasMethod("removeObjects"), init:function(items) {
Ember.deprecate("Ember.Set is deprecated and will be removed in a future release.");
this._super();
if (items) {
this.addObjects(items);
}
}, nextObject:function(idx) {
return this[idx];
}, firstObject:computed(function() {
return this.length > 0 ? this[0] : undefined;
}), lastObject:computed(function() {
return this.length > 0 ? this[this.length - 1] : undefined;
}), addObject:function(obj) {
if (get(this, "isFrozen")) {
throw new EmberError(FROZEN_ERROR);
}
if (isNone(obj)) {
return this;
}
var guid = guidFor(obj);
var idx = this[guid];
var len = get(this, "length");
var added;
if (idx >= 0 && (idx < len && this[idx] === obj)) {
return this;
}
added = [obj];
this.enumerableContentWillChange(null, added);
propertyWillChange(this, "lastObject");
len = get(this, "length");
this[guid] = len;
this[len] = obj;
set(this, "length", len + 1);
propertyDidChange(this, "lastObject");
this.enumerableContentDidChange(null, added);
return this;
}, removeObject:function(obj) {
if (get(this, "isFrozen")) {
throw new EmberError(FROZEN_ERROR);
}
if (isNone(obj)) {
return this;
}
var guid = guidFor(obj);
var idx = this[guid];
var len = get(this, "length");
var isFirst = idx === 0;
var isLast = idx === len - 1;
var last, removed;
if (idx >= 0 && (idx < len && this[idx] === obj)) {
removed = [obj];
this.enumerableContentWillChange(removed, null);
if (isFirst) {
propertyWillChange(this, "firstObject");
}
if (isLast) {
propertyWillChange(this, "lastObject");
}
if (idx < len - 1) {
last = this[len - 1];
this[idx] = last;
this[guidFor(last)] = idx;
}
delete this[guid];
delete this[len - 1];
set(this, "length", len - 1);
if (isFirst) {
propertyDidChange(this, "firstObject");
}
if (isLast) {
propertyDidChange(this, "lastObject");
}
this.enumerableContentDidChange(removed, null);
}
return this;
}, contains:function(obj) {
return this[guidFor(obj)] >= 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__) {
var Ember = __dependency1__["default"];
var isArray = __dependency2__.isArray;
var emberInspect = __dependency2__.inspect;
var Cache = __dependency3__["default"];
var STRING_DASHERIZE_REGEXP = /[ _]/g;
var STRING_DASHERIZE_CACHE = new Cache(1E3, function(key) {
return decamelize(key).replace(STRING_DASHERIZE_REGEXP, "-");
});
var CAMELIZE_CACHE = new Cache(1E3, 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(1E3, function(str) {
var parts = str.split(".");
var out = [];
for (var i = 0, l = parts.length;i < l;i++) {
var camelized = camelize(parts[i]);
out.push(camelized.charAt(0).toUpperCase() + camelized.substr(1));
}
return out.join(".");
});
var UNDERSCORE_CACHE = new Cache(1E3, function(str) {
return str.replace(STRING_UNDERSCORE_REGEXP_1, "$1_$2").replace(STRING_UNDERSCORE_REGEXP_2, "_").toLowerCase();
});
var CAPITALIZE_CACHE = new Cache(1E3, function(str) {
return str.charAt(0).toUpperCase() + str.substr(1);
});
var DECAMELIZE_CACHE = new Cache(1E3, function(str) {
return str.replace(STRING_DECAMELIZE_REGEXP, "$1_$2").toLowerCase();
});
var STRING_DECAMELIZE_REGEXP = /([a-z\d])([A-Z])/g;
var STRING_CAMELIZE_REGEXP = /(\-|_|\.|\s)+(.)?/g;
var STRING_UNDERSCORE_REGEXP_1 = /([a-z\d])([A-Z]+)/g;
var STRING_UNDERSCORE_REGEXP_2 = /\-|\s+/g;
function fmt(str, formats) {
var cachedFormats = formats;
if (!isArray(cachedFormats) || arguments.length > 2) {
cachedFormats = new Array(arguments.length - 1);
for (var i = 1, l = arguments.length;i < l;i++) {
cachedFormats[i - 1] = arguments[i];
}
}
var idx = 0;
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);
}
Ember.STRINGS = {};
__exports__["default"] = {fmt:fmt, loc:loc, w:w, decamelize:decamelize, dasherize:dasherize, camelize:camelize, classify:classify, underscore:underscore, 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__) {
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;
function SubArray(length) {
if (arguments.length < 1) {
length = 0;
}
if (length > 0) {
this._operations = [new Operation(RETAIN, length)];
} else {
this._operations = [];
}
}
SubArray.prototype = {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) {
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;
}, 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;
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) {
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__) {
var get = __dependency1__.get;
var forEach = __dependency2__.forEach;
var RETAIN = "r";
var INSERT = "i";
var DELETE = "d";
__exports__["default"] = TrackedArray;
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 = {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) {
this._operations.splice(arrayOperationIndex, 0, newArrayOperation);
composeIndex = arrayOperationIndex;
} else {
this._split(arrayOperationIndex, index - arrayOperationRangeStart, newArrayOperation);
composeIndex = arrayOperationIndex + 1;
}
} else {
this._operations.push(newArrayOperation);
composeIndex = arrayOperationIndex;
}
this._composeInsert(composeIndex);
}, 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) {
this._operations.splice(arrayOperationIndex, 0, newArrayOperation);
composeIndex = arrayOperationIndex;
} else {
this._split(arrayOperationIndex, index - arrayOperationRangeStart, newArrayOperation);
composeIndex = arrayOperationIndex + 1;
}
return this._composeDelete(composeIndex);
}, 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)];
}, _findArrayOperation:function(index) {
var split = false;
var arrayOperationIndex, arrayOperation, arrayOperationRangeStart, arrayOperationRangeEnd, len;
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);
arrayOperation.count = splitIndex;
arrayOperation.items = arrayOperation.items.slice(0, splitIndex);
this._operations.splice(arrayOperationIndex + 1, 0, newArrayOperation, splitArrayOperation);
}, _composeInsert:function(index) {
var newArrayOperation = this._operations[index];
var leftArrayOperation = this._operations[index - 1];
var rightArrayOperation = this._operations[index + 1];
var leftOp = leftArrayOperation && leftArrayOperation.type;
var rightOp = rightArrayOperation && rightArrayOperation.type;
if (leftOp === INSERT) {
leftArrayOperation.count += newArrayOperation.count;
leftArrayOperation.items = leftArrayOperation.items.concat(newArrayOperation.items);
if (rightOp === INSERT) {
leftArrayOperation.count += rightArrayOperation.count;
leftArrayOperation.items = leftArrayOperation.items.concat(rightArrayOperation.items);
this._operations.splice(index, 2);
} else {
this._operations.splice(index, 1);
}
} else {
if (rightOp === INSERT) {
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];
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) {
removedItems = removedItems.concat(nextArrayOperation.items.splice(0, deletesToGo));
nextArrayOperation.count -= deletesToGo;
i -= 1;
nextCount = deletesToGo;
deletesToGo = 0;
} else {
if (nextCount === deletesToGo) {
removeNewAndNextOp = true;
}
removedItems = removedItems.concat(nextArrayOperation.items);
deletesToGo -= nextCount;
}
if (nextOp === INSERT) {
arrayOperation.count -= nextCount;
}
}
if (arrayOperation.count > 0) {
this._operations.splice(index + 1, i - 1 - index);
} else {
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);
}};
function ArrayOperation(operation, count, items) {
this.type = operation;
this.count = count;
this.items = items;
}
function ArrayOperationMatch(operation, index, split, rangeStart) {
this.operation = operation;
this.index = index;
this.split = split;
this.rangeStart = rangeStart;
}
});
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__) {
var Ember = __dependency1__["default"];
var setupForTesting = __dependency4__["default"];
var Test = __dependency5__["default"];
var Adapter = __dependency6__["default"];
var QUnitAdapter = __dependency7__["default"];
Ember.Test = Test;
Ember.Test.Adapter = Adapter;
Ember.Test.QUnitAdapter = QUnitAdapter;
Ember.setupForTesting = setupForTesting;
});
enifed("ember-testing/adapters/adapter", ["ember-metal/core", "ember-runtime/system/object", "exports"], function(__dependency1__, __dependency2__, __exports__) {
var Ember = __dependency1__["default"];
var EmberObject = __dependency2__["default"];
var Adapter = EmberObject.extend({asyncStart:Ember.K, asyncEnd:Ember.K, 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__) {
var Adapter = __dependency1__["default"];
var inspect = __dependency2__.inspect;
__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__) {
var get = __dependency1__.get;
var EmberError = __dependency2__["default"];
var run = __dependency3__["default"];
var jQuery = __dependency4__["default"];
var Test = __dependency5__["default"];
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")) {
var type = $el.prop("type");
if (type !== "checkbox" && (type !== "radio" && type !== "hidden")) {
run($el, function() {
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 = null;
type = contextOrType;
options = {};
} else {
if (arity === 4) {
if (typeof typeOrOptions === "object") {
context = null;
type = contextOrType;
options = typeOrOptions;
} else {
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 (++countAsync === 1) {
Test.adapter.asyncStart();
}
var watcher = setInterval(function() {
var routerIsLoading = !!app.__container__.lookup("router:main").router.activeTransition;
if (routerIsLoading) {
return;
}
if (Test.pendingAjaxRequests) {
return;
}
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;
}
clearInterval(watcher);
if (--countAsync === 0) {
Test.adapter.asyncEnd();
}
run(null, resolve, value);
}, 10);
});
}
asyncHelper("visit", visit);
asyncHelper("click", click);
asyncHelper("keyEvent", keyEvent);
asyncHelper("fillIn", fillIn);
helper("find", find);
helper("findWithAssert", findWithAssert);
asyncHelper("wait", wait);
asyncHelper("andThen", andThen);
helper("currentRouteName", currentRouteName);
helper("currentPath", currentPath);
helper("currentURL", currentURL);
helper("pauseTest", pauseTest);
asyncHelper("triggerEvent", triggerEvent);
});
enifed("ember-testing/initializers", ["ember-runtime/system/lazy_load"], function(__dependency1__) {
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__) {
var Ember = __dependency1__["default"];
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 < requests.length;i++) {
if (xhr === requests[i]) {
requests.splice(i, 1);
}
}
Test.pendingAjaxRequests = requests.length;
}
__exports__["default"] = function setupForTesting() {
if (!Test) {
Test = requireModule("ember-testing/test")["default"];
}
Ember.testing = true;
if (!Test.adapter) {
Test.adapter = QUnitAdapter.create();
}
requests = [];
Test.pendingAjaxRequests = requests.length;
jQuery(document).off("ajaxSend", incrementAjaxPendingRequests);
jQuery(document).off("ajaxComplete", decrementAjaxPendingRequests);
jQuery(document).on("ajaxSend", incrementAjaxPendingRequests);
jQuery(document).on("ajaxComplete", decrementAjaxPendingRequests);
};
});
enifed("ember-testing/support", ["ember-metal/core", "ember-views/system/jquery"], function(__dependency1__, __dependency2__) {
var Ember = __dependency1__["default"];
var jQuery = __dependency2__["default"];
var $ = jQuery;
function testCheckboxClick(handler) {
$('').css({position:"absolute", left:"-1000px", top:"-1000px"}).appendTo("body").on("click", handler).trigger("click").remove();
}
$(function() {
testCheckboxClick(function() {
if (!this.checked && !$.event.special.click) {
$.event.special.click = {trigger:function() {
if ($.nodeName(this, "input") && (this.type === "checkbox" && this.click)) {
this.click();
return false;
}
}};
}
});
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/compare", "ember-runtime/ext/rsvp", "ember-testing/setup_for_testing", "ember-application/system/application", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
var Ember = __dependency1__["default"];
var emberRun = __dependency2__["default"];
var create = __dependency3__.create;
var compare = __dependency4__["default"];
var RSVP = __dependency5__["default"];
var setupForTesting = __dependency6__["default"];
var EmberApplication = __dependency7__["default"];
var slice = [].slice;
var helpers = {};
var injectHelpersCallbacks = [];
var Test = {_helpers:helpers, registerHelper:function(name, helperMethod) {
helpers[name] = {method:helperMethod, meta:{wait:false}};
}, registerAsyncHelper:function(name, helperMethod) {
helpers[name] = {method:helperMethod, meta:{wait:true}};
}, unregisterHelper:function(name) {
delete helpers[name];
delete Test.Promise.prototype[name];
}, onInjectHelpers:function(callback) {
injectHelpersCallbacks.push(callback);
}, promise:function(resolver) {
return new Test.Promise(resolver);
}, adapter:null, resolve:function(val) {
return Test.promise(function(resolve) {
return resolve(val);
});
}, 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:function(context, callback) {
var pair;
if (!this.waiters) {
return;
}
if (arguments.length === 1) {
callback = context;
context = null;
}
pair = [context, callback];
this.waiters = Ember.A(this.waiters.filter(function(elt) {
return compare(elt, pair) !== 0;
}));
}};
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);
if (!meta.wait) {
return fn.apply(app, args);
}
if (!lastPromise) {
lastPromise = fn.apply(app, args);
} else {
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({testHelpers:{}, originalMethods:{}, testing:false, setupForTesting:function() {
setupForTesting();
this.testing = true;
this.Router.reopen({location:"none"});
}, helperContainer:window, 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);
}
}, removeTestHelpers:function() {
for (var name in helpers) {
this.helperContainer[name] = this.originalMethods[name];
delete this.testHelpers[name];
delete this.originalMethods[name];
}
}});
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;
var originalThen = RSVP.Promise.prototype.then;
Test.Promise.prototype.then = function(onSuccess, onFailure) {
return originalThen.call(this, function(val) {
return isolate(onSuccess, val);
}, onFailure);
};
function isolate(fn, val) {
var value, lastPromise;
Test.lastPromise = null;
value = fn(val);
lastPromise = Test.lastPromise;
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", "exports"], function(__dependency1__, __dependency2__, __dependency3__,
__dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __exports__) {
var Ember = __dependency1__["default"];
var jQuery = __dependency2__["default"];
var isSimpleClick = __dependency3__.isSimpleClick;
var getViewClientRects = __dependency3__.getViewClientRects;
var getViewBoundingClientRect = __dependency3__.getViewBoundingClientRect;
var RenderBuffer = __dependency4__["default"];
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"];
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.ContainerView = ContainerView;
Ember.CollectionView = CollectionView;
Ember.Component = Component;
Ember.EventDispatcher = EventDispatcher;
__exports__["default"] = Ember;
});
enifed("ember-views/mixins/component_template_deprecation", ["ember-metal/core", "ember-metal/property_get", "ember-metal/mixin", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
var Ember = __dependency1__["default"];
var get = __dependency2__.get;
var Mixin = __dependency3__.Mixin;
__exports__["default"] = Mixin.create({willMergeMixin:function(props) {
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"];
}
if (deprecatedProperty) {
Ember.deprecate("Do not specify " + deprecatedProperty + " on a Component, use " + replacementProperty + " instead.", false);
}
}});
});
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__) {
var Mixin = __dependency1__.Mixin;
var TargetActionSupport = __dependency2__["default"];
var alias = __dependency3__["default"];
__exports__["default"] = Mixin.create(TargetActionSupport, {target:alias("controller"), actionContext:alias("context")});
});
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__) {
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.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/read", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
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;
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.source = source;
this.obj = undefined;
this.key = key;
if (source && source.isStream) {
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 (prevSource && prevSource.isStream) {
prevSource.unsubscribe(this._didChange, this);
}
if (nextSource && nextSource.isStream) {
nextSource.subscribe(this._didChange, this);
}
this.source = nextSource;
this.notify();
}
}, _didChange:function() {
this.notify();
}, destroy:function() {
if (this.source && this.source.isStream) {
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;
Stream.prototype.destroy.call(this);
}});
__exports__["default"] = KeyStream;
Stream.prototype._makeChildStream = function(key) {
return new KeyStream(this, key);
};
});
enifed("ember-views/streams/read", ["ember-metal/core", "ember-metal/property_get", "ember-metal/path_cache", "ember-runtime/system/string", "ember-metal/streams/read", "ember-views/views/view", "ember-runtime/mixins/controller", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
var Ember = __dependency1__["default"];
var get = __dependency2__.get;
var isGlobal = __dependency3__.isGlobal;
var fmt = __dependency4__.fmt;
var read = __dependency5__.read;
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"}}. http://emberjs.com/guides/deprecations#toc_global-lookup-of-views', !viewClass);
} 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 of Ember.View, not %@", [viewClass]), View.detect(viewClass));
return viewClass;
}
__exports__.readViewFactory = readViewFactory;
function readUnwrappedModel(object) {
if (object && object.isStream) {
var result = object.value();
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__) {
function ActionManager() {
}
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__) {
var Ember = __dependency1__["default"];
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"];
__exports__["default"] = EmberObject.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:true, 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]);
}
}
}, 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];
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);
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__) {
var run = __dependency1__["default"];
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__) {
var Ember = __dependency1__["default"];
var forEach = __dependency2__.forEach;
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));
if (jQuery) {
var dragEvents = ["dragstart", "drag", "dragenter", "dragleave", "dragover", "drop", "dragend"];
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", "exports"], function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
var jQuery = __dependency1__["default"];
var DOMHelper = __dependency2__.DOMHelper;
var Ember = __dependency3__["default"];
var create = __dependency4__.create;
var omittedStartTagChildren = {tr:document.createElement("tbody"), col:document.createElement("colgroup")};
var omittedStartTagChildTest = /(?:"'`]/g;
var POSSIBLE_CHARS_REGEXP = /[&<>"'`]/;
function escapeAttribute(value) {
var escape = {"<":"<", ">":">", '"':""", "'":"'", "`":"`"};
var escapeChar = function(chr) {
return escape[chr] || "&";
};
var string = value.toString();
if (!POSSIBLE_CHARS_REGEXP.test(string)) {
return string;
}
return string.replace(BAD_CHARS_REGEXP, escapeChar);
}
var canSetNameOnInputs = function() {
var div = document.createElement("div");
var el = document.createElement("input");
el.setAttribute("name", "foo");
div.appendChild(el);
return!!div.innerHTML.match("foo");
}();
__exports__["default"] = function renderBuffer(tagName, contextualElement) {
return new _RenderBuffer(tagName, contextualElement);
};
function _RenderBuffer(tagName, contextualElement) {
this.tagName = tagName;
this._outerContextualElement = contextualElement;
this.buffer = null;
this.childViews = [];
this.dom = new DOMHelper;
}
_RenderBuffer.prototype = {reset:function(tagName, contextualElement) {
this.tagName = tagName;
this.buffer = null;
this._element = null;
this._outerContextualElement = contextualElement;
this.elementClasses = null;
this.elementId = null;
this.elementAttributes = null;
this.elementProperties = null;
this.elementTag = null;
this.elementStyle = null;
this.childViews.length = 0;
}, _element:null, _outerContextualElement:null, elementClasses:null, classes:null, elementId:null, elementAttributes:null, elementProperties:null, elementTag:null, elementStyle:null, pushChildView:function(view) {
var index = this.childViews.length;
this.childViews[index] = view;
this.push("