Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
handlebars
Advanced tools
handlebars - npm Package Compare versions
Comparing version 1.0.9 to 1.0.10
@@ -25,7 +25,8 @@ /* | ||
| // lib/handlebars/base.js | ||
| // lib/handlebars/browser-prefix.js | ||
| var Handlebars = {}; | ||
| (function(Handlebars) { | ||
| (function(Handlebars, undefined) { | ||
| ; | ||
| // lib/handlebars/base.js | ||
@@ -155,7 +156,3 @@ Handlebars.VERSION = "1.0.0-rc.3"; | ||
| Handlebars.registerHelper('unless', function(context, options) { | ||
| var fn = options.fn, inverse = options.inverse; | ||
| options.fn = inverse; | ||
| options.inverse = fn; | ||
| return Handlebars.helpers['if'].call(this, context, options); | ||
| return Handlebars.helpers['if'].call(this, context, {fn: options.inverse, inverse: options.fn}); | ||
| }); | ||
@@ -171,4 +168,2 @@ | ||
| }); | ||
| }(Handlebars)); | ||
| ; | ||
@@ -197,43 +192,41 @@ // lib/handlebars/utils.js | ||
| (function() { | ||
| var escape = { | ||
| "&": "&", | ||
| "<": "<", | ||
| ">": ">", | ||
| '"': """, | ||
| "'": "'", | ||
| "`": "`" | ||
| }; | ||
| var escape = { | ||
| "&": "&", | ||
| "<": "<", | ||
| ">": ">", | ||
| '"': """, | ||
| "'": "'", | ||
| "`": "`" | ||
| }; | ||
| var badChars = /[&<>"'`]/g; | ||
| var possible = /[&<>"'`]/; | ||
| var badChars = /[&<>"'`]/g; | ||
| var possible = /[&<>"'`]/; | ||
| var escapeChar = function(chr) { | ||
| return escape[chr] || "&"; | ||
| }; | ||
| 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 ""; | ||
| } | ||
| 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); | ||
| }, | ||
| 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; | ||
| } | ||
| isEmpty: function(value) { | ||
| if (!value && value !== 0) { | ||
| return true; | ||
| } else if(toString.call(value) === "[object Array]" && value.length === 0) { | ||
| return true; | ||
| } else { | ||
| return false; | ||
| } | ||
| }; | ||
| })(); | ||
| } | ||
| }; | ||
| ; | ||
@@ -325,1 +318,4 @@ // lib/handlebars/runtime.js | ||
| ; | ||
| // lib/handlebars/browser-suffix.js | ||
| })(Handlebars); | ||
| ; |
@@ -5,7 +5,5 @@ /*jshint eqnull: true */ | ||
| // BEGIN(BROWSER) | ||
| var Handlebars = {}; | ||
| (function(Handlebars) { | ||
| // BEGIN(BROWSER) | ||
@@ -135,7 +133,3 @@ Handlebars.VERSION = "1.0.0-rc.3"; | ||
| Handlebars.registerHelper('unless', function(context, options) { | ||
| var fn = options.fn, inverse = options.inverse; | ||
| options.fn = inverse; | ||
| options.inverse = fn; | ||
| return Handlebars.helpers['if'].call(this, context, options); | ||
| return Handlebars.helpers['if'].call(this, context, {fn: options.inverse, inverse: options.fn}); | ||
| }); | ||
@@ -152,4 +146,2 @@ | ||
| }(Handlebars)); | ||
| // END(BROWSER) | ||
@@ -156,0 +148,0 @@ |
| exports.attach = function(Handlebars) { | ||
| // BEGIN(BROWSER) | ||
| (function() { | ||
| Handlebars.AST = {}; | ||
| 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.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; | ||
| 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); | ||
| 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 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); | ||
| // 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. | ||
| }; | ||
| // 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.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); | ||
| } | ||
| }; | ||
| 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; | ||
| verifyMatch(mustache.id, close); | ||
| this.type = "block"; | ||
| this.mustache = mustache; | ||
| this.program = program; | ||
| this.inverse = inverse; | ||
| if (this.inverse && !this.program) { | ||
| this.isInverse = true; | ||
| } | ||
| }; | ||
| if (this.inverse && !this.program) { | ||
| this.isInverse = true; | ||
| } | ||
| }; | ||
| Handlebars.AST.ContentNode = function(string) { | ||
| this.type = "content"; | ||
| this.string = string; | ||
| }; | ||
| Handlebars.AST.ContentNode = function(string) { | ||
| this.type = "content"; | ||
| this.string = string; | ||
| }; | ||
| Handlebars.AST.HashNode = function(pairs) { | ||
| this.type = "hash"; | ||
| this.pairs = pairs; | ||
| }; | ||
| Handlebars.AST.HashNode = function(pairs) { | ||
| this.type = "hash"; | ||
| this.pairs = pairs; | ||
| }; | ||
| Handlebars.AST.IdNode = function(parts) { | ||
| this.type = "ID"; | ||
| this.original = parts.join("."); | ||
| Handlebars.AST.IdNode = function(parts) { | ||
| this.type = "ID"; | ||
| this.original = parts.join("."); | ||
| var dig = [], depth = 0; | ||
| var dig = [], depth = 0; | ||
| for(var i=0,l=parts.length; i<l; i++) { | ||
| var part = parts[i]; | ||
| 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); } | ||
| 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; | ||
| 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; | ||
| // 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; | ||
| }; | ||
| this.stringModeValue = this.string; | ||
| }; | ||
| Handlebars.AST.PartialNameNode = function(name) { | ||
| this.type = "PARTIAL_NAME"; | ||
| this.name = name; | ||
| }; | ||
| 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.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.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.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.BooleanNode = function(bool) { | ||
| this.type = "BOOLEAN"; | ||
| this.bool = bool; | ||
| this.stringModeValue = bool === "true"; | ||
| }; | ||
| Handlebars.AST.CommentNode = function(comment) { | ||
| this.type = "comment"; | ||
| this.comment = comment; | ||
| }; | ||
| Handlebars.AST.CommentNode = function(comment) { | ||
| this.type = "comment"; | ||
| this.comment = comment; | ||
| }; | ||
| })(); | ||
| // END(BROWSER) | ||
@@ -133,0 +130,0 @@ |
@@ -18,5 +18,2 @@ var handlebars = require("./parser"); | ||
| Handlebars.print = function(ast) { | ||
| return new Handlebars.PrintVisitor().accept(ast); | ||
| }; | ||
| // END(BROWSER) | ||
@@ -23,0 +20,0 @@ |
@@ -10,1225 +10,1233 @@ var compilerbase = require("./base"); | ||
| /*jshint eqnull:true*/ | ||
| Handlebars.Compiler = function() {}; | ||
| Handlebars.JavaScriptCompiler = function() {}; | ||
| var Compiler = Handlebars.Compiler = function() {}; | ||
| var JavaScriptCompiler = 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. | ||
| // 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, | ||
| Compiler.prototype = { | ||
| compiler: Compiler, | ||
| disassemble: function() { | ||
| var opcodes = this.opcodes, opcode, out = [], params, param; | ||
| disassemble: function() { | ||
| var opcodes = this.opcodes, opcode, out = [], params, param; | ||
| for (var i=0, l=opcodes.length; i<l; i++) { | ||
| opcode = opcodes[i]; | ||
| 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); | ||
| 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") + "\""; | ||
| } | ||
| out.push(opcode.opcode + " " + params.join(" ")); | ||
| 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 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 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) { | ||
| for (var j = 0; j < opcode.args.length; j++) { | ||
| if (opcode.args[j] !== otherOpcode.args[j]) { | ||
| return false; | ||
| } | ||
| for (var j = 0; j < opcode.args.length; j++) { | ||
| if (opcode.args[j] !== otherOpcode.args[j]) { | ||
| 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]; | ||
| } | ||
| 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 this.program(program); | ||
| }, | ||
| return true; | ||
| }, | ||
| accept: function(node) { | ||
| return this[node.type](node); | ||
| }, | ||
| guid: 0, | ||
| program: function(program) { | ||
| var statements = program.statements, statement; | ||
| this.opcodes = []; | ||
| compile: function(program, options) { | ||
| this.children = []; | ||
| this.depths = {list: []}; | ||
| this.options = options; | ||
| for(var i=0, l=statements.length; i<l; i++) { | ||
| statement = statements[i]; | ||
| this[statement.type](statement); | ||
| // 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]; | ||
| } | ||
| this.isSimple = l === 1; | ||
| } | ||
| this.depths.list = this.depths.list.sort(function(a, b) { | ||
| return a - b; | ||
| }); | ||
| return this.program(program); | ||
| }, | ||
| return this; | ||
| }, | ||
| accept: function(node) { | ||
| return this[node.type](node); | ||
| }, | ||
| compileProgram: function(program) { | ||
| var result = new this.compiler().compile(program, this.options); | ||
| var guid = this.guid++, depth; | ||
| program: function(program) { | ||
| var statements = program.statements, statement; | ||
| this.opcodes = []; | ||
| this.usePartial = this.usePartial || result.usePartial; | ||
| for(var i=0, l=statements.length; i<l; i++) { | ||
| statement = statements[i]; | ||
| this[statement.type](statement); | ||
| } | ||
| this.isSimple = l === 1; | ||
| this.children[guid] = result; | ||
| this.depths.list = this.depths.list.sort(function(a, b) { | ||
| return a - b; | ||
| }); | ||
| for(var i=0, l=result.depths.list.length; i<l; i++) { | ||
| depth = result.depths.list[i]; | ||
| return this; | ||
| }, | ||
| if(depth < 2) { continue; } | ||
| else { this.addDepth(depth - 1); } | ||
| } | ||
| compileProgram: function(program) { | ||
| var result = new this.compiler().compile(program, this.options); | ||
| var guid = this.guid++, depth; | ||
| return guid; | ||
| }, | ||
| this.usePartial = this.usePartial || result.usePartial; | ||
| block: function(block) { | ||
| var mustache = block.mustache, | ||
| program = block.program, | ||
| inverse = block.inverse; | ||
| this.children[guid] = result; | ||
| if (program) { | ||
| program = this.compileProgram(program); | ||
| } | ||
| for(var i=0, l=result.depths.list.length; i<l; i++) { | ||
| depth = result.depths.list[i]; | ||
| if (inverse) { | ||
| inverse = this.compileProgram(inverse); | ||
| } | ||
| if(depth < 2) { continue; } | ||
| else { this.addDepth(depth - 1); } | ||
| } | ||
| var type = this.classifyMustache(mustache); | ||
| return guid; | ||
| }, | ||
| if (type === "helper") { | ||
| this.helperMustache(mustache, program, inverse); | ||
| } else if (type === "simple") { | ||
| this.simpleMustache(mustache); | ||
| block: function(block) { | ||
| var mustache = block.mustache, | ||
| program = block.program, | ||
| inverse = block.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('blockValue'); | ||
| } else { | ||
| this.ambiguousMustache(mustache, program, inverse); | ||
| if (program) { | ||
| program = this.compileProgram(program); | ||
| } | ||
| // 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'); | ||
| } | ||
| if (inverse) { | ||
| inverse = this.compileProgram(inverse); | ||
| } | ||
| this.opcode('append'); | ||
| }, | ||
| var type = this.classifyMustache(mustache); | ||
| hash: function(hash) { | ||
| var pairs = hash.pairs, pair, val; | ||
| if (type === "helper") { | ||
| this.helperMustache(mustache, program, inverse); | ||
| } else if (type === "simple") { | ||
| this.simpleMustache(mustache); | ||
| this.opcode('pushHash'); | ||
| // 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); | ||
| for(var i=0, l=pairs.length; i<l; i++) { | ||
| pair = pairs[i]; | ||
| val = pair[1]; | ||
| // 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'); | ||
| } | ||
| if (this.options.stringParams) { | ||
| this.opcode('pushStringParam', val.stringModeValue, val.type); | ||
| } else { | ||
| this.accept(val); | ||
| } | ||
| this.opcode('append'); | ||
| }, | ||
| this.opcode('assignToHash', pair[0]); | ||
| } | ||
| this.opcode('popHash'); | ||
| }, | ||
| hash: function(hash) { | ||
| var pairs = hash.pairs, pair, val; | ||
| partial: function(partial) { | ||
| var partialName = partial.partialName; | ||
| this.usePartial = true; | ||
| this.opcode('pushHash'); | ||
| if(partial.context) { | ||
| this.ID(partial.context); | ||
| 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.opcode('push', 'depth0'); | ||
| this.accept(val); | ||
| } | ||
| this.opcode('invokePartial', partialName.name); | ||
| this.opcode('append'); | ||
| }, | ||
| this.opcode('assignToHash', pair[0]); | ||
| } | ||
| this.opcode('popHash'); | ||
| }, | ||
| content: function(content) { | ||
| this.opcode('appendContent', content.string); | ||
| }, | ||
| partial: function(partial) { | ||
| var partialName = partial.partialName; | ||
| this.usePartial = true; | ||
| mustache: function(mustache) { | ||
| var options = this.options; | ||
| var type = this.classifyMustache(mustache); | ||
| if(partial.context) { | ||
| this.ID(partial.context); | ||
| } else { | ||
| this.opcode('push', 'depth0'); | ||
| } | ||
| if (type === "simple") { | ||
| this.simpleMustache(mustache); | ||
| } else if (type === "helper") { | ||
| this.helperMustache(mustache); | ||
| } else { | ||
| this.ambiguousMustache(mustache); | ||
| } | ||
| this.opcode('invokePartial', partialName.name); | ||
| this.opcode('append'); | ||
| }, | ||
| if(mustache.escaped && !options.noEscape) { | ||
| this.opcode('appendEscaped'); | ||
| } else { | ||
| this.opcode('append'); | ||
| } | ||
| }, | ||
| content: function(content) { | ||
| this.opcode('appendContent', content.string); | ||
| }, | ||
| ambiguousMustache: function(mustache, program, inverse) { | ||
| var id = mustache.id, | ||
| name = id.parts[0], | ||
| isBlock = program != null || inverse != null; | ||
| mustache: function(mustache) { | ||
| var options = this.options; | ||
| var type = this.classifyMustache(mustache); | ||
| this.opcode('getContext', id.depth); | ||
| if (type === "simple") { | ||
| this.simpleMustache(mustache); | ||
| } else if (type === "helper") { | ||
| this.helperMustache(mustache); | ||
| } else { | ||
| this.ambiguousMustache(mustache); | ||
| } | ||
| this.opcode('pushProgram', program); | ||
| this.opcode('pushProgram', inverse); | ||
| if(mustache.escaped && !options.noEscape) { | ||
| this.opcode('appendEscaped'); | ||
| } else { | ||
| this.opcode('append'); | ||
| } | ||
| }, | ||
| this.opcode('invokeAmbiguous', name, isBlock); | ||
| }, | ||
| ambiguousMustache: function(mustache, program, inverse) { | ||
| var id = mustache.id, | ||
| name = id.parts[0], | ||
| isBlock = program != null || inverse != null; | ||
| simpleMustache: function(mustache) { | ||
| var id = mustache.id; | ||
| this.opcode('getContext', id.depth); | ||
| 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('pushProgram', program); | ||
| this.opcode('pushProgram', inverse); | ||
| this.opcode('resolvePossibleLambda'); | ||
| }, | ||
| this.opcode('invokeAmbiguous', name, isBlock); | ||
| }, | ||
| helperMustache: function(mustache, program, inverse) { | ||
| var params = this.setupFullMustacheParams(mustache, program, inverse), | ||
| name = mustache.id.parts[0]; | ||
| simpleMustache: function(mustache) { | ||
| var id = mustache.id; | ||
| 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) { | ||
| 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'); | ||
| } | ||
| var name = id.parts[0]; | ||
| if (!name) { | ||
| this.opcode('pushContext'); | ||
| } else { | ||
| this.opcode('lookupOnContext', id.parts[0]); | ||
| } | ||
| this.opcode('resolvePossibleLambda'); | ||
| }, | ||
| for(var i=1, l=id.parts.length; i<l; i++) { | ||
| this.opcode('lookup', id.parts[i]); | ||
| } | ||
| }, | ||
| helperMustache: function(mustache, program, inverse) { | ||
| var params = this.setupFullMustacheParams(mustache, program, inverse), | ||
| name = mustache.id.parts[0]; | ||
| DATA: function(data) { | ||
| this.options.data = true; | ||
| this.opcode('lookupData', data.id); | ||
| }, | ||
| 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); | ||
| } | ||
| }, | ||
| STRING: function(string) { | ||
| this.opcode('pushString', string.string); | ||
| }, | ||
| ID: function(id) { | ||
| this.addDepth(id.depth); | ||
| this.opcode('getContext', id.depth); | ||
| INTEGER: function(integer) { | ||
| this.opcode('pushLiteral', integer.integer); | ||
| }, | ||
| var name = id.parts[0]; | ||
| if (!name) { | ||
| this.opcode('pushContext'); | ||
| } else { | ||
| this.opcode('lookupOnContext', id.parts[0]); | ||
| } | ||
| BOOLEAN: function(bool) { | ||
| this.opcode('pushLiteral', bool.bool); | ||
| }, | ||
| for(var i=1, l=id.parts.length; i<l; i++) { | ||
| this.opcode('lookup', id.parts[i]); | ||
| } | ||
| }, | ||
| comment: function() {}, | ||
| DATA: function(data) { | ||
| this.options.data = true; | ||
| this.opcode('lookupData', data.id); | ||
| }, | ||
| // HELPERS | ||
| opcode: function(name) { | ||
| this.opcodes.push({ opcode: name, args: [].slice.call(arguments, 1) }); | ||
| }, | ||
| STRING: function(string) { | ||
| this.opcode('pushString', string.string); | ||
| }, | ||
| declare: function(name, value) { | ||
| this.opcodes.push({ opcode: 'DECLARE', name: name, value: value }); | ||
| }, | ||
| INTEGER: function(integer) { | ||
| this.opcode('pushLiteral', integer.integer); | ||
| }, | ||
| addDepth: function(depth) { | ||
| if(isNaN(depth)) { throw new Error("EWOT"); } | ||
| if(depth === 0) { return; } | ||
| BOOLEAN: function(bool) { | ||
| this.opcode('pushLiteral', bool.bool); | ||
| }, | ||
| if(!this.depths[depth]) { | ||
| this.depths[depth] = true; | ||
| this.depths.list.push(depth); | ||
| } | ||
| }, | ||
| comment: function() {}, | ||
| classifyMustache: function(mustache) { | ||
| var isHelper = mustache.isHelper; | ||
| var isEligible = mustache.eligibleHelper; | ||
| var options = this.options; | ||
| // HELPERS | ||
| opcode: function(name) { | ||
| this.opcodes.push({ opcode: name, args: [].slice.call(arguments, 1) }); | ||
| }, | ||
| // if ambiguous, we can possibly resolve the ambiguity now | ||
| if (isEligible && !isHelper) { | ||
| var name = mustache.id.parts[0]; | ||
| declare: function(name, value) { | ||
| this.opcodes.push({ opcode: 'DECLARE', name: name, value: value }); | ||
| }, | ||
| if (options.knownHelpers[name]) { | ||
| isHelper = true; | ||
| } else if (options.knownHelpersOnly) { | ||
| isEligible = false; | ||
| } | ||
| } | ||
| addDepth: function(depth) { | ||
| if(isNaN(depth)) { throw new Error("EWOT"); } | ||
| if(depth === 0) { return; } | ||
| if (isHelper) { return "helper"; } | ||
| else if (isEligible) { return "ambiguous"; } | ||
| else { return "simple"; } | ||
| }, | ||
| if(!this.depths[depth]) { | ||
| this.depths[depth] = true; | ||
| this.depths.list.push(depth); | ||
| } | ||
| }, | ||
| pushParams: function(params) { | ||
| var i = params.length, param; | ||
| classifyMustache: function(mustache) { | ||
| var isHelper = mustache.isHelper; | ||
| var isEligible = mustache.eligibleHelper; | ||
| var options = this.options; | ||
| while(i--) { | ||
| param = params[i]; | ||
| // if ambiguous, we can possibly resolve the ambiguity now | ||
| if (isEligible && !isHelper) { | ||
| var name = mustache.id.parts[0]; | ||
| 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); | ||
| } | ||
| if (options.knownHelpers[name]) { | ||
| isHelper = true; | ||
| } else if (options.knownHelpersOnly) { | ||
| isEligible = false; | ||
| } | ||
| }, | ||
| } | ||
| setupMustacheParams: function(mustache) { | ||
| var params = mustache.params; | ||
| this.pushParams(params); | ||
| if (isHelper) { return "helper"; } | ||
| else if (isEligible) { return "ambiguous"; } | ||
| else { return "simple"; } | ||
| }, | ||
| if(mustache.hash) { | ||
| this.hash(mustache.hash); | ||
| } else { | ||
| this.opcode('emptyHash'); | ||
| } | ||
| pushParams: function(params) { | ||
| var i = params.length, param; | ||
| return params; | ||
| }, | ||
| while(i--) { | ||
| param = params[i]; | ||
| // this will replace setupMustacheParams when we're done | ||
| setupFullMustacheParams: function(mustache, program, inverse) { | ||
| var params = mustache.params; | ||
| this.pushParams(params); | ||
| if(this.options.stringParams) { | ||
| if(param.depth) { | ||
| this.addDepth(param.depth); | ||
| } | ||
| this.opcode('pushProgram', program); | ||
| this.opcode('pushProgram', inverse); | ||
| if(mustache.hash) { | ||
| this.hash(mustache.hash); | ||
| this.opcode('getContext', param.depth || 0); | ||
| this.opcode('pushStringParam', param.stringModeValue, param.type); | ||
| } else { | ||
| this.opcode('emptyHash'); | ||
| this[param.type](param); | ||
| } | ||
| } | ||
| }, | ||
| return params; | ||
| setupMustacheParams: function(mustache) { | ||
| var params = mustache.params; | ||
| this.pushParams(params); | ||
| if(mustache.hash) { | ||
| this.hash(mustache.hash); | ||
| } else { | ||
| this.opcode('emptyHash'); | ||
| } | ||
| }; | ||
| var Literal = function(value) { | ||
| this.value = value; | ||
| }; | ||
| return params; | ||
| }, | ||
| 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 + "']"; | ||
| } | ||
| }, | ||
| // this will replace setupMustacheParams when we're done | ||
| setupFullMustacheParams: function(mustache, program, inverse) { | ||
| var params = mustache.params; | ||
| this.pushParams(params); | ||
| appendToBuffer: function(string) { | ||
| if (this.environment.isSimple) { | ||
| return "return " + string + ";"; | ||
| } else { | ||
| return { | ||
| appendToBuffer: true, | ||
| content: string, | ||
| toString: function() { return "buffer += " + string + ";"; } | ||
| }; | ||
| } | ||
| }, | ||
| this.opcode('pushProgram', program); | ||
| this.opcode('pushProgram', inverse); | ||
| initializeBuffer: function() { | ||
| return this.quotedString(""); | ||
| }, | ||
| if(mustache.hash) { | ||
| this.hash(mustache.hash); | ||
| } else { | ||
| this.opcode('emptyHash'); | ||
| } | ||
| namespace: "Handlebars", | ||
| // END PUBLIC API | ||
| return params; | ||
| } | ||
| }; | ||
| compile: function(environment, options, context, asObject) { | ||
| this.environment = environment; | ||
| this.options = options || {}; | ||
| var Literal = function(value) { | ||
| this.value = value; | ||
| }; | ||
| Handlebars.log(Handlebars.logger.DEBUG, this.environment.disassemble() + "\n\n"); | ||
| 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 + "']"; | ||
| } | ||
| }, | ||
| this.name = this.environment.name; | ||
| this.isChild = !!context; | ||
| this.context = context || { | ||
| programs: [], | ||
| environments: [], | ||
| aliases: { } | ||
| appendToBuffer: function(string) { | ||
| if (this.environment.isSimple) { | ||
| return "return " + string + ";"; | ||
| } else { | ||
| return { | ||
| appendToBuffer: true, | ||
| content: string, | ||
| toString: function() { return "buffer += " + string + ";"; } | ||
| }; | ||
| } | ||
| }, | ||
| this.preamble(); | ||
| initializeBuffer: function() { | ||
| return this.quotedString(""); | ||
| }, | ||
| this.stackSlot = 0; | ||
| this.stackVars = []; | ||
| this.registers = { list: [] }; | ||
| this.compileStack = []; | ||
| this.inlineStack = []; | ||
| namespace: "Handlebars", | ||
| // END PUBLIC API | ||
| this.compileChildren(environment, options); | ||
| compile: function(environment, options, context, asObject) { | ||
| this.environment = environment; | ||
| this.options = options || {}; | ||
| var opcodes = environment.opcodes, opcode; | ||
| Handlebars.log(Handlebars.logger.DEBUG, this.environment.disassemble() + "\n\n"); | ||
| this.i = 0; | ||
| this.name = this.environment.name; | ||
| this.isChild = !!context; | ||
| this.context = context || { | ||
| programs: [], | ||
| environments: [], | ||
| aliases: { } | ||
| }; | ||
| for(l=opcodes.length; this.i<l; this.i++) { | ||
| opcode = opcodes[this.i]; | ||
| this.preamble(); | ||
| if(opcode.opcode === 'DECLARE') { | ||
| this[opcode.name] = opcode.value; | ||
| } else { | ||
| this[opcode.opcode].apply(this, opcode.args); | ||
| } | ||
| } | ||
| this.stackSlot = 0; | ||
| this.stackVars = []; | ||
| this.registers = { list: [] }; | ||
| this.compileStack = []; | ||
| this.inlineStack = []; | ||
| return this.createFunctionContext(asObject); | ||
| }, | ||
| this.compileChildren(environment, options); | ||
| nextOpcode: function() { | ||
| var opcodes = this.environment.opcodes; | ||
| return opcodes[this.i + 1]; | ||
| }, | ||
| var opcodes = environment.opcodes, opcode; | ||
| eat: function() { | ||
| this.i = this.i + 1; | ||
| }, | ||
| this.i = 0; | ||
| preamble: function() { | ||
| var out = []; | ||
| for(l=opcodes.length; this.i<l; this.i++) { | ||
| opcode = opcodes[this.i]; | ||
| 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); | ||
| if(opcode.opcode === 'DECLARE') { | ||
| this[opcode.name] = opcode.value; | ||
| } else { | ||
| out.push(''); | ||
| this[opcode.opcode].apply(this, opcode.args); | ||
| } | ||
| } | ||
| if (!this.environment.isSimple) { | ||
| out.push(", buffer = " + this.initializeBuffer()); | ||
| } else { | ||
| out.push(""); | ||
| } | ||
| return this.createFunctionContext(asObject); | ||
| }, | ||
| // 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; | ||
| }, | ||
| nextOpcode: function() { | ||
| var opcodes = this.environment.opcodes; | ||
| return opcodes[this.i + 1]; | ||
| }, | ||
| createFunctionContext: function(asObject) { | ||
| var locals = this.stackVars.concat(this.registers.list); | ||
| eat: function() { | ||
| this.i = this.i + 1; | ||
| }, | ||
| if(locals.length > 0) { | ||
| this.source[1] = this.source[1] + ", " + locals.join(", "); | ||
| } | ||
| preamble: function() { | ||
| var out = []; | ||
| // 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.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.source[1]) { | ||
| this.source[1] = "var " + this.source[1].substring(2) + ";"; | ||
| } | ||
| if (!this.environment.isSimple) { | ||
| out.push(", buffer = " + this.initializeBuffer()); | ||
| } else { | ||
| out.push(""); | ||
| } | ||
| // Merge children | ||
| if (!this.isChild) { | ||
| this.source[1] += '\n' + this.context.programs.join('\n') + '\n'; | ||
| } | ||
| // 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; | ||
| }, | ||
| if (!this.environment.isSimple) { | ||
| this.source.push("return buffer;"); | ||
| } | ||
| createFunctionContext: function(asObject) { | ||
| var locals = this.stackVars.concat(this.registers.list); | ||
| var params = this.isChild ? ["depth0", "data"] : ["Handlebars", "depth0", "helpers", "partials", "data"]; | ||
| if(locals.length > 0) { | ||
| this.source[1] = this.source[1] + ", " + locals.join(", "); | ||
| } | ||
| for(var i=0, l=this.environment.depths.list.length; i<l; i++) { | ||
| params.push("depth" + this.environment.depths.list[i]); | ||
| // 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]; | ||
| } | ||
| } | ||
| // Perform a second pass over the output to merge content when possible | ||
| var source = this.mergeSource(); | ||
| if (this.source[1]) { | ||
| this.source[1] = "var " + this.source[1].substring(2) + ";"; | ||
| } | ||
| if (!this.isChild) { | ||
| var revision = Handlebars.COMPILER_REVISION, | ||
| versions = Handlebars.REVISION_CHANGES[revision]; | ||
| source = "this.compilerInfo = ["+revision+",'"+versions+"'];\n"+source; | ||
| } | ||
| // Merge children | ||
| if (!this.isChild) { | ||
| this.source[1] += '\n' + this.context.programs.join('\n') + '\n'; | ||
| } | ||
| if (asObject) { | ||
| params.push(source); | ||
| if (!this.environment.isSimple) { | ||
| this.source.push("return buffer;"); | ||
| } | ||
| 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; | ||
| } | ||
| 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 { | ||
| if (buffer) { | ||
| source += 'buffer += ' + buffer + ';\n '; | ||
| buffer = undefined; | ||
| } | ||
| source += line + '\n '; | ||
| buffer = line.content; | ||
| } | ||
| } else { | ||
| if (buffer) { | ||
| source += 'buffer += ' + buffer + ';\n '; | ||
| buffer = undefined; | ||
| } | ||
| source += line + '\n '; | ||
| } | ||
| return source; | ||
| }, | ||
| } | ||
| 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'; | ||
| // [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); | ||
| var params = ["depth0"]; | ||
| this.setupParams(0, params); | ||
| this.replaceStack(function(current) { | ||
| params.splice(1, 0, current); | ||
| return "blockHelperMissing.call(" + params.join(", ") + ")"; | ||
| }); | ||
| }, | ||
| 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'; | ||
| // [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 params = ["depth0"]; | ||
| this.setupParams(0, params); | ||
| var current = this.topStack(); | ||
| params.splice(1, 0, current); | ||
| var current = this.topStack(); | ||
| params.splice(1, 0, current); | ||
| // Use the options value generated from the invocation | ||
| params[params.length-1] = 'options'; | ||
| // Use the options value generated from the invocation | ||
| params[params.length-1] = 'options'; | ||
| this.source.push("if (!" + this.lastHelper + ") { " + current + " = blockHelperMissing.call(" + params.join(", ") + "); }"); | ||
| }, | ||
| 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))); | ||
| }, | ||
| // [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("''") + " }"); | ||
| } | ||
| }, | ||
| // [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'; | ||
| // [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() + ")")); | ||
| }, | ||
| 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; | ||
| } | ||
| }, | ||
| // [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')); | ||
| }, | ||
| // [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); | ||
| }, | ||
| // [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"'; | ||
| // [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; | ||
| }); | ||
| }, | ||
| 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'); | ||
| }); | ||
| }, | ||
| // [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')); | ||
| }, | ||
| // [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); | ||
| // [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); | ||
| this.pushString(type); | ||
| if (typeof string === 'string') { | ||
| this.pushString(string); | ||
| } else { | ||
| this.pushStackLiteral(string); | ||
| } | ||
| }, | ||
| if (typeof string === 'string') { | ||
| this.pushString(string); | ||
| } else { | ||
| this.pushStackLiteral(string); | ||
| } | ||
| }, | ||
| emptyHash: function() { | ||
| this.pushStackLiteral('{}'); | ||
| emptyHash: function() { | ||
| this.pushStackLiteral('{}'); | ||
| if (this.options.stringParams) { | ||
| this.register('hashTypes', '{}'); | ||
| } | ||
| }, | ||
| pushHash: function() { | ||
| this.hash = {values: [], types: []}; | ||
| }, | ||
| popHash: function() { | ||
| var hash = this.hash; | ||
| this.hash = undefined; | ||
| if (this.options.stringParams) { | ||
| this.register('hashTypes', '{}'); | ||
| } | ||
| }, | ||
| pushHash: function() { | ||
| this.hash = {values: [], types: []}; | ||
| }, | ||
| popHash: function() { | ||
| var hash = this.hash; | ||
| this.hash = undefined; | ||
| if (this.options.stringParams) { | ||
| this.register('hashTypes', '{' + hash.types.join(',') + '}'); | ||
| } | ||
| this.push('{\n ' + hash.values.join(',\n ') + '\n }'); | ||
| }, | ||
| if (this.options.stringParams) { | ||
| this.register('hashTypes', '{' + hash.types.join(',') + '}'); | ||
| } | ||
| this.push('{\n ' + hash.values.join(',\n ') + '\n }'); | ||
| }, | ||
| // [pushString] | ||
| // | ||
| // On stack, before: ... | ||
| // On stack, after: quotedString(string), ... | ||
| // | ||
| // Push a quoted version of `string` onto the stack | ||
| pushString: function(string) { | ||
| this.pushStackLiteral(this.quotedString(string)); | ||
| }, | ||
| // [pushString] | ||
| // | ||
| // On stack, before: ... | ||
| // On stack, after: quotedString(string), ... | ||
| // | ||
| // Push a quoted version of `string` onto the stack | ||
| pushString: function(string) { | ||
| this.pushStackLiteral(this.quotedString(string)); | ||
| }, | ||
| // [push] | ||
| // | ||
| // On stack, before: ... | ||
| // On stack, after: expr, ... | ||
| // | ||
| // Push an expression onto the stack | ||
| push: function(expr) { | ||
| this.inlineStack.push(expr); | ||
| return expr; | ||
| }, | ||
| // [push] | ||
| // | ||
| // On stack, before: ... | ||
| // On stack, after: expr, ... | ||
| // | ||
| // Push an expression onto the stack | ||
| push: function(expr) { | ||
| this.inlineStack.push(expr); | ||
| return expr; | ||
| }, | ||
| // [pushLiteral] | ||
| // | ||
| // On stack, before: ... | ||
| // On stack, after: value, ... | ||
| // | ||
| // Pushes a value onto the stack. This operation prevents | ||
| // the compiler from creating a temporary variable to hold | ||
| // it. | ||
| pushLiteral: function(value) { | ||
| this.pushStackLiteral(value); | ||
| }, | ||
| // [pushLiteral] | ||
| // | ||
| // On stack, before: ... | ||
| // On stack, after: value, ... | ||
| // | ||
| // Pushes a value onto the stack. This operation prevents | ||
| // the compiler from creating a temporary variable to hold | ||
| // it. | ||
| pushLiteral: function(value) { | ||
| this.pushStackLiteral(value); | ||
| }, | ||
| // [pushProgram] | ||
| // | ||
| // On stack, before: ... | ||
| // On stack, after: program(guid), ... | ||
| // | ||
| // Push a program expression onto the stack. This takes | ||
| // a compile-time guid and converts it into a runtime-accessible | ||
| // expression. | ||
| pushProgram: function(guid) { | ||
| if (guid != null) { | ||
| this.pushStackLiteral(this.programExpression(guid)); | ||
| } else { | ||
| this.pushStackLiteral(null); | ||
| } | ||
| }, | ||
| // [pushProgram] | ||
| // | ||
| // On stack, before: ... | ||
| // On stack, after: program(guid), ... | ||
| // | ||
| // Push a program expression onto the stack. This takes | ||
| // a compile-time guid and converts it into a runtime-accessible | ||
| // expression. | ||
| pushProgram: function(guid) { | ||
| if (guid != null) { | ||
| this.pushStackLiteral(this.programExpression(guid)); | ||
| } else { | ||
| this.pushStackLiteral(null); | ||
| } | ||
| }, | ||
| // [invokeHelper] | ||
| // | ||
| // On stack, before: hash, inverse, program, params..., ... | ||
| // On stack, after: result of helper invocation | ||
| // | ||
| // Pops off the helper's parameters, invokes the helper, | ||
| // and pushes the helper's return value onto the stack. | ||
| // | ||
| // If the helper is not found, `helperMissing` is called. | ||
| invokeHelper: function(paramSize, name) { | ||
| this.context.aliases.helperMissing = 'helpers.helperMissing'; | ||
| // [invokeHelper] | ||
| // | ||
| // On stack, before: hash, inverse, program, params..., ... | ||
| // On stack, after: result of helper invocation | ||
| // | ||
| // Pops off the helper's parameters, invokes the helper, | ||
| // and pushes the helper's return value onto the stack. | ||
| // | ||
| // If the helper is not found, `helperMissing` is called. | ||
| invokeHelper: function(paramSize, name) { | ||
| this.context.aliases.helperMissing = 'helpers.helperMissing'; | ||
| var helper = this.lastHelper = this.setupHelper(paramSize, name, true); | ||
| var helper = this.lastHelper = this.setupHelper(paramSize, name, true); | ||
| this.push(helper.name); | ||
| this.replaceStack(function(name) { | ||
| return name + ' ? ' + name + '.call(' + | ||
| helper.callParams + ") " + ": helperMissing.call(" + | ||
| helper.helperMissingParams + ")"; | ||
| }); | ||
| }, | ||
| this.push(helper.name); | ||
| this.replaceStack(function(name) { | ||
| return name + ' ? ' + name + '.call(' + | ||
| helper.callParams + ") " + ": helperMissing.call(" + | ||
| helper.helperMissingParams + ")"; | ||
| }); | ||
| }, | ||
| // [invokeKnownHelper] | ||
| // | ||
| // On stack, before: hash, inverse, program, params..., ... | ||
| // On stack, after: result of helper invocation | ||
| // | ||
| // This operation is used when the helper is known to exist, | ||
| // so a `helperMissing` fallback is not required. | ||
| invokeKnownHelper: function(paramSize, name) { | ||
| var helper = this.setupHelper(paramSize, name); | ||
| this.push(helper.name + ".call(" + helper.callParams + ")"); | ||
| }, | ||
| // [invokeKnownHelper] | ||
| // | ||
| // On stack, before: hash, inverse, program, params..., ... | ||
| // On stack, after: result of helper invocation | ||
| // | ||
| // This operation is used when the helper is known to exist, | ||
| // so a `helperMissing` fallback is not required. | ||
| invokeKnownHelper: function(paramSize, name) { | ||
| var helper = this.setupHelper(paramSize, name); | ||
| this.push(helper.name + ".call(" + helper.callParams + ")"); | ||
| }, | ||
| // [invokeAmbiguous] | ||
| // | ||
| // On stack, before: hash, inverse, program, params..., ... | ||
| // On stack, after: result of disambiguation | ||
| // | ||
| // This operation is used when an expression like `{{foo}}` | ||
| // is provided, but we don't know at compile-time whether it | ||
| // is a helper or a path. | ||
| // | ||
| // This operation emits more code than the other options, | ||
| // and can be avoided by passing the `knownHelpers` and | ||
| // `knownHelpersOnly` flags at compile-time. | ||
| invokeAmbiguous: function(name, helperCall) { | ||
| this.context.aliases.functionType = '"function"'; | ||
| // [invokeAmbiguous] | ||
| // | ||
| // On stack, before: hash, inverse, program, params..., ... | ||
| // On stack, after: result of disambiguation | ||
| // | ||
| // This operation is used when an expression like `{{foo}}` | ||
| // is provided, but we don't know at compile-time whether it | ||
| // is a helper or a path. | ||
| // | ||
| // This operation emits more code than the other options, | ||
| // and can be avoided by passing the `knownHelpers` and | ||
| // `knownHelpersOnly` flags at compile-time. | ||
| invokeAmbiguous: function(name, helperCall) { | ||
| this.context.aliases.functionType = '"function"'; | ||
| this.pushStackLiteral('{}'); // Hash value | ||
| var helper = this.setupHelper(0, name, helperCall); | ||
| this.pushStackLiteral('{}'); // Hash value | ||
| var helper = this.setupHelper(0, name, helperCall); | ||
| var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper'); | ||
| var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper'); | ||
| var nonHelper = this.nameLookup('depth' + this.lastContext, name, 'context'); | ||
| var nextStack = this.nextStack(); | ||
| var nonHelper = this.nameLookup('depth' + this.lastContext, name, 'context'); | ||
| var nextStack = this.nextStack(); | ||
| this.source.push('if (' + nextStack + ' = ' + helperName + ') { ' + nextStack + ' = ' + nextStack + '.call(' + helper.callParams + '); }'); | ||
| this.source.push('else { ' + nextStack + ' = ' + nonHelper + '; ' + nextStack + ' = typeof ' + nextStack + ' === functionType ? ' + nextStack + '.apply(depth0) : ' + nextStack + '; }'); | ||
| }, | ||
| this.source.push('if (' + nextStack + ' = ' + helperName + ') { ' + nextStack + ' = ' + nextStack + '.call(' + helper.callParams + '); }'); | ||
| this.source.push('else { ' + nextStack + ' = ' + nonHelper + '; ' + nextStack + ' = typeof ' + nextStack + ' === functionType ? ' + nextStack + '.apply(depth0) : ' + nextStack + '; }'); | ||
| }, | ||
| // [invokePartial] | ||
| // | ||
| // On stack, before: context, ... | ||
| // On stack after: result of partial invocation | ||
| // | ||
| // This operation pops off a context, invokes a partial with that context, | ||
| // and pushes the result of the invocation back. | ||
| invokePartial: function(name) { | ||
| var params = [this.nameLookup('partials', name, 'partial'), "'" + name + "'", this.popStack(), "helpers", "partials"]; | ||
| // [invokePartial] | ||
| // | ||
| // On stack, before: context, ... | ||
| // On stack after: result of partial invocation | ||
| // | ||
| // This operation pops off a context, invokes a partial with that context, | ||
| // and pushes the result of the invocation back. | ||
| invokePartial: function(name) { | ||
| var params = [this.nameLookup('partials', name, 'partial'), "'" + name + "'", this.popStack(), "helpers", "partials"]; | ||
| if (this.options.data) { | ||
| params.push("data"); | ||
| } | ||
| if (this.options.data) { | ||
| params.push("data"); | ||
| } | ||
| this.context.aliases.self = "this"; | ||
| this.push("self.invokePartial(" + params.join(", ") + ")"); | ||
| }, | ||
| this.context.aliases.self = "this"; | ||
| this.push("self.invokePartial(" + params.join(", ") + ")"); | ||
| }, | ||
| // [assignToHash] | ||
| // | ||
| // On stack, before: value, hash, ... | ||
| // On stack, after: hash, ... | ||
| // | ||
| // Pops a value and hash off the stack, assigns `hash[key] = value` | ||
| // and pushes the hash back onto the stack. | ||
| assignToHash: function(key) { | ||
| var value = this.popStack(), | ||
| type; | ||
| // [assignToHash] | ||
| // | ||
| // On stack, before: value, hash, ... | ||
| // On stack, after: hash, ... | ||
| // | ||
| // Pops a value and hash off the stack, assigns `hash[key] = value` | ||
| // and pushes the hash back onto the stack. | ||
| assignToHash: function(key) { | ||
| var value = this.popStack(), | ||
| type; | ||
| if (this.options.stringParams) { | ||
| type = this.popStack(); | ||
| this.popStack(); | ||
| } | ||
| if (this.options.stringParams) { | ||
| type = this.popStack(); | ||
| this.popStack(); | ||
| } | ||
| var hash = this.hash; | ||
| if (type) { | ||
| hash.types.push("'" + key + "': " + type); | ||
| } | ||
| hash.values.push("'" + key + "': (" + value + ")"); | ||
| }, | ||
| var hash = this.hash; | ||
| if (type) { | ||
| hash.types.push("'" + key + "': " + type); | ||
| } | ||
| hash.values.push("'" + key + "': (" + value + ")"); | ||
| }, | ||
| // HELPERS | ||
| // HELPERS | ||
| compiler: JavaScriptCompiler, | ||
| compiler: JavaScriptCompiler, | ||
| compileChildren: function(environment, options) { | ||
| var children = environment.children, child, compiler; | ||
| 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(); | ||
| for(var i=0, l=children.length; i<l; i++) { | ||
| child = children[i]; | ||
| compiler = new this.compiler(); | ||
| var index = this.matchExistingProgram(child); | ||
| var index = this.matchExistingProgram(child); | ||
| if (index == null) { | ||
| this.context.programs.push(''); // Placeholder to prevent name conflicts for nested children | ||
| index = this.context.programs.length; | ||
| child.index = index; | ||
| child.name = 'program' + index; | ||
| this.context.programs[index] = compiler.compile(child, options, this.context); | ||
| this.context.environments[index] = child; | ||
| } else { | ||
| child.index = index; | ||
| child.name = 'program' + index; | ||
| } | ||
| if (index == null) { | ||
| this.context.programs.push(''); // Placeholder to prevent name conflicts for nested children | ||
| index = this.context.programs.length; | ||
| child.index = index; | ||
| child.name = 'program' + index; | ||
| this.context.programs[index] = compiler.compile(child, options, this.context); | ||
| this.context.environments[index] = child; | ||
| } 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; | ||
| } | ||
| } | ||
| }, | ||
| 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) { | ||
| this.context.aliases.self = "this"; | ||
| programExpression: function(guid) { | ||
| this.context.aliases.self = "this"; | ||
| if(guid == null) { | ||
| return "self.noop"; | ||
| } | ||
| if(guid == null) { | ||
| return "self.noop"; | ||
| } | ||
| var child = this.environment.children[guid], | ||
| depths = child.depths.list, depth; | ||
| var child = this.environment.children[guid], | ||
| depths = child.depths.list, depth; | ||
| var programParams = [child.index, child.name, "data"]; | ||
| var programParams = [child.index, child.name, "data"]; | ||
| for(var i=0, l = depths.length; i<l; i++) { | ||
| depth = depths[i]; | ||
| for(var i=0, l = depths.length; i<l; i++) { | ||
| depth = depths[i]; | ||
| if(depth === 1) { programParams.push("depth0"); } | ||
| else { programParams.push("depth" + (depth - 1)); } | ||
| } | ||
| if(depth === 1) { programParams.push("depth0"); } | ||
| else { programParams.push("depth" + (depth - 1)); } | ||
| } | ||
| if(depths.length === 0) { | ||
| return "self.program(" + programParams.join(", ") + ")"; | ||
| } else { | ||
| programParams.shift(); | ||
| return "self.programWithDepth(" + programParams.join(", ") + ")"; | ||
| } | ||
| }, | ||
| if(depths.length === 0) { | ||
| return "self.program(" + programParams.join(", ") + ")"; | ||
| } else { | ||
| programParams.shift(); | ||
| return "self.programWithDepth(" + programParams.join(", ") + ")"; | ||
| } | ||
| }, | ||
| register: function(name, val) { | ||
| this.useRegister(name); | ||
| this.source.push(name + " = " + val + ";"); | ||
| }, | ||
| register: function(name, val) { | ||
| this.useRegister(name); | ||
| this.source.push(name + " = " + val + ";"); | ||
| }, | ||
| useRegister: function(name) { | ||
| if(!this.registers[name]) { | ||
| this.registers[name] = true; | ||
| this.registers.list.push(name); | ||
| } | ||
| }, | ||
| 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)); | ||
| }, | ||
| pushStackLiteral: function(item) { | ||
| return this.push(new Literal(item)); | ||
| }, | ||
| pushStack: function(item) { | ||
| this.flushInline(); | ||
| pushStack: function(item) { | ||
| this.flushInline(); | ||
| var stack = this.incrStack(); | ||
| if (item) { | ||
| this.source.push(stack + " = " + item + ";"); | ||
| } | ||
| this.compileStack.push(stack); | ||
| return stack; | ||
| }, | ||
| var stack = this.incrStack(); | ||
| if (item) { | ||
| this.source.push(stack + " = " + item + ";"); | ||
| } | ||
| this.compileStack.push(stack); | ||
| return stack; | ||
| }, | ||
| replaceStack: function(callback) { | ||
| var prefix = '', | ||
| inline = this.isInline(), | ||
| stack; | ||
| replaceStack: function(callback) { | ||
| var prefix = '', | ||
| inline = this.isInline(), | ||
| stack; | ||
| // If we are currently inline then we want to merge the inline statement into the | ||
| // replacement statement via ',' | ||
| if (inline) { | ||
| var top = this.popStack(true); | ||
| // If we are currently inline then we want to merge the inline statement into the | ||
| // replacement statement via ',' | ||
| if (inline) { | ||
| var top = this.popStack(true); | ||
| if (top instanceof Literal) { | ||
| // Literals do not need to be inlined | ||
| stack = top.value; | ||
| } else { | ||
| // Get or create the current stack name for use by the inline | ||
| var name = this.stackSlot ? this.topStackName() : this.incrStack(); | ||
| if (top instanceof Literal) { | ||
| // Literals do not need to be inlined | ||
| stack = top.value; | ||
| } else { | ||
| // Get or create the current stack name for use by the inline | ||
| var name = this.stackSlot ? this.topStackName() : this.incrStack(); | ||
| prefix = '(' + this.push(name) + ' = ' + top + '),'; | ||
| stack = this.topStack(); | ||
| } | ||
| } else { | ||
| prefix = '(' + this.push(name) + ' = ' + top + '),'; | ||
| stack = this.topStack(); | ||
| } | ||
| } else { | ||
| stack = this.topStack(); | ||
| } | ||
| var item = callback.call(this, stack); | ||
| var item = callback.call(this, stack); | ||
| if (inline) { | ||
| if (this.inlineStack.length || this.compileStack.length) { | ||
| this.popStack(); | ||
| } | ||
| this.push('(' + prefix + item + ')'); | ||
| } else { | ||
| // Prevent modification of the context depth variable. Through replaceStack | ||
| if (!/^stack/.test(stack)) { | ||
| stack = this.nextStack(); | ||
| } | ||
| this.source.push(stack + " = (" + prefix + item + ");"); | ||
| if (inline) { | ||
| if (this.inlineStack.length || this.compileStack.length) { | ||
| this.popStack(); | ||
| } | ||
| return stack; | ||
| }, | ||
| this.push('(' + prefix + item + ')'); | ||
| } else { | ||
| // Prevent modification of the context depth variable. Through replaceStack | ||
| if (!/^stack/.test(stack)) { | ||
| stack = this.nextStack(); | ||
| } | ||
| nextStack: function() { | ||
| return this.pushStack(); | ||
| }, | ||
| this.source.push(stack + " = (" + prefix + item + ");"); | ||
| } | ||
| return stack; | ||
| }, | ||
| 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; | ||
| }, | ||
| nextStack: function() { | ||
| return this.pushStack(); | ||
| }, | ||
| 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) { | ||
| this.stackSlot--; | ||
| 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); | ||
| } | ||
| return item; | ||
| } | ||
| }, | ||
| } | ||
| }, | ||
| isInline: function() { | ||
| return this.inlineStack.length; | ||
| }, | ||
| topStack: function(wrapped) { | ||
| var stack = (this.isInline() ? this.inlineStack : this.compileStack), | ||
| item = stack[stack.length - 1]; | ||
| popStack: function(wrapped) { | ||
| var inline = this.isInline(), | ||
| item = (inline ? this.inlineStack : this.compileStack).pop(); | ||
| if (!wrapped && (item instanceof Literal)) { | ||
| return item.value; | ||
| } else { | ||
| return item; | ||
| if (!wrapped && (item instanceof Literal)) { | ||
| return item.value; | ||
| } else { | ||
| if (!inline) { | ||
| this.stackSlot--; | ||
| } | ||
| }, | ||
| return item; | ||
| } | ||
| }, | ||
| quotedString: function(str) { | ||
| return '"' + str | ||
| .replace(/\\/g, '\\\\') | ||
| .replace(/"/g, '\\"') | ||
| .replace(/\n/g, '\\n') | ||
| .replace(/\r/g, '\\r') + '"'; | ||
| }, | ||
| topStack: function(wrapped) { | ||
| var stack = (this.isInline() ? this.inlineStack : this.compileStack), | ||
| item = stack[stack.length - 1]; | ||
| setupHelper: function(paramSize, name, missingParams) { | ||
| var params = []; | ||
| this.setupParams(paramSize, params, missingParams); | ||
| var foundHelper = this.nameLookup('helpers', name, 'helper'); | ||
| if (!wrapped && (item instanceof Literal)) { | ||
| return item.value; | ||
| } else { | ||
| return item; | ||
| } | ||
| }, | ||
| return { | ||
| params: params, | ||
| name: foundHelper, | ||
| callParams: ["depth0"].concat(params).join(", "), | ||
| helperMissingParams: missingParams && ["depth0", this.quotedString(name)].concat(params).join(", ") | ||
| }; | ||
| }, | ||
| quotedString: function(str) { | ||
| return '"' + str | ||
| .replace(/\\/g, '\\\\') | ||
| .replace(/"/g, '\\"') | ||
| .replace(/\n/g, '\\n') | ||
| .replace(/\r/g, '\\r') + '"'; | ||
| }, | ||
| // the params and contexts arguments are passed in arrays | ||
| // to fill in | ||
| setupParams: function(paramSize, params, useRegister) { | ||
| var options = [], contexts = [], types = [], param, inverse, program; | ||
| setupHelper: function(paramSize, name, missingParams) { | ||
| var params = []; | ||
| this.setupParams(paramSize, params, missingParams); | ||
| var foundHelper = this.nameLookup('helpers', name, 'helper'); | ||
| options.push("hash:" + this.popStack()); | ||
| return { | ||
| params: params, | ||
| name: foundHelper, | ||
| callParams: ["depth0"].concat(params).join(", "), | ||
| helperMissingParams: missingParams && ["depth0", this.quotedString(name)].concat(params).join(", ") | ||
| }; | ||
| }, | ||
| inverse = this.popStack(); | ||
| program = this.popStack(); | ||
| // the params and contexts arguments are passed in arrays | ||
| // to fill in | ||
| setupParams: function(paramSize, params, useRegister) { | ||
| var options = [], contexts = [], types = [], param, inverse, program; | ||
| // Avoid setting fn and inverse if neither are set. This allows | ||
| // helpers to do a check for `if (options.fn)` | ||
| if (program || inverse) { | ||
| if (!program) { | ||
| this.context.aliases.self = "this"; | ||
| program = "self.noop"; | ||
| } | ||
| options.push("hash:" + this.popStack()); | ||
| if (!inverse) { | ||
| this.context.aliases.self = "this"; | ||
| inverse = "self.noop"; | ||
| } | ||
| inverse = this.popStack(); | ||
| program = this.popStack(); | ||
| options.push("inverse:" + inverse); | ||
| options.push("fn:" + program); | ||
| // Avoid setting fn and inverse if neither are set. This allows | ||
| // helpers to do a check for `if (options.fn)` | ||
| if (program || inverse) { | ||
| if (!program) { | ||
| this.context.aliases.self = "this"; | ||
| program = "self.noop"; | ||
| } | ||
| for(var i=0; i<paramSize; i++) { | ||
| param = this.popStack(); | ||
| params.push(param); | ||
| if(this.options.stringParams) { | ||
| types.push(this.popStack()); | ||
| contexts.push(this.popStack()); | ||
| } | ||
| if (!inverse) { | ||
| this.context.aliases.self = "this"; | ||
| inverse = "self.noop"; | ||
| } | ||
| if (this.options.stringParams) { | ||
| options.push("contexts:[" + contexts.join(",") + "]"); | ||
| options.push("types:[" + types.join(",") + "]"); | ||
| options.push("hashTypes:hashTypes"); | ||
| } | ||
| options.push("inverse:" + inverse); | ||
| options.push("fn:" + program); | ||
| } | ||
| if(this.options.data) { | ||
| options.push("data:data"); | ||
| } | ||
| for(var i=0; i<paramSize; i++) { | ||
| param = this.popStack(); | ||
| params.push(param); | ||
| options = "{" + options.join(",") + "}"; | ||
| if (useRegister) { | ||
| this.register('options', options); | ||
| params.push('options'); | ||
| } else { | ||
| params.push(options); | ||
| if(this.options.stringParams) { | ||
| types.push(this.popStack()); | ||
| contexts.push(this.popStack()); | ||
| } | ||
| return params.join(", "); | ||
| } | ||
| }; | ||
| 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(" "); | ||
| if (this.options.stringParams) { | ||
| options.push("contexts:[" + contexts.join(",") + "]"); | ||
| options.push("types:[" + types.join(",") + "]"); | ||
| options.push("hashTypes:hashTypes"); | ||
| } | ||
| var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {}; | ||
| if(this.options.data) { | ||
| options.push("data:data"); | ||
| } | ||
| for(var i=0, l=reservedWords.length; i<l; i++) { | ||
| compilerWords[reservedWords[i]] = true; | ||
| options = "{" + options.join(",") + "}"; | ||
| if (useRegister) { | ||
| this.register('options', options); | ||
| params.push('options'); | ||
| } else { | ||
| params.push(options); | ||
| } | ||
| return params.join(", "); | ||
| } | ||
| }; | ||
| JavaScriptCompiler.isValidJavaScriptVariableName = function(name) { | ||
| if(!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]+$/.test(name)) { | ||
| return true; | ||
| } | ||
| return false; | ||
| }; | ||
| 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(" "); | ||
| })(Handlebars.Compiler, Handlebars.JavaScriptCompiler); | ||
| var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {}; | ||
| for(var i=0, l=reservedWords.length; i<l; i++) { | ||
| compilerWords[reservedWords[i]] = true; | ||
| } | ||
| JavaScriptCompiler.isValidJavaScriptVariableName = function(name) { | ||
| if(!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]+$/.test(name)) { | ||
| return true; | ||
| } | ||
| return false; | ||
| }; | ||
| Handlebars.precompile = function(input, options) { | ||
| if (!input || (typeof input !== 'string' && input.constructor !== Handlebars.AST.ProgramNode)) { | ||
| throw new Handlebars.Exception("You must pass a string or Handlebars AST to Handlebars.compile. You passed " + input); | ||
| throw new Handlebars.Exception("You must pass a string or Handlebars AST to Handlebars.precompile. You passed " + input); | ||
| } | ||
@@ -1241,4 +1249,4 @@ | ||
| var ast = Handlebars.parse(input); | ||
| var environment = new Handlebars.Compiler().compile(ast, options); | ||
| return new Handlebars.JavaScriptCompiler().compile(environment, options); | ||
| var environment = new Compiler().compile(ast, options); | ||
| return new JavaScriptCompiler().compile(environment, options); | ||
| }; | ||
@@ -1258,4 +1266,4 @@ | ||
| var ast = Handlebars.parse(input); | ||
| var environment = new Handlebars.Compiler().compile(ast, options); | ||
| var templateSpec = new Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true); | ||
| var environment = new Compiler().compile(ast, options); | ||
| var templateSpec = new JavaScriptCompiler().compile(environment, options, undefined, true); | ||
| return Handlebars.template(templateSpec); | ||
@@ -1262,0 +1270,0 @@ } |
@@ -467,3 +467,3 @@ // BEGIN(BROWSER) | ||
| }; | ||
| 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.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}}; | ||
@@ -470,0 +470,0 @@ return lexer;})() |
@@ -5,2 +5,6 @@ exports.attach = function(Handlebars) { | ||
| Handlebars.print = function(ast) { | ||
| return new Handlebars.PrintVisitor().accept(ast); | ||
| }; | ||
| Handlebars.PrintVisitor = function() { this.padding = 0; }; | ||
@@ -7,0 +11,0 @@ Handlebars.PrintVisitor.prototype = new Handlebars.Visitor(); |
@@ -25,43 +25,41 @@ exports.attach = function(Handlebars) { | ||
| (function() { | ||
| var escape = { | ||
| "&": "&", | ||
| "<": "<", | ||
| ">": ">", | ||
| '"': """, | ||
| "'": "'", | ||
| "`": "`" | ||
| }; | ||
| var escape = { | ||
| "&": "&", | ||
| "<": "<", | ||
| ">": ">", | ||
| '"': """, | ||
| "'": "'", | ||
| "`": "`" | ||
| }; | ||
| var badChars = /[&<>"'`]/g; | ||
| var possible = /[&<>"'`]/; | ||
| var badChars = /[&<>"'`]/g; | ||
| var possible = /[&<>"'`]/; | ||
| var escapeChar = function(chr) { | ||
| return escape[chr] || "&"; | ||
| }; | ||
| 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 ""; | ||
| } | ||
| 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); | ||
| }, | ||
| 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; | ||
| } | ||
| isEmpty: function(value) { | ||
| if (!value && value !== 0) { | ||
| return true; | ||
| } else if(toString.call(value) === "[object Array]" && value.length === 0) { | ||
| return true; | ||
| } else { | ||
| return false; | ||
| } | ||
| }; | ||
| })(); | ||
| } | ||
| }; | ||
@@ -68,0 +66,0 @@ // END(BROWSER) |
| { | ||
| "name": "handlebars", | ||
| "description": "Extension of the Mustache logicless template language", | ||
| "version": "1.0.9", | ||
| "version": "1.0.10", | ||
| "homepage": "http://www.handlebarsjs.com/", | ||
@@ -6,0 +6,0 @@ "keywords": [ |
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is not supported yet
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Improved metrics
- Number of package files
- increased by35%
27
- Lines of code
- increased by0.4%
4256
Worsened metrics
- Total package byte prevSize
- decreased by-1.38%
175073
No dependency changes