1.0.12

Update to 1.0.0 final
Merge global and passed helpers and partials
2013-05-31 14:16:53 -04:00 · 2013-05-31 14:16:45 -04:00 · 2013-05-31 13:12:06 -04:00 · 2013-05-31 13:11:22 -04:00 · 2013-05-30 15:57:15 -04:00 · 2013-05-30 15:47:30 -04:00
40 changed files with 5392 additions and 1375 deletions
@@ -1,8 +1,8 @@
-dist
 vendor
 .rvmrc
 .DS_Store
 lib/handlebars/compiler/parser.js
+dist/*.min.js
 node_modules
 *.sublime-project
 *.sublime-workspace
@@ -5,7 +5,6 @@ Gemfile
 Gemfile.lock
 Rakefile
 bench/*
-dist/*
 spec/*
 src/*
 vendor/*
@@ -1,5 +1,5 @@
 source "http://rubygems.org"

 gem "rake"
-gem "therubyracer", ">= 0.9.8"
+gem "therubyracer", ">= 0.9.8", "< 0.11"
 gem "rspec"
@@ -3,16 +3,16 @@ GEM
  specs:
    diff-lcs (1.1.3)
    libv8 (3.3.10.4)
-    rake (0.9.2.2)
-    rspec (2.11.0)
-      rspec-core (~> 2.11.0)
-      rspec-expectations (~> 2.11.0)
-      rspec-mocks (~> 2.11.0)
-    rspec-core (2.11.0)
-    rspec-expectations (2.11.1)
+    rake (10.0.3)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
      diff-lcs (~> 1.1.3)
-    rspec-mocks (2.11.1)
-    therubyracer (0.10.1)
+    rspec-mocks (2.12.1)
+    therubyracer (0.10.2)
      libv8 (~> 3.3.10)

 PLATFORMS
@@ -21,4 +21,4 @@ PLATFORMS
 DEPENDENCIES
  rake
  rspec
-  therubyracer (>= 0.9.8)
+  therubyracer (>= 0.9.8, < 0.11)
@@ -17,4 +17,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
-
@@ -1,25 +1,35 @@
-[![Build Status](https://secure.travis-ci.org/wycats/handlebars.js.png)](http://travis-ci.org/wycats/handlebars.js)
+[![Build Status](https://travis-ci.org/wycats/handlebars.js.png?branch=master)](https://travis-ci.org/wycats/handlebars.js)

 Handlebars.js
 =============

-Handlebars.js is an extension to the [Mustache templating language](http://mustache.github.com/) created by Chris Wanstrath. Handlebars.js and Mustache are both logicless templating languages that keep the view and the code separated like we all know they should be.
+Handlebars.js is an extension to the [Mustache templating
+language](http://mustache.github.com/) created by Chris Wanstrath.
+Handlebars.js and Mustache are both logicless templating languages that
+keep the view and the code separated like we all know they should be.

-Checkout the official Handlebars docs site at [http://www.handlebarsjs.com](http://www.handlebarsjs.com).
+Checkout the official Handlebars docs site at
+[http://www.handlebarsjs.com](http://www.handlebarsjs.com).


 Installing
 ----------
-Installing Handlebars is easy. Simply [download the package from GitHub](https://github.com/wycats/handlebars.js/archives/master) and add it to your web pages (you should usually use the most recent version).
+Installing Handlebars is easy. Simply download the package [from the
+official site](http://handlebarsjs.com/) and add it to your web pages
+(you should usually use the most recent version).

 Usage
 -----
-In general, the syntax of Handlebars.js templates is a superset of Mustache templates. For basic syntax, check out the [Mustache manpage](http://mustache.github.com/mustache.5.html).
+In general, the syntax of Handlebars.js templates is a superset
+of Mustache templates. For basic syntax, check out the [Mustache
+manpage](http://mustache.github.com/mustache.5.html).

-Once you have a template, use the Handlebars.compile method to compile the template into a function. The generated function takes a context argument, which will be used to render the template.
+Once you have a template, use the `Handlebars.compile` method to compile
+the template into a function. The generated function takes a context
+argument, which will be used to render the template.

 ```js
-var source = "<p>Hello, my name is {{name}}. I am from {{hometown}}. I have " + 
+var source = "<p>Hello, my name is {{name}}. I am from {{hometown}}. I have " +
             "{{kids.length}} kids:</p>" +
             "<ul>{{#kids}}<li>{{name}} is {{age}}</li>{{/kids}}</ul>";
 var template = Handlebars.compile(source);
@@ -45,12 +55,12 @@ template. Here's an example, which assumes that your objects have a URL
 embedded in them, as well as the text for a link:

 ```js
-Handlebars.registerHelper('link_to', function(context) {
-  return "<a href='" + context.url + "'>" + context.body + "</a>";
+Handlebars.registerHelper('link_to', function() {
+  return "<a href='" + this.url + "'>" + this.body + "</a>";
 });

 var context = { posts: [{url: "/hello-world", body: "Hello World!"}] };
-var source = "<ul>{{#posts}}<li>{{{link_to this}}}</li>{{/posts}}</ul>"
+var source = "<ul>{{#posts}}<li>{{{link_to}}}</li>{{/posts}}</ul>"

 var template = Handlebars.compile(source);
 template(context);
@@ -62,6 +72,14 @@ template(context);
 // </ul>
 ```

+Helpers take precedence over fields defined on the context. To access a field
+that is masked by a helper, a path reference may be used. In the example above
+a field named `link_to` on the `context` object would be referenced using:
+
+```
+{{./link_to}}
+```
+
 Escaping
 --------

@@ -75,25 +93,34 @@ To explicitly *not* escape the contents, use the triple-mustache

 Differences Between Handlebars.js and Mustache
 ----------------------------------------------
-Handlebars.js adds a couple of additional features to make writing templates easier and also changes a tiny detail of how partials work.
+Handlebars.js adds a couple of additional features to make writing
+templates easier and also changes a tiny detail of how partials work.

 ### Paths

-Handlebars.js supports an extended expression syntax that we call paths. Paths are made up of typical expressions and . characters. Expressions allow you to not only display data from the current context, but to display data from contexts that are descendents and ancestors of the current context.
+Handlebars.js supports an extended expression syntax that we call paths.
+Paths are made up of typical expressions and . characters. Expressions
+allow you to not only display data from the current context, but to
+display data from contexts that are descendants and ancestors of the
+current context.

-To display data from descendent contexts, use the `.` character. So, for example, if your data were structured like:
+To display data from descendant contexts, use the `.` character. So, for
+example, if your data were structured like:

 ```js
 var data = {"person": { "name": "Alan" }, company: {"name": "Rad, Inc." } };
 ```

-you could display the person's name from the top-level context with the following expression:
+You could display the person's name from the top-level context with the
+following expression:

 ```
 {{person.name}}
 ```

-You can backtrack using `../`. For example, if you've already traversed into the person object you could still display the company's name with an expression like `{{../company.name}}`, so:
+You can backtrack using `../`. For example, if you've already traversed
+into the person object you could still display the company's name with
+an expression like `{{../company.name}}`, so:

 ```
 {{#person}}{{name}} - {{../company.name}}{{/person}}
@@ -111,12 +138,12 @@ When calling a helper, you can pass paths or Strings as parameters. For
 instance:

 ```js
-Handlebars.registerHelper('link_to', function(title, context) {
-  return "<a href='/posts" + context.id + "'>" + title + "</a>"
+Handlebars.registerHelper('link_to', function(title, options) {
+  return "<a href='/posts" + this.url + "'>" + title + "!</a>"
 });

 var context = { posts: [{url: "/hello-world", body: "Hello World!"}] };
-var source = '<ul>{{#posts}}<li>{{{link_to "Post" this}}}</li>{{/posts}}</ul>'
+var source = '<ul>{{#posts}}<li>{{{link_to "Post"}}}</li>{{/posts}}</ul>'

 var template = Handlebars.compile(source);
 template(context);
@@ -124,7 +151,7 @@ template(context);
 // Would render:
 //
 // <ul>
-//   <li><a href='/hello-world'>Post!</a></li>
+//   <li><a href='/posts/hello-world'>Post!</a></li>
 // </ul>
 ```

@@ -134,12 +161,14 @@ gets passed to the helper function.

 ### Block Helpers

-Handlebars.js also adds the ability to define block helpers. Block helpers are functions that can be called from anywhere in the template. Here's an example:
+Handlebars.js also adds the ability to define block helpers. Block
+helpers are functions that can be called from anywhere in the template.
+Here's an example:

 ```js
-var source = "<ul>{{#people}}<li>{{{#link}}}{{name}}{{/link}}</li>{{/people}}</ul>";
-Handlebars.registerHelper('link', function(context, fn) {
-  return '<a href="/people/' + this.__get__("id") + '">' + fn(this) + '</a>';
+var source = "<ul>{{#people}}<li>{{#link}}{{name}}{{/link}}</li>{{/people}}</ul>";
+Handlebars.registerHelper('link', function(options) {
+  return '<a href="/people/' + this.id + '">' + options.fn(this) + '</a>';
 });
 var template = Handlebars.compile(source);

@@ -156,7 +185,18 @@ template(data);
 // </ul>
 ```

-Whenever the block helper is called it is given two parameters, the argument that is passed to the helper, or the current context if no argument is passed and the compiled contents of the block. Inside of the block helper the value of `this` is the current context, wrapped to include a method named `__get__` that helps translate paths into values within the helpers.
+Whenever the block helper is called it is given one or more parameters,
+any arguments that are passed in the helper in the call and an `options`
+object containing the `fn` function which executes the block's child.
+The block's current context may be accessed through `this`.
+
+Block helpers have the same syntax as mustache sections but should not be
+confused with one another. Sections are akin to an implicit `each` or
+`with` statement depending on the input data and helpers are explicit
+pieces of code that are free to implement whatever behavior they like.
+The [mustache spec](http://mustache.github.io/mustache.5.html)
+defines the exact behavior of sections. In the case of name conflicts,
+helpers are given priority.

 ### Partials

@@ -220,6 +260,7 @@ Precompile handlebar templates.
 Usage: handlebars template...

 Options:
+  -a, --amd        Create an AMD format function (allows loading with RequireJS)         [boolean]
  -f, --output     Output File                                                           [string]
  -k, --known      Known helpers                                                         [string]
  -o, --knownOnly  Known helpers only                                                    [boolean]
@@ -228,13 +269,15 @@ Options:
  -r, --root       Template root. Base value that will be stripped from template names.  [string]
 </pre>

-If using the precompiler's normal mode, the resulting templates will be stored
-to the `Handlebars.templates` object using the relative template name sans the
-extension. These templates may be executed in the same manner as templates.
+If using the precompiler's normal mode, the resulting templates will be
+stored to the `Handlebars.templates` object using the relative template
+name sans the extension. These templates may be executed in the same
+manner as templates.

-If using the simple mode the precompiler will generate a single javascript method.
-To execute this method it must be passed to the using the `Handlebars.template`
-method and the resulting object may be as normal.
+If using the simple mode the precompiler will generate a single
+javascript method. To execute this method it must be passed to the using
+the `Handlebars.template` method and the resulting object may be as
+normal.

 ### Optimizations

@@ -247,11 +290,33 @@ method and the resulting object may be as normal.
 - When all helpers are known in advance the `--knownOnly` argument may be used
  to optimize all block helper references.

+Supported Environments
+----------------------
+
+Handlebars has been designed to work in any ECMAScript 3 environment. This includes
+
+- Node.js
+- Chrome
+- Firefox
+- Safari 5+
+- Opera 11+
+- IE 6+
+
+Older versions and other runtimes are likely to work but have not been formally
+tested.

 Performance
 -----------

-In a rough performance test, precompiled Handlebars.js templates (in the original version of Handlebars.js) rendered in about half the time of Mustache templates. It would be a shame if it were any other way, since they were precompiled, but the difference in architecture does have some big performance advantages. Justin Marney, a.k.a. [gotascii](http://github.com/gotascii), confirmed that with an [independent test](http://sorescode.com/2010/09/12/benchmarks.html). The rewritten Handlebars (current version) is faster than the old version, and we will have some benchmarks in the near future.
+In a rough performance test, precompiled Handlebars.js templates (in
+the original version of Handlebars.js) rendered in about half the
+time of Mustache templates. It would be a shame if it were any other
+way, since they were precompiled, but the difference in architecture
+does have some big performance advantages. Justin Marney, a.k.a.
+[gotascii](http://github.com/gotascii), confirmed that with an
+[independent test](http://sorescode.com/2010/09/12/benchmarks.html). The
+rewritten Handlebars (current version) is faster than the old version,
+and we will have some benchmarks in the near future.


 Building
@@ -264,21 +329,7 @@ in the `dist` directory.
 Upgrading
 ---------

-When upgrading from the Handlebars 0.9 series, be aware that the
-signature for passing custom helpers or partials to templates has
-changed.
-
-Instead of:
-
-```js
-template(context, helpers, partials, [data])
-```
-
-Use:
-
-```js
-template(context, {helpers: helpers, partials: partials, data: data})
-```
+See [release-notes.md](https://github.com/wycats/handlebars.js/blob/master/release-notes.md) for upgrade notes.

 Known Issues
 ------------
@@ -287,30 +338,54 @@ Known Issues

 Handlebars in the Wild
 -----------------
-* [jblotus](http://github.com/jblotus) created [http://tryhandlebarsjs.com](http://tryhandlebarsjs.com) for anyone who would
-like to try out Handlebars.js in their browser.
-* Don Park wrote an Express.js view engine adapter for Handlebars.js called [hbs](http://github.com/donpark/hbs).
-* [sammy.js](http://github.com/quirkey/sammy) by Aaron Quint, a.k.a. quirkey, supports Handlebars.js as one of its template plugins.
-* [SproutCore](http://www.sproutcore.com) uses Handlebars.js as its main templating engine, extending it with automatic data binding support.
-* [Ember.js](http://www.emberjs.com) makes Handlebars.js the primary way to structure your views, also with automatic data binding support.
-* Les Hill (@leshill) wrote a Rails Asset Pipeline gem named [handlebars_assets](http://github.com/leshill/handlebars_assets).
+* [jblotus](http://github.com/jblotus) created [http://tryhandlebarsjs.com](http://tryhandlebarsjs.com)
+  for anyone who would like to try out Handlebars.js in their browser.
+* Don Park wrote an Express.js view engine adapter for Handlebars.js called
+  [hbs](http://github.com/donpark/hbs).
+* [sammy.js](http://github.com/quirkey/sammy) by Aaron Quint, a.k.a. quirkey,
+  supports Handlebars.js as one of its template plugins.
+* [SproutCore](http://www.sproutcore.com) uses Handlebars.js as its main
+  templating engine, extending it with automatic data binding support.
+* [Ember.js](http://www.emberjs.com) makes Handlebars.js the primary way to
+  structure your views, also with automatic data binding support.
+* Les Hill (@leshill) wrote a Rails Asset Pipeline gem named
+  [handlebars_assets](http://github.com/leshill/handlebars_assets).
+* [Gist about Synchronous and asynchronous loading of external handlebars templates](https://gist.github.com/2287070)
+* [Lumbar](walmartlabs.github.io/lumbar) provides easy module-based template management for handlebars projects.
+* [YUI](http://yuilibrary.com/yui/docs/handlebars/) implements a port of handlebars
+
+Have a project using Handlebars? Send us a [pull request](https://github.com/wycats/handlebars.js/pull/new/master)!

 Helping Out
 -----------
 To build Handlebars.js you'll need a few things installed.

 * Node.js
-* Jison, for building the compiler - `npm install jison`
 * Ruby
 * therubyracer, for running tests - `gem install therubyracer`
 * rspec, for running tests - `gem install rspec`

-There's a Gemfile in the repo, so you can run `bundle` to install rspec and therubyracer if you've got bundler installed.
+There's a Gemfile in the repo, so you can run `bundle` to install rspec
+and therubyracer if you've got bundler installed.

-To build Handlebars.js from scratch, you'll want to run `rake compile` in the root of the project. That will build Handlebars and output the results to the dist/ folder. To run tests, run `rake spec`. You can also run our set of benchmarks with `rake bench`.
+To build Handlebars.js from scratch, you'll want to run `rake compile`
+in the root of the project. That will build Handlebars and output the
+results to the dist/ folder. To run tests, run `rake test`. You can also
+run our set of benchmarks with `rake bench`. Node tests can be run with
+`npm test` or `rake npm_test`. The default rake target will compile and
+run both test suites.

-If you notice any problems, please report them to the GitHub issue tracker at [http://github.com/wycats/handlebars.js/issues](http://github.com/wycats/handlebars.js/issues). Feel free to contact commondream or wycats through GitHub with any other questions or feature requests. To submit changes fork the project and send a pull request.
+Some environments, notably Windows, have issues running therubyracer. Under these
+envrionments the `rake compile` and `npm test` should be sufficient to test
+most handlebars functionality.
+
+If you notice any problems, please report them to the GitHub issue tracker at
+[http://github.com/wycats/handlebars.js/issues](http://github.com/wycats/handlebars.js/issues).
+Feel free to contact commondream or wycats through GitHub with any other
+questions or feature requests. To submit changes fork the project and
+send a pull request.

 License
 -------
 Handlebars.js is released under the MIT license.
+
@@ -2,24 +2,24 @@ require "rubygems"
 require "bundler/setup"

 def compile_parser
-  system "./node_modules/jison/lib/jison/cli-wrapper.js src/handlebars.yy src/handlebars.l"
+  system "./node_modules/.bin/jison -m js src/handlebars.yy src/handlebars.l"
  if $?.success?
    File.open("lib/handlebars/compiler/parser.js", "w") do |file|
-      file.puts File.read("handlebars.js") + ";"
+      file.puts File.read("src/parser-prefix.js") + File.read("handlebars.js") + File.read("src/parser-suffix.js")
    end

    sh "rm handlebars.js"
  else
-    puts "Failed to run Jison."
+    fail "Failed to run Jison."
  end
 end

 file "lib/handlebars/compiler/parser.js" => ["src/handlebars.yy","src/handlebars.l"] do
-  if File.exists?('./node_modules/jison/lib/jison/cli-wrapper.js')
+  if File.exists?('./node_modules/jison')
    compile_parser
  else
    puts "Jison is not installed. Trying `npm install jison`."
-    sh "npm install jison"
+    sh "npm install"
    compile_parser
  end
 end
@@ -32,18 +32,24 @@ task :spec => [:release] do
  fail "rspec spec failed with exit code #{$?.exitstatus}" if (rc.nil? || ! rc || $?.exitstatus != 0)
 end

-task :default => [:compile, :spec]
+desc "run the npm test suite"
+task :npm_test => [:release] do
+  rc = system "npm test"
+  fail "npm test failed with exit code #{$?.exitstatus}" if (rc.nil? || ! rc || $?.exitstatus != 0)
+end
+
+task :default => [:compile, :spec, :npm_test]

 def remove_exports(string)
  match = string.match(%r{^// BEGIN\(BROWSER\)\n(.*)\n^// END\(BROWSER\)}m)
  match ? match[1] : string
 end

-minimal_deps = %w(base compiler/parser compiler/base compiler/ast utils compiler/compiler runtime).map do |file|
+minimal_deps = %w(browser-prefix base compiler/parser compiler/base compiler/ast utils compiler/compiler runtime browser-suffix).map do |file|
  "lib/handlebars/#{file}.js"
 end

-runtime_deps = %w(base utils runtime).map do |file|
+runtime_deps = %w(browser-prefix base utils runtime browser-suffix).map do |file|
  "lib/handlebars/#{file}.js"
 end

@@ -55,7 +61,7 @@ def build_for_task(task)
  FileUtils.rm_rf("dist/*") if File.directory?("dist")
  FileUtils.mkdir_p("dist")

-  contents = []
+  contents = ["/*\n\n" + File.read('LICENSE') + "\n*/\n"]
  task.prerequisites.each do |filename|
    next if filename == "dist"

@@ -75,31 +81,44 @@ file "dist/handlebars.runtime.js" => runtime_deps do |task|
  build_for_task(task)
 end

-task :build => [:compile, "dist/handlebars.js"]
-task :runtime => [:compile, "dist/handlebars.runtime.js"]
+task :build => [:compile] do |task|
+  # Since the tests are dependent on this always rebuild.
+  Rake::Task["dist/handlebars.js"].execute
+end
+task :runtime => [:compile] do |task|
+  # Since the tests are dependent on this always rebuild.
+  Rake::Task["dist/handlebars.runtime.js"].execute
+end
+
+# Updates the various version numbers.
+task :version => [] do |task|
+  # TODO : Pull from package.json when the version numbers are synced
+  version = File.read("lib/handlebars/base.js").match(/Handlebars.VERSION = "(.*)";/)[1]
+
+  content = File.read("bower.json")
+  File.open("bower.json", "w") do |file|
+    file.puts content.gsub(/"version":.*/, "\"version\": \"#{version}\",")
+  end
+
+  content = File.read("handlebars.js.nuspec")
+  File.open("handlebars.js.nuspec", "w") do |file|
+    file.puts content.gsub(/<version>.*<\/version>/, "<version>#{version}</version>")
+  end
+end
+
+task :minify => [] do |task|
+  system "./node_modules/.bin/uglifyjs --comments -o dist/handlebars.min.js dist/handlebars.js"
+  system "./node_modules/.bin/uglifyjs --comments -o dist/handlebars.runtime.min.js dist/handlebars.runtime.js"
+end

 desc "build the build and runtime version of handlebars"
-task :release => [:build, :runtime]
+task :release => [:version, :build, :runtime, :minify]

 directory "vendor"

 desc "benchmark against dust.js and mustache.js"
 task :bench => "vendor" do
  require "open-uri"
-  #File.open("vendor/mustache.js", "w") do |file|
-    #file.puts open("https://github.com/janl/mustache.js/raw/master/mustache.js").read
-    #file.puts "module.exports = Mustache;"
-  #end
-
-  File.open("vendor/benchmark.js", "w") do |file|
-    file.puts open("https://raw.github.com/bestiejs/benchmark.js/master/benchmark.js").read
-  end
-
-  #if File.directory?("vendor/dustjs")
-    #system "cd vendor/dustjs && git pull"
-  #else
-    #system "git clone git://github.com/akdubya/dustjs.git vendor/dustjs"
-  #end

  #if File.directory?("vendor/coffee")
    #system "cd vendor/coffee && git pull"
@@ -133,7 +133,7 @@ BenchWarmer.prototype = {

    if(!bench.error) {
      var count = bench.hz,
-          moe   = count * bench.stats.RME / 100;
+          moe   = count * bench.stats.rme / 100;

      out = Math.round(count / 1000) + " ±" + Math.round(moe / 1000) + " (" + bench.cycles + ")";
    } else {
@@ -1,20 +1,22 @@
-require.paths.push("lib");
-require.paths.push("vendor");
-require.paths.push("vendor/dustjs/lib");
-require.paths.push("vendor/coffee/lib");
-require.paths.push("vendor/eco/lib");
-
-
 var BenchWarmer = require("./benchwarmer");
-Handlebars = require("handlebars");
+Handlebars = require("../lib/handlebars");

-var dust = require("dust");
-var Mustache = require("mustache");
-var ecoExports = require("eco");
+var dust, Mustache, eco;

-eco = function(str) {
-  return ecoExports(str);
-}
+try {
+  dust = require("dust");
+} catch (err) { /* NOP */ }
+
+try {
+  Mustache = require("mustache");
+} catch (err) { /* NOP */ }
+
+try {
+  var ecoExports = require("eco");
+  eco = function(str) {
+    return ecoExports(str);
+  }
+} catch (err) { /* NOP */ }

 var benchDetails = {
  string: {
@@ -113,39 +115,46 @@ var makeSuite = function(name) {

    var error = function() { throw new Error("EWOT"); };

-
-    //bench("dust", function() {
-      //dust.render(templateName, context, function(err, out) { });
-    //});
+    if (dust) {
+      bench("dust", function() {
+        dust.render(templateName, context, function(err, out) { });
+      });
+    }

    bench("handlebars", function() {
      handlebarsTemplates[templateName](context);
    });

-    //if(ecoTemplates[templateName]) {
-      //bench("eco", function() {
-        //ecoTemplates[templateName](context);
-      //});
-    //} else {
-      //bench("eco", error);
-    //}
+    if (eco) {
+      if(ecoTemplates[templateName]) {
+        bench("eco", function() {
+          ecoTemplates[templateName](context);
+        });
+      } else {
+        bench("eco", error);
+      }
+    }

-    //if(mustacheSource) {
-      //bench("mustache", function() {
-        //Mustache.to_html(mustacheSource, context, mustachePartials);
-      //});
-    //} else {
-      //bench("mustache", error);
-    //}
+    if (Mustache && mustacheSource) {
+      bench("mustache", function() {
+        Mustache.to_html(mustacheSource, context, mustachePartials);
+      });
+    } else {
+      bench("mustache", error);
+    }
  });
 }

 for(var name in benchDetails) {
  if(benchDetails.hasOwnProperty(name)) {
-    dust.loadSource(dust.compile(benchDetails[name].dust, name));
+    if (dust) {
+      dust.loadSource(dust.compile(benchDetails[name].dust, name));
+    }
    handlebarsTemplates[name] = Handlebars.compile(benchDetails[name].handlebars);

-    if(benchDetails[name].eco) { ecoTemplates[name] = eco(benchDetails[name].eco); }
+    if (eco && benchDetails[name].eco) {
+      ecoTemplates[name] = eco(benchDetails[name].eco);
+    }

    var partials = benchDetails[name].partials;
    if(partials) {
@@ -12,11 +12,17 @@ var optimist = require('optimist')
        'description': 'Exports amd style (require.js)',
        'alias': 'amd'
      },
+      'c': {
+        'type': 'string',
+        'description': 'Exports CommonJS style, path to Handlebars module',
+        'alias': 'commonjs',
+        'default': null
+      },
      'h': {
        'type': 'string',
        'description': 'Path to handlebar.js (only valid for amd-style)',
        'alias': 'handlebarPath',
-		'default': ''
+		    'default': ''
      },
      'k': {
        'type': 'string',
@@ -33,6 +39,12 @@ var optimist = require('optimist')
        'description': 'Minimize output',
        'alias': 'min'
      },
+      'n': {
+        'type': 'string',
+        'description': 'Template namespace',
+        'alias': 'namespace',
+        'default': 'Handlebars.templates'
+      },
      's': {
        'type': 'boolean',
        'description': 'Output template function only.',
@@ -42,6 +54,22 @@ var optimist = require('optimist')
        'type': 'string',
        'description': 'Template root. Base value that will be stripped from template names.',
        'alias': 'root'
+      },
+      'p' : {
+        'type': 'boolean',
+        'description': 'Compiling a partial template',
+        'alias': 'partial'
+      },
+      'd' : {
+        'type': 'boolean',
+        'description': 'Include data when compiling',
+        'alias': 'data'
+      },
+      'e': {
+        'type': 'string',
+        'description': 'Template extension.',
+        'alias': 'extension',
+        'default': 'handlebars'
      }
    })

@@ -87,14 +115,24 @@ if (argv.known) {
  }
 }

+// Build file extension pattern
+var extension = argv.extension.replace(/[\\^$*+?.():=!|{}\-\[\]]/g, function(arg) { return '\\' + arg; });
+extension = new RegExp('\\.' + extension + '$');
+
 var output = [];
 if (!argv.simple) {
  if (argv.amd) {
    output.push('define([\'' + argv.handlebarPath + 'handlebars\'], function(Handlebars) {\n');
+  } else if (argv.commonjs) {
+    output.push('var Handlebars = require("' + argv.commonjs + '");');
  } else {
    output.push('(function() {\n');
  }
-  output.push('  var template = Handlebars.template, templates = Handlebars.templates = Handlebars.templates || {};\n');
+  output.push('  var template = Handlebars.template, templates = ');
+  output.push(argv.namespace);
+  output.push(' = ');
+  output.push(argv.namespace);
+  output.push(' || {};\n');
 }
 function processTemplate(template, root) {
  var path = template,
@@ -103,7 +141,7 @@ function processTemplate(template, root) {
    fs.readdirSync(template).map(function(file) {
      var path = template + '/' + file;

-      if (/\.handlebars$/.test(path) || fs.statSync(path).isDirectory()) {
+      if (extension.test(path) || fs.statSync(path).isDirectory()) {
        processTemplate(path, root || template);
      }
    });
@@ -115,17 +153,29 @@ function processTemplate(template, root) {
      knownHelpersOnly: argv.o
    };

+    if (argv.data) {
+      options.data = true;
+    }
+
    // Clean the template name
    if (!root) {
      template = basename(template);
    } else if (template.indexOf(root) === 0) {
      template = template.substring(root.length+1);
    }
-    template = template.replace(/\.handlebars$/, '');
+    template = template.replace(extension, '');

    if (argv.simple) {
      output.push(handlebars.precompile(data, options) + '\n');
+    } else if (argv.partial) {
+      if(argv.amd && (argv._.length == 1 && !fs.statSync(argv._[0]).isDirectory())) {
+        output.push('return ');
+      }
+      output.push('Handlebars.partials[\'' + template + '\'] = template(' + handlebars.precompile(data, options) + ');\n');
    } else {
+      if(argv.amd && (argv._.length == 1 && !fs.statSync(argv._[0]).isDirectory())) {
+        output.push('return ');
+      }
      output.push('templates[\'' + template + '\'] = template(' + handlebars.precompile(data, options) + ');\n');
    }
  }
@@ -138,18 +188,22 @@ argv._.forEach(function(template) {
 // Output the content
 if (!argv.simple) {
  if (argv.amd) {
+    if(argv._.length > 1 || (argv._.length == 1 && fs.statSync(argv._[0]).isDirectory())) {
+      if(argv.partial){
+        output.push('return Handlebars.partials;\n');
+      } else {
+        output.push('return templates;\n');
+      }
+    }
    output.push('});');
-  } else {
+  } else if (!argv.commonjs) {
    output.push('})();');
  }
 }
 output = output.join('');

 if (argv.min) {
-  var ast = uglify.parser.parse(output);
-  ast = uglify.uglify.ast_mangle(ast);
-  ast = uglify.uglify.ast_squeeze(ast);
-  output = uglify.uglify.gen_code(ast);
+  output = uglify.minify(output, {fromString: true}).code;
 }

 if (argv.output) {
@@ -0,0 +1,9 @@
+{
+  "name": "handlebars.js",
+  "version": "1.0.0",
+  "main": "dist/handlebars.js",
+  "ignore": [
+    "node_modules",
+    "components"
+  ]
+}
@@ -0,0 +1,362 @@
+/*
+
+Copyright (C) 2011 by Yehuda Katz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+// lib/handlebars/browser-prefix.js
+var Handlebars = {};
+
+(function(Handlebars, undefined) {
+;
+// lib/handlebars/base.js
+
+Handlebars.VERSION = "1.0.0";
+Handlebars.COMPILER_REVISION = 4;
+
+Handlebars.REVISION_CHANGES = {
+  1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
+  2: '== 1.0.0-rc.3',
+  3: '== 1.0.0-rc.4',
+  4: '>= 1.0.0'
+};
+
+Handlebars.helpers  = {};
+Handlebars.partials = {};
+
+var toString = Object.prototype.toString,
+    functionType = '[object Function]',
+    objectType = '[object Object]';
+
+Handlebars.registerHelper = function(name, fn, inverse) {
+  if (toString.call(name) === objectType) {
+    if (inverse || fn) { throw new Handlebars.Exception('Arg not supported with multiple helpers'); }
+    Handlebars.Utils.extend(this.helpers, name);
+  } else {
+    if (inverse) { fn.not = inverse; }
+    this.helpers[name] = fn;
+  }
+};
+
+Handlebars.registerPartial = function(name, str) {
+  if (toString.call(name) === objectType) {
+    Handlebars.Utils.extend(this.partials,  name);
+  } else {
+    this.partials[name] = str;
+  }
+};
+
+Handlebars.registerHelper('helperMissing', function(arg) {
+  if(arguments.length === 2) {
+    return undefined;
+  } else {
+    throw new Error("Missing helper: '" + arg + "'");
+  }
+});
+
+Handlebars.registerHelper('blockHelperMissing', function(context, options) {
+  var inverse = options.inverse || function() {}, fn = options.fn;
+
+  var type = toString.call(context);
+
+  if(type === functionType) { context = context.call(this); }
+
+  if(context === true) {
+    return fn(this);
+  } else if(context === false || context == null) {
+    return inverse(this);
+  } else if(type === "[object Array]") {
+    if(context.length > 0) {
+      return Handlebars.helpers.each(context, options);
+    } else {
+      return inverse(this);
+    }
+  } else {
+    return fn(context);
+  }
+});
+
+Handlebars.K = function() {};
+
+Handlebars.createFrame = Object.create || function(object) {
+  Handlebars.K.prototype = object;
+  var obj = new Handlebars.K();
+  Handlebars.K.prototype = null;
+  return obj;
+};
+
+Handlebars.logger = {
+  DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3,
+
+  methodMap: {0: 'debug', 1: 'info', 2: 'warn', 3: 'error'},
+
+  // can be overridden in the host environment
+  log: function(level, obj) {
+    if (Handlebars.logger.level <= level) {
+      var method = Handlebars.logger.methodMap[level];
+      if (typeof console !== 'undefined' && console[method]) {
+        console[method].call(console, obj);
+      }
+    }
+  }
+};
+
+Handlebars.log = function(level, obj) { Handlebars.logger.log(level, obj); };
+
+Handlebars.registerHelper('each', function(context, options) {
+  var fn = options.fn, inverse = options.inverse;
+  var i = 0, ret = "", data;
+
+  var type = toString.call(context);
+  if(type === functionType) { context = context.call(this); }
+
+  if (options.data) {
+    data = Handlebars.createFrame(options.data);
+  }
+
+  if(context && typeof context === 'object') {
+    if(context instanceof Array){
+      for(var j = context.length; i<j; i++) {
+        if (data) { data.index = i; }
+        ret = ret + fn(context[i], { data: data });
+      }
+    } else {
+      for(var key in context) {
+        if(context.hasOwnProperty(key)) {
+          if(data) { data.key = key; }
+          ret = ret + fn(context[key], {data: data});
+          i++;
+        }
+      }
+    }
+  }
+
+  if(i === 0){
+    ret = inverse(this);
+  }
+
+  return ret;
+});
+
+Handlebars.registerHelper('if', function(conditional, options) {
+  var type = toString.call(conditional);
+  if(type === functionType) { conditional = conditional.call(this); }
+
+  if(!conditional || Handlebars.Utils.isEmpty(conditional)) {
+    return options.inverse(this);
+  } else {
+    return options.fn(this);
+  }
+});
+
+Handlebars.registerHelper('unless', function(conditional, options) {
+  return Handlebars.helpers['if'].call(this, conditional, {fn: options.inverse, inverse: options.fn});
+});
+
+Handlebars.registerHelper('with', function(context, options) {
+  var type = toString.call(context);
+  if(type === functionType) { context = context.call(this); }
+
+  if (!Handlebars.Utils.isEmpty(context)) return options.fn(context);
+});
+
+Handlebars.registerHelper('log', function(context, options) {
+  var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
+  Handlebars.log(level, context);
+});
+;
+// lib/handlebars/utils.js
+
+var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
+
+Handlebars.Exception = function(message) {
+  var tmp = Error.prototype.constructor.apply(this, arguments);
+
+  // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
+  for (var idx = 0; idx < errorProps.length; idx++) {
+    this[errorProps[idx]] = tmp[errorProps[idx]];
+  }
+};
+Handlebars.Exception.prototype = new Error();
+
+// Build out our basic SafeString type
+Handlebars.SafeString = function(string) {
+  this.string = string;
+};
+Handlebars.SafeString.prototype.toString = function() {
+  return this.string.toString();
+};
+
+var escape = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#x27;",
+  "`": "&#x60;"
+};
+
+var badChars = /[&<>"'`]/g;
+var possible = /[&<>"'`]/;
+
+var escapeChar = function(chr) {
+  return escape[chr] || "&amp;";
+};
+
+Handlebars.Utils = {
+  extend: function(obj, value) {
+    for(var key in value) {
+      if(value.hasOwnProperty(key)) {
+        obj[key] = value[key];
+      }
+    }
+  },
+
+  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 "";
+    }
+
+    // Force a string conversion as this will be done by the append regardless and
+    // the regex test will do this transparently behind the scenes, causing issues if
+    // an object's to string has escaped characters in it.
+    string = string.toString();
+
+    if(!possible.test(string)) { return string; }
+    return string.replace(badChars, escapeChar);
+  },
+
+  isEmpty: function(value) {
+    if (!value && value !== 0) {
+      return true;
+    } else if(toString.call(value) === "[object Array]" && value.length === 0) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+};
+;
+// lib/handlebars/runtime.js
+
+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) {
+          programWrapper = Handlebars.VM.program(i, fn, data);
+        } else if (!programWrapper) {
+          programWrapper = this.programs[i] = Handlebars.VM.program(i, fn);
+        }
+        return programWrapper;
+      },
+      merge: function(param, common) {
+        var ret = param || common;
+
+        if (param && common) {
+          ret = {};
+          Handlebars.Utils.extend(ret, common);
+          Handlebars.Utils.extend(ret, param);
+        }
+        return ret;
+      },
+      programWithDepth: Handlebars.VM.programWithDepth,
+      noop: Handlebars.VM.noop,
+      compilerInfo: null
+    };
+
+    return function(context, options) {
+      options = options || {};
+      var result = templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
+
+      var compilerInfo = container.compilerInfo || [],
+          compilerRevision = compilerInfo[0] || 1,
+          currentRevision = Handlebars.COMPILER_REVISION;
+
+      if (compilerRevision !== currentRevision) {
+        if (compilerRevision < currentRevision) {
+          var runtimeVersions = Handlebars.REVISION_CHANGES[currentRevision],
+              compilerVersions = Handlebars.REVISION_CHANGES[compilerRevision];
+          throw "Template was precompiled with an older version of Handlebars than the current runtime. "+
+                "Please update your precompiler to a newer version ("+runtimeVersions+") or downgrade your runtime to an older version ("+compilerVersions+").";
+        } else {
+          // Use the embedded version info since the runtime doesn't know about this revision yet
+          throw "Template was precompiled with a newer version of Handlebars than the current runtime. "+
+                "Please update your runtime to a newer version ("+compilerInfo[1]+").";
+        }
+      }
+
+      return result;
+    };
+  },
+
+  programWithDepth: function(i, fn, data /*, $depth */) {
+    var args = Array.prototype.slice.call(arguments, 3);
+
+    var program = function(context, options) {
+      options = options || {};
+
+      return fn.apply(this, [context, options.data || data].concat(args));
+    };
+    program.program = i;
+    program.depth = args.length;
+    return program;
+  },
+  program: function(i, fn, data) {
+    var program = function(context, options) {
+      options = options || {};
+
+      return fn(context, options.data || data);
+    };
+    program.program = i;
+    program.depth = 0;
+    return program;
+  },
+  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, {data: data !== undefined});
+      return partials[name](context, options);
+    }
+  }
+};
+
+Handlebars.template = Handlebars.VM.template;
+;
+// lib/handlebars/browser-suffix.js
+})(Handlebars);
+;
@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require 'json'
+
+package = JSON.parse(File.read('package.json'))
+
+Gem::Specification.new do |gem|
+  gem.name          = "handlebars-source"
+  gem.authors       = ["Yehuda Katz"]
+  gem.email         = ["wycats@gmail.com"]
+  gem.date          = Time.now.strftime("%Y-%m-%d")
+  gem.description   = %q{Handlebars.js source code wrapper for (pre)compilation gems.}
+  gem.summary       = %q{Handlebars.js source code wrapper}
+  gem.homepage      = "https://github.com/wycats/handlebars.js/"
+  gem.version       = package["version"]
+
+  gem.files = [
+    'dist/handlebars.js',
+    'dist/handlebars.runtime.js',
+    'lib/handlebars/source.rb'
+  ]
+end
@@ -0,0 +1,17 @@
+<?xml version="1.0"?>
+<package>
+	<metadata>
+		<id>handlebars.js</id>
+		<version>1.0.0</version>
+		<authors>handlebars.js Authors</authors>
+		<licenseUrl>https://github.com/wycats/handlebars.js/blob/master/LICENSE</licenseUrl>
+		<projectUrl>https://github.com/wycats/handlebars.js/</projectUrl>
+		<requireLicenseAcceptance>false</requireLicenseAcceptance>
+		<description>Extension of the Mustache logicless template language</description>
+		<releaseNotes></releaseNotes>
+		<tags>handlebars mustache template html</tags>
+	</metadata>
+	<files>
+		<file src="dist\handlebars.js" target="Content\Scripts" />
+	</files>
+</package>
@@ -1,14 +1,43 @@
-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
+
+// Publish a Node.js require() handler for .handlebars and .hbs files
+if (require.extensions) {
+  var extension = function(module, filename) {
+    var fs = require("fs");
+    var templateString = fs.readFileSync(filename, "utf8");
+    module.exports = Handlebars.compile(templateString);
+  };
+  require.extensions[".handlebars"] = extension;
+  require.extensions[".hbs"] = extension;
+}

 // BEGIN(BROWSER)

 // END(BROWSER)

+// USAGE:
+// var handlebars = require('handlebars');
+
+// var singleton = handlebars.Handlebars,
+//  local = handlebars.create();
@@ -1,39 +1,57 @@
+/*jshint eqnull: true */
+
+module.exports.create = function() {
+
+var Handlebars = {};
+
 // BEGIN(BROWSER)

-/*jshint eqnull:true*/
-this.Handlebars = {};
+Handlebars.VERSION = "1.0.0";
+Handlebars.COMPILER_REVISION = 4;

-(function(Handlebars) {
-
-Handlebars.VERSION = "1.0.rc.1";
+Handlebars.REVISION_CHANGES = {
+  1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
+  2: '== 1.0.0-rc.3',
+  3: '== 1.0.0-rc.4',
+  4: '>= 1.0.0'
+};

 Handlebars.helpers  = {};
 Handlebars.partials = {};

+var toString = Object.prototype.toString,
+    functionType = '[object Function]',
+    objectType = '[object Object]';
+
 Handlebars.registerHelper = function(name, fn, inverse) {
-  if(inverse) { fn.not = inverse; }
-  this.helpers[name] = fn;
+  if (toString.call(name) === objectType) {
+    if (inverse || fn) { throw new Handlebars.Exception('Arg not supported with multiple helpers'); }
+    Handlebars.Utils.extend(this.helpers, name);
+  } else {
+    if (inverse) { fn.not = inverse; }
+    this.helpers[name] = fn;
+  }
 };

 Handlebars.registerPartial = function(name, str) {
-  this.partials[name] = str;
+  if (toString.call(name) === objectType) {
+    Handlebars.Utils.extend(this.partials,  name);
+  } else {
+    this.partials[name] = str;
+  }
 };

 Handlebars.registerHelper('helperMissing', function(arg) {
  if(arguments.length === 2) {
    return undefined;
  } else {
-    throw new Error("Could not find property '" + arg + "'");
+    throw new Error("Missing helper: '" + arg + "'");
  }
 });

-var toString = Object.prototype.toString, functionType = "[object Function]";
-
 Handlebars.registerHelper('blockHelperMissing', function(context, options) {
  var inverse = options.inverse || function() {}, fn = options.fn;

-
-  var ret = "";
  var type = toString.call(context);

  if(type === functionType) { context = context.call(this); }
@@ -62,55 +80,87 @@ Handlebars.createFrame = Object.create || function(object) {
  return obj;
 };

+Handlebars.logger = {
+  DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3,
+
+  methodMap: {0: 'debug', 1: 'info', 2: 'warn', 3: 'error'},
+
+  // can be overridden in the host environment
+  log: function(level, obj) {
+    if (Handlebars.logger.level <= level) {
+      var method = Handlebars.logger.methodMap[level];
+      if (typeof console !== 'undefined' && console[method]) {
+        console[method].call(console, obj);
+      }
+    }
+  }
+};
+
+Handlebars.log = function(level, obj) { Handlebars.logger.log(level, obj); };
+
 Handlebars.registerHelper('each', function(context, options) {
  var fn = options.fn, inverse = options.inverse;
-  var ret = "", data;
+  var i = 0, ret = "", data;
+
+  var type = toString.call(context);
+  if(type === functionType) { context = context.call(this); }

  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 });
+  if(context && typeof context === 'object') {
+    if(context instanceof Array){
+      for(var j = context.length; i<j; i++) {
+        if (data) { data.index = i; }
+        ret = ret + fn(context[i], { data: data });
+      }
+    } else {
+      for(var key in context) {
+        if(context.hasOwnProperty(key)) {
+          if(data) { data.key = key; }
+          ret = ret + fn(context[key], {data: data});
+          i++;
+        }
+      }
    }
-  } else {
+  }
+
+  if(i === 0){
    ret = inverse(this);
  }
+
  return ret;
 });

-Handlebars.registerHelper('if', function(context, options) {
-  var type = toString.call(context);
-  if(type === functionType) { context = context.call(this); }
+Handlebars.registerHelper('if', function(conditional, options) {
+  var type = toString.call(conditional);
+  if(type === functionType) { conditional = conditional.call(this); }

-  if(!context || Handlebars.Utils.isEmpty(context)) {
+  if(!conditional || Handlebars.Utils.isEmpty(conditional)) {
    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('unless', function(conditional, options) {
+  return Handlebars.helpers['if'].call(this, conditional, {fn: options.inverse, inverse: options.fn});
 });

 Handlebars.registerHelper('with', function(context, options) {
-  return options.fn(context);
+  var type = toString.call(context);
+  if(type === functionType) { context = context.call(this); }
+
+  if (!Handlebars.Utils.isEmpty(context)) return options.fn(context);
 });

-Handlebars.registerHelper('log', function(context) {
-  Handlebars.log(context);
+Handlebars.registerHelper('log', function(context, options) {
+  var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
+  Handlebars.log(level, context);
 });

-}(this.Handlebars));
-
 // END(BROWSER)

-module.exports = this.Handlebars;
-
+return Handlebars;
+};
@@ -0,0 +1,3 @@
+var Handlebars = {};
+
+(function(Handlebars, undefined) {
@@ -0,0 +1 @@
+})(Handlebars);
@@ -1,123 +1,138 @@
-var Handlebars = require('./base');
+exports.attach = function(Handlebars) {

 // BEGIN(BROWSER)
-(function() {
+Handlebars.AST = {};

-  Handlebars.AST = {};
+Handlebars.AST.ProgramNode = function(statements, inverse) {
+  this.type = "program";
+  this.statements = statements;
+  if(inverse) { this.inverse = new Handlebars.AST.ProgramNode(inverse); }
+};

-  Handlebars.AST.ProgramNode = function(statements, inverse) {
-    this.type = "program";
-    this.statements = statements;
-    if(inverse) { this.inverse = new Handlebars.AST.ProgramNode(inverse); }
-  };
+Handlebars.AST.MustacheNode = function(rawParams, hash, unescaped) {
+  this.type = "mustache";
+  this.escaped = !unescaped;
+  this.hash = hash;

-  Handlebars.AST.MustacheNode = function(rawParams, hash, unescaped) {
-    this.type = "mustache";
-    this.escaped = !unescaped;
-    this.hash = hash;
+  var id = this.id = rawParams[0];
+  var params = this.params = rawParams.slice(1);

-    var id = this.id = rawParams[0];
-    var params = this.params = rawParams.slice(1);
+  // a mustache is an eligible helper if:
+  // * its id is simple (a single part, not `this` or `..`)
+  var eligibleHelper = this.eligibleHelper = id.isSimple;

-    // a mustache is an eligible helper if:
-    // * its id is simple (a single part, not `this` or `..`)
-    var eligibleHelper = this.eligibleHelper = id.isSimple;
+  // a mustache is definitely a helper if:
+  // * it is an eligible helper, and
+  // * it has at least one parameter or hash segment
+  this.isHelper = eligibleHelper && (params.length || hash);

-    // a mustache is definitely a helper if:
-    // * it is an eligible helper, and
-    // * it has at least one parameter or hash segment
-    this.isHelper = eligibleHelper && (params.length || hash);
+  // if a mustache is an eligible helper but not a definite
+  // helper, it is ambiguous, and will be resolved in a later
+  // pass or at runtime.
+};

-    // if a mustache is an eligible helper but not a definite
-    // helper, it is ambiguous, and will be resolved in a later
-    // pass or at runtime.
-  };
-
-  Handlebars.AST.PartialNode = function(id, context) {
-    this.type    = "partial";
-
-    // TODO: disallow complex IDs
-
-    this.id      = id;
-    this.context = context;
-  };
+Handlebars.AST.PartialNode = function(partialName, context) {
+  this.type         = "partial";
+  this.partialName  = partialName;
+  this.context      = context;
+};

+Handlebars.AST.BlockNode = function(mustache, program, inverse, close) {
  var verifyMatch = function(open, close) {
    if(open.original !== close.original) {
      throw new Handlebars.Exception(open.original + " doesn't match " + close.original);
    }
  };

-  Handlebars.AST.BlockNode = function(mustache, program, inverse, close) {
-    verifyMatch(mustache.id, close);
-    this.type = "block";
-    this.mustache = mustache;
-    this.program  = program;
-    this.inverse  = inverse;
+  verifyMatch(mustache.id, close);
+  this.type = "block";
+  this.mustache = mustache;
+  this.program  = program;
+  this.inverse  = inverse;

-    if (this.inverse && !this.program) {
-      this.isInverse = true;
+  if (this.inverse && !this.program) {
+    this.isInverse = true;
+  }
+};
+
+Handlebars.AST.ContentNode = function(string) {
+  this.type = "content";
+  this.string = string;
+};
+
+Handlebars.AST.HashNode = function(pairs) {
+  this.type = "hash";
+  this.pairs = pairs;
+};
+
+Handlebars.AST.IdNode = function(parts) {
+  this.type = "ID";
+
+  var original = "",
+      dig = [],
+      depth = 0;
+
+  for(var i=0,l=parts.length; i<l; i++) {
+    var part = parts[i].part;
+    original += (parts[i].separator || '') + part;
+
+    if (part === ".." || part === "." || part === "this") {
+      if (dig.length > 0) { throw new Handlebars.Exception("Invalid path: " + original); }
+      else if (part === "..") { depth++; }
+      else { this.isScoped = true; }
    }
-  };
+    else { dig.push(part); }
+  }

-  Handlebars.AST.ContentNode = function(string) {
-    this.type = "content";
-    this.string = string;
-  };
+  this.original = original;
+  this.parts    = dig;
+  this.string   = dig.join('.');
+  this.depth    = depth;

-  Handlebars.AST.HashNode = function(pairs) {
-    this.type = "hash";
-    this.pairs = pairs;
-  };
+  // 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.IdNode = function(parts) {
-    this.type = "ID";
-    this.original = parts.join(".");
+  this.stringModeValue = this.string;
+};

-    var dig = [], depth = 0;
+Handlebars.AST.PartialNameNode = function(name) {
+  this.type = "PARTIAL_NAME";
+  this.name = name.original;
+};

-    for(var i=0,l=parts.length; i<l; i++) {
-      var part = parts[i];
+Handlebars.AST.DataNode = function(id) {
+  this.type = "DATA";
+  this.id = id;
+};

-      if(part === "..") { depth++; }
-      else if(part === "." || part === "this") { this.isScoped = true; }
-      else { dig.push(part); }
-    }
+Handlebars.AST.StringNode = function(string) {
+  this.type = "STRING";
+  this.original =
+    this.string =
+    this.stringModeValue = string;
+};

-    this.parts    = dig;
-    this.string   = dig.join('.');
-    this.depth    = depth;
-
-    // an ID is simple if it only has one part, and that part is not
-    // `..` or `this`.
-    this.isSimple = parts.length === 1 && !this.isScoped && depth === 0;
-  };
-
-  Handlebars.AST.DataNode = function(id) {
-    this.type = "DATA";
-    this.id = id;
-  };
-
-  Handlebars.AST.StringNode = function(string) {
-    this.type = "STRING";
-    this.string = string;
-  };
-
-  Handlebars.AST.IntegerNode = function(integer) {
-    this.type = "INTEGER";
+Handlebars.AST.IntegerNode = function(integer) {
+  this.type = "INTEGER";
+  this.original =
    this.integer = integer;
-  };
+  this.stringModeValue = Number(integer);
+};

-  Handlebars.AST.BooleanNode = function(bool) {
-    this.type = "BOOLEAN";
-    this.bool = bool;
-  };
+Handlebars.AST.BooleanNode = function(bool) {
+  this.type = "BOOLEAN";
+  this.bool = bool;
+  this.stringModeValue = bool === "true";
+};

-  Handlebars.AST.CommentNode = function(comment) {
-    this.type = "comment";
-    this.comment = comment;
-  };
+Handlebars.AST.CommentNode = function(comment) {
+  this.type = "comment";
+  this.comment = comment;
+};

-})();
 // END(BROWSER)

+return Handlebars;
+};
+
@@ -1,27 +1,21 @@
-var handlebars = require("./parser").parser;
-var Handlebars = require("../base");
+var handlebars = require("./parser");
+
+exports.attach = function(Handlebars) {

 // BEGIN(BROWSER)
+
 Handlebars.Parser = handlebars;

-Handlebars.parse = function(string) {
+Handlebars.parse = function(input) {
+
+  // Just return if an already-compile AST was passed in.
+  if(input.constructor === Handlebars.AST.ProgramNode) { return input; }
+
  Handlebars.Parser.yy = Handlebars.AST;
-  return Handlebars.Parser.parse(string);
+  return Handlebars.Parser.parse(input);
 };

-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;
+return Handlebars;
+};
@@ -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;
+
+};
@@ -1,6 +1,11 @@
-var Handlebars = require("./base");
+exports.attach = function(Handlebars) {

 // BEGIN(BROWSER)
+
+Handlebars.print = function(ast) {
+  return new Handlebars.PrintVisitor().accept(ast);
+};
+
 Handlebars.PrintVisitor = function() { this.padding = 0; };
 Handlebars.PrintVisitor.prototype = new Handlebars.Visitor();

@@ -72,7 +77,7 @@ Handlebars.PrintVisitor.prototype.mustache = function(mustache) {
 };

 Handlebars.PrintVisitor.prototype.partial = function(partial) {
-  var content = this.accept(partial.id);
+  var content = this.accept(partial.partialName);
  if(partial.context) { content = content + " " + this.accept(partial.context); }
  return this.pad("{{> " + content + " }}");
 };
@@ -111,8 +116,12 @@ Handlebars.PrintVisitor.prototype.ID = function(id) {
  }
 };

+Handlebars.PrintVisitor.prototype.PARTIAL_NAME = function(partialName) {
+    return "PARTIAL:" + partialName.name;
+};
+
 Handlebars.PrintVisitor.prototype.DATA = function(data) {
-  return "@" + data.id;
+  return "@" + this.accept(data.id);
 };

 Handlebars.PrintVisitor.prototype.content = function(content) {
@@ -124,4 +133,6 @@ Handlebars.PrintVisitor.prototype.comment = function(comment) {
 };
 // END(BROWSER)

-exports.PrintVisitor = Handlebars.PrintVisitor;
+return Handlebars;
+};
+
@@ -1,4 +1,4 @@
-var Handlebars = require("./base");
+exports.attach = function(Handlebars) {

 // BEGIN(BROWSER)

@@ -9,5 +9,10 @@ Handlebars.Visitor.prototype = {
    return this[object.type](object);
  }
 };
+
 // END(BROWSER)

+return Handlebars;
+};
+
+
@@ -1,6 +1,7 @@
-var Handlebars = require("./base");
+exports.attach = function(Handlebars) {

 // BEGIN(BROWSER)
+
 Handlebars.VM = {
  template: function(templateSpec) {
    // Just add water
@@ -11,39 +12,73 @@ Handlebars.VM = {
      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;
+          programWrapper = Handlebars.VM.program(i, fn, data);
+        } else if (!programWrapper) {
+          programWrapper = this.programs[i] = Handlebars.VM.program(i, fn);
        }
+        return programWrapper;
+      },
+      merge: function(param, common) {
+        var ret = param || common;
+
+        if (param && common) {
+          ret = {};
+          Handlebars.Utils.extend(ret, common);
+          Handlebars.Utils.extend(ret, param);
+        }
+        return ret;
      },
      programWithDepth: Handlebars.VM.programWithDepth,
-      noop: Handlebars.VM.noop
+      noop: Handlebars.VM.noop,
+      compilerInfo: null
    };

    return function(context, options) {
      options = options || {};
-      return templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
+      var result = templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
+
+      var compilerInfo = container.compilerInfo || [],
+          compilerRevision = compilerInfo[0] || 1,
+          currentRevision = Handlebars.COMPILER_REVISION;
+
+      if (compilerRevision !== currentRevision) {
+        if (compilerRevision < currentRevision) {
+          var runtimeVersions = Handlebars.REVISION_CHANGES[currentRevision],
+              compilerVersions = Handlebars.REVISION_CHANGES[compilerRevision];
+          throw "Template was precompiled with an older version of Handlebars than the current runtime. "+
+                "Please update your precompiler to a newer version ("+runtimeVersions+") or downgrade your runtime to an older version ("+compilerVersions+").";
+        } else {
+          // Use the embedded version info since the runtime doesn't know about this revision yet
+          throw "Template was precompiled with a newer version of Handlebars than the current runtime. "+
+                "Please update your runtime to a newer version ("+compilerInfo[1]+").";
+        }
+      }
+
+      return result;
    };
  },

-  programWithDepth: function(fn, data, $depth) {
-    var args = Array.prototype.slice.call(arguments, 2);
+  programWithDepth: function(i, fn, data /*, $depth */) {
+    var args = Array.prototype.slice.call(arguments, 3);

-    return function(context, options) {
+    var program = function(context, options) {
      options = options || {};

      return fn.apply(this, [context, options.data || data].concat(args));
    };
+    program.program = i;
+    program.depth = args.length;
+    return program;
  },
-  program: function(fn, data) {
-    return function(context, options) {
+  program: function(i, fn, data) {
+    var program = function(context, options) {
      options = options || {};

      return fn(context, options.data || data);
    };
+    program.program = i;
+    program.depth = 0;
+    return program;
  },
  noop: function() { return ""; },
  invokePartial: function(partial, name, context, helpers, partials, data) {
@@ -66,3 +101,6 @@ Handlebars.template = Handlebars.VM.template;

 // END(BROWSER)

+return Handlebars;
+
+};
@@ -0,0 +1,11 @@
+module Handlebars
+  module Source
+    def self.bundled_path
+      File.expand_path("../../../dist/handlebars.js", __FILE__)
+    end
+
+    def self.runtime_bundled_path
+      File.expand_path("../../../dist/handlebars.runtime.js", __FILE__)
+    end
+  end
+end
@@ -1,14 +1,18 @@
-var Handlebars = require("./base");
+exports.attach = function(Handlebars) {
+
+var toString = Object.prototype.toString;

 // BEGIN(BROWSER)
+
+var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
+
 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]; }
+  // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
+  for (var idx = 0; idx < errorProps.length; idx++) {
+    this[errorProps[idx]] = tmp[errorProps[idx]];
  }
-
-  this.message = tmp.message;
 };
 Handlebars.Exception.prototype = new Error();

@@ -20,50 +24,60 @@ Handlebars.SafeString.prototype.toString = function() {
  return this.string.toString();
 };

-(function() {
-  var escape = {
-    "&": "&amp;",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#x27;",
-    "`": "&#x60;"
-  };
+var escape = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#x27;",
+  "`": "&#x60;"
+};

-  var badChars = /[&<>"'`]/g;
-  var possible = /[&<>"'`]/;
+var badChars = /[&<>"'`]/g;
+var possible = /[&<>"'`]/;

-  var escapeChar = function(chr) {
-    return escape[chr] || "&amp;";
-  };
+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;
+Handlebars.Utils = {
+  extend: function(obj, value) {
+    for(var key in value) {
+      if(value.hasOwnProperty(key)) {
+        obj[key] = value[key];
      }
    }
-  };
-})();
+  },
+
+  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 "";
+    }
+
+    // Force a string conversion as this will be done by the append regardless and
+    // the regex test will do this transparently behind the scenes, causing issues if
+    // an object's to string has escaped characters in it.
+    string = string.toString();
+
+    if(!possible.test(string)) { return string; }
+    return string.replace(badChars, escapeChar);
+  },
+
+  isEmpty: function(value) {
+    if (!value && value !== 0) {
+      return true;
+    } else if(toString.call(value) === "[object Array]" && value.length === 0) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+};
+
 // END(BROWSER)

+return Handlebars;
+};
@@ -1,7 +1,7 @@
 {
  "name": "handlebars",
  "description": "Extension of the Mustache logicless template language",
-  "version": "1.0.0-rc.1",
+  "version": "1.0.12",
  "homepage": "http://www.handlebarsjs.com/",
  "keywords": [
    "handlebars mustache template html"
@@ -15,10 +15,14 @@
  },
  "dependencies": {
    "optimist": "~0.3",
-    "uglify-js": "~1.2"
+    "uglify-js": "~2.3"
  },
  "devDependencies": {
-    "mocha": "*"
+    "benchmark": "~1.0",
+    "dust": "~0.3",
+    "jison": "~0.3",
+    "mocha": "*",
+    "mustache": "~0.7.2"
  },
  "main": "lib/handlebars.js",
  "bin": {
@@ -0,0 +1,93 @@
+# Release Notes
+
+## Development
+[Commits](https://github.com/wycats/handlebars.js/compare/v1.0.12...master)
+
+## v1.0.12 / 1.0.0 - May 31 2013
+
+- [#515](https://github.com/wycats/handlebars.js/issues/515) - Add node require extensions support ([@jjclark1982](https://github.com/jjclark1982))
+- [#517](https://github.com/wycats/handlebars.js/issues/517) - Fix amd precompiler output with directories ([@blessenm](https://github.com/blessenm))
+- [#433](https://github.com/wycats/handlebars.js/issues/433) - Add support for unicode ids
+- [#469](https://github.com/wycats/handlebars.js/issues/469) - Add support for `?` in ids
+- [#534](https://github.com/wycats/handlebars.js/issues/534) - Protect from object prototype modifications
+- [#519](https://github.com/wycats/handlebars.js/issues/519) - Fix partials with . name ([@jamesgorrie](https://github.com/jamesgorrie))
+- [#519](https://github.com/wycats/handlebars.js/issues/519) - Allow ID or strings in partial names
+- [#437](https://github.com/wycats/handlebars.js/issues/437) - Require matching brace counts in escaped expressions
+- Merge passed partials and helpers with global namespace values
+- Add support for complex ids in @data references
+- Docs updates
+
+Compatibility notes:
+- The parser is now stricter on `{{{`, requiring that the end token be `}}}`. Templates that do not
+  follow this convention should add the additional brace value.
+- Code that relies on global the namespace being muted when custom helpers or partials are passed will need to explicitly pass an `undefined` value for any helpers that should not be available.
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v1.0.11...v1.0.12)
+
+## v1.0.11 / 1.0.0-rc4 - May 13 2013
+
+- [#458](https://github.com/wycats/handlebars.js/issues/458) - Fix `./foo` syntax ([@jpfiset](https://github.com/jpfiset))
+- [#460](https://github.com/wycats/handlebars.js/issues/460) - Allow `:` in unescaped identifers ([@jpfiset](https://github.com/jpfiset))
+- [#471](https://github.com/wycats/handlebars.js/issues/471) - Create release notes (These!)
+- [#456](https://github.com/wycats/handlebars.js/issues/456) - Allow escaping of `\\`
+- [#211](https://github.com/wycats/handlebars.js/issues/211) - Fix exception in `escapeExpression`
+- [#375](https://github.com/wycats/handlebars.js/issues/375) - Escape unicode newlines
+- [#461](https://github.com/wycats/handlebars.js/issues/461) - Do not fail when compiling `""`
+- [#302](https://github.com/wycats/handlebars.js/issues/302) - Fix sanity check in knownHelpersOnly mode
+- [#369](https://github.com/wycats/handlebars.js/issues/369) - Allow registration of multiple helpers and partial by passing definition object
+- Add bower package declaration ([@DevinClark](https://github.com/DevinClark))
+- Add NuSpec package declaration ([@MikeMayer](https://github.com/MikeMayer))
+- Handle empty context in `with` ([@thejohnfreeman](https://github.com/thejohnfreeman))
+- Support custom template extensions in CLI ([@matteoagosti](https://github.com/matteoagosti))
+- Fix Rhino support ([@broady](https://github.com/broady))
+- Include contexts in string mode ([@leshill](https://github.com/leshill))
+- Return precompiled scripts when compiling to AMD ([@JamesMaroney](https://github.com/JamesMaroney))
+- Docs updates ([@iangreenleaf](https://github.com/iangreenleaf), [@gilesbowkett](https://github.com/gilesbowkett), [@utkarsh2012](https://github.com/utkarsh2012))
+- Fix `toString` handling under IE and browserify ([@tommydudebreaux](https://github.com/tommydudebreaux))
+- Add program metadata
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v1.0.10...v1.0.11)
+
+## v1.0.10 - Node - Feb 27 2013
+
+- [#428](https://github.com/wycats/handlebars.js/issues/428) - Fix incorrect rendering of nested programs
+- Fix exception message ([@tricknotes](https://github.com/tricknotes))
+- Added negative number literal support
+- Concert library to single IIFE
+- Add handlebars-source gemspec ([@machty](https://github.com/machty))
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v1.0.9...v1.0.10)
+
+## v1.0.9 - Node - Feb 15 2013
+
+- Added `Handlebars.create` API in node module for sandboxed instances ([@tommydudebreaux](https://github.com/tommydudebreaux))
+
+[Commits](https://github.com/wycats/handlebars.js/compare/1.0.0-rc.3...v1.0.9)
+
+## 1.0.0-rc3 - Browser - Feb 14 2013
+
+- Prevent use of `this` or `..` in illogical place ([@leshill](https://github.com/leshill))
+- Allow AST passing for `parse`/`compile`/`precompile` ([@machty](https://github.com/machty))
+- Optimize generated output by inlining statements where possible
+- Check compiler version when evaluating templates
+- Package browser dist in npm package
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v1.0.8...1.0.0-rc.3)
+
+## Prior Versions
+
+When upgrading from the Handlebars 0.9 series, be aware that the
+signature for passing custom helpers or partials to templates has
+changed.
+
+Instead of:
+
+```js
+template(context, helpers, partials, [data])
+```
+
+Use:
+
+```js
+template(context, {helpers: helpers, partials: partials, data: data})
+```
@@ -0,0 +1 @@
+{{foo}}
@@ -0,0 +1 @@
+Hello, {{name}}!
@@ -111,7 +111,11 @@ describe "Parser" do
    end

    def data(id)
-      "@#{id}"
+      "@ID:#{id}"
+    end
+
+    def partial_name(name)
+      "PARTIAL:#{name}"
    end

    def path(*parts)
@@ -121,6 +125,10 @@ describe "Parser" do

  it "parses simple mustaches" do
    ast_for("{{foo}}").should == root { mustache id("foo") }
+    ast_for("{{foo?}}").should == root { mustache id("foo?") }
+    ast_for("{{foo_}}").should == root { mustache id("foo_") }
+    ast_for("{{foo-}}").should == root { mustache id("foo-") }
+    ast_for("{{foo:}}").should == root { mustache id("foo:") }
  end

  it "parses simple mustaches with data" do
@@ -218,11 +226,15 @@ describe "Parser" do
  end

  it "parses a partial" do
-    ast_for("{{> foo }}").should == root { partial id("foo") }
+    ast_for("{{> foo }}").should == root { partial partial_name("foo") }
  end

  it "parses a partial with context" do
-    ast_for("{{> foo bar}}").should == root { partial id("foo"), id("bar") }
+    ast_for("{{> foo bar}}").should == root { partial partial_name("foo"), id("bar") }
+  end
+
+  it "parses a partial with a complex name" do
+    ast_for("{{> shared/partial?.bar}}").should == root { partial partial_name("shared/partial?.bar") }
  end

  it "parses a comment" do
@@ -253,6 +265,130 @@ describe "Parser" do
    end
  end

+  it "parses an inverse ('else'-style) section" do
+    ast_for("{{#foo}} bar {{else}} baz {{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          content " bar "
+        end
+
+        inverse do
+          content " baz "
+        end
+      end
+    end
+  end
+
+  it "parses empty blocks" do
+    ast_for("{{#foo}}{{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          #  empty program
+        end
+      end
+    end
+  end
+
+  it "parses empty blocks with empty inverse section" do
+    ast_for("{{#foo}}{{^}}{{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          #  empty program
+        end
+
+        inverse do
+          #  empty inverse
+        end
+      end
+    end
+  end
+
+  it "parses empty blocks with empty inverse ('else'-style) section" do
+    ast_for("{{#foo}}{{else}}{{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          #  empty program
+        end
+
+        inverse do
+          #  empty inverse
+        end
+      end
+    end
+  end
+
+  it "parses non-empty blocks with empty inverse section" do
+    ast_for("{{#foo}} bar {{^}}{{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          content " bar "
+        end
+
+        inverse do
+          #  empty inverse
+        end
+      end
+    end
+  end
+
+  it "parses non-empty blocks with empty inverse ('else'-style) section" do
+    ast_for("{{#foo}} bar {{else}}{{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          content " bar "
+        end
+
+        inverse do
+          #  empty inverse
+        end
+      end
+    end
+  end
+
+  it "parses empty blocks with non-empty inverse section" do
+    ast_for("{{#foo}}{{^}} bar {{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          #  empty program
+        end
+
+        inverse do
+          content " bar "
+        end
+      end
+    end
+  end
+
+  it "parses empty blocks with non-empty inverse ('else'-style) section" do
+    ast_for("{{#foo}}{{else}} bar {{/foo}}").should == root do
+      block do
+        mustache id("foo")
+
+        program do
+          #  empty program
+        end
+
+        inverse do
+          content " bar "
+        end
+      end
+    end
+  end
+
  it "parses a standalone inverse section" do
    ast_for("{{^foo}}bar{{/foo}}").should == root do
      block do
@@ -279,4 +415,12 @@ describe "Parser" do
  it "knows how to report the correct line number in errors when the first character is a newline" do
    lambda { ast_for("\n\nhello\n\nmy\n\n{{foo}") }.should raise_error(V8::JSError, /Parse error on line 7/m)
  end
+
+  context "externally compiled AST" do
+    it "can pass through an already-compiled AST" do
+      ast_for(@context.eval('new Handlebars.AST.ProgramNode([ new Handlebars.AST.ContentNode("Hello")]);')).should == root do
+        content "Hello"
+      end
+    end
+  end
 end
@@ -20,30 +20,28 @@ if (!Handlebars) {
      return Handlebars.compile(template, options);
    }
  };
+} else {
+  var _equal = equal;
+  equals = equal = function(a, b, msg) {
+    // Allow exec with missing message params
+    _equal(a, b, msg || '');
+  };
 }

 suite("basic context");

-Handlebars.registerHelper('helperMissing', function(helper, context) {
-  if(helper === "link_to") {
-    return new Handlebars.SafeString("<a>" + context + "</a>");
-  }
-});
-
 function shouldCompileTo(string, hashOrArray, expected, message) {
  shouldCompileToWithPartials(string, hashOrArray, false, expected, message);
 }
+
 function shouldCompileToWithPartials(string, hashOrArray, partials, expected, message) {
+  var result = compileWithPartials(string, hashOrArray, partials);
+  equal(result, expected, "'" + expected + "' should === '" + result + "': " + message);
+}
+
+function compileWithPartials(string, hashOrArray, partials) {
  var template = CompilerContext[partials ? 'compileWithPartial' : 'compile'](string), ary;
  if(Object.prototype.toString.call(hashOrArray) === "[object Array]") {
-    var helpers = hashOrArray[1];
-
-    if(helpers) {
-      for(var prop in Handlebars.helpers) {
-        helpers[prop] = Handlebars.helpers[prop];
-      }
-    }
-
    ary = [];
    ary.push(hashOrArray[0]);
    ary.push({ helpers: hashOrArray[1], partials: hashOrArray[2] });
@@ -51,18 +49,31 @@ function shouldCompileToWithPartials(string, hashOrArray, partials, expected, me
    ary = [hashOrArray];
  }

-  var result = template.apply(this, ary);
-  equal(result, expected, "'" + expected + "' should === '" + result + "': " + message);
+  return template.apply(this, ary);
 }

 function shouldThrow(fn, exception, message) {
-  var caught = false;
+  var caught = false,
+      exType, exMessage;
+
+  if (exception instanceof Array) {
+    exType = exception[0];
+    exMessage = exception[1];
+  } else if (typeof exception === 'string') {
+    exType = Error;
+    exMessage = exception;
+  } else {
+    exType = exception;
+  }
+
  try {
    fn();
  }
  catch (e) {
-    if (e instanceof exception) {
-      caught = true;
+    if (e instanceof exType) {
+      if (!exMessage || e.message === exMessage) {
+        caught = true;
+      }
    }
  }

@@ -73,6 +84,12 @@ test("most basic", function() {
  shouldCompileTo("{{foo}}", { foo: "foo" }, "foo");
 });

+test("escaping", function() {
+  shouldCompileTo("\\{{foo}}", { foo: "food" }, "{{foo}}");
+  shouldCompileTo("\\\\{{foo}}", { foo: "food" }, "\\food");
+  shouldCompileTo("\\\\ {{foo}}", { foo: "food" }, "\\\\ food");
+});
+
 test("compiling with a basic context", function() {
  shouldCompileTo("Goodbye\n{{cruel}}\n{{world}}!", {cruel: "cruel", world: "world"}, "Goodbye\ncruel\nworld!",
                  "It works if all the required keys are provided");
@@ -136,8 +153,18 @@ test("functions returning safestrings shouldn't be escaped", function() {
 test("functions", function() {
  shouldCompileTo("{{awesome}}", {awesome: function() { return "Awesome"; }}, "Awesome",
                  "functions are called and render their output");
+  shouldCompileTo("{{awesome}}", {awesome: function() { return this.more; }, more:  "More awesome"}, "More awesome",
+                  "functions are bound to the context");
 });

+test("functions with context argument", function() {
+  shouldCompileTo("{{awesome frank}}",
+      {awesome: function(context) { return context; },
+        frank: "Frank"},
+      "Frank", "functions are called with context arguments");
+});
+
+
 test("paths with hyphens", function() {
  shouldCompileTo("{{foo-bar}}", {"foo-bar": "baz"}, "baz", "Paths can contain hyphens (-)");
  shouldCompileTo("{{foo.foo-bar}}", {foo: {"foo-bar": "baz"}}, "baz", "Paths can contain hyphens (-)");
@@ -155,20 +182,15 @@ test("nested paths with empty string value", function() {
 });

 test("literal paths", function() {
-	shouldCompileTo("Goodbye {{[@alan]/expression}} world!", {"@alan": {expression: "beautiful"}},
-			"Goodbye beautiful world!", "Literal paths can be used");
+  shouldCompileTo("Goodbye {{[@alan]/expression}} world!", {"@alan": {expression: "beautiful"}},
+      "Goodbye beautiful world!", "Literal paths can be used");
+  shouldCompileTo("Goodbye {{[foo bar]/expression}} world!", {"foo bar": {expression: "beautiful"}},
+      "Goodbye beautiful world!", "Literal paths can be used");
 });

-test("--- TODO --- bad idea nested paths", function() {
-  return;
-	var hash     = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
-  shouldThrow(function() {
-      CompilerContext.compile("{{#goodbyes}}{{../name/../name}}{{/goodbyes}}")(hash);
-    }, Handlebars.Exception,
-    "Cannot jump (..) into previous context after moving into a context.");
-
-  var string = "{{#goodbyes}}{{.././world}} {{/goodbyes}}";
-  shouldCompileTo(string, hash, "world world world ", "Same context (.) is ignored in paths");
+test('literal references', function() {
+  shouldCompileTo("Goodbye {{[foo bar]}} world!", {"foo bar": "beautiful"},
+      "Goodbye beautiful world!", "Literal paths can be used");
 });

 test("that current context path ({{.}}) doesn't hit helpers", function() {
@@ -191,8 +213,15 @@ test("this keyword in paths", function() {
  shouldCompileTo(string, hash, "helloHelloHELLO", "This keyword evaluates in more complex paths");
 });

+test("this keyword nested inside path", function() {
+  var string = "{{#hellos}}{{text/this/foo}}{{/hellos}}";
+  shouldThrow(function() {
+      CompilerContext.compile(string);
+    }, Error, "Should throw exception");
+});
+
 test("this keyword in helpers", function() {
-  var helpers = {foo: function(value, options) {
+  var helpers = {foo: function(value) {
      return 'bar ' + value;
  }};
  var string = "{{#goodbyes}}{{foo this}}{{/goodbyes}}";
@@ -205,6 +234,13 @@ test("this keyword in helpers", function() {
  shouldCompileTo(string, [hash, helpers], "bar hellobar Hellobar HELLO", "This keyword evaluates in more complex paths");
 });

+test("this keyword nested inside helpers param", function() {
+  var string = "{{#hellos}}{{foo text/this/foo}}{{/hellos}}";
+  shouldThrow(function() {
+      CompilerContext.compile(string);
+    }, Error, "Should throw exception");
+});
+
 suite("inverted sections");

 test("inverted sections with unset value", function() {
@@ -270,6 +306,14 @@ test("block with complex lookup", function() {
                  "Templates can access variables in contexts up the stack with relative path syntax");
 });

+test("block with complex lookup using nested context", function() {
+  var string = "{{#goodbyes}}{{text}} cruel {{foo/../name}}! {{/goodbyes}}";
+
+  shouldThrow(function() {
+      CompilerContext.compile(string);
+    }, Error, "Should throw exception");
+});
+
 test("helper with complex lookup$", function() {
  var string = "{{#goodbyes}}{{{link ../prefix}}}{{/goodbyes}}";
  var hash = {prefix: "/root", goodbyes: [{text: "Goodbye", url: "goodbye"}]};
@@ -435,12 +479,49 @@ test("providing a helpers hash", function() {
                  "Goodbye cruel world!", "helpers hash is available inside other blocks");
 });

-test("in cases of conflict, the explicit hash wins", function() {
-
+test("in cases of conflict, helpers win", function() {
+  shouldCompileTo("{{{lookup}}}", [{lookup: 'Explicit'}, {lookup: function() { return 'helpers'; }}], "helpers",
+                  "helpers hash has precedence escaped expansion");
+  shouldCompileTo("{{lookup}}", [{lookup: 'Explicit'}, {lookup: function() { return 'helpers'; }}], "helpers",
+                  "helpers hash has precedence simple expansion");
 });

 test("the helpers hash is available is nested contexts", function() {
+  shouldCompileTo("{{#outer}}{{#inner}}{{helper}}{{/inner}}{{/outer}}",
+                [{'outer': {'inner': {'unused':[]}}},  {'helper': function() { return 'helper'; }}], "helper",
+                "helpers hash is available in nested contexts.");
+});

+test("the helper hash should augment the global hash", function() {
+  Handlebars.registerHelper('test_helper', function() { return 'found it!'; });
+
+  shouldCompileTo(
+    "{{test_helper}} {{#if cruel}}Goodbye {{cruel}} {{world}}!{{/if}}", [
+      {cruel: "cruel"},
+      {world: function() { return "world!"; }}
+    ],
+    "found it! Goodbye cruel world!!");
+});
+
+test("Multiple global helper registration", function() {
+  var helpers = Handlebars.helpers;
+  try {
+    Handlebars.helpers = {};
+    Handlebars.registerHelper({
+      'if': helpers['if'],
+      world: function() { return "world!"; },
+      test_helper: function() { return 'found it!'; }
+    });
+
+    shouldCompileTo(
+      "{{test_helper}} {{#if cruel}}Goodbye {{cruel}} {{world}}!{{/if}}",
+      [{cruel: "cruel"}],
+      "found it! Goodbye cruel world!!");
+  } finally {
+    if (helpers) {
+      Handlebars.helpers = helpers;
+    }
+  }
 });

 suite("partials");
@@ -473,14 +554,14 @@ test("rendering undefined partial throws an exception", function() {
  shouldThrow(function() {
      var template = CompilerContext.compile("{{> whatever}}");
      template();
-    }, Handlebars.Exception, "Should throw exception");
+    }, [Handlebars.Exception, 'The partial whatever could not be found'], "Should throw exception");
 });

 test("rendering template partial in vm mode throws an exception", function() {
  shouldThrow(function() {
      var template = CompilerContext.compile("{{> whatever}}");
      template();
-    }, Handlebars.Exception, "Should throw exception");
+    }, [Handlebars.Exception, 'The partial whatever could not be found'], "Should throw exception");
 });

 test("rendering function partial in vm mode", function() {
@@ -500,11 +581,66 @@ test("GH-14: a partial preceding a selector", function() {
   shouldCompileToWithPartials(string, [hash, {}, {dude:dude}], true, "Dudes: Jeepers Creepers", "Regular selectors can follow a partial");
 });

-test("Partials with literal paths", function() {
-	var string = "Dudes: {{> [dude]}}";
+test("Partials with slash paths", function() {
+	var string = "Dudes: {{> shared/dude}}";
 	var dude = "{{name}}";
 	var hash = {name:"Jeepers", another_dude:"Creepers"};
-  shouldCompileToWithPartials(string, [hash, {}, {dude:dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
+  shouldCompileToWithPartials(string, [hash, {}, {'shared/dude':dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
+});
+
+test("Partials with slash and point paths", function() {
+  var string = "Dudes: {{> shared/dude.thing}}";
+  var dude = "{{name}}";
+  var hash = {name:"Jeepers", another_dude:"Creepers"};
+  shouldCompileToWithPartials(string, [hash, {}, {'shared/dude.thing':dude}], true, "Dudes: Jeepers", "Partials can use literal with points in paths");
+});
+
+test("Global Partials", function() {
+  Handlebars.registerPartial('global_test', '{{another_dude}}');
+
+  var string = "Dudes: {{> shared/dude}} {{> global_test}}";
+  var dude = "{{name}}";
+  var hash = {name:"Jeepers", another_dude:"Creepers"};
+  shouldCompileToWithPartials(string, [hash, {}, {'shared/dude':dude}], true, "Dudes: Jeepers Creepers", "Partials can use globals or passed");
+});
+
+test("Multiple partial registration", function() {
+  Handlebars.registerPartial({
+    'shared/dude': '{{name}}',
+    global_test: '{{another_dude}}'
+  });
+
+  var string = "Dudes: {{> shared/dude}} {{> global_test}}";
+  var hash = {name:"Jeepers", another_dude:"Creepers"};
+  shouldCompileToWithPartials(string, [hash], true, "Dudes: Jeepers Creepers", "Partials can use globals or passed");
+});
+
+test("Partials with integer path", function() {
+	var string = "Dudes: {{> 404}}";
+	var dude = "{{name}}";
+	var hash = {name:"Jeepers", another_dude:"Creepers"};
+  shouldCompileToWithPartials(string, [hash, {}, {404:dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
+});
+
+test("Partials with complex path", function() {
+  var string = "Dudes: {{> 404/asdf?.bar}}";
+  var dude = "{{name}}";
+  var hash = {name:"Jeepers", another_dude:"Creepers"};
+  shouldCompileToWithPartials(string, [hash, {}, {'404/asdf?.bar':dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
+});
+
+test("Partials with escaped", function() {
+  var string = "Dudes: {{> [+404/asdf?.bar]}}";
+  var dude = "{{name}}";
+  var hash = {name:"Jeepers", another_dude:"Creepers"};
+  shouldCompileToWithPartials(string, [hash, {}, {'+404/asdf?.bar':dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
+});
+
+test("Partials with string", function() {
+  var string = "Dudes: {{> \"+404/asdf?.bar\"}}";
+  var dude = "{{name}}";
+  var hash = {name:"Jeepers", another_dude:"Creepers"};
+  shouldCompileToWithPartials(string, [hash, {}, {'+404/asdf?.bar':dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
 });

 suite("String literal parameters");
@@ -520,6 +656,16 @@ test("simple literals work", function() {
  }};
  shouldCompileTo(string, [hash, helpers], "Message: Hello world 12 times: true false", "template with a simple String literal");
 });
+test("negative number literals work", function() {
+  var string   = 'Message: {{hello -12}}';
+  var hash     = {};
+  var helpers  = {hello: function(times) {
+    if(typeof times !== 'number') { times = "NaN"; }
+    return "Hello " + times + " times";
+  }};
+  shouldCompileTo(string, [hash, helpers], "Message: Hello -12 times", "template with a negative integer literal");
+});
+

 test("using a quote in the middle of a parameter raises an error", function() {
  shouldThrow(function() {
@@ -568,13 +714,34 @@ test("constructing a safestring from a string and checking its type", function()
  equal(safe, "testing 1, 2, 3", "SafeString is equivalent to its underlying string");
 });

+test("it should not escape SafeString properties", function() {
+  var name = new Handlebars.SafeString("<em>Sean O&#x27;Malley</em>");
+
+  shouldCompileTo('{{name}}', [{ name: name }], "<em>Sean O&#x27;Malley</em>");
+});
+
 suite("helperMissing");

 test("if a context is not found, helperMissing is used", function() {
+  shouldThrow(function() {
+      var template = CompilerContext.compile("{{hello}} {{link_to world}}");
+      template({});
+    }, [Error, "Missing helper: 'link_to'"], "Should throw exception");
+});
+
+test("if a context is not found, custom helperMissing is used", function() {
  var string = "{{hello}} {{link_to world}}";
  var context = { hello: "Hello", world: "world" };

-  shouldCompileTo(string, context, "Hello <a>world</a>");
+  var helpers = {
+    helperMissing: function(helper, context) {
+      if(helper === "link_to") {
+        return new Handlebars.SafeString("<a>" + context + "</a>");
+      }
+    }
+  };
+
+  shouldCompileTo(string, [context, helpers], "Hello <a>world</a>");
 });

 suite("knownHelpers");
@@ -616,6 +783,16 @@ test("Invert blocks work in knownHelpers only mode", function() {
  var result = template({foo: false});
  equal(result, "bar", "'bar' should === '" + result);
 });
+test("Functions are bound to the context in knownHelpers only mode", function() {
+  var template = CompilerContext.compile("{{foo}}", {knownHelpersOnly: true});
+  var result = template({foo: function() { return this.bar; }, bar: 'bar'});
+  equal(result, "bar", "'bar' should === '" + result);
+});
+test("Unknown helper call in knownHelpers only mode should throw", function() {
+  shouldThrow(function() {
+    CompilerContext.compile("{{typeof hello}}", {knownHelpersOnly: true});
+  }, Error, 'specified knownHelpersOnly');
+});

 suite("blockHelperMissing");

@@ -624,6 +801,11 @@ test("lambdas are resolved by blockHelperMissing, not handlebars proper", functi
  var data = { truthy: function() { return true; } };
  shouldCompileTo(string, data, "yep");
 });
+test("lambdas resolved by blockHelperMissing are bound to the context", function() {
+  var string = "{{#truthy}}yep{{/truthy}}";
+  var boundData = { truthy: function() { return this.truthiness(); }, truthiness: function() { return false; } };
+  shouldCompileTo(string, boundData, "");
+});

 var teardown;
 suite("built-in helpers", {
@@ -635,6 +817,10 @@ test("with", function() {
  var string = "{{#with person}}{{first}} {{last}}{{/with}}";
  shouldCompileTo(string, {person: {first: "Alan", last: "Johnson"}}, "Alan Johnson");
 });
+test("with with function argument", function() {
+  var string = "{{#with person}}{{first}} {{last}}{{/with}}";
+  shouldCompileTo(string, {person: function() { return {first: "Alan", last: "Johnson"};}}, "Alan Johnson");
+});

 test("if", function() {
  var string   = "{{#if goodbye}}GOODBYE {{/if}}cruel {{world}}!";
@@ -673,6 +859,22 @@ test("each", function() {
                  "each with array argument ignores the contents when empty");
 });

+test("each with an object and @key", function() {
+  var string   = "{{#each goodbyes}}{{@key}}. {{text}}! {{/each}}cruel {{world}}!";
+  var hash     = {goodbyes: {"<b>#1</b>": {text: "goodbye"}, 2: {text: "GOODBYE"}}, world: "world"};
+
+  // Object property iteration order is undefined according to ECMA spec,
+  // so we need to check both possible orders
+  // @see http://stackoverflow.com/questions/280713/elements-order-in-a-for-in-loop
+  var actual = compileWithPartials(string, hash);
+  var expected1 = "&lt;b&gt;#1&lt;/b&gt;. goodbye! 2. GOODBYE! cruel world!";
+  var expected2 = "2. GOODBYE! &lt;b&gt;#1&lt;/b&gt;. goodbye! cruel world!";
+
+  ok(actual === expected1 || actual === expected2, "each with object argument iterates over the contents when not empty");
+  shouldCompileTo(string, {goodbyes: [], world: "world"}, "cruel world!",
+                  "each with object argument ignores the contents when empty");
+});
+
 test("each with @index", function() {
  var string = "{{#each goodbyes}}{{@index}}. {{text}}! {{/each}}cruel {{world}}!";
  var hash   = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
@@ -683,16 +885,43 @@ test("each with @index", function() {
  equal(result, "0. goodbye! 1. Goodbye! 2. GOODBYE! cruel world!", "The @index variable is used");
 });

+test("each with function argument", function() {
+  var string = "{{#each goodbyes}}{{text}}! {{/each}}cruel {{world}}!";
+  var hash   = {goodbyes: function () { return [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}];}, world: "world"};
+  shouldCompileTo(string, hash, "goodbye! Goodbye! GOODBYE! cruel world!",
+            "each with array function argument iterates over the contents when not empty");
+  shouldCompileTo(string, {goodbyes: [], world: "world"}, "cruel world!",
+            "each with array function argument ignores the contents when empty");
+});
+
+test("data passed to helpers", function() {
+  var string = "{{#each letters}}{{this}}{{detectDataInsideEach}}{{/each}}";
+  var hash = {letters: ['a', 'b', 'c']};
+
+  var template = CompilerContext.compile(string);
+  var result = template(hash, {
+    data: {
+      exclaim: '!'
+    }
+  });
+  equal(result, 'a!b!c!', 'should output data');
+});
+
+Handlebars.registerHelper('detectDataInsideEach', function(options) {
+  return options.data && options.data.exclaim;
+});
+
 test("log", function() {
  var string = "{{log blah}}";
  var hash   = { blah: "whee" };

-  var logArg;
+  var levelArg, logArg;
  var originalLog = Handlebars.log;
-  Handlebars.log = function(arg){ logArg = arg; };
+  Handlebars.log = function(level, arg){ levelArg = level, logArg = arg; };
  teardown = function(){ Handlebars.log = originalLog; };

  shouldCompileTo(string, hash, "", "log should not display");
+  equals(1, levelArg, "should call log with 1");
  equals("whee", logArg, "should call log with 'whee'");
 });

@@ -764,6 +993,54 @@ test("hash values can be looked up via @foo", function() {
  equals("Hello world", result, "@foo as a parameter retrieves template data");
 });

+test("nested parameter data can be looked up via @foo.bar", function() {
+  var template = CompilerContext.compile("{{hello @world.bar}}");
+  var helpers = {
+    hello: function(noun) {
+      return "Hello " + noun;
+    }
+  };
+
+  var result = template({}, { helpers: helpers, data: { world: {bar: "world" } } });
+  equals("Hello world", result, "@foo as a parameter retrieves template data");
+});
+
+test("nested parameter data does not fail with @world.bar", function() {
+  var template = CompilerContext.compile("{{hello @world.bar}}");
+  var helpers = {
+    hello: function(noun) {
+      return "Hello " + noun;
+    }
+  };
+
+  var result = template({}, { helpers: helpers, data: { foo: {bar: "world" } } });
+  equals("Hello undefined", result, "@foo as a parameter retrieves template data");
+});
+
+test("parameter data throws when using this scope references", function() {
+  var string = "{{#goodbyes}}{{text}} cruel {{@./name}}! {{/goodbyes}}";
+
+  shouldThrow(function() {
+      CompilerContext.compile(string);
+    }, Error, "Should throw exception");
+});
+
+test("parameter data throws when using parent scope references", function() {
+  var string = "{{#goodbyes}}{{text}} cruel {{@../name}}! {{/goodbyes}}";
+
+  shouldThrow(function() {
+      CompilerContext.compile(string);
+    }, Error, "Should throw exception");
+});
+
+test("parameter data throws when using complex scope references", function() {
+  var string = "{{#goodbyes}}{{text}} cruel {{@foo/../name}}! {{/goodbyes}}";
+
+  shouldThrow(function() {
+      CompilerContext.compile(string);
+    }, Error, "Should throw exception");
+});
+
 test("data is inherited downstream", function() {
  var template = CompilerContext.compile("{{#let foo=bar.baz}}{{@foo}}{{/let}}", { data: true });
  var helpers = {
@@ -1070,7 +1347,7 @@ test("arguments to helpers can be retrieved from options hash in string form", f
  var template = CompilerContext.compile('{{wycats is.a slave.driver}}', {stringParams: true});

  var helpers = {
-    wycats: function(passiveVoice, noun, options) {
+    wycats: function(passiveVoice, noun) {
      return "HELP ME MY BOSS " + passiveVoice + ' ' + noun;
    }
  };
@@ -1118,6 +1395,74 @@ test("when inside a block in String mode, .. passes the appropriate context in t
  equals(result, "STOP ME FROM READING HACKER NEWS I need-a dad.joke", "Proper context variable output");
 });

+test("in string mode, information about the types is passed along", function() {
+  var template = CompilerContext.compile('{{tomdale "need" dad.joke true false}}', { stringParams: true });
+
+  var helpers = {
+    tomdale: function(desire, noun, trueBool, falseBool, options) {
+      equal(options.types[0], 'STRING', "the string type is passed");
+      equal(options.types[1], 'ID', "the expression type is passed");
+      equal(options.types[2], 'BOOLEAN', "the expression type is passed");
+      equal(desire, "need", "the string form is passed for strings");
+      equal(noun, "dad.joke", "the string form is passed for expressions");
+      equal(trueBool, true, "raw booleans are passed through");
+      equal(falseBool, false, "raw booleans are passed through");
+      return "Helper called";
+    }
+  };
+
+  var result = template({}, { helpers: helpers });
+  equal(result, "Helper called");
+});
+
+test("in string mode, hash parameters get type information", function() {
+  var template = CompilerContext.compile('{{tomdale he.says desire="need" noun=dad.joke bool=true}}', { stringParams: true });
+
+  var helpers = {
+    tomdale: function(exclamation, options) {
+      equal(exclamation, "he.says");
+      equal(options.types[0], "ID");
+
+      equal(options.hashTypes.desire, "STRING");
+      equal(options.hashTypes.noun, "ID");
+      equal(options.hashTypes.bool, "BOOLEAN");
+      equal(options.hash.desire, "need");
+      equal(options.hash.noun, "dad.joke");
+      equal(options.hash.bool, true);
+      return "Helper called";
+    }
+  };
+
+  var result = template({}, { helpers: helpers });
+  equal(result, "Helper called");
+});
+
+test("in string mode, hash parameters get context information", function() {
+  var template = CompilerContext.compile('{{#with dale}}{{tomdale he.says desire="need" noun=../dad/joke bool=true}}{{/with}}', { stringParams: true });
+
+  var context = {dale: {}};
+
+  var helpers = {
+    tomdale: function(exclamation, options) {
+      equal(exclamation, "he.says");
+      equal(options.types[0], "ID");
+
+      equal(options.contexts.length, 1);
+      equal(options.hashContexts.noun, context);
+      equal(options.hash.desire, "need");
+      equal(options.hash.noun, "dad.joke");
+      equal(options.hash.bool, true);
+      return "Helper called";
+    },
+    "with": function(context, options) {
+      return options.fn(options.contexts[0][context]);
+    }
+  };
+
+  var result = template(context, { helpers: helpers });
+  equal(result, "Helper called");
+});
+
 test("when inside a block in String mode, .. passes the appropriate context in the options hash to a block helper", function() {
  var template = CompilerContext.compile('{{#with dale}}{{#tomdale ../need dad.joke}}wot{{/tomdale}}{{/with}}', {stringParams: true});

@@ -1198,3 +1543,115 @@ test("bug reported by @fat where lambdas weren't being properly resolved", funct
  var output = "<strong>This is a slightly more complicated blah.</strong>.\n\nCheck this out:\n\n<ul>\n\n<li class=one>@fat</li>\n\n<li class=two>@dhg</li>\n\n<li class=three>@sayrer</li>\n</ul>.\n\n";
  shouldCompileTo(string, data, output);
 });
+
+test("Passing falsy values to Handlebars.compile throws an error", function() {
+  shouldThrow(function() {
+    CompilerContext.compile(null);
+  }, "You must pass a string or Handlebars AST to Handlebars.precompile. You passed null");
+});
+
+test("can pass through an already-compiled AST via compile/precompile", function() {
+  equal(Handlebars.compile(new Handlebars.AST.ProgramNode([ new Handlebars.AST.ContentNode("Hello")]))(), 'Hello')
+});
+
+test('GH-408: Multiple loops fail', function() {
+  var context = [
+    { name: "John Doe", location: { city: "Chicago" } },
+    { name: "Jane Doe", location: { city: "New York"} }
+  ];
+
+  var template = CompilerContext.compile('{{#.}}{{name}}{{/.}}{{#.}}{{name}}{{/.}}{{#.}}{{name}}{{/.}}');
+
+  var result = template(context);
+  equals(result, "John DoeJane DoeJohn DoeJane DoeJohn DoeJane Doe", 'It should output multiple times');
+});
+
+test('GS-428: Nested if else rendering', function() {
+  var succeedingTemplate = '{{#inverse}} {{#blk}} Unexpected {{/blk}} {{else}}  {{#blk}} Expected {{/blk}} {{/inverse}}';
+  var failingTemplate = '{{#inverse}} {{#blk}} Unexpected {{/blk}} {{else}} {{#blk}} Expected {{/blk}} {{/inverse}}';
+
+  var helpers = {
+    blk: function(block) { return block.fn(''); },
+    inverse: function(block) { return block.inverse(''); }
+  };
+
+  shouldCompileTo(succeedingTemplate, [{}, helpers], '   Expected  ');
+  shouldCompileTo(failingTemplate, [{}, helpers], '  Expected  ');
+});
+
+test('GH-458: Scoped this identifier', function() {
+  shouldCompileTo('{{./foo}}', {foo: 'bar'}, 'bar');
+});
+
+test('GH-375: Unicode line terminators', function() {
+  shouldCompileTo('\u2028', {}, '\u2028');
+});
+
+test('GH-534: Object prototype aliases', function() {
+  Object.prototype[0xD834] = true;
+
+  shouldCompileTo('{{foo}}', { foo: 'bar' }, 'bar');
+
+  delete Object.prototype[0xD834];
+});
+
+test('GH-437: Matching escaping', function() {
+  shouldThrow(function() {
+    CompilerContext.compile('{{{a}}');
+  }, Error);
+  shouldThrow(function() {
+    CompilerContext.compile('{{a}}}');
+  }, Error);
+});
+
+suite('Utils');
+
+test('escapeExpression', function() {
+  equal(Handlebars.Utils.escapeExpression('foo<&"\'>'), 'foo&lt;&amp;&quot;&#x27;&gt;');
+  equal(Handlebars.Utils.escapeExpression(new Handlebars.SafeString('foo<&"\'>')), 'foo<&"\'>');
+  equal(Handlebars.Utils.escapeExpression(''), '');
+  equal(Handlebars.Utils.escapeExpression(undefined), '');
+  equal(Handlebars.Utils.escapeExpression(null), '');
+  equal(Handlebars.Utils.escapeExpression(false), '');
+
+  equal(Handlebars.Utils.escapeExpression(0), '0');
+  equal(Handlebars.Utils.escapeExpression({}), {}.toString());
+  equal(Handlebars.Utils.escapeExpression([]), [].toString());
+});
+
+test('isEmpty', function() {
+  equal(Handlebars.Utils.isEmpty(undefined), true);
+  equal(Handlebars.Utils.isEmpty(null), true);
+  equal(Handlebars.Utils.isEmpty(false), true);
+  equal(Handlebars.Utils.isEmpty(''), true);
+  equal(Handlebars.Utils.isEmpty([]), true);
+
+  equal(Handlebars.Utils.isEmpty(0), false);
+  equal(Handlebars.Utils.isEmpty([1]), false);
+  equal(Handlebars.Utils.isEmpty('foo'), false);
+  equal(Handlebars.Utils.isEmpty({bar: 1}), false);
+});
+
+if (typeof(require) !== 'undefined') {
+  suite('Require');
+
+  test('Load .handlebars files with require()', function() {
+    var template = require("./example_1");
+    assert.deepEqual(template, require("./example_1.handlebars"));
+
+    var expected = 'foo\n';
+    var result = template({foo: "foo"});
+
+    equal(result, expected);
+  });
+
+  test('Load .hbs files with require()', function() {
+    var template = require("./example_2");
+    assert.deepEqual(template, require("./example_2.hbs"));
+
+    var expected = 'Hello, World!\n';
+    var result = template({name: "World"});
+
+    equal(result, expected);
+  });
+}
@@ -76,9 +76,7 @@ module Handlebars
    CONTEXT.instance_eval do |context|
      Handlebars::Spec.load_helpers(context);

-      Handlebars::Spec.js_load(context, 'lib/handlebars/base.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/utils.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/runtime.js');
+      Handlebars::Spec.js_load(context, 'dist/handlebars.js');

      context["CompilerContext"] = {}
      CompilerContext = context["CompilerContext"]
@@ -89,47 +87,24 @@ module Handlebars
      end
      CompilerContext["compileWithPartial"] = proc do |this, *args|
        template, options = args[0], args[1] || nil
-        FULL_CONTEXT["Handlebars"]["compile"].call(template, options);
+        context["Handlebars"]["compile"].call(template, options);
      end
    end

+    PARSER_CONTEXT = V8::Context.new
+    PARSER_CONTEXT.instance_eval do |context|
+      Handlebars::Spec.load_helpers(context);
+
+      Handlebars::Spec.js_load(context, 'lib/handlebars/compiler/parser.js');
+    end
+
    COMPILE_CONTEXT = V8::Context.new
    COMPILE_CONTEXT.instance_eval do |context|
      Handlebars::Spec.load_helpers(context);

-      Handlebars::Spec.js_load(context, 'lib/handlebars/base.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/utils.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/compiler/parser.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/compiler/base.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/compiler/ast.js');
+      Handlebars::Spec.js_load(context, 'dist/handlebars.js');
      Handlebars::Spec.js_load(context, 'lib/handlebars/compiler/visitor.js');
      Handlebars::Spec.js_load(context, 'lib/handlebars/compiler/printer.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/compiler/compiler.js');
-
-      context["Handlebars"]["logger"]["level"] = ENV["DEBUG_JS"] ? context["Handlebars"]["logger"][ENV["DEBUG_JS"]] : 4
-
-      context["Handlebars"]["logger"]["log"] = proc do |this, level, str|
-        logger_level = context["Handlebars"]["logger"]["level"].to_i
-
-        if logger_level <= level
-          puts str
-        end
-      end
-    end
-
-    FULL_CONTEXT = V8::Context.new
-    FULL_CONTEXT.instance_eval do |context|
-      Handlebars::Spec.load_helpers(context);
-
-      Handlebars::Spec.js_load(context, 'lib/handlebars/base.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/utils.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/compiler/parser.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/compiler/base.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/compiler/ast.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/compiler/visitor.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/compiler/printer.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/compiler/compiler.js');
-      Handlebars::Spec.js_load(context, 'lib/handlebars/runtime.js');

      context["Handlebars"]["logger"]["level"] = ENV["DEBUG_JS"] ? context["Handlebars"]["logger"][ENV["DEBUG_JS"]] : 4

@@ -2,12 +2,9 @@ require "spec_helper"
 require "timeout"

 describe "Tokenizer" do
-  let(:parser) { @context["handlebars"] }
-  let(:lexer) { @context["handlebars"]["lexer"] }
+  let(:parser) { Handlebars::Spec::PARSER_CONTEXT["handlebars"] }
+  let(:lexer) { Handlebars::Spec::PARSER_CONTEXT["handlebars"]["lexer"] }

-  before(:all) do
-    @compiles = true
-  end
  Token = Struct.new(:name, :text)

  def tokenize(string)
@@ -44,6 +41,21 @@ describe "Tokenizer" do
    result[1].should be_token("ID", "foo")
  end

+  it "supports unescaping with &" do
+    result = tokenize("{{&bar}}")
+    result.should match_tokens(%w(OPEN ID CLOSE))
+
+    result[0].should be_token("OPEN", "{{&")
+    result[1].should be_token("ID", "bar")
+  end
+
+  it "supports unescaping with {{{" do
+    result = tokenize("{{{bar}}}")
+    result.should match_tokens(%w(OPEN_UNESCAPED ID CLOSE_UNESCAPED))
+
+    result[1].should be_token("ID", "bar")
+  end
+
  it "supports escaping delimiters" do
    result = tokenize("{{foo}} \\{{bar}} {{baz}}")
    result.should match_tokens(%w(OPEN ID CLOSE CONTENT CONTENT OPEN ID CLOSE))
@@ -152,12 +164,29 @@ describe "Tokenizer" do
    result.should match_tokens(%w(OPEN_PARTIAL ID CLOSE))
  end

+  it "tokenizes a partial space at the end as 'OPEN_PARTIAL ID CLOSE'" do
+    result = tokenize("{{>foo/bar.baz  }}")
+    result.should match_tokens(%w(OPEN_PARTIAL ID SEP ID SEP ID CLOSE))
+  end
+
  it "tokenizes a comment as 'COMMENT'" do
    result = tokenize("foo {{! this is a comment }} bar {{ baz }}")
    result.should match_tokens(%w(CONTENT COMMENT CONTENT OPEN ID CLOSE))
    result[1].should be_token("COMMENT", " this is a comment ")
  end

+  it "tokenizes a block comment as 'COMMENT'" do
+    result = tokenize("foo {{!-- this is a {{comment}} --}} bar {{ baz }}")
+    result.should match_tokens(%w(CONTENT COMMENT CONTENT OPEN ID CLOSE))
+    result[1].should be_token("COMMENT", " this is a {{comment}} ")
+  end
+
+  it "tokenizes a block comment with whitespace as 'COMMENT'" do
+    result = tokenize("foo {{!-- this is a\n{{comment}}\n--}} bar {{ baz }}")
+    result.should match_tokens(%w(CONTENT COMMENT CONTENT OPEN ID CLOSE))
+    result[1].should be_token("COMMENT", " this is a\n{{comment}}\n")
+  end
+
  it "tokenizes open and closing blocks as 'OPEN_BLOCK ID CLOSE ... OPEN_ENDBLOCK ID CLOSE'" do
    result = tokenize("{{#foo}}content{{/foo}}")
    result.should match_tokens(%w(OPEN_BLOCK ID CLOSE CONTENT OPEN_ENDBLOCK ID CLOSE))
@@ -195,6 +224,12 @@ describe "Tokenizer" do
    result[3].should be_token("STRING", "baz")
  end

+  it "tokenizes mustaches with String params using single quotes as 'OPEN ID ID STRING CLOSE'" do
+    result = tokenize("{{ foo bar \'baz\' }}")
+    result.should match_tokens(%w(OPEN ID ID STRING CLOSE))
+    result[3].should be_token("STRING", "baz")
+  end
+
  it "tokenizes String params with spaces inside as 'STRING'" do
    result = tokenize("{{ foo bar \"baz bat\" }}")
    result.should match_tokens(%w(OPEN ID ID STRING CLOSE))
@@ -207,10 +242,20 @@ describe "Tokenizer" do
    result[2].should be_token("STRING", %{bar"baz})
  end

+  it "tokenizes String params using single quotes with escapes quotes as 'STRING'" do
+    result = tokenize(%|{{ foo 'bar\\'baz' }}|)
+    result.should match_tokens(%w(OPEN ID STRING CLOSE))
+    result[2].should be_token("STRING", %{bar'baz})
+  end
+
  it "tokenizes numbers" do
    result = tokenize(%|{{ foo 1 }}|)
    result.should match_tokens(%w(OPEN ID INTEGER CLOSE))
    result[2].should be_token("INTEGER", "1")
+
+    result = tokenize(%|{{ foo -1 }}|)
+    result.should match_tokens(%w(OPEN ID INTEGER CLOSE))
+    result[2].should be_token("INTEGER", "-1")
  end

  it "tokenizes booleans" do
@@ -255,16 +300,16 @@ describe "Tokenizer" do

  it "tokenizes special @ identifiers" do
    result = tokenize("{{ @foo }}")
-    result.should match_tokens %w( OPEN DATA CLOSE )
-    result[1].should be_token("DATA", "foo")
+    result.should match_tokens %w( OPEN DATA ID CLOSE )
+    result[2].should be_token("ID", "foo")

    result = tokenize("{{ foo @bar }}")
-    result.should match_tokens %w( OPEN ID DATA CLOSE )
-    result[2].should be_token("DATA", "bar")
+    result.should match_tokens %w( OPEN ID DATA ID CLOSE )
+    result[3].should be_token("ID", "bar")

    result = tokenize("{{ foo bar=@baz }}")
-    result.should match_tokens %w( OPEN ID ID EQUALS DATA CLOSE )
-    result[4].should be_token("DATA", "baz")
+    result.should match_tokens %w( OPEN ID ID EQUALS DATA ID CLOSE )
+    result[5].should be_token("ID", "baz")
  end

  it "does not time out in a mustache with a single } followed by EOF" do
@@ -1,8 +1,9 @@

-%x mu emu
+%x mu emu com

 %%

+"\\\\"/("{{")                    { yytext = "\\"; return 'CONTENT'; }
 [^\x00]*?/("{{")                 {
                                   if(yytext.slice(-1) !== "\\") this.begin("mu");
                                   if(yytext.slice(-1) === "\\") yytext = yytext.substr(0,yyleng-1), this.begin("emu");
@@ -17,30 +18,44 @@
                                   return 'CONTENT';
                                 }

+<com>[\s\S]*?"--}}"              { yytext = yytext.substr(0, yyleng-4); this.popState(); return 'COMMENT'; }
+
 <mu>"{{>"                        { return 'OPEN_PARTIAL'; }
 <mu>"{{#"                        { return 'OPEN_BLOCK'; }
 <mu>"{{/"                        { return 'OPEN_ENDBLOCK'; }
 <mu>"{{^"                        { return 'OPEN_INVERSE'; }
 <mu>"{{"\s*"else"                { return 'OPEN_INVERSE'; }
 <mu>"{{{"                        { return 'OPEN_UNESCAPED'; }
-<mu>"{{&"                        { return 'OPEN_UNESCAPED'; }
+<mu>"{{&"                        { return 'OPEN'; }
+<mu>"{{!--"                      { this.popState(); this.begin('com'); }
 <mu>"{{!"[\s\S]*?"}}"            { yytext = yytext.substr(3,yyleng-5); this.popState(); return 'COMMENT'; }
 <mu>"{{"                         { return 'OPEN'; }

 <mu>"="                          { return 'EQUALS'; }
-<mu>"."/[} ]                     { return 'ID'; }
+<mu>"."/[}\/ ]                   { return 'ID'; }
 <mu>".."                         { return 'ID'; }
 <mu>[\/.]                        { return 'SEP'; }
 <mu>\s+                          { /*ignore whitespace*/ }
-<mu>"}}}"                        { this.popState(); return 'CLOSE'; }
+<mu>"}}}"                        { this.popState(); return 'CLOSE_UNESCAPED'; }
 <mu>"}}"                         { this.popState(); return 'CLOSE'; }
 <mu>'"'("\\"["]|[^"])*'"'        { yytext = yytext.substr(1,yyleng-2).replace(/\\"/g,'"'); return 'STRING'; }
-<mu>"'"("\\"[']|[^'])*"'"        { yytext = yytext.substr(1,yyleng-2).replace(/\\"/g,'"'); return 'STRING'; }
-<mu>"@"[a-zA-Z]+                 { yytext = yytext.substr(1); return 'DATA'; }
+<mu>"'"("\\"[']|[^'])*"'"        { yytext = yytext.substr(1,yyleng-2).replace(/\\'/g,"'"); return 'STRING'; }
+<mu>"@"                          { return 'DATA'; }
 <mu>"true"/[}\s]                 { return 'BOOLEAN'; }
 <mu>"false"/[}\s]                { return 'BOOLEAN'; }
-<mu>[0-9]+/[}\s]                 { return 'INTEGER'; }
-<mu>[a-zA-Z0-9_$-]+/[=}\s\/.]    { return 'ID'; }
+<mu>\-?[0-9]+/[}\s]              { return 'INTEGER'; }
+
+/*
+ID is the inverse of control characters.
+Control characters ranges:
+  [\s]          Whitespace
+  [!"#%-,\./]   !, ", #, %, &, ', (, ), *, +, ,, ., /,  Exceptions in range: $, -
+  [;->@]        ;, <, =, >, @,                          Exceptions in range: :, ?
+  [\[-\^`]      [, \, ], ^, `,                          Exceptions in range: _
+  [\{-~]        {, |, }, ~
+*/
+<mu>[^\s!"#%-,\.\/;->@\[-\^`\{-~]+/[=}\s\/.]   { return 'ID'; }
+
 <mu>'['[^\]]*']'                 { yytext = yytext.substr(1, yyleng-2); return 'ID'; }
 <mu>.                            { return 'INVALID'; }

@@ -7,8 +7,11 @@ root
  ;

 program
-  : statements simpleInverse statements { $$ = new yy.ProgramNode($1, $3); }
+  : simpleInverse statements { $$ = new yy.ProgramNode([], $2); }
+  | statements simpleInverse statements { $$ = new yy.ProgramNode($1, $3); }
+  | statements simpleInverse { $$ = new yy.ProgramNode($1, []); }
  | statements { $$ = new yy.ProgramNode($1); }
+  | simpleInverse { $$ = new yy.ProgramNode([], []); }
  | "" { $$ = new yy.ProgramNode([]); }
  ;

@@ -39,14 +42,17 @@ closeBlock
  ;

 mustache
-  : OPEN inMustache CLOSE { $$ = new yy.MustacheNode($2[0], $2[1]); }
-  | OPEN_UNESCAPED inMustache CLOSE { $$ = new yy.MustacheNode($2[0], $2[1], true); }
+  : OPEN inMustache CLOSE {
+    // Parsing out the '&' escape token at this level saves ~500 bytes after min due to the removal of one parser node.
+    $$ = new yy.MustacheNode($2[0], $2[1], $1[2] === '&');
+  }
+  | OPEN_UNESCAPED inMustache CLOSE_UNESCAPED { $$ = new yy.MustacheNode($2[0], $2[1], true); }
  ;


 partial
-  : OPEN_PARTIAL path CLOSE { $$ = new yy.PartialNode($2); }
-  | OPEN_PARTIAL path path CLOSE { $$ = new yy.PartialNode($2, $3); }
+  : OPEN_PARTIAL partialName CLOSE { $$ = new yy.PartialNode($2); }
+  | OPEN_PARTIAL partialName path CLOSE { $$ = new yy.PartialNode($2, $3); }
  ;

 simpleInverse
@@ -58,7 +64,7 @@ inMustache
  | path params { $$ = [[$1].concat($2), null]; }
  | path hash { $$ = [[$1], $2]; }
  | path { $$ = [[$1], null]; }
-  | DATA { $$ = [[new yy.DataNode($1)], null]; }
+  | dataName { $$ = [[$1], null]; }
  ;

 params
@@ -71,7 +77,7 @@ param
  | STRING { $$ = new yy.StringNode($1); }
  | INTEGER { $$ = new yy.IntegerNode($1); }
  | BOOLEAN { $$ = new yy.BooleanNode($1); }
-  | DATA { $$ = new yy.DataNode($1); }
+  | dataName { $$ = $1; }
  ;

 hash
@@ -88,7 +94,17 @@ hashSegment
  | ID EQUALS STRING { $$ = [$1, new yy.StringNode($3)]; }
  | ID EQUALS INTEGER { $$ = [$1, new yy.IntegerNode($3)]; }
  | ID EQUALS BOOLEAN { $$ = [$1, new yy.BooleanNode($3)]; }
-  | ID EQUALS DATA { $$ = [$1, new yy.DataNode($3)]; }
+  | ID EQUALS dataName { $$ = [$1, $3]; }
+  ;
+
+partialName
+  : path { $$ = new yy.PartialNameNode($1); }
+  | STRING { $$ = new yy.PartialNameNode(new yy.StringNode($1)); }
+  | INTEGER { $$ = new yy.PartialNameNode(new yy.IntegerNode($1)); }
+  ;
+
+dataName
+  : DATA path { $$ = new yy.DataNode($2); }
  ;

 path
@@ -96,7 +112,7 @@ path
  ;

 pathSegments
-  : pathSegments SEP ID { $1.push($3); $$ = $1; }
-  | ID { $$ = [$1]; }
+  : pathSegments SEP ID { $1.push({part: $3, separator: $2}); $$ = $1; }
+  | ID { $$ = [{part: $1}]; }
  ;

@@ -0,0 +1 @@
+// BEGIN(BROWSER)
@@ -0,0 +1,4 @@
+
+// END(BROWSER)
+
+module.exports = handlebars;