replaced full version of handlebar with handlebar.runtime since we don't need the compiler anymore.

UI/JsLibraries/handlebars.runtime.js

@@ -0,0 +1,316 @@
+/*
+
+ Copyright (C) 2011 by Yehuda Katz
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+
+ */
+
+// lib/handlebars/browser-prefix.js
+var Handlebars = {};
+
+(function(Handlebars, undefined) {
+    ;
+    // lib/handlebars/base.js
+
+    Handlebars.VERSION = "1.0.0-rc.3";
+    Handlebars.COMPILER_REVISION = 2;
+
+    Handlebars.REVISION_CHANGES = {
+        1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
+        2: '>= 1.0.0-rc.3'
+    };
+
+    Handlebars.helpers  = {};
+    Handlebars.partials = {};
+
+    Handlebars.registerHelper = function(name, fn, inverse) {
+        if(inverse) { fn.not = inverse; }
+        this.helpers[name] = fn;
+    };
+
+    Handlebars.registerPartial = function(name, str) {
+        this.partials[name] = str;
+    };
+
+    Handlebars.registerHelper('helperMissing', function(arg) {
+        if(arguments.length === 2) {
+            return undefined;
+        } else {
+            throw new Error("Could not find property '" + arg + "'");
+        }
+    });
+
+    var toString = Object.prototype.toString, functionType = "[object Function]";
+
+    Handlebars.registerHelper('blockHelperMissing', function(context, options) {
+        var inverse = options.inverse || function() {}, fn = options.fn;
+
+        var type = toString.call(context);
+
+        if(type === functionType) { context = context.call(this); }
+
+        if(context === true) {
+            return fn(this);
+        } else if(context === false || context == null) {
+            return inverse(this);
+        } else if(type === "[object Array]") {
+            if(context.length > 0) {
+                return Handlebars.helpers.each(context, options);
+            } else {
+                return inverse(this);
+            }
+        } else {
+            return fn(context);
+        }
+    });
+
+    Handlebars.K = function() {};
+
+    Handlebars.createFrame = Object.create || function(object) {
+        Handlebars.K.prototype = object;
+        var obj = new Handlebars.K();
+        Handlebars.K.prototype = null;
+        return obj;
+    };
+
+    Handlebars.logger = {
+        DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3,
+
+        methodMap: {0: 'debug', 1: 'info', 2: 'warn', 3: 'error'},
+
+        // can be overridden in the host environment
+        log: function(level, obj) {
+            if (Handlebars.logger.level <= level) {
+                var method = Handlebars.logger.methodMap[level];
+                if (typeof console !== 'undefined' && console[method]) {
+                    console[method].call(console, obj);
+                }
+            }
+        }
+    };
+
+    Handlebars.log = function(level, obj) { Handlebars.logger.log(level, obj); };
+
+    Handlebars.registerHelper('each', function(context, options) {
+        var fn = options.fn, inverse = options.inverse;
+        var i = 0, ret = "", data;
+
+        if (options.data) {
+            data = Handlebars.createFrame(options.data);
+        }
+
+        if(context && typeof context === 'object') {
+            if(context instanceof Array){
+                for(var j = context.length; i<j; i++) {
+                    if (data) { data.index = i; }
+                    ret = ret + fn(context[i], { data: data });
+                }
+            } else {
+                for(var key in context) {
+                    if(context.hasOwnProperty(key)) {
+                        if(data) { data.key = key; }
+                        ret = ret + fn(context[key], {data: data});
+                        i++;
+                    }
+                }
+            }
+        }
+
+        if(i === 0){
+            ret = inverse(this);
+        }
+
+        return ret;
+    });
+
+    Handlebars.registerHelper('if', function(context, options) {
+        var type = toString.call(context);
+        if(type === functionType) { context = context.call(this); }
+
+        if(!context || Handlebars.Utils.isEmpty(context)) {
+            return options.inverse(this);
+        } else {
+            return options.fn(this);
+        }
+    });
+
+    Handlebars.registerHelper('unless', function(context, options) {
+        return Handlebars.helpers['if'].call(this, context, {fn: options.inverse, inverse: options.fn});
+    });
+
+    Handlebars.registerHelper('with', function(context, options) {
+        if (!Handlebars.Utils.isEmpty(context)) return options.fn(context);
+    });
+
+    Handlebars.registerHelper('log', function(context, options) {
+        var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
+        Handlebars.log(level, context);
+    });
+    ;
+    // lib/handlebars/utils.js
+
+    var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
+
+    Handlebars.Exception = function(message) {
+        var tmp = Error.prototype.constructor.apply(this, arguments);
+
+        // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
+        for (var idx = 0; idx < errorProps.length; idx++) {
+            this[errorProps[idx]] = tmp[errorProps[idx]];
+        }
+    };
+    Handlebars.Exception.prototype = new Error();
+
+    // Build out our basic SafeString type
+    Handlebars.SafeString = function(string) {
+        this.string = string;
+    };
+    Handlebars.SafeString.prototype.toString = function() {
+        return this.string.toString();
+    };
+
+    var escape = {
+        "&": "&amp;",
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&quot;",
+        "'": "&#x27;",
+        "`": "&#x60;"
+    };
+
+    var badChars = /[&<>"'`]/g;
+    var possible = /[&<>"'`]/;
+
+    var escapeChar = function(chr) {
+        return escape[chr] || "&amp;";
+    };
+
+    Handlebars.Utils = {
+        escapeExpression: function(string) {
+            // don't escape SafeStrings, since they're already safe
+            if (string instanceof Handlebars.SafeString) {
+                return string.toString();
+            } else if (string == null || string === false) {
+                return "";
+            }
+
+            if(!possible.test(string)) { return string; }
+            return string.replace(badChars, escapeChar);
+        },
+
+        isEmpty: function(value) {
+            if (!value && value !== 0) {
+                return true;
+            } else if(toString.call(value) === "[object Array]" && value.length === 0) {
+                return true;
+            } else {
+                return false;
+            }
+        }
+    };
+    ;
+    // lib/handlebars/runtime.js
+
+    Handlebars.VM = {
+        template: function(templateSpec) {
+            // Just add water
+            var container = {
+                escapeExpression: Handlebars.Utils.escapeExpression,
+                invokePartial: Handlebars.VM.invokePartial,
+                programs: [],
+                program: function(i, fn, data) {
+                    var programWrapper = this.programs[i];
+                    if(data) {
+                        return Handlebars.VM.program(fn, data);
+                    } else if(programWrapper) {
+                        return programWrapper;
+                    } else {
+                        programWrapper = this.programs[i] = Handlebars.VM.program(fn);
+                        return programWrapper;
+                    }
+                },
+                programWithDepth: Handlebars.VM.programWithDepth,
+                noop: Handlebars.VM.noop,
+                compilerInfo: null
+            };
+
+            return function(context, options) {
+                options = options || {};
+                var result = templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
+
+                var compilerInfo = container.compilerInfo || [],
+                    compilerRevision = compilerInfo[0] || 1,
+                    currentRevision = Handlebars.COMPILER_REVISION;
+
+                if (compilerRevision !== currentRevision) {
+                    if (compilerRevision < currentRevision) {
+                        var runtimeVersions = Handlebars.REVISION_CHANGES[currentRevision],
+                            compilerVersions = Handlebars.REVISION_CHANGES[compilerRevision];
+                        throw "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 {
+                        // Use the embedded version info since the runtime doesn't know about this revision yet
+                        throw "Template was precompiled with a newer version of Handlebars than the current runtime. "+
+                            "Please update your runtime to a newer version ("+compilerInfo[1]+").";
+                    }
+                }
+
+                return result;
+            };
+        },
+
+        programWithDepth: function(fn, data, $depth) {
+            var args = Array.prototype.slice.call(arguments, 2);
+
+            return function(context, options) {
+                options = options || {};
+
+                return fn.apply(this, [context, options.data || data].concat(args));
+            };
+        },
+        program: function(fn, data) {
+            return function(context, options) {
+                options = options || {};
+
+                return fn(context, options.data || data);
+            };
+        },
+        noop: function() { return ""; },
+        invokePartial: function(partial, name, context, helpers, partials, data) {
+            var options = { helpers: helpers, partials: partials, data: data };
+
+            if(partial === undefined) {
+                throw new Handlebars.Exception("The partial " + name + " could not be found");
+            } else if(partial instanceof Function) {
+                return partial(context, options);
+            } else if (!Handlebars.compile) {
+                throw new Handlebars.Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
+            } else {
+                partials[name] = Handlebars.compile(partial, {data: data !== undefined});
+                return partials[name](context, options);
+            }
+        }
+    };
+
+    Handlebars.template = Handlebars.VM.template;
+    ;
+    // lib/handlebars/browser-suffix.js
+})(Handlebars);
+;

UI/Series/SeasonModel.js

@@ -6,7 +6,7 @@
                 var seasonNumber = this.get('seasonNumber');
 
                 if (seasonNumber === 0) {
-                    return "Specials"
+                    return "Specials";
                 }
 
                 return "Season " + seasonNumber;