You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@atlas.apache.org by ma...@apache.org on 2016/12/23 01:47:11 UTC
[42/50] [abbrv] incubator-atlas git commit: ATLAS-1142 Lineage UI
Improvement (kevalbhatt via shwethags)
http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/a8307be0/dashboardv2/public/js/external_lib/require-handlebars-plugin/js/handlebars.js
----------------------------------------------------------------------
diff --git a/dashboardv2/public/js/external_lib/require-handlebars-plugin/js/handlebars.js b/dashboardv2/public/js/external_lib/require-handlebars-plugin/js/handlebars.js
new file mode 100644
index 0000000..b62aa79
--- /dev/null
+++ b/dashboardv2/public/js/external_lib/require-handlebars-plugin/js/handlebars.js
@@ -0,0 +1,3103 @@
+(function() {
+ /*
+
+ 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) {
+ 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);
+ });;
+ }(Handlebars));;
+ //>>excludeStart('excludeHbsParser', pragmas.excludeHbsParser)
+ // lib/handlebars/compiler/parser.js
+ /* Jison generated parser */
+ var handlebars = (function() {
+ var parser = {
+ trace: function trace() {},
+ yy: {},
+ symbols_: {
+ "error": 2,
+ "root": 3,
+ "program": 4,
+ "EOF": 5,
+ "simpleInverse": 6,
+ "statements": 7,
+ "statement": 8,
+ "openInverse": 9,
+ "closeBlock": 10,
+ "openBlock": 11,
+ "mustache": 12,
+ "partial": 13,
+ "CONTENT": 14,
+ "COMMENT": 15,
+ "OPEN_BLOCK": 16,
+ "inMustache": 17,
+ "CLOSE": 18,
+ "OPEN_INVERSE": 19,
+ "OPEN_ENDBLOCK": 20,
+ "path": 21,
+ "OPEN": 22,
+ "OPEN_UNESCAPED": 23,
+ "OPEN_PARTIAL": 24,
+ "partialName": 25,
+ "params": 26,
+ "hash": 27,
+ "DATA": 28,
+ "param": 29,
+ "STRING": 30,
+ "INTEGER": 31,
+ "BOOLEAN": 32,
+ "hashSegments": 33,
+ "hashSegment": 34,
+ "ID": 35,
+ "EQUALS": 36,
+ "PARTIAL_NAME": 37,
+ "pathSegments": 38,
+ "SEP": 39,
+ "$accept": 0,
+ "$end": 1
+ },
+ terminals_: {
+ 2: "error",
+ 5: "EOF",
+ 14: "CONTENT",
+ 15: "COMMENT",
+ 16: "OPEN_BLOCK",
+ 18: "CLOSE",
+ 19: "OPEN_INVERSE",
+ 20: "OPEN_ENDBLOCK",
+ 22: "OPEN",
+ 23: "OPEN_UNESCAPED",
+ 24: "OPEN_PARTIAL",
+ 28: "DATA",
+ 30: "STRING",
+ 31: "INTEGER",
+ 32: "BOOLEAN",
+ 35: "ID",
+ 36: "EQUALS",
+ 37: "PARTIAL_NAME",
+ 39: "SEP"
+ },
+ productions_: [0, [3, 2],
+ [4, 2],
+ [4, 3],
+ [4, 2],
+ [4, 1],
+ [4, 1],
+ [4, 0],
+ [7, 1],
+ [7, 2],
+ [8, 3],
+ [8, 3],
+ [8, 1],
+ [8, 1],
+ [8, 1],
+ [8, 1],
+ [11, 3],
+ [9, 3],
+ [10, 3],
+ [12, 3],
+ [12, 3],
+ [13, 3],
+ [13, 4],
+ [6, 2],
+ [17, 3],
+ [17, 2],
+ [17, 2],
+ [17, 1],
+ [17, 1],
+ [26, 2],
+ [26, 1],
+ [29, 1],
+ [29, 1],
+ [29, 1],
+ [29, 1],
+ [29, 1],
+ [27, 1],
+ [33, 2],
+ [33, 1],
+ [34, 3],
+ [34, 3],
+ [34, 3],
+ [34, 3],
+ [34, 3],
+ [25, 1],
+ [21, 1],
+ [38, 3],
+ [38, 1]
+ ],
+ performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
+
+ var $0 = $$.length - 1;
+ switch (yystate) {
+ case 1:
+ return $$[$0 - 1];
+ break;
+ case 2:
+ this.$ = new yy.ProgramNode([], $$[$0]);
+ break;
+ case 3:
+ this.$ = new yy.ProgramNode($$[$0 - 2], $$[$0]);
+ break;
+ case 4:
+ this.$ = new yy.ProgramNode($$[$0 - 1], []);
+ break;
+ case 5:
+ this.$ = new yy.ProgramNode($$[$0]);
+ break;
+ case 6:
+ this.$ = new yy.ProgramNode([], []);
+ break;
+ case 7:
+ this.$ = new yy.ProgramNode([]);
+ break;
+ case 8:
+ this.$ = [$$[$0]];
+ break;
+ case 9:
+ $$[$0 - 1].push($$[$0]);
+ this.$ = $$[$0 - 1];
+ break;
+ case 10:
+ this.$ = new yy.BlockNode($$[$0 - 2], $$[$0 - 1].inverse, $$[$0 - 1], $$[$0]);
+ break;
+ case 11:
+ this.$ = new yy.BlockNode($$[$0 - 2], $$[$0 - 1], $$[$0 - 1].inverse, $$[$0]);
+ break;
+ case 12:
+ this.$ = $$[$0];
+ break;
+ case 13:
+ this.$ = $$[$0];
+ break;
+ case 14:
+ this.$ = new yy.ContentNode($$[$0]);
+ break;
+ case 15:
+ this.$ = new yy.CommentNode($$[$0]);
+ break;
+ case 16:
+ this.$ = new yy.MustacheNode($$[$0 - 1][0], $$[$0 - 1][1]);
+ break;
+ case 17:
+ this.$ = new yy.MustacheNode($$[$0 - 1][0], $$[$0 - 1][1]);
+ break;
+ case 18:
+ this.$ = $$[$0 - 1];
+ break;
+ case 19:
+ this.$ = new yy.MustacheNode($$[$0 - 1][0], $$[$0 - 1][1]);
+ break;
+ case 20:
+ this.$ = new yy.MustacheNode($$[$0 - 1][0], $$[$0 - 1][1], true);
+ break;
+ case 21:
+ this.$ = new yy.PartialNode($$[$0 - 1]);
+ break;
+ case 22:
+ this.$ = new yy.PartialNode($$[$0 - 2], $$[$0 - 1]);
+ break;
+ case 23:
+ break;
+ case 24:
+ this.$ = [
+ [$$[$0 - 2]].concat($$[$0 - 1]), $$[$0]
+ ];
+ break;
+ case 25:
+ this.$ = [
+ [$$[$0 - 1]].concat($$[$0]), null
+ ];
+ break;
+ case 26:
+ this.$ = [
+ [$$[$0 - 1]], $$[$0]
+ ];
+ break;
+ case 27:
+ this.$ = [
+ [$$[$0]], null
+ ];
+ break;
+ case 28:
+ this.$ = [
+ [new yy.DataNode($$[$0])], null
+ ];
+ break;
+ case 29:
+ $$[$0 - 1].push($$[$0]);
+ this.$ = $$[$0 - 1];
+ break;
+ case 30:
+ this.$ = [$$[$0]];
+ break;
+ case 31:
+ this.$ = $$[$0];
+ break;
+ case 32:
+ this.$ = new yy.StringNode($$[$0]);
+ break;
+ case 33:
+ this.$ = new yy.IntegerNode($$[$0]);
+ break;
+ case 34:
+ this.$ = new yy.BooleanNode($$[$0]);
+ break;
+ case 35:
+ this.$ = new yy.DataNode($$[$0]);
+ break;
+ case 36:
+ this.$ = new yy.HashNode($$[$0]);
+ break;
+ case 37:
+ $$[$0 - 1].push($$[$0]);
+ this.$ = $$[$0 - 1];
+ break;
+ case 38:
+ this.$ = [$$[$0]];
+ break;
+ case 39:
+ this.$ = [$$[$0 - 2], $$[$0]];
+ break;
+ case 40:
+ this.$ = [$$[$0 - 2], new yy.StringNode($$[$0])];
+ break;
+ case 41:
+ this.$ = [$$[$0 - 2], new yy.IntegerNode($$[$0])];
+ break;
+ case 42:
+ this.$ = [$$[$0 - 2], new yy.BooleanNode($$[$0])];
+ break;
+ case 43:
+ this.$ = [$$[$0 - 2], new yy.DataNode($$[$0])];
+ break;
+ case 44:
+ this.$ = new yy.PartialNameNode($$[$0]);
+ break;
+ case 45:
+ this.$ = new yy.IdNode($$[$0]);
+ break;
+ case 46:
+ $$[$0 - 2].push($$[$0]);
+ this.$ = $$[$0 - 2];
+ break;
+ case 47:
+ this.$ = [$$[$0]];
+ break;
+ }
+ },
+ table: [{
+ 3: 1,
+ 4: 2,
+ 5: [2, 7],
+ 6: 3,
+ 7: 4,
+ 8: 6,
+ 9: 7,
+ 11: 8,
+ 12: 9,
+ 13: 10,
+ 14: [1, 11],
+ 15: [1, 12],
+ 16: [1, 13],
+ 19: [1, 5],
+ 22: [1, 14],
+ 23: [1, 15],
+ 24: [1, 16]
+ }, {
+ 1: [3]
+ }, {
+ 5: [1, 17]
+ }, {
+ 5: [2, 6],
+ 7: 18,
+ 8: 6,
+ 9: 7,
+ 11: 8,
+ 12: 9,
+ 13: 10,
+ 14: [1, 11],
+ 15: [1, 12],
+ 16: [1, 13],
+ 19: [1, 19],
+ 20: [2, 6],
+ 22: [1, 14],
+ 23: [1, 15],
+ 24: [1, 16]
+ }, {
+ 5: [2, 5],
+ 6: 20,
+ 8: 21,
+ 9: 7,
+ 11: 8,
+ 12: 9,
+ 13: 10,
+ 14: [1, 11],
+ 15: [1, 12],
+ 16: [1, 13],
+ 19: [1, 5],
+ 20: [2, 5],
+ 22: [1, 14],
+ 23: [1, 15],
+ 24: [1, 16]
+ }, {
+ 17: 23,
+ 18: [1, 22],
+ 21: 24,
+ 28: [1, 25],
+ 35: [1, 27],
+ 38: 26
+ }, {
+ 5: [2, 8],
+ 14: [2, 8],
+ 15: [2, 8],
+ 16: [2, 8],
+ 19: [2, 8],
+ 20: [2, 8],
+ 22: [2, 8],
+ 23: [2, 8],
+ 24: [2, 8]
+ }, {
+ 4: 28,
+ 6: 3,
+ 7: 4,
+ 8: 6,
+ 9: 7,
+ 11: 8,
+ 12: 9,
+ 13: 10,
+ 14: [1, 11],
+ 15: [1, 12],
+ 16: [1, 13],
+ 19: [1, 5],
+ 20: [2, 7],
+ 22: [1, 14],
+ 23: [1, 15],
+ 24: [1, 16]
+ }, {
+ 4: 29,
+ 6: 3,
+ 7: 4,
+ 8: 6,
+ 9: 7,
+ 11: 8,
+ 12: 9,
+ 13: 10,
+ 14: [1, 11],
+ 15: [1, 12],
+ 16: [1, 13],
+ 19: [1, 5],
+ 20: [2, 7],
+ 22: [1, 14],
+ 23: [1, 15],
+ 24: [1, 16]
+ }, {
+ 5: [2, 12],
+ 14: [2, 12],
+ 15: [2, 12],
+ 16: [2, 12],
+ 19: [2, 12],
+ 20: [2, 12],
+ 22: [2, 12],
+ 23: [2, 12],
+ 24: [2, 12]
+ }, {
+ 5: [2, 13],
+ 14: [2, 13],
+ 15: [2, 13],
+ 16: [2, 13],
+ 19: [2, 13],
+ 20: [2, 13],
+ 22: [2, 13],
+ 23: [2, 13],
+ 24: [2, 13]
+ }, {
+ 5: [2, 14],
+ 14: [2, 14],
+ 15: [2, 14],
+ 16: [2, 14],
+ 19: [2, 14],
+ 20: [2, 14],
+ 22: [2, 14],
+ 23: [2, 14],
+ 24: [2, 14]
+ }, {
+ 5: [2, 15],
+ 14: [2, 15],
+ 15: [2, 15],
+ 16: [2, 15],
+ 19: [2, 15],
+ 20: [2, 15],
+ 22: [2, 15],
+ 23: [2, 15],
+ 24: [2, 15]
+ }, {
+ 17: 30,
+ 21: 24,
+ 28: [1, 25],
+ 35: [1, 27],
+ 38: 26
+ }, {
+ 17: 31,
+ 21: 24,
+ 28: [1, 25],
+ 35: [1, 27],
+ 38: 26
+ }, {
+ 17: 32,
+ 21: 24,
+ 28: [1, 25],
+ 35: [1, 27],
+ 38: 26
+ }, {
+ 25: 33,
+ 37: [1, 34]
+ }, {
+ 1: [2, 1]
+ }, {
+ 5: [2, 2],
+ 8: 21,
+ 9: 7,
+ 11: 8,
+ 12: 9,
+ 13: 10,
+ 14: [1, 11],
+ 15: [1, 12],
+ 16: [1, 13],
+ 19: [1, 19],
+ 20: [2, 2],
+ 22: [1, 14],
+ 23: [1, 15],
+ 24: [1, 16]
+ }, {
+ 17: 23,
+ 21: 24,
+ 28: [1, 25],
+ 35: [1, 27],
+ 38: 26
+ }, {
+ 5: [2, 4],
+ 7: 35,
+ 8: 6,
+ 9: 7,
+ 11: 8,
+ 12: 9,
+ 13: 10,
+ 14: [1, 11],
+ 15: [1, 12],
+ 16: [1, 13],
+ 19: [1, 19],
+ 20: [2, 4],
+ 22: [1, 14],
+ 23: [1, 15],
+ 24: [1, 16]
+ }, {
+ 5: [2, 9],
+ 14: [2, 9],
+ 15: [2, 9],
+ 16: [2, 9],
+ 19: [2, 9],
+ 20: [2, 9],
+ 22: [2, 9],
+ 23: [2, 9],
+ 24: [2, 9]
+ }, {
+ 5: [2, 23],
+ 14: [2, 23],
+ 15: [2, 23],
+ 16: [2, 23],
+ 19: [2, 23],
+ 20: [2, 23],
+ 22: [2, 23],
+ 23: [2, 23],
+ 24: [2, 23]
+ }, {
+ 18: [1, 36]
+ }, {
+ 18: [2, 27],
+ 21: 41,
+ 26: 37,
+ 27: 38,
+ 28: [1, 45],
+ 29: 39,
+ 30: [1, 42],
+ 31: [1, 43],
+ 32: [1, 44],
+ 33: 40,
+ 34: 46,
+ 35: [1, 47],
+ 38: 26
+ }, {
+ 18: [2, 28]
+ }, {
+ 18: [2, 45],
+ 28: [2, 45],
+ 30: [2, 45],
+ 31: [2, 45],
+ 32: [2, 45],
+ 35: [2, 45],
+ 39: [1, 48]
+ }, {
+ 18: [2, 47],
+ 28: [2, 47],
+ 30: [2, 47],
+ 31: [2, 47],
+ 32: [2, 47],
+ 35: [2, 47],
+ 39: [2, 47]
+ }, {
+ 10: 49,
+ 20: [1, 50]
+ }, {
+ 10: 51,
+ 20: [1, 50]
+ }, {
+ 18: [1, 52]
+ }, {
+ 18: [1, 53]
+ }, {
+ 18: [1, 54]
+ }, {
+ 18: [1, 55],
+ 21: 56,
+ 35: [1, 27],
+ 38: 26
+ }, {
+ 18: [2, 44],
+ 35: [2, 44]
+ }, {
+ 5: [2, 3],
+ 8: 21,
+ 9: 7,
+ 11: 8,
+ 12: 9,
+ 13: 10,
+ 14: [1, 11],
+ 15: [1, 12],
+ 16: [1, 13],
+ 19: [1, 19],
+ 20: [2, 3],
+ 22: [1, 14],
+ 23: [1, 15],
+ 24: [1, 16]
+ }, {
+ 14: [2, 17],
+ 15: [2, 17],
+ 16: [2, 17],
+ 19: [2, 17],
+ 20: [2, 17],
+ 22: [2, 17],
+ 23: [2, 17],
+ 24: [2, 17]
+ }, {
+ 18: [2, 25],
+ 21: 41,
+ 27: 57,
+ 28: [1, 45],
+ 29: 58,
+ 30: [1, 42],
+ 31: [1, 43],
+ 32: [1, 44],
+ 33: 40,
+ 34: 46,
+ 35: [1, 47],
+ 38: 26
+ }, {
+ 18: [2, 26]
+ }, {
+ 18: [2, 30],
+ 28: [2, 30],
+ 30: [2, 30],
+ 31: [2, 30],
+ 32: [2, 30],
+ 35: [2, 30]
+ }, {
+ 18: [2, 36],
+ 34: 59,
+ 35: [1, 60]
+ }, {
+ 18: [2, 31],
+ 28: [2, 31],
+ 30: [2, 31],
+ 31: [2, 31],
+ 32: [2, 31],
+ 35: [2, 31]
+ }, {
+ 18: [2, 32],
+ 28: [2, 32],
+ 30: [2, 32],
+ 31: [2, 32],
+ 32: [2, 32],
+ 35: [2, 32]
+ }, {
+ 18: [2, 33],
+ 28: [2, 33],
+ 30: [2, 33],
+ 31: [2, 33],
+ 32: [2, 33],
+ 35: [2, 33]
+ }, {
+ 18: [2, 34],
+ 28: [2, 34],
+ 30: [2, 34],
+ 31: [2, 34],
+ 32: [2, 34],
+ 35: [2, 34]
+ }, {
+ 18: [2, 35],
+ 28: [2, 35],
+ 30: [2, 35],
+ 31: [2, 35],
+ 32: [2, 35],
+ 35: [2, 35]
+ }, {
+ 18: [2, 38],
+ 35: [2, 38]
+ }, {
+ 18: [2, 47],
+ 28: [2, 47],
+ 30: [2, 47],
+ 31: [2, 47],
+ 32: [2, 47],
+ 35: [2, 47],
+ 36: [1, 61],
+ 39: [2, 47]
+ }, {
+ 35: [1, 62]
+ }, {
+ 5: [2, 10],
+ 14: [2, 10],
+ 15: [2, 10],
+ 16: [2, 10],
+ 19: [2, 10],
+ 20: [2, 10],
+ 22: [2, 10],
+ 23: [2, 10],
+ 24: [2, 10]
+ }, {
+ 21: 63,
+ 35: [1, 27],
+ 38: 26
+ }, {
+ 5: [2, 11],
+ 14: [2, 11],
+ 15: [2, 11],
+ 16: [2, 11],
+ 19: [2, 11],
+ 20: [2, 11],
+ 22: [2, 11],
+ 23: [2, 11],
+ 24: [2, 11]
+ }, {
+ 14: [2, 16],
+ 15: [2, 16],
+ 16: [2, 16],
+ 19: [2, 16],
+ 20: [2, 16],
+ 22: [2, 16],
+ 23: [2, 16],
+ 24: [2, 16]
+ }, {
+ 5: [2, 19],
+ 14: [2, 19],
+ 15: [2, 19],
+ 16: [2, 19],
+ 19: [2, 19],
+ 20: [2, 19],
+ 22: [2, 19],
+ 23: [2, 19],
+ 24: [2, 19]
+ }, {
+ 5: [2, 20],
+ 14: [2, 20],
+ 15: [2, 20],
+ 16: [2, 20],
+ 19: [2, 20],
+ 20: [2, 20],
+ 22: [2, 20],
+ 23: [2, 20],
+ 24: [2, 20]
+ }, {
+ 5: [2, 21],
+ 14: [2, 21],
+ 15: [2, 21],
+ 16: [2, 21],
+ 19: [2, 21],
+ 20: [2, 21],
+ 22: [2, 21],
+ 23: [2, 21],
+ 24: [2, 21]
+ }, {
+ 18: [1, 64]
+ }, {
+ 18: [2, 24]
+ }, {
+ 18: [2, 29],
+ 28: [2, 29],
+ 30: [2, 29],
+ 31: [2, 29],
+ 32: [2, 29],
+ 35: [2, 29]
+ }, {
+ 18: [2, 37],
+ 35: [2, 37]
+ }, {
+ 36: [1, 61]
+ }, {
+ 21: 65,
+ 28: [1, 69],
+ 30: [1, 66],
+ 31: [1, 67],
+ 32: [1, 68],
+ 35: [1, 27],
+ 38: 26
+ }, {
+ 18: [2, 46],
+ 28: [2, 46],
+ 30: [2, 46],
+ 31: [2, 46],
+ 32: [2, 46],
+ 35: [2, 46],
+ 39: [2, 46]
+ }, {
+ 18: [1, 70]
+ }, {
+ 5: [2, 22],
+ 14: [2, 22],
+ 15: [2, 22],
+ 16: [2, 22],
+ 19: [2, 22],
+ 20: [2, 22],
+ 22: [2, 22],
+ 23: [2, 22],
+ 24: [2, 22]
+ }, {
+ 18: [2, 39],
+ 35: [2, 39]
+ }, {
+ 18: [2, 40],
+ 35: [2, 40]
+ }, {
+ 18: [2, 41],
+ 35: [2, 41]
+ }, {
+ 18: [2, 42],
+ 35: [2, 42]
+ }, {
+ 18: [2, 43],
+ 35: [2, 43]
+ }, {
+ 5: [2, 18],
+ 14: [2, 18],
+ 15: [2, 18],
+ 16: [2, 18],
+ 19: [2, 18],
+ 20: [2, 18],
+ 22: [2, 18],
+ 23: [2, 18],
+ 24: [2, 18]
+ }],
+ defaultActions: {
+ 17: [2, 1],
+ 25: [2, 28],
+ 38: [2, 26],
+ 57: [2, 24]
+ },
+ 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;
+ }
+ };
+ /* Jison generated lexer */
+ 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.yyleng -= len;
+ 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) {
+
+ var YYSTATE = YY_START
+ switch ($avoiding_name_collisions) {
+ case 0:
+ if (yy_.yytext.slice(-1) !== "\\") this.begin("mu");
+ if (yy_.yytext.slice(-1) === "\\") yy_.yytext = yy_.yytext.substr(0, yy_.yyleng - 1), this.begin("emu");
+ if (yy_.yytext) return 14;
+
+ break;
+ case 1:
+ return 14;
+ break;
+ case 2:
+ if (yy_.yytext.slice(-1) !== "\\") this.popState();
+ if (yy_.yytext.slice(-1) === "\\") yy_.yytext = yy_.yytext.substr(0, yy_.yyleng - 1);
+ return 14;
+
+ break;
+ case 3:
+ yy_.yytext = yy_.yytext.substr(0, yy_.yyleng - 4);
+ this.popState();
+ return 15;
+ break;
+ case 4:
+ this.begin("par");
+ return 24;
+ break;
+ case 5:
+ return 16;
+ break;
+ case 6:
+ return 20;
+ break;
+ case 7:
+ return 19;
+ break;
+ case 8:
+ return 19;
+ break;
+ case 9:
+ return 23;
+ break;
+ case 10:
+ return 23;
+ break;
+ case 11:
+ this.popState();
+ this.begin('com');
+ break;
+ case 12:
+ yy_.yytext = yy_.yytext.substr(3, yy_.yyleng - 5);
+ this.popState();
+ return 15;
+ break;
+ case 13:
+ return 22;
+ break;
+ case 14:
+ return 36;
+ break;
+ case 15:
+ return 35;
+ break;
+ case 16:
+ return 35;
+ break;
+ case 17:
+ return 39;
+ break;
+ case 18:
+ /*ignore whitespace*/
+ break;
+ case 19:
+ this.popState();
+ return 18;
+ break;
+ case 20:
+ this.popState();
+ return 18;
+ break;
+ case 21:
+ yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2).replace(/\\"/g, '"');
+ return 30;
+ break;
+ case 22:
+ yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2).replace(/\\'/g, "'");
+ return 30;
+ break;
+ case 23:
+ yy_.yytext = yy_.yytext.substr(1);
+ return 28;
+ break;
+ case 24:
+ return 32;
+ break;
+ case 25:
+ return 32;
+ break;
+ case 26:
+ return 31;
+ break;
+ case 27:
+ return 35;
+ break;
+ case 28:
+ yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2);
+ return 35;
+ break;
+ case 29:
+ return 'INVALID';
+ break;
+ case 30:
+ /*ignore whitespace*/
+ break;
+ case 31:
+ this.popState();
+ return 37;
+ break;
+ case 32:
+ return 5;
+ break;
+ }
+ };
+ lexer.rules = [/^(?:[^\x00]*?(?=(\{\{)))/, /^(?:[^\x00]+)/, /^(?:[^\x00]{2,}?(?=(\{\{|$)))/, /^(?:[\s\S]*?--\}\})/, /^(?:\{\{>)/, /^(?:\{\{#)/, /^(?:\{\{\/)/, /^(?:\{\{\^)/, /^(?:\{\{\s*else\b)/, /^(?:\{\{\{)/, /^(?:\{\{&)/, /^(?:\{\{!--)/, /^(?:\{\{![\s\S]*?\}\})/, /^(?:\{\{)/, /^(?:=)/, /^(?:\.(?=[} ]))/, /^(?:\.\.)/, /^(?:[\/.])/, /^(?:\s+)/, /^(?:\}\}\})/, /^(?:\}\})/, /^(?:"(\\["]|[^"])*")/, /^(?:'(\\[']|[^'])*')/, /^(?:@[a-zA-Z]+)/, /^(?:true(?=[}\s]))/, /^(?:false(?=[}\s]))/, /^(?:-?[0-9]+(?=[}\s]))/, /^(?:[a-zA-Z0-9_$-]+(?=[=}\s\/.]))/, /^(?:\[[^\]]*\])/, /^(?:.)/, /^(?:\s+)/, /^(?:[a-zA-Z0-9_$-/]+)/, /^(?:$)/];
+ lexer.conditions = {
+ "mu": {
+ "rules": [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 32],
+ "inclusive": false
+ },
+ "emu": {
+ "rules": [2],
+ "inclusive": false
+ },
+ "com": {
+ "rules": [3],
+ "inclusive": false
+ },
+ "par": {
+ "rules": [30, 31],
+ "inclusive": false
+ },
+ "INITIAL": {
+ "rules": [0, 1, 32],
+ "inclusive": true
+ }
+ };
+ return lexer;
+ })()
+ parser.lexer = lexer;
+
+ function Parser() {
+ this.yy = {};
+ }
+ Parser.prototype = parser;
+ parser.Parser = Parser;
+ return new Parser;
+ })();;
+ // lib/handlebars/compiler/base.js
+
+ Handlebars.Parser = handlebars;
+
+ Handlebars.parse = function(input) {
+
+ // Just return if an already-compile AST was passed in.
+ if (input.constructor === Handlebars.AST.ProgramNode) {
+ return input;
+ }
+
+ Handlebars.Parser.yy = Handlebars.AST;
+ return Handlebars.Parser.parse(input);
+ };;
+ // lib/handlebars/compiler/ast.js
+ (function() {
+ Handlebars.AST = {};
+
+ Handlebars.AST.ProgramNode = function(statements, inverse) {
+ this.type = "program";
+ this.statements = statements;
+ if (inverse) {
+ this.inverse = new Handlebars.AST.ProgramNode(inverse);
+ }
+ };
+
+ Handlebars.AST.MustacheNode = function(rawParams, hash, unescaped) {
+ this.type = "mustache";
+ this.escaped = !unescaped;
+ this.hash = hash;
+
+ var id = this.id = rawParams[0];
+ var params = this.params = rawParams.slice(1);
+
+ // a mustache is an eligible helper if:
+ // * its id is simple (a single part, not `this` or `..`)
+ var eligibleHelper = this.eligibleHelper = id.isSimple;
+
+ // a mustache is definitely a helper if:
+ // * it is an eligible helper, and
+ // * it has at least one parameter or hash segment
+ this.isHelper = eligibleHelper && (params.length || hash);
+
+ // if a mustache is an eligible helper but not a definite
+ // helper, it is ambiguous, and will be resolved in a later
+ // pass or at runtime.
+ };
+
+ Handlebars.AST.PartialNode = function(partialName, context) {
+ this.type = "partial";
+ this.partialName = partialName;
+ this.context = context;
+ };
+
+ Handlebars.AST.BlockNode = function(mustache, program, inverse, close) {
+ var verifyMatch = function(open, close) {
+ if (open.original !== close.original) {
+ throw new Handlebars.Exception(open.original + " doesn't match " + close.original);
+ }
+ };
+
+ verifyMatch(mustache.id, close);
+ this.type = "block";
+ this.mustache = mustache;
+ this.program = program;
+ this.inverse = inverse;
+
+ if (this.inverse && !this.program) {
+ this.isInverse = true;
+ }
+ };
+
+ Handlebars.AST.ContentNode = function(string) {
+ this.type = "content";
+ this.string = string;
+ };
+
+ Handlebars.AST.HashNode = function(pairs) {
+ this.type = "hash";
+ this.pairs = pairs;
+ };
+
+ Handlebars.AST.IdNode = function(parts) {
+ this.type = "ID";
+ this.original = parts.join(".");
+
+ var dig = [],
+ depth = 0;
+
+ for (var i = 0, l = parts.length; i < l; i++) {
+ var part = parts[i];
+
+ if (part === ".." || part === "." || part === "this") {
+ if (dig.length > 0) {
+ throw new Handlebars.Exception("Invalid path: " + this.original);
+ } else if (part === "..") {
+ depth++;
+ } else {
+ this.isScoped = true;
+ }
+ } else {
+ dig.push(part);
+ }
+ }
+
+ this.parts = dig;
+ this.string = dig.join('.');
+ this.depth = depth;
+
+ // an ID is simple if it only has one part, and that part is not
+ // `..` or `this`.
+ this.isSimple = parts.length === 1 && !this.isScoped && depth === 0;
+
+ this.stringModeValue = this.string;
+ };
+
+ Handlebars.AST.PartialNameNode = function(name) {
+ this.type = "PARTIAL_NAME";
+ this.name = name;
+ };
+
+ Handlebars.AST.DataNode = function(id) {
+ this.type = "DATA";
+ this.id = id;
+ };
+
+ Handlebars.AST.StringNode = function(string) {
+ this.type = "STRING";
+ this.string = string;
+ this.stringModeValue = string;
+ };
+
+ Handlebars.AST.IntegerNode = function(integer) {
+ this.type = "INTEGER";
+ this.integer = integer;
+ this.stringModeValue = Number(integer);
+ };
+
+ Handlebars.AST.BooleanNode = function(bool) {
+ this.type = "BOOLEAN";
+ this.bool = bool;
+ this.stringModeValue = bool === "true";
+ };
+
+ Handlebars.AST.CommentNode = function(comment) {
+ this.type = "comment";
+ this.comment = comment;
+ };;
+ })();;
+ //>>excludeEnd('excludeHbsParser')
+ // 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();
+ };
+
+ (function() {
+ var escape = {
+ "&": "&",
+ "<": "<",
+ ">": ">",
+ '"': """,
+ "'": "'",
+ "`": "`"
+ };
+
+ var badChars = /[&<>"'`]/g;
+ var possible = /[&<>"'`]/;
+
+ var escapeChar = function(chr) {
+ return escape[chr] || "&";
+ };
+
+ 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 (Object.prototype.toString.call(value) === "[object Array]" && value.length === 0) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+ };;
+ })();
+ // lib/handlebars/compiler/compiler.js
+
+ /*jshint eqnull:true*/
+ Handlebars.Compiler = function() {};
+ Handlebars.JavaScriptCompiler = function() {};
+
+ (function(Compiler, JavaScriptCompiler) {
+ // the foundHelper register will disambiguate helper lookup from finding a
+ // function in a context. This is necessary for mustache compatibility, which
+ // requires that context functions in blocks are evaluated by blockHelperMissing,
+ // and then proceed as if the resulting value was provided to blockHelperMissing.
+
+ Compiler.prototype = {
+ compiler: Compiler,
+
+ disassemble: function() {
+ var opcodes = this.opcodes,
+ opcode, out = [],
+ params, param;
+
+ for (var i = 0, l = opcodes.length; i < l; i++) {
+ opcode = opcodes[i];
+
+ if (opcode.opcode === 'DECLARE') {
+ out.push("DECLARE " + opcode.name + "=" + opcode.value);
+ } else {
+ params = [];
+ for (var j = 0; j < opcode.args.length; j++) {
+ param = opcode.args[j];
+ if (typeof param === "string") {
+ param = "\"" + param.replace("\n", "\\n") + "\"";
+ }
+ params.push(param);
+ }
+ out.push(opcode.opcode + " " + params.join(" "));
+ }
+ }
+
+ return out.join("\n");
+ },
+ 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 || opcode.args.length !== otherOpcode.args.length) {
+ return false;
+ }
+ for (var j = 0; j < opcode.args.length; j++) {
+ if (opcode.args[j] !== otherOpcode.args[j]) {
+ return false;
+ }
+ }
+ }
+
+ len = this.children.length;
+ if (other.children.length !== len) {
+ return false;
+ }
+ 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.children = [];
+ this.depths = {
+ list: []
+ };
+ this.options = options;
+
+ // These changes will propagate to the other compiler components
+ var knownHelpers = this.options.knownHelpers;
+ this.options.knownHelpers = {
+ 'helperMissing': true,
+ 'blockHelperMissing': true,
+ 'each': true,
+ 'if': true,
+ 'unless': true,
+ 'with': true,
+ 'log': true
+ };
+ if (knownHelpers) {
+ for (var name in knownHelpers) {
+ this.options.knownHelpers[name] = knownHelpers[name];
+ }
+ }
+
+ return this.program(program);
+ },
+
+ accept: function(node) {
+ return this[node.type](node);
+ },
+
+ program: function(program) {
+ var statements = program.statements,
+ statement;
+ this.opcodes = [];
+
+ for (var i = 0, l = statements.length; i < l; i++) {
+ statement = statements[i];
+ this[statement.type](statement);
+ }
+ 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 type = this.classifyMustache(mustache);
+
+ if (type === "helper") {
+ this.helperMustache(mustache, program, inverse);
+ } else if (type === "simple") {
+ this.simpleMustache(mustache);
+
+ // now that the simple mustache is resolved, we need to
+ // evaluate it by executing `blockHelperMissing`
+ this.opcode('pushProgram', program);
+ this.opcode('pushProgram', inverse);
+ this.opcode('emptyHash');
+ this.opcode('blockValue');
+ } else {
+ this.ambiguousMustache(mustache, program, inverse);
+
+ // now that the simple mustache is resolved, we need to
+ // evaluate it by executing `blockHelperMissing`
+ this.opcode('pushProgram', program);
+ this.opcode('pushProgram', inverse);
+ this.opcode('emptyHash');
+ this.opcode('ambiguousBlockValue');
+ }
+
+ this.opcode('append');
+ },
+
+ hash: function(hash) {
+ var pairs = hash.pairs,
+ pair, val;
+
+ this.opcode('pushHash');
+
+ for (var i = 0, l = pairs.length; i < l; i++) {
+ pair = pairs[i];
+ val = pair[1];
+
+ if (this.options.stringParams) {
+ this.opcode('pushStringParam', val.stringModeValue, val.type);
+ } else {
+ this.accept(val);
+ }
+
+ this.opcode('assignToHash', pair[0]);
+ }
+ this.opcode('popHash');
+ },
+
+ partial: function(partial) {
+ var partialName = partial.partialName;
+ this.usePartial = true;
+
+ if (partial.context) {
+ this.ID(partial.context);
+ } else {
+ this.opcode('push', 'depth0');
+ }
+
+ this.opcode('invokePartial', partialName.name);
+ this.opcode('append');
+ },
+
+ content: function(content) {
+ this.opcode('appendContent', content.string);
+ },
+
+ mustache: function(mustache) {
+ var options = this.options;
+ var type = this.classifyMustache(mustache);
+
+ if (type === "simple") {
+ this.simpleMustache(mustache);
+ } else if (type === "helper") {
+ this.helperMustache(mustache);
+ } else {
+ this.ambiguousMustache(mustache);
+ }
+
+ if (mustache.escaped && !options.noEscape) {
+ this.opcode('appendEscaped');
+ } else {
+ this.opcode('append');
+ }
+ },
+
+ ambiguousMustache: function(mustache, program, inverse) {
+ var id = mustache.id,
+ name = id.parts[0],
+ isBlock = program != null || inverse != null;
+
+ this.opcode('getContext', id.depth);
+
+ this.opcode('pushProgram', program);
+ this.opcode('pushProgram', inverse);
+
+ this.opcode('invokeAmbiguous', name, isBlock);
+ },
+
+ simpleMustache: function(mustache) {
+ var id = mustache.id;
+
+ if (id.type === 'DATA') {
+ this.DATA(id);
+ } else if (id.parts.length) {
+ this.ID(id);
+ } else {
+ // Simplified ID for `this`
+ this.addDepth(id.depth);
+ this.opcode('getContext', id.depth);
+ this.opcode('pushContext');
+ }
+
+ this.opcode('resolvePossibleLambda');
+ },
+
+ helperMustache: function(mustache, program, inverse) {
+ var params = this.setupFullMustacheParams(mustache, program, inverse),
+ name = mustache.id.parts[0];
+
+ if (this.options.knownHelpers[name]) {
+ this.opcode('invokeKnownHelper', params.length, name);
+ } else if (this.knownHelpersOnly) {
+ throw new Error("You specified knownHelpersOnly, but used the unknown helper " + name);
+ } else {
+ this.opcode('invokeHelper', params.length, name);
+ }
+ },
+
+ 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[0]);
+ }
+
+ for (var i = 1, l = id.parts.length; i < l; i++) {
+ this.opcode('lookup', id.parts[i]);
+ }
+ },
+
+ DATA: function(data) {
+ this.options.data = true;
+ this.opcode('lookupData', data.id);
+ },
+
+ STRING: function(string) {
+ this.opcode('pushString', string.string);
+ },
+
+ INTEGER: function(integer) {
+ this.opcode('pushLiteral', integer.integer);
+ },
+
+ BOOLEAN: function(bool) {
+ this.opcode('pushLiteral', bool.bool);
+ },
+
+ comment: function() {},
+
+ // HELPERS
+ opcode: function(name) {
+ this.opcodes.push({
+ opcode: name,
+ args: [].slice.call(arguments, 1)
+ });
+ },
+
+ declare: function(name, value) {
+ this.opcodes.push({
+ opcode: 'DECLARE',
+ name: name,
+ value: value
+ });
+ },
+
+ addDepth: function(depth) {
+ if (isNaN(depth)) {
+ throw new Error("EWOT");
+ }
+ if (depth === 0) {
+ return;
+ }
+
+ if (!this.depths[depth]) {
+ this.depths[depth] = true;
+ this.depths.list.push(depth);
+ }
+ },
+
+ classifyMustache: function(mustache) {
+ var isHelper = mustache.isHelper;
+ var isEligible = mustache.eligibleHelper;
+ var options = this.options;
+
+ // if ambiguous, we can possibly resolve the ambiguity now
+ if (isEligible && !isHelper) {
+ var name = mustache.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) {
+ var i = params.length,
+ param;
+
+ while (i--) {
+ param = params[i];
+
+ if (this.options.stringParams) {
+ if (param.depth) {
+ this.addDepth(param.depth);
+ }
+
+ this.opcode('getContext', param.depth || 0);
+ this.opcode('pushStringParam', param.stringModeValue, param.type);
+ } else {
+ this[param.type](param);
+ }
+ }
+ },
+
+ setupMustacheParams: function(mustache) {
+ var params = mustache.params;
+ this.pushParams(params);
+
+ if (mustache.hash) {
+ this.hash(mustache.hash);
+ } else {
+ this.opcode('emptyHash');
+ }
+
+ return params;
+ },
+
+ // this will replace setupMustacheParams when we're done
+ setupFullMustacheParams: function(mustache, program, inverse) {
+ var params = mustache.params;
+ this.pushParams(params);
+
+ this.opcode('pushProgram', program);
+ this.opcode('pushProgram', inverse);
+
+ if (mustache.hash) {
+ this.hash(mustache.hash);
+ } else {
+ this.opcode('emptyHash');
+ }
+
+ return params;
+ }
+ };
+
+ var Literal = function(value) {
+ this.value = value;
+ };
+
+ JavaScriptCompiler.prototype = {
+ // PUBLIC API: You can override these methods in a subclass to provide
+ // alternative compiled forms for name lookup and buffering semantics
+ nameLookup: function(parent, name /* , type*/ ) {
+ if (/^[0-9]+$/.test(name)) {
+ return parent + "[" + name + "]";
+ } else if (JavaScriptCompiler.isValidJavaScriptVariableName(name)) {
+ return parent + "." + name;
+ } else {
+ return parent + "['" + name + "']";
+ }
+ },
+
+ 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",
+ // END PUBLIC API
+
+ compile: function(environment, options, context, asObject) {
+ this.environment = environment;
+ this.options = options || {};
+
+ Handlebars.log(Handlebars.logger.DEBUG, this.environment.disassemble() + "\n\n");
+
+ this.name = this.environment.name;
+ this.isChild = !!context;
+ this.context = context || {
+ programs: [],
+ environments: [],
+ aliases: {}
+ };
+
+ this.preamble();
+
+ this.stackSlot = 0;
+ this.stackVars = [];
+ this.registers = {
+ list: []
+ };
+ this.compileStack = [];
+ this.inlineStack = [];
+
+ this.compileChildren(environment, options);
+
+ var opcodes = environment.opcodes,
+ opcode;
+
+ this.i = 0;
+
+ for (l = opcodes.length; this.i < l; this.i++) {
+ opcode = opcodes[this.i];
+
+ if (opcode.opcode === 'DECLARE') {
+ this[opcode.name] = opcode.value;
+ } else {
+ this[opcode.opcode].apply(this, opcode.args);
+ }
+ }
+
+ return this.createFunctionContext(asObject);
+ },
+
+ nextOpcode: function() {
+ var opcodes = this.environment.opcodes;
+ return opcodes[this.i + 1];
+ },
+
+ eat: function() {
+ this.i = this.i + 1;
+ },
+
+ preamble: function() {
+ var out = [];
+
+ if (!this.isChild) {
+ var namespace = this.namespace;
+ var copies = "helpers = helpers || " + namespace + ".helpers;";
+ if (this.environment.usePartial) {
+ copies = copies + " partials = partials || " + namespace + ".partials;";
+ }
+ if (this.options.data) {
+ copies = copies + " data = data || {};";
+ }
+ out.push(copies);
+ } else {
+ out.push('');
+ }
+
+ if (!this.environment.isSimple) {
+ out.push(", buffer = " + this.initializeBuffer());
+ } else {
+ out.push("");
+ }
+
+ // track the last context pushed into place to allow skipping the
+ // getContext opcode when it would be a noop
+ this.lastContext = 0;
+ this.source = out;
+ },
+
+ createFunctionContext: function(asObject) {
+ var locals = this.stackVars.concat(this.registers.list);
+
+ if (locals.length > 0) {
+ this.source[1] = this.source[1] + ", " + locals.join(", ");
+ }
+
+ // Generate minimizer alias mappings
+ if (!this.isChild) {
+ for (var alias in this.context.aliases) {
+ this.source[1] = this.source[1] + ', ' + alias + '=' + this.context.aliases[alias];
+ }
+ }
+
+ if (this.source[1]) {
+ this.source[1] = "var " + this.source[1].substring(2) + ";";
+ }
+
+ // Merge children
+ if (!this.isChild) {
+ this.source[1] += '\n' + this.context.programs.join('\n') + '\n';
+ }
+
+ if (!this.environment.isSimple) {
+ this.source.push("return buffer;");
+ }
+
+ var params = this.isChild ? ["depth0", "data"] : ["Handlebars", "depth0", "helpers", "partials", "data"];
+
+ for (var i = 0, l = this.environment.depths.list.length; i < l; i++) {
+ params.push("depth" + this.environment.depths.list[i]);
+ }
+
+ // Perform a second pass over the output to merge content when possible
+ var source = this.mergeSource();
+
+ if (!this.isChild) {
+ var revision = Handlebars.COMPILER_REVISION,
+ versions = Handlebars.REVISION_CHANGES[revision];
+ source = "this.compilerInfo = [" + revision + ",'" + versions + "'];\n" + source;
+ }
+
+ if (asObject) {
+ params.push(source);
+
+ return Function.apply(this, params);
+ } else {
+ var functionSource = 'function ' + (this.name || '') + '(' + params.join(',') + ') {\n ' + source + '}';
+ Handlebars.log(Handlebars.logger.DEBUG, functionSource + "\n\n");
+ return functionSource;
+ }
+ },
+ mergeSource: function() {
+ // WARN: We are not handling the case where buffer is still populated as the source should
+ // not have buffer append operations as their final action.
+ var source = '',
+ buffer;
+ 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) {
+ source += 'buffer += ' + buffer + ';\n ';
+ buffer = undefined;
+ }
+ source += line + '\n ';
+ }
+ }
+ return source;
+ },
+
+ // [blockValue]
+ //
+ // On stack, before: hash, inverse, program, value
+ // On stack, after: return value of blockHelperMissing
+ //
+ // The purpose of this opcode is to take a block of the form
+ // `{{#foo}}...{{/foo}}`, resolve the value of `foo`, and
+ // replace it on the stack with the result of properly
+ // invoking blockHelperMissing.
+ blockValue: function() {
+ this.context.aliases.blockHelperMissing = 'helpers.blockHelperMissing';
+
+ var params = ["depth0"];
+ this.setupParams(0, params);
+
+ this.replaceStack(function(current) {
+ params.splice(1, 0, current);
+ return "blockHelperMissing.call(" + params.join(", ") + ")";
+ });
+ },
+
+ // [ambiguousBlockValue]
+ //
+ // On stack, before: hash, inverse, program, value
+ // Compiler value, before: lastHelper=value of last found helper, if any
+ // On stack, after, if no lastHelper: same as [blockValue]
+ // On stack, after, if lastHelper: value
+ ambiguousBlockValue: function() {
+ this.context.aliases.blockHelperMissing = 'helpers.blockHelperMissing';
+
+ var params = ["depth0"];
+ this.setupParams(0, params);
+
+ var current = this.topStack();
+ params.splice(1, 0, current);
+
+ // Use the options value generated from the invocation
+ params[params.length - 1] = 'options';
+
+ this.source.push("if (!" + this.lastHelper + ") { " + current + " = blockHelperMissing.call(" + params.join(", ") + "); }");
+ },
+
+ // [appendContent]
+ //
+ // On stack, before: ...
+ // On stack, after: ...
+ //
+ // Appends the string value of `content` to the current buffer
+ appendContent: function(content) {
+ this.source.push(this.appendToBuffer(this.quotedString(content)));
+ },
+
+ // [append]
+ //
+ // On stack, before: value, ...
+ // On stack, after: ...
+ //
+ // Coerces `value` to a String and appends it to the current buffer.
+ //
+ // If `value` is truthy, or 0, it is coerced into a string and appended
+ // Otherwise, the empty string is appended
+ append: function() {
+ // Force anything that is inlined onto the stack so we don't have duplication
+ // when we examine local
+ this.flushInline();
+ var local = this.popStack();
+ this.source.push("if(" + local + " || " + local + " === 0) { " + this.appendToBuffer(local) + " }");
+ if (this.environment.isSimple) {
+ this.source.push("else { " + this.appendToBuffer("''") + " }");
+ }
+ },
+
+ // [appendEscaped]
+ //
+ // On stack, before: value, ...
+ // On stack, after: ...
+ //
+ // Escape `value` and append it to the buffer
+ appendEscaped: function() {
+ this.context.aliases.escapeExpression = 'this.escapeExpression';
+
+ this.source.push(this.appendToBuffer("escapeExpression(" + this.popStack() + ")"));
+ },
+
+ // [getContext]
+ //
+ // On stack, before: ...
+ // On stack, after: ...
+ // Compiler value, after: lastContext=depth
+ //
+ // Set the value of the `lastContext` compiler value to the depth
+ getContext: function(depth) {
+ if (this.lastContext !== depth) {
+ this.lastContext = depth;
+ }
+ },
+
+ // [lookupOnContext]
+ //
+ // On stack, before: ...
+ // On stack, after: currentContext[name], ...
+ //
+ // Looks up the value of `name` on the current context and pushes
+ // it onto the stack.
+ lookupOnContext: function(name) {
+ this.push(this.nameLookup('depth' + this.lastContext, name, 'context'));
+ },
+
+ // [pushContext]
+ //
+ // On stack, before: ...
+ // On stack, after: currentContext, ...
+ //
+ // Pushes the value of the current context onto the stack.
+ pushContext: function() {
+ this.pushStackLiteral('depth' + this.lastContext);
+ },
+
+ // [resolvePossibleLambda]
+ //
+ // On stack, before: value, ...
+ // On stack, after: resolved value, ...
+ //
+ // If the `value` is a lambda, replace it on the stack by
+ // the return value of the lambda
+ resolvePossibleLambda: function() {
+ this.context.aliases.functionType = '"function"';
+
+ this.replaceStack(function(current) {
+ return "typeof " + current + " === functionType ? " + current + ".apply(depth0) : " + current;
+ });
+ },
+
+ // [lookup]
+ //
+ // On stack, before: value, ...
+ // On stack, after: value[name], ...
+ //
+ // Replace the value on the stack with the result of looking
+ // up `name` on `value`
+ lookup: function(name) {
+ this.replaceStack(function(current) {
+ return current + " == null || " + current + " === false ? " + current + " : " + this.nameLookup(current, name, 'context');
+ });
+ },
+
+ // [lookupData]
+ //
+ // On stack, before: ...
+ // On stack, after: data[id], ...
+ //
+ // Push the result of looking up `id` on the current data
+ lookupData: function(id) {
+ this.push(this.nameLookup('data', id, 'data'));
+ },
+
+ // [pushStringParam]
+ //
+ // On stack, before: ...
+ // On stack, after: string, currentContext, ...
+ //
+ // This opcode is designed for use in string mode, which
+ // provides the string value of a parameter along with its
+ // depth rather than resolving it immediately.
+ pushStringParam: function(string, type) {
+ this.pushStackLiteral('depth' + this.lastContext);
+
+ this.pushString(type);
+
+ if (typeof string === 'string') {
+ this.pushString(string);
+ } else {
+ this.pushStackLiteral(string);
+ }
+ },
+
+ emptyHash: function() {
+ this.pushStackLiteral('{}');
+
<TRUNCATED>