diff --git a/lib/handlebars.js b/lib/handlebars.js
index 78244969..7d85c261 100644
--- a/lib/handlebars.js
+++ b/lib/handlebars.js
@@ -2,18 +2,18 @@ var handlebars = require("./handlebars/base"),
 
 // Each of these augment the Handlebars object. No need to setup here.
 // (This is done to easily share code between commonjs and browse envs)
-	utils = require("./handlebars/utils"),
-	compiler = require("./handlebars/compiler"),
-	runtime = require("./handlebars/runtime");
+  utils = require("./handlebars/utils"),
+  compiler = require("./handlebars/compiler"),
+  runtime = require("./handlebars/runtime");
 
 var create = function() {
-	var hb = handlebars.create();
+  var hb = handlebars.create();
 
-	utils.attach(hb);
-	compiler.attach(hb);
-	runtime.attach(hb);
+  utils.attach(hb);
+  compiler.attach(hb);
+  runtime.attach(hb);
 
-	return hb;
+  return hb;
 };
 
 var Handlebars = create();
@@ -29,4 +29,4 @@ module.exports = Handlebars; // instantiate an instance
 // var handlebars = require('handlebars');
 
 // var singleton = handlebars.Handlebars,
-// 	local = handlebars.create();
+//  local = handlebars.create();
diff --git a/lib/handlebars/base.js b/lib/handlebars/base.js
index 656f0fb9..8640cb85 100644
--- a/lib/handlebars/base.js
+++ b/lib/handlebars/base.js
@@ -1,116 +1,116 @@
 module.exports.create = function() {
 
-  // BEGIN(BROWSER)
+// BEGIN(BROWSER)
 
-  var Handlebars = {};
+var Handlebars = {};
 
-  Handlebars.VERSION = "1.0.rc.1";
+Handlebars.VERSION = "1.0.rc.1";
 
-  Handlebars.helpers  = {};
-  Handlebars.partials = {};
+Handlebars.helpers  = {};
+Handlebars.partials = {};
 
-  Handlebars.registerHelper = function(name, fn, inverse) {
-    if(inverse) { fn.not = inverse; }
-    this.helpers[name] = fn;
-  };
+Handlebars.registerHelper = function(name, fn, inverse) {
+  if(inverse) { fn.not = inverse; }
+  this.helpers[name] = fn;
+};
 
-  Handlebars.registerPartial = function(name, str) {
-    this.partials[name] = str;
-  };
+Handlebars.registerPartial = function(name, str) {
+  this.partials[name] = str;
+};
 
-  Handlebars.registerHelper('helperMissing', function(arg) {
-    if(arguments.length === 2) {
-      return undefined;
-    } else {
-      throw new Error("Could not find property '" + arg + "'");
-    }
-  });
+Handlebars.registerHelper('helperMissing', function(arg) {
+  if(arguments.length === 2) {
+    return undefined;
+  } else {
+    throw new Error("Could not find property '" + arg + "'");
+  }
+});
 
-  var toString = Object.prototype.toString, functionType = "[object Function]";
+var toString = Object.prototype.toString, functionType = "[object Function]";
 
-  Handlebars.registerHelper('blockHelperMissing', function(context, options) {
-    var inverse = options.inverse || function() {}, fn = options.fn;
+Handlebars.registerHelper('blockHelperMissing', function(context, options) {
+  var inverse = options.inverse || function() {}, fn = options.fn;
 
 
-    var ret = "";
-    var type = toString.call(context);
+  var ret = "";
+  var type = toString.call(context);
 
-    if(type === functionType) { context = context.call(this); }
+  if(type === functionType) { context = context.call(this); }
 
-    if(context === true) {
-      return fn(this);
-    } else if(context === false || context == null) {
-      return inverse(this);
-    } else if(type === "[object Array]") {
-      if(context.length > 0) {
-        for(var i=0, j=context.length; i<j; i++) {
-          ret = ret + fn(context[i]);
-        }
-      } else {
-        ret = inverse(this);
-      }
-      return ret;
-    } else {
-      return fn(context);
-    }
-  });
-
-  Handlebars.K = function() {};
-
-  Handlebars.createFrame = Object.create || function(object) {
-    Handlebars.K.prototype = object;
-    var obj = new Handlebars.K();
-    Handlebars.K.prototype = null;
-    return obj;
-  };
-
-  Handlebars.registerHelper('each', function(context, options) {
-    var fn = options.fn, inverse = options.inverse;
-    var ret = "", data;
-
-    if (options.data) {
-      data = Handlebars.createFrame(options.data);
-    }
-
-    if(context && context.length > 0) {
+  if(context === true) {
+    return fn(this);
+  } else if(context === false || context == null) {
+    return inverse(this);
+  } else if(type === "[object Array]") {
+    if(context.length > 0) {
       for(var i=0, j=context.length; i<j; i++) {
-        if (data) { data.index = i; }
-        ret = ret + fn(context[i], { data: data });
+        ret = ret + fn(context[i]);
       }
     } else {
       ret = inverse(this);
     }
     return ret;
-  });
+  } else {
+    return fn(context);
+  }
+});
 
-  Handlebars.registerHelper('if', function(context, options) {
-    var type = toString.call(context);
-    if(type === functionType) { context = context.call(this); }
+Handlebars.K = function() {};
 
-    if(!context || Handlebars.Utils.isEmpty(context)) {
-      return options.inverse(this);
-    } else {
-      return options.fn(this);
+Handlebars.createFrame = Object.create || function(object) {
+  Handlebars.K.prototype = object;
+  var obj = new Handlebars.K();
+  Handlebars.K.prototype = null;
+  return obj;
+};
+
+Handlebars.registerHelper('each', function(context, options) {
+  var fn = options.fn, inverse = options.inverse;
+  var ret = "", data;
+
+  if (options.data) {
+    data = Handlebars.createFrame(options.data);
+  }
+
+  if(context && context.length > 0) {
+    for(var i=0, j=context.length; i<j; i++) {
+      if (data) { data.index = i; }
+      ret = ret + fn(context[i], { data: data });
     }
-  });
+  } else {
+    ret = inverse(this);
+  }
+  return ret;
+});
 
-  Handlebars.registerHelper('unless', function(context, options) {
-    var fn = options.fn, inverse = options.inverse;
-    options.fn = inverse;
-    options.inverse = fn;
+Handlebars.registerHelper('if', function(context, options) {
+  var type = toString.call(context);
+  if(type === functionType) { context = context.call(this); }
 
-    return Handlebars.helpers['if'].call(this, context, options);
-  });
+  if(!context || Handlebars.Utils.isEmpty(context)) {
+    return options.inverse(this);
+  } else {
+    return options.fn(this);
+  }
+});
 
-  Handlebars.registerHelper('with', function(context, options) {
-    return options.fn(context);
-  });
+Handlebars.registerHelper('unless', function(context, options) {
+  var fn = options.fn, inverse = options.inverse;
+  options.fn = inverse;
+  options.inverse = fn;
 
-  Handlebars.registerHelper('log', function(context) {
-    Handlebars.log(context);
-  });
+  return Handlebars.helpers['if'].call(this, context, options);
+});
 
-  // END(BROWSER)
+Handlebars.registerHelper('with', function(context, options) {
+  return options.fn(context);
+});
+
+Handlebars.registerHelper('log', function(context) {
+  Handlebars.log(context);
+});
+
+// END(BROWSER)
   
   return Handlebars;
 
diff --git a/lib/handlebars/compiler/ast.js b/lib/handlebars/compiler/ast.js
index d6f5ee0d..9648ef07 100644
--- a/lib/handlebars/compiler/ast.js
+++ b/lib/handlebars/compiler/ast.js
@@ -1,124 +1,126 @@
-
-// BEGIN(BROWSER)
 exports.attach = function(Handlebars) {
 
-  Handlebars.AST = {};
+// BEGIN(BROWSER)
 
-  Handlebars.AST.ProgramNode = function(statements, inverse) {
-    this.type = "program";
-    this.statements = statements;
-    if(inverse) { this.inverse = new Handlebars.AST.ProgramNode(inverse); }
-  };
+Handlebars.AST = {};
 
-  Handlebars.AST.MustacheNode = function(rawParams, hash, unescaped) {
-    this.type = "mustache";
-    this.escaped = !unescaped;
-    this.hash = hash;
+Handlebars.AST.ProgramNode = function(statements, inverse) {
+  this.type = "program";
+  this.statements = statements;
+  if(inverse) { this.inverse = new Handlebars.AST.ProgramNode(inverse); }
+};
 
-    var id = this.id = rawParams[0];
-    var params = this.params = rawParams.slice(1);
+Handlebars.AST.MustacheNode = function(rawParams, hash, unescaped) {
+  this.type = "mustache";
+  this.escaped = !unescaped;
+  this.hash = hash;
 
-    // a mustache is an eligible helper if:
-    // * its id is simple (a single part, not `this` or `..`)
-    var eligibleHelper = this.eligibleHelper = id.isSimple;
+  var id = this.id = rawParams[0];
+  var params = this.params = rawParams.slice(1);
 
-    // 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 an eligible helper if:
+  // * its id is simple (a single part, not `this` or `..`)
+  var eligibleHelper = this.eligibleHelper = id.isSimple;
 
-    // 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.
-  };
+  // 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);
 
-  Handlebars.AST.PartialNode = function(id, context) {
-    this.type    = "partial";
+  // 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.
+};
 
-    // TODO: disallow complex IDs
+Handlebars.AST.PartialNode = function(id, context) {
+  this.type    = "partial";
 
-    this.id      = id;
-    this.context = context;
-  };
+  // TODO: disallow complex IDs
 
-  var verifyMatch = function(open, close) {
-    if(open.original !== close.original) {
-      throw new Handlebars.Exception(open.original + " doesn't match " + close.original);
-    }
-  };
+  this.id      = id;
+  this.context = context;
+};
 
-  Handlebars.AST.BlockNode = function(mustache, program, inverse, close) {
-    verifyMatch(mustache.id, close);
-    this.type = "block";
-    this.mustache = mustache;
-    this.program  = program;
-    this.inverse  = inverse;
+var verifyMatch = function(open, close) {
+  if(open.original !== close.original) {
+    throw new Handlebars.Exception(open.original + " doesn't match " + close.original);
+  }
+};
 
-    if (this.inverse && !this.program) {
-      this.isInverse = true;
-    }
-  };
+Handlebars.AST.BlockNode = function(mustache, program, inverse, close) {
+  verifyMatch(mustache.id, close);
+  this.type = "block";
+  this.mustache = mustache;
+  this.program  = program;
+  this.inverse  = inverse;
 
-  Handlebars.AST.ContentNode = function(string) {
-    this.type = "content";
-    this.string = string;
-  };
+  if (this.inverse && !this.program) {
+    this.isInverse = true;
+  }
+};
 
-  Handlebars.AST.HashNode = function(pairs) {
-    this.type = "hash";
-    this.pairs = pairs;
-  };
+Handlebars.AST.ContentNode = function(string) {
+  this.type = "content";
+  this.string = string;
+};
 
-  Handlebars.AST.IdNode = function(parts) {
-    this.type = "ID";
-    this.original = parts.join(".");
+Handlebars.AST.HashNode = function(pairs) {
+  this.type = "hash";
+  this.pairs = pairs;
+};
 
-    var dig = [], depth = 0;
+Handlebars.AST.IdNode = function(parts) {
+  this.type = "ID";
+  this.original = parts.join(".");
 
-    for(var i=0,l=parts.length; i<l; i++) {
-      var part = parts[i];
+  var dig = [], depth = 0;
 
-      if(part === "..") { depth++; }
-      else if(part === "." || part === "this") { this.isScoped = true; }
-      else { dig.push(part); }
-    }
+  for(var i=0,l=parts.length; i<l; i++) {
+    var part = parts[i];
 
-    this.parts    = dig;
-    this.string   = dig.join('.');
-    this.depth    = depth;
+    if(part === "..") { depth++; }
+    else if(part === "." || part === "this") { this.isScoped = true; }
+    else { dig.push(part); }
+  }
 
-    // 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.parts    = dig;
+  this.string   = dig.join('.');
+  this.depth    = depth;
 
-  Handlebars.AST.DataNode = function(id) {
-    this.type = "DATA";
-    this.id = id;
-  };
+  // 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;
+};
 
-  Handlebars.AST.StringNode = function(string) {
-    this.type = "STRING";
-    this.string = string;
-  };
+Handlebars.AST.DataNode = function(id) {
+  this.type = "DATA";
+  this.id = id;
+};
 
-  Handlebars.AST.IntegerNode = function(integer) {
-    this.type = "INTEGER";
-    this.integer = integer;
-  };
+Handlebars.AST.StringNode = function(string) {
+  this.type = "STRING";
+  this.string = string;
+};
 
-  Handlebars.AST.BooleanNode = function(bool) {
-    this.type = "BOOLEAN";
-    this.bool = bool;
-  };
+Handlebars.AST.IntegerNode = function(integer) {
+  this.type = "INTEGER";
+  this.integer = integer;
+};
 
-  Handlebars.AST.CommentNode = function(comment) {
-    this.type = "comment";
-    this.comment = comment;
-  };
+Handlebars.AST.BooleanNode = function(bool) {
+  this.type = "BOOLEAN";
+  this.bool = bool;
+};
 
-  return Handlebars;
+Handlebars.AST.CommentNode = function(comment) {
+  this.type = "comment";
+  this.comment = comment;
 };
 
 // END(BROWSER)
 
+return Handlebars;
+};
+
+
+
diff --git a/lib/handlebars/compiler/base.js b/lib/handlebars/compiler/base.js
index 28150d9d..5319cf9c 100644
--- a/lib/handlebars/compiler/base.js
+++ b/lib/handlebars/compiler/base.js
@@ -1,30 +1,30 @@
 var handlebars = require("./parser").parser;
 
 exports.attach = function(Handlebars) {
-	
-	// BEGIN(BROWSER)
-	
-	Handlebars.Parser = handlebars;
 
-	Handlebars.parse = function(string) {
-	  Handlebars.Parser.yy = Handlebars.AST;
-	  return Handlebars.Parser.parse(string);
-	};
+// BEGIN(BROWSER)
 
-	Handlebars.print = function(ast) {
-	  return new Handlebars.PrintVisitor().accept(ast);
-	};
+Handlebars.Parser = handlebars;
 
-	Handlebars.logger = {
-	  DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3,
-
-	  // override in the host environment
-	  log: function(level, str) {}
-	};
-
-	Handlebars.log = function(level, str) { Handlebars.logger.log(level, str); };
-
-	return Handlebars;
-
-	// END(BROWSER)
+Handlebars.parse = function(string) {
+  Handlebars.Parser.yy = Handlebars.AST;
+  return Handlebars.Parser.parse(string);
+};
+
+Handlebars.print = function(ast) {
+  return new Handlebars.PrintVisitor().accept(ast);
+};
+
+Handlebars.logger = {
+  DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3,
+
+  // override in the host environment
+  log: function(level, str) {}
+};
+
+Handlebars.log = function(level, str) { Handlebars.logger.log(level, str); };
+
+return Handlebars;
+
+// END(BROWSER)
 };
diff --git a/lib/handlebars/compiler/compiler.js b/lib/handlebars/compiler/compiler.js
index 33bf1208..97a87f05 100644
--- a/lib/handlebars/compiler/compiler.js
+++ b/lib/handlebars/compiler/compiler.js
@@ -2,1074 +2,1074 @@ var compilerbase = require("./base");
 
 exports.attach = function(Handlebars) {
 
-  compilerbase.attach(Handlebars);
+compilerbase.attach(Handlebars);
 
 // BEGIN(BROWSER)
 
-  /*jshint eqnull:true*/
-  Handlebars.Compiler = function() {};
-  Handlebars.JavaScriptCompiler = function() {};
+/*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.
+(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,
+  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");
-      },
+      return out.join("\n");
+    },
 
-      guid: 0,
+    guid: 0,
 
-      compile: function(program, options) {
-        this.children = [];
-        this.depths = {list: []};
-        this.options = options;
+    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];
-          }
+      // 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);
-
-          // 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');
-        }
-
-        this.opcode('append');
-      },
-
-      hash: function(hash) {
-        var pairs = hash.pairs, pair, val;
-
-        this.opcode('push', '{}');
-
-        for(var i=0, l=pairs.length; i<l; i++) {
-          pair = pairs[i];
-          val  = pair[1];
-
-          this.accept(val);
-          this.opcode('assignToHash', pair[0]);
-        }
-      },
-
-      partial: function(partial) {
-        var id = partial.id;
-        this.usePartial = true;
-
-        if(partial.context) {
-          this.ID(partial.context);
-        } else {
-          this.opcode('push', 'depth0');
-        }
-
-        this.opcode('invokePartial', id.original);
-        this.opcode('append');
-      },
-
-      content: function(content) {
-        this.opcode('appendContent', content.string);
-      },
-
-      mustache: function(mustache) {
-        var options = this.options;
-        var type = this.classifyMustache(mustache);
-
-        if (type === "simple") {
-          this.simpleMustache(mustache);
-        } else if (type === "helper") {
-          this.helperMustache(mustache);
-        } else {
-          this.ambiguousMustache(mustache);
-        }
-
-        if(mustache.escaped && !options.noEscape) {
-          this.opcode('appendEscaped');
-        } else {
-          this.opcode('append');
-        }
-      },
-
-      ambiguousMustache: function(mustache, program, inverse) {
-        var id = mustache.id, name = id.parts[0];
-
-        this.opcode('getContext', id.depth);
+      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);
 
-        this.opcode('invokeAmbiguous', name);
-      },
+        // 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');
+      }
 
-      simpleMustache: function(mustache, program, inverse) {
-        var id = mustache.id;
+      this.opcode('append');
+    },
 
-        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');
-        }
+    hash: function(hash) {
+      var pairs = hash.pairs, pair, val;
 
-        this.opcode('resolvePossibleLambda');
-      },
+      this.opcode('push', '{}');
 
-      helperMustache: function(mustache, program, inverse) {
-        var params = this.setupFullMustacheParams(mustache, program, inverse),
-            name = mustache.id.parts[0];
+      for(var i=0, l=pairs.length; i<l; i++) {
+        pair = pairs[i];
+        val  = pair[1];
 
-        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);
-        }
-      },
+        this.accept(val);
+        this.opcode('assignToHash', pair[0]);
+      }
+    },
 
-      ID: function(id) {
+    partial: function(partial) {
+      var id = partial.id;
+      this.usePartial = true;
+
+      if(partial.context) {
+        this.ID(partial.context);
+      } else {
+        this.opcode('push', 'depth0');
+      }
+
+      this.opcode('invokePartial', id.original);
+      this.opcode('append');
+    },
+
+    content: function(content) {
+      this.opcode('appendContent', content.string);
+    },
+
+    mustache: function(mustache) {
+      var options = this.options;
+      var type = this.classifyMustache(mustache);
+
+      if (type === "simple") {
+        this.simpleMustache(mustache);
+      } else if (type === "helper") {
+        this.helperMustache(mustache);
+      } else {
+        this.ambiguousMustache(mustache);
+      }
+
+      if(mustache.escaped && !options.noEscape) {
+        this.opcode('appendEscaped');
+      } else {
+        this.opcode('append');
+      }
+    },
+
+    ambiguousMustache: function(mustache, program, inverse) {
+      var id = mustache.id, name = id.parts[0];
+
+      this.opcode('getContext', id.depth);
+
+      this.opcode('pushProgram', program);
+      this.opcode('pushProgram', inverse);
+
+      this.opcode('invokeAmbiguous', name);
+    },
+
+    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);
-
-        var name = id.parts[0];
-        if (!name) {
-          this.opcode('pushContext');
-        } else {
-          this.opcode('lookupOnContext', id.parts[0]);
-        }
-
-        for(var i=1, l=id.parts.length; i<l; i++) {
-          this.opcode('lookup', id.parts[i]);
-        }
-      },
-
-      DATA: function(data) {
-        this.options.data = true;
-        this.opcode('lookupData', data.id);
-      },
-
-      STRING: function(string) {
-        this.opcode('pushString', string.string);
-      },
-
-      INTEGER: function(integer) {
-        this.opcode('pushLiteral', integer.integer);
-      },
-
-      BOOLEAN: function(bool) {
-        this.opcode('pushLiteral', bool.bool);
-      },
-
-      comment: function() {},
-
-      // HELPERS
-      opcode: function(name) {
-        this.opcodes.push({ opcode: name, args: [].slice.call(arguments, 1) });
-      },
-
-      declare: function(name, value) {
-        this.opcodes.push({ opcode: 'DECLARE', name: name, value: value });
-      },
-
-      addDepth: function(depth) {
-        if(isNaN(depth)) { throw new Error("EWOT"); }
-        if(depth === 0) { return; }
-
-        if(!this.depths[depth]) {
-          this.depths[depth] = true;
-          this.depths.list.push(depth);
-        }
-      },
-
-      classifyMustache: function(mustache) {
-        var isHelper   = mustache.isHelper;
-        var isEligible = mustache.eligibleHelper;
-        var options    = this.options;
-
-        // if ambiguous, we can possibly resolve the ambiguity now
-        if (isEligible && !isHelper) {
-          var name = mustache.id.parts[0];
-
-          if (options.knownHelpers[name]) {
-            isHelper = true;
-          } else if (options.knownHelpersOnly) {
-            isEligible = false;
-          }
-        }
-
-        if (isHelper) { return "helper"; }
-        else if (isEligible) { return "ambiguous"; }
-        else { return "simple"; }
-      },
-
-      pushParams: function(params) {
-        var i = params.length, param;
-
-        while(i--) {
-          param = params[i];
-
-          if(this.options.stringParams) {
-            if(param.depth) {
-              this.addDepth(param.depth);
-            }
-
-            this.opcode('getContext', param.depth || 0);
-            this.opcode('pushStringParam', param.string);
-          } else {
-            this[param.type](param);
-          }
-        }
-      },
-
-      setupMustacheParams: function(mustache) {
-        var params = mustache.params;
-        this.pushParams(params);
-
-        if(mustache.hash) {
-          this.hash(mustache.hash);
-        } else {
-          this.opcode('pushLiteral', '{}');
-        }
-
-        return params;
-      },
-
-      // this will replace setupMustacheParams when we're done
-      setupFullMustacheParams: function(mustache, program, inverse) {
-        var params = mustache.params;
-        this.pushParams(params);
-
-        this.opcode('pushProgram', program);
-        this.opcode('pushProgram', inverse);
-
-        if(mustache.hash) {
-          this.hash(mustache.hash);
-        } else {
-          this.opcode('pushLiteral', '{}');
-        }
-
-        return params;
+        this.opcode('pushContext');
       }
-    };
 
-    var Literal = function(value) {
-      this.value = value;
-    };
+      this.opcode('resolvePossibleLambda');
+    },
 
-    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 + "']";
-        }
-      },
+    helperMustache: function(mustache, program, inverse) {
+      var params = this.setupFullMustacheParams(mustache, program, inverse),
+          name = mustache.id.parts[0];
 
-      appendToBuffer: function(string) {
-        if (this.environment.isSimple) {
-          return "return " + string + ";";
-        } else {
-          return "buffer += " + string + ";";
-        }
-      },
-
-      initializeBuffer: function() {
-        return this.quotedString("");
-      },
-
-      namespace: "Handlebars",
-      // END PUBLIC API
-
-      compile: function(environment, options, context, asObject) {
-        this.environment = environment;
-        this.options = options || {};
-
-        Handlebars.log(Handlebars.logger.DEBUG, this.environment.disassemble() + "\n\n");
-
-        this.name = this.environment.name;
-        this.isChild = !!context;
-        this.context = context || {
-          programs: [],
-          aliases: { }
-        };
-
-        this.preamble();
-
-        this.stackSlot = 0;
-        this.stackVars = [];
-        this.registers = { list: [] };
-        this.compileStack = [];
-
-        this.compileChildren(environment, options);
-
-        var opcodes = environment.opcodes, opcode;
-
-        this.i = 0;
-
-        for(l=opcodes.length; this.i<l; this.i++) {
-          opcode = opcodes[this.i];
-
-          if(opcode.opcode === 'DECLARE') {
-            this[opcode.name] = opcode.value;
-          } else {
-            this[opcode.opcode].apply(this, opcode.args);
-          }
-        }
-
-        return this.createFunctionContext(asObject);
-      },
-
-      nextOpcode: function() {
-        var opcodes = this.environment.opcodes, 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('');
-        }
-
-        if (!this.environment.isSimple) {
-          out.push(", buffer = " + this.initializeBuffer());
-        } else {
-          out.push("");
-        }
-
-        // track the last context pushed into place to allow skipping the
-        // getContext opcode when it would be a noop
-        this.lastContext = 0;
-        this.source = out;
-      },
-
-      createFunctionContext: function(asObject) {
-        var locals = this.stackVars.concat(this.registers.list);
-
-        if(locals.length > 0) {
-          this.source[1] = this.source[1] + ", " + locals.join(", ");
-        }
-
-        // Generate minimizer alias mappings
-        if (!this.isChild) {
-          var aliases = [];
-          for (var alias in this.context.aliases) {
-            this.source[1] = this.source[1] + ', ' + alias + '=' + this.context.aliases[alias];
-          }
-        }
-
-        if (this.source[1]) {
-          this.source[1] = "var " + this.source[1].substring(2) + ";";
-        }
-
-        // Merge children
-        if (!this.isChild) {
-          this.source[1] += '\n' + this.context.programs.join('\n') + '\n';
-        }
-
-        if (!this.environment.isSimple) {
-          this.source.push("return buffer;");
-        }
-
-        var params = this.isChild ? ["depth0", "data"] : ["Handlebars", "depth0", "helpers", "partials", "data"];
-
-        for(var i=0, l=this.environment.depths.list.length; i<l; i++) {
-          params.push("depth" + this.environment.depths.list[i]);
-        }
-
-        if (asObject) {
-          params.push(this.source.join("\n  "));
-
-          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.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();
-
-        this.source.push(hash + "['" + key + "'] = " + value + ";");
-      },
-
-      // HELPERS
-
-      compiler: JavaScriptCompiler,
-
-      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();
-
-          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";
-
-        if(guid == null) {
-          return "self.noop";
-        }
-
-        var child = this.environment.children[guid],
-            depths = child.depths.list, depth;
-
-        var programParams = [child.index, child.name, "data"];
-
-        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(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 + ";");
-      },
-
-      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--;
-          return item;
-        }
-      },
-
-      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 (!inverse) {
-           this.context.aliases.self = "this";
-            inverse = "self.noop";
-          }
-
-          options.push("inverse:" + inverse);
-          options.push("fn:" + program);
-        }
-
-        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) {
-          options.push("contexts:[" + contexts.join(",") + "]");
-        }
-
-        if(this.options.data) {
-          options.push("data:data");
-        }
-
-        params.push("{" + options.join(",") + "}");
-        return params.join(", ");
+      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);
       }
-    };
+    },
 
-    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(" ");
+    ID: function(id) {
+      this.addDepth(id.depth);
+      this.opcode('getContext', id.depth);
 
-    var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {};
+      var name = id.parts[0];
+      if (!name) {
+        this.opcode('pushContext');
+      } else {
+        this.opcode('lookupOnContext', id.parts[0]);
+      }
 
-    for(var i=0, l=reservedWords.length; i<l; i++) {
-      compilerWords[reservedWords[i]] = true;
+      for(var i=1, l=id.parts.length; i<l; i++) {
+        this.opcode('lookup', id.parts[i]);
+      }
+    },
+
+    DATA: function(data) {
+      this.options.data = true;
+      this.opcode('lookupData', data.id);
+    },
+
+    STRING: function(string) {
+      this.opcode('pushString', string.string);
+    },
+
+    INTEGER: function(integer) {
+      this.opcode('pushLiteral', integer.integer);
+    },
+
+    BOOLEAN: function(bool) {
+      this.opcode('pushLiteral', bool.bool);
+    },
+
+    comment: function() {},
+
+    // HELPERS
+    opcode: function(name) {
+      this.opcodes.push({ opcode: name, args: [].slice.call(arguments, 1) });
+    },
+
+    declare: function(name, value) {
+      this.opcodes.push({ opcode: 'DECLARE', name: name, value: value });
+    },
+
+    addDepth: function(depth) {
+      if(isNaN(depth)) { throw new Error("EWOT"); }
+      if(depth === 0) { return; }
+
+      if(!this.depths[depth]) {
+        this.depths[depth] = true;
+        this.depths.list.push(depth);
+      }
+    },
+
+    classifyMustache: function(mustache) {
+      var isHelper   = mustache.isHelper;
+      var isEligible = mustache.eligibleHelper;
+      var options    = this.options;
+
+      // if ambiguous, we can possibly resolve the ambiguity now
+      if (isEligible && !isHelper) {
+        var name = mustache.id.parts[0];
+
+        if (options.knownHelpers[name]) {
+          isHelper = true;
+        } else if (options.knownHelpersOnly) {
+          isEligible = false;
+        }
+      }
+
+      if (isHelper) { return "helper"; }
+      else if (isEligible) { return "ambiguous"; }
+      else { return "simple"; }
+    },
+
+    pushParams: function(params) {
+      var i = params.length, param;
+
+      while(i--) {
+        param = params[i];
+
+        if(this.options.stringParams) {
+          if(param.depth) {
+            this.addDepth(param.depth);
+          }
+
+          this.opcode('getContext', param.depth || 0);
+          this.opcode('pushStringParam', param.string);
+        } else {
+          this[param.type](param);
+        }
+      }
+    },
+
+    setupMustacheParams: function(mustache) {
+      var params = mustache.params;
+      this.pushParams(params);
+
+      if(mustache.hash) {
+        this.hash(mustache.hash);
+      } else {
+        this.opcode('pushLiteral', '{}');
+      }
+
+      return params;
+    },
+
+    // this will replace setupMustacheParams when we're done
+    setupFullMustacheParams: function(mustache, program, inverse) {
+      var params = mustache.params;
+      this.pushParams(params);
+
+      this.opcode('pushProgram', program);
+      this.opcode('pushProgram', inverse);
+
+      if(mustache.hash) {
+        this.hash(mustache.hash);
+      } else {
+        this.opcode('pushLiteral', '{}');
+      }
+
+      return params;
     }
+  };
 
-    JavaScriptCompiler.isValidJavaScriptVariableName = function(name) {
-      if(!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]+$/.test(name)) {
-        return true;
+  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;
       }
-      return false;
-    };
+      else {
+        return parent + "['" + name + "']";
+      }
+    },
 
-  })(Handlebars.Compiler, Handlebars.JavaScriptCompiler);
+    appendToBuffer: function(string) {
+      if (this.environment.isSimple) {
+        return "return " + string + ";";
+      } else {
+        return "buffer += " + string + ";";
+      }
+    },
 
-  Handlebars.precompile = function(string, options) {
-    options = options || {};
+    initializeBuffer: function() {
+      return this.quotedString("");
+    },
 
+    namespace: "Handlebars",
+    // END PUBLIC API
+
+    compile: function(environment, options, context, asObject) {
+      this.environment = environment;
+      this.options = options || {};
+
+      Handlebars.log(Handlebars.logger.DEBUG, this.environment.disassemble() + "\n\n");
+
+      this.name = this.environment.name;
+      this.isChild = !!context;
+      this.context = context || {
+        programs: [],
+        aliases: { }
+      };
+
+      this.preamble();
+
+      this.stackSlot = 0;
+      this.stackVars = [];
+      this.registers = { list: [] };
+      this.compileStack = [];
+
+      this.compileChildren(environment, options);
+
+      var opcodes = environment.opcodes, opcode;
+
+      this.i = 0;
+
+      for(l=opcodes.length; this.i<l; this.i++) {
+        opcode = opcodes[this.i];
+
+        if(opcode.opcode === 'DECLARE') {
+          this[opcode.name] = opcode.value;
+        } else {
+          this[opcode.opcode].apply(this, opcode.args);
+        }
+      }
+
+      return this.createFunctionContext(asObject);
+    },
+
+    nextOpcode: function() {
+      var opcodes = this.environment.opcodes, 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('');
+      }
+
+      if (!this.environment.isSimple) {
+        out.push(", buffer = " + this.initializeBuffer());
+      } else {
+        out.push("");
+      }
+
+      // track the last context pushed into place to allow skipping the
+      // getContext opcode when it would be a noop
+      this.lastContext = 0;
+      this.source = out;
+    },
+
+    createFunctionContext: function(asObject) {
+      var locals = this.stackVars.concat(this.registers.list);
+
+      if(locals.length > 0) {
+        this.source[1] = this.source[1] + ", " + locals.join(", ");
+      }
+
+      // Generate minimizer alias mappings
+      if (!this.isChild) {
+        var aliases = [];
+        for (var alias in this.context.aliases) {
+          this.source[1] = this.source[1] + ', ' + alias + '=' + this.context.aliases[alias];
+        }
+      }
+
+      if (this.source[1]) {
+        this.source[1] = "var " + this.source[1].substring(2) + ";";
+      }
+
+      // Merge children
+      if (!this.isChild) {
+        this.source[1] += '\n' + this.context.programs.join('\n') + '\n';
+      }
+
+      if (!this.environment.isSimple) {
+        this.source.push("return buffer;");
+      }
+
+      var params = this.isChild ? ["depth0", "data"] : ["Handlebars", "depth0", "helpers", "partials", "data"];
+
+      for(var i=0, l=this.environment.depths.list.length; i<l; i++) {
+        params.push("depth" + this.environment.depths.list[i]);
+      }
+
+      if (asObject) {
+        params.push(this.source.join("\n  "));
+
+        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.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();
+
+      this.source.push(hash + "['" + key + "'] = " + value + ";");
+    },
+
+    // HELPERS
+
+    compiler: JavaScriptCompiler,
+
+    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();
+
+        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";
+
+      if(guid == null) {
+        return "self.noop";
+      }
+
+      var child = this.environment.children[guid],
+          depths = child.depths.list, depth;
+
+      var programParams = [child.index, child.name, "data"];
+
+      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(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 + ";");
+    },
+
+    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--;
+        return item;
+      }
+    },
+
+    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 (!inverse) {
+         this.context.aliases.self = "this";
+          inverse = "self.noop";
+        }
+
+        options.push("inverse:" + inverse);
+        options.push("fn:" + program);
+      }
+
+      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) {
+        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;
+  }
+
+  JavaScriptCompiler.isValidJavaScriptVariableName = function(name) {
+    if(!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]+$/.test(name)) {
+      return true;
+    }
+    return false;
+  };
+
+})(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);
+};
+
+Handlebars.compile = function(string, options) {
+  options = options || {};
+
+  var compiled;
+  function compile() {
     var ast = Handlebars.parse(string);
     var environment = new Handlebars.Compiler().compile(ast, options);
-    return new Handlebars.JavaScriptCompiler().compile(environment, options);
-  };
+    var templateSpec = new Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true);
+    return Handlebars.template(templateSpec);
+  }
 
-  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);
+  // Template is only compiled on first use and cached after that point.
+  return function(context, options) {
+    if (!compiled) {
+      compiled = compile();
     }
-
-    // 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);
-    };
+    return compiled.call(this, context, options);
   };
+};
 
 
-  // END(BROWSER)
+// END(BROWSER)
 
-  return Handlebars;
+return Handlebars;
 
 };
 
diff --git a/lib/handlebars/compiler/index.js b/lib/handlebars/compiler/index.js
index ce8e9869..6ed8d219 100644
--- a/lib/handlebars/compiler/index.js
+++ b/lib/handlebars/compiler/index.js
@@ -2,9 +2,9 @@
 module.exports.attach = function(Handlebars) {
 
 var visitor = require("./visitor"),
-	printer = require("./printer"),
-	ast = require("./ast"),
-	compiler = require("./compiler");
+    printer = require("./printer"),
+    ast = require("./ast"),
+    compiler = require("./compiler");
 
 visitor.attach(Handlebars);
 printer.attach(Handlebars);
diff --git a/lib/handlebars/compiler/printer.js b/lib/handlebars/compiler/printer.js
index f5b83092..8c4bdd7a 100644
--- a/lib/handlebars/compiler/printer.js
+++ b/lib/handlebars/compiler/printer.js
@@ -1,130 +1,130 @@
 exports.attach = function(Handlebars) {
 
-  // BEGIN(BROWSER)
-  
-  Handlebars.PrintVisitor = function() { this.padding = 0; };
-  Handlebars.PrintVisitor.prototype = new Handlebars.Visitor();
+// BEGIN(BROWSER)
 
-  Handlebars.PrintVisitor.prototype.pad = function(string, newline) {
-    var out = "";
+Handlebars.PrintVisitor = function() { this.padding = 0; };
+Handlebars.PrintVisitor.prototype = new Handlebars.Visitor();
 
-    for(var i=0,l=this.padding; i<l; i++) {
-      out = out + "  ";
-    }
+Handlebars.PrintVisitor.prototype.pad = function(string, newline) {
+  var out = "";
 
-    out = out + string;
+  for(var i=0,l=this.padding; i<l; i++) {
+    out = out + "  ";
+  }
 
-    if(newline !== false) { out = out + "\n"; }
-    return out;
-  };
+  out = out + string;
 
-  Handlebars.PrintVisitor.prototype.program = function(program) {
-    var out = "",
-        statements = program.statements,
-        inverse = program.inverse,
-        i, l;
-
-    for(i=0, l=statements.length; i<l; i++) {
-      out = out + this.accept(statements[i]);
-    }
-
-    this.padding--;
-
-    return out;
-  };
-
-  Handlebars.PrintVisitor.prototype.block = function(block) {
-    var out = "";
-
-    out = out + this.pad("BLOCK:");
-    this.padding++;
-    out = out + this.accept(block.mustache);
-    if (block.program) {
-      out = out + this.pad("PROGRAM:");
-      this.padding++;
-      out = out + this.accept(block.program);
-      this.padding--;
-    }
-    if (block.inverse) {
-      if (block.program) { this.padding++; }
-      out = out + this.pad("{{^}}");
-      this.padding++;
-      out = out + this.accept(block.inverse);
-      this.padding--;
-      if (block.program) { this.padding--; }
-    }
-    this.padding--;
-
-    return out;
-  };
-
-  Handlebars.PrintVisitor.prototype.mustache = function(mustache) {
-    var params = mustache.params, paramStrings = [], hash;
-
-    for(var i=0, l=params.length; i<l; i++) {
-      paramStrings.push(this.accept(params[i]));
-    }
-
-    params = "[" + paramStrings.join(", ") + "]";
-
-    hash = mustache.hash ? " " + this.accept(mustache.hash) : "";
-
-    return this.pad("{{ " + this.accept(mustache.id) + " " + params + hash + " }}");
-  };
-
-  Handlebars.PrintVisitor.prototype.partial = function(partial) {
-    var content = this.accept(partial.id);
-    if(partial.context) { content = content + " " + this.accept(partial.context); }
-    return this.pad("{{> " + content + " }}");
-  };
-
-  Handlebars.PrintVisitor.prototype.hash = function(hash) {
-    var pairs = hash.pairs;
-    var joinedPairs = [], left, right;
-
-    for(var i=0, l=pairs.length; i<l; i++) {
-      left = pairs[i][0];
-      right = this.accept(pairs[i][1]);
-      joinedPairs.push( left + "=" + right );
-    }
-
-    return "HASH{" + joinedPairs.join(", ") + "}";
-  };
-
-  Handlebars.PrintVisitor.prototype.STRING = function(string) {
-    return '"' + string.string + '"';
-  };
-
-  Handlebars.PrintVisitor.prototype.INTEGER = function(integer) {
-    return "INTEGER{" + integer.integer + "}";
-  };
-
-  Handlebars.PrintVisitor.prototype.BOOLEAN = function(bool) {
-    return "BOOLEAN{" + bool.bool + "}";
-  };
-
-  Handlebars.PrintVisitor.prototype.ID = function(id) {
-    var path = id.parts.join("/");
-    if(id.parts.length > 1) {
-      return "PATH:" + path;
-    } else {
-      return "ID:" + path;
-    }
-  };
-
-  Handlebars.PrintVisitor.prototype.DATA = function(data) {
-    return "@" + data.id;
-  };
-
-  Handlebars.PrintVisitor.prototype.content = function(content) {
-    return this.pad("CONTENT[ '" + content.string + "' ]");
-  };
-
-  Handlebars.PrintVisitor.prototype.comment = function(comment) {
-    return this.pad("{{! '" + comment.comment + "' }}");
-  };
-  // END(BROWSER)
-
-  return Handlebars;
+  if(newline !== false) { out = out + "\n"; }
+  return out;
+};
+
+Handlebars.PrintVisitor.prototype.program = function(program) {
+  var out = "",
+      statements = program.statements,
+      inverse = program.inverse,
+      i, l;
+
+  for(i=0, l=statements.length; i<l; i++) {
+    out = out + this.accept(statements[i]);
+  }
+
+  this.padding--;
+
+  return out;
+};
+
+Handlebars.PrintVisitor.prototype.block = function(block) {
+  var out = "";
+
+  out = out + this.pad("BLOCK:");
+  this.padding++;
+  out = out + this.accept(block.mustache);
+  if (block.program) {
+    out = out + this.pad("PROGRAM:");
+    this.padding++;
+    out = out + this.accept(block.program);
+    this.padding--;
+  }
+  if (block.inverse) {
+    if (block.program) { this.padding++; }
+    out = out + this.pad("{{^}}");
+    this.padding++;
+    out = out + this.accept(block.inverse);
+    this.padding--;
+    if (block.program) { this.padding--; }
+  }
+  this.padding--;
+
+  return out;
+};
+
+Handlebars.PrintVisitor.prototype.mustache = function(mustache) {
+  var params = mustache.params, paramStrings = [], hash;
+
+  for(var i=0, l=params.length; i<l; i++) {
+    paramStrings.push(this.accept(params[i]));
+  }
+
+  params = "[" + paramStrings.join(", ") + "]";
+
+  hash = mustache.hash ? " " + this.accept(mustache.hash) : "";
+
+  return this.pad("{{ " + this.accept(mustache.id) + " " + params + hash + " }}");
+};
+
+Handlebars.PrintVisitor.prototype.partial = function(partial) {
+  var content = this.accept(partial.id);
+  if(partial.context) { content = content + " " + this.accept(partial.context); }
+  return this.pad("{{> " + content + " }}");
+};
+
+Handlebars.PrintVisitor.prototype.hash = function(hash) {
+  var pairs = hash.pairs;
+  var joinedPairs = [], left, right;
+
+  for(var i=0, l=pairs.length; i<l; i++) {
+    left = pairs[i][0];
+    right = this.accept(pairs[i][1]);
+    joinedPairs.push( left + "=" + right );
+  }
+
+  return "HASH{" + joinedPairs.join(", ") + "}";
+};
+
+Handlebars.PrintVisitor.prototype.STRING = function(string) {
+  return '"' + string.string + '"';
+};
+
+Handlebars.PrintVisitor.prototype.INTEGER = function(integer) {
+  return "INTEGER{" + integer.integer + "}";
+};
+
+Handlebars.PrintVisitor.prototype.BOOLEAN = function(bool) {
+  return "BOOLEAN{" + bool.bool + "}";
+};
+
+Handlebars.PrintVisitor.prototype.ID = function(id) {
+  var path = id.parts.join("/");
+  if(id.parts.length > 1) {
+    return "PATH:" + path;
+  } else {
+    return "ID:" + path;
+  }
+};
+
+Handlebars.PrintVisitor.prototype.DATA = function(data) {
+  return "@" + data.id;
+};
+
+Handlebars.PrintVisitor.prototype.content = function(content) {
+  return this.pad("CONTENT[ '" + content.string + "' ]");
+};
+
+Handlebars.PrintVisitor.prototype.comment = function(comment) {
+  return this.pad("{{! '" + comment.comment + "' }}");
+};
+// END(BROWSER)
+
+return Handlebars;
 };
 
diff --git a/lib/handlebars/compiler/visitor.js b/lib/handlebars/compiler/visitor.js
index 56f262ab..5d073140 100644
--- a/lib/handlebars/compiler/visitor.js
+++ b/lib/handlebars/compiler/visitor.js
@@ -1,20 +1,18 @@
-
 exports.attach = function(Handlebars) {
 
-	// BEGIN(BROWSER)
+// BEGIN(BROWSER)
 
-	Handlebars.Visitor = function() {};
+Handlebars.Visitor = function() {};
 
-	Handlebars.Visitor.prototype = {
-	  accept: function(object) {
-	    return this[object.type](object);
-	  }
-	};
+Handlebars.Visitor.prototype = {
+  accept: function(object) {
+    return this[object.type](object);
+  }
+};
 
-	// END(BROWSER)
-
-	return Handlebars;
+// END(BROWSER)
 
+return Handlebars;
 };
 
 
diff --git a/lib/handlebars/runtime.js b/lib/handlebars/runtime.js
index edf10257..6fd38fd9 100644
--- a/lib/handlebars/runtime.js
+++ b/lib/handlebars/runtime.js
@@ -1,72 +1,72 @@
 exports.attach = function(Handlebars) {
 
-  // BEGIN(BROWSER)
-  
-  Handlebars.VM = {
-    template: function(templateSpec) {
-      // Just add water
-      var container = {
-        escapeExpression: Handlebars.Utils.escapeExpression,
-        invokePartial: Handlebars.VM.invokePartial,
-        programs: [],
-        program: function(i, fn, data) {
-          var programWrapper = this.programs[i];
-          if(data) {
-            return Handlebars.VM.program(fn, data);
-          } else if(programWrapper) {
-            return programWrapper;
-          } else {
-            programWrapper = this.programs[i] = Handlebars.VM.program(fn);
-            return programWrapper;
-          }
-        },
-        programWithDepth: Handlebars.VM.programWithDepth,
-        noop: Handlebars.VM.noop
-      };
+// BEGIN(BROWSER)
 
-      return function(context, options) {
-        options = options || {};
-        return templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
-      };
-    },
+Handlebars.VM = {
+  template: function(templateSpec) {
+    // Just add water
+    var container = {
+      escapeExpression: Handlebars.Utils.escapeExpression,
+      invokePartial: Handlebars.VM.invokePartial,
+      programs: [],
+      program: function(i, fn, data) {
+        var programWrapper = this.programs[i];
+        if(data) {
+          return Handlebars.VM.program(fn, data);
+        } else if(programWrapper) {
+          return programWrapper;
+        } else {
+          programWrapper = this.programs[i] = Handlebars.VM.program(fn);
+          return programWrapper;
+        }
+      },
+      programWithDepth: Handlebars.VM.programWithDepth,
+      noop: Handlebars.VM.noop
+    };
 
-    programWithDepth: function(fn, data, $depth) {
-      var args = Array.prototype.slice.call(arguments, 2);
+    return function(context, options) {
+      options = options || {};
+      return templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
+    };
+  },
 
-      return function(context, options) {
-        options = options || {};
+  programWithDepth: function(fn, data, $depth) {
+    var args = Array.prototype.slice.call(arguments, 2);
 
-        return fn.apply(this, [context, options.data || data].concat(args));
-      };
-    },
-    program: function(fn, data) {
-      return function(context, options) {
-        options = options || {};
+    return function(context, options) {
+      options = options || {};
 
-        return fn(context, options.data || data);
-      };
-    },
-    noop: function() { return ""; },
-    invokePartial: function(partial, name, context, helpers, partials, data) {
-      var options = { helpers: helpers, partials: partials, data: data };
+      return fn.apply(this, [context, options.data || data].concat(args));
+    };
+  },
+  program: function(fn, data) {
+    return function(context, options) {
+      options = options || {};
 
-      if(partial === undefined) {
-        throw new Handlebars.Exception("The partial " + name + " could not be found");
-      } else if(partial instanceof Function) {
-        return partial(context, options);
-      } else if (!Handlebars.compile) {
-        throw new Handlebars.Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
-      } else {
-        partials[name] = Handlebars.compile(partial);
-        return partials[name](context, options);
-      }
+      return fn(context, options.data || data);
+    };
+  },
+  noop: function() { return ""; },
+  invokePartial: function(partial, name, context, helpers, partials, data) {
+    var options = { helpers: helpers, partials: partials, data: data };
+
+    if(partial === undefined) {
+      throw new Handlebars.Exception("The partial " + name + " could not be found");
+    } else if(partial instanceof Function) {
+      return partial(context, options);
+    } else if (!Handlebars.compile) {
+      throw new Handlebars.Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
+    } else {
+      partials[name] = Handlebars.compile(partial);
+      return partials[name](context, options);
     }
-  };
+  }
+};
 
-  Handlebars.template = Handlebars.VM.template;
+Handlebars.template = Handlebars.VM.template;
 
-  // END(BROWSER)
+// END(BROWSER)
 
-  return Handlebars;
+return Handlebars;
 
 };
\ No newline at end of file
diff --git a/lib/handlebars/utils.js b/lib/handlebars/utils.js
index 0aa89b84..d467205a 100644
--- a/lib/handlebars/utils.js
+++ b/lib/handlebars/utils.js
@@ -1,72 +1,72 @@
 exports.attach = function(Handlebars) {
 
-  // BEGIN(BROWSER)
+// BEGIN(BROWSER)
 
-  Handlebars.Exception = function(message) {
-    var tmp = Error.prototype.constructor.apply(this, arguments);
+Handlebars.Exception = function(message) {
+  var tmp = Error.prototype.constructor.apply(this, arguments);
 
-    for (var p in tmp) {
-      if (tmp.hasOwnProperty(p)) { this[p] = tmp[p]; }
-    }
+  for (var p in tmp) {
+    if (tmp.hasOwnProperty(p)) { this[p] = tmp[p]; }
+  }
 
-    this.message = tmp.message;
-  };
-  Handlebars.Exception.prototype = new Error();
-
-  // Build out our basic SafeString type
-  Handlebars.SafeString = function(string) {
-    this.string = string;
-  };
-  Handlebars.SafeString.prototype.toString = function() {
-    return this.string.toString();
-  };
-
-  (function() {
-    var escape = {
-      "<": "&lt;",
-      ">": "&gt;",
-      '"': "&quot;",
-      "'": "&#x27;",
-      "`": "&#x60;"
-    };
-
-    var badChars = /&(?!\w+;)|[<>"'`]/g;
-    var possible = /[&<>"'`]/;
-
-    var escapeChar = function(chr) {
-      return escape[chr] || "&amp;";
-    };
-
-    Handlebars.Utils = {
-      escapeExpression: function(string) {
-        // don't escape SafeStrings, since they're already safe
-        if (string instanceof Handlebars.SafeString) {
-          return string.toString();
-        } else if (string == null || string === false) {
-          return "";
-        }
-
-        if(!possible.test(string)) { return string; }
-        return string.replace(badChars, escapeChar);
-      },
-
-      isEmpty: function(value) {
-        if (typeof value === "undefined") {
-          return true;
-        } else if (value === null) {
-          return true;
-        } else if (value === false) {
-          return true;
-        } else if(Object.prototype.toString.call(value) === "[object Array]" && value.length === 0) {
-          return true;
-        } else {
-          return false;
-        }
-      }
-    };
-  })();
-
-  // END(BROWSER)
-
-  return Handlebars;
+  this.message = tmp.message;
+};
+Handlebars.Exception.prototype = new Error();
+
+// Build out our basic SafeString type
+Handlebars.SafeString = function(string) {
+  this.string = string;
+};
+Handlebars.SafeString.prototype.toString = function() {
+  return this.string.toString();
+};
+
+(function() {
+  var escape = {
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#x27;",
+    "`": "&#x60;"
+  };
+
+  var badChars = /&(?!\w+;)|[<>"'`]/g;
+  var possible = /[&<>"'`]/;
+
+  var escapeChar = function(chr) {
+    return escape[chr] || "&amp;";
+  };
+
+  Handlebars.Utils = {
+    escapeExpression: function(string) {
+      // don't escape SafeStrings, since they're already safe
+      if (string instanceof Handlebars.SafeString) {
+        return string.toString();
+      } else if (string == null || string === false) {
+        return "";
+      }
+
+      if(!possible.test(string)) { return string; }
+      return string.replace(badChars, escapeChar);
+    },
+
+    isEmpty: function(value) {
+      if (typeof value === "undefined") {
+        return true;
+      } else if (value === null) {
+        return true;
+      } else if (value === false) {
+        return true;
+      } else if(Object.prototype.toString.call(value) === "[object Array]" && value.length === 0) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+  };
+})();
+
+// END(BROWSER)
+
+return Handlebars;
 };