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
34 changed files with 3836 additions and 2509 deletions
@@ -2,6 +2,7 @@ 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/*
@@ -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,22 +1,32 @@
-[![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 " +
@@ -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.url + "'>" + 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);
@@ -134,7 +161,9 @@ 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>";
@@ -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

@@ -229,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

@@ -248,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
@@ -265,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
 ------------
@@ -288,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.
+
@@ -10,7 +10,7 @@ def compile_parser

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

@@ -45,11 +45,11 @@ def remove_exports(string)
  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

@@ -61,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"

@@ -81,11 +81,38 @@ 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"

@@ -64,6 +64,12 @@ var optimist = require('optimist')
        'type': 'boolean',
        'description': 'Include data when compiling',
        'alias': 'data'
+      },
+      'e': {
+        'type': 'string',
+        'description': 'Template extension.',
+        'alias': 'extension',
+        'default': 'handlebars'
      }
    })

@@ -109,6 +115,10 @@ 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) {
@@ -131,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);
      }
    });
@@ -153,13 +163,19 @@ function processTemplate(template, root) {
    } 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');
    }
  }
@@ -172,6 +188,13 @@ 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 if (!argv.commonjs) {
    output.push('})();');
@@ -180,10 +203,7 @@ if (!argv.simple) {
 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"
+  ]
+}
@@ -1,39 +1,80 @@
+/*
+
+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

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

-(function(Handlebars) {
-
-Handlebars.VERSION = "1.0.rc.2";
+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); }
@@ -84,6 +125,9 @@ 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);
  }
@@ -112,35 +156,32 @@ Handlebars.registerHelper('each', function(context, options) {
  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, options) {
  var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
  Handlebars.log(level, context);
 });
-
-}(this.Handlebars));
 ;
 // lib/handlebars/utils.js

@@ -164,48 +205,61 @@ 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 (!value && value !== 0) {
-        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;
+    }
+  }
+};
+;
 // lib/handlebars/runtime.js
+
 Handlebars.VM = {
  template: function(templateSpec) {
    // Just add water
@@ -216,39 +270,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) {
@@ -269,3 +357,6 @@ Handlebars.VM = {

 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.2";
+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); }
@@ -84,6 +102,9 @@ 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);
  }
@@ -112,27 +133,26 @@ Handlebars.registerHelper('each', function(context, options) {
  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, options) {
@@ -140,9 +160,7 @@ Handlebars.registerHelper('log', function(context, options) {
  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,130 +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(partialName, context) {
-    this.type         = "partial";
-    this.partialName  = partialName;
-    this.context      = context;
-  };
+Handlebars.AST.PartialNode = function(partialName, context) {
+  this.type         = "partial";
+  this.partialName  = partialName;
+  this.context      = context;
+};

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

-  Handlebars.AST.BlockNode = function(mustache, program, inverse, close) {
-    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); }
-    }
-
-    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;
-
-    this.stringModeValue = this.string;
-  };
-
-  Handlebars.AST.PartialNameNode = function(name) {
-    this.type = "PARTIAL_NAME";
-    this.name = name;
-  };
-
-  Handlebars.AST.DataNode = function(id) {
-    this.type = "DATA";
-    this.id = id;
-  };
-
-  Handlebars.AST.StringNode = function(string) {
-    this.type = "STRING";
-    this.string = string;
+Handlebars.AST.StringNode = function(string) {
+  this.type = "STRING";
+  this.original =
+    this.string =
    this.stringModeValue = 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);
-  };
+  this.stringModeValue = Number(integer);
+};

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

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

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

+return Handlebars;
+};
+
@@ -1,17 +1,21 @@
 var handlebars = require("./parser");
-var Handlebars = require("../base");
+
+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);
-};
 // 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();

@@ -116,7 +121,7 @@ Handlebars.PrintVisitor.prototype.PARTIAL_NAME = function(partialName) {
 };

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

 Handlebars.PrintVisitor.prototype.content = function(content) {
@@ -128,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,4 +1,6 @@
-var Handlebars = require("./base");
+exports.attach = function(Handlebars) {
+
+var toString = Object.prototype.toString;

 // BEGIN(BROWSER)

@@ -22,46 +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 (!value && value !== 0) {
-        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.7",
+  "version": "1.0.12",
  "homepage": "http://www.handlebarsjs.com/",
  "keywords": [
    "handlebars mustache template html"
@@ -15,7 +15,7 @@
  },
  "dependencies": {
    "optimist": "~0.3",
-    "uglify-js": "~1.2"
+    "uglify-js": "~2.3"
  },
  "devDependencies": {
    "benchmark": "~1.0",
@@ -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,7 @@ describe "Parser" do
    end

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

    def partial_name(name)
@@ -125,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
@@ -230,7 +234,7 @@ describe "Parser" do
  end

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

  it "parses a comment" do
@@ -411,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,6 +20,12 @@ 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");
@@ -36,14 +42,6 @@ function shouldCompileToWithPartials(string, hashOrArray, partials, expected, me
 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] = helpers[prop] || Handlebars.helpers[prop];
-      }
-    }
-
    ary = [];
    ary.push(hashOrArray[0]);
    ary.push({ helpers: hashOrArray[1], partials: hashOrArray[2] });
@@ -86,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");
@@ -153,6 +157,14 @@ test("functions", function() {
                  "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 (-)");
@@ -170,8 +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('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() {
@@ -194,6 +213,13 @@ 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) {
      return 'bar ' + value;
@@ -208,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() {
@@ -273,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"}]};
@@ -451,6 +492,38 @@ test("the helpers hash is available is nested contexts", function() {
                "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");

 test("basic partials", function() {
@@ -515,6 +588,33 @@ test("Partials with slash paths", function() {
  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}}";
@@ -522,6 +622,26 @@ test("Partials with integer path", function() {
  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");

@@ -536,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() {
@@ -584,13 +714,19 @@ 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, "Could not find property 'link_to'"], "Should throw exception");
+    }, [Error, "Missing helper: 'link_to'"], "Should throw exception");
 });

 test("if a context is not found, custom helperMissing is used", function() {
@@ -652,6 +788,11 @@ test("Functions are bound to the context in knownHelpers only mode", function()
  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");

@@ -676,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}}!";
@@ -740,6 +885,15 @@ 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']};
@@ -839,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 = {
@@ -1235,6 +1437,32 @@ test("in string mode, hash parameters get type information", function() {
  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});

@@ -1319,7 +1547,11 @@ test("bug reported by @fat where lambdas weren't being properly resolved", funct
 test("Passing falsy values to Handlebars.compile throws an error", function() {
  shouldThrow(function() {
    CompilerContext.compile(null);
-  }, "You must pass a string to Handlebars.compile. You passed 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() {
@@ -1333,3 +1565,93 @@ test('GH-408: Multiple loops fail', function() {
  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))
@@ -132,24 +144,29 @@ describe "Tokenizer" do
    result[4].should be_token("CONTENT", " baz")
  end

-  it "tokenizes a partial as 'OPEN_PARTIAL PARTIAL_NAME CLOSE'" do
+  it "tokenizes a partial as 'OPEN_PARTIAL ID CLOSE'" do
    result = tokenize("{{> foo}}")
-    result.should match_tokens(%w(OPEN_PARTIAL PARTIAL_NAME CLOSE))
+    result.should match_tokens(%w(OPEN_PARTIAL ID CLOSE))
  end

-  it "tokenizes a partial with context as 'OPEN_PARTIAL PARTIAL_NAME ID CLOSE'" do
+  it "tokenizes a partial with context as 'OPEN_PARTIAL ID ID CLOSE'" do
    result = tokenize("{{> foo bar }}")
-    result.should match_tokens(%w(OPEN_PARTIAL PARTIAL_NAME ID CLOSE))
+    result.should match_tokens(%w(OPEN_PARTIAL ID ID CLOSE))
  end

-  it "tokenizes a partial without spaces as 'OPEN_PARTIAL PARTIAL_NAME CLOSE'" do
+  it "tokenizes a partial without spaces as 'OPEN_PARTIAL ID CLOSE'" do
    result = tokenize("{{>foo}}")
-    result.should match_tokens(%w(OPEN_PARTIAL PARTIAL_NAME CLOSE))
+    result.should match_tokens(%w(OPEN_PARTIAL ID CLOSE))
  end

-  it "tokenizes a partial space at the end as 'OPEN_PARTIAL PARTIAL_NAME CLOSE'" do
+  it "tokenizes a partial space at the end as 'OPEN_PARTIAL ID CLOSE'" do
    result = tokenize("{{>foo  }}")
-    result.should match_tokens(%w(OPEN_PARTIAL PARTIAL_NAME CLOSE))
+    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
@@ -235,6 +252,10 @@ describe "Tokenizer" 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
@@ -279,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 com par
+%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");
@@ -19,35 +20,44 @@

 <com>[\s\S]*?"--}}"              { yytext = yytext.substr(0, yyleng-4); this.popState(); return 'COMMENT'; }

-<mu>"{{>"                        { this.begin("par"); return 'OPEN_PARTIAL'; }
+<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>"@"                          { 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'; }
-<par>\s+                         { /*ignore whitespace*/ }
-<par>[a-zA-Z0-9_$-/]+            { this.popState(); return 'PARTIAL_NAME'; }

 <INITIAL,mu><<EOF>>              { return 'EOF'; }

@@ -42,8 +42,11 @@ 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); }
  ;


@@ -61,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
@@ -74,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
@@ -91,11 +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
-  : PARTIAL_NAME { $$ = new yy.PartialNameNode($1); }
+  : 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
@@ -103,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}]; }
  ;
Author	SHA1	Message	Date
kpdecker	2a073e0993	1.0.12	2013-05-31 14:16:53 -04:00
kpdecker	f63b226b76	Update to 1.0.0 final	2013-05-31 14:16:45 -04:00
kpdecker	16fd601a5c	Merge global and passed helpers and partials	2013-05-31 13:12:06 -04:00
kpdecker	ef062adcc2	Move external AST tests into qunit spec	2013-05-31 13:11:22 -04:00
kpdecker	2024209519	Move upgrade notes to release-notes	2013-05-30 15:57:15 -04:00
kpdecker	d7b345b2da	Allow execution of helpers on the context Fixes #285	2013-05-30 15:47:30 -04:00
kpdecker	17659b9720	Ignore minimized files from git	2013-05-29 15:31:08 -04:00
kpdecker	58a0b4f17d	Require matching braces in escaped expressions Fixes #437	2013-05-29 15:30:50 -04:00
kpdecker	61f64e9f04	Add minify task to release target	2013-05-29 15:21:19 -04:00
kpdecker	66f6f94867	Update to latest uglify lib	2013-05-29 15:17:10 -04:00
kpdecker	c540d7186a	Allow function arguments to with and each Via @mcdan Fixes #239	2013-05-29 12:23:55 -04:00
kpdecker	293672432b	improve error message on missing helper Via @stefanpenner Fixes #523	2013-05-29 10:57:48 -04:00
kpdecker	da2aabe7bd	Allow ID, STRING, or INTEGER for partial name Fixes #519	2013-05-29 10:46:28 -04:00
kpdecker	3ddbc5237f	Protect from object prototype modifications Fixes #534	2013-05-28 17:03:07 -04:00
kpdecker	503e32208b	Improve tracking of original path values	2013-05-27 19:47:17 -04:00
kpdecker	15186dc9dd	Add supported environments statement Fixes #344	2013-05-27 19:03:16 -04:00
kpdecker	2c8dd74997	Add unescaped tokenizer tests	2013-05-27 14:59:45 -05:00
kpdecker	3d51088d4d	Fail if jison fails	2013-05-27 14:58:49 -05:00
kpdecker	822a8911ec	Add support for complex ids in @data references	2013-05-27 14:40:52 -05:00
kpdecker	5f349913aa	Update in the wild section Fixes #246	2013-05-27 12:29:57 -05:00
kpdecker	c1020a0130	Add unicode support for ID tokens Fixes #433 Fixes #469	2013-05-27 11:56:28 -05:00
kpdecker	bff71d79d3	Update release notes	2013-05-25 12:32:16 -05:00
kpdecker	4d95d58e15	Rebuild	2013-05-25 12:27:31 -05:00
Kevin Decker	47e0aa795a	Merge pull request #526 from jamesgorrie/master Fixing regex on partial names	2013-05-25 10:07:46 -07:00
kpdecker	6bf9c6fc13	Merge branch 'master' of github.com:wycats/handlebars.js	2013-05-22 08:40:28 -04:00
kpdecker	533be694b5	Use better variable name	2013-05-21 13:12:11 -05:00
kpdecker	a97820f54b	Update testing notes Fixes #467	2013-05-21 13:03:41 -05:00
kpdecker	f6b6361ad7	Fix typo	2013-05-21 13:03:01 -05:00
Kevin Decker	10669e0e36	Merge pull request #533 from blessenm/amd-precompilation-fix Fix for the issue #517	2013-05-21 08:46:27 -07:00
Blessan Mathew	69bcdf36c7	Fix for issue #517 . Now when compiiled with amd option and a single input argument, we are checking to see whether the input is a file or folder.	2013-05-21 20:50:46 +05:30
kpdecker	5ba17c9642	Merge branch 'master' of github.com:wycats/handlebars.js	2013-05-19 11:47:01 -05:00
kpdecker	7fb9750717	Update block helper docs in README Fixes #231, #259	2013-05-19 11:45:20 -05:00
kpdecker	c95d9d68ea	Use context rather than arg in README examples	2013-05-19 11:30:26 -05:00
kpdecker	3aef7f604a	Misc readme updates	2013-05-19 11:30:04 -05:00
James Gorrie	f5fe6d0bf6	Allowed for points to be in partial path name	2013-05-17 16:58:34 +01:00
Kevin Decker	94cc41900b	Merge pull request #515 from jjclark1982/master Allow requiring ".handlebars" files within Node.js scripts	2013-05-14 21:10:14 -07:00
Jesse Clark	d649b3581e	Only run "require" tests when require() is available	2013-05-15 10:50:01 +10:00
Jesse Clark	229b82bef5	Add unit tests for require() handler	2013-05-15 10:38:45 +10:00
Jesse Clark	531be77138	Publish a Node.js require() handler for handlebars files	2013-05-14 22:26:20 +10:00
kpdecker	4cf0410b7c	1.0.11	2013-05-13 23:09:21 -05:00
kpdecker	2ec5a97f4a	Update release notes	2013-05-13 23:08:43 -05:00
kpdecker	ddc4d31861	Rev to rc4	2013-05-13 23:07:29 -05:00
kpdecker	85dd39427b	Add regex escapes	2013-05-10 01:35:25 -05:00
kpdecker	8b65fa771e	Update release notes	2013-05-10 01:24:11 -05:00
kpdecker	fa6cec26bf	Update client packager versions	2013-05-10 01:02:13 -05:00
kpdecker	436973f470	Version update script	2013-05-10 01:01:55 -05:00
Kevin Decker	a2796784ab	Merge pull request #505 from MikeMayer/master Include a .nuspec package file to include handlebars.js on NuGet	2013-05-09 22:37:23 -07:00
Kevin Decker	d355d1f6aa	Fix links in release notes	2013-05-10 00:35:05 -05:00
Kevin Decker	71c5e36268	Merge pull request #489 from DevinClark/bower-update Added a component.json file for Twitter's Bower package manager.	2013-05-09 22:29:27 -07:00
kpdecker	44ae572e2f	Add release notes Fixes #471	2013-05-10 00:14:55 -05:00
Kevin Decker	7cd9cdb0eb	Merge pull request #513 from tommydudebreaux/master Using handlebars with browserify causes IE to throw - TypeError: Invalid calling object	2013-05-09 21:03:03 -07:00
Tommy Messbauer	090ee7c59a	added local pointer to handlerbars.utils to allow this to browserify properly for IE	2013-05-09 17:17:34 -05:00
MikeMayer	8a5705a253	Explicitly only include the handlebars.js from the dist folder	2013-05-01 09:58:17 -07:00
MikeMayer	344bb9092d	Create handlebars.js.nuspec for inclusion in NuGet Added a .nuspec file for those people who use Visual Studio and NuGet and might want to use handlebars.js deployed from NuGet in their application.	2013-05-01 09:52:55 -07:00
Utkarsh Sengar	ef325733bb	Added link to a gist for loading handlebars templates (sync and async) in README.	2013-04-28 13:54:47 -05:00
kpdecker	18798a7546	Adjust formatting of bullet list	2013-04-28 13:53:01 -05:00
Kevin Decker	bbce33778e	Merge pull request #499 from gilesbowkett/paragraph_width adjusted paragraph width for readability	2013-04-28 11:44:19 -07:00
DevinClark	fc52a65c70	Changed component.json to bower.json per Bower 0.9.0 update.	2013-04-25 21:05:21 -05:00
Giles Bowkett	06e593d32e	paragraph width	2013-04-25 14:44:52 -07:00
Kevin Decker	16a6fe15f2	Merge pull request #492 from iangreenleaf/patch-1 Change download link in install instructions	2013-04-25 09:39:13 -07:00
Ian Young	d8d2a6a1d2	Change download link in install instructions The install instructions in the readme were still pointing to the GitHub downloads page, which is deprecated and out of date. Updated to point to the official site, which has a big download button.	2013-04-16 16:32:40 -07:00
Kevin Decker	4c35f89c2a	Merge pull request #488 from tnwinc/amd-module-return-values Amd module return values	2013-04-08 10:41:08 -07:00
DevinClark	5c9aa9e4d6	Added a component.json file for Twitter's Bower package manager. See [https://github.com/twitter/bower#defining-a-package](Defining a package) for more information about how the file was generated.	2013-04-08 12:28:13 -05:00
James Maroney	ca576c27fc	If building AMD module and compiling multiple templates, return the full templates (or partials) hash from the AMD module	2013-04-08 10:37:18 -04:00
James Maroney	85a21f2359	If building AMD modules, and only one template is being compiled, return the compiled template from the AMD module	2013-04-08 10:36:43 -04:00
Kevin Decker	075fdb8ac4	Merge pull request #454 from leshill/fix_string_mode_contexts Add contexts for string mode hash values	2013-04-07 17:21:40 -07:00
kpdecker	4429ffa9f3	Allow multiple partial and helper registration Fixes #369	2013-04-07 18:04:51 -05:00
kpdecker	73f2016a6a	Remove FULL_CONTEXT from spec_helper	2013-04-07 16:50:57 -05:00
kpdecker	381c113d66	Rebuild	2013-04-07 12:41:55 -05:00
kpdecker	0329c852bd	Merge branch 'program-metadata'	2013-04-07 12:29:54 -05:00
kpdecker	f6ff5c648b	Restore knownHelpersOnly throw Fixes #302	2013-04-06 23:23:40 -05:00
kpdecker	12d68caa58	Allow compilation of empty string Fixes #461	2013-04-06 23:17:39 -05:00
kpdecker	ff32b4e2ad	Escape passed regex	2013-04-06 23:14:29 -05:00
kpdecker	c59882cce1	Merge branch 'master' of github.com:matteoagosti/handlebars.js into matteoagosti-master Conflicts: bin/handlebars	2013-04-06 23:07:50 -05:00
kpdecker	4d66d0c0a6	Escape unicode newlines in string literals Fixes #375	2013-04-06 16:42:24 -05:00
kpdecker	bee0facaca	Rebuild	2013-04-06 15:49:13 -05:00
Kevin Decker	af3501636c	Merge pull request #462 from broady/master Fix support for Rhino	2013-04-06 13:48:47 -07:00
kpdecker	e33d9b4dcf	Add test case for GH-458	2013-04-06 15:28:27 -05:00
kpdecker	31aaa30fcd	Rebuild	2013-04-06 15:28:18 -05:00
kpdecker	ec5882a31a	Merge branch 'master' of github.com:jpfiset/handlebars.js into jpfiset-master	2013-04-06 15:18:30 -05:00
kpdecker	671c07e699	Force toString in escapeExpression Fixes #211	2013-04-06 14:46:04 -05:00
kpdecker	f4d0092bb8	escapeExpression tests	2013-04-06 14:42:33 -05:00
kpdecker	fe74d65f2b	isEmpty test	2013-04-06 14:26:08 -05:00
kpdecker	9e4b59e815	Add support for \\{ escapes Fixes #456	2013-03-31 16:27:34 -05:00
Les Hill	53de75927c	Add contexts for string mode hash values Allows for evaluating hash parameters such as ../city in string mode.	2013-03-19 21:41:36 -07:00
kpdecker	bcc15ea5e7	Rebuild dist	2013-03-13 21:56:30 -05:00
Kevin Decker	21977633a0	Merge pull request #213 from thejohnfreeman/master Block helper "with" should check for empty context	2013-03-13 19:54:26 -07:00
Chris Broadfoot	e4a0ac4b04	Fix Rhino support	2013-03-04 16:08:00 -08:00
Jean-Pierre Fiset	681f1a6396	Allow colon characters in identifiers Issue #460	2013-03-04 13:33:13 -05:00
Jean-Pierre Fiset	bf30bf9115	Allow accessing properties in current context using paths. This is to avoid name collisions with registered helper functions. Issue #458	2013-03-04 13:25:00 -05:00
kpdecker	948231a31d	1.0.10	2013-02-27 07:52:34 -06:00
kpdecker	3657457d81	Merge branch 'master' of github.com:wycats/handlebars.js	2013-02-27 07:49:56 -06:00
Kevin Decker	4bfb137e81	Use master build for travis badge	2013-02-26 17:46:19 -06:00
Yehuda Katz	835496f0b6	Merge pull request #443 from machty/gemified Added handlebars-source gemspec	2013-02-19 21:12:51 -08:00
machty	519156138d	Added handlebars-source gemspec for sharing with 3rd party precompilation libs	2013-02-20 00:04:39 -05:00
kpdecker	ac59d6d060	Always rebuild dist files	2013-02-17 04:34:04 -06:00
kpdecker	baccdb4cfc	Add program metadata Include program id and depth on the generated wrapper objects. This allows helpers who are passed these objects to differentiate between helpers for cases where they may want to cache the generated DOM structure.	2013-02-17 04:27:42 -06:00
kpdecker	c95b3d6fc5	Create new options object for unless nesting Fixes #343	2013-02-16 16:18:48 -06:00
kpdecker	d6f146f8a5	Fix #428 nested if else rendering The program equality checker was not taking children into account when determining equality, causing breakages under similar cases.	2013-02-16 16:18:17 -06:00
kpdecker	1f00504d25	Rebuild	2013-02-16 16:02:08 -06:00
Kevin Decker	8b2c1e5d23	Merge pull request #442 from tricknotes/fix-method-name-in-error-message Fix method name in error message	2013-02-16 14:01:31 -08:00
kpdecker	fa400d9dcb	Merge branch 'iife'	2013-02-16 15:58:29 -06:00
kpdecker	10453d1ef8	Use local vars	2013-02-16 13:56:19 -06:00
kpdecker	30623ce903	Add explicit SafeString property test	2013-02-16 13:55:55 -06:00
kpdecker	da5cde5d1f	Move Handlerbars.print into printer file	2013-02-16 13:36:34 -06:00
kpdecker	3e86bb0f64	Remove unnecessary child scopes	2013-02-16 13:08:46 -06:00
kpdecker	16bfebbf49	Use dist output in spec helper	2013-02-16 13:07:56 -06:00
kpdecker	1f76b065fc	browser-prefix/suffix templates	2013-02-16 13:07:39 -06:00
kpdecker	e2481cd66e	Use PARSER_CONTEXT for tokenizer tests	2013-02-16 10:47:42 -06:00
kpdecker	8a05dcb70e	Remove unused scope function	2013-02-16 10:47:04 -06:00
Ryunosuke SATO	261a2deb51	Fix method name in error message - compile -> precompile	2013-02-16 20:14:38 +09:00
kpdecker	75a4f0d931	Negative number literal support Fixes #422	2013-02-15 20:22:11 -06:00
kpdecker	b74711e63b	1.0.9	2013-02-15 19:43:52 -06:00
kpdecker	e3454a0187	Restore module scope in base.js	2013-02-15 19:41:10 -06:00
kpdecker	f72cbed479	Merge branch 'master' of github.com:tommydudebreaux/handlebars.js into tommydudebreaux-master	2013-02-15 19:24:15 -06:00
Peter Wagenet	bc8214cb7c	Updated to 1.0.0-rc.3	2013-02-14 21:58:20 -08:00
Tommy Messbauer	7f9e3fea81	tests passing	2013-02-11 23:13:37 -06:00
Tommy Messbauer	1ca7462497	merge	2013-02-11 23:00:47 -06:00
Tommy Messbauer	514c9391e0	restored scope of var verifyMatch	2013-02-11 22:50:23 -06:00
Peter Wagenet	7c633b604d	Better error messages for precompiler runtime mismatch	2013-02-09 19:25:53 -08:00
Peter Wagenet	51e9259fac	Decouple compiler version checks from release versions	2013-02-08 18:42:20 -08:00
Yehuda Katz	0844d74fbe	Merge pull request #429 from machty/extension-support Open Handlebars compilation to externally-compiled AST	2013-02-07 10:02:38 -08:00
machty	a48e32bbf6	Handlebars.parse/precompile/compile can now be passed an already-compiled Handlebars AST.	2013-02-07 02:06:17 -05:00
Yehuda Katz	448e43c41e	Merge pull request #424 from wagenet/version-check-v2 Improved precompile template version check	2013-01-30 22:57:24 -08:00
Peter Wagenet	6fe7f17c89	Improved precompile template version check This check reduces duplicated code as well as also failing if the template was precompiled on a version before the check was added.	2013-01-30 22:44:30 -08:00
Yehuda Katz	edb6f11b42	Merge pull request #420 from wagenet/version-check Check version when evaluating templates.	2013-01-29 13:29:58 -08:00
Peter Wagenet	d7758fe1a9	Check version when evaluating templates. This makes sure that we throw an error when a template was precompiled with a version of Handlebars that doesn't match the evaluating version.	2013-01-29 13:29:19 -08:00
kpdecker	a3376e24b1	Rebuild	2013-01-21 19:49:16 -06:00
Kevin Decker	6a51198a9b	Merge pull request #412 from wycats/inline-ops Inline ops	2013-01-21 17:47:31 -08:00
Yehuda Katz	a68a5ad5ba	Merge pull request #414 from leshill/leading_context_only Only allow `this` or `..` to lead a path	2013-01-21 11:30:19 -08:00
Les Hill	6ab92eee6d	Only allow 'this' or '..' to lead a path Paths like 'outer/../key' raise an exception when compiling.	2013-01-21 11:21:43 -08:00
kpdecker	b0c9f3d83b	mergeSource helper	2013-01-21 01:03:42 -06:00
kpdecker	b661977966	Merge duplicate programs	2013-01-21 00:49:28 -06:00
kpdecker	969b418291	Remove inline option from pushStack	2013-01-21 00:23:08 -06:00
kpdecker	8e9688792b	Use push rather than pushStack for inline ops	2013-01-21 00:21:17 -06:00
kpdecker	9ac47df7dd	Make replaceStack always inline	2013-01-20 23:58:42 -06:00
kpdecker	6210d0b040	Merge branch 'master' into inline-ops	2013-01-20 21:43:10 -06:00
kpdecker	69d46e008b	Rebuild dist	2013-01-20 21:42:37 -06:00
kpdecker	f8a346b3ce	Add LICENSE to built file Fixes #411	2013-01-20 21:42:29 -06:00
kpdecker	0f6651bad9	Formatting updates for inlined content	2013-01-20 21:19:39 -06:00
kpdecker	231543feaf	Merge consecutive buffer appends	2013-01-20 21:18:49 -06:00
kpdecker	b3a39ccefd	Use options register for blockHelperMissing	2013-01-20 17:30:40 -06:00
kpdecker	956b0a62a6	Inline known helper calls	2013-01-20 17:05:17 -06:00
kpdecker	94e70043f9	Use stack rather than register for invoke lookup	2013-01-20 17:04:30 -06:00
kpdecker	bf201a66c2	Prevent duplication of inline content in append	2013-01-20 17:00:46 -06:00
kpdecker	39cc7c6816	Update 2nd level opcodes to use inlines	2013-01-19 18:33:49 -06:00
kpdecker	e9ac494ffd	Allow replaceStack to work with the inline stack	2013-01-19 18:21:05 -06:00
kpdecker	cb50caaf53	Use inline values for simple terminals	2013-01-19 17:39:13 -06:00
kpdecker	ae95407775	Inline stack helper implementation	2013-01-19 17:35:05 -06:00
kpdecker	7277284132	Merge branch 'master' into inline-ops	2013-01-19 17:01:20 -06:00
kpdecker	d486e7fa47	Remove unused vars	2013-01-19 17:01:08 -06:00
kpdecker	3c20641a2e	Reuse stack var to avoid register	2013-01-19 16:57:54 -06:00
kpdecker	5e20c809dc	Output options only once to unknownHelper case	2013-01-19 16:44:43 -06:00
kpdecker	2b875cfb33	Merge branch 'master' into inline-ops	2013-01-19 13:50:41 -06:00
kpdecker	228c75669f	Expand literal syntax tests	2013-01-19 13:19:17 -06:00
kpdecker	d1fdb82291	Make equals without messages more resilient When called without a message parameter the tests would fail under some environments. I'm not clear on what is causing the failure, perhaps ruby version, but this patch cleans up the issues there.	2013-01-19 13:19:03 -06:00
kpdecker	247babbe1a	Empty hash literal output	2013-01-19 12:15:43 -06:00
kpdecker	b1ea697b7d	Inline foundHelper lookup	2013-01-19 11:39:23 -06:00
kpdecker	822d98a1ef	Includ dist in npm package	2013-01-19 02:17:26 -06:00
kpdecker	5ac29dcb50	1.0.8	2013-01-19 02:12:36 -06:00
Tommy Messbauer	db975b42a0	Merged upstream master and ran unit tests	2012-11-26 10:26:15 -06:00
Tommy Messbauer	7963218495	Factory update with tabs to spaces.. sorry :(	2012-11-26 09:39:08 -06:00
Matteo Agosti	53d6b4ca04	Supporting custom template extension Fix missing escape	2012-11-08 12:22:35 +01:00
Tommy Messbauer	eccc7c35ca	Finished factory pattern	2012-08-29 15:07:15 -05:00
Tommy Messbauer	7c4813b417	Commiting initial factory code	2012-08-29 12:48:22 -05:00
John Freeman	0872fb6699	block helper "with" should check for empty context	2012-03-31 23:09:27 -05:00