From 7c4813b417eaf4b9aab597dcd618857b8419f301 Mon Sep 17 00:00:00 2001
From: Tommy Messbauer <tommy@vast.com>
Date: Wed, 29 Aug 2012 12:48:22 -0500
Subject: [PATCH 1/5] Commiting initial factory code

---
 lib/handlebars.js                   |   28 +-
 lib/handlebars/base.js              |  190 +--
 lib/handlebars/compiler/ast.js      |    7 +-
 lib/handlebars/compiler/base.js     |   49 +-
 lib/handlebars/compiler/compiler.js | 1999 ++++++++++++++-------------
 lib/handlebars/compiler/index.js    |   19 +-
 lib/handlebars/compiler/printer.js  |  229 +--
 lib/handlebars/compiler/visitor.js  |   23 +-
 lib/handlebars/runtime.js           |  118 +-
 lib/handlebars/utils.js             |  130 +-
 10 files changed, 1425 insertions(+), 1367 deletions(-)

diff --git a/lib/handlebars.js b/lib/handlebars.js
index 8705269c..78244969 100644
--- a/lib/handlebars.js
+++ b/lib/handlebars.js
@@ -1,14 +1,32 @@
-var Handlebars = require("./handlebars/base");
-module.exports = Handlebars;
+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)
-require("./handlebars/utils");
+	utils = require("./handlebars/utils"),
+	compiler = require("./handlebars/compiler"),
+	runtime = require("./handlebars/runtime");
 
-require("./handlebars/compiler");
-require("./handlebars/runtime");
+var create = function() {
+	var hb = handlebars.create();
+
+	utils.attach(hb);
+	compiler.attach(hb);
+	runtime.attach(hb);
+
+	return hb;
+};
+
+var Handlebars = create();
+Handlebars.create = create;
+
+module.exports = Handlebars; // instantiate an instance
 
 // BEGIN(BROWSER)
 
 // END(BROWSER)
 
+// USAGE:
+// var handlebars = require('handlebars');
+
+// var singleton = handlebars.Handlebars,
+// 	local = handlebars.create();
diff --git a/lib/handlebars/base.js b/lib/handlebars/base.js
index ca4b1596..656f0fb9 100644
--- a/lib/handlebars/base.js
+++ b/lib/handlebars/base.js
@@ -1,119 +1,119 @@
-// BEGIN(BROWSER)
+module.exports.create = function() {
 
-/*jshint eqnull:true*/
-this.Handlebars = {};
+  // BEGIN(BROWSER)
 
-(function(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) {
+    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) {
       for(var i=0, j=context.length; i<j; i++) {
-        ret = ret + fn(context[i]);
+        if (data) { data.index = i; }
+        ret = ret + fn(context[i], { data: data });
       }
     } else {
       ret = inverse(this);
     }
     return ret;
-  } else {
-    return fn(context);
-  }
-});
+  });
 
-Handlebars.K = function() {};
+  Handlebars.registerHelper('if', function(context, options) {
+    var type = toString.call(context);
+    if(type === functionType) { context = context.call(this); }
+
+    if(!context || Handlebars.Utils.isEmpty(context)) {
+      return options.inverse(this);
+    } else {
+      return options.fn(this);
+    }
+  });
+
+  Handlebars.registerHelper('unless', function(context, options) {
+    var fn = options.fn, inverse = options.inverse;
+    options.fn = inverse;
+    options.inverse = fn;
+
+    return Handlebars.helpers['if'].call(this, context, options);
+  });
+
+  Handlebars.registerHelper('with', function(context, options) {
+    return options.fn(context);
+  });
+
+  Handlebars.registerHelper('log', function(context) {
+    Handlebars.log(context);
+  });
+
+  // END(BROWSER)
+  
+  return Handlebars;
 
-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('if', function(context, options) {
-  var type = toString.call(context);
-  if(type === functionType) { context = context.call(this); }
-
-  if(!context || Handlebars.Utils.isEmpty(context)) {
-    return options.inverse(this);
-  } else {
-    return options.fn(this);
-  }
-});
-
-Handlebars.registerHelper('unless', function(context, options) {
-  var fn = options.fn, inverse = options.inverse;
-  options.fn = inverse;
-  options.inverse = fn;
-
-  return Handlebars.helpers['if'].call(this, context, options);
-});
-
-Handlebars.registerHelper('with', function(context, options) {
-  return options.fn(context);
-});
-
-Handlebars.registerHelper('log', function(context) {
-  Handlebars.log(context);
-});
-
-}(this.Handlebars));
-
-// END(BROWSER)
-
-module.exports = this.Handlebars;
 
diff --git a/lib/handlebars/compiler/ast.js b/lib/handlebars/compiler/ast.js
index 25abe0a3..d6f5ee0d 100644
--- a/lib/handlebars/compiler/ast.js
+++ b/lib/handlebars/compiler/ast.js
@@ -1,7 +1,6 @@
-var Handlebars = require('./base');
 
 // BEGIN(BROWSER)
-(function() {
+exports.attach = function(Handlebars) {
 
   Handlebars.AST = {};
 
@@ -118,6 +117,8 @@ var Handlebars = require('./base');
     this.comment = comment;
   };
 
-})();
+  return Handlebars;
+};
+
 // END(BROWSER)
 
diff --git a/lib/handlebars/compiler/base.js b/lib/handlebars/compiler/base.js
index 4bb87350..1f97c0ba 100644
--- a/lib/handlebars/compiler/base.js
+++ b/lib/handlebars/compiler/base.js
@@ -1,27 +1,30 @@
 var handlebars = require("./parser").parser;
-var Handlebars = require("../base");
 
-// BEGIN(BROWSER)
-Handlebars.Parser = handlebars;
+exports.attach = function(Handlebars) {
 
-Handlebars.parse = function(string) {
-  Handlebars.Parser.yy = Handlebars.AST;
-  return Handlebars.Parser.parse(string);
+	// BEGIN(BROWSER)
+	
+	Handlebars.Parser = handlebars;
+
+	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)
 };
-
-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); };
-
-// END(BROWSER)
-
-module.exports = Handlebars;
diff --git a/lib/handlebars/compiler/compiler.js b/lib/handlebars/compiler/compiler.js
index 108d0551..51582947 100644
--- a/lib/handlebars/compiler/compiler.js
+++ b/lib/handlebars/compiler/compiler.js
@@ -1,1066 +1,1075 @@
-var Handlebars = require("./base");
+
+
+
+exports.attach = function(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") + "\"";
+          if (opcode.opcode === 'DECLARE') {
+            out.push("DECLARE " + opcode.name + "=" + opcode.value);
+          } else {
+            params = [];
+            for (var j=0; j<opcode.args.length; j++) {
+              param = opcode.args[j];
+              if (typeof param === "string") {
+                param = "\"" + param.replace("\n", "\\n") + "\"";
+              }
+              params.push(param);
             }
-            params.push(param);
+            out.push(opcode.opcode + " " + params.join(" "));
           }
-          out.push(opcode.opcode + " " + params.join(" "));
         }
-      }
 
-      return out.join("\n");
-    },
+        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);
+        if (type === "helper") {
+          this.helperMustache(mustache, program, inverse);
+        } else if (type === "simple") {
+          this.simpleMustache(mustache);
 
-        // now that the simple mustache is resolved, we need to
-        // evaluate it by executing `blockHelperMissing`
-        this.opcode('pushProgram', program);
-        this.opcode('pushProgram', inverse);
-        this.opcode('pushLiteral', '{}');
-        this.opcode('blockValue');
-      } else {
-        this.ambiguousMustache(mustache, program, inverse);
+          // now that the simple mustache is resolved, we need to
+          // evaluate it by executing `blockHelperMissing`
+          this.opcode('pushProgram', program);
+          this.opcode('pushProgram', inverse);
+          this.opcode('pushLiteral', '{}');
+          this.opcode('blockValue');
+        } else {
+          this.ambiguousMustache(mustache, program, inverse);
 
-        // now that the simple mustache is resolved, we need to
-        // evaluate it by executing `blockHelperMissing`
-        this.opcode('pushProgram', program);
-        this.opcode('pushProgram', inverse);
-        this.opcode('pushLiteral', '{}');
-        this.opcode('ambiguousBlockValue');
-      }
+          // now that the simple mustache is resolved, we need to
+          // evaluate it by executing `blockHelperMissing`
+          this.opcode('pushProgram', program);
+          this.opcode('pushProgram', inverse);
+          this.opcode('pushLiteral', '{}');
+          this.opcode('ambiguousBlockValue');
+        }
 
-      this.opcode('append');
-    },
-
-    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];
+      hash: function(hash) {
+        var pairs = hash.pairs, pair, val;
 
-      this.opcode('getContext', id.depth);
+        this.opcode('push', '{}');
 
-      this.opcode('pushProgram', program);
-      this.opcode('pushProgram', inverse);
+        for(var i=0, l=pairs.length; i<l; i++) {
+          pair = pairs[i];
+          val  = pair[1];
 
-      this.opcode('invokeAmbiguous', name);
-    },
+          this.accept(val);
+          this.opcode('assignToHash', pair[0]);
+        }
+      },
 
-    simpleMustache: function(mustache, program, inverse) {
-      var id = mustache.id;
+      partial: function(partial) {
+        var id = partial.id;
+        this.usePartial = true;
 
-      if (id.type === 'DATA') {
-        this.DATA(id);
-      } else if (id.parts.length) {
-        this.ID(id);
-      } else {
-        // Simplified ID for `this`
+        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);
+          this.opcode('pushContext');
+        }
+
+        this.opcode('resolvePossibleLambda');
+      },
+
+      helperMustache: function(mustache, program, inverse) {
+        var params = this.setupFullMustacheParams(mustache, program, inverse),
+            name = mustache.id.parts[0];
+
+        if (this.options.knownHelpers[name]) {
+          this.opcode('invokeKnownHelper', params.length, name);
+        } else if (this.knownHelpersOnly) {
+          throw new Error("You specified knownHelpersOnly, but used the unknown helper " + name);
+        } else {
+          this.opcode('invokeHelper', params.length, name);
+        }
+      },
+
+      ID: function(id) {
         this.addDepth(id.depth);
         this.opcode('getContext', id.depth);
-        this.opcode('pushContext');
-      }
 
-      this.opcode('resolvePossibleLambda');
-    },
-
-    helperMustache: function(mustache, program, inverse) {
-      var params = this.setupFullMustacheParams(mustache, program, inverse),
-          name = mustache.id.parts[0];
-
-      if (this.options.knownHelpers[name]) {
-        this.opcode('invokeKnownHelper', params.length, name);
-      } else if (this.knownHelpersOnly) {
-        throw new Error("You specified knownHelpersOnly, but used the unknown helper " + name);
-      } else {
-        this.opcode('invokeHelper', params.length, name);
-      }
-    },
-
-    ID: function(id) {
-      this.addDepth(id.depth);
-      this.opcode('getContext', id.depth);
-
-      var name = id.parts[0];
-      if (!name) {
-        this.opcode('pushContext');
-      } else {
-        this.opcode('lookupOnContext', id.parts[0]);
-      }
-
-      for(var i=1, l=id.parts.length; i<l; i++) {
-        this.opcode('lookup', id.parts[i]);
-      }
-    },
-
-    DATA: function(data) {
-      this.options.data = true;
-      this.opcode('lookupData', data.id);
-    },
-
-    STRING: function(string) {
-      this.opcode('pushString', string.string);
-    },
-
-    INTEGER: function(integer) {
-      this.opcode('pushLiteral', integer.integer);
-    },
-
-    BOOLEAN: function(bool) {
-      this.opcode('pushLiteral', bool.bool);
-    },
-
-    comment: function() {},
-
-    // HELPERS
-    opcode: function(name) {
-      this.opcodes.push({ opcode: name, args: [].slice.call(arguments, 1) });
-    },
-
-    declare: function(name, value) {
-      this.opcodes.push({ opcode: 'DECLARE', name: name, value: value });
-    },
-
-    addDepth: function(depth) {
-      if(isNaN(depth)) { throw new Error("EWOT"); }
-      if(depth === 0) { return; }
-
-      if(!this.depths[depth]) {
-        this.depths[depth] = true;
-        this.depths.list.push(depth);
-      }
-    },
-
-    classifyMustache: function(mustache) {
-      var isHelper   = mustache.isHelper;
-      var isEligible = mustache.eligibleHelper;
-      var options    = this.options;
-
-      // if ambiguous, we can possibly resolve the ambiguity now
-      if (isEligible && !isHelper) {
-        var name = mustache.id.parts[0];
-
-        if (options.knownHelpers[name]) {
-          isHelper = true;
-        } else if (options.knownHelpersOnly) {
-          isEligible = false;
+        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;
       }
+    };
 
-      if (isHelper) { return "helper"; }
-      else if (isEligible) { return "ambiguous"; }
-      else { return "simple"; }
-    },
+    var Literal = function(value) {
+      this.value = value;
+    };
 
-    pushParams: function(params) {
-      var i = params.length, param;
+    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 + "']";
+        }
+      },
 
-      while(i--) {
-        param = params[i];
+      appendToBuffer: function(string) {
+        if (this.environment.isSimple) {
+          return "return " + string + ";";
+        } else {
+          return "buffer += " + string + ";";
+        }
+      },
 
-        if(this.options.stringParams) {
-          if(param.depth) {
-            this.addDepth(param.depth);
+      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";
           }
 
-          this.opcode('getContext', param.depth || 0);
-          this.opcode('pushStringParam', param.string);
-        } else {
-          this[param.type](param);
+          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(", ");
       }
-    },
+    };
 
-    setupMustacheParams: function(mustache) {
-      var params = mustache.params;
-      this.pushParams(params);
+    var reservedWords = (
+      "break else new var" +
+      " case finally return void" +
+      " catch for switch while" +
+      " continue function this with" +
+      " default if throw" +
+      " delete in try" +
+      " do instanceof typeof" +
+      " abstract enum int short" +
+      " boolean export interface static" +
+      " byte extends long super" +
+      " char final native synchronized" +
+      " class float package throws" +
+      " const goto private transient" +
+      " debugger implements protected volatile" +
+      " double import public let yield"
+    ).split(" ");
 
-      if(mustache.hash) {
-        this.hash(mustache.hash);
-      } else {
-        this.opcode('pushLiteral', '{}');
-      }
+    var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {};
 
-      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;
+    for(var i=0, l=reservedWords.length; i<l; i++) {
+      compilerWords[reservedWords[i]] = 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;
+    JavaScriptCompiler.isValidJavaScriptVariableName = function(name) {
+      if(!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]+$/.test(name)) {
+        return true;
       }
-      else {
-        return parent + "['" + name + "']";
-      }
-    },
+      return false;
+    };
 
-    appendToBuffer: function(string) {
-      if (this.environment.isSimple) {
-        return "return " + string + ";";
-      } else {
-        return "buffer += " + string + ";";
-      }
-    },
+  })(Handlebars.Compiler, Handlebars.JavaScriptCompiler);
 
-    initializeBuffer: function() {
-      return this.quotedString("");
-    },
+  Handlebars.precompile = function(string, options) {
+    options = options || {};
 
-    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);
-    var templateSpec = new Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true);
-    return Handlebars.template(templateSpec);
-  }
-
-  // Template is only compiled on first use and cached after that point.
-  return function(context, options) {
-    if (!compiled) {
-      compiled = compile();
-    }
-    return compiled.call(this, context, options);
+    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);
+      var templateSpec = new Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true);
+      return Handlebars.template(templateSpec);
+    }
+
+    // Template is only compiled on first use and cached after that point.
+    return function(context, options) {
+      if (!compiled) {
+        compiled = compile();
+      }
+      return compiled.call(this, context, options);
+    };
+  };
+
+
+  // END(BROWSER)
+
+  return Handlebars;
+
 };
 
-// END(BROWSER)
 
diff --git a/lib/handlebars/compiler/index.js b/lib/handlebars/compiler/index.js
index e62c7684..ce8e9869 100644
--- a/lib/handlebars/compiler/index.js
+++ b/lib/handlebars/compiler/index.js
@@ -1,7 +1,16 @@
 // Each of these module will augment the Handlebars object as it loads. No need to perform addition operations
-module.exports = require("./base");
-require("./visitor");
-require("./printer");
+module.exports.attach = function(Handlebars) {
 
-require("./ast");
-require("./compiler");
+var visitor = require("./visitor"),
+	printer = require("./printer"),
+	ast = require("./ast"),
+	compiler = require("./compiler");
+
+visitor.attach(Handlebars);
+printer.attach(Handlebars);
+ast.attach(Handlebars);
+compiler.attach(Handlebars);
+
+return Handlebars;
+
+};
diff --git a/lib/handlebars/compiler/printer.js b/lib/handlebars/compiler/printer.js
index 7a42a667..f5b83092 100644
--- a/lib/handlebars/compiler/printer.js
+++ b/lib/handlebars/compiler/printer.js
@@ -1,127 +1,130 @@
-var Handlebars = require("./base");
+exports.attach = function(Handlebars) {
 
-// BEGIN(BROWSER)
-Handlebars.PrintVisitor = function() { this.padding = 0; };
-Handlebars.PrintVisitor.prototype = new Handlebars.Visitor();
+  // BEGIN(BROWSER)
+  
+  Handlebars.PrintVisitor = function() { this.padding = 0; };
+  Handlebars.PrintVisitor.prototype = new Handlebars.Visitor();
 
-Handlebars.PrintVisitor.prototype.pad = function(string, newline) {
-  var out = "";
+  Handlebars.PrintVisitor.prototype.pad = function(string, newline) {
+    var out = "";
 
-  for(var i=0,l=this.padding; i<l; i++) {
-    out = out + "  ";
-  }
+    for(var i=0,l=this.padding; i<l; i++) {
+      out = out + "  ";
+    }
 
-  out = out + string;
+    out = out + string;
 
-  if(newline !== false) { out = out + "\n"; }
-  return out;
-};
+    if(newline !== false) { out = out + "\n"; }
+    return out;
+  };
 
-Handlebars.PrintVisitor.prototype.program = function(program) {
-  var out = "",
-      statements = program.statements,
-      inverse = program.inverse,
-      i, l;
+  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]);
-  }
+    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("{{^}}");
+
+    return out;
+  };
+
+  Handlebars.PrintVisitor.prototype.block = function(block) {
+    var out = "";
+
+    out = out + this.pad("BLOCK:");
     this.padding++;
-    out = out + this.accept(block.inverse);
+    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--;
-    if (block.program) { this.padding--; }
-  }
-  this.padding--;
 
-  return out;
+    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;
 };
 
-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)
-
-exports.PrintVisitor = Handlebars.PrintVisitor;
diff --git a/lib/handlebars/compiler/visitor.js b/lib/handlebars/compiler/visitor.js
index a557dd3d..56f262ab 100644
--- a/lib/handlebars/compiler/visitor.js
+++ b/lib/handlebars/compiler/visitor.js
@@ -1,13 +1,20 @@
-var Handlebars = require("./base");
 
-// BEGIN(BROWSER)
+exports.attach = function(Handlebars) {
 
-Handlebars.Visitor = function() {};
+	// BEGIN(BROWSER)
+
+	Handlebars.Visitor = function() {};
+
+	Handlebars.Visitor.prototype = {
+	  accept: function(object) {
+	    return this[object.type](object);
+	  }
+	};
+
+	// END(BROWSER)
+
+	return Handlebars;
 
-Handlebars.Visitor.prototype = {
-  accept: function(object) {
-    return this[object.type](object);
-  }
 };
-// END(BROWSER)
+
 
diff --git a/lib/handlebars/runtime.js b/lib/handlebars/runtime.js
index eb6d7570..edf10257 100644
--- a/lib/handlebars/runtime.js
+++ b/lib/handlebars/runtime.js
@@ -1,68 +1,72 @@
-var Handlebars = require("./base");
+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)
+  
+  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
+      };
 
-    return function(context, options) {
-      options = options || {};
-      return templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
-    };
-  },
+      return function(context, options) {
+        options = options || {};
+        return templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
+      };
+    },
 
-  programWithDepth: function(fn, data, $depth) {
-    var args = Array.prototype.slice.call(arguments, 2);
+    programWithDepth: function(fn, data, $depth) {
+      var args = Array.prototype.slice.call(arguments, 2);
 
-    return function(context, options) {
-      options = options || {};
+      return function(context, options) {
+        options = options || {};
 
-      return fn.apply(this, [context, options.data || data].concat(args));
-    };
-  },
-  program: function(fn, data) {
-    return function(context, options) {
-      options = options || {};
+        return fn.apply(this, [context, options.data || data].concat(args));
+      };
+    },
+    program: function(fn, data) {
+      return function(context, options) {
+        options = options || {};
 
-      return fn(context, options.data || data);
-    };
-  },
-  noop: function() { return ""; },
-  invokePartial: function(partial, name, context, helpers, partials, data) {
-    var options = { helpers: helpers, partials: partials, data: data };
+        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);
+      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;
+
+};
\ No newline at end of file
diff --git a/lib/handlebars/utils.js b/lib/handlebars/utils.js
index bd5d0eb8..0aa89b84 100644
--- a/lib/handlebars/utils.js
+++ b/lib/handlebars/utils.js
@@ -1,68 +1,72 @@
-var Handlebars = require("./base");
+exports.attach = function(Handlebars) {
 
-// BEGIN(BROWSER)
-Handlebars.Exception = function(message) {
-  var tmp = Error.prototype.constructor.apply(this, arguments);
+  // BEGIN(BROWSER)
 
-  for (var p in tmp) {
-    if (tmp.hasOwnProperty(p)) { this[p] = tmp[p]; }
-  }
+  Handlebars.Exception = function(message) {
+    var tmp = Error.prototype.constructor.apply(this, arguments);
 
-  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;
-      }
+    for (var p in tmp) {
+      if (tmp.hasOwnProperty(p)) { this[p] = tmp[p]; }
     }
-  };
-})();
-// END(BROWSER)
 
+    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;
+};

From eccc7c35ca3221b0a168485d5c323d6054958a3e Mon Sep 17 00:00:00 2001
From: Tommy Messbauer <tommy@vast.com>
Date: Wed, 29 Aug 2012 15:07:15 -0500
Subject: [PATCH 2/5] Finished factory pattern

---
 lib/handlebars/compiler/base.js     | 2 +-
 lib/handlebars/compiler/compiler.js | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/lib/handlebars/compiler/base.js b/lib/handlebars/compiler/base.js
index 1f97c0ba..28150d9d 100644
--- a/lib/handlebars/compiler/base.js
+++ b/lib/handlebars/compiler/base.js
@@ -1,7 +1,7 @@
 var handlebars = require("./parser").parser;
 
 exports.attach = function(Handlebars) {
-
+	
 	// BEGIN(BROWSER)
 	
 	Handlebars.Parser = handlebars;
diff --git a/lib/handlebars/compiler/compiler.js b/lib/handlebars/compiler/compiler.js
index 51582947..33bf1208 100644
--- a/lib/handlebars/compiler/compiler.js
+++ b/lib/handlebars/compiler/compiler.js
@@ -1,8 +1,9 @@
-
-
+var compilerbase = require("./base");
 
 exports.attach = function(Handlebars) {
 
+  compilerbase.attach(Handlebars);
+
 // BEGIN(BROWSER)
 
   /*jshint eqnull:true*/

From 79632184953284603b64a3179d087ebcda9d0ab6 Mon Sep 17 00:00:00 2001
From: Tommy Messbauer <tommy@vast.com>
Date: Mon, 26 Nov 2012 09:39:08 -0600
Subject: [PATCH 3/5] Factory update with tabs to spaces.. sorry :(

---
 lib/handlebars.js                   |   18 +-
 lib/handlebars/base.js              |  170 +--
 lib/handlebars/compiler/ast.js      |  186 +--
 lib/handlebars/compiler/base.js     |   46 +-
 lib/handlebars/compiler/compiler.js | 2002 +++++++++++++--------------
 lib/handlebars/compiler/index.js    |    6 +-
 lib/handlebars/compiler/printer.js  |  242 ++--
 lib/handlebars/compiler/visitor.js  |   20 +-
 lib/handlebars/runtime.js           |  116 +-
 lib/handlebars/utils.js             |  132 +-
 10 files changed, 1469 insertions(+), 1469 deletions(-)

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;
 };

From 514c9391e0fbee8a0c8c184bcef77d6be38722aa Mon Sep 17 00:00:00 2001
From: Tommy Messbauer <tommy@vast.com>
Date: Mon, 11 Feb 2013 22:50:23 -0600
Subject: [PATCH 4/5] restored scope of var verifyMatch

---
 lib/handlebars/compiler/ast.js | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/lib/handlebars/compiler/ast.js b/lib/handlebars/compiler/ast.js
index 9648ef07..27cd6cc1 100644
--- a/lib/handlebars/compiler/ast.js
+++ b/lib/handlebars/compiler/ast.js
@@ -41,13 +41,13 @@ Handlebars.AST.PartialNode = function(id, context) {
   this.context = context;
 };
 
-var verifyMatch = function(open, close) {
-  if(open.original !== close.original) {
-    throw new Handlebars.Exception(open.original + " doesn't match " + close.original);
-  }
-};
-
 Handlebars.AST.BlockNode = function(mustache, program, inverse, close) {
+  var verifyMatch = function(open, close) {
+    if(open.original !== close.original) {
+      throw new Handlebars.Exception(open.original + " doesn't match " + close.original);
+    }
+  };
+
   verifyMatch(mustache.id, close);
   this.type = "block";
   this.mustache = mustache;

From 7f9e3fea8126ec0111946cd4e4ffa088d29c0768 Mon Sep 17 00:00:00 2001
From: Tommy Messbauer <tommy@vast.com>
Date: Mon, 11 Feb 2013 23:13:37 -0600
Subject: [PATCH 5/5] tests passing

---
 dist/handlebars.js              | 25 ++++++++++++-------------
 lib/handlebars/base.js          |  2 +-
 lib/handlebars/compiler/base.js |  2 +-
 3 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/dist/handlebars.js b/dist/handlebars.js
index c6b8e719..a2789feb 100644
--- a/dist/handlebars.js
+++ b/dist/handlebars.js
@@ -24,10 +24,7 @@ THE SOFTWARE.
 
 // lib/handlebars/base.js
 
-/*jshint eqnull:true*/
-this.Handlebars = {};
-
-(function(Handlebars) {
+var Handlebars = {};
 
 Handlebars.VERSION = "1.0.rc.2";
 Handlebars.COMPILER_REVISION = 2;
@@ -169,8 +166,6 @@ Handlebars.registerHelper('log', function(context, options) {
   var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
   Handlebars.log(level, context);
 });
-
-}(this.Handlebars));
 ;
 // lib/handlebars/compiler/parser.js
 /* Jison generated parser */
@@ -646,6 +641,7 @@ function Parser () { this.yy = {}; }Parser.prototype = parser;parser.Parser = Pa
 return new Parser;
 })();;
 // lib/handlebars/compiler/base.js
+
 Handlebars.Parser = handlebars;
 
 Handlebars.parse = function(input) {
@@ -699,13 +695,13 @@ Handlebars.print = function(ast) {
     this.context      = context;
   };
 
-  var verifyMatch = function(open, close) {
-    if(open.original !== close.original) {
-      throw new Handlebars.Exception(open.original + " doesn't match " + close.original);
-    }
-  };
-
   Handlebars.AST.BlockNode = function(mustache, program, inverse, close) {
+    var verifyMatch = function(open, close) {
+      if(open.original !== close.original) {
+        throw new Handlebars.Exception(open.original + " doesn't match " + close.original);
+      }
+    };
+
     verifyMatch(mustache.id, close);
     this.type = "block";
     this.mustache = mustache;
@@ -851,7 +847,8 @@ Handlebars.SafeString.prototype.toString = function() {
       }
     }
   };
-})();;
+})();
+;
 // lib/handlebars/compiler/compiler.js
 
 /*jshint eqnull:true*/
@@ -2114,8 +2111,10 @@ Handlebars.compile = function(input, options) {
     return compiled.call(this, context, options);
   };
 };
+
 ;
 // lib/handlebars/runtime.js
+
 Handlebars.VM = {
   template: function(templateSpec) {
     // Just add water
diff --git a/lib/handlebars/base.js b/lib/handlebars/base.js
index 32436869..63f4d135 100644
--- a/lib/handlebars/base.js
+++ b/lib/handlebars/base.js
@@ -147,7 +147,7 @@ Handlebars.registerHelper('log', function(context, options) {
 
 // END(BROWSER)
   
-  return Handlebars;
+return Handlebars;
 
 };
 
diff --git a/lib/handlebars/compiler/base.js b/lib/handlebars/compiler/base.js
index 791f56cb..8ff1101d 100644
--- a/lib/handlebars/compiler/base.js
+++ b/lib/handlebars/compiler/base.js
@@ -1,4 +1,4 @@
-var handlebars = require("./parser").parser;
+var handlebars = require("./parser");
 
 exports.attach = function(Handlebars) {