From 16e00d77cac324f5249003a1a480da483c7b2e6a Mon Sep 17 00:00:00 2001
From: Keivan Beigi <kay.one@gmail.com>
Date: Thu, 16 May 2013 15:49:57 -0700
Subject: [PATCH] updated handlebar runtime. update your compiler 'npm update'

---
 UI/JsLibraries/backbone.pageable.js  |  10 +-
 UI/JsLibraries/handlebars.runtime.js | 601 ++++++++++++++-------------
 2 files changed, 321 insertions(+), 290 deletions(-)

diff --git a/UI/JsLibraries/backbone.pageable.js b/UI/JsLibraries/backbone.pageable.js
index de4e36a07..7733d1c54 100644
--- a/UI/JsLibraries/backbone.pageable.js
+++ b/UI/JsLibraries/backbone.pageable.js
@@ -1,5 +1,5 @@
 /*
-  backbone-pageable 1.2.3
+  backbone-pageable 1.2.4
   http://github.com/wyuenho/backbone-pageable
 
   Copyright (c) 2013 Jimmy Yuen Ho Wong
@@ -260,8 +260,8 @@
        @param {Object} [options]
 
        @param {function(*, *): number} [options.comparator] If specified, this
-       comparator is set to the current page under server mode, or the
-       #fullCollection otherwise.
+       comparator is set to the current page under server mode, or the #fullCollection
+       otherwise.
 
        @param {boolean} [options.full] If `false` and either a
        `options.comparator` or `sortKey` is defined, the comparator is attached
@@ -281,7 +281,9 @@
 
        @param {Object} [options.queryParam]
     */
-    initialize: function (models, options) {
+    constructor: function (models, options) {
+
+      Backbone.Collection.apply(this, arguments);
 
       options = options || {};
 
diff --git a/UI/JsLibraries/handlebars.runtime.js b/UI/JsLibraries/handlebars.runtime.js
index 08cc4f03c..7dd40f62e 100644
--- a/UI/JsLibraries/handlebars.runtime.js
+++ b/UI/JsLibraries/handlebars.runtime.js
@@ -1,316 +1,345 @@
 /*
 
- Copyright (C) 2011 by Yehuda Katz
+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:
+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 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.
+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
+;
+// lib/handlebars/base.js
 
-    Handlebars.VERSION = "1.0.0-rc.3";
-    Handlebars.COMPILER_REVISION = 2;
+Handlebars.VERSION = "1.0.0-rc.4";
+Handlebars.COMPILER_REVISION = 3;
 
-    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.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',
+  3: '>= 1.0.0-rc.4'
+};
+
+Handlebars.helpers  = {};
+Handlebars.partials = {};
+
+var toString = Object.prototype.toString,
+    functionType = '[object Function]',
+    objectType = '[object Object]';
+
+Handlebars.registerHelper = function(name, fn, inverse) {
+  if (toString.call(name) === objectType) {
+    if (inverse || fn) { throw new Handlebars.Exception('Arg not supported with multiple helpers'); }
+    Handlebars.Utils.extend(this.helpers, name);
+  } else {
+    if (inverse) { fn.not = inverse; }
+    this.helpers[name] = fn;
+  }
+};
+
+Handlebars.registerPartial = function(name, str) {
+  if (toString.call(name) === objectType) {
+    Handlebars.Utils.extend(this.partials,  name);
+  } else {
+    this.partials[name] = str;
+  }
+};
+
+Handlebars.registerHelper('helperMissing', function(arg) {
+  if(arguments.length === 2) {
+    return undefined;
+  } else {
+    throw new Error("Could not find property '" + arg + "'");
+  }
+});
+
+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 = {
+  extend: function(obj, value) {
+    for(var key in value) {
+      if(value.hasOwnProperty(key)) {
+        obj[key] = value[key];
+      }
+    }
+  },
+
+  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 "";
+    }
+
+    // Force a string conversion as this will be done by the append regardless and
+    // the regex test will do this transparently behind the scenes, causing issues if
+    // an object's to string has escaped characters in it.
+    string = string.toString();
+
+    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) {
+          programWrapper = Handlebars.VM.program(i, fn, data);
+        } else if (!programWrapper) {
+          programWrapper = this.programs[i] = Handlebars.VM.program(i, fn);
+        }
+        return programWrapper;
+      },
+      programWithDepth: Handlebars.VM.programWithDepth,
+      noop: Handlebars.VM.noop,
+      compilerInfo: null
     };
 
-    Handlebars.helpers  = {};
-    Handlebars.partials = {};
+    return function(context, options) {
+      options = options || {};
+      var result = templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
 
-    Handlebars.registerHelper = function(name, fn, inverse) {
-        if(inverse) { fn.not = inverse; }
-        this.helpers[name] = fn;
-    };
+      var compilerInfo = container.compilerInfo || [],
+          compilerRevision = compilerInfo[0] || 1,
+          currentRevision = Handlebars.COMPILER_REVISION;
 
-    Handlebars.registerPartial = function(name, str) {
-        this.partials[name] = str;
-    };
-
-    Handlebars.registerHelper('helperMissing', function(arg) {
-        if(arguments.length === 2) {
-            return undefined;
+      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 {
-            throw new Error("Could not find property '" + arg + "'");
+          // 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]+").";
         }
-    });
+      }
 
-    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;
+      return result;
     };
+  },
 
-    Handlebars.logger = {
-        DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3,
+  programWithDepth: function(i, fn, data /*, $depth */) {
+    var args = Array.prototype.slice.call(arguments, 3);
 
-        methodMap: {0: 'debug', 1: 'info', 2: 'warn', 3: 'error'},
+    var program = function(context, options) {
+      options = options || {};
 
-        // 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);
-                }
-            }
-        }
+      return fn.apply(this, [context, options.data || data].concat(args));
     };
+    program.program = i;
+    program.depth = args.length;
+    return program;
+  },
+  program: function(i, fn, data) {
+    var program = function(context, options) {
+      options = options || {};
 
-    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]];
-        }
+      return fn(context, options.data || data);
     };
-    Handlebars.Exception.prototype = new Error();
+    program.program = i;
+    program.depth = 0;
+    return program;
+  },
+  noop: function() { return ""; },
+  invokePartial: function(partial, name, context, helpers, partials, data) {
+    var options = { helpers: helpers, partials: partials, data: data };
 
-    // Build out our basic SafeString type
-    Handlebars.SafeString = function(string) {
-        this.string = string;
-    };
-    Handlebars.SafeString.prototype.toString = function() {
-        return this.string.toString();
-    };
+    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);
+    }
+  }
+};
 
-    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.template = Handlebars.VM.template;
+;
+// lib/handlebars/browser-suffix.js
 })(Handlebars);
-;
\ No newline at end of file
+;