Commiting initial factory code

1 files changed, 919 insertions, 910 deletions

diff --git a/lib/handlebars/compiler/compiler.js b/lib/handlebars/compiler/compiler.js
index 108d055..5158294 100644
--- a/lib/handlebars/compiler/compiler.js
+++ b/lib/handlebars/compiler/compiler.js
@@ -1,1066 +1,1075 @@
-var Handlebars = require("./base");
 
-// BEGIN(BROWSER)
-
-/*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;
+exports.attach = function(Handlebars) {
 
-      for (var i=0, l=opcodes.length; i<l; i++) {
-        opcode = opcodes[i];
+// BEGIN(BROWSER)
 
-        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") + "\"";
+  /*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);
             }
-            params.push(param);
+            out.push(opcode.opcode + " " + params.join(" "));
           }
-          out.push(opcode.opcode + " " + params.join(" "));
         }
-      }
 
-      return out.join("\n");
-    },
-
-    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 out.join("\n");
+      },
+
+      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);
-    },
+        return this.program(program);
+      },
 
-    accept: function(node) {
-      return this[node.type](node);
-    },
+      accept: function(node) {
+        return this[node.type](node);
+      },
 
-    program: function(program) {
-      var statements = program.statements, statement;
-      this.opcodes = [];
+      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;
+        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;
-      });
+        this.depths.list = this.depths.list.sort(function(a, b) {
+          return a - b;
+        });
 
-      return this;
-    },
+        return this;
+      },
 
-    compileProgram: function(program) {
-      var result = new this.compiler().compile(program, this.options);
-      var guid = this.guid++, depth;
+      compileProgram: function(program) {
+        var result = new this.compiler().compile(program, this.options);
+        var guid = this.guid++, depth;
 
-      this.usePartial = this.usePartial || result.usePartial;
+        this.usePartial = this.usePartial || result.usePartial;
 
-      this.children[guid] = result;
+        this.children[guid] = result;
 
-      for(var i=0, l=result.depths.list.length; i<l; i++) {
-        depth = result.depths.list[i];
+        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); }
-      }
+          if(depth < 2) { continue; }
+          else { this.addDepth(depth - 1); }
+        }
 
-      return guid;
-    },
+        return guid;
+      },
 
-    block: function(block) {
-      var mustache = block.mustache,
-          program = block.program,
-          inverse = block.inverse;
+      block: function(block) {
+        var mustache = block.mustache,
+            program = block.program,
+            inverse = block.inverse;
 
-      if (program) {
-        program = this.compileProgram(program);
-      }
+        if (program) {
+          program = this.compileProgram(program);
+        }
 
-      if (inverse) {
-        inverse = this.compileProgram(inverse);
-      }
+        if (inverse) {
+          inverse = this.compileProgram(inverse);
+        }
 
-      var type = this.classifyMustache(mustache);
+        var type = this.classifyMustache(mustache);
 
-      if (type === "helper") {
-        this.helperMustache(mustache, program, inverse);
-      } else if (type === "simple") {
-        this.simpleMustache(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('pushLiteral', '{}');
-        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('pushLiteral', '{}');
+          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('pushLiteral', '{}');
+          this.opcode('ambiguousBlockValue');
+        }
 
-        // 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('pushLiteral', '{}');
-        this.opcode('ambiguousBlockValue');
-      }
+        this.opcode('append');
+      },
 
-      this.opcode('append');
-    },
+      hash: function(hash) {
+        var pairs = hash.pairs, pair, val;
 
-    hash: function(hash) {
-      var pairs = hash.pairs, pair, val;
+        this.opcode('push', '{}');
 
-      this.opcode('push', '{}');
+        for(var i=0, l=pairs.length; i<l; i++) {
+          pair = pairs[i];
+          val  = pair[1];
 
-      for(var i=0, l=pairs.length; i<l; i++) {
-        pair = pairs[i];
-        val  = pair[1];
+          this.accept(val);
+          this.opcode('assignToHash', pair[0]);
+        }
+      },
 
-        this.accept(val);
-        this.opcode('assignToHash', pair[0]);
-      }
-    },
+      partial: function(partial) {
+        var id = partial.id;
+        this.usePartial = true;
 
-    partial: function(partial) {
-      var id = partial.id;
-      this.usePartial = true;
+        if(partial.context) {
+          this.ID(partial.context);
+        } else {
+          this.opcode('push', 'depth0');
+        }
 
-      if(partial.context) {
-        this.ID(partial.context);
-      } else {
-        this.opcode('push', 'depth0');
-      }
+        this.opcode('invokePartial', id.original);
+        this.opcode('append');
+      },
 
-      this.opcode('invokePartial', id.original);
-      this.opcode('append');
-    },
+      content: function(content) {
+        this.opcode('appendContent', content.string);
+      },
 
-    content: function(content) {
-      this.opcode('appendContent', content.string);
-    },
+      mustache: function(mustache) {
+        var options = this.options;
+        var type = this.classifyMustache(mustache);
 
-    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 (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');
+        }
+      },
 
-      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];
 
-    ambiguousMustache: function(mustache, program, inverse) {
-      var id = mustache.id, name = id.parts[0];
+        this.opcode('getContext', id.depth);
 
-      this.opcode('getContext', id.depth);
+        this.opcode('pushProgram', program);
+        this.opcode('pushProgram', inverse);
 
-      this.opcode('pushProgram', program);
-      this.opcode('pushProgram', inverse);
+        this.opcode('invokeAmbiguous', name);
+      },
 
-      this.opcode('invokeAmbiguous', name);
-    },
+      simpleMustache: function(mustache, program, inverse) {
+        var id = mustache.id;
 
-    simpleMustache: function(mustache, program, inverse) {
-      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);
+        }
+      },
 
-      if (id.type === 'DATA') {
-        this.DATA(id);
-      } else if (id.parts.length) {
-        this.ID(id);
-      } else {
-        // Simplified ID for `this`
+      ID: function(id) {
         this.addDepth(id.depth);
         this.opcode('getContext', id.depth);
-        this.opcode('pushContext');
-      }
 
-      this.opcode('resolvePossibleLambda');
-    },
+        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]);
+        }
+      },
 
-    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);
+            }
 
-        if (options.knownHelpers[name]) {
-          isHelper = true;
-        } else if (options.knownHelpersOnly) {
-          isEligible = false;
+            this.opcode('getContext', param.depth || 0);
+            this.opcode('pushStringParam', param.string);
+          } else {
+            this[param.type](param);
+          }
         }
-      }
+      },
 
-      if (isHelper) { return "helper"; }
-      else if (isEligible) { return "ambiguous"; }
-      else { return "simple"; }
-    },
+      setupMustacheParams: function(mustache) {
+        var params = mustache.params;
+        this.pushParams(params);
 
-    pushParams: function(params) {
-      var i = params.length, param;
+        if(mustache.hash) {
+          this.hash(mustache.hash);
+        } else {
+          this.opcode('pushLiteral', '{}');
+        }
 
-      while(i--) {
-        param = params[i];
+        return params;
+      },
 
-        if(this.options.stringParams) {
-          if(param.depth) {
-            this.addDepth(param.depth);
-          }
+      // this will replace setupMustacheParams when we're done
+      setupFullMustacheParams: function(mustache, program, inverse) {
+        var params = mustache.params;
+        this.pushParams(params);
 
-          this.opcode('getContext', param.depth || 0);
-          this.opcode('pushStringParam', param.string);
+        this.opcode('pushProgram', program);
+        this.opcode('pushProgram', inverse);
+
+        if(mustache.hash) {
+          this.hash(mustache.hash);
         } else {
-          this[param.type](param);
+          this.opcode('pushLiteral', '{}');
         }
-      }
-    },
-
-    setupMustacheParams: function(mustache) {
-      var params = mustache.params;
-      this.pushParams(params);
 
-      if(mustache.hash) {
-        this.hash(mustache.hash);
-      } else {
-        this.opcode('pushLiteral', '{}');
+        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 + "']";
+        }
+      },
 
-      return params;
-    },
+      appendToBuffer: function(string) {
+        if (this.environment.isSimple) {
+          return "return " + string + ";";
+        } else {
+          return "buffer += " + string + ";";
+        }
+      },
 
-    // this will replace setupMustacheParams when we're done
-    setupFullMustacheParams: function(mustache, program, inverse) {
-      var params = mustache.params;
-      this.pushParams(params);
+      initializeBuffer: function() {
+        return this.quotedString("");
+      },
 
-      this.opcode('pushProgram', program);
-      this.opcode('pushProgram', inverse);
+      namespace: "Handlebars",
+      // END PUBLIC API
 
-      if(mustache.hash) {
-        this.hash(mustache.hash);
-      } else {
-        this.opcode('pushLiteral', '{}');
-      }
+      compile: function(environment, options, context, asObject) {
+        this.environment = environment;
+        this.options = options || {};
 
-      return params;
-    }
-  };
-
-  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: [],
+          aliases: { }
+        };
 
-    appendToBuffer: function(string) {
-      if (this.environment.isSimple) {
-        return "return " + string + ";";
-      } else {
-        return "buffer += " + string + ";";
-      }
-    },
+        this.preamble();
 
-    initializeBuffer: function() {
-      return this.quotedString("");
-    },
+        this.stackSlot = 0;
+        this.stackVars = [];
+        this.registers = { list: [] };
+        this.compileStack = [];
 
-    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: [],
-        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 = [];
+        return this.createFunctionContext(asObject);
+      },
 
-      this.compileChildren(environment, options);
+      nextOpcode: function() {
+        var opcodes = this.environment.opcodes, opcode = opcodes[this.i + 1];
+        return opcodes[this.i + 1];
+      },
 
-      var opcodes = environment.opcodes, opcode;
+      eat: function(opcode) {
+        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);
+        } else {
+          out.push('');
+        }
 
-        if(opcode.opcode === 'DECLARE') {
-          this[opcode.name] = opcode.value;
+        if (!this.environment.isSimple) {
+          out.push(", buffer = " + this.initializeBuffer());
         } else {
-          this[opcode.opcode].apply(this, opcode.args);
+          out.push("");
         }
-      }
 
-      return this.createFunctionContext(asObject);
-    },
-
-    nextOpcode: function() {
-      var opcodes = this.environment.opcodes, opcode = opcodes[this.i + 1];
-      return opcodes[this.i + 1];
-    },
-
-    eat: function(opcode) {
-      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('');
-      }
+        // 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) {
-        out.push(", buffer = " + this.initializeBuffer());
-      } else {
-        out.push("");
-      }
+      createFunctionContext: function(asObject) {
+        var locals = this.stackVars.concat(this.registers.list);
 
-      // 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(locals.length > 0) {
+          this.source[1] = this.source[1] + ", " + locals.join(", ");
+        }
 
-    createFunctionContext: function(asObject) {
-      var locals = this.stackVars.concat(this.registers.list);
+        // Generate minimizer alias mappings
+        if (!this.isChild) {
+          var aliases = [];
+          for (var alias in this.context.aliases) {
+            this.source[1] = this.source[1] + ', ' + alias + '=' + this.context.aliases[alias];
+          }
+        }
 
-      if(locals.length > 0) {
-        this.source[1] = this.source[1] + ", " + locals.join(", ");
-      }
+        if (this.source[1]) {
+          this.source[1] = "var " + this.source[1].substring(2) + ";";
+        }
 
-      // Generate minimizer alias mappings
-      if (!this.isChild) {
-        var aliases = [];
-        for (var alias in this.context.aliases) {
-          this.source[1] = this.source[1] + ', ' + alias + '=' + this.context.aliases[alias];
+        // Merge children
+        if (!this.isChild) {
+          this.source[1] += '\n' + this.context.programs.join('\n') + '\n';
         }
-      }
 
-      if (this.source[1]) {
-        this.source[1] = "var " + this.source[1].substring(2) + ";";
-      }
+        if (!this.environment.isSimple) {
+          this.source.push("return buffer;");
+        }
 
-      // Merge children
-      if (!this.isChild) {
-        this.source[1] += '\n' + this.context.programs.join('\n') + '\n';
-      }
+        var params = this.isChild ? ["depth0", "data"] : ["Handlebars", "depth0", "helpers", "partials", "data"];
 
-      if (!this.environment.isSimple) {
-        this.source.push("return buffer;");
-      }
+        for(var i=0, l=this.environment.depths.list.length; i<l; i++) {
+          params.push("depth" + this.environment.depths.list[i]);
+        }
 
-      var params = this.isChild ? ["depth0", "data"] : ["Handlebars", "depth0", "helpers", "partials", "data"];
+        if (asObject) {
+          params.push(this.source.join("\n  "));
 
-      for(var i=0, l=this.environment.depths.list.length; i<l; i++) {
-        params.push("depth" + this.environment.depths.list[i]);
-      }
+          return Function.apply(this, params);
+        } else {
+          var functionSource = 'function ' + (this.name || '') + '(' + params.join(',') + ') {\n  ' + this.source.join("\n  ") + '}';
+          Handlebars.log(Handlebars.logger.DEBUG, functionSource + "\n\n");
+          return functionSource;
+        }
+      },
+
+      // [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 current + " = 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);
 
-      if (asObject) {
-        params.push(this.source.join("\n  "));
+        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() {
+        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() {
+        var opcode = this.nextOpcode(), extra = "";
+        this.context.aliases.escapeExpression = 'this.escapeExpression';
+
+        if(opcode && opcode.opcode === 'appendContent') {
+          extra = " + " + this.quotedString(opcode.args[0]);
+          this.eat(opcode);
+        }
 
-        return Function.apply(this, params);
-      } else {
-        var functionSource = 'function ' + (this.name || '') + '(' + params.join(',') + ') {\n  ' + this.source.join("\n  ") + '}';
-        Handlebars.log(Handlebars.logger.DEBUG, functionSource + "\n\n");
-        return functionSource;
-      }
-    },
-
-    // [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 current + " = 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);
-
-      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() {
-      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() {
-      var opcode = this.nextOpcode(), extra = "";
-      this.context.aliases.escapeExpression = 'this.escapeExpression';
-
-      if(opcode && opcode.opcode === 'appendContent') {
-        extra = " + " + this.quotedString(opcode.args[0]);
-        this.eat(opcode);
-      }
+        this.source.push(this.appendToBuffer("escapeExpression(" + this.popStack() + ")" + extra));
+      },
+
+      // [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.pushStack(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 + "() : " + 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.pushStack(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) {
+        this.pushStackLiteral('depth' + this.lastContext);
+        this.pushString(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.pushStack(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);
+      },
+
+      // [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';
+
+        var helper = this.lastHelper = this.setupHelper(paramSize, name);
+        this.register('foundHelper', helper.name);
+
+        this.pushStack("foundHelper ? foundHelper.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.pushStack(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) {
+        this.context.aliases.functionType = '"function"';
+
+        this.pushStackLiteral('{}');
+        var helper = this.setupHelper(0, name);
+
+        var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper');
+        this.register('foundHelper', helperName);
+
+        var nonHelper = this.nameLookup('depth' + this.lastContext, name, 'context');
+        var nextStack = this.nextStack();
+
+        this.source.push('if (foundHelper) { ' + nextStack + ' = foundHelper.call(' + helper.callParams + '); }');
+        this.source.push('else { ' + nextStack + ' = ' + nonHelper + '; ' + nextStack + ' = typeof ' + nextStack + ' === functionType ? ' + nextStack + '() : ' + 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"];
+
+        if (this.options.data) {
+          params.push("data");
+        }
 
-      this.source.push(this.appendToBuffer("escapeExpression(" + this.popStack() + ")" + extra));
-    },
-
-    // [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.pushStack(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 + "() : " + 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.pushStack(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) {
-      this.pushStackLiteral('depth' + this.lastContext);
-      this.pushString(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.pushStack(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);
-    },
-
-    // [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';
-
-      var helper = this.lastHelper = this.setupHelper(paramSize, name);
-      this.register('foundHelper', helper.name);
-
-      this.pushStack("foundHelper ? foundHelper.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.pushStack(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) {
-      this.context.aliases.functionType = '"function"';
-
-      this.pushStackLiteral('{}');
-      var helper = this.setupHelper(0, name);
-
-      var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper');
-      this.register('foundHelper', helperName);
-
-      var nonHelper = this.nameLookup('depth' + this.lastContext, name, 'context');
-      var nextStack = this.nextStack();
-
-      this.source.push('if (foundHelper) { ' + nextStack + ' = foundHelper.call(' + helper.callParams + '); }');
-      this.source.push('else { ' + nextStack + ' = ' + nonHelper + '; ' + nextStack + ' = typeof ' + nextStack + ' === functionType ? ' + nextStack + '() : ' + 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"];
-
-      if (this.options.data) {
-        params.push("data");
-      }
+        this.context.aliases.self = "this";
+        this.pushStack("self.invokePartial(" + params.join(", ") + ");");
+      },
 
-      this.context.aliases.self = "this";
-      this.pushStack("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();
+        var hash = this.topStack();
 
-    // [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();
-      var hash = this.topStack();
+        this.source.push(hash + "['" + key + "'] = " + value + ";");
+      },
 
-      this.source.push(hash + "['" + 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();
+          this.context.programs.push('');     // Placeholder to prevent name conflicts for nested children
+          var index = this.context.programs.length;
+          child.index = index;
+          child.name = 'program' + index;
+          this.context.programs[index] = compiler.compile(child, options, this.context);
+        }
+      },
 
-        this.context.programs.push('');     // Placeholder to prevent name conflicts for nested children
-        var index = this.context.programs.length;
-        child.index = index;
-        child.name = 'program' + index;
-        this.context.programs[index] = compiler.compile(child, options, this.context);
-      }
-    },
+      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) {
-      this.compileStack.push(new Literal(item));
-      return item;
-    },
-
-    pushStack: function(item) {
-      this.source.push(this.incrStack() + " = " + item + ";");
-      this.compileStack.push("stack" + this.stackSlot);
-      return "stack" + this.stackSlot;
-    },
-
-    replaceStack: function(callback) {
-      var item = callback.call(this, this.topStack());
-
-      this.source.push(this.topStack() + " = " + item + ";");
-      return "stack" + this.stackSlot;
-    },
-
-    nextStack: function(skipCompileStack) {
-      var name = this.incrStack();
-      this.compileStack.push("stack" + this.stackSlot);
-      return name;
-    },
-
-    incrStack: function() {
-      this.stackSlot++;
-      if(this.stackSlot > this.stackVars.length) { this.stackVars.push("stack" + this.stackSlot); }
-      return "stack" + this.stackSlot;
-    },
-
-    popStack: function() {
-      var item = this.compileStack.pop();
-
-      if (item instanceof Literal) {
-        return item.value;
-      } else {
-        this.stackSlot--;
+      pushStackLiteral: function(item) {
+        this.compileStack.push(new Literal(item));
         return item;
-      }
-    },
+      },
+
+      pushStack: function(item) {
+        this.source.push(this.incrStack() + " = " + item + ";");
+        this.compileStack.push("stack" + this.stackSlot);
+        return "stack" + this.stackSlot;
+      },
+
+      replaceStack: function(callback) {
+        var item = callback.call(this, this.topStack());
+
+        this.source.push(this.topStack() + " = " + item + ";");
+        return "stack" + this.stackSlot;
+      },
+
+      nextStack: function(skipCompileStack) {
+        var name = this.incrStack();
+        this.compileStack.push("stack" + this.stackSlot);
+        return name;
+      },
+
+      incrStack: function() {
+        this.stackSlot++;
+        if(this.stackSlot > this.stackVars.length) { this.stackVars.push("stack" + this.stackSlot); }
+        return "stack" + this.stackSlot;
+      },
+
+      popStack: function() {
+        var item = this.compileStack.pop();
+
+        if (item instanceof Literal) {
+          return item.value;
+        } else {
+          this.stackSlot--;
+          return item;
+        }
+      },
 
-    topStack: function() {
-      var item = this.compileStack[this.compileStack.length - 1];
+      topStack: function() {
+        var item = this.compileStack[this.compileStack.length - 1];
 
-      if (item instanceof Literal) {
-        return item.value;
-      } else {
-        return item;
-      }
-    },
-
-    quotedString: function(str) {
-      return '"' + str
-        .replace(/\\/g, '\\\\')
-        .replace(/"/g, '\\"')
-        .replace(/\n/g, '\\n')
-        .replace(/\r/g, '\\r') + '"';
-    },
-
-    setupHelper: function(paramSize, name) {
-      var params = [];
-      this.setupParams(paramSize, params);
-      var foundHelper = this.nameLookup('helpers', name, 'helper');
-
-      return {
-        params: params,
-        name: foundHelper,
-        callParams: ["depth0"].concat(params).join(", "),
-        helperMissingParams: ["depth0", this.quotedString(name)].concat(params).join(", ")
-      };
-    },
-
-    // the params and contexts arguments are passed in arrays
-    // to fill in
-    setupParams: function(paramSize, params) {
-      var options = [], contexts = [], param, inverse, program;
-
-      options.push("hash:" + this.popStack());
-
-      inverse = this.popStack();
-      program = this.popStack();
-
-      // 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";
+        if (item instanceof Literal) {
+          return item.value;
+        } else {
+          return item;
         }
+      },
+
+      quotedString: function(str) {
+        return '"' + str
+          .replace(/\\/g, '\\\\')
+          .replace(/"/g, '\\"')
+          .replace(/\n/g, '\\n')
+          .replace(/\r/g, '\\r') + '"';
+      },
+
+      setupHelper: function(paramSize, name) {
+        var params = [];
+        this.setupParams(paramSize, params);
+        var foundHelper = this.nameLookup('helpers', name, 'helper');
+
+        return {
+          params: params,
+          name: foundHelper,
+          callParams: ["depth0"].concat(params).join(", "),
+          helperMissingParams: ["depth0", this.quotedString(name)].concat(params).join(", ")
+        };
+      },
+
+      // the params and contexts arguments are passed in arrays
+      // to fill in
+      setupParams: function(paramSize, params) {
+        var options = [], contexts = [], param, inverse, program;
+
+        options.push("hash:" + this.popStack());
+
+        inverse = this.popStack();
+        program = this.popStack();
+
+        // 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";
+          }
+
+          if (!inverse) {
+           this.context.aliases.self = "this";
+            inverse = "self.noop";
+          }
 
-        if (!inverse) {
-         this.context.aliases.self = "this";
-          inverse = "self.noop";
+          options.push("inverse:" + inverse);
+          options.push("fn:" + program);
         }
 
-        options.push("inverse:" + inverse);
-        options.push("fn:" + program);
-      }
+        for(var i=0; i<paramSize; i++) {
+          param = this.popStack();
+          params.push(param);
 
-      for(var i=0; i<paramSize; i++) {
-        param = this.popStack();
-        params.push(param);
+          if(this.options.stringParams) {
+            contexts.push(this.popStack());
+          }
+        }
 
-        if(this.options.stringParams) {
-          contexts.push(this.popStack());
+        if (this.options.stringParams) {
+          options.push("contexts:[" + contexts.join(",") + "]");
         }
-      }
 
-      if (this.options.stringParams) {
-        options.push("contexts:[" + contexts.join(",") + "]");
+        if(this.options.data) {
+          options.push("data:data");
+        }
+
+        params.push("{" + options.join(",") + "}");
+        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(" ");
+
+    var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {};
+
+    for(var i=0, l=reservedWords.length; i<l; i++) {
+      compilerWords[reservedWords[i]] = true;
+    }
 
-      if(this.options.data) {
-        options.push("data:data");
+    JavaScriptCompiler.isValidJavaScriptVariableName = function(name) {
+      if(!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]+$/.test(name)) {
+        return true;
       }
+      return false;
+    };
 
-      params.push("{" + options.join(",") + "}");
-      return params.join(", ");
-    }
+  })(Handlebars.Compiler, Handlebars.JavaScriptCompiler);
+
+  Handlebars.precompile = function(string, options) {
+    options = options || {};
+
+    var ast = Handlebars.parse(string);
+    var environment = new Handlebars.Compiler().compile(ast, options);
+    return new Handlebars.JavaScriptCompiler().compile(environment, options);
   };
 
-  var reservedWords = (
-    "break else new var" +
-    " case finally return void" +
-    " catch for switch while" +
-    " continue function this with" +
-    " default if throw" +
-    " delete in try" +
-    " do instanceof typeof" +
-    " abstract enum int short" +
-    " boolean export interface static" +
-    " byte extends long super" +
-    " char final native synchronized" +
-    " class float package throws" +
-    " const goto private transient" +
-    " debugger implements protected volatile" +
-    " double import public let yield"
-  ).split(" ");
-
-  var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {};
-
-  for(var i=0, l=reservedWords.length; i<l; i++) {
-    compilerWords[reservedWords[i]] = true;
-  }
-
-  JavaScriptCompiler.isValidJavaScriptVariableName = function(name) {
-    if(!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]+$/.test(name)) {
-      return true;
+  Handlebars.compile = function(string, options) {
+    options = options || {};
+
+    var compiled;
+    function compile() {
+      var ast = Handlebars.parse(string);
+      var environment = new Handlebars.Compiler().compile(ast, options);
+      var templateSpec = new Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true);
+      return Handlebars.template(templateSpec);
     }
-    return false;
-  };
 
-})(Handlebars.Compiler, Handlebars.JavaScriptCompiler);
+    // Template is only compiled on first use and cached after that point.
+    return function(context, options) {
+      if (!compiled) {
+        compiled = compile();
+      }
+      return compiled.call(this, context, options);
+    };
+  };
 
-Handlebars.precompile = function(string, options) {
-  options = options || {};
 
-  var ast = Handlebars.parse(string);
-  var environment = new Handlebars.Compiler().compile(ast, options);
-  return new Handlebars.JavaScriptCompiler().compile(environment, options);
-};
+  // END(BROWSER)
 
-Handlebars.compile = function(string, options) {
-  options = options || {};
+  return Handlebars;
 
-  var compiled;
-  function compile() {
-    var ast = Handlebars.parse(string);
-    var environment = new Handlebars.Compiler().compile(ast, options);
-    var templateSpec = new Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true);
-    return Handlebars.template(templateSpec);
-  }
-
-  // Template is only compiled on first use and cached after that point.
-  return function(context, options) {
-    if (!compiled) {
-      compiled = compile();
-    }
-    return compiled.call(this, context, options);
-  };
 };
 
-// END(BROWSER)