diff --git a/.gitignore b/.gitignore
index bd08399..9000776 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 .DS_Store
 .rvmrc
+node_modules
 runner.js
 jquery.mustache.js
 qooxdoo.mustache.js
diff --git a/.jshintrc b/.jshintrc
new file mode 100644
index 0000000..28dff71
--- /dev/null
+++ b/.jshintrc
@@ -0,0 +1,5 @@
+{
+  "eqnull": true,
+  "evil": true
+}
+
diff --git a/.travis.yml b/.travis.yml
index b52599e..3d839b0 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,5 +1,4 @@
-rvm:
-  - 1.9.2
-before_script:
-  - sudo apt-get -y install xulrunner-2.0
-  - gem install rspec
+language: node_js
+node_js:
+  - 0.6
+
diff --git a/CHANGES b/CHANGES
new file mode 100644
index 0000000..436f791
--- /dev/null
+++ b/CHANGES
@@ -0,0 +1,27 @@
+= HEAD / 22 Sep 2012
+
+  * Cache partials by template, not by name. Fixes #257.
+  * Added Mustache.compileTokens to compile the output of Mustache.parse. Fixes
+    #258.
+
+= 0.7.0 / 10 Sep 2012
+
+  * Rename Renderer => Writer.
+  * Allow partials to be loaded dynamically using a callback (thanks @TiddoLangerak
+    for the suggestion).
+  * Fixed a bug with higher-order sections that prevented them from being
+    passed the raw text of the section from the original template.
+  * More concise token format. Tokens also include start/end indices in the
+    original template.
+  * High-level API is consistent with the Writer API.
+  * Allow partials to be passed to the pre-compiled function (thanks @fallenice).
+  * Don't use eval (thanks @cweider).
+
+= 0.6.0 / 31 Aug 2012
+
+  * Use JavaScript's definition of falsy when determining whether to render an
+    inverted section or not. Issue #186.
+  * Use Mustache.escape to escape values inside {{}}. This function may be
+    reassigned to alter the default escaping behavior. Issue #244.
+  * Fixed a bug that clashed with QUnit (thanks @kannix).
+  * Added volo support (thanks @guybedford).
diff --git a/LICENSE b/LICENSE
index 395e263..6626848 100644
--- a/LICENSE
+++ b/LICENSE
@@ -3,21 +3,8 @@ The MIT License
 Copyright (c) 2009 Chris Wanstrath (Ruby)
 Copyright (c) 2010 Jan Lehnardt (JavaScript)
 
-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.
\ No newline at end of file
+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.
diff --git a/README.md b/README.md
index a04f667..75c45b1 100644
--- a/README.md
+++ b/README.md
@@ -2,31 +2,23 @@
 
 > What could be more logical awesome than no logic at all?
 
-[mustache.js](http://github.com/janl/mustache.js) is an implementation of the
-[Mustache](http://mustache.github.com/) template system in JavaScript.
+[mustache.js](http://github.com/janl/mustache.js) is an implementation of the [mustache](http://mustache.github.com/) template system in JavaScript.
 
-[Mustache](http://mustache.github.com/) is a logic-less template syntax. It can
-be used for HTML, config files, source code - anything. It works by expanding
-tags in a template using values provided in a hash or object.
+[Mustache](http://mustache.github.com/) is a logic-less template syntax. It can be used for HTML, config files, source code - anything. It works by expanding tags in a template using values provided in a hash or object.
 
-We call it "logic-less" because there are no if statements, else clauses, or for
-loops. Instead there are only tags. Some tags are replaced with a value, some
-nothing, and others a series of values.
+We call it "logic-less" because there are no if statements, else clauses, or for loops. Instead there are only tags. Some tags are replaced with a value, some nothing, and others a series of values.
 
-For a language-agnostic overview of Mustache's template syntax, see the
-`mustache(5)` [manpage](http://mustache.github.com/mustache.5.html).
+For a language-agnostic overview of mustache's template syntax, see the `mustache(5)` [manpage](http://mustache.github.com/mustache.5.html).
 
 ## Where to use mustache.js?
 
-You can use mustache.js to render templates in many various scenarios where you
-can use JavaScript. For example, you can render templates in a browser,
-server-side using [node](http://nodejs.org/), in [CouchDB](http://couchdb.apache.org/)
-views, or in almost any other environment where you can use JavaScript.
+You can use mustache.js to render mustache templates anywhere you can use JavaScript. This includes web browsers, server-side environments such as [node](http://nodejs.org/), and [CouchDB](http://couchdb.apache.org/) views.
+
+mustache.js ships with support for both the [CommonJS](http://www.commonjs.org/) module API and the [Asynchronous Module Definition](https://github.com/amdjs/amdjs-api/wiki/AMD) API, or AMD.
 
 ## Who uses mustache.js?
 
-An updated list of mustache.js users is kept [on the Github wiki](http://wiki.github.com/janl/mustache.js/beard-competition).
-Add yourself or your company if you use mustache.js!
+An updated list of mustache.js users is kept [on the Github wiki](http://wiki.github.com/janl/mustache.js/beard-competition). Add yourself or your company if you use mustache.js!
 
 ## Usage
 
@@ -41,36 +33,26 @@ Below is quick example how to use mustache.js:
 
     var output = Mustache.render("{{title}} spends {{calc}}", view);
 
-In this example, the `Mustache.render` function takes two parameters: 1) the
-[mustache](http://mustache.github.com/) template and 2) a `view` object that
-contains the data and code needed to render the template.
-
-### CommonJS
-
-mustache.js is usable without any modification in both browsers and [CommonJS](http://www.commonjs.org/)
-environments like [node.js](http://nodejs.org/). To use it as a CommonJS module,
-simply require the file, like this:
-
-    var Mustache = require("mustache");
+In this example, the `Mustache.render` function takes two parameters: 1) the [mustache](http://mustache.github.com/) template and 2) a `view` object that contains the data and code needed to render the template.
 
 ## Templates
 
-A [mustache](http://mustache.github.com/) template is a string that contains
-any number of mustache tags. Tags are indicated by the double mustaches that
-surround them. `{{person}}` is a tag, as is `{{#person}}`. In both examples we
-refer to `person` as the tag's key.
+A [mustache](http://mustache.github.com/) template is a string that contains any number of mustache tags. Tags are indicated by the double mustaches that surround them. `{{person}}` is a tag, as is `{{#person}}`. In both examples we refer to `person` as the tag's key.
 
 There are several types of tags available in mustache.js.
 
 ### Variables
 
-The most basic tag type is a simple variable. A `{{name}}` tag renders the value
-of the `name` key in the current context. If there is no such key, nothing is
-rendered.
+The most basic tag type is a simple variable. A `{{name}}` tag renders the value of the `name` key in the current context. If there is no such key, nothing is rendered.
+
+All variables are HTML-escaped by default. If you want to render unescaped HTML, use the triple mustache: `{{{name}}}`. You can also use `&` to unescape a variable.
+
+View:
 
-All variables are HTML-escaped by default. If you want to render unescaped HTML,
-use the triple mustache: `{{{name}}}`. You can also use `&` to unescape a
-variable.
+    {
+      "name": "Chris",
+      "company": "<b>GitHub</b>"
+    }
 
 Template:
 
@@ -80,13 +62,6 @@ Template:
     * {{{company}}}
     * {{&company}}
 
-View:
-
-    {
-      "name": "Chris",
-      "company": "<b>GitHub</b>"
-    }
-
 Output:
 
     * Chris
@@ -95,13 +70,7 @@ Output:
     * <b>GitHub</b>
     * <b>GitHub</b>
 
-JavaScript's dot notation may be used to access keys that are properties of
-objects in a view.
-
-Template:
-
-    * {{name.first}} {{name.last}}
-    * {{age}}
+JavaScript's dot notation may be used to access keys that are properties of objects in a view.
 
 View:
 
@@ -113,6 +82,11 @@ View:
       "age": "RIP"
     }
 
+Template:
+
+    * {{name.first}} {{name.last}}
+    * {{age}}
+
 Output:
 
     * Michael Jackson
@@ -120,19 +94,21 @@ Output:
 
 ### Sections
 
-Sections render blocks of text one or more times, depending on the value of the
-key in the current context.
+Sections render blocks of text one or more times, depending on the value of the key in the current context.
 
-A section begins with a pound and ends with a slash. That is, `{{#person}}`
-begins a `person` section, while `{{/person}}` ends it. The text between the two
-tags is referred to as that section's "block".
+A section begins with a pound and ends with a slash. That is, `{{#person}}` begins a `person` section, while `{{/person}}` ends it. The text between the two tags is referred to as that section's "block".
 
 The behavior of the section is determined by the value of the key.
 
 #### False Values or Empty Lists
 
-If the `person` key exists and has a value of `null`, `undefined`, or `false`,
-or is an empty list, the block will not be rendered.
+If the `person` key does not exist, or exists and has a value of `null`, `undefined`, or `false`, or is an empty list, the block will not be rendered.
+
+View:
+
+    {
+      "person": false
+    }
 
 Template:
 
@@ -141,30 +117,15 @@ Template:
     Never shown!
     {{/person}}
 
-View:
-
-    {
-      "person": true
-    }
-
 Output:
 
     Shown.
 
 #### Non-Empty Lists
 
-If the `person` key exists and is not `null`, `undefined`, or `false`, and is
-not an empty list the block will be rendered one or more times.
-
-When the value is a list, the block is rendered once for each item in the list.
-The context of the block is set to the current item in the list for each
-iteration. In this way we can loop over collections.
-
-Template:
+If the `person` key exists and is not `null`, `undefined`, or `false`, and is not an empty list the block will be rendered one or more times.
 
-    {{#stooges}}
-    <b>{{name}}</b>
-    {{/stooges}}
+When the value is a list, the block is rendered once for each item in the list. The context of the block is set to the current item in the list for each iteration. In this way we can loop over collections.
 
 View:
 
@@ -176,20 +137,19 @@ View:
       ]
     }
 
+Template:
+
+    {{#stooges}}
+    <b>{{name}}</b>
+    {{/stooges}}
+
 Output:
 
     <b>Moe</b>
     <b>Larry</b>
     <b>Curly</b>
 
-When looping over an array of strings, a `.` can be used to refer to the current
-item in the list.
-
-Template:
-
-    {{#musketeers}}
-    * {{.}}
-    {{/musketeers}}
+When looping over an array of strings, a `.` can be used to refer to the current item in the list.
 
 View:
 
@@ -197,6 +157,12 @@ View:
       "musketeers": ["Athos", "Aramis", "Porthos", "D'Artagnan"]
     }
 
+Template:
+
+    {{#musketeers}}
+    * {{.}}
+    {{/musketeers}}
+
 Output:
 
     * Athos
@@ -204,14 +170,7 @@ Output:
     * Porthos
     * D'Artagnan
 
-If the value of a section variable is a function, it will be called in the
-context of the current item in the list on each iteration.
-
-Template:
-
-    {{#beatles}}
-    * {{name}}
-    {{/beatles}}
+If the value of a section variable is a function, it will be called in the context of the current item in the list on each iteration.
 
 View:
 
@@ -227,6 +186,12 @@ View:
       }
     }
 
+Template:
+
+    {{#beatles}}
+    * {{name}}
+    {{/beatles}}
+
 Output:
 
     * John Lennon
@@ -236,14 +201,7 @@ Output:
 
 #### Functions
 
-If the value of a section key is a function, it is called with the section's
-literal block of text, un-rendered, as its first argument. The second argument
-is a special rendering function that uses the current view as its view argument.
-It is called in the context of the current view object.
-
-Template:
-
-    {{#bold}}Hi {{name}}.{{/bold}}
+If the value of a section key is a function, it is called with the section's literal block of text, un-rendered, as its first argument. The second argument is a special rendering function that uses the current view as its view argument. It is called in the context of the current view object.
 
 View:
 
@@ -256,20 +214,17 @@ View:
       }
     }
 
+Template:
+
+    {{#bold}}Hi {{name}}.{{/bold}}
+
 Output:
 
     <b>Hi Tater.</b>
 
 ### Inverted Sections
 
-An inverted section opens with `{{^section}}` instead of `{{#section}}`. The
-block of an inverted section is rendered only if the value of that section's tag
-is `null`, `undefined`, `false`, or an empty list.
-
-Template:
-
-    {{#repos}}<b>{{name}}</b>{{/repos}}
-    {{^repos}}No repos :({{/repos}}
+An inverted section opens with `{{^section}}` instead of `{{#section}}`. The block of an inverted section is rendered only if the value of that section's tag is `null`, `undefined`, `false`, or an empty list.
 
 View:
 
@@ -277,6 +232,11 @@ View:
       "repos": []
     }
 
+Template:
+
+    {{#repos}}<b>{{name}}</b>{{/repos}}
+    {{^repos}}No repos :({{/repos}}
+
 Output:
 
     No repos :(
@@ -297,8 +257,7 @@ Comments may contain newlines.
 
 Partials begin with a greater than sign, like {{> box}}.
 
-Partials are rendered at runtime (as opposed to compile time), so recursive
-partials are possible. Just avoid infinite loops.
+Partials are rendered at runtime (as opposed to compile time), so recursive partials are possible. Just avoid infinite loops.
 
 They also inherit the calling context. Whereas in ERB you may have this:
 
@@ -308,9 +267,7 @@ Mustache requires only this:
 
     {{> next_more}}
 
-Why? Because the `next_more.mustache` file will inherit the `size` and `start`
-variables from the calling context. In this way you may want to think of
-partials as includes, or template expansion, even though it's not literally true.
+Why? Because the `next_more.mustache` file will inherit the `size` and `start` variables from the calling context. In this way you may want to think of partials as includes, or template expansion, even though it's not literally true.
 
 For example, this template and partial:
 
@@ -330,14 +287,11 @@ Can be thought of as a single, expanded template:
       <strong>{{name}}</strong>
     {{/names}}
 
-In mustache.js an object of partials may be passed as the third argument to
-`Mustache.render`. The object should be keyed by the name of the partial, and
-its value should be the partial text.
+In mustache.js an object of partials may be passed as the third argument to `Mustache.render`. The object should be keyed by the name of the partial, and its value should be the partial text.
 
 ### Set Delimiter
 
-Set Delimiter tags start with an equals sign and change the tag delimiters from
-`{{` and `}}` to custom strings.
+Set Delimiter tags start with an equals sign and change the tag delimiters from `{{` and `}}` to custom strings.
 
 Consider the following contrived example:
 
@@ -347,55 +301,57 @@ Consider the following contrived example:
     <%={{ }}=%>
     * {{ default_tags_again }}
 
-Here we have a list with three items. The first item uses the default tag style,
-the second uses ERB style as defined by the Set Delimiter tag, and the third
-returns to the default style after yet another Set Delimiter declaration.
+Here we have a list with three items. The first item uses the default tag style, the second uses ERB style as defined by the Set Delimiter tag, and the third returns to the default style after yet another Set Delimiter declaration.
 
-According to [ctemplates](http://google-ctemplate.googlecode.com/svn/trunk/doc/howto.html),
-this "is useful for languages like TeX, where double-braces may occur in the
-text and are awkward to use for markup."
+According to [ctemplates](http://google-ctemplate.googlecode.com/svn/trunk/doc/howto.html), this "is useful for languages like TeX, where double-braces may occur in the text and are awkward to use for markup."
 
 Custom delimiters may not contain whitespace or the equals sign.
 
-## Streaming
-
-To stream template results out of mustache.js, you can pass an optional callback
-to the call to `Mustache.render`:
-
-    Mustache.render(template, view, partials, function (chunk) {
-      print(chunk);
-    });
-
-When the template is finished rendering, the callback will be called with `null`
-after which it won't be called anymore for that rendering.
-
 ## Plugins for JavaScript Libraries
 
-By default mustache.js may be used in a browser or any [CommonJS](http://www.commonjs.org/)
-environment, including [node](http://nodejs.org/). Additionally, mustache.js may
-be built specifically for several different client libraries and platforms,
-including the following:
+mustache.js may be built specifically for several different client libraries, including the following:
 
   - [jQuery](http://jquery.com/)
   - [MooTools](http://mootools.net/)
   - [Dojo](http://www.dojotoolkit.org/)
   - [YUI](http://developer.yahoo.com/yui/)
-  - [RequireJS](http://requirejs.org/)
   - [qooxdoo](http://qooxdoo.org/)
 
-These may be built using [Rake](http://rake.rubyforge.org/) and one of the
-following commands:
+These may be built using [Rake](http://rake.rubyforge.org/) and one of the following commands:
 
     $ rake jquery
     $ rake mootools
     $ rake dojo
     $ rake yui
-    $ rake requirejs
     $ rake qooxdoo
 
+## Testing
+
+The mustache.js test suite uses the [vows](http://vowsjs.org/) testing framework. In order to run the tests you'll need to install [node](http://nodejs.org/). Once that's done you can install vows using [npm](http://npmjs.org/).
+
+    $ npm install -g vows
+
+Then run the tests.
+
+    $ vows --spec
+
+The test suite consists of both unit and integration tests. If a template isn't rendering correctly for you, you can make a test for it by doing the following:
+
+  1. Create a template file named `mytest.mustache` in the `test/_files`
+     directory. Replace `mytest` with the name of your test.
+  2. Create a corresponding view file named `mytest.js` in the same directory.
+     This file should contain a JavaScript object literal enclosed in
+     parentheses. See any of the other view files for an example.
+  3. Create a file with the expected output in `mytest.txt` in the same
+     directory.
+
+Then, you can run the test with:
+
+    $ TEST=mytest vows test/render_test.js
+
 ## Thanks
 
-Mustache.js wouldn't kick ass if it weren't for these fine souls:
+mustache.js wouldn't kick ass if it weren't for these fine souls:
 
   * Chris Wanstrath / defunkt
   * Alexander Lang / langalex
diff --git a/Rakefile b/Rakefile
index 61700ee..bc32175 100644
--- a/Rakefile
+++ b/Rakefile
@@ -1,15 +1,33 @@
 require 'rake'
 require 'rake/clean'
 
-task :default => :spec
-
-desc "Run all specs"
-task :spec do
-  require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:spec) do |t|
-    #t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
-    t.pattern = 'spec/*_spec.rb'
-  end
+task :default => :test
+
+ROOT = File.expand_path('..', __FILE__)
+MUSTACHE_JS = File.read(File.join(ROOT, 'mustache.js'))
+
+def mustache_version
+  match = MUSTACHE_JS.match(/exports\.version = "([^"]+)";/)
+  match[1]
+end
+
+def minified_file
+  ENV['FILE'] || 'mustache.min.js'
+end
+
+desc "Run all tests, requires vows (see http://vowsjs.org)"
+task :test do
+  sh "vows --spec"
+end
+
+desc "Minify to #{minified_file}, requires UglifyJS (see http://marijnhaverbeke.nl/uglifyjs)"
+task :minify do
+  sh "uglifyjs mustache.js > #{minified_file}"
+end
+
+desc "Run JSHint, requires jshint (see http://www.jshint.com)"
+task :lint do
+  sh "jshint mustache.js"
 end
 
 # Creates a task that uses the various template wrappers to make a wrapped
@@ -47,13 +65,4 @@ templated_build "jQuery"
 templated_build "MooTools"
 templated_build "Dojo", :location => "dojox/string"
 templated_build "YUI3", :location => "yui3/mustache"
-templated_build "RequireJS"
 templated_build "qooxdoo"
-
-task :minify do
-  # npm install uglify-js
-  mmjs = "mustache.min.js"
-  `echo "/*! Version: 0.5.1-dev */" > #{mmjs}`
-  `uglifyjs mustache.js >> #{mmjs}`
-  puts "Created #{mmjs}"
-end
diff --git a/TESTING.md b/TESTING.md
deleted file mode 100644
index 47d15e4..0000000
--- a/TESTING.md
+++ /dev/null
@@ -1,62 +0,0 @@
-## Running the mustache.js test suite
-
-The mustache.js test suite uses the [RSpec](http://rspec.info/) testing
-framework. In order to run the tests you'll need to install [Ruby](http://ruby-lang.org/)
-as well as the `rake`, `rspec` (>=2), and `json` [RubyGems](http://rubygems.org/).
-
-### How to install Ruby and the required gems from source
-
-Make sure you have the required tools to compile it:
-
-    $ apt-get install build-essential libssl-dev libreadline5-dev zlib1g-dev
-
-Download and extract the Ruby source, and install it:
-
-    $ wget ftp://ftp.ruby-lang.org/pub/ruby/stable-snapshot.tar.gz
-    $ tar xvzf stable-snapshot.tar.gz
-    $ cd ruby
-    $ ./configure && make && make install
-
-Download and extract RubyGems, and install it:
-
-    $ wget http://production.cf.rubygems.org/rubygems/rubygems-1.8.12.tgz
-    $ tar xzvf rubygems-1.8.12.tgz
-    $ cd rubygems-1.8.12
-    $ ruby setup.rb
-
-If you want to update RubyGems:
-
-    $ gem update --system
-
-Install the required gems:
-
-    $ gem install rake rspec json
-
-That's it!
-
-### How to run the tests
-
-The mustache.js test suite currently uses 4 different JavaScript runtime engines
-to maximize portability across platforms and browsers. They are:
-
-  * node
-  * SpiderMonkey (Mozilla, Firefox)
-  * JavaScriptCore (WebKit, Safari)
-  * Rhino (Mozilla, Java)
-
-When the test suite runs it will automatically determine which platforms are
-available on your machine and run on all of them. The suite must run on at least
-one platform in order to succeed.
-
-Once you have at least one JavaScript platform installed, you can run the test
-suite with the following command:
-
-    $ rake
-
-### How to create a test
-
-All test files live in the spec/_files directory. To create a new test:
-
-  * Create a template file called `somename.mustache`
-  * Create a JavaScript file containing the view called `somename.js`
-  * Create a text file with the expected result called `somename.txt`
diff --git a/mustache.js b/mustache.js
index 641cebd..7165a8a 100644
--- a/mustache.js
+++ b/mustache.js
@@ -2,535 +2,621 @@
  * mustache.js - Logic-less {{mustache}} templates with JavaScript
  * http://github.com/janl/mustache.js
  */
-var Mustache = (typeof module !== "undefined" && module.exports) || {};
 
-(function (exports) {
-
-  exports.name = "mustache.js";
-  exports.version = "0.5.0-dev";
-  exports.tags = ["{{", "}}"];
-  exports.parse = parse;
-  exports.compile = compile;
-  exports.render = render;
-  exports.clearCache = clearCache;
-
-  // This is here for backwards compatibility with 0.4.x.
-  exports.to_html = function (template, view, partials, send) {
-    var result = render(template, view, partials);
-
-    if (typeof send === "function") {
-      send(result);
-    } else {
-      return result;
-    }
-  };
+/*global define: false*/
 
-  var _toString = Object.prototype.toString;
-  var _isArray = Array.isArray;
-  var _forEach = Array.prototype.forEach;
-  var _trim = String.prototype.trim;
+var Mustache;
 
-  var isArray;
-  if (_isArray) {
-    isArray = _isArray;
+(function (exports) {
+  if (typeof module !== "undefined" && module.exports) {
+    module.exports = exports; // CommonJS
+  } else if (typeof define === "function") {
+    define(exports); // AMD
   } else {
-    isArray = function (obj) {
-      return _toString.call(obj) === "[object Array]";
-    };
+    Mustache = exports; // <script>
   }
+}((function () {
 
-  var forEach;
-  if (_forEach) {
-    forEach = function (obj, callback, scope) {
-      return _forEach.call(obj, callback, scope);
-    };
-  } else {
-    forEach = function (obj, callback, scope) {
-      for (var i = 0, len = obj.length; i < len; ++i) {
-        callback.call(scope, obj[i], i, obj);
-      }
-    };
-  }
+  var exports = {};
 
-  var spaceRe = /^\s*$/;
+  exports.name = "mustache.js";
+  exports.version = "0.7.0";
+  exports.tags = ["{{", "}}"];
 
-  function isWhitespace(string) {
-    return spaceRe.test(string);
+  exports.Scanner = Scanner;
+  exports.Context = Context;
+  exports.Writer = Writer;
+
+  var whiteRe = /\s*/;
+  var spaceRe = /\s+/;
+  var nonSpaceRe = /\S/;
+  var eqRe = /\s*=/;
+  var curlyRe = /\s*\}/;
+  var tagRe = /#|\^|\/|>|\{|&|=|!/;
+
+  // Workaround for https://issues.apache.org/jira/browse/COUCHDB-577
+  // See https://github.com/janl/mustache.js/issues/189
+  function testRe(re, string) {
+    return RegExp.prototype.test.call(re, string);
   }
 
-  var trim;
-  if (_trim) {
-    trim = function (string) {
-      return string == null ? "" : _trim.call(string);
-    };
-  } else {
-    var trimLeft, trimRight;
+  function isWhitespace(string) {
+    return !testRe(nonSpaceRe, string);
+  }
 
-    if (isWhitespace("\xA0")) {
-      trimLeft = /^\s+/;
-      trimRight = /\s+$/;
-    } else {
-      // IE doesn't match non-breaking spaces with \s, thanks jQuery.
-      trimLeft = /^[\s\xA0]+/;
-      trimRight = /[\s\xA0]+$/;
-    }
+  var isArray = Array.isArray || function (obj) {
+    return Object.prototype.toString.call(obj) === "[object Array]";
+  };
 
-    trim = function (string) {
-      return string == null ? "" :
-        String(string).replace(trimLeft, "").replace(trimRight, "");
-    };
+  function escapeRe(string) {
+    return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
   }
 
-  var escapeMap = {
+  var entityMap = {
     "&": "&amp;",
     "<": "&lt;",
     ">": "&gt;",
     '"': '&quot;',
-    "'": '&#39;'
+    "'": '&#39;',
+    "/": '&#x2F;'
   };
 
-  function escapeHTML(string) {
-    return String(string).replace(/&(?!\w+;)|[<>"']/g, function (s) {
-      return escapeMap[s] || s;
+  function escapeHtml(string) {
+    return String(string).replace(/[&<>"'\/]/g, function (s) {
+      return entityMap[s];
     });
   }
 
+  // Export the escaping function so that the user may override it.
+  // See https://github.com/janl/mustache.js/issues/244
+  exports.escape = escapeHtml;
+
+  function Scanner(string) {
+    this.string = string;
+    this.tail = string;
+    this.pos = 0;
+  }
+
   /**
-   * Adds the `template`, `line`, and `file` properties to the given error
-   * object and alters the message to provide more useful debugging information.
+   * Returns `true` if the tail is empty (end of string).
    */
-  function debug(e, template, line, file) {
-    file = file || "<template>";
-
-    var lines = template.split("\n"),
-        start = Math.max(line - 3, 0),
-        end = Math.min(lines.length, line + 3),
-        context = lines.slice(start, end);
-
-    var c;
-    for (var i = 0, len = context.length; i < len; ++i) {
-      c = i + start + 1;
-      context[i] = (c === line ? " >> " : "    ") + context[i];
-    }
+  Scanner.prototype.eos = function () {
+    return this.tail === "";
+  };
 
-    e.template = template;
-    e.line = line;
-    e.file = file;
-    e.message = [file + ":" + line, context.join("\n"), "", e.message].join("\n");
+  /**
+   * Tries to match the given regular expression at the current position.
+   * Returns the matched text if it can match, the empty string otherwise.
+   */
+  Scanner.prototype.scan = function (re) {
+    var match = this.tail.match(re);
 
-    return e;
-  }
+    if (match && match.index === 0) {
+      this.tail = this.tail.substring(match[0].length);
+      this.pos += match[0].length;
+      return match[0];
+    }
+
+    return "";
+  };
 
   /**
-   * Looks up the value of the given `name` in the given context `stack`.
+   * Skips all text until the given regular expression can be matched. Returns
+   * the skipped string, which is the entire tail if no match can be made.
    */
-  function lookup(name, stack, defaultValue) {
-    if (name === ".") {
-      return stack[stack.length - 1];
+  Scanner.prototype.scanUntil = function (re) {
+    var match, pos = this.tail.search(re);
+
+    switch (pos) {
+    case -1:
+      match = this.tail;
+      this.pos += this.tail.length;
+      this.tail = "";
+      break;
+    case 0:
+      match = "";
+      break;
+    default:
+      match = this.tail.substring(0, pos);
+      this.tail = this.tail.substring(pos);
+      this.pos += pos;
     }
 
-    var names = name.split(".");
-    var lastIndex = names.length - 1;
-    var target = names[lastIndex];
+    return match;
+  };
 
-    var value, context, i = stack.length, j, localStack;
-    while (i) {
-      localStack = stack.slice(0);
-      context = stack[--i];
+  function Context(view, parent) {
+    this.view = view;
+    this.parent = parent;
+    this.clearCache();
+  }
 
-      j = 0;
-      while (j < lastIndex) {
-        context = context[names[j++]];
+  Context.make = function (view) {
+    return (view instanceof Context) ? view : new Context(view);
+  };
 
-        if (context == null) {
-          break;
-        }
+  Context.prototype.clearCache = function () {
+    this._cache = {};
+  };
 
-        localStack.push(context);
-      }
+  Context.prototype.push = function (view) {
+    return new Context(view, this);
+  };
 
-      if (context && typeof context === "object" && target in context) {
-        value = context[target];
-        break;
+  Context.prototype.lookup = function (name) {
+    var value = this._cache[name];
+
+    if (!value) {
+      if (name === ".") {
+        value = this.view;
+      } else {
+        var context = this;
+
+        while (context) {
+          if (name.indexOf(".") > 0) {
+            var names = name.split("."), i = 0;
+
+            value = context.view;
+
+            while (value && i < names.length) {
+              value = value[names[i++]];
+            }
+          } else {
+            value = context.view[name];
+          }
+
+          if (value != null) {
+            break;
+          }
+
+          context = context.parent;
+        }
       }
-    }
 
-    // If the value is a function, call it in the current context.
-    if (typeof value === "function") {
-      value = value.call(localStack[localStack.length - 1]);
+      this._cache[name] = value;
     }
 
-    if (value == null)  {
-      return defaultValue;
+    if (typeof value === "function") {
+      value = value.call(this.view);
     }
 
     return value;
+  };
+
+  function Writer() {
+    this.clearCache();
   }
 
-  function renderSection(name, stack, callback, inverted) {
-    var buffer = "";
-    var value =  lookup(name, stack);
+  Writer.prototype.clearCache = function () {
+    this._cache = {};
+    this._partialCache = {};
+  };
+
+  Writer.prototype.compile = function (template, tags) {
+    var fn = this._cache[template];
 
-    if (inverted) {
-      // From the spec: inverted sections may render text once based on the
-      // inverse value of the key. That is, they will be rendered if the key
-      // doesn't exist, is false, or is an empty list.
-      if (value == null || value === false || (isArray(value) && value.length === 0)) {
-        buffer += callback();
-      }
-    } else if (isArray(value)) {
-      forEach(value, function (value) {
-        stack.push(value);
-        buffer += callback();
-        stack.pop();
-      });
-    } else if (typeof value === "object") {
-      stack.push(value);
-      buffer += callback();
-      stack.pop();
-    } else if (typeof value === "function") {
-      var scope = stack[stack.length - 1];
-      var scopedRender = function (template) {
-        return render(template, scope);
-      };
-      buffer += value.call(scope, callback(), scopedRender) || "";
-    } else if (value) {
-      buffer += callback();
+    if (!fn) {
+      var tokens = exports.parse(template, tags);
+      fn = this._cache[template] = this.compileTokens(tokens, template);
     }
 
-    return buffer;
-  }
+    return fn;
+  };
 
-  /**
-   * Parses the given `template` and returns the source of a function that,
-   * with the proper arguments, will render the template. Recognized options
-   * include the following:
-   *
-   *   - file     The name of the file the template comes from (displayed in
-   *              error messages)
-   *   - tags     An array of open and close tags the `template` uses. Defaults
-   *              to the value of Mustache.tags
-   *   - debug    Set `true` to log the body of the generated function to the
-   *              console
-   *   - space    Set `true` to preserve whitespace from lines that otherwise
-   *              contain only a {{tag}}. Defaults to `false`
-   */
-  function parse(template, options) {
-    options = options || {};
-
-    var tags = options.tags || exports.tags,
-        openTag = tags[0],
-        closeTag = tags[tags.length - 1];
-
-    var code = [
-      'var buffer = "";', // output buffer
-      "\nvar line = 1;", // keep track of source line number
-      "\ntry {",
-      '\nbuffer += "'
-    ];
+  Writer.prototype.compilePartial = function (name, template, tags) {
+    var fn = this.compile(template, tags);
+    this._partialCache[name] = fn;
+    return fn;
+  };
 
-    var spaces = [],      // indices of whitespace in code on the current line
-        hasTag = false,   // is there a {{tag}} on the current line?
-        nonSpace = false; // is there a non-space char on the current line?
+  Writer.prototype.compileTokens = function (tokens, template) {
+    var fn = compileTokens(tokens);
+    var self = this;
 
-    // Strips all space characters from the code array for the current line
-    // if there was a {{tag}} on it and otherwise only spaces.
-    var stripSpace = function () {
-      if (hasTag && !nonSpace && !options.space) {
-        while (spaces.length) {
-          code.splice(spaces.pop(), 1);
+    return function (view, partials) {
+      if (partials) {
+        if (typeof partials === "function") {
+          self._loadPartial = partials;
+        } else {
+          for (var name in partials) {
+            self.compilePartial(name, partials[name]);
+          }
         }
-      } else {
-        spaces = [];
       }
 
-      hasTag = false;
-      nonSpace = false;
+      return fn(self, Context.make(view), template);
     };
+  };
 
-    var sectionStack = [], updateLine, nextOpenTag, nextCloseTag;
+  Writer.prototype.render = function (template, view, partials) {
+    return this.compile(template)(view, partials);
+  };
 
-    var setTags = function (source) {
-      tags = trim(source).split(/\s+/);
-      nextOpenTag = tags[0];
-      nextCloseTag = tags[tags.length - 1];
-    };
+  Writer.prototype._section = function (name, context, text, callback) {
+    var value = context.lookup(name);
 
-    var includePartial = function (source) {
-      code.push(
-        '";',
-        updateLine,
-        '\nvar partial = partials["' + trim(source) + '"];',
-        '\nif (partial) {',
-        '\n  buffer += render(partial,stack[stack.length - 1],partials);',
-        '\n}',
-        '\nbuffer += "'
-      );
-    };
+    switch (typeof value) {
+    case "object":
+      if (isArray(value)) {
+        var buffer = "";
 
-    var openSection = function (source, inverted) {
-      var name = trim(source);
+        for (var i = 0, len = value.length; i < len; ++i) {
+          buffer += callback(this, context.push(value[i]));
+        }
 
-      if (name === "") {
-        throw debug(new Error("Section name may not be empty"), template, line, options.file);
+        return buffer;
       }
 
-      sectionStack.push({name: name, inverted: inverted});
-
-      code.push(
-        '";',
-        updateLine,
-        '\nvar name = "' + name + '";',
-        '\nvar callback = (function () {',
-        '\n  return function () {',
-        '\n    var buffer = "";',
-        '\nbuffer += "'
-      );
-    };
+      return value ? callback(this, context.push(value)) : "";
+    case "function":
+      var self = this;
+      var scopedRender = function (template) {
+        return self.render(template, context);
+      };
 
-    var openInvertedSection = function (source) {
-      openSection(source, true);
-    };
+      return value.call(context.view, text, scopedRender) || "";
+    default:
+      if (value) {
+        return callback(this, context);
+      }
+    }
 
-    var closeSection = function (source) {
-      var name = trim(source);
-      var openName = sectionStack.length != 0 && sectionStack[sectionStack.length - 1].name;
+    return "";
+  };
 
-      if (!openName || name != openName) {
-        throw debug(new Error('Section named "' + name + '" was never opened'), template, line, options.file);
-      }
+  Writer.prototype._inverted = function (name, context, callback) {
+    var value = context.lookup(name);
 
-      var section = sectionStack.pop();
+    // Use JavaScript's definition of falsy. Include empty arrays.
+    // See https://github.com/janl/mustache.js/issues/186
+    if (!value || (isArray(value) && value.length === 0)) {
+      return callback(this, context);
+    }
 
-      code.push(
-        '";',
-        '\n    return buffer;',
-        '\n  };',
-        '\n})();'
-      );
+    return "";
+  };
 
-      if (section.inverted) {
-        code.push("\nbuffer += renderSection(name,stack,callback,true);");
-      } else {
-        code.push("\nbuffer += renderSection(name,stack,callback);");
+  Writer.prototype._partial = function (name, context) {
+    if (!(name in this._partialCache) && this._loadPartial) {
+      this.compilePartial(name, this._loadPartial(name));
+    }
+
+    var fn = this._partialCache[name];
+
+    return fn ? fn(context) : "";
+  };
+
+  Writer.prototype._name = function (name, context) {
+    var value = context.lookup(name);
+
+    if (typeof value === "function") {
+      value = value.call(context.view);
+    }
+
+    return (value == null) ? "" : String(value);
+  };
+
+  Writer.prototype._escaped = function (name, context) {
+    return exports.escape(this._name(name, context));
+  };
+
+  /**
+   * Calculates the bounds of the section represented by the given `token` in
+   * the original template by drilling down into nested sections to find the
+   * last token that is part of that section. Returns an array of [start, end].
+   */
+  function sectionBounds(token) {
+    var start = token[3];
+    var end = start;
+
+    var tokens;
+    while ((tokens = token[4]) && tokens.length) {
+      token = tokens[tokens.length - 1];
+      end = token[3];
+    }
+
+    return [start, end];
+  }
+
+  /**
+   * Low-level function that compiles the given `tokens` into a function
+   * that accepts three arguments: a Writer, a Context, and the template.
+   */
+  function compileTokens(tokens) {
+    var subRenders = {};
+
+    function subRender(i, tokens, template) {
+      if (!subRenders[i]) {
+        var fn = compileTokens(tokens);
+        subRenders[i] = function (writer, context) {
+          return fn(writer, context, template);
+        };
       }
 
-      code.push('\nbuffer += "');
-    };
+      return subRenders[i];
+    }
 
-    var sendPlain = function (source) {
-      code.push(
-        '";',
-        updateLine,
-        '\nbuffer += lookup("' + trim(source) + '",stack,"");',
-        '\nbuffer += "'
-      );
-    };
+    return function (writer, context, template) {
+      var buffer = "";
+      var token, sectionText;
 
-    var sendEscaped = function (source) {
-      code.push(
-        '";',
-        updateLine,
-        '\nbuffer += escapeHTML(lookup("' + trim(source) + '",stack,""));',
-        '\nbuffer += "'
-      );
-    };
+      for (var i = 0, len = tokens.length; i < len; ++i) {
+        token = tokens[i];
 
-    var line = 1, c, callback;
-    for (var i = 0, len = template.length; i < len; ++i) {
-      if (template.slice(i, i + openTag.length) === openTag) {
-        i += openTag.length;
-        c = template.substr(i, 1);
-        updateLine = '\nline = ' + line + ';';
-        nextOpenTag = openTag;
-        nextCloseTag = closeTag;
-        hasTag = true;
-
-        switch (c) {
-        case "!": // comment
-          i++;
-          callback = null;
-          break;
-        case "=": // change open/close tags, e.g. {{=<% %>=}}
-          i++;
-          closeTag = "=" + closeTag;
-          callback = setTags;
+        switch (token[0]) {
+        case "#":
+          sectionText = template.slice.apply(template, sectionBounds(token));
+          buffer += writer._section(token[1], context, sectionText, subRender(i, token[4], template));
           break;
-        case ">": // include partial
-          i++;
-          callback = includePartial;
+        case "^":
+          buffer += writer._inverted(token[1], context, subRender(i, token[4], template));
           break;
-        case "#": // start section
-          i++;
-          callback = openSection;
+        case ">":
+          buffer += writer._partial(token[1], context);
           break;
-        case "^": // start inverted section
-          i++;
-          callback = openInvertedSection;
+        case "&":
+          buffer += writer._name(token[1], context);
           break;
-        case "/": // end section
-          i++;
-          callback = closeSection;
+        case "name":
+          buffer += writer._escaped(token[1], context);
           break;
-        case "{": // plain variable
-          closeTag = "}" + closeTag;
-          // fall through
-        case "&": // plain variable
-          i++;
-          nonSpace = true;
-          callback = sendPlain;
+        case "text":
+          buffer += token[1];
           break;
-        default: // escaped variable
-          nonSpace = true;
-          callback = sendEscaped;
         }
+      }
 
-        var end = template.indexOf(closeTag, i);
+      return buffer;
+    };
+  }
 
-        if (end === -1) {
-          throw debug(new Error('Tag "' + openTag + '" was not closed properly'), template, line, options.file);
+  /**
+   * Forms the given array of `tokens` into a nested tree structure where
+   * tokens that represent a section have a fifth item: an array that contains
+   * all tokens in that section.
+   */
+  function nestTokens(tokens) {
+    var tree = [];
+    var collector = tree;
+    var sections = [];
+    var token, section;
+
+    for (var i = 0; i < tokens.length; ++i) {
+      token = tokens[i];
+
+      switch (token[0]) {
+      case "#":
+      case "^":
+        token[4] = [];
+        sections.push(token);
+        collector.push(token);
+        collector = token[4];
+        break;
+      case "/":
+        if (sections.length === 0) {
+          throw new Error("Unopened section: " + token[1]);
         }
 
-        var source = template.substring(i, end);
+        section = sections.pop();
 
-        if (callback) {
-          callback(source);
+        if (section[1] !== token[1]) {
+          throw new Error("Unclosed section: " + section[1]);
         }
 
-        // Maintain line count for \n in source.
-        var n = 0;
-        while (~(n = source.indexOf("\n", n))) {
-          line++;
-          n++;
+        if (sections.length > 0) {
+          collector = sections[sections.length - 1][4];
+        } else {
+          collector = tree;
         }
+        break;
+      default:
+        collector.push(token);
+      }
+    }
+
+    // Make sure there were no open sections when we're done.
+    section = sections.pop();
 
-        i = end + closeTag.length - 1;
-        openTag = nextOpenTag;
-        closeTag = nextCloseTag;
+    if (section) {
+      throw new Error("Unclosed section: " + section[1]);
+    }
+
+    return tree;
+  }
+
+  /**
+   * Combines the values of consecutive text tokens in the given `tokens` array
+   * to a single token.
+   */
+  function squashTokens(tokens) {
+    var token, lastToken;
+
+    for (var i = 0; i < tokens.length; ++i) {
+      token = tokens[i];
+
+      if (lastToken && lastToken[0] === "text" && token[0] === "text") {
+        lastToken[1] += token[1];
+        lastToken[3] = token[3];
+        tokens.splice(i--, 1); // Remove this token from the array.
       } else {
-        c = template.substr(i, 1);
+        lastToken = token;
+      }
+    }
+  }
 
-        switch (c) {
-        case '"':
-        case "\\":
-          nonSpace = true;
-          code.push("\\" + c);
-          break;
-        case "\r":
-          // Ignore carriage returns.
-          break;
-        case "\n":
-          spaces.push(code.length);
-          code.push("\\n");
-          stripSpace(); // Check for whitespace on the current line.
-          line++;
-          break;
-        default:
-          if (isWhitespace(c)) {
-            spaces.push(code.length);
+  function escapeTags(tags) {
+    if (tags.length !== 2) {
+      throw new Error("Invalid tags: " + tags.join(" "));
+    }
+
+    return [
+      new RegExp(escapeRe(tags[0]) + "\\s*"),
+      new RegExp("\\s*" + escapeRe(tags[1]))
+    ];
+  }
+
+  /**
+   * Breaks up the given `template` string into a tree of token objects. If
+   * `tags` is given here it must be an array with two string values: the
+   * opening and closing tags used in the template (e.g. ["<%", "%>"]). Of
+   * course, the default is to use mustaches (i.e. Mustache.tags).
+   */
+  exports.parse = function (template, tags) {
+    tags = tags || exports.tags;
+
+    var tagRes = escapeTags(tags);
+    var scanner = new Scanner(template);
+
+    var tokens = [],      // Buffer to hold the tokens
+        spaces = [],      // Indices of whitespace tokens on the current line
+        hasTag = false,   // Is there a {{tag}} on the current line?
+        nonSpace = false; // Is there a non-space char on the current line?
+
+    // Strips all whitespace tokens array for the current line
+    // if there was a {{#tag}} on it and otherwise only space.
+    function stripSpace() {
+      if (hasTag && !nonSpace) {
+        while (spaces.length) {
+          tokens.splice(spaces.pop(), 1);
+        }
+      } else {
+        spaces = [];
+      }
+
+      hasTag = false;
+      nonSpace = false;
+    }
+
+    var start, type, value, chr;
+
+    while (!scanner.eos()) {
+      start = scanner.pos;
+      value = scanner.scanUntil(tagRes[0]);
+
+      if (value) {
+        for (var i = 0, len = value.length; i < len; ++i) {
+          chr = value.charAt(i);
+
+          if (isWhitespace(chr)) {
+            spaces.push(tokens.length);
           } else {
             nonSpace = true;
           }
 
-          code.push(c);
+          tokens.push(["text", chr, start, start + 1]);
+          start += 1;
+
+          if (chr === "\n") {
+            stripSpace(); // Check for whitespace on the current line.
+          }
         }
       }
-    }
 
-    if (sectionStack.length != 0) {
-      throw debug(new Error('Section "' + sectionStack[sectionStack.length - 1].name + '" was not closed properly'), template, line, options.file);
-    }
+      start = scanner.pos;
 
-    // Clean up any whitespace from a closing {{tag}} that was at the end
-    // of the template without a trailing \n.
-    stripSpace();
+      // Match the opening tag.
+      if (!scanner.scan(tagRes[0])) {
+        break;
+      }
 
-    code.push(
-      '";',
-      "\nreturn buffer;",
-      "\n} catch (e) { throw {error: e, line: line}; }"
-    );
+      hasTag = true;
+      type = scanner.scan(tagRe) || "name";
+
+      // Skip any whitespace between tag and value.
+      scanner.scan(whiteRe);
+
+      // Extract the tag value.
+      if (type === "=") {
+        value = scanner.scanUntil(eqRe);
+        scanner.scan(eqRe);
+        scanner.scanUntil(tagRes[1]);
+      } else if (type === "{") {
+        var closeRe = new RegExp("\\s*" + escapeRe("}" + tags[1]));
+        value = scanner.scanUntil(closeRe);
+        scanner.scan(curlyRe);
+        scanner.scanUntil(tagRes[1]);
+        type = "&";
+      } else {
+        value = scanner.scanUntil(tagRes[1]);
+      }
 
-    // Ignore `buffer += "";` statements.
-    var body = code.join("").replace(/buffer \+= "";\n/g, "");
+      // Match the closing tag.
+      if (!scanner.scan(tagRes[1])) {
+        throw new Error("Unclosed tag at " + scanner.pos);
+      }
+
+      tokens.push([type, value, start, scanner.pos]);
 
-    if (options.debug) {
-      if (typeof console != "undefined" && console.log) {
-        console.log(body);
-      } else if (typeof print === "function") {
-        print(body);
+      if (type === "name" || type === "{" || type === "&") {
+        nonSpace = true;
+      }
+
+      // Set the tags for the next time around.
+      if (type === "=") {
+        tags = value.split(spaceRe);
+        tagRes = escapeTags(tags);
       }
     }
 
-    return body;
-  }
+    squashTokens(tokens);
+
+    return nestTokens(tokens);
+  };
+
+  // The high-level clearCache, compile, compilePartial, and render functions
+  // use this default writer.
+  var _writer = new Writer();
 
   /**
-   * Used by `compile` to generate a reusable function for the given `template`.
+   * Clears all cached templates and partials in the default writer.
    */
-  function _compile(template, options) {
-    var args = "view,partials,stack,lookup,escapeHTML,renderSection,render";
-    var body = parse(template, options);
-    var fn = new Function(args, body);
-
-    // This anonymous function wraps the generated function so we can do
-    // argument coercion, setup some variables, and handle any errors
-    // encountered while executing it.
-    return function (view, partials) {
-      partials = partials || {};
-
-      var stack = [view]; // context stack
+  exports.clearCache = function () {
+    return _writer.clearCache();
+  };
 
-      try {
-        return fn(view, partials, stack, lookup, escapeHTML, renderSection, render);
-      } catch (e) {
-        throw debug(e.error, template, e.line, options.file);
-      }
-    };
-  }
+  /**
+   * Compiles the given `template` to a reusable function using the default
+   * writer.
+   */
+  exports.compile = function (template, tags) {
+    return _writer.compile(template, tags);
+  };
 
-  // Cache of pre-compiled templates.
-  var _cache = {};
+  /**
+   * Compiles the partial with the given `name` and `template` to a reusable
+   * function using the default writer.
+   */
+  exports.compilePartial = function (name, template, tags) {
+    return _writer.compilePartial(name, template, tags);
+  };
 
   /**
-   * Clear the cache of compiled templates.
+   * Compiles the given array of tokens (the output of a parse) to a reusable
+   * function using the default writer.
    */
-  function clearCache() {
-    _cache = {};
-  }
+  exports.compileTokens = function (tokens, template) {
+    return _writer.compileTokens(tokens, template);
+  };
 
   /**
-   * Compiles the given `template` into a reusable function using the given
-   * `options`. In addition to the options accepted by Mustache.parse,
-   * recognized options include the following:
-   *
-   *   - cache    Set `false` to bypass any pre-compiled version of the given
-   *              template. Otherwise, a given `template` string will be cached
-   *              the first time it is parsed
+   * Renders the `template` with the given `view` and `partials` using the
+   * default writer.
    */
-  function compile(template, options) {
-    options = options || {};
+  exports.render = function (template, view, partials) {
+    return _writer.render(template, view, partials);
+  };
 
-    // Use a pre-compiled version from the cache if we have one.
-    if (options.cache !== false) {
-      if (!_cache[template]) {
-        _cache[template] = _compile(template, options);
-      }
+  // This is here for backwards compatibility with 0.4.x.
+  exports.to_html = function (template, view, partials, send) {
+    var result = exports.render(template, view, partials);
 
-      return _cache[template];
+    if (typeof send === "function") {
+      send(result);
+    } else {
+      return result;
     }
+  };
 
-    return _compile(template, options);
-  }
-
-  /**
-   * High-level function that renders the given `template` using the given
-   * `view` and `partials`. If you need to use any of the template options (see
-   * `compile` above), you must compile in a separate step, and then call that
-   * compiled function.
-   */
-  function render(template, view, partials) {
-    return compile(template)(view, partials);
-  }
+  return exports;
 
-})(Mustache);
+}())));
diff --git a/mustache.js.nuspec b/mustache.js.nuspec
index ec69150..1e5554b 100644
--- a/mustache.js.nuspec
+++ b/mustache.js.nuspec
@@ -2,7 +2,7 @@
 <package >
   <metadata>
     <id>mustache.js</id>
-    <version>0.5.0-dev</version>
+    <version>0.7.0</version>
     <authors>mustache.js Authors</authors>
     <licenseUrl>https://github.com/janl/mustache.js/blob/master/LICENSE</licenseUrl>
     <projectUrl>http://mustache.github.com/</projectUrl>
diff --git a/package.json b/package.json
index 1845b86..1303ec0 100644
--- a/package.json
+++ b/package.json
@@ -1,8 +1,17 @@
 {
   "name": "mustache",
-  "version": "0.5.0-dev",
+  "version": "0.7.0",
   "description": "Logic-less {{mustache}} templates with JavaScript",
   "author": "mustache.js Authors <http://github.com/janl/mustache.js>",
   "keywords": ["mustache", "template", "templates", "ejs"],
-  "main": "./mustache"
+  "main": "./mustache.js",
+  "devDependencies": {
+    "vows": "0.6.x"
+  },
+  "volo": {
+    "url": "https://raw.github.com/janl/mustache.js/0.7.0/mustache.js"
+  },
+  "scripts": {
+    "test": "vows --spec"
+  }
 }
diff --git a/spec/_files/ampersand_escape.js b/spec/_files/ampersand_escape.js
deleted file mode 100644
index 645efe1..0000000
--- a/spec/_files/ampersand_escape.js
+++ /dev/null
@@ -1,3 +0,0 @@
-var ampersand_escape = {
-  message: "Some <code>"
-};
diff --git a/spec/_files/apostrophe.js b/spec/_files/apostrophe.js
deleted file mode 100644
index df69cd2..0000000
--- a/spec/_files/apostrophe.js
+++ /dev/null
@@ -1 +0,0 @@
-var apostrophe = {'apos': "'", 'control':'X'};
diff --git a/spec/_files/array_of_strings.js b/spec/_files/array_of_strings.js
deleted file mode 100644
index 12c4992..0000000
--- a/spec/_files/array_of_strings.js
+++ /dev/null
@@ -1 +0,0 @@
-var array_of_strings = {array_of_strings: ['hello', 'world']};
diff --git a/spec/_files/backslashes.js b/spec/_files/backslashes.js
deleted file mode 100644
index 0b9765b..0000000
--- a/spec/_files/backslashes.js
+++ /dev/null
@@ -1,3 +0,0 @@
-var backslashes = {
-  value: "\\abc"
-};
diff --git a/spec/_files/bug_11_eating_whitespace.js b/spec/_files/bug_11_eating_whitespace.js
deleted file mode 100644
index 78ce975..0000000
--- a/spec/_files/bug_11_eating_whitespace.js
+++ /dev/null
@@ -1,3 +0,0 @@
-var bug_11_eating_whitespace = {
-  tag: "yo"
-};
diff --git a/spec/_files/changing_delimiters.js b/spec/_files/changing_delimiters.js
deleted file mode 100644
index 4fbe9f3..0000000
--- a/spec/_files/changing_delimiters.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var changing_delimiters = {
-  "foo": "foooooooooooooo",
-  "bar":"<b>bar!</b>"
-};
diff --git a/spec/_files/comments.js b/spec/_files/comments.js
deleted file mode 100644
index f85f979..0000000
--- a/spec/_files/comments.js
+++ /dev/null
@@ -1,5 +0,0 @@
-var comments = {
-  title: function() {
-    return "A Comedy of Errors";
-  }
-};
diff --git a/spec/_files/disappearing_whitespace.js b/spec/_files/disappearing_whitespace.js
deleted file mode 100644
index 3fe7121..0000000
--- a/spec/_files/disappearing_whitespace.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var disappearing_whitespace = {
-  bedrooms: true,
-  total: 1
-};
diff --git a/spec/_files/empty_list.js b/spec/_files/empty_list.js
deleted file mode 100644
index 80555c0..0000000
--- a/spec/_files/empty_list.js
+++ /dev/null
@@ -1,3 +0,0 @@
-var empty_list = {
-    jobs: []
-};
diff --git a/spec/_files/empty_sections.js b/spec/_files/empty_sections.js
deleted file mode 100644
index 6e50514..0000000
--- a/spec/_files/empty_sections.js
+++ /dev/null
@@ -1 +0,0 @@
-var empty_sections = {};
diff --git a/spec/_files/empty_template.js b/spec/_files/empty_template.js
deleted file mode 100644
index 564c9e2..0000000
--- a/spec/_files/empty_template.js
+++ /dev/null
@@ -1 +0,0 @@
-var empty_template = {};
diff --git a/spec/_files/error_not_found.js b/spec/_files/error_not_found.js
deleted file mode 100644
index 6cdbdb3..0000000
--- a/spec/_files/error_not_found.js
+++ /dev/null
@@ -1 +0,0 @@
-var error_not_found = {bar: 2};
\ No newline at end of file
diff --git a/spec/_files/escaped.js b/spec/_files/escaped.js
deleted file mode 100644
index 7a8baef..0000000
--- a/spec/_files/escaped.js
+++ /dev/null
@@ -1,6 +0,0 @@
-var escaped = {
-  title: function() {
-    return "Bear > Shark";
-  },
-  entities: "&quot;"
-};
diff --git a/spec/_files/escaped.mustache b/spec/_files/escaped.mustache
deleted file mode 100644
index ea25951..0000000
--- a/spec/_files/escaped.mustache
+++ /dev/null
@@ -1,2 +0,0 @@
-<h1>{{title}}</h1>
-But not {{entities}}.
diff --git a/spec/_files/escaped.txt b/spec/_files/escaped.txt
deleted file mode 100644
index 73ac5ce..0000000
--- a/spec/_files/escaped.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-<h1>Bear &gt; Shark</h1>
-But not &quot;.
diff --git a/spec/_files/higher_order_sections.js b/spec/_files/higher_order_sections.js
deleted file mode 100644
index c7e558e..0000000
--- a/spec/_files/higher_order_sections.js
+++ /dev/null
@@ -1,9 +0,0 @@
-var higher_order_sections = {
-  "name": "Tater",
-  "helper": "To tinker?",
-  "bolder": function() {
-    return function(text, render) {
-      return "<b>" + render(text) + '</b> ' + this.helper;
-    }
-  }
-}
\ No newline at end of file
diff --git a/spec/_files/higher_order_sections.txt b/spec/_files/higher_order_sections.txt
deleted file mode 100644
index 9db786a..0000000
--- a/spec/_files/higher_order_sections.txt
+++ /dev/null
@@ -1 +0,0 @@
-<b>Hi Tater.</b> To tinker?
diff --git a/spec/_files/inverted_section.js b/spec/_files/inverted_section.js
deleted file mode 100644
index 2e07fc3..0000000
--- a/spec/_files/inverted_section.js
+++ /dev/null
@@ -1,3 +0,0 @@
-var inverted_section =  {
-  "repos": []
-};
diff --git a/spec/_files/multiline_comment.js b/spec/_files/multiline_comment.js
deleted file mode 100644
index 24e7445..0000000
--- a/spec/_files/multiline_comment.js
+++ /dev/null
@@ -1 +0,0 @@
-var multiline_comment = {};
diff --git a/spec/_files/partial_array_of_partials.js b/spec/_files/partial_array_of_partials.js
deleted file mode 100644
index 706e7ed..0000000
--- a/spec/_files/partial_array_of_partials.js
+++ /dev/null
@@ -1,3 +0,0 @@
-var partial_array_of_partials = { 
-  numbers: [{i: '1'}, {i: '2'}, {i: '3'}, {i: '4'}]
-};
diff --git a/spec/_files/partial_array_of_partials_implicit.js b/spec/_files/partial_array_of_partials_implicit.js
deleted file mode 100644
index 864efa3..0000000
--- a/spec/_files/partial_array_of_partials_implicit.js
+++ /dev/null
@@ -1,3 +0,0 @@
-var partial_array_of_partials_implicit = { 
-  numbers: ['1', '2', '3', '4']
-};
diff --git a/spec/_files/partial_empty.js b/spec/_files/partial_empty.js
deleted file mode 100644
index 3f36df6..0000000
--- a/spec/_files/partial_empty.js
+++ /dev/null
@@ -1,3 +0,0 @@
-var partial_empty = {
-  foo: 1
-};
diff --git a/spec/_files/partial_recursion.js b/spec/_files/partial_recursion.js
deleted file mode 100644
index 3094eba..0000000
--- a/spec/_files/partial_recursion.js
+++ /dev/null
@@ -1,11 +0,0 @@
-var partial_recursion = {
-  name: '1',
-  kids: [
-    {
-      name: '1.1',
-      children: [
-        {name: '1.1.1'}
-      ]
-    }
-  ]
-};
diff --git a/spec/_files/partial_recursion.mustache b/spec/_files/partial_recursion.mustache
deleted file mode 100644
index 3c3651a..0000000
--- a/spec/_files/partial_recursion.mustache
+++ /dev/null
@@ -1,4 +0,0 @@
-{{name}}
-{{#kids}}
-{{>partial}}
-{{/kids}}
diff --git a/spec/_files/partial_recursion.partial b/spec/_files/partial_recursion.partial
deleted file mode 100644
index ba6f8fa..0000000
--- a/spec/_files/partial_recursion.partial
+++ /dev/null
@@ -1,4 +0,0 @@
-{{name}}
-{{#children}}
-{{>partial}}
-{{/children}}
diff --git a/spec/_files/partial_recursion.txt b/spec/_files/partial_recursion.txt
deleted file mode 100644
index 0f70515..0000000
--- a/spec/_files/partial_recursion.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-1
-1.1
-1.1.1
diff --git a/spec/_files/partial_template.js b/spec/_files/partial_template.js
deleted file mode 100644
index 196f1e8..0000000
--- a/spec/_files/partial_template.js
+++ /dev/null
@@ -1,6 +0,0 @@
-var partial_template = {
-  title: function() {
-    return "Welcome";
-  },
-  again: "Goodbye"
-};
diff --git a/spec/_files/string_as_context.js b/spec/_files/string_as_context.js
deleted file mode 100644
index 784368b..0000000
--- a/spec/_files/string_as_context.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var string_as_context = {
-    a_string: 'aa',
-    a_list: ['a','b','c']
-};
diff --git a/spec/_files/two_sections.js b/spec/_files/two_sections.js
deleted file mode 100644
index 8546f64..0000000
--- a/spec/_files/two_sections.js
+++ /dev/null
@@ -1 +0,0 @@
-var two_sections = {};
\ No newline at end of file
diff --git a/spec/_files/unescaped.js b/spec/_files/unescaped.js
deleted file mode 100644
index 0bd20b8..0000000
--- a/spec/_files/unescaped.js
+++ /dev/null
@@ -1,5 +0,0 @@
-var unescaped = {
-  title: function() {
-    return "Bear > Shark";
-  }
-};
diff --git a/spec/mustache_spec.rb b/spec/mustache_spec.rb
deleted file mode 100644
index 3c27d80..0000000
--- a/spec/mustache_spec.rb
+++ /dev/null
@@ -1,218 +0,0 @@
-require 'rubygems'
-require 'json'
-
-ROOT = File.expand_path('../..', __FILE__)
-SPEC = File.join(ROOT, 'spec')
-FILES = File.join(SPEC, '_files')
-
-MUSTACHE = File.read(File.join(ROOT, "mustache.js"))
-
-TESTS = Dir.glob(File.join(FILES, '*.js')).map do |name|
-  File.basename name, '.js'
-end
-
-NODE_PATH = `which node`.strip
-JS_PATH = `which js`.strip
-JSC_PATH = "/System/Library/Frameworks/JavaScriptCore.framework/Versions/A/Resources/jsc"
-RHINO_JAR = "org.mozilla.javascript.tools.shell.Main"
-
-def load_test(name)
-  template = File.read(File.join(FILES, "#{name}.mustache"))
-  view = File.read(File.join(FILES, "#{name}.js"))
-  partial_file = File.join(FILES, "#{name}.partial")
-  partial = if File.exist?(partial_file)
-    File.read(partial_file)
-  end
-  expect = File.read(File.join(FILES, "#{name}.txt"))
-
-  [template, view, partial, expect]
-end
-
-def run_js(runner, js)
-  cmd = case runner
-    when :spidermonkey
-      JS_PATH
-    when :jsc
-      JSC_PATH
-    when :rhino
-      "java #{RHINO_JAR}"
-    when :v8
-      NODE_PATH
-    end
-
-  runner_file = "runner.js"
-  File.open(runner_file, 'w') {|file| file.write(js) }
-  `#{cmd} #{runner_file}`
-ensure
-  FileUtils.rm_r(runner_file)
-end
-
-$engines_run = 0
-
-describe "mustache" do
-  shared_examples_for "mustache rendering" do
-    before(:all) do
-      $engines_run += 1
-    end
-
-    it "should return the same result when invoked multiple times" do
-      js = <<-JS
-        #{@boilerplate}
-        Mustache.render("x")
-        print(Mustache.render("x"));
-      JS
-
-      run_js(@runner, js).should == "x\n"
-    end
-
-    it "should clear the context after each run" do
-      js = <<-JS
-        #{@boilerplate}
-        Mustache.render("{{#list}}{{x}}{{/list}}", {list: [{x: 1}]})
-        try {
-          print(Mustache.render("{{#list}}{{x}}{{/list}}", {list: [{}]}));
-        } catch(e) {
-          print('ERROR: ' + e.message);
-        }
-      JS
-
-      run_js(@runner, js).should == "\n"
-    end
-
-    TESTS.each do |test|
-      describe test do
-        it "should render the correct output" do
-          template, view, partial, expect = load_test(test)
-
-          js = <<-JS
-            try {
-              #{@boilerplate}
-              var template = #{template.to_json};
-              #{view}
-              var partials = {partial: #{partial ? partial.to_json : '""'}};
-              print(Mustache.render(template, #{test}, partials));
-            } catch(e) {
-              print('ERROR: ' + e.message);
-            }
-          JS
-
-          run_js(@runner, js).chomp.should == expect
-        end
-
-        # it "should send the correct output" do
-        #   template, view, partial, expect = load_test(test)
-        #
-        #   js = <<-JS
-        #     try {
-        #       #{@boilerplate}
-        #       var template = #{template.to_json};
-        #       #{view}
-        #       var partials = {
-        #         "partial": #{(partial || '').to_json}
-        #       };
-        #       var buffer = [];
-        #       var send = function (chunk) {
-        #         buffer.push(chunk);
-        #       };
-        #       Mustache.render(template, #{test}, partials, send);
-        #       print(buffer.join(""));
-        #     } catch(e) {
-        #       print('ERROR: ' + e.message);
-        #     }
-        #   JS
-        #
-        #   run_js(@runner, js).chomp.should == expect
-        # end
-      end
-    end
-  end
-
-  context "running in V8 (Chrome, node)" do
-    if File.exist?(NODE_PATH)
-      before(:all) do
-        $stdout.write "Testing in V8 "
-        @runner = :v8
-        @boilerplate = MUSTACHE.dup
-        @boilerplate << <<-JS
-        var print = console.log;
-        JS
-      end
-
-      after(:all) do
-        puts " Done!"
-      end
-
-      it_should_behave_like "mustache rendering"
-    else
-      puts "Skipping tests in V8 (node not found)"
-    end
-  end
-
-  context "running in SpiderMonkey (Mozilla, Firefox)" do
-    if File.exist?(JS_PATH)
-      before(:all) do
-        $stdout.write "Testing in SpiderMonkey "
-        @runner = :spidermonkey
-        @boilerplate = MUSTACHE.dup
-      end
-
-      after(:all) do
-        puts " Done!"
-      end
-
-      it_should_behave_like "mustache rendering"
-    else
-      puts "Skipping tests in SpiderMonkey (js not found)"
-    end
-  end
-
-  context "running in JavaScriptCore (WebKit, Safari)" do
-    if File.exist?(JSC_PATH)
-      before(:all) do
-        $stdout.write "Testing in JavaScriptCore "
-        @runner = :jsc
-        @boilerplate = MUSTACHE.dup
-      end
-
-      after(:all) do
-        puts " Done!"
-      end
-
-      it_should_behave_like "mustache rendering"
-    else
-      puts "Skipping tests in JavaScriptCore (jsc not found)"
-    end
-  end
-
-  context "running in Rhino (Mozilla, Java)" do
-    if `java #{RHINO_JAR} 'foo' 2>&1` !~ /ClassNotFoundException/
-      before(:all) do
-        $stdout.write "Testing in Rhino "
-        @runner = :rhino
-        @boilerplate = MUSTACHE.dup
-      end
-
-      after(:all) do
-        puts " Done!"
-      end
-
-      it_should_behave_like "mustache rendering"
-    else
-      puts "Skipping tests in Rhino (JAR #{RHINO_JAR} was not found)"
-    end
-  end
-
-  context "suite" do
-    before(:each) do
-      $stdout.write "Verifying that we ran the tests in at least one engine ... "
-    end
-
-    after(:each) do
-      puts @exception.nil? ? "OK" : "ERROR"
-    end
-
-    it "should have run at least one time" do
-      $engines_run.should > 0
-    end
-  end
-end
diff --git a/test/_files/ampersand_escape.js b/test/_files/ampersand_escape.js
new file mode 100644
index 0000000..df6409f
--- /dev/null
+++ b/test/_files/ampersand_escape.js
@@ -0,0 +1,3 @@
+({
+  message: "Some <code>"
+})
diff --git a/spec/_files/ampersand_escape.mustache b/test/_files/ampersand_escape.mustache
similarity index 100%
rename from spec/_files/ampersand_escape.mustache
rename to test/_files/ampersand_escape.mustache
diff --git a/spec/_files/ampersand_escape.txt b/test/_files/ampersand_escape.txt
similarity index 100%
rename from spec/_files/ampersand_escape.txt
rename to test/_files/ampersand_escape.txt
diff --git a/test/_files/apostrophe.js b/test/_files/apostrophe.js
new file mode 100644
index 0000000..183c6d5
--- /dev/null
+++ b/test/_files/apostrophe.js
@@ -0,0 +1,4 @@
+({
+  'apos': "'",
+  'control': 'X'
+})
diff --git a/spec/_files/apostrophe.mustache b/test/_files/apostrophe.mustache
similarity index 100%
rename from spec/_files/apostrophe.mustache
rename to test/_files/apostrophe.mustache
diff --git a/spec/_files/apostrophe.txt b/test/_files/apostrophe.txt
similarity index 100%
rename from spec/_files/apostrophe.txt
rename to test/_files/apostrophe.txt
diff --git a/test/_files/array_of_strings.js b/test/_files/array_of_strings.js
new file mode 100644
index 0000000..6926612
--- /dev/null
+++ b/test/_files/array_of_strings.js
@@ -0,0 +1,3 @@
+({
+  array_of_strings: ['hello', 'world']
+})
diff --git a/spec/_files/array_of_strings.mustache b/test/_files/array_of_strings.mustache
similarity index 100%
rename from spec/_files/array_of_strings.mustache
rename to test/_files/array_of_strings.mustache
diff --git a/spec/_files/array_of_strings.txt b/test/_files/array_of_strings.txt
similarity index 100%
rename from spec/_files/array_of_strings.txt
rename to test/_files/array_of_strings.txt
diff --git a/test/_files/backslashes.js b/test/_files/backslashes.js
new file mode 100644
index 0000000..427acd9
--- /dev/null
+++ b/test/_files/backslashes.js
@@ -0,0 +1,3 @@
+({
+  value: "\\abc"
+})
diff --git a/spec/_files/backslashes.mustache b/test/_files/backslashes.mustache
similarity index 100%
rename from spec/_files/backslashes.mustache
rename to test/_files/backslashes.mustache
diff --git a/spec/_files/backslashes.txt b/test/_files/backslashes.txt
similarity index 100%
rename from spec/_files/backslashes.txt
rename to test/_files/backslashes.txt
diff --git a/test/_files/bug_11_eating_whitespace.js b/test/_files/bug_11_eating_whitespace.js
new file mode 100644
index 0000000..e41ccd1
--- /dev/null
+++ b/test/_files/bug_11_eating_whitespace.js
@@ -0,0 +1,3 @@
+({
+  tag: "yo"
+})
diff --git a/spec/_files/bug_11_eating_whitespace.mustache b/test/_files/bug_11_eating_whitespace.mustache
similarity index 100%
rename from spec/_files/bug_11_eating_whitespace.mustache
rename to test/_files/bug_11_eating_whitespace.mustache
diff --git a/spec/_files/bug_11_eating_whitespace.txt b/test/_files/bug_11_eating_whitespace.txt
similarity index 100%
rename from spec/_files/bug_11_eating_whitespace.txt
rename to test/_files/bug_11_eating_whitespace.txt
diff --git a/test/_files/changing_delimiters.js b/test/_files/changing_delimiters.js
new file mode 100644
index 0000000..b808f4c
--- /dev/null
+++ b/test/_files/changing_delimiters.js
@@ -0,0 +1,4 @@
+({
+  "foo": "foooooooooooooo",
+  "bar": "<b>bar!</b>"
+})
diff --git a/spec/_files/changing_delimiters.mustache b/test/_files/changing_delimiters.mustache
similarity index 100%
rename from spec/_files/changing_delimiters.mustache
rename to test/_files/changing_delimiters.mustache
diff --git a/spec/_files/changing_delimiters.txt b/test/_files/changing_delimiters.txt
similarity index 100%
rename from spec/_files/changing_delimiters.txt
rename to test/_files/changing_delimiters.txt
diff --git a/test/_files/comments.js b/test/_files/comments.js
new file mode 100644
index 0000000..f20b8b1
--- /dev/null
+++ b/test/_files/comments.js
@@ -0,0 +1,5 @@
+({
+  title: function () {
+    return "A Comedy of Errors";
+  }
+})
diff --git a/spec/_files/comments.mustache b/test/_files/comments.mustache
similarity index 100%
rename from spec/_files/comments.mustache
rename to test/_files/comments.mustache
diff --git a/spec/_files/comments.txt b/test/_files/comments.txt
similarity index 100%
rename from spec/_files/comments.txt
rename to test/_files/comments.txt
diff --git a/spec/_files/complex.js b/test/_files/complex.js
similarity index 74%
rename from spec/_files/complex.js
rename to test/_files/complex.js
index a0dfb63..68a4809 100644
--- a/spec/_files/complex.js
+++ b/test/_files/complex.js
@@ -1,5 +1,5 @@
-var complex = {
-  header: function() {
+({
+  header: function () {
     return "Colors";
   },
   item: [
@@ -7,13 +7,13 @@ var complex = {
       {name: "green", current: false, url: "#Green"},
       {name: "blue", current: false, url: "#Blue"}
   ],
-  link: function() {
+  link: function () {
     return this["current"] !== true;
   },
-  list: function() {
+  list: function () {
     return this.item.length !== 0;
   },
-  empty: function() {
+  empty: function () {
     return this.item.length === 0;
   }
-};
+})
diff --git a/spec/_files/complex.mustache b/test/_files/complex.mustache
similarity index 100%
rename from spec/_files/complex.mustache
rename to test/_files/complex.mustache
diff --git a/spec/_files/complex.txt b/test/_files/complex.txt
similarity index 100%
rename from spec/_files/complex.txt
rename to test/_files/complex.txt
diff --git a/spec/_files/context_lookup.js b/test/_files/context_lookup.js
similarity index 73%
rename from spec/_files/context_lookup.js
rename to test/_files/context_lookup.js
index 49d4453..8ce6299 100644
--- a/spec/_files/context_lookup.js
+++ b/test/_files/context_lookup.js
@@ -1,8 +1,8 @@
-var context_lookup = {
+({
   "outer": {
     "id": 1,
     "second": {
       "nothing": 2
     }
   }
-};
+})
diff --git a/spec/_files/context_lookup.mustache b/test/_files/context_lookup.mustache
similarity index 100%
rename from spec/_files/context_lookup.mustache
rename to test/_files/context_lookup.mustache
diff --git a/spec/_files/context_lookup.txt b/test/_files/context_lookup.txt
similarity index 100%
rename from spec/_files/context_lookup.txt
rename to test/_files/context_lookup.txt
diff --git a/spec/_files/delimiters.js b/test/_files/delimiters.js
similarity index 89%
rename from spec/_files/delimiters.js
rename to test/_files/delimiters.js
index 220d0d2..365d01e 100644
--- a/spec/_files/delimiters.js
+++ b/test/_files/delimiters.js
@@ -1,6 +1,6 @@
-var delimiters = {
+({
   first: "It worked the first time.",
   second: "And it worked the second time.",
   third: "Then, surprisingly, it worked the third time.",
   fourth: "Fourth time also fine!."
-}
+})
diff --git a/spec/_files/delimiters.mustache b/test/_files/delimiters.mustache
similarity index 100%
rename from spec/_files/delimiters.mustache
rename to test/_files/delimiters.mustache
diff --git a/spec/_files/delimiters.txt b/test/_files/delimiters.txt
similarity index 100%
rename from spec/_files/delimiters.txt
rename to test/_files/delimiters.txt
diff --git a/test/_files/disappearing_whitespace.js b/test/_files/disappearing_whitespace.js
new file mode 100644
index 0000000..973dd1c
--- /dev/null
+++ b/test/_files/disappearing_whitespace.js
@@ -0,0 +1,4 @@
+({
+  bedrooms: true,
+  total: 1
+})
diff --git a/spec/_files/disappearing_whitespace.mustache b/test/_files/disappearing_whitespace.mustache
similarity index 100%
rename from spec/_files/disappearing_whitespace.mustache
rename to test/_files/disappearing_whitespace.mustache
diff --git a/spec/_files/disappearing_whitespace.txt b/test/_files/disappearing_whitespace.txt
similarity index 100%
rename from spec/_files/disappearing_whitespace.txt
rename to test/_files/disappearing_whitespace.txt
diff --git a/spec/_files/dot_notation.js b/test/_files/dot_notation.js
similarity index 70%
rename from spec/_files/dot_notation.js
rename to test/_files/dot_notation.js
index c1295f5..de06a03 100644
--- a/spec/_files/dot_notation.js
+++ b/test/_files/dot_notation.js
@@ -1,17 +1,17 @@
-var dot_notation = {
+({
   name: "A Book",
   authors: ["John Power", "Jamie Walsh"],
-  price:{
+  price: {
     value: 200,
-    vat: function() {
+    vat: function () {
       return this.value * 0.2;
     },
     currency: {
-      symbol: '&euro;',
-      name: 'Euro'
+      symbol: '$',
+      name: 'USD'
     }
   },
-  availability:{
+  availability: {
     status: true,
     text: "In Stock"
   },
@@ -20,4 +20,4 @@ var dot_notation = {
     zero: 0,
     notTrue: false
   }
-};
+})
diff --git a/spec/_files/dot_notation.mustache b/test/_files/dot_notation.mustache
similarity index 53%
rename from spec/_files/dot_notation.mustache
rename to test/_files/dot_notation.mustache
index da1bad7..f89d70b 100644
--- a/spec/_files/dot_notation.mustache
+++ b/test/_files/dot_notation.mustache
@@ -1,8 +1,8 @@
 <!-- exciting part -->
 <h1>{{name}}</h1>
 <p>Authors: <ul>{{#authors}}<li>{{.}}</li>{{/authors}}</ul></p>
-<p>Price: {{price.currency.symbol}}{{price.value}} {{#price.currency}}{{name}} <b>{{availability.text}}</b>{{/price.currency}}</p>
-<p>VAT: {{price.currency.symbol}}{{price.vat}}</p>
+<p>Price: {{{price.currency.symbol}}}{{price.value}} {{#price.currency}}{{name}} <b>{{availability.text}}</b>{{/price.currency}}</p>
+<p>VAT: {{{price.currency.symbol}}}{{#price}}{{vat}}{{/price}}</p>
 <!-- boring part -->
 <h2>Test truthy false values:</h2>
 <p>Zero: {{truthy.zero}}</p>
diff --git a/spec/_files/dot_notation.txt b/test/_files/dot_notation.txt
similarity index 74%
rename from spec/_files/dot_notation.txt
rename to test/_files/dot_notation.txt
index d0e4707..08afa05 100644
--- a/spec/_files/dot_notation.txt
+++ b/test/_files/dot_notation.txt
@@ -1,8 +1,8 @@
 <!-- exciting part -->
 <h1>A Book</h1>
 <p>Authors: <ul><li>John Power</li><li>Jamie Walsh</li></ul></p>
-<p>Price: &euro;200 Euro <b>In Stock</b></p>
-<p>VAT: &euro;40</p>
+<p>Price: $200 USD <b>In Stock</b></p>
+<p>VAT: $40</p>
 <!-- boring part -->
 <h2>Test truthy false values:</h2>
 <p>Zero: 0</p>
diff --git a/spec/_files/double_render.js b/test/_files/double_render.js
similarity index 65%
rename from spec/_files/double_render.js
rename to test/_files/double_render.js
index 24125dc..28acb2c 100644
--- a/spec/_files/double_render.js
+++ b/test/_files/double_render.js
@@ -1,5 +1,5 @@
-var double_render = {
+({
   foo: true,
   bar: "{{win}}",
   win: "FAIL"
-};
\ No newline at end of file
+})
diff --git a/spec/_files/double_render.mustache b/test/_files/double_render.mustache
similarity index 100%
rename from spec/_files/double_render.mustache
rename to test/_files/double_render.mustache
diff --git a/spec/_files/double_render.txt b/test/_files/double_render.txt
similarity index 100%
rename from spec/_files/double_render.txt
rename to test/_files/double_render.txt
diff --git a/test/_files/empty_list.js b/test/_files/empty_list.js
new file mode 100644
index 0000000..c0e1159
--- /dev/null
+++ b/test/_files/empty_list.js
@@ -0,0 +1,3 @@
+({
+  jobs: []
+})
diff --git a/spec/_files/empty_list.mustache b/test/_files/empty_list.mustache
similarity index 100%
rename from spec/_files/empty_list.mustache
rename to test/_files/empty_list.mustache
diff --git a/spec/_files/empty_list.txt b/test/_files/empty_list.txt
similarity index 100%
rename from spec/_files/empty_list.txt
rename to test/_files/empty_list.txt
diff --git a/test/_files/empty_sections.js b/test/_files/empty_sections.js
new file mode 100644
index 0000000..b4100a5
--- /dev/null
+++ b/test/_files/empty_sections.js
@@ -0,0 +1 @@
+({})
diff --git a/spec/_files/empty_sections.mustache b/test/_files/empty_sections.mustache
similarity index 100%
rename from spec/_files/empty_sections.mustache
rename to test/_files/empty_sections.mustache
diff --git a/spec/_files/empty_sections.txt b/test/_files/empty_sections.txt
similarity index 100%
rename from spec/_files/empty_sections.txt
rename to test/_files/empty_sections.txt
diff --git a/spec/_files/empty_string.js b/test/_files/empty_string.js
similarity index 73%
rename from spec/_files/empty_string.js
rename to test/_files/empty_string.js
index 2151336..be6e058 100644
--- a/spec/_files/empty_string.js
+++ b/test/_files/empty_string.js
@@ -1,6 +1,6 @@
-var empty_string = {
+({
   description: "That is all!",
   child: {
     description: ""
   }
-};
+})
diff --git a/spec/_files/empty_string.mustache b/test/_files/empty_string.mustache
similarity index 100%
rename from spec/_files/empty_string.mustache
rename to test/_files/empty_string.mustache
diff --git a/spec/_files/empty_string.txt b/test/_files/empty_string.txt
similarity index 100%
rename from spec/_files/empty_string.txt
rename to test/_files/empty_string.txt
diff --git a/test/_files/empty_template.js b/test/_files/empty_template.js
new file mode 100644
index 0000000..b4100a5
--- /dev/null
+++ b/test/_files/empty_template.js
@@ -0,0 +1 @@
+({})
diff --git a/spec/_files/empty_template.mustache b/test/_files/empty_template.mustache
similarity index 100%
rename from spec/_files/empty_template.mustache
rename to test/_files/empty_template.mustache
diff --git a/spec/_files/empty_template.txt b/test/_files/empty_template.txt
similarity index 100%
rename from spec/_files/empty_template.txt
rename to test/_files/empty_template.txt
diff --git a/test/_files/error_not_found.js b/test/_files/error_not_found.js
new file mode 100644
index 0000000..10e4709
--- /dev/null
+++ b/test/_files/error_not_found.js
@@ -0,0 +1,3 @@
+({
+  bar: 2
+})
diff --git a/spec/_files/error_not_found.mustache b/test/_files/error_not_found.mustache
similarity index 100%
rename from spec/_files/error_not_found.mustache
rename to test/_files/error_not_found.mustache
diff --git a/spec/_files/error_not_found.txt b/test/_files/error_not_found.txt
similarity index 100%
rename from spec/_files/error_not_found.txt
rename to test/_files/error_not_found.txt
diff --git a/test/_files/escaped.js b/test/_files/escaped.js
new file mode 100644
index 0000000..cd77c1f
--- /dev/null
+++ b/test/_files/escaped.js
@@ -0,0 +1,6 @@
+({
+  title: function () {
+    return "Bear > Shark";
+  },
+  entities: "&quot; \"'<>/"
+})
diff --git a/test/_files/escaped.mustache b/test/_files/escaped.mustache
new file mode 100644
index 0000000..93e800b
--- /dev/null
+++ b/test/_files/escaped.mustache
@@ -0,0 +1,2 @@
+<h1>{{title}}</h1>
+And even {{entities}}, but not {{{entities}}}.
diff --git a/test/_files/escaped.txt b/test/_files/escaped.txt
new file mode 100644
index 0000000..c1527d5
--- /dev/null
+++ b/test/_files/escaped.txt
@@ -0,0 +1,2 @@
+<h1>Bear &gt; Shark</h1>
+And even &amp;quot; &quot;&#39;&lt;&gt;&#x2F;, but not &quot; "'<>/.
diff --git a/test/_files/falsy.js b/test/_files/falsy.js
new file mode 100644
index 0000000..ae9b9bf
--- /dev/null
+++ b/test/_files/falsy.js
@@ -0,0 +1,8 @@
+({
+  "emptyString": "",
+  "emptyArray": [],
+  "zero": 0,
+  "null": null,
+  "undefined": undefined,
+  "NaN": 0/0
+})
\ No newline at end of file
diff --git a/test/_files/falsy.mustache b/test/_files/falsy.mustache
new file mode 100644
index 0000000..f3698da
--- /dev/null
+++ b/test/_files/falsy.mustache
@@ -0,0 +1,12 @@
+{{#emptyString}}empty string{{/emptyString}}
+{{^emptyString}}inverted empty string{{/emptyString}}
+{{#emptyArray}}empty array{{/emptyArray}}
+{{^emptyArray}}inverted empty array{{/emptyArray}}
+{{#zero}}zero{{/zero}}
+{{^zero}}inverted zero{{/zero}}
+{{#null}}null{{/null}}
+{{^null}}inverted null{{/null}}
+{{#undefined}}undefined{{/undefined}}
+{{^undefined}}inverted undefined{{/undefined}}
+{{#NaN}}NaN{{/NaN}}
+{{^NaN}}inverted NaN{{/NaN}}
diff --git a/test/_files/falsy.txt b/test/_files/falsy.txt
new file mode 100644
index 0000000..9b7cde3
--- /dev/null
+++ b/test/_files/falsy.txt
@@ -0,0 +1,12 @@
+
+inverted empty string
+
+inverted empty array
+
+inverted zero
+
+inverted null
+
+inverted undefined
+
+inverted NaN
diff --git a/test/_files/grandparent_context.js b/test/_files/grandparent_context.js
new file mode 100644
index 0000000..97dbfd3
--- /dev/null
+++ b/test/_files/grandparent_context.js
@@ -0,0 +1,19 @@
+({
+  grand_parent_id: 'grand_parent1',
+  parent_contexts: [
+    {
+      parent_id: 'parent1',
+      child_contexts: [
+        { child_id: 'parent1-child1' },
+        { child_id: 'parent1-child2' }
+      ]
+    },
+    {
+      parent_id: 'parent2',
+      child_contexts: [
+        { child_id: 'parent2-child1' },
+        { child_id: 'parent2-child2' }
+      ]
+    }
+  ]
+})
diff --git a/test/_files/grandparent_context.mustache b/test/_files/grandparent_context.mustache
new file mode 100644
index 0000000..e6c07a2
--- /dev/null
+++ b/test/_files/grandparent_context.mustache
@@ -0,0 +1,10 @@
+{{grand_parent_id}}
+{{#parent_contexts}}
+{{grand_parent_id}}
+{{parent_id}}
+{{#child_contexts}}
+{{grand_parent_id}}
+{{parent_id}}
+{{child_id}}
+{{/child_contexts}}
+{{/parent_contexts}}
diff --git a/test/_files/grandparent_context.txt b/test/_files/grandparent_context.txt
new file mode 100644
index 0000000..64996ad
--- /dev/null
+++ b/test/_files/grandparent_context.txt
@@ -0,0 +1,17 @@
+grand_parent1
+grand_parent1
+parent1
+grand_parent1
+parent1
+parent1-child1
+grand_parent1
+parent1
+parent1-child2
+grand_parent1
+parent2
+grand_parent1
+parent2
+parent2-child1
+grand_parent1
+parent2
+parent2-child2
diff --git a/test/_files/higher_order_sections.js b/test/_files/higher_order_sections.js
new file mode 100644
index 0000000..bacb0a4
--- /dev/null
+++ b/test/_files/higher_order_sections.js
@@ -0,0 +1,9 @@
+({
+  name: "Tater",
+  helper: "To tinker?",
+  bolder: function () {
+    return function (text, render) {
+      return text + ' => <b>' + render(text) + '</b> ' + this.helper;
+    }
+  }
+})
diff --git a/spec/_files/higher_order_sections.mustache b/test/_files/higher_order_sections.mustache
similarity index 100%
rename from spec/_files/higher_order_sections.mustache
rename to test/_files/higher_order_sections.mustache
diff --git a/test/_files/higher_order_sections.txt b/test/_files/higher_order_sections.txt
new file mode 100644
index 0000000..be50ad7
--- /dev/null
+++ b/test/_files/higher_order_sections.txt
@@ -0,0 +1 @@
+Hi {{name}}. => <b>Hi Tater.</b> To tinker?
diff --git a/spec/_files/included_tag.js b/test/_files/included_tag.js
similarity index 55%
rename from spec/_files/included_tag.js
rename to test/_files/included_tag.js
index a63df27..eb032a4 100644
--- a/spec/_files/included_tag.js
+++ b/test/_files/included_tag.js
@@ -1,3 +1,3 @@
-var included_tag = {
+({
   html: "I like {{mustache}}"
-};
+})
diff --git a/spec/_files/included_tag.mustache b/test/_files/included_tag.mustache
similarity index 100%
rename from spec/_files/included_tag.mustache
rename to test/_files/included_tag.mustache
diff --git a/spec/_files/included_tag.txt b/test/_files/included_tag.txt
similarity index 100%
rename from spec/_files/included_tag.txt
rename to test/_files/included_tag.txt
diff --git a/test/_files/inverted_section.js b/test/_files/inverted_section.js
new file mode 100644
index 0000000..f8f08fd
--- /dev/null
+++ b/test/_files/inverted_section.js
@@ -0,0 +1,3 @@
+({
+  "repos": []
+})
diff --git a/spec/_files/inverted_section.mustache b/test/_files/inverted_section.mustache
similarity index 100%
rename from spec/_files/inverted_section.mustache
rename to test/_files/inverted_section.mustache
diff --git a/spec/_files/inverted_section.txt b/test/_files/inverted_section.txt
similarity index 100%
rename from spec/_files/inverted_section.txt
rename to test/_files/inverted_section.txt
diff --git a/spec/_files/keys_with_questionmarks.js b/test/_files/keys_with_questionmarks.js
similarity index 50%
rename from spec/_files/keys_with_questionmarks.js
rename to test/_files/keys_with_questionmarks.js
index 55a220d..becd631 100644
--- a/spec/_files/keys_with_questionmarks.js
+++ b/test/_files/keys_with_questionmarks.js
@@ -1,5 +1,5 @@
-var keys_with_questionmarks = {
+({
   "person?": {
     name: "Jon"
   }
-}
+})
diff --git a/spec/_files/keys_with_questionmarks.mustache b/test/_files/keys_with_questionmarks.mustache
similarity index 100%
rename from spec/_files/keys_with_questionmarks.mustache
rename to test/_files/keys_with_questionmarks.mustache
diff --git a/spec/_files/keys_with_questionmarks.txt b/test/_files/keys_with_questionmarks.txt
similarity index 100%
rename from spec/_files/keys_with_questionmarks.txt
rename to test/_files/keys_with_questionmarks.txt
diff --git a/test/_files/malicious_template.js b/test/_files/malicious_template.js
new file mode 100644
index 0000000..b4100a5
--- /dev/null
+++ b/test/_files/malicious_template.js
@@ -0,0 +1 @@
+({})
diff --git a/test/_files/malicious_template.mustache b/test/_files/malicious_template.mustache
new file mode 100644
index 0000000..b956867
--- /dev/null
+++ b/test/_files/malicious_template.mustache
@@ -0,0 +1,5 @@
+{{"+(function () {throw "evil"})()+"}}
+{{{"+(function () {throw "evil"})()+"}}}
+{{> "+(function () {throw "evil"})()+"}}
+{{# "+(function () {throw "evil"})()+"}}
+{{/ "+(function () {throw "evil"})()+"}}
diff --git a/test/_files/malicious_template.txt b/test/_files/malicious_template.txt
new file mode 100644
index 0000000..139597f
--- /dev/null
+++ b/test/_files/malicious_template.txt
@@ -0,0 +1,2 @@
+
+
diff --git a/test/_files/multiline_comment.js b/test/_files/multiline_comment.js
new file mode 100644
index 0000000..b4100a5
--- /dev/null
+++ b/test/_files/multiline_comment.js
@@ -0,0 +1 @@
+({})
diff --git a/spec/_files/multiline_comment.mustache b/test/_files/multiline_comment.mustache
similarity index 100%
rename from spec/_files/multiline_comment.mustache
rename to test/_files/multiline_comment.mustache
diff --git a/spec/_files/multiline_comment.txt b/test/_files/multiline_comment.txt
similarity index 100%
rename from spec/_files/multiline_comment.txt
rename to test/_files/multiline_comment.txt
diff --git a/spec/_files/nested_iterating.js b/test/_files/nested_iterating.js
similarity index 71%
rename from spec/_files/nested_iterating.js
rename to test/_files/nested_iterating.js
index a8275f9..2708b2d 100644
--- a/spec/_files/nested_iterating.js
+++ b/test/_files/nested_iterating.js
@@ -1,8 +1,8 @@
-var nested_iterating = {
+({
   inner: [{
     foo: 'foo',
     inner: [{
       bar: 'bar'
     }]
   }]
-};
+})
diff --git a/spec/_files/nested_iterating.mustache b/test/_files/nested_iterating.mustache
similarity index 100%
rename from spec/_files/nested_iterating.mustache
rename to test/_files/nested_iterating.mustache
diff --git a/spec/_files/nested_iterating.txt b/test/_files/nested_iterating.txt
similarity index 100%
rename from spec/_files/nested_iterating.txt
rename to test/_files/nested_iterating.txt
diff --git a/spec/_files/nesting.js b/test/_files/nesting.js
similarity index 76%
rename from spec/_files/nesting.js
rename to test/_files/nesting.js
index 1f76cd0..264cc2f 100644
--- a/spec/_files/nesting.js
+++ b/test/_files/nesting.js
@@ -1,7 +1,7 @@
-var nesting = {
+({
   foo: [
     {a: {b: 1}},
     {a: {b: 2}},
     {a: {b: 3}}
   ]
-};
+})
diff --git a/spec/_files/nesting.mustache b/test/_files/nesting.mustache
similarity index 100%
rename from spec/_files/nesting.mustache
rename to test/_files/nesting.mustache
diff --git a/spec/_files/nesting.txt b/test/_files/nesting.txt
similarity index 100%
rename from spec/_files/nesting.txt
rename to test/_files/nesting.txt
diff --git a/spec/_files/nesting_same_name.js b/test/_files/nesting_same_name.js
similarity index 71%
rename from spec/_files/nesting_same_name.js
rename to test/_files/nesting_same_name.js
index a5fb65b..10a0c14 100644
--- a/spec/_files/nesting_same_name.js
+++ b/test/_files/nesting_same_name.js
@@ -1,8 +1,8 @@
-var nesting_same_name = {
+({
   items: [
     {
       name: 'name',
       items: [1, 2, 3, 4]
     }
   ]
-};
+})
diff --git a/spec/_files/nesting_same_name.mustache b/test/_files/nesting_same_name.mustache
similarity index 100%
rename from spec/_files/nesting_same_name.mustache
rename to test/_files/nesting_same_name.mustache
diff --git a/spec/_files/nesting_same_name.txt b/test/_files/nesting_same_name.txt
similarity index 100%
rename from spec/_files/nesting_same_name.txt
rename to test/_files/nesting_same_name.txt
diff --git a/spec/_files/null_string.js b/test/_files/null_string.js
similarity index 84%
rename from spec/_files/null_string.js
rename to test/_files/null_string.js
index ab5291f..984ee51 100644
--- a/spec/_files/null_string.js
+++ b/test/_files/null_string.js
@@ -1,4 +1,4 @@
-var null_string = {
+({
   name: "Elise",
   glytch: true,
   binary: false,
@@ -7,4 +7,4 @@ var null_string = {
   numeric: function() {
     return NaN;
   }
-};
+})
diff --git a/spec/_files/null_string.mustache b/test/_files/null_string.mustache
similarity index 100%
rename from spec/_files/null_string.mustache
rename to test/_files/null_string.mustache
diff --git a/spec/_files/null_string.txt b/test/_files/null_string.txt
similarity index 100%
rename from spec/_files/null_string.txt
rename to test/_files/null_string.txt
diff --git a/test/_files/null_view.js b/test/_files/null_view.js
new file mode 100644
index 0000000..dbdae72
--- /dev/null
+++ b/test/_files/null_view.js
@@ -0,0 +1,4 @@
+({
+  name: 'Joe',
+  friends: null
+})
diff --git a/test/_files/null_view.mustache b/test/_files/null_view.mustache
new file mode 100644
index 0000000..115b376
--- /dev/null
+++ b/test/_files/null_view.mustache
@@ -0,0 +1 @@
+{{name}}'s friends: {{#friends}}{{name}}, {{/friends}}
\ No newline at end of file
diff --git a/test/_files/null_view.txt b/test/_files/null_view.txt
new file mode 100644
index 0000000..15ed2ab
--- /dev/null
+++ b/test/_files/null_view.txt
@@ -0,0 +1 @@
+Joe's friends: 
\ No newline at end of file
diff --git a/spec/_files/partial_array.js b/test/_files/partial_array.js
similarity index 55%
rename from spec/_files/partial_array.js
rename to test/_files/partial_array.js
index f16e9eb..2a6ddf1 100644
--- a/spec/_files/partial_array.js
+++ b/test/_files/partial_array.js
@@ -1,3 +1,3 @@
-var partial_array = {
+({
   array: ['1', '2', '3', '4']
-};
\ No newline at end of file
+})
diff --git a/spec/_files/partial_array.mustache b/test/_files/partial_array.mustache
similarity index 100%
rename from spec/_files/partial_array.mustache
rename to test/_files/partial_array.mustache
diff --git a/spec/_files/partial_array.partial b/test/_files/partial_array.partial
similarity index 100%
rename from spec/_files/partial_array.partial
rename to test/_files/partial_array.partial
diff --git a/spec/_files/partial_array.txt b/test/_files/partial_array.txt
similarity index 100%
rename from spec/_files/partial_array.txt
rename to test/_files/partial_array.txt
diff --git a/test/_files/partial_array_of_partials.js b/test/_files/partial_array_of_partials.js
new file mode 100644
index 0000000..03f13c9
--- /dev/null
+++ b/test/_files/partial_array_of_partials.js
@@ -0,0 +1,8 @@
+({
+  numbers: [
+    {i: '1'},
+    {i: '2'},
+    {i: '3'},
+    {i: '4'}
+  ]
+})
diff --git a/spec/_files/partial_array_of_partials.mustache b/test/_files/partial_array_of_partials.mustache
similarity index 100%
rename from spec/_files/partial_array_of_partials.mustache
rename to test/_files/partial_array_of_partials.mustache
diff --git a/spec/_files/partial_array_of_partials.partial b/test/_files/partial_array_of_partials.partial
similarity index 100%
rename from spec/_files/partial_array_of_partials.partial
rename to test/_files/partial_array_of_partials.partial
diff --git a/spec/_files/partial_array_of_partials.txt b/test/_files/partial_array_of_partials.txt
similarity index 100%
rename from spec/_files/partial_array_of_partials.txt
rename to test/_files/partial_array_of_partials.txt
diff --git a/test/_files/partial_array_of_partials_implicit.js b/test/_files/partial_array_of_partials_implicit.js
new file mode 100644
index 0000000..9ec0c00
--- /dev/null
+++ b/test/_files/partial_array_of_partials_implicit.js
@@ -0,0 +1,3 @@
+({
+  numbers: ['1', '2', '3', '4']
+})
diff --git a/spec/_files/partial_array_of_partials_implicit.mustache b/test/_files/partial_array_of_partials_implicit.mustache
similarity index 100%
rename from spec/_files/partial_array_of_partials_implicit.mustache
rename to test/_files/partial_array_of_partials_implicit.mustache
diff --git a/spec/_files/partial_array_of_partials_implicit.partial b/test/_files/partial_array_of_partials_implicit.partial
similarity index 100%
rename from spec/_files/partial_array_of_partials_implicit.partial
rename to test/_files/partial_array_of_partials_implicit.partial
diff --git a/spec/_files/partial_array_of_partials_implicit.txt b/test/_files/partial_array_of_partials_implicit.txt
similarity index 100%
rename from spec/_files/partial_array_of_partials_implicit.txt
rename to test/_files/partial_array_of_partials_implicit.txt
diff --git a/test/_files/partial_empty.js b/test/_files/partial_empty.js
new file mode 100644
index 0000000..82b8c22
--- /dev/null
+++ b/test/_files/partial_empty.js
@@ -0,0 +1,3 @@
+({
+  foo: 1
+})
diff --git a/spec/_files/partial_empty.mustache b/test/_files/partial_empty.mustache
similarity index 100%
rename from spec/_files/partial_empty.mustache
rename to test/_files/partial_empty.mustache
diff --git a/spec/_files/partial_empty.partial b/test/_files/partial_empty.partial
similarity index 100%
rename from spec/_files/partial_empty.partial
rename to test/_files/partial_empty.partial
diff --git a/spec/_files/partial_empty.txt b/test/_files/partial_empty.txt
similarity index 100%
rename from spec/_files/partial_empty.txt
rename to test/_files/partial_empty.txt
diff --git a/test/_files/partial_template.js b/test/_files/partial_template.js
new file mode 100644
index 0000000..a913f87
--- /dev/null
+++ b/test/_files/partial_template.js
@@ -0,0 +1,6 @@
+({
+  title: function () {
+    return "Welcome";
+  },
+  again: "Goodbye"
+})
diff --git a/spec/_files/partial_template.mustache b/test/_files/partial_template.mustache
similarity index 100%
rename from spec/_files/partial_template.mustache
rename to test/_files/partial_template.mustache
diff --git a/spec/_files/partial_template.partial b/test/_files/partial_template.partial
similarity index 100%
rename from spec/_files/partial_template.partial
rename to test/_files/partial_template.partial
diff --git a/spec/_files/partial_template.txt b/test/_files/partial_template.txt
similarity index 100%
rename from spec/_files/partial_template.txt
rename to test/_files/partial_template.txt
diff --git a/spec/_files/partial_view.js b/test/_files/partial_view.js
similarity index 60%
rename from spec/_files/partial_view.js
rename to test/_files/partial_view.js
index 4ea8a12..3ad70d3 100644
--- a/spec/_files/partial_view.js
+++ b/test/_files/partial_view.js
@@ -1,16 +1,14 @@
-var partial_view = {
-  greeting: function() {
+({
+  greeting: function () {
     return "Welcome";
   },
-
-  farewell: function() {
+  farewell: function () {
     return "Fair enough, right?";
   },
-
   name: "Chris",
   value: 10000,
-  taxed_value: function() {
+  taxed_value: function () {
     return this.value - (this.value * 0.4);
   },
   in_ca: true
-};
+})
diff --git a/spec/_files/partial_view.mustache b/test/_files/partial_view.mustache
similarity index 100%
rename from spec/_files/partial_view.mustache
rename to test/_files/partial_view.mustache
diff --git a/spec/_files/partial_view.partial b/test/_files/partial_view.partial
similarity index 89%
rename from spec/_files/partial_view.partial
rename to test/_files/partial_view.partial
index 2fea632..03df206 100644
--- a/spec/_files/partial_view.partial
+++ b/test/_files/partial_view.partial
@@ -2,4 +2,4 @@ Hello {{name}}
 You have just won ${{value}}!
 {{#in_ca}}
 Well, ${{ taxed_value }}, after taxes.
-{{/in_ca}}
+{{/in_ca}}
\ No newline at end of file
diff --git a/spec/_files/partial_view.txt b/test/_files/partial_view.txt
similarity index 100%
rename from spec/_files/partial_view.txt
rename to test/_files/partial_view.txt
diff --git a/spec/_files/partial_whitespace.js b/test/_files/partial_whitespace.js
similarity index 59%
rename from spec/_files/partial_whitespace.js
rename to test/_files/partial_whitespace.js
index f4b1ee5..3ad70d3 100644
--- a/spec/_files/partial_whitespace.js
+++ b/test/_files/partial_whitespace.js
@@ -1,17 +1,14 @@
-var partial_whitespace = {
-  greeting: function() {
+({
+  greeting: function () {
     return "Welcome";
   },
-
-  farewell: function() {
+  farewell: function () {
     return "Fair enough, right?";
   },
-
   name: "Chris",
   value: 10000,
-  taxed_value: function() {
+  taxed_value: function () {
     return this.value - (this.value * 0.4);
   },
   in_ca: true
-};
-
+})
diff --git a/spec/_files/partial_whitespace.mustache b/test/_files/partial_whitespace.mustache
similarity index 100%
rename from spec/_files/partial_whitespace.mustache
rename to test/_files/partial_whitespace.mustache
diff --git a/spec/_files/partial_whitespace.partial b/test/_files/partial_whitespace.partial
similarity index 87%
rename from spec/_files/partial_whitespace.partial
rename to test/_files/partial_whitespace.partial
index 9c46084..30de8f6 100644
--- a/spec/_files/partial_whitespace.partial
+++ b/test/_files/partial_whitespace.partial
@@ -2,4 +2,4 @@ Hello {{ name}}
 You have just won ${{value }}!
 {{# in_ca  }}
 Well, ${{ taxed_value }}, after taxes.
-{{/  in_ca }}
+{{/  in_ca }}
\ No newline at end of file
diff --git a/spec/_files/partial_whitespace.txt b/test/_files/partial_whitespace.txt
similarity index 100%
rename from spec/_files/partial_whitespace.txt
rename to test/_files/partial_whitespace.txt
diff --git a/spec/_files/recursion_with_same_names.js b/test/_files/recursion_with_same_names.js
similarity index 56%
rename from spec/_files/recursion_with_same_names.js
rename to test/_files/recursion_with_same_names.js
index 5cceb08..ce26502 100644
--- a/spec/_files/recursion_with_same_names.js
+++ b/test/_files/recursion_with_same_names.js
@@ -1,8 +1,8 @@
-var recursion_with_same_names = {
+({
   name: 'name',
   description: 'desc',
   terms: [
     {name: 't1', index: 0},
-    {name: 't2', index: 1},
+    {name: 't2', index: 1}
   ]
-};
\ No newline at end of file
+})
diff --git a/spec/_files/recursion_with_same_names.mustache b/test/_files/recursion_with_same_names.mustache
similarity index 100%
rename from spec/_files/recursion_with_same_names.mustache
rename to test/_files/recursion_with_same_names.mustache
diff --git a/spec/_files/recursion_with_same_names.txt b/test/_files/recursion_with_same_names.txt
similarity index 100%
rename from spec/_files/recursion_with_same_names.txt
rename to test/_files/recursion_with_same_names.txt
diff --git a/spec/_files/reuse_of_enumerables.js b/test/_files/reuse_of_enumerables.js
similarity index 69%
rename from spec/_files/reuse_of_enumerables.js
rename to test/_files/reuse_of_enumerables.js
index a3168d3..4368b57 100644
--- a/spec/_files/reuse_of_enumerables.js
+++ b/test/_files/reuse_of_enumerables.js
@@ -1,6 +1,6 @@
-var reuse_of_enumerables = {
+({
   terms: [
     {name: 't1', index: 0},
     {name: 't2', index: 1}
   ]
-};
\ No newline at end of file
+})
diff --git a/spec/_files/reuse_of_enumerables.mustache b/test/_files/reuse_of_enumerables.mustache
similarity index 100%
rename from spec/_files/reuse_of_enumerables.mustache
rename to test/_files/reuse_of_enumerables.mustache
diff --git a/spec/_files/reuse_of_enumerables.txt b/test/_files/reuse_of_enumerables.txt
similarity index 100%
rename from spec/_files/reuse_of_enumerables.txt
rename to test/_files/reuse_of_enumerables.txt
diff --git a/spec/_files/section_as_context.js b/test/_files/section_as_context.js
similarity index 53%
rename from spec/_files/section_as_context.js
rename to test/_files/section_as_context.js
index 81ca1be..425b29c 100644
--- a/spec/_files/section_as_context.js
+++ b/test/_files/section_as_context.js
@@ -1,7 +1,10 @@
-var section_as_context = {
+({
   a_object: {
     title: 'this is an object',
     description: 'one of its attributes is a list',
-    a_list: [{label: 'listitem1'}, {label: 'listitem2'}]
+    a_list: [
+      {label: 'listitem1'},
+      {label: 'listitem2'}
+    ]
   }
-};
+})
diff --git a/spec/_files/section_as_context.mustache b/test/_files/section_as_context.mustache
similarity index 100%
rename from spec/_files/section_as_context.mustache
rename to test/_files/section_as_context.mustache
diff --git a/spec/_files/section_as_context.txt b/test/_files/section_as_context.txt
similarity index 100%
rename from spec/_files/section_as_context.txt
rename to test/_files/section_as_context.txt
diff --git a/spec/_files/simple.js b/test/_files/simple.js
similarity index 67%
rename from spec/_files/simple.js
rename to test/_files/simple.js
index 30f9834..1d8d6f4 100644
--- a/spec/_files/simple.js
+++ b/test/_files/simple.js
@@ -1,8 +1,8 @@
-var simple = {
+({
   name: "Chris",
   value: 10000,
-  taxed_value: function() {
+  taxed_value: function () {
     return this.value - (this.value * 0.4);
   },
   in_ca: true
-};
+})
diff --git a/spec/_files/simple.mustache b/test/_files/simple.mustache
similarity index 100%
rename from spec/_files/simple.mustache
rename to test/_files/simple.mustache
diff --git a/spec/_files/simple.txt b/test/_files/simple.txt
similarity index 100%
rename from spec/_files/simple.txt
rename to test/_files/simple.txt
diff --git a/test/_files/string_as_context.js b/test/_files/string_as_context.js
new file mode 100644
index 0000000..e8bb4da
--- /dev/null
+++ b/test/_files/string_as_context.js
@@ -0,0 +1,4 @@
+({
+  a_string: 'aa',
+  a_list: ['a','b','c']
+})
diff --git a/spec/_files/string_as_context.mustache b/test/_files/string_as_context.mustache
similarity index 100%
rename from spec/_files/string_as_context.mustache
rename to test/_files/string_as_context.mustache
diff --git a/spec/_files/string_as_context.txt b/test/_files/string_as_context.txt
similarity index 100%
rename from spec/_files/string_as_context.txt
rename to test/_files/string_as_context.txt
diff --git a/spec/_files/two_in_a_row.js b/test/_files/two_in_a_row.js
similarity index 60%
rename from spec/_files/two_in_a_row.js
rename to test/_files/two_in_a_row.js
index 09c1809..9c17c11 100644
--- a/spec/_files/two_in_a_row.js
+++ b/test/_files/two_in_a_row.js
@@ -1,4 +1,4 @@
-var two_in_a_row = {
+({
   name: "Joe",
   greeting: "Welcome"
-};
+})
diff --git a/spec/_files/two_in_a_row.mustache b/test/_files/two_in_a_row.mustache
similarity index 100%
rename from spec/_files/two_in_a_row.mustache
rename to test/_files/two_in_a_row.mustache
diff --git a/spec/_files/two_in_a_row.txt b/test/_files/two_in_a_row.txt
similarity index 100%
rename from spec/_files/two_in_a_row.txt
rename to test/_files/two_in_a_row.txt
diff --git a/test/_files/two_sections.js b/test/_files/two_sections.js
new file mode 100644
index 0000000..b4100a5
--- /dev/null
+++ b/test/_files/two_sections.js
@@ -0,0 +1 @@
+({})
diff --git a/spec/_files/two_sections.mustache b/test/_files/two_sections.mustache
similarity index 100%
rename from spec/_files/two_sections.mustache
rename to test/_files/two_sections.mustache
diff --git a/spec/_files/two_sections.txt b/test/_files/two_sections.txt
similarity index 100%
rename from spec/_files/two_sections.txt
rename to test/_files/two_sections.txt
diff --git a/test/_files/unescaped.js b/test/_files/unescaped.js
new file mode 100644
index 0000000..b6d064f
--- /dev/null
+++ b/test/_files/unescaped.js
@@ -0,0 +1,5 @@
+({
+  title: function () {
+    return "Bear > Shark";
+  }
+})
diff --git a/spec/_files/unescaped.mustache b/test/_files/unescaped.mustache
similarity index 100%
rename from spec/_files/unescaped.mustache
rename to test/_files/unescaped.mustache
diff --git a/spec/_files/unescaped.txt b/test/_files/unescaped.txt
similarity index 100%
rename from spec/_files/unescaped.txt
rename to test/_files/unescaped.txt
diff --git a/spec/_files/whitespace.js b/test/_files/whitespace.js
similarity index 60%
rename from spec/_files/whitespace.js
rename to test/_files/whitespace.js
index 97f53c1..f41cb56 100644
--- a/spec/_files/whitespace.js
+++ b/test/_files/whitespace.js
@@ -1,4 +1,4 @@
-var whitespace = {
+({
   tag1: "Hello",
   tag2: "World"
-};
+})
diff --git a/spec/_files/whitespace.mustache b/test/_files/whitespace.mustache
similarity index 100%
rename from spec/_files/whitespace.mustache
rename to test/_files/whitespace.mustache
diff --git a/spec/_files/whitespace.txt b/test/_files/whitespace.txt
similarity index 100%
rename from spec/_files/whitespace.txt
rename to test/_files/whitespace.txt
diff --git a/test/context_test.js b/test/context_test.js
new file mode 100644
index 0000000..eab6729
--- /dev/null
+++ b/test/context_test.js
@@ -0,0 +1,47 @@
+var assert = require("assert");
+var vows = require("vows");
+var Context = require("./../mustache").Context;
+
+vows.describe("Mustache.Context").addBatch({
+  "A Context": {
+    topic: function () {
+      var view = { name: 'parent', message: 'hi', a: { b: 'b' } };
+      var context = new Context(view);
+      return context;
+    },
+    "is able to lookup properties of its own view": function (context) {
+      assert.equal(context.lookup("name"), "parent");
+    },
+    "is able to lookup nested properties of its own view": function (context) {
+      assert.equal(context.lookup("a.b"), "b");
+    },
+    "when pushed": {
+      topic: function (context) {
+        var view = { name: 'child', c: { d: 'd' } };
+        return context.push(view);
+      },
+      "returns the child context": function (context) {
+        assert.equal(context.view.name, "child");
+        assert.equal(context.parent.view.name, "parent");
+      },
+      "is able to lookup properties of its own view": function (context) {
+        assert.equal(context.lookup("name"), "child");
+      },
+      "is able to lookup properties of the parent context's view": function (context) {
+        assert.equal(context.lookup("message"), "hi");
+      },
+      "is able to lookup nested properties of its own view": function (context) {
+        assert.equal(context.lookup("c.d"), "d");
+      },
+      "is able to lookup nested properties of its parent view": function (context) {
+        assert.equal(context.lookup("a.b"), "b");
+      }
+    } // when pushed
+  }, // A Context
+  "make": {
+    "returns the same object when given a Context": function () {
+      var context = new Context;
+      assert.strictEqual(Context.make(context), context);
+    }
+  }
+}).export(module);
diff --git a/test/parse_test.js b/test/parse_test.js
new file mode 100644
index 0000000..6aa0609
--- /dev/null
+++ b/test/parse_test.js
@@ -0,0 +1,69 @@
+var assert = require('assert');
+var vows = require('vows');
+var Mustache = require('./../mustache');
+
+// A map of templates to their expected token output. Tokens are in the format:
+// [type, value, startIndex, endIndex].
+var expectations = {
+  '{{hi}}'                                  : [ [ 'name', 'hi', 0, 6 ] ],
+  '{{hi.world}}'                            : [ [ 'name', 'hi.world', 0, 12 ] ],
+  '{{hi . world}}'                          : [ [ 'name', 'hi . world', 0, 14 ] ],
+  '{{ hi}}'                                 : [ [ 'name', 'hi', 0, 7 ] ],
+  '{{hi }}'                                 : [ [ 'name', 'hi', 0, 7 ] ],
+  '{{ hi }}'                                : [ [ 'name', 'hi', 0, 8 ] ],
+  '{{{hi}}}'                                : [ [ '&', 'hi', 0, 8 ] ],
+  '{{!hi}}'                                 : [ [ '!', 'hi', 0, 7 ] ],
+  '{{! hi}}'                                : [ [ '!', 'hi', 0, 8 ] ],
+  '{{! hi }}'                               : [ [ '!', 'hi', 0, 9 ] ],
+  '{{ !hi}}'                                : [ [ '!', 'hi', 0, 8 ] ],
+  '{{ ! hi}}'                               : [ [ '!', 'hi', 0, 9 ] ],
+  '{{ ! hi }}'                              : [ [ '!', 'hi', 0, 10 ] ],
+  'a\n b'                                   : [ [ 'text', 'a\n b', 0, 4 ] ],
+  'a{{hi}}'                                 : [ [ 'text', 'a', 0, 1 ], [ 'name', 'hi', 1, 7 ] ],
+  'a {{hi}}'                                : [ [ 'text', 'a ', 0, 2 ], [ 'name', 'hi', 2, 8 ] ],
+  ' a{{hi}}'                                : [ [ 'text', ' a', 0, 2 ], [ 'name', 'hi', 2, 8 ] ],
+  ' a {{hi}}'                               : [ [ 'text', ' a ', 0, 3 ], [ 'name', 'hi', 3, 9 ] ],
+  'a{{hi}}b'                                : [ [ 'text', 'a', 0, 1 ], [ 'name', 'hi', 1, 7 ], [ 'text', 'b', 7, 8 ] ],
+  'a{{hi}} b'                               : [ [ 'text', 'a', 0, 1 ], [ 'name', 'hi', 1, 7 ], [ 'text', ' b', 7, 9 ] ],
+  'a{{hi}}b '                               : [ [ 'text', 'a', 0, 1 ], [ 'name', 'hi', 1, 7 ], [ 'text', 'b ', 7, 9 ] ],
+  'a\n{{hi}} b \n'                          : [ [ 'text', 'a\n', 0, 2 ], [ 'name', 'hi', 2, 8 ], [ 'text', ' b \n', 8, 12 ] ],
+  'a\n {{hi}} \nb'                          : [ [ 'text', 'a\n ', 0, 3 ], [ 'name', 'hi', 3, 9 ], [ 'text', ' \nb', 9, 12 ] ],
+  'a\n {{!hi}} \nb'                         : [ [ 'text', 'a\n', 0, 2 ], [ '!', 'hi', 3, 10 ], [ 'text', 'b', 12, 13 ] ],
+  'a\n{{#a}}{{/a}}\nb'                      : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 2, 8, [] ], [ 'text', 'b', 15, 16 ] ],
+  'a\n {{#a}}{{/a}}\nb'                     : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [] ], [ 'text', 'b', 16, 17 ] ],
+  'a\n {{#a}}{{/a}} \nb'                    : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [] ], [ 'text', 'b', 17, 18 ] ],
+  'a\n{{#a}}\n{{/a}}\nb'                    : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 2, 8, [] ], [ 'text', 'b', 16, 17 ] ],
+  'a\n {{#a}}\n{{/a}}\nb'                   : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [] ], [ 'text', 'b', 17, 18 ] ],
+  'a\n {{#a}}\n{{/a}} \nb'                  : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [] ], [ 'text', 'b', 18, 19 ] ],
+  'a\n{{#a}}\n{{/a}}\n{{#b}}\n{{/b}}\nb'    : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 2, 8, [] ], [ '#', 'b', 16, 22, [] ], [ 'text', 'b', 30, 31 ] ],
+  'a\n {{#a}}\n{{/a}}\n{{#b}}\n{{/b}}\nb'   : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [] ], [ '#', 'b', 17, 23, [] ], [ 'text', 'b', 31, 32 ] ],
+  'a\n {{#a}}\n{{/a}}\n{{#b}}\n{{/b}} \nb'  : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [] ], [ '#', 'b', 17, 23, [] ], [ 'text', 'b', 32, 33 ] ],
+  'a\n{{#a}}\n{{#b}}\n{{/b}}\n{{/a}}\nb'    : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 2, 8, [ [ '#', 'b', 9, 15, [] ] ] ], [ 'text', 'b', 30, 31 ] ],
+  'a\n {{#a}}\n{{#b}}\n{{/b}}\n{{/a}}\nb'   : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [ [ '#', 'b', 10, 16, [] ] ] ], [ 'text', 'b', 31, 32 ] ],
+  'a\n {{#a}}\n{{#b}}\n{{/b}}\n{{/a}} \nb'  : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [ [ '#', 'b', 10, 16, [] ] ] ], [ 'text', 'b', 32, 33 ] ],
+  '{{>abc}}'                                : [ [ '>', 'abc', 0, 8 ] ],
+  '{{> abc }}'                              : [ [ '>', 'abc', 0, 10 ] ],
+  '{{ > abc }}'                             : [ [ '>', 'abc', 0, 11 ] ],
+  '{{=<% %>=}}'                             : [ [ '=', '<% %>', 0, 11 ] ],
+  '{{= <% %> =}}'                           : [ [ '=', '<% %>', 0, 13 ] ],
+  '{{=<% %>=}}<%={{ }}=%>'                  : [ [ '=', '<% %>', 0, 11 ], [ '=', '{{ }}', 11, 22 ] ],
+  '{{=<% %>=}}<%hi%>'                       : [ [ '=', '<% %>', 0, 11 ], [ 'name', 'hi', 11, 17 ] ],
+  '{{#a}}{{/a}}hi{{#b}}{{/b}}\n'            : [ [ '#', 'a', 0, 6, [] ], [ 'text', 'hi', 12, 14 ], [ '#', 'b', 14, 20, [] ], [ 'text', '\n', 26, 27 ] ],
+  '{{a}}\n{{b}}\n\n{{#c}}\n{{/c}}\n'        : [ [ 'name', 'a', 0, 5 ], [ 'text', '\n', 5, 6 ], [ 'name', 'b', 6, 11 ], [ 'text', '\n\n', 11, 13 ], [ '#', 'c', 13, 19, [] ] ],
+  '{{#foo}}\n  {{#a}}\n    {{b}}\n  {{/a}}\n{{/foo}}\n'
+                                            : [ [ '#', 'foo', 0, 8, [ [ '#', 'a', 11, 17, [ [ 'text', '    ', 18, 22 ], [ 'name', 'b', 22, 27 ], [ 'text', '\n', 27, 28 ] ] ] ] ] ]
+};
+
+var spec = {};
+
+for (var template in expectations) {
+  (function (template, tokens) {
+    spec['knows how to parse ' + JSON.stringify(template)] = function () {
+      assert.deepEqual(Mustache.parse(template), tokens);
+    };
+  })(template, expectations[template]);
+}
+
+vows.describe('Mustache.parse').addBatch({
+  'parse': spec
+}).export(module);
diff --git a/test/render_test.js b/test/render_test.js
new file mode 100644
index 0000000..57f41a1
--- /dev/null
+++ b/test/render_test.js
@@ -0,0 +1,66 @@
+var fs = require("fs");
+var path = require("path");
+var assert = require("assert");
+var vows = require("vows");
+var Mustache = require("./../mustache");
+
+var _files = path.join(__dirname, "_files");
+
+function getContents(testName, ext) {
+  return fs.readFileSync(path.join(_files, testName + "." + ext), "utf8");
+}
+
+// You can put the name of a specific test to run in the TEST environment
+// variable (e.g. TEST=backslashes vows test/render_test.js)
+var testToRun = process.env["TEST"];
+
+var testNames;
+if (testToRun) {
+  testNames = [testToRun];
+} else {
+  testNames = fs.readdirSync(_files).filter(function (file) {
+    return (/\.js$/).test(file);
+  }).map(function (file) {
+    return path.basename(file).replace(/\.js$/, "");
+  });
+}
+
+var spec = {};
+
+testNames.forEach(function (testName) {
+  var view = getContents(testName, "js");
+
+  if (view) {
+    view = eval(view);
+  } else {
+    console.log("Cannot find view for test: " + testName);
+    process.exit();
+  }
+
+  var template = getContents(testName, "mustache");
+  var expect = getContents(testName, "txt");
+
+  var partial;
+  try {
+    partial = getContents(testName, "partial");
+  } catch (e) {
+    // No big deal.
+  }
+
+  spec["knows how to render " + testName] = function () {
+    Mustache.clearCache();
+
+    var output;
+    if (partial) {
+      output = Mustache.render(template, view, {partial: partial});
+    } else {
+      output = Mustache.render(template, view);
+    }
+
+    assert.equal(output, expect);
+  };
+});
+
+vows.describe("Mustache.render").addBatch({
+  "render": spec
+}).export(module);
diff --git a/test/scanner_test.js b/test/scanner_test.js
new file mode 100644
index 0000000..5850fe2
--- /dev/null
+++ b/test/scanner_test.js
@@ -0,0 +1,117 @@
+var assert = require("assert");
+var vows = require("vows");
+var Scanner = require("./../mustache").Scanner;
+
+vows.describe("Mustache.Scanner").addBatch({
+  "A Scanner": {
+    "for an empty string": {
+      topic: new Scanner(""),
+      "is at the end of the string": function () {
+        var scanner = new Scanner("");
+        assert(scanner.eos());
+      }
+    },
+    "for a non-empty string": {
+      topic: "a b c",
+      "when calling scan": {
+        "when the regexp matches the entire string": {
+          topic: function (string) {
+            var scanner = new Scanner(string);
+            var match = scanner.scan(/a b c/);
+            this.callback(scanner, match);
+          },
+          "returns the entire string": function (scanner, match) {
+            assert.equal(match, scanner.string);
+          },
+          "is at the end of the string": function (scanner, match) {
+            assert(scanner.eos());
+          }
+        }, // when the regexp matches the entire string
+        "when the regexp matches": {
+          "at the 0th index": {
+            topic: function (string) {
+              var scanner = new Scanner(string);
+              var match = scanner.scan(/a/);
+              this.callback(scanner, match);
+            },
+            "returns the portion of the string that was matched": function (scanner, match) {
+              assert.equal(match, "a");
+            },
+            "advances the internal pointer the length of the match": function (scanner, match) {
+              assert.equal(scanner.pos, 1);
+            }
+          }, // at the 0th index
+          "at some index other than 0": {
+            topic: function (string) {
+              var scanner = new Scanner(string);
+              var match = scanner.scan(/b/);
+              this.callback(scanner, match);
+            },
+            "returns the empty string": function (scanner, match) {
+              assert.equal(match, "");
+            },
+            "does not advance the internal pointer": function (scanner, match) {
+              assert.equal(scanner.pos, 0);
+            }
+          } // at some index other than 0
+        }, // when the regexp matches
+        "when the regexp doesn't match": {
+          topic: function (string) {
+            var scanner = new Scanner(string);
+            var match = scanner.scan(/z/);
+            this.callback(scanner, match);
+          },
+          "returns the empty string": function (scanner, match) {
+            assert.equal(match, "");
+          },
+          "does not advance the internal pointer": function (scanner, match) {
+            assert.equal(scanner.pos, 0);
+          }
+        }
+      }, // when calling scan
+      "when calling scanUntil": {
+        "when the regexp matches": {
+          "at the 0th index": {
+            topic: function (string) {
+              var scanner = new Scanner(string);
+              var match = scanner.scanUntil(/a/);
+              this.callback(scanner, match);
+            },
+            "returns the empty string": function (scanner, match) {
+              assert.equal(match, "")
+            },
+            "does not advance the internal pointer": function (scanner, match) {
+              assert.equal(scanner.pos, 0);
+            }
+          },
+          "at index 2": {
+            topic: function (string) {
+              var scanner = new Scanner(string);
+              var match = scanner.scanUntil(/b/);
+              this.callback(scanner, match);
+            },
+            "returns the portion of the string it scanned": function (scanner, match) {
+              assert.equal(match, "a ");
+            },
+            "advances the internal pointer the length of the match": function (scanner, match) {
+              assert.equal(scanner.pos, 2);
+            }
+          }
+        }, // when the regexp matches
+        "when the regexp doesn't match": {
+          topic: function (string) {
+            var scanner = new Scanner(string);
+            var match = scanner.scanUntil(/z/);
+            this.callback(scanner, match);
+          },
+          "returns the entire string": function (scanner, match) {
+            assert.equal(match, scanner.string);
+          },
+          "is at the end of the string": function (scanner, match) {
+            assert(scanner.eos());
+          }
+        } // when the regexp doesn't match
+      } // when calling scanUntil
+    } // for a non-empty string
+  }
+}).export(module);
diff --git a/test/writer_test.js b/test/writer_test.js
new file mode 100644
index 0000000..10a4587
--- /dev/null
+++ b/test/writer_test.js
@@ -0,0 +1,44 @@
+var assert = require("assert");
+var vows = require("vows");
+var Mustache = require("./../mustache");
+var Writer = Mustache.Writer;
+
+vows.describe("Mustache.Writer").addBatch({
+  "A Writer": {
+    topic: function () {
+      var writer = new Writer();
+      return writer;
+    },
+    "loads partials correctly": function (writer) {
+      var partial = "The content of the partial.";
+      var result = writer.render("{{>partial}}", {}, function (name) {
+        assert.equal(name, "partial");
+        return partial;
+      });
+
+      assert.equal(result, partial);
+    },
+    "caches partials by content, not by name": function (writer) {
+      var result = writer.render("{{>partial}}", {}, {
+        partial: "partial one"
+      });
+
+      assert.equal(result, "partial one");
+
+      result = writer.render("{{>partial}}", {}, {
+        partial: "partial two"
+      });
+
+      assert.equal(result, "partial two");
+    },
+    "can compile an array of tokens": function (writer) {
+      var template = "Hello {{name}}!";
+      var tokens = Mustache.parse(template);
+      var render = writer.compileTokens(tokens, template);
+
+      var result = render({ name: 'Michael' });
+
+      assert.equal(result, 'Hello Michael!');
+    }
+  }
+}).export(module);
diff --git a/wrappers/qooxdoo/mustache.js.pre b/wrappers/qooxdoo/mustache.js.pre
index faf41b2..7c7055d 100644
--- a/wrappers/qooxdoo/mustache.js.pre
+++ b/wrappers/qooxdoo/mustache.js.pre
@@ -19,7 +19,7 @@
 
    This class contains code based on the following work:
 
-   * Mustache.js version 0.5.0-dev
+   * Mustache.js version 0.5.1-dev
 
      Code:
        https://github.com/janl/mustache.js
diff --git a/wrappers/requirejs/mustache.js.post b/wrappers/requirejs/mustache.js.post
deleted file mode 100644
index 632fd2a..0000000
--- a/wrappers/requirejs/mustache.js.post
+++ /dev/null
@@ -1,3 +0,0 @@
-
-return Mustache;
-});
\ No newline at end of file
diff --git a/wrappers/requirejs/mustache.js.pre b/wrappers/requirejs/mustache.js.pre
deleted file mode 100644
index 160286d..0000000
--- a/wrappers/requirejs/mustache.js.pre
+++ /dev/null
@@ -1,6 +0,0 @@
-/*
-Shameless port of a shameless port ^ 2
-@defunkt => @janl => @aq => @voodootikigod => @timruffles
- 
-*/
-define(function(){