CoffeeScript 0.6.0 is on the books.

This reverts commit 7ee10e06be.

Cakefile

@@ -1,5 +1,6 @@
 fs: require 'fs'
-CoffeeScript: require 'coffee-script'
+helpers: require('./lib/helpers').helpers
+CoffeeScript: require './lib/coffee-script'
 
 # Run a CoffeeScript through our node/coffee interpreter.
 run: (args) ->
@@ -11,12 +12,13 @@ option '-p', '--prefix [DIR]', 'set the installation prefix for `cake install`'
 
 task 'install', 'install CoffeeScript into /usr/local (or --prefix)', (options) ->
   base: options.prefix or '/usr/local'
-  lib:  base + '/lib/coffee-script'
+  lib:  "$base/lib/coffee-script"
+  bin:  "$base/bin"
   exec([
-    'mkdir -p ' + lib
-    'cp -rf bin lib LICENSE README package.json src vendor ' + lib
-    'ln -sf ' + lib + '/bin/coffee ' + base + '/bin/coffee'
-    'ln -sf ' + lib + '/bin/cake ' + base + '/bin/cake'
+    "mkdir -p $lib $bin"
+    "cp -rf bin lib LICENSE README package.json src vendor $lib"
+    "ln -sf $lib/bin/coffee $base/bin/coffee"
+    "ln -sf $lib/bin/cake $base/bin/cake"
   ].join(' && '), (err, stdout, stderr) ->
    if err then print stderr
   )
@@ -28,8 +30,8 @@ task 'build', 'build the CoffeeScript language from source', ->
   run ['-c', '-o', 'lib'].concat(files)
 
 
-task 'build:full', 'checkout /lib, rebuild the source twice, and run the tests', ->
-  exec 'git co lib && bin/cake build && bin/cake build && bin/cake test', (err, stdout, stderr) ->
+task 'build:full', 'rebuild the source twice, and run the tests', ->
+  exec 'bin/cake build && bin/cake build && bin/cake test', (err, stdout, stderr) ->
     print stdout if stdout
     print stderr if stderr
     throw err    if err
@@ -37,14 +39,15 @@ task 'build:full', 'checkout /lib, rebuild the source twice, and run the tests',
 
 task 'build:parser', 'rebuild the Jison parser (run build first)', ->
   require.paths.unshift 'vendor/jison/lib'
-  parser: require('grammar').parser
+  parser: require('./lib/grammar').parser
   js: parser.generate()
   parser_path: 'lib/parser.js'
   fs.writeFile parser_path, js
 
 
 task 'build:ultraviolet', 'build and install the Ultraviolet syntax highlighter', ->
-  exec 'plist2syntax extras/CoffeeScript.tmbundle/Syntaxes/CoffeeScript.tmLanguage', (err) ->
+  exec 'plist2syntax ../coffee-script-tmbundle/Syntaxes/CoffeeScript.tmLanguage', (err) ->
+    throw err if err
     exec 'sudo mv coffeescript.yaml /usr/local/lib/ruby/gems/1.8/gems/ultraviolet-0.10.2/syntax/coffeescript.syntax'
 
 
@@ -63,22 +66,35 @@ task 'doc:source', 'rebuild the internal documentation', ->
 
 
 task 'doc:underscore', 'rebuild the Underscore.coffee documentation page', ->
-  exec 'uv -s coffeescript -t idle -h examples/underscore.coffee > documentation/underscore.html'
+  exec 'docco examples/underscore.coffee && cp -rf docs documentation && rm -r docs', (err) ->
+    throw err if err
 
 
 task 'test', 'run the CoffeeScript language test suite', ->
-  process.mixin require 'assert'
-  test_count: 0
+  helpers.extend global, require 'assert'
+  passed_tests: failed_tests: 0
   start_time: new Date()
-  [original_ok, original_throws]: [ok, throws]
-  process.mixin {
-    ok:     (args...) -> test_count += 1; original_ok(args...)
-    throws: (args...) -> test_count += 1; original_throws(args...)
+  original_ok: ok
+  helpers.extend global, {
+    ok: (args...) -> passed_tests += 1; original_ok(args...)
+    CoffeeScript: CoffeeScript
   }
-  process.addListener 'exit', ->
+  red: '\033[0;31m'
+  green: '\033[0;32m'
+  reset: '\033[0m'
+  on_exit:  ->
     time: ((new Date() - start_time) / 1000).toFixed(2)
-    puts '\033[0;32mpassed ' + test_count + ' tests in ' + time + ' seconds\033[0m'
+    message: "passed $passed_tests tests in $time seconds$reset"
+    puts(if failed_tests then "${red}failed $failed_tests and $message" else "$green$message")
+  process.addListener 'exit', on_exit
   fs.readdir 'test', (err, files) ->
-    for file in files
-      fs.readFile 'test/' + file, (err, code) ->
-        CoffeeScript.run code, {source: file}
+    files.forEach (file) ->
+      return unless file.match(/\.coffee$/i)
+      source: path.join 'test', file
+      fs.readFile source, (err, code) ->
+        try
+          CoffeeScript.run code, {source: source}
+        catch err
+          failed_tests += 1
+          puts "${red}failed:${reset} $source"
+          puts err.stack

README

@@ -39,4 +39,22 @@
 
   The source repository:
   git://github.com/jashkenas/coffee-script.git
-
+  
+  
+  Contributors:
+  
+  Stan Angeloff (StanAngeloff)
+  Jeremy Ashkenas (jashkenas)
+  Zach Carter (zaach)
+  Tim Cuthbertson (gfxmonk)
+  Mathieu D'Amours (matehat)
+  Chris Hoffman (cehoffman)
+  Jason Huggins (hugs)
+  Tim Jones (Tesco)
+  Matt Lyon (mattly)
+  Jeff Olson (olsonjeffery)
+  Samuel Reis (grgh)
+  Tom Robinson (tlrobinson)
+  Tim Smart (Tim-Smart)
+  Dr. Nic Williams (drnic)
+  

Rakefile

@@ -23,7 +23,7 @@ end
 
 desc "Build the single concatenated and minified script for the browser"
 task :browser do
-  sources = %w(rewriter.js lexer.js parser.js scope.js nodes.js coffee-script.js)
+  sources = %w(helpers.js rewriter.js lexer.js parser.js scope.js nodes.js coffee-script.js)
   code    = sources.map {|s| File.read('lib/' + s) }.join('')
   code    = YUI::JavaScriptCompressor.new.compress(code)
   File.open('extras/coffee-script.js', 'w+') {|f| f.write(code) }

bin/cake

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
 
-process.mixin(require('sys'));
 var path = require('path');
 var fs = require('fs');
 var lib = path.join(path.dirname(fs.realpathSync(__filename)), '../lib');
 
-require.paths.unshift(lib);
-require('cake').run();
+require(lib + '/helpers').helpers.extend(global, require('sys'));
+require(lib + '/cake').run();

bin/coffee

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
 
-process.mixin(require('sys'));
 var path = require('path');
 var fs = require('fs');
 var lib = path.join(path.dirname(fs.realpathSync(__filename)), '../lib');
 
-require.paths.unshift(lib);
-require('command').run();
+require(lib + '/helpers').helpers.extend(global, require('sys'));
+require(lib + '/command').run();

documentation/coffee/arguments.coffee

@@ -1,4 +0,0 @@
-backwards: ->
-  alert arguments.reverse()
-
-backwards "stairway", "to", "heaven"

documentation/coffee/binding.coffee

@@ -0,0 +1,5 @@
+url: "documentation/coffee/binding.coffee"
+
+get_source: jQuery.get <- jQuery, url
+
+get_source (response) -> alert response

documentation/coffee/cake_tasks.coffee

@@ -1,5 +1,3 @@
-process.mixin require 'assert'
-
 task 'test', 'run each of the unit tests', ->
   for test in test_files
     fs.readFile test, (err, code) -> eval coffee.compile code

documentation/coffee/conditionals.coffee

@@ -6,4 +6,4 @@ if happy and knows_it
 
 date: if friday then sue else jill
 
-expensive ||= do_the_math()
+expensive: or do_the_math()

documentation/coffee/interpolation_expression.coffee

@@ -1,4 +1,6 @@
 sentence: "${ 22 / 7 } is a decent approximation of π"
 
+sep:   "[.\\/\\- ]"
+dates: /\d+$sep\d+$sep\d+/g
 
 

documentation/coffee/patterns_and_splats.coffee

@@ -0,0 +1,7 @@
+tag: "<impossible>"
+
+[open, contents..., close]: tag.split("")
+
+
+
+

documentation/css/docs.css

@@ -105,6 +105,7 @@ div.code {
   position: fixed;
   z-index: 100;
   height: 50px;
+  min-width: 490px;
   left: 40px; right: 40px; top: 25px;
   background: #ddd;
   padding-left: 235px;

documentation/docs/cake.html

@@ -1,4 +1,4 @@
-<!DOCTYPE html>  <html> <head>   <title>cake.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               cake.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p><code>cake</code> is a simplified version of <a href="http://www.gnu.org/software/make/">Make</a>
+<!DOCTYPE html>  <html> <head>   <title>cake.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="helpers.html">                 helpers.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               cake.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p><code>cake</code> is a simplified version of <a href="http://www.gnu.org/software/make/">Make</a>
 (<a href="http://rake.rubyforge.org/">Rake</a>, <a href="http://github.com/280north/jake">Jake</a>)
 for CoffeeScript. You define tasks with names and descriptions in a Cakefile,
 and can call them from the command line, or invoke them from other tasks.</p>
@@ -6,11 +6,12 @@ and can call them from the command line, or invoke them from other tasks.</p>
 <p>Running <code>cake</code> with no arguments will print out a list of all the tasks in the
 current directory's Cakefile.</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-2">#</a>               </div>               <p>External dependencies.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">fs: </span>          <span class="nx">require</span> <span class="s1">&#39;fs&#39;</span>
 <span class="nv">path: </span>        <span class="nx">require</span> <span class="s1">&#39;path&#39;</span>
-<span class="nv">optparse: </span>    <span class="nx">require</span> <span class="s1">&#39;optparse&#39;</span>
-<span class="nv">CoffeeScript: </span><span class="nx">require</span> <span class="s1">&#39;coffee-script&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>Keep track of the list of defined tasks, the accepted options, and so on.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">tasks: </span><span class="p">{}</span>
+<span class="nv">helpers: </span>     <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./helpers&#39;</span><span class="p">).</span><span class="nx">helpers</span>
+<span class="nv">optparse: </span>    <span class="nx">require</span> <span class="s1">&#39;./optparse&#39;</span>
+<span class="nv">CoffeeScript: </span><span class="nx">require</span> <span class="s1">&#39;./coffee-script&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>Keep track of the list of defined tasks, the accepted options, and so on.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">tasks: </span><span class="p">{}</span>
 <span class="nv">options: </span><span class="p">{}</span>
 <span class="nv">switches: </span><span class="p">[]</span>
-<span class="nv">oparse: </span><span class="kc">null</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <p>Mixin the top-level Cake functions for Cakefiles to use directly.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nx">process</span><span class="p">.</span><span class="nx">mixin</span> <span class="p">{</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-5">#</a>               </div>               <p>Define a Cake task with a short name, a sentence description,
+<span class="nv">oparse: </span><span class="kc">null</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <p>Mixin the top-level Cake functions for Cakefiles to use directly.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nx">helpers</span><span class="p">.</span><span class="nx">extend</span> <span class="nx">global</span><span class="p">,</span> <span class="p">{</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-5">#</a>               </div>               <p>Define a Cake task with a short name, a sentence description,
 and the function to run as the action itself.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">task: </span><span class="p">(</span><span class="nx">name</span><span class="p">,</span> <span class="nx">description</span><span class="p">,</span> <span class="nx">action</span><span class="p">)</span> <span class="o">-&gt;</span>
     <span class="nx">tasks</span><span class="p">[</span><span class="nx">name</span><span class="p">]</span><span class="o">:</span> <span class="p">{</span><span class="nv">name: </span><span class="nx">name</span><span class="p">,</span> <span class="nv">description: </span><span class="nx">description</span><span class="p">,</span> <span class="nv">action: </span><span class="nx">action</span><span class="p">}</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-6">#</a>               </div>               <p>Define an option that the Cakefile accepts. The parsed options hash,
 containing all of the command-line options passed, will be made available

documentation/docs/coffee-script.html

@@ -1,46 +1,56 @@
-<!DOCTYPE html>  <html> <head>   <title>coffee-script.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               coffee-script.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>CoffeeScript can be used both on the server, as a command-line compiler based
+<!DOCTYPE html>  <html> <head>   <title>coffee-script.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="helpers.html">                 helpers.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               coffee-script.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>CoffeeScript can be used both on the server, as a command-line compiler based
 on Node.js/V8, or to run CoffeeScripts directly in the browser. This module
 contains the main entry functions for tokenzing, parsing, and compiling source
 CoffeeScript into JavaScript.</p>
 
 <p>If included on a webpage, it will automatically sniff out, compile, and
 execute all scripts present in <code>text/coffeescript</code> tags.</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-2">#</a>               </div>               <p>Set up dependencies correctly for both the server and the browser.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">if</span> <span class="nx">process</span><span class="o">?</span>
-  <span class="nx">process</span><span class="p">.</span><span class="nx">mixin</span> <span class="nx">require</span> <span class="s1">&#39;nodes&#39;</span>
   <span class="nv">path: </span>        <span class="nx">require</span> <span class="s1">&#39;path&#39;</span>
-  <span class="nv">lexer: </span>  <span class="k">new</span> <span class="p">(</span><span class="nx">require</span><span class="p">(</span><span class="s1">&#39;lexer&#39;</span><span class="p">).</span><span class="nx">Lexer</span><span class="p">)()</span>
-  <span class="nv">parser: </span>      <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;parser&#39;</span><span class="p">).</span><span class="nx">parser</span>
+  <span class="nv">Lexer: </span>       <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./lexer&#39;</span><span class="p">).</span><span class="nx">Lexer</span>
+  <span class="nv">parser: </span>      <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./parser&#39;</span><span class="p">).</span><span class="nx">parser</span>
+  <span class="nv">helpers: </span>     <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./helpers&#39;</span><span class="p">).</span><span class="nx">helpers</span>
+  <span class="nx">helpers</span><span class="p">.</span><span class="nx">extend</span> <span class="nx">global</span><span class="p">,</span> <span class="nx">require</span> <span class="s1">&#39;./nodes&#39;</span>
+  <span class="k">if</span> <span class="nx">require</span><span class="p">.</span><span class="nx">registerExtension</span>
+    <span class="nx">require</span><span class="p">.</span><span class="nx">registerExtension</span> <span class="s1">&#39;.coffee&#39;</span><span class="p">,</span> <span class="p">(</span><span class="nx">content</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">compile</span> <span class="nx">content</span>
 <span class="k">else</span>
-  <span class="nv">lexer: </span><span class="k">new</span> <span class="nx">Lexer</span><span class="p">()</span>
-  <span class="nv">parser: </span><span class="nx">exports</span><span class="p">.</span><span class="nx">parser</span>
-  <span class="k">this</span><span class="p">.</span><span class="nv">exports: </span><span class="k">this</span><span class="p">.</span><span class="nv">CoffeeScript: </span><span class="p">{}</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>The current CoffeeScript version number.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.VERSION: </span><span class="s1">&#39;0.5.5&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <p>Compile a string of CoffeeScript code to JavaScript, using the Coffee/Jison
-compiler.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.compile: </span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="k">this</span><span class="p">.</span><span class="nv">exports: </span><span class="k">this</span><span class="p">.</span><span class="nv">CoffeeScript: </span><span class="p">{}</span>
+  <span class="nv">Lexer: </span>       <span class="k">this</span><span class="p">.</span><span class="nx">Lexer</span>
+  <span class="nv">parser: </span>      <span class="k">this</span><span class="p">.</span><span class="nx">parser</span>
+  <span class="nv">helpers: </span>     <span class="k">this</span><span class="p">.</span><span class="nx">helpers</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>The current CoffeeScript version number.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.VERSION: </span><span class="s1">&#39;0.6.0&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <p>Instantiate a Lexer for our use here.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">lexer: </span><span class="k">new</span> <span class="nx">Lexer</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-5">#</a>               </div>               <p>Compile a string of CoffeeScript code to JavaScript, using the Coffee/Jison
+compiler.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.compile: compile: </span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nv">options: </span><span class="o">or</span> <span class="p">{}</span>
   <span class="k">try</span>
     <span class="p">(</span><span class="nx">parser</span><span class="p">.</span><span class="nx">parse</span> <span class="nx">lexer</span><span class="p">.</span><span class="nx">tokenize</span> <span class="nx">code</span><span class="p">).</span><span class="nx">compile</span> <span class="nx">options</span>
   <span class="k">catch</span> <span class="nx">err</span>
     <span class="nv">err.message: </span><span class="s2">&quot;In ${options.source}, ${err.message}&quot;</span> <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">source</span>
-    <span class="k">throw</span> <span class="nx">err</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-5">#</a>               </div>               <p>Tokenize a string of CoffeeScript code, and return the array of tokens.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.tokens: </span><span class="p">(</span><span class="nx">code</span><span class="p">)</span> <span class="o">-&gt;</span>
-  <span class="nx">lexer</span><span class="p">.</span><span class="nx">tokenize</span> <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-6">#</a>               </div>               <p>Tokenize and parse a string of CoffeeScript code, and return the AST. You can
+    <span class="k">throw</span> <span class="nx">err</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-6">#</a>               </div>               <p>Tokenize a string of CoffeeScript code, and return the array of tokens.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.tokens: </span><span class="p">(</span><span class="nx">code</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">lexer</span><span class="p">.</span><span class="nx">tokenize</span> <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-7">#</a>               </div>               <p>Tokenize and parse a string of CoffeeScript code, and return the AST. You can
 then compile it by calling <code>.compile()</code> on the root, or traverse it by using
 <code>.traverse()</code> with a callback.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.nodes: </span><span class="p">(</span><span class="nx">code</span><span class="p">)</span> <span class="o">-&gt;</span>
-  <span class="nx">parser</span><span class="p">.</span><span class="nx">parse</span> <span class="nx">lexer</span><span class="p">.</span><span class="nx">tokenize</span> <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-7">#</a>               </div>               <p>Compile and execute a string of CoffeeScript (on the server), correctly
-setting <code>__filename</code>, <code>__dirname</code>, and relative <code>require()</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.run: </span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">parser</span><span class="p">.</span><span class="nx">parse</span> <span class="nx">lexer</span><span class="p">.</span><span class="nx">tokenize</span> <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-8">#</a>               </div>               <p>Compile and execute a string of CoffeeScript (on the server), correctly
+setting <code>__filename</code>, <code>__dirname</code>, and relative <code>require()</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.run: </span><span class="p">((</span><span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span>
   <span class="nv">module.filename: __filename: </span><span class="nx">options</span><span class="p">.</span><span class="nx">source</span>
-  <span class="nv">__dirname: </span><span class="nx">path</span><span class="p">.</span><span class="nx">dirname</span> <span class="nx">__filename</span>
-  <span class="nb">eval</span> <span class="nx">exports</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">options</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-8">#</a>               </div>               <p>The real Lexer produces a generic stream of tokens. This object provides a
+  <span class="nv">__dirname: </span><span class="nx">path</span><span class="p">.</span><span class="nx">dirname</span><span class="p">(</span><span class="nx">__filename</span><span class="p">)</span>
+  <span class="nb">eval</span> <span class="nx">exports</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">options</span>
+<span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-9">#</a>               </div>               <p>Extend CoffeeScript with a custom language extension. It should hook in to
+the <strong>Lexer</strong> (as a peer of any of the lexer's tokenizing methods), and
+push a token on to the stack that contains a <strong>Node</strong> as the value (as a
+peer of the nodes in <a href="nodes.html">nodes.coffee</a>).</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.extend: </span><span class="p">(</span><span class="nx">func</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">Lexer</span><span class="p">.</span><span class="nx">extensions</span><span class="p">.</span><span class="nx">push</span> <span class="nx">func</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-10">#</a>               </div>               <p>The real Lexer produces a generic stream of tokens. This object provides a
 thin wrapper around it, compatible with the Jison API. We can then pass it
 directly as a "Jison lexer".</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">parser.lexer: </span><span class="p">{</span>
   <span class="nv">lex: </span><span class="o">-&gt;</span>
-    <span class="nv">token: </span><span class="err">@</span><span class="nx">tokens</span><span class="p">[</span><span class="err">@</span><span class="nx">pos</span><span class="p">]</span> <span class="o">or</span> <span class="p">[</span><span class="s2">&quot;&quot;</span><span class="p">]</span>
-    <span class="err">@</span><span class="nx">pos</span> <span class="o">+=</span> <span class="mi">1</span>
+    <span class="nv">token: </span><span class="nx">@tokens</span><span class="p">[</span><span class="nx">@pos</span><span class="p">]</span> <span class="o">or</span> <span class="p">[</span><span class="s2">&quot;&quot;</span><span class="p">]</span>
+    <span class="vi">@pos: </span><span class="o">+</span> <span class="mi">1</span>
     <span class="k">this</span><span class="p">.</span><span class="nv">yylineno: </span><span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
     <span class="k">this</span><span class="p">.</span><span class="nv">yytext: </span>  <span class="nx">token</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
     <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
   <span class="nv">setInput: </span><span class="p">(</span><span class="nx">tokens</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nv">tokens: </span><span class="nx">tokens</span>
-    <span class="err">@</span><span class="nv">pos: </span><span class="mi">0</span>
+    <span class="vi">@tokens: </span><span class="nx">tokens</span>
+    <span class="vi">@pos: </span><span class="mi">0</span>
   <span class="nv">upcomingInput: </span><span class="o">-&gt;</span> <span class="s2">&quot;&quot;</span>
-  <span class="nv">showPosition: </span><span class="o">-&gt;</span> <span class="err">@</span><span class="nx">pos</span>
-<span class="p">}</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-9">#</a>               </div>               <p>Activate CoffeeScript in the browser by having it compile and evaluate
+  <span class="nv">showPosition: </span><span class="o">-&gt;</span> <span class="nx">@pos</span>
+<span class="p">}</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-11">#</a>               </div>               <p>Activate CoffeeScript in the browser by having it compile and evaluate
 all script tags with a content-type of <code>text/coffeescript</code>. This happens
 on page load. Unfortunately, the text contents of remote scripts cannot be
 accessed from the browser, so only inline script tags will work.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">if</span> <span class="nb">document</span><span class="o">?</span> <span class="o">and</span> <span class="nb">document</span><span class="p">.</span><span class="nx">getElementsByTagName</span>

documentation/docs/command.html

@@ -1,11 +1,11 @@
-<!DOCTYPE html>  <html> <head>   <title>command.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               command.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>The <code>coffee</code> utility. Handles command-line compilation of CoffeeScript
+<!DOCTYPE html>  <html> <head>   <title>command.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="helpers.html">                 helpers.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               command.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>The <code>coffee</code> utility. Handles command-line compilation of CoffeeScript
 into various forms: saved into <code>.js</code> files or printed to stdout, piped to
 <a href="http://javascriptlint.com/">JSLint</a> or recompiled every time the source is
 saved, printed as a token stream or as the syntax tree, or launch an
 interactive REPL.</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-2">#</a>               </div>               <p>External dependencies.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">fs: </span>          <span class="nx">require</span> <span class="s1">&#39;fs&#39;</span>
 <span class="nv">path: </span>        <span class="nx">require</span> <span class="s1">&#39;path&#39;</span>
-<span class="nv">optparse: </span>    <span class="nx">require</span> <span class="s1">&#39;optparse&#39;</span>
-<span class="nv">CoffeeScript: </span><span class="nx">require</span> <span class="s1">&#39;coffee-script&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>The help banner that is printed when <code>coffee</code> is called without arguments.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">BANNER: </span><span class="s1">&#39;&#39;&#39;</span>
+<span class="nv">optparse: </span>    <span class="nx">require</span> <span class="s1">&#39;./optparse&#39;</span>
+<span class="nv">CoffeeScript: </span><span class="nx">require</span> <span class="s1">&#39;./coffee-script&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>The help banner that is printed when <code>coffee</code> is called without arguments.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">BANNER: </span><span class="s1">&#39;&#39;&#39;</span>
 <span class="s1">  coffee compiles CoffeeScript source files into JavaScript.</span>
 
 <span class="s1">  Usage:</span>
@@ -32,7 +32,7 @@ Many flags cause us to divert before compiling anything. Flags passed after
   <span class="nx">parse_options</span><span class="p">()</span>
   <span class="k">return</span> <span class="nx">usage</span><span class="p">()</span>                              <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">help</span>
   <span class="k">return</span> <span class="nx">version</span><span class="p">()</span>                            <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">version</span>
-  <span class="k">return</span> <span class="nx">require</span> <span class="s1">&#39;repl&#39;</span>                       <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">interactive</span>
+  <span class="k">return</span> <span class="nx">require</span> <span class="s1">&#39;./repl&#39;</span>                     <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">interactive</span>
   <span class="k">return</span> <span class="nx">compile_stdio</span><span class="p">()</span>                      <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">stdio</span>
   <span class="k">return</span> <span class="nx">compile_script</span> <span class="s1">&#39;console&#39;</span><span class="p">,</span> <span class="nx">sources</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nb">eval</span>
   <span class="k">return</span> <span class="nx">usage</span><span class="p">()</span>                              <span class="nx">unless</span> <span class="nx">sources</span><span class="p">.</span><span class="nx">length</span>
@@ -70,7 +70,7 @@ and write them back to <strong>stdout</strong>.</p>             </td>
   <span class="nv">code: </span><span class="s1">&#39;&#39;</span>
   <span class="nx">process</span><span class="p">.</span><span class="nx">stdio</span><span class="p">.</span><span class="nx">open</span><span class="p">()</span>
   <span class="nx">process</span><span class="p">.</span><span class="nx">stdio</span><span class="p">.</span><span class="nx">addListener</span> <span class="s1">&#39;data&#39;</span><span class="p">,</span> <span class="p">(</span><span class="nx">string</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="nx">code</span> <span class="o">+=</span> <span class="nx">string</span> <span class="k">if</span> <span class="nx">string</span>
+    <span class="nv">code: </span><span class="o">+</span> <span class="nx">string</span> <span class="k">if</span> <span class="nx">string</span>
   <span class="nx">process</span><span class="p">.</span><span class="nx">stdio</span><span class="p">.</span><span class="nx">addListener</span> <span class="s1">&#39;close&#39;</span><span class="p">,</span> <span class="o">-&gt;</span>
     <span class="nx">compile_script</span> <span class="s1">&#39;stdio&#39;</span><span class="p">,</span> <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-10">#</a>               </div>               <p>Watch a list of source CoffeeScript files using <code>fs.watchFile</code>, recompiling
 them every time the files are updated. May be used in combination with other

documentation/docs/docco.css

@@ -124,7 +124,7 @@ td.linenos { background-color: #f0f0f0; padding-right: 10px; }
 span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }
 body .hll { background-color: #ffffcc }
 body .c { color: #408080; font-style: italic }  /* Comment */
-/*body .err { border: 1px solid #FF0000 }         /* Error */
+body .err { border: 1px solid #FF0000 }         /* Error */
 body .k { color: #954121 }                      /* Keyword */
 body .o { color: #666666 }                      /* Operator */
 body .cm { color: #408080; font-style: italic } /* Comment.Multiline */

documentation/docs/grammar.html

@@ -1,4 +1,4 @@
-<!DOCTYPE html>  <html> <head>   <title>grammar.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               grammar.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>The CoffeeScript parser is generated by <a href="http://github.com/zaach/jison">Jison</a>
+<!DOCTYPE html>  <html> <head>   <title>grammar.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="helpers.html">                 helpers.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               grammar.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>The CoffeeScript parser is generated by <a href="http://github.com/zaach/jison">Jison</a>
 from this grammar file. Jison is a bottom-up parser generator, similar in
 style to <a href="http://www.gnu.org/software/bison">Bison</a>, implemented in JavaScript.
 It can recognize <a href="http://en.wikipedia.org/wiki/LR_grammar">LALR(1), LR(0), SLR(1), and LR(1)</a>
@@ -33,14 +33,14 @@ their numeric position, so in this rule:</p>
 for the <code>UNLESS</code> terminal, and <code>$3</code> would be the value of the second
 <code>Expression</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">grammar: </span><span class="p">{</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-8">#</a>               </div>               <p>The <strong>Root</strong> is the top-level node in the syntax tree. Since we parse bottom-up,
 all parsing must end here.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Root: </span><span class="p">[</span>
-    <span class="nx">o</span> <span class="s2">&quot;&quot;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Expressions</span><span class="p">()</span>
-    <span class="nx">o</span> <span class="s2">&quot;TERMINATOR&quot;</span><span class="p">,</span>                        <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Expressions</span><span class="p">()</span>
+    <span class="nx">o</span> <span class="s2">&quot;&quot;</span><span class="p">,</span>                                       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Expressions</span><span class="p">()</span>
+    <span class="nx">o</span> <span class="s2">&quot;TERMINATOR&quot;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Expressions</span><span class="p">()</span>
     <span class="nx">o</span> <span class="s2">&quot;Expressions&quot;</span>
     <span class="nx">o</span> <span class="s2">&quot;Block TERMINATOR&quot;</span>
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-9">#</a>               </div>               <p>Any list of expressions or method body, seperated by line breaks or
 semicolons.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Expressions: </span><span class="p">[</span>
-    <span class="nx">o</span> <span class="s2">&quot;Expression&quot;</span><span class="p">,</span>                        <span class="o">-&gt;</span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
-    <span class="nx">o</span> <span class="s2">&quot;Expressions TERMINATOR Expression&quot;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">push</span> <span class="nx">$3</span>
+    <span class="nx">o</span> <span class="s2">&quot;Expression&quot;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
+    <span class="nx">o</span> <span class="s2">&quot;Expressions TERMINATOR Expression&quot;</span><span class="p">,</span>      <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">push</span> <span class="nx">$3</span>
     <span class="nx">o</span> <span class="s2">&quot;Expressions TERMINATOR&quot;</span>
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-10">#</a>               </div>               <p>All the different types of expressions in our language. The basic unit of
 CoffeeScript is the <strong>Expression</strong> -- you'll notice that there is no
@@ -48,6 +48,7 @@ CoffeeScript is the <strong>Expression</strong> -- you'll notice that there is n
 of many other rules, making them somewhat circular.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Expression: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;Value&quot;</span>
     <span class="nx">o</span> <span class="s2">&quot;Call&quot;</span>
+    <span class="nx">o</span> <span class="s2">&quot;Curry&quot;</span>
     <span class="nx">o</span> <span class="s2">&quot;Code&quot;</span>
     <span class="nx">o</span> <span class="s2">&quot;Operation&quot;</span>
     <span class="nx">o</span> <span class="s2">&quot;Assign&quot;</span>
@@ -63,11 +64,13 @@ of many other rules, making them somewhat circular.</p>             </td>
     <span class="nx">o</span> <span class="s2">&quot;Splat&quot;</span>
     <span class="nx">o</span> <span class="s2">&quot;Existence&quot;</span>
     <span class="nx">o</span> <span class="s2">&quot;Comment&quot;</span>
+    <span class="nx">o</span> <span class="s2">&quot;Extension&quot;</span>
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-11">#</a>               </div>               <p>A an indented block of expressions. Note that the <a href="rewriter.html">Rewriter</a>
 will convert some postfix forms into blocks for us, by adjusting the
 token stream.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Block: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;INDENT Expressions OUTDENT&quot;</span><span class="p">,</span>             <span class="o">-&gt;</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s2">&quot;INDENT OUTDENT&quot;</span><span class="p">,</span>                         <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Expressions</span><span class="p">()</span>
+    <span class="nx">o</span> <span class="s2">&quot;TERMINATOR Comment&quot;</span><span class="p">,</span>                     <span class="o">-&gt;</span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">$2</span><span class="p">]</span>
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-12">#</a>               </div>               <p>A literal identifier, a variable name or property.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Identifier: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;IDENTIFIER&quot;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">LiteralNode</span> <span class="nx">yytext</span>
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-13">#</a>               </div>               <p>Alphanumerics are separated from the other <strong>Literal</strong> matchers because
@@ -88,7 +91,7 @@ through and printed to JavaScript.</p>             </td>             <td class="
     <span class="nx">o</span> <span class="s2">&quot;ON&quot;</span><span class="p">,</span>                                     <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">LiteralNode</span> <span class="kc">true</span>
     <span class="nx">o</span> <span class="s2">&quot;OFF&quot;</span><span class="p">,</span>                                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">LiteralNode</span> <span class="kc">false</span>
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-15">#</a>               </div>               <p>Assignment of a variable, property, or index to a value.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Assign: </span><span class="p">[</span>
-    <span class="nx">o</span> <span class="s2">&quot;Value ASSIGN Expression&quot;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">AssignNode</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
+    <span class="nx">o</span> <span class="s2">&quot;Assignable ASSIGN Expression&quot;</span><span class="p">,</span>           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">AssignNode</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-16">#</a>               </div>               <p>Assignment when it happens within an object literal. The difference from
 the ordinary <strong>Assign</strong> is that these allow numbers and strings as keys.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">AssignObj: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;Identifier ASSIGN Expression&quot;</span><span class="p">,</span>           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">AssignNode</span> <span class="k">new</span> <span class="nx">ValueNode</span><span class="p">(</span><span class="nx">$1</span><span class="p">),</span> <span class="nx">$3</span><span class="p">,</span> <span class="s1">&#39;object&#39;</span>
@@ -122,72 +125,96 @@ that hoovers up the remaining arguments.</p>             </td>             <td c
     <span class="nx">o</span> <span class="s2">&quot;Param . . .&quot;</span><span class="p">,</span>                            <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">SplatNode</span> <span class="nx">$1</span>
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-24">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-24">#</a>               </div>               <p>A splat that occurs outside of a parameter list.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Splat: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;Expression . . .&quot;</span><span class="p">,</span>                       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">SplatNode</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-25">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-25">#</a>               </div>               <p>The types of things that can be treated as values -- assigned to, invoked
-as functions, indexed into, named as a class, etc.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Value: </span><span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-25">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-25">#</a>               </div>               <p>Variables and properties that can be assigned to.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">SimpleAssignable: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;Identifier&quot;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ValueNode</span> <span class="nx">$1</span>
-    <span class="nx">o</span> <span class="s2">&quot;Literal&quot;</span><span class="p">,</span>                                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ValueNode</span> <span class="nx">$1</span>
+    <span class="nx">o</span> <span class="s2">&quot;Value Accessor&quot;</span><span class="p">,</span>                         <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">push</span> <span class="nx">$2</span>
+    <span class="nx">o</span> <span class="s2">&quot;Invocation Accessor&quot;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ValueNode</span> <span class="nx">$1</span><span class="p">,</span> <span class="p">[</span><span class="nx">$2</span><span class="p">]</span>
+    <span class="nx">o</span> <span class="s2">&quot;ThisProperty&quot;</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-26">#</a>               </div>               <p>Everything that can be assigned to.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Assignable: </span><span class="p">[</span>
+    <span class="nx">o</span> <span class="s2">&quot;SimpleAssignable&quot;</span>
     <span class="nx">o</span> <span class="s2">&quot;Array&quot;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ValueNode</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s2">&quot;Object&quot;</span><span class="p">,</span>                                 <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ValueNode</span> <span class="nx">$1</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-27">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-27">#</a>               </div>               <p>The types of things that can be treated as values -- assigned to, invoked
+as functions, indexed into, named as a class, etc.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Value: </span><span class="p">[</span>
+    <span class="nx">o</span> <span class="s2">&quot;Assignable&quot;</span>
+    <span class="nx">o</span> <span class="s2">&quot;Literal&quot;</span><span class="p">,</span>                                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ValueNode</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s2">&quot;Parenthetical&quot;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ValueNode</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s2">&quot;Range&quot;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ValueNode</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s2">&quot;This&quot;</span>
-    <span class="nx">o</span> <span class="s2">&quot;Value Accessor&quot;</span><span class="p">,</span>                         <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">push</span> <span class="nx">$2</span>
-    <span class="nx">o</span> <span class="s2">&quot;Invocation Accessor&quot;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ValueNode</span> <span class="nx">$1</span><span class="p">,</span> <span class="p">[</span><span class="nx">$2</span><span class="p">]</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-26">#</a>               </div>               <p>The general group of accessors into an object, by property, by prototype
+    <span class="nx">o</span> <span class="s2">&quot;NULL&quot;</span><span class="p">,</span>                                   <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ValueNode</span> <span class="k">new</span> <span class="nx">LiteralNode</span> <span class="s1">&#39;null&#39;</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-28">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-28">#</a>               </div>               <p>The general group of accessors into an object, by property, by prototype
 or by array index or slice.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Accessor: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;PROPERTY_ACCESS Identifier&quot;</span><span class="p">,</span>             <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">AccessorNode</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s2">&quot;PROTOTYPE_ACCESS Identifier&quot;</span><span class="p">,</span>            <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">AccessorNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="s1">&#39;prototype&#39;</span>
+    <span class="nx">o</span> <span class="s2">&quot;::&quot;</span><span class="p">,</span>                                     <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">AccessorNode</span><span class="p">(</span><span class="k">new</span> <span class="nx">LiteralNode</span><span class="p">(</span><span class="s1">&#39;prototype&#39;</span><span class="p">))</span>
     <span class="nx">o</span> <span class="s2">&quot;SOAK_ACCESS Identifier&quot;</span><span class="p">,</span>                 <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">AccessorNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="s1">&#39;soak&#39;</span>
     <span class="nx">o</span> <span class="s2">&quot;Index&quot;</span>
     <span class="nx">o</span> <span class="s2">&quot;Slice&quot;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">SliceNode</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-27">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-27">#</a>               </div>               <p>Indexing into an object or array using bracket notation.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Index: </span><span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-29">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-29">#</a>               </div>               <p>Indexing into an object or array using bracket notation.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Index: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;INDEX_START Expression INDEX_END&quot;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">IndexNode</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s2">&quot;SOAKED_INDEX_START Expression SOAKED_INDEX_END&quot;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">IndexNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="s1">&#39;soak&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-28">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-28">#</a>               </div>               <p>In CoffeeScript, an object literal is simply a list of assignments.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nb">Object</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-30">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-30">#</a>               </div>               <p>In CoffeeScript, an object literal is simply a list of assignments.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nb">Object</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;{ AssignList }&quot;</span><span class="p">,</span>                         <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ObjectNode</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s2">&quot;{ IndentedAssignList }&quot;</span><span class="p">,</span>                 <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ObjectNode</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-29">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-29">#</a>               </div>               <p>Class definitions have optional bodies of prototype property assignments,
-and optional references to the superclass.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Class: </span><span class="p">[</span>
-    <span class="nx">o</span> <span class="s2">&quot;CLASS Value&quot;</span><span class="p">,</span>                            <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ClassNode</span> <span class="nx">$2</span>
-    <span class="nx">o</span> <span class="s2">&quot;CLASS Value EXTENDS Value&quot;</span><span class="p">,</span>              <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ClassNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$4</span>
-    <span class="nx">o</span> <span class="s2">&quot;CLASS Value IndentedAssignList&quot;</span><span class="p">,</span>         <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ClassNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">$3</span>
-    <span class="nx">o</span> <span class="s2">&quot;CLASS Value EXTENDS Value IndentedAssignList&quot;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ClassNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$4</span><span class="p">,</span> <span class="nx">$5</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-30">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-30">#</a>               </div>               <p>Assignment of properties within an object literal can be separated by
+    <span class="nx">o</span> <span class="s2">&quot;{ AssignList , }&quot;</span><span class="p">,</span>                       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ObjectNode</span> <span class="nx">$2</span>
+    <span class="nx">o</span> <span class="s2">&quot;{ IndentedAssignList , }&quot;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ObjectNode</span> <span class="nx">$2</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-31">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-31">#</a>               </div>               <p>Assignment of properties within an object literal can be separated by
 comma, as in JavaScript, or simply by newline.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">AssignList: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;&quot;</span><span class="p">,</span>                                       <span class="o">-&gt;</span> <span class="p">[]</span>
     <span class="nx">o</span> <span class="s2">&quot;AssignObj&quot;</span><span class="p">,</span>                              <span class="o">-&gt;</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s2">&quot;AssignList , AssignObj&quot;</span><span class="p">,</span>                 <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">concat</span> <span class="p">[</span><span class="nx">$3</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s2">&quot;AssignList TERMINATOR AssignObj&quot;</span><span class="p">,</span>        <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">concat</span> <span class="p">[</span><span class="nx">$3</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s2">&quot;AssignList , TERMINATOR AssignObj&quot;</span><span class="p">,</span>      <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">concat</span> <span class="p">[</span><span class="nx">$4</span><span class="p">]</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-31">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-31">#</a>               </div>               <p>An <strong>AssignList</strong> within a block indentation.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">IndentedAssignList: </span><span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-32">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-32">#</a>               </div>               <p>An <strong>AssignList</strong> within a block indentation.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">IndentedAssignList: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;INDENT AssignList OUTDENT&quot;</span><span class="p">,</span>              <span class="o">-&gt;</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-32">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-32">#</a>               </div>               <p>The three flavors of function call: normal, object instantiation with <code>new</code>,
+    <span class="nx">o</span> <span class="s2">&quot;INDENT AssignList , OUTDENT&quot;</span><span class="p">,</span>            <span class="o">-&gt;</span> <span class="nx">$2</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-33">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-33">#</a>               </div>               <p>Class definitions have optional bodies of prototype property assignments,
+and optional references to the superclass.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Class: </span><span class="p">[</span>
+    <span class="nx">o</span> <span class="s2">&quot;CLASS SimpleAssignable&quot;</span><span class="p">,</span>                 <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ClassNode</span> <span class="nx">$2</span>
+    <span class="nx">o</span> <span class="s2">&quot;CLASS SimpleAssignable EXTENDS Value&quot;</span><span class="p">,</span>   <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ClassNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$4</span>
+    <span class="nx">o</span> <span class="s2">&quot;CLASS SimpleAssignable INDENT ClassBody OUTDENT&quot;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ClassNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">$4</span>
+    <span class="nx">o</span> <span class="s2">&quot;CLASS SimpleAssignable EXTENDS Value INDENT ClassBody OUTDENT&quot;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ClassNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$4</span><span class="p">,</span> <span class="nx">$6</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-34">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-34">#</a>               </div>               <p>Assignments that can happen directly inside a class declaration.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">ClassAssign: </span><span class="p">[</span>
+    <span class="nx">o</span> <span class="s2">&quot;AssignObj&quot;</span><span class="p">,</span>                              <span class="o">-&gt;</span> <span class="nx">$1</span>
+    <span class="nx">o</span> <span class="s2">&quot;ThisProperty ASSIGN Expression&quot;</span><span class="p">,</span>         <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">AssignNode</span> <span class="k">new</span> <span class="nx">ValueNode</span><span class="p">(</span><span class="nx">$1</span><span class="p">),</span> <span class="nx">$3</span><span class="p">,</span> <span class="s1">&#39;this&#39;</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-35">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-35">#</a>               </div>               <p>A list of assignments to a class.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">ClassBody: </span><span class="p">[</span>
+    <span class="nx">o</span> <span class="s2">&quot;&quot;</span><span class="p">,</span>                                       <span class="o">-&gt;</span> <span class="p">[]</span>
+    <span class="nx">o</span> <span class="s2">&quot;ClassAssign&quot;</span><span class="p">,</span>                            <span class="o">-&gt;</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
+    <span class="nx">o</span> <span class="s2">&quot;ClassBody TERMINATOR ClassAssign&quot;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">$3</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-36">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-36">#</a>               </div>               <p>The three flavors of function call: normal, object instantiation with <code>new</code>,
 and calling <code>super()</code></p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Call: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;Invocation&quot;</span>
     <span class="nx">o</span> <span class="s2">&quot;NEW Invocation&quot;</span><span class="p">,</span>                         <span class="o">-&gt;</span> <span class="nx">$2</span><span class="p">.</span><span class="nx">new_instance</span><span class="p">()</span>
     <span class="nx">o</span> <span class="s2">&quot;Super&quot;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-33">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-33">#</a>               </div>               <p>Extending an object by setting its prototype chain to reference a parent
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-37">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-37">#</a>               </div>               <p>Binds a function call to a context and/or arguments.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Curry: </span><span class="p">[</span>
+    <span class="nx">o</span> <span class="s2">&quot;Value &lt;- Arguments&quot;</span><span class="p">,</span>                     <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">CurryNode</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-38">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-38">#</a>               </div>               <p>Extending an object by setting its prototype chain to reference a parent
 object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Extends: </span><span class="p">[</span>
-    <span class="nx">o</span> <span class="s2">&quot;Value EXTENDS Value&quot;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ExtendsNode</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-34">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-34">#</a>               </div>               <p>Ordinary function invocation, or a chained series of calls.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Invocation: </span><span class="p">[</span>
+    <span class="nx">o</span> <span class="s2">&quot;SimpleAssignable EXTENDS Value&quot;</span><span class="p">,</span>         <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ExtendsNode</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-39">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-39">#</a>               </div>               <p>Ordinary function invocation, or a chained series of calls.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Invocation: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;Value Arguments&quot;</span><span class="p">,</span>                        <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">CallNode</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s2">&quot;Invocation Arguments&quot;</span><span class="p">,</span>                   <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">CallNode</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-35">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-35">#</a>               </div>               <p>The list of arguments to a function call.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Arguments: </span><span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-40">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-40">#</a>               </div>               <p>The list of arguments to a function call.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Arguments: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;CALL_START ArgList CALL_END&quot;</span><span class="p">,</span>            <span class="o">-&gt;</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-36">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-36">#</a>               </div>               <p>Calling super.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Super: </span><span class="p">[</span>
+    <span class="nx">o</span> <span class="s2">&quot;CALL_START ArgList , CALL_END&quot;</span><span class="p">,</span>          <span class="o">-&gt;</span> <span class="nx">$2</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-41">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-41">#</a>               </div>               <p>Calling super.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Super: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;SUPER CALL_START ArgList CALL_END&quot;</span><span class="p">,</span>      <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">CallNode</span> <span class="s1">&#39;super&#39;</span><span class="p">,</span> <span class="nx">$3</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-37">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-37">#</a>               </div>               <p>A reference to the <em>this</em> current object, either naked or to a property.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">This: </span><span class="p">[</span>
+    <span class="nx">o</span> <span class="s2">&quot;SUPER CALL_START ArgList , CALL_END&quot;</span><span class="p">,</span>    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">CallNode</span> <span class="s1">&#39;super&#39;</span><span class="p">,</span> <span class="nx">$3</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-42">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-42">#</a>               </div>               <p>A reference to the <em>this</em> current object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">This: </span><span class="p">[</span>
+    <span class="nx">o</span> <span class="s2">&quot;THIS&quot;</span><span class="p">,</span>                                   <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ValueNode</span> <span class="k">new</span> <span class="nx">LiteralNode</span> <span class="s1">&#39;this&#39;</span>
     <span class="nx">o</span> <span class="s2">&quot;@&quot;</span><span class="p">,</span>                                      <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ValueNode</span> <span class="k">new</span> <span class="nx">LiteralNode</span> <span class="s1">&#39;this&#39;</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-43">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-43">#</a>               </div>               <p>A reference to a property on <em>this</em>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">ThisProperty: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;@ Identifier&quot;</span><span class="p">,</span>                           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ValueNode</span> <span class="k">new</span> <span class="nx">LiteralNode</span><span class="p">(</span><span class="s1">&#39;this&#39;</span><span class="p">),</span> <span class="p">[</span><span class="k">new</span> <span class="nx">AccessorNode</span><span class="p">(</span><span class="nx">$2</span><span class="p">)]</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-38">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-38">#</a>               </div>               <p>The CoffeeScript range literal.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Range: </span><span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-44">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-44">#</a>               </div>               <p>The CoffeeScript range literal.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Range: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;[ Expression . . Expression ]&quot;</span><span class="p">,</span>          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">RangeNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$5</span>
     <span class="nx">o</span> <span class="s2">&quot;[ Expression . . . Expression ]&quot;</span><span class="p">,</span>        <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">RangeNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$6</span><span class="p">,</span> <span class="kc">true</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-39">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-39">#</a>               </div>               <p>The slice literal.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Slice: </span><span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-45">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-45">#</a>               </div>               <p>The slice literal.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Slice: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;INDEX_START Expression . . Expression INDEX_END&quot;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">RangeNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$5</span>
     <span class="nx">o</span> <span class="s2">&quot;INDEX_START Expression . . . Expression INDEX_END&quot;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">RangeNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$6</span><span class="p">,</span> <span class="kc">true</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-40">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-40">#</a>               </div>               <p>The array literal.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nb">Array</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-46">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-46">#</a>               </div>               <p>The array literal.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nb">Array</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;[ ArgList ]&quot;</span><span class="p">,</span>                            <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ArrayNode</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-41">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-41">#</a>               </div>               <p>The <strong>ArgList</strong> is both the list of objects passed into a function call,
+    <span class="nx">o</span> <span class="s2">&quot;[ ArgList , ]&quot;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ArrayNode</span> <span class="nx">$2</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-47">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-47">#</a>               </div>               <p>The <strong>ArgList</strong> is both the list of objects passed into a function call,
 as well as the contents of an array literal
 (i.e. comma-separated expressions). Newlines work as well.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">ArgList: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;&quot;</span><span class="p">,</span>                                       <span class="o">-&gt;</span> <span class="p">[]</span>
@@ -198,77 +225,84 @@ as well as the contents of an array literal
     <span class="nx">o</span> <span class="s2">&quot;ArgList , TERMINATOR Expression&quot;</span><span class="p">,</span>        <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">concat</span> <span class="p">[</span><span class="nx">$4</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s2">&quot;ArgList , INDENT Expression&quot;</span><span class="p">,</span>            <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">concat</span> <span class="p">[</span><span class="nx">$4</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s2">&quot;ArgList OUTDENT&quot;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-42">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-42">#</a>               </div>               <p>Just simple, comma-separated, required arguments (no fancy syntax). We need
+    <span class="nx">o</span> <span class="s2">&quot;ArgList , OUTDENT&quot;</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-48">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-48">#</a>               </div>               <p>Just simple, comma-separated, required arguments (no fancy syntax). We need
 this to be separate from the <strong>ArgList</strong> for use in <strong>Switch</strong> blocks, where
 having the newlines wouldn't make sense.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">SimpleArgs: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;Expression&quot;</span>
     <span class="nx">o</span> <span class="s2">&quot;SimpleArgs , Expression&quot;</span><span class="p">,</span>                <span class="o">-&gt;</span>
       <span class="k">if</span> <span class="nx">$1</span> <span class="k">instanceof</span> <span class="nb">Array</span> <span class="k">then</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">concat</span><span class="p">([</span><span class="nx">$3</span><span class="p">])</span> <span class="k">else</span> <span class="p">[</span><span class="nx">$1</span><span class="p">].</span><span class="nx">concat</span><span class="p">([</span><span class="nx">$3</span><span class="p">])</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-43">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-43">#</a>               </div>               <p>The variants of <em>try/catch/finally</em> exception handling blocks.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Try: </span><span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-49">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-49">#</a>               </div>               <p>The variants of <em>try/catch/finally</em> exception handling blocks.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Try: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;TRY Block Catch&quot;</span><span class="p">,</span>                        <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">TryNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$3</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nx">$3</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s2">&quot;TRY Block FINALLY Block&quot;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">TryNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">$4</span>
     <span class="nx">o</span> <span class="s2">&quot;TRY Block Catch FINALLY Block&quot;</span><span class="p">,</span>          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">TryNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$3</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nx">$3</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="nx">$5</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-44">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-44">#</a>               </div>               <p>A catch clause names its error and runs a block of code.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Catch: </span><span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-50">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-50">#</a>               </div>               <p>A catch clause names its error and runs a block of code.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Catch: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;CATCH Identifier Block&quot;</span><span class="p">,</span>                 <span class="o">-&gt;</span> <span class="p">[</span><span class="nx">$2</span><span class="p">,</span> <span class="nx">$3</span><span class="p">]</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-45">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-45">#</a>               </div>               <p>Throw an exception object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Throw: </span><span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-51">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-51">#</a>               </div>               <p>Throw an exception object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Throw: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;THROW Expression&quot;</span><span class="p">,</span>                       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ThrowNode</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-46">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-46">#</a>               </div>               <p>Parenthetical expressions. Note that the <strong>Parenthetical</strong> is a <strong>Value</strong>,
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-52">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-52">#</a>               </div>               <p>Parenthetical expressions. Note that the <strong>Parenthetical</strong> is a <strong>Value</strong>,
 not an <strong>Expression</strong>, so if you need to use an expression in a place
 where only values are accepted, wrapping it in parentheses will always do
 the trick.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Parenthetical: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;( Expression )&quot;</span><span class="p">,</span>                         <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ParentheticalNode</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-47">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-47">#</a>               </div>               <p>The condition portion of a while loop.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">WhileSource: </span><span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-53">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-53">#</a>               </div>               <p>A language extension to CoffeeScript from the outside. We simply pass
+it through unaltered.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Extension: </span><span class="p">[</span>
+    <span class="nx">o</span> <span class="s2">&quot;EXTENSION&quot;</span><span class="p">,</span>                              <span class="o">-&gt;</span> <span class="nx">yytext</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-54">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-54">#</a>               </div>               <p>The condition portion of a while loop.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">WhileSource: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;WHILE Expression&quot;</span><span class="p">,</span>                       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">WhileNode</span> <span class="nx">$2</span>
-    <span class="nx">o</span> <span class="s2">&quot;WHILE Expression WHEN Expression&quot;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">WhileNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="p">{</span><span class="nx">filter</span> <span class="o">:</span> <span class="nx">$4</span><span class="p">}</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-48">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-48">#</a>               </div>               <p>The while loop can either be normal, with a block of expressions to execute,
+    <span class="nx">o</span> <span class="s2">&quot;WHILE Expression WHEN Expression&quot;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">WhileNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="p">{</span><span class="nv">filter : </span><span class="nx">$4</span><span class="p">}</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-55">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-55">#</a>               </div>               <p>The while loop can either be normal, with a block of expressions to execute,
 or postfix, with a single expression. There is no do..while.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">While: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;WhileSource Block&quot;</span><span class="p">,</span>                      <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">add_body</span> <span class="nx">$2</span>
-    <span class="nx">o</span> <span class="s2">&quot;Expression WhileSource&quot;</span><span class="p">,</span>                 <span class="o">-&gt;</span> <span class="nx">$2</span><span class="p">.</span><span class="nx">add_body</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-49">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-49">#</a>               </div>               <p>Array, object, and range comprehensions, at the most generic level.
+    <span class="nx">o</span> <span class="s2">&quot;Expression WhileSource&quot;</span><span class="p">,</span>                 <span class="o">-&gt;</span> <span class="nx">$2</span><span class="p">.</span><span class="nx">add_body</span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-56">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-56">#</a>               </div>               <p>Array, object, and range comprehensions, at the most generic level.
 Comprehensions can either be normal, with a block of expressions to execute,
 or postfix, with a single expression.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">For: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;Expression FOR ForVariables ForSource&quot;</span><span class="p">,</span>  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ForNode</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$4</span><span class="p">,</span> <span class="nx">$3</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nx">$3</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s2">&quot;FOR ForVariables ForSource Block&quot;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">ForNode</span> <span class="nx">$4</span><span class="p">,</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">$2</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nx">$2</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-50">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-50">#</a>               </div>               <p>An array or range comprehension has variables for the current element and
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-57">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-57">#</a>               </div>               <p>An array or range comprehension has variables for the current element and
 (optional) reference to the current index. Or, <em>key, value</em>, in the case
 of object comprehensions.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">ForVariables: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;Identifier&quot;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s2">&quot;Identifier , Identifier&quot;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="p">[</span><span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span><span class="p">]</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-51">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-51">#</a>               </div>               <p>The source of a comprehension is an array or object with an optional filter
-clause. If it's an array comprehension, you can also choose to step throug
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-58">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-58">#</a>               </div>               <p>The source of a comprehension is an array or object with an optional filter
+clause. If it's an array comprehension, you can also choose to step through
 in fixed-size increments.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">ForSource: </span><span class="p">[</span>
-    <span class="nx">o</span> <span class="s2">&quot;IN Expression&quot;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="p">{</span><span class="nv">source: </span>  <span class="nx">$2</span><span class="p">}</span>
-    <span class="nx">o</span> <span class="s2">&quot;OF Expression&quot;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="p">{</span><span class="nv">source: </span>  <span class="nx">$2</span><span class="p">,</span> <span class="nv">object: </span><span class="kc">true</span><span class="p">}</span>
-    <span class="nx">o</span> <span class="s2">&quot;ForSource WHEN Expression&quot;</span><span class="p">,</span>              <span class="o">-&gt;</span> <span class="nv">$1.filter: </span><span class="nx">$3</span><span class="p">;</span> <span class="nx">$1</span>
-    <span class="nx">o</span> <span class="s2">&quot;ForSource BY Expression&quot;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="nv">$1.step: </span>  <span class="nx">$3</span><span class="p">;</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-52">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-52">#</a>               </div>               <p>The CoffeeScript switch/when/else block replaces the JavaScript
+    <span class="nx">o</span> <span class="s2">&quot;IN Expression&quot;</span><span class="p">,</span>                               <span class="o">-&gt;</span> <span class="p">{</span><span class="nv">source: </span><span class="nx">$2</span><span class="p">}</span>
+    <span class="nx">o</span> <span class="s2">&quot;OF Expression&quot;</span><span class="p">,</span>                               <span class="o">-&gt;</span> <span class="p">{</span><span class="nv">source: </span><span class="nx">$2</span><span class="p">,</span> <span class="nv">object: </span><span class="kc">true</span><span class="p">}</span>
+    <span class="nx">o</span> <span class="s2">&quot;IN Expression WHEN Expression&quot;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="p">{</span><span class="nv">source: </span><span class="nx">$2</span><span class="p">,</span> <span class="nv">filter: </span><span class="nx">$4</span><span class="p">}</span>
+    <span class="nx">o</span> <span class="s2">&quot;OF Expression WHEN Expression&quot;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="p">{</span><span class="nv">source: </span><span class="nx">$2</span><span class="p">,</span> <span class="nv">filter: </span><span class="nx">$4</span><span class="p">,</span> <span class="nv">object: </span><span class="kc">true</span><span class="p">}</span>
+    <span class="nx">o</span> <span class="s2">&quot;IN Expression BY Expression&quot;</span><span class="p">,</span>                 <span class="o">-&gt;</span> <span class="p">{</span><span class="nv">source: </span><span class="nx">$2</span><span class="p">,</span> <span class="nv">step: </span>  <span class="nx">$4</span><span class="p">}</span>
+    <span class="nx">o</span> <span class="s2">&quot;IN Expression WHEN Expression BY Expression&quot;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="p">{</span><span class="nv">source: </span><span class="nx">$2</span><span class="p">,</span> <span class="nv">filter: </span><span class="nx">$4</span><span class="p">;</span> <span class="nv">step: </span>  <span class="nx">$6</span><span class="p">}</span>
+    <span class="nx">o</span> <span class="s2">&quot;IN Expression BY Expression WHEN Expression&quot;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="p">{</span><span class="nv">source: </span><span class="nx">$2</span><span class="p">,</span> <span class="nv">step: </span>  <span class="nx">$4</span><span class="p">,</span> <span class="nv">filter: </span><span class="nx">$6</span><span class="p">}</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-59">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-59">#</a>               </div>               <p>The CoffeeScript switch/when/else block replaces the JavaScript
 switch/case/default by compiling into an if-else chain.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Switch: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;SWITCH Expression INDENT Whens OUTDENT&quot;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="nx">$4</span><span class="p">.</span><span class="nx">rewrite_condition</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s2">&quot;SWITCH Expression INDENT Whens ELSE Block OUTDENT&quot;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="nx">$4</span><span class="p">.</span><span class="nx">rewrite_condition</span><span class="p">(</span><span class="nx">$2</span><span class="p">).</span><span class="nx">add_else</span> <span class="nx">$6</span><span class="p">,</span> <span class="kc">true</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-53">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-53">#</a>               </div>               <p>The inner list of whens is left recursive. At code-generation time, the
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-60">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-60">#</a>               </div>               <p>The inner list of whens is left recursive. At code-generation time, the
 IfNode will rewrite them into a proper chain.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Whens: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;When&quot;</span>
     <span class="nx">o</span> <span class="s2">&quot;Whens When&quot;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">push</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-54">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-54">#</a>               </div>               <p>An individual <strong>When</strong> clause, with action.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">When: </span><span class="p">[</span>
-    <span class="nx">o</span> <span class="s2">&quot;LEADING_WHEN SimpleArgs Block&quot;</span><span class="p">,</span>          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">IfNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$3</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="p">{</span><span class="nv">statement: </span><span class="kc">true</span><span class="p">}</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-61">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-61">#</a>               </div>               <p>An individual <strong>When</strong> clause, with action.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">When: </span><span class="p">[</span>
+    <span class="nx">o</span> <span class="s2">&quot;LEADING_WHEN SimpleArgs Block&quot;</span><span class="p">,</span>            <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">IfNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$3</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="p">{</span><span class="nv">statement: </span><span class="kc">true</span><span class="p">}</span>
     <span class="nx">o</span> <span class="s2">&quot;LEADING_WHEN SimpleArgs Block TERMINATOR&quot;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">IfNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$3</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="p">{</span><span class="nv">statement: </span><span class="kc">true</span><span class="p">}</span>
-    <span class="nx">o</span> <span class="s2">&quot;Comment TERMINATOR When&quot;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="nv">$3.comment: </span><span class="nx">$1</span><span class="p">;</span> <span class="nx">$3</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-55">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-55">#</a>               </div>               <p>The most basic form of <em>if</em> is a condition and an action. The following
+    <span class="nx">o</span> <span class="s2">&quot;Comment TERMINATOR When&quot;</span><span class="p">,</span>                  <span class="o">-&gt;</span> <span class="nv">$3.comment: </span><span class="nx">$1</span><span class="p">;</span> <span class="nx">$3</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-62">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-62">#</a>               </div>               <p>The most basic form of <em>if</em> is a condition and an action. The following
 if-related rules are broken up along these lines in order to avoid
 ambiguity.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">IfStart: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;IF Expression Block&quot;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">IfNode</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$3</span>
     <span class="nx">o</span> <span class="s2">&quot;IfStart ElsIf&quot;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">add_else</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-56">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-56">#</a>               </div>               <p>An <strong>IfStart</strong> can optionally be followed by an else block.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">IfBlock: </span><span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-63">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-63">#</a>               </div>               <p>An <strong>IfStart</strong> can optionally be followed by an else block.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">IfBlock: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;IfStart&quot;</span>
     <span class="nx">o</span> <span class="s2">&quot;IfStart ELSE Block&quot;</span><span class="p">,</span>                     <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">add_else</span> <span class="nx">$3</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-57">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-57">#</a>               </div>               <p>An <em>else if</em> continuation of the <em>if</em> expression.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">ElsIf: </span><span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-64">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-64">#</a>               </div>               <p>An <em>else if</em> continuation of the <em>if</em> expression.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">ElsIf: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;ELSE IF Expression Block&quot;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="p">(</span><span class="k">new</span> <span class="nx">IfNode</span><span class="p">(</span><span class="nx">$3</span><span class="p">,</span> <span class="nx">$4</span><span class="p">)).</span><span class="nx">force_statement</span><span class="p">()</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-58">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-58">#</a>               </div>               <p>The full complement of <em>if</em> expressions, including postfix one-liner
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-65">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-65">#</a>               </div>               <p>The full complement of <em>if</em> expressions, including postfix one-liner
 <em>if</em> and <em>unless</em>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">If: </span><span class="p">[</span>
     <span class="nx">o</span> <span class="s2">&quot;IfBlock&quot;</span>
     <span class="nx">o</span> <span class="s2">&quot;Expression IF Expression&quot;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">IfNode</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span><span class="p">([</span><span class="nx">$1</span><span class="p">]),</span> <span class="kc">null</span><span class="p">,</span> <span class="p">{</span><span class="nv">statement: </span><span class="kc">true</span><span class="p">}</span>
     <span class="nx">o</span> <span class="s2">&quot;Expression UNLESS Expression&quot;</span><span class="p">,</span>           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">IfNode</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span><span class="p">([</span><span class="nx">$1</span><span class="p">]),</span> <span class="kc">null</span><span class="p">,</span> <span class="p">{</span><span class="nv">statement: </span><span class="kc">true</span><span class="p">,</span> <span class="nv">invert: </span><span class="kc">true</span><span class="p">}</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-59">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-59">#</a>               </div>               <p>Arithmetic and logical operators, working on one or more operands.
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-66">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-66">#</a>               </div>               <p>Arithmetic and logical operators, working on one or more operands.
 Here they are grouped by order of precedence. The actual precedence rules
 are defined at the bottom of the page. It would be shorter if we could
 combine most of these rules into a single generic <em>Operand OpSymbol Operand</em>
@@ -278,7 +312,6 @@ rules are necessary.</p>             </td>             <td class="code">
     <span class="nx">o</span> <span class="s2">&quot;!! Expression&quot;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;!!&#39;</span><span class="p">,</span> <span class="nx">$2</span>
     <span class="nx">o</span><span class="p">(</span><span class="s2">&quot;- Expression&quot;</span><span class="p">,</span>                           <span class="p">(</span><span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span><span class="p">(</span><span class="s1">&#39;-&#39;</span><span class="p">,</span> <span class="nx">$2</span><span class="p">)),</span> <span class="p">{</span><span class="nv">prec: </span><span class="s1">&#39;UMINUS&#39;</span><span class="p">})</span>
     <span class="nx">o</span><span class="p">(</span><span class="s2">&quot;+ Expression&quot;</span><span class="p">,</span>                           <span class="p">(</span><span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span><span class="p">(</span><span class="s1">&#39;+&#39;</span><span class="p">,</span> <span class="nx">$2</span><span class="p">)),</span> <span class="p">{</span><span class="nv">prec: </span><span class="s1">&#39;UPLUS&#39;</span><span class="p">})</span>
-    <span class="nx">o</span> <span class="s2">&quot;NOT Expression&quot;</span><span class="p">,</span>                         <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;not&#39;</span><span class="p">,</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s2">&quot;~ Expression&quot;</span><span class="p">,</span>                           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;~&#39;</span><span class="p">,</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s2">&quot;-- Expression&quot;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;--&#39;</span><span class="p">,</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s2">&quot;++ Expression&quot;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;++&#39;</span><span class="p">,</span> <span class="nx">$2</span>
@@ -308,13 +341,9 @@ rules are necessary.</p>             </td>             <td class="code">
 
     <span class="nx">o</span> <span class="s2">&quot;Expression == Expression&quot;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;==&#39;</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
     <span class="nx">o</span> <span class="s2">&quot;Expression != Expression&quot;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;!=&#39;</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
-    <span class="nx">o</span> <span class="s2">&quot;Expression IS Expression&quot;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;is&#39;</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
-    <span class="nx">o</span> <span class="s2">&quot;Expression ISNT Expression&quot;</span><span class="p">,</span>             <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;isnt&#39;</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
 
     <span class="nx">o</span> <span class="s2">&quot;Expression &amp;&amp; Expression&quot;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;&amp;&amp;&#39;</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
     <span class="nx">o</span> <span class="s2">&quot;Expression || Expression&quot;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;||&#39;</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
-    <span class="nx">o</span> <span class="s2">&quot;Expression AND Expression&quot;</span><span class="p">,</span>              <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;and&#39;</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
-    <span class="nx">o</span> <span class="s2">&quot;Expression OR Expression&quot;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;or&#39;</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
     <span class="nx">o</span> <span class="s2">&quot;Expression ? Expression&quot;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;?&#39;</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
 
     <span class="nx">o</span> <span class="s2">&quot;Expression -= Expression&quot;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;-=&#39;</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
@@ -330,7 +359,7 @@ rules are necessary.</p>             </td>             <td class="code">
     <span class="nx">o</span> <span class="s2">&quot;Expression IN Expression&quot;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">OpNode</span> <span class="s1">&#39;in&#39;</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
   <span class="p">]</span>
 
-<span class="p">}</span></pre></div>             </td>           </tr>                               <tr id="section-60">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-60">#</a>               </div>               <h2>Precedence</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-61">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-61">#</a>               </div>               <p>Operators at the top of this list have higher precedence than the ones lower
+<span class="p">}</span></pre></div>             </td>           </tr>                               <tr id="section-67">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-67">#</a>               </div>               <h2>Precedence</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-68">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-68">#</a>               </div>               <p>Operators at the top of this list have higher precedence than the ones lower
 down. Following these rules is what makes <code>2 + 3 * 4</code> parse as:</p>
 
 <pre><code>2 + (3 * 4)
@@ -341,15 +370,15 @@ down. Following these rules is what makes <code>2 + 3 * 4</code> parse as:</p>
 <pre><code>(2 + 3) * 4
 </code></pre>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">operators: </span><span class="p">[</span>
   <span class="p">[</span><span class="s2">&quot;left&quot;</span><span class="p">,</span>      <span class="s1">&#39;?&#39;</span><span class="p">]</span>
-  <span class="p">[</span><span class="s2">&quot;nonassoc&quot;</span><span class="p">,</span>  <span class="s1">&#39;UMINUS&#39;</span><span class="p">,</span> <span class="s1">&#39;UPLUS&#39;</span><span class="p">,</span> <span class="s1">&#39;NOT&#39;</span><span class="p">,</span> <span class="s1">&#39;!&#39;</span><span class="p">,</span> <span class="s1">&#39;!!&#39;</span><span class="p">,</span> <span class="s1">&#39;~&#39;</span><span class="p">,</span> <span class="s1">&#39;++&#39;</span><span class="p">,</span> <span class="s1">&#39;--&#39;</span><span class="p">]</span>
+  <span class="p">[</span><span class="s2">&quot;nonassoc&quot;</span><span class="p">,</span>  <span class="s1">&#39;UMINUS&#39;</span><span class="p">,</span> <span class="s1">&#39;UPLUS&#39;</span><span class="p">,</span> <span class="s1">&#39;!&#39;</span><span class="p">,</span> <span class="s1">&#39;!!&#39;</span><span class="p">,</span> <span class="s1">&#39;~&#39;</span><span class="p">,</span> <span class="s1">&#39;++&#39;</span><span class="p">,</span> <span class="s1">&#39;--&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s2">&quot;left&quot;</span><span class="p">,</span>      <span class="s1">&#39;*&#39;</span><span class="p">,</span> <span class="s1">&#39;/&#39;</span><span class="p">,</span> <span class="s1">&#39;%&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s2">&quot;left&quot;</span><span class="p">,</span>      <span class="s1">&#39;+&#39;</span><span class="p">,</span> <span class="s1">&#39;-&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s2">&quot;left&quot;</span><span class="p">,</span>      <span class="s1">&#39;&lt;&lt;&#39;</span><span class="p">,</span> <span class="s1">&#39;&gt;&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;&gt;&gt;&gt;&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s2">&quot;left&quot;</span><span class="p">,</span>      <span class="s1">&#39;&amp;&#39;</span><span class="p">,</span> <span class="s1">&#39;|&#39;</span><span class="p">,</span> <span class="s1">&#39;^&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s2">&quot;left&quot;</span><span class="p">,</span>      <span class="s1">&#39;&lt;=&#39;</span><span class="p">,</span> <span class="s1">&#39;&lt;&#39;</span><span class="p">,</span> <span class="s1">&#39;&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;&gt;=&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s2">&quot;right&quot;</span><span class="p">,</span>     <span class="s1">&#39;DELETE&#39;</span><span class="p">,</span> <span class="s1">&#39;INSTANCEOF&#39;</span><span class="p">,</span> <span class="s1">&#39;TYPEOF&#39;</span><span class="p">]</span>
-  <span class="p">[</span><span class="s2">&quot;left&quot;</span><span class="p">,</span>      <span class="s1">&#39;==&#39;</span><span class="p">,</span> <span class="s1">&#39;!=&#39;</span><span class="p">,</span> <span class="s1">&#39;IS&#39;</span><span class="p">,</span> <span class="s1">&#39;ISNT&#39;</span><span class="p">]</span>
-  <span class="p">[</span><span class="s2">&quot;left&quot;</span><span class="p">,</span>      <span class="s1">&#39;&amp;&amp;&#39;</span><span class="p">,</span> <span class="s1">&#39;||&#39;</span><span class="p">,</span> <span class="s1">&#39;AND&#39;</span><span class="p">,</span> <span class="s1">&#39;OR&#39;</span><span class="p">]</span>
+  <span class="p">[</span><span class="s2">&quot;left&quot;</span><span class="p">,</span>      <span class="s1">&#39;==&#39;</span><span class="p">,</span> <span class="s1">&#39;!=&#39;</span><span class="p">]</span>
+  <span class="p">[</span><span class="s2">&quot;left&quot;</span><span class="p">,</span>      <span class="s1">&#39;&amp;&amp;&#39;</span><span class="p">,</span> <span class="s1">&#39;||&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s2">&quot;right&quot;</span><span class="p">,</span>     <span class="s1">&#39;-=&#39;</span><span class="p">,</span> <span class="s1">&#39;+=&#39;</span><span class="p">,</span> <span class="s1">&#39;/=&#39;</span><span class="p">,</span> <span class="s1">&#39;*=&#39;</span><span class="p">,</span> <span class="s1">&#39;%=&#39;</span><span class="p">,</span> <span class="s1">&#39;||=&#39;</span><span class="p">,</span> <span class="s1">&#39;&amp;&amp;=&#39;</span><span class="p">,</span> <span class="s1">&#39;?=&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s2">&quot;left&quot;</span><span class="p">,</span>      <span class="s1">&#39;.&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s2">&quot;right&quot;</span><span class="p">,</span>     <span class="s1">&#39;INDENT&#39;</span><span class="p">]</span>
@@ -358,8 +387,8 @@ down. Following these rules is what makes <code>2 + 3 * 4</code> parse as:</p>
   <span class="p">[</span><span class="s2">&quot;right&quot;</span><span class="p">,</span>     <span class="s1">&#39;FOR&#39;</span><span class="p">,</span> <span class="s1">&#39;NEW&#39;</span><span class="p">,</span> <span class="s1">&#39;SUPER&#39;</span><span class="p">,</span> <span class="s1">&#39;CLASS&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s2">&quot;left&quot;</span><span class="p">,</span>      <span class="s1">&#39;EXTENDS&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s2">&quot;right&quot;</span><span class="p">,</span>     <span class="s1">&#39;ASSIGN&#39;</span><span class="p">,</span> <span class="s1">&#39;RETURN&#39;</span><span class="p">]</span>
-  <span class="p">[</span><span class="s2">&quot;right&quot;</span><span class="p">,</span>     <span class="s1">&#39;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;UNLESS&#39;</span><span class="p">,</span> <span class="s1">&#39;IF&#39;</span><span class="p">,</span> <span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s1">&#39;WHILE&#39;</span><span class="p">]</span>
-<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-62">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-62">#</a>               </div>               <h2>Wrapping Up</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-63">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-63">#</a>               </div>               <p>Finally, now what we have our <strong>grammar</strong> and our <strong>operators</strong>, we can create
+  <span class="p">[</span><span class="s2">&quot;right&quot;</span><span class="p">,</span>     <span class="s1">&#39;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;&lt;-&#39;</span><span class="p">,</span> <span class="s1">&#39;UNLESS&#39;</span><span class="p">,</span> <span class="s1">&#39;IF&#39;</span><span class="p">,</span> <span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s1">&#39;WHILE&#39;</span><span class="p">]</span>
+<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-69">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-69">#</a>               </div>               <h2>Wrapping Up</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-70">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-70">#</a>               </div>               <p>Finally, now what we have our <strong>grammar</strong> and our <strong>operators</strong>, we can create
 our <strong>Jison.Parser</strong>. We do this by processing all of our rules, recording all
 terminals (every symbol which does not appear as the name of a rule above)
 as "tokens".</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">tokens: </span><span class="p">[]</span>
@@ -368,7 +397,7 @@ as "tokens".</p>             </td>             <td class="code">               <
     <span class="k">for</span> <span class="nx">token</span> <span class="k">in</span> <span class="nx">alt</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="nx">split</span> <span class="s1">&#39; &#39;</span>
       <span class="nx">tokens</span><span class="p">.</span><span class="nx">push</span> <span class="nx">token</span> <span class="nx">unless</span> <span class="nx">grammar</span><span class="p">[</span><span class="nx">token</span><span class="p">]</span>
     <span class="nx">alt</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="s2">&quot;return ${alt[1]}&quot;</span> <span class="k">if</span> <span class="nx">name</span> <span class="o">is</span> <span class="s1">&#39;Root&#39;</span>
-    <span class="nx">alt</span></pre></div>             </td>           </tr>                               <tr id="section-64">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-64">#</a>               </div>               <p>Initialize the <strong>Parser</strong> with our list of terminal <strong>tokens</strong>, our <strong>grammar</strong>
+    <span class="nx">alt</span></pre></div>             </td>           </tr>                               <tr id="section-71">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-71">#</a>               </div>               <p>Initialize the <strong>Parser</strong> with our list of terminal <strong>tokens</strong>, our <strong>grammar</strong>
 rules, and the name of the root. Reverse the operators because Jison orders
 precedence from low to high, and we have it high to low
 (as in <a href="http://dinosaur.compilertools.net/yacc/index.html">Yacc</a>).</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.parser: </span><span class="k">new</span> <span class="nx">Parser</span> <span class="p">{</span>

documentation/docs/helpers.html

@@ -0,0 +1,59 @@
+<!DOCTYPE html>  <html> <head>   <title>helpers.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="helpers.html">                 helpers.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               helpers.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>This file contains the common helper functions that we'd like to share among
+the <strong>Lexer</strong>, <strong>Rewriter</strong>, and the <strong>Nodes</strong>. Merge objects, flatten
+arrays, count characters, that sort of thing.</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-2">#</a>               </div>               <p>Set up exported variables for both <strong>Node.js</strong> and the browser.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">this</span><span class="p">.</span><span class="nv">exports: </span><span class="k">this</span> <span class="nx">unless</span> <span class="nx">process</span><span class="o">?</span>
+<span class="nv">helpers: exports.helpers: </span><span class="p">{}</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>Does a list include a value?</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">helpers.include: include: </span><span class="p">(</span><span class="nx">list</span><span class="p">,</span> <span class="nx">value</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">list</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">value</span><span class="p">)</span> <span class="o">&gt;=</span> <span class="mi">0</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <p>Peek at the beginning of a given string to see if it matches a sequence.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">helpers.starts: starts: </span><span class="p">(</span><span class="nx">string</span><span class="p">,</span> <span class="nx">literal</span><span class="p">,</span> <span class="nx">start</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">string</span><span class="p">.</span><span class="nx">substring</span><span class="p">(</span><span class="nx">start</span><span class="p">,</span> <span class="p">(</span><span class="nx">start</span> <span class="o">or</span> <span class="mi">0</span><span class="p">)</span> <span class="o">+</span> <span class="nx">literal</span><span class="p">.</span><span class="nx">length</span><span class="p">)</span> <span class="o">is</span> <span class="nx">literal</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-5">#</a>               </div>               <p>Trim out all falsy values from an array.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">helpers.compact: compact: </span><span class="p">(</span><span class="nx">array</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">item</span> <span class="k">for</span> <span class="nx">item</span> <span class="k">in</span> <span class="nx">array</span> <span class="k">when</span> <span class="nx">item</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-6">#</a>               </div>               <p>Count the number of occurences of a character in a string.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">helpers.count: count: </span><span class="p">(</span><span class="nx">string</span><span class="p">,</span> <span class="nx">letter</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nv">num: </span><span class="mi">0</span>
+  <span class="nv">pos: </span><span class="nx">string</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">letter</span><span class="p">)</span>
+  <span class="k">while</span> <span class="nx">pos</span> <span class="o">isnt</span> <span class="o">-</span><span class="mi">1</span>
+    <span class="nv">num: </span><span class="o">+</span> <span class="mi">1</span>
+    <span class="nv">pos: </span><span class="nx">string</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">letter</span><span class="p">,</span> <span class="nx">pos</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)</span>
+  <span class="nx">num</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-7">#</a>               </div>               <p>Merge objects, returning a fresh copy with attributes from both sides.
+Used every time <code>BaseNode#compile</code> is called, to allow properties in the
+options hash to propagate down the tree without polluting other branches.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">helpers.merge: merge: </span><span class="p">(</span><span class="nx">options</span><span class="p">,</span> <span class="nx">overrides</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nv">fresh: </span><span class="p">{}</span>
+  <span class="p">(</span><span class="nx">fresh</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span><span class="o">:</span> <span class="nx">val</span><span class="p">)</span> <span class="k">for</span> <span class="nx">key</span><span class="p">,</span> <span class="nx">val</span> <span class="k">of</span> <span class="nx">options</span>
+  <span class="p">(</span><span class="nx">fresh</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span><span class="o">:</span> <span class="nx">val</span><span class="p">)</span> <span class="k">for</span> <span class="nx">key</span><span class="p">,</span> <span class="nx">val</span> <span class="k">of</span> <span class="nx">overrides</span> <span class="k">if</span> <span class="nx">overrides</span>
+  <span class="nx">fresh</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-8">#</a>               </div>               <p>Extend a source object with the properties of another object (shallow copy).
+We use this to simulate Node's deprecated <code>process.mixin</code></p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">helpers.extend: extend: </span><span class="p">(</span><span class="nx">object</span><span class="p">,</span> <span class="nx">properties</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="p">(</span><span class="nx">object</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span><span class="o">:</span> <span class="nx">val</span><span class="p">)</span> <span class="k">for</span> <span class="nx">key</span><span class="p">,</span> <span class="nx">val</span> <span class="k">of</span> <span class="nx">properties</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-9">#</a>               </div>               <p>Return a completely flattened version of an array. Handy for getting a
+list of <code>children</code> from the nodes.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">helpers.flatten: flatten: </span><span class="p">(</span><span class="nx">array</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nv">memo: </span><span class="p">[]</span>
+  <span class="k">for</span> <span class="nx">item</span> <span class="k">in</span> <span class="nx">array</span>
+    <span class="k">if</span> <span class="nx">item</span> <span class="k">instanceof</span> <span class="nb">Array</span> <span class="k">then</span> <span class="nv">memo: </span><span class="nx">memo</span><span class="p">.</span><span class="nx">concat</span><span class="p">(</span><span class="nx">item</span><span class="p">)</span> <span class="k">else</span> <span class="nx">memo</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">item</span><span class="p">)</span>
+  <span class="nx">memo</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-10">#</a>               </div>               <p>Delete a key from an object, returning the value. Useful when a node is
+looking for a particular method in an options hash.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">helpers.del: del: </span><span class="p">(</span><span class="nx">obj</span><span class="p">,</span> <span class="nx">key</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nv">val: </span><span class="nx">obj</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span>
+  <span class="k">delete</span> <span class="nx">obj</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span>
+  <span class="nx">val</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-11">#</a>               </div>               <p>Matches a balanced group such as a single or double-quoted string. Pass in
+a series of delimiters, all of which must be nested correctly within the
+contents of the string. This method allows us to have strings within
+interpolations within strings, ad infinitum.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">helpers.balanced_string: balanced_string: </span><span class="p">(</span><span class="nx">str</span><span class="p">,</span> <span class="nx">delimited</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nv">options: </span><span class="o">or</span> <span class="p">{}</span>
+  <span class="nv">slash: </span><span class="nx">delimited</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;/&#39;</span>
+  <span class="nv">levels: </span><span class="p">[]</span>
+  <span class="nv">i: </span><span class="mi">0</span>
+  <span class="k">while</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">str</span><span class="p">.</span><span class="nx">length</span>
+    <span class="k">if</span> <span class="nx">levels</span><span class="p">.</span><span class="nx">length</span> <span class="o">and</span> <span class="nx">starts</span> <span class="nx">str</span><span class="p">,</span> <span class="s1">&#39;\\&#39;</span><span class="p">,</span> <span class="nx">i</span>
+      <span class="nv">i: </span><span class="o">+</span> <span class="mi">1</span>
+    <span class="k">else</span>
+      <span class="k">for</span> <span class="nx">pair</span> <span class="k">in</span> <span class="nx">delimited</span>
+        <span class="p">[</span><span class="nx">open</span><span class="p">,</span> <span class="nx">close</span><span class="p">]</span><span class="o">:</span> <span class="nx">pair</span>
+        <span class="k">if</span> <span class="nx">levels</span><span class="p">.</span><span class="nx">length</span> <span class="o">and</span> <span class="nx">starts</span><span class="p">(</span><span class="nx">str</span><span class="p">,</span> <span class="nx">close</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">and</span> <span class="nx">levels</span><span class="p">[</span><span class="nx">levels</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">is</span> <span class="nx">pair</span>
+          <span class="nx">levels</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
+          <span class="nv">i: </span><span class="o">+</span> <span class="nx">close</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
+          <span class="nv">i: </span><span class="o">+</span> <span class="mi">1</span> <span class="nx">unless</span> <span class="nx">levels</span><span class="p">.</span><span class="nx">length</span>
+          <span class="k">break</span>
+        <span class="k">else</span> <span class="k">if</span> <span class="nx">starts</span> <span class="nx">str</span><span class="p">,</span> <span class="nx">open</span><span class="p">,</span> <span class="nx">i</span>
+          <span class="nx">levels</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">pair</span><span class="p">)</span>
+          <span class="nv">i: </span><span class="o">+</span> <span class="nx">open</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
+          <span class="k">break</span>
+    <span class="k">break</span> <span class="k">if</span> <span class="o">not</span> <span class="nx">levels</span><span class="p">.</span><span class="nx">length</span> <span class="o">or</span> <span class="nx">slash</span> <span class="o">and</span> <span class="nx">starts</span> <span class="nx">str</span><span class="p">,</span> <span class="s1">&#39;\n&#39;</span><span class="p">,</span> <span class="nx">i</span>
+    <span class="nv">i: </span><span class="o">+</span> <span class="mi">1</span>
+  <span class="k">if</span> <span class="nx">levels</span><span class="p">.</span><span class="nx">length</span>
+    <span class="k">return</span> <span class="kc">false</span> <span class="k">if</span> <span class="nx">slash</span>
+    <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;SyntaxError: Unterminated ${levels.pop()[0]} starting on line ${@line + 1}&quot;</span>
+  <span class="k">if</span> <span class="o">not</span> <span class="nx">i</span> <span class="k">then</span> <span class="kc">false</span> <span class="k">else</span> <span class="nx">str</span><span class="p">.</span><span class="nx">substring</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span>
+
+</pre></div>             </td>           </tr>                </tbody>     </table>   </div> </body> </html> 

documentation/docs/lexer.html

@@ -1,4 +1,4 @@
-<!DOCTYPE html>  <html> <head>   <title>lexer.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               lexer.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>The CoffeeScript Lexer. Uses a series of token-matching regexes to attempt
+<!DOCTYPE html>  <html> <head>   <title>lexer.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="helpers.html">                 helpers.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               lexer.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>The CoffeeScript Lexer. Uses a series of token-matching regexes to attempt
 matches against the beginning of the source code. When a match is found,
 a token is produced, we consume the match, and start again. Tokens are in the
 form:</p>
@@ -8,11 +8,17 @@ form:</p>
 
 <p>Which is a format that can be fed directly into <a href="http://github.com/zaach/jison">Jison</a>.</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-2">#</a>               </div>               <p>Set up the Lexer for both Node.js and the browser, depending on where we are.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">if</span> <span class="nx">process</span><span class="o">?</span>
   <span class="nv">Rewriter: </span><span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./rewriter&#39;</span><span class="p">).</span><span class="nx">Rewriter</span>
+  <span class="nv">helpers: </span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./helpers&#39;</span><span class="p">).</span><span class="nx">helpers</span>
 <span class="k">else</span>
   <span class="k">this</span><span class="p">.</span><span class="nv">exports: </span><span class="k">this</span>
-  <span class="nv">Rewriter: </span><span class="k">this</span><span class="p">.</span><span class="nx">Rewriter</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <h2>The Lexer Class</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <p>The Lexer class reads a stream of CoffeeScript and divvys it up into tagged
+  <span class="nv">Rewriter: </span>    <span class="k">this</span><span class="p">.</span><span class="nx">Rewriter</span>
+  <span class="nv">helpers: </span>     <span class="k">this</span><span class="p">.</span><span class="nx">helpers</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>Import the helpers we need.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">include: </span>         <span class="nx">helpers</span><span class="p">.</span><span class="nx">include</span>
+<span class="nv">count: </span>           <span class="nx">helpers</span><span class="p">.</span><span class="nx">count</span>
+<span class="nv">starts: </span>          <span class="nx">helpers</span><span class="p">.</span><span class="nx">starts</span>
+<span class="nv">compact: </span>         <span class="nx">helpers</span><span class="p">.</span><span class="nx">compact</span>
+<span class="nv">balanced_string: </span> <span class="nx">helpers</span><span class="p">.</span><span class="nx">balanced_string</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <h2>The Lexer Class</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-5">#</a>               </div>               <p>The Lexer class reads a stream of CoffeeScript and divvys it up into tagged
 tokens. Some potential ambiguity in the grammar has been avoided by
-pushing some extra smarts into the Lexer.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Lexer: </span><span class="nx">class</span> <span class="nx">Lexer</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-5">#</a>               </div>               <p><strong>tokenize</strong> is the Lexer's main method. Scan by attempting to match tokens
+pushing some extra smarts into the Lexer.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Lexer: </span><span class="nx">class</span> <span class="nx">Lexer</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-6">#</a>               </div>               <p><strong>tokenize</strong> is the Lexer's main method. Scan by attempting to match tokens
 one at a time, using a regular expression anchored at the start of the
 remaining code, or a custom recursive token-matching method
 (for interpolations). When the next token has been recorded, we move forward
@@ -24,88 +30,110 @@ of source.</p>
 
 <p>Before returning the token stream, run it through the <a href="rewriter.html">Rewriter</a>
 unless explicitly asked not to.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">tokenize: </span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="nx">o</span>        <span class="o">:</span> <span class="nx">options</span> <span class="o">or</span> <span class="p">{}</span>
-    <span class="err">@</span><span class="nx">code</span>    <span class="o">:</span> <span class="nx">code</span>         <span class="c1"># The remainder of the source code.</span>
-    <span class="err">@</span><span class="nx">i</span>       <span class="o">:</span> <span class="mi">0</span>            <span class="c1"># Current character position we&#39;re parsing.</span>
-    <span class="err">@</span><span class="nx">line</span>    <span class="o">:</span> <span class="nx">o</span><span class="p">.</span><span class="nx">line</span> <span class="o">or</span> <span class="mi">0</span>  <span class="c1"># The current line.</span>
-    <span class="err">@</span><span class="nx">indent</span>  <span class="o">:</span> <span class="mi">0</span>            <span class="c1"># The current indentation level.</span>
-    <span class="err">@</span><span class="nx">indents</span> <span class="o">:</span> <span class="p">[]</span>           <span class="c1"># The stack of all current indentation levels.</span>
-    <span class="err">@</span><span class="nx">tokens</span>  <span class="o">:</span> <span class="p">[]</span>           <span class="c1"># Stream of parsed tokens in the form [&#39;TYPE&#39;, value, line]</span>
-    <span class="k">while</span> <span class="err">@</span><span class="nx">i</span> <span class="o">&lt;</span> <span class="err">@</span><span class="nx">code</span><span class="p">.</span><span class="nx">length</span>
-      <span class="err">@</span><span class="nv">chunk: </span><span class="err">@</span><span class="nx">code</span><span class="p">.</span><span class="nx">slice</span><span class="p">(</span><span class="err">@</span><span class="nx">i</span><span class="p">)</span>
-      <span class="err">@</span><span class="nx">extract_next_token</span><span class="p">()</span>
-    <span class="err">@</span><span class="nx">close_indentation</span><span class="p">()</span>
-    <span class="k">return</span> <span class="err">@</span><span class="nx">tokens</span> <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">rewrite</span> <span class="o">is</span> <span class="kc">off</span>
-    <span class="p">(</span><span class="k">new</span> <span class="nx">Rewriter</span><span class="p">()).</span><span class="nx">rewrite</span> <span class="err">@</span><span class="nx">tokens</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-6">#</a>               </div>               <p>At every position, run through this list of attempted matches,
+    <span class="nv">code     : </span><span class="nx">code</span><span class="p">.</span><span class="nx">replace</span> <span class="sr">/(\r|\s+$)/g</span><span class="p">,</span> <span class="s1">&#39;&#39;</span>
+    <span class="nv">o        : </span><span class="nx">options</span> <span class="o">or</span> <span class="p">{}</span>
+    <span class="vi">@code    : </span><span class="nx">code</span>         <span class="c1"># The remainder of the source code.</span>
+    <span class="vi">@i       : </span><span class="mi">0</span>            <span class="c1"># Current character position we&#39;re parsing.</span>
+    <span class="vi">@line    : </span><span class="nx">o</span><span class="p">.</span><span class="nx">line</span> <span class="o">or</span> <span class="mi">0</span>  <span class="c1"># The current line.</span>
+    <span class="vi">@indent  : </span><span class="mi">0</span>            <span class="c1"># The current indentation level.</span>
+    <span class="vi">@indents : </span><span class="p">[]</span>           <span class="c1"># The stack of all current indentation levels.</span>
+    <span class="vi">@tokens  : </span><span class="p">[]</span>           <span class="c1"># Stream of parsed tokens in the form [&#39;TYPE&#39;, value, line]</span>
+    <span class="k">while</span> <span class="nx">@i</span> <span class="o">&lt;</span> <span class="nx">@code</span><span class="p">.</span><span class="nx">length</span>
+      <span class="vi">@chunk: </span><span class="nx">@code</span><span class="p">.</span><span class="nx">slice</span> <span class="nx">@i</span>
+      <span class="nx">@extract_next_token</span><span class="p">()</span>
+    <span class="nx">@close_indentation</span><span class="p">()</span>
+    <span class="k">return</span> <span class="nx">@tokens</span> <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">rewrite</span> <span class="o">is</span> <span class="kc">off</span>
+    <span class="p">(</span><span class="k">new</span> <span class="nx">Rewriter</span><span class="p">()).</span><span class="nx">rewrite</span> <span class="nx">@tokens</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-7">#</a>               </div>               <p>At every position, run through this list of attempted matches,
 short-circuiting if any of them succeed. Their order determines precedence:
 <code>@literal_token</code> is the fallback catch-all.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">extract_next_token: </span><span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="k">if</span> <span class="err">@</span><span class="nx">identifier_token</span><span class="p">()</span>
-    <span class="k">return</span> <span class="k">if</span> <span class="err">@</span><span class="nx">number_token</span><span class="p">()</span>
-    <span class="k">return</span> <span class="k">if</span> <span class="err">@</span><span class="nx">heredoc_token</span><span class="p">()</span>
-    <span class="k">return</span> <span class="k">if</span> <span class="err">@</span><span class="nx">regex_token</span><span class="p">()</span>
-    <span class="k">return</span> <span class="k">if</span> <span class="err">@</span><span class="nx">comment_token</span><span class="p">()</span>
-    <span class="k">return</span> <span class="k">if</span> <span class="err">@</span><span class="nx">line_token</span><span class="p">()</span>
-    <span class="k">return</span> <span class="k">if</span> <span class="err">@</span><span class="nx">whitespace_token</span><span class="p">()</span>
-    <span class="k">return</span> <span class="k">if</span> <span class="err">@</span><span class="nx">js_token</span><span class="p">()</span>
-    <span class="k">return</span> <span class="k">if</span> <span class="err">@</span><span class="nx">string_token</span><span class="p">()</span>
-    <span class="k">return</span>    <span class="err">@</span><span class="nx">literal_token</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-7">#</a>               </div>               <h2>Tokenizers</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-8">#</a>               </div>               <p>Matches identifying literals: variables, keywords, method names, etc.
+    <span class="k">return</span> <span class="k">if</span> <span class="nx">@extension_token</span><span class="p">()</span>
+    <span class="k">return</span> <span class="k">if</span> <span class="nx">@identifier_token</span><span class="p">()</span>
+    <span class="k">return</span> <span class="k">if</span> <span class="nx">@number_token</span><span class="p">()</span>
+    <span class="k">return</span> <span class="k">if</span> <span class="nx">@heredoc_token</span><span class="p">()</span>
+    <span class="k">return</span> <span class="k">if</span> <span class="nx">@regex_token</span><span class="p">()</span>
+    <span class="k">return</span> <span class="k">if</span> <span class="nx">@comment_token</span><span class="p">()</span>
+    <span class="k">return</span> <span class="k">if</span> <span class="nx">@line_token</span><span class="p">()</span>
+    <span class="k">return</span> <span class="k">if</span> <span class="nx">@whitespace_token</span><span class="p">()</span>
+    <span class="k">return</span> <span class="k">if</span> <span class="nx">@js_token</span><span class="p">()</span>
+    <span class="k">return</span> <span class="k">if</span> <span class="nx">@string_token</span><span class="p">()</span>
+    <span class="k">return</span>    <span class="nx">@literal_token</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-8">#</a>               </div>               <h2>Tokenizers</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-9">#</a>               </div>               <p>Language extensions get the highest priority, first chance to tag tokens
+as something else.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">extension_token: </span><span class="o">-&gt;</span>
+    <span class="k">for</span> <span class="nx">extension</span> <span class="k">in</span> <span class="nx">Lexer</span><span class="p">.</span><span class="nx">extensions</span>
+      <span class="k">return</span> <span class="kc">true</span> <span class="k">if</span> <span class="nx">extension</span><span class="p">.</span><span class="nx">call</span> <span class="k">this</span>
+    <span class="kc">false</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-10">#</a>               </div>               <p>Matches identifying literals: variables, keywords, method names, etc.
 Check to ensure that JavaScript reserved words aren't being used as
 identifiers. Because CoffeeScript reserves a handful of keywords that are
 allowed in JavaScript, we're careful not to tag them as keywords when
 referenced as property names here, so you can still do <code>jQuery.is()</code> even
 though <code>is</code> means <code>===</code> otherwise.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">identifier_token: </span><span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">id: </span><span class="err">@</span><span class="nx">match</span> <span class="nx">IDENTIFIER</span><span class="p">,</span> <span class="mi">1</span>
-    <span class="err">@</span><span class="nx">name_access_type</span><span class="p">()</span>
+    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">id: </span><span class="nx">@match</span> <span class="nx">IDENTIFIER</span><span class="p">,</span> <span class="mi">1</span>
+    <span class="nx">@name_access_type</span><span class="p">()</span>
+    <span class="nv">accessed: </span><span class="nx">include</span> <span class="nx">ACCESSORS</span><span class="p">,</span> <span class="nx">@tag</span> <span class="mi">0</span>
     <span class="nv">tag: </span><span class="s1">&#39;IDENTIFIER&#39;</span>
-    <span class="nv">tag: </span><span class="nx">id</span><span class="p">.</span><span class="nx">toUpperCase</span><span class="p">()</span> <span class="k">if</span> <span class="nx">include</span><span class="p">(</span><span class="nx">KEYWORDS</span><span class="p">,</span> <span class="nx">id</span><span class="p">)</span> <span class="o">and</span>
-      <span class="o">not</span> <span class="p">(</span><span class="nx">include</span><span class="p">(</span><span class="nx">ACCESSORS</span><span class="p">,</span> <span class="err">@</span><span class="nx">tag</span><span class="p">(</span><span class="mi">0</span><span class="p">))</span> <span class="o">and</span> <span class="o">not</span> <span class="err">@</span><span class="nx">prev</span><span class="p">().</span><span class="nx">spaced</span><span class="p">)</span>
-    <span class="err">@</span><span class="nx">identifier_error</span> <span class="nx">id</span>  <span class="k">if</span> <span class="nx">include</span> <span class="nx">RESERVED</span><span class="p">,</span> <span class="nx">id</span>
-    <span class="nv">tag: </span><span class="s1">&#39;LEADING_WHEN&#39;</span>   <span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;WHEN&#39;</span> <span class="o">and</span> <span class="nx">include</span> <span class="nx">BEFORE_WHEN</span><span class="p">,</span> <span class="err">@</span><span class="nx">tag</span><span class="p">()</span>
-    <span class="err">@</span><span class="nx">token</span><span class="p">(</span><span class="nx">tag</span><span class="p">,</span> <span class="nx">id</span><span class="p">)</span>
-    <span class="err">@</span><span class="nx">i</span> <span class="o">+=</span> <span class="nx">id</span><span class="p">.</span><span class="nx">length</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-9">#</a>               </div>               <p>Matches numbers, including decimals, hex, and exponential notation.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">number_token: </span><span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">number: </span><span class="err">@</span><span class="nx">match</span> <span class="nx">NUMBER</span><span class="p">,</span> <span class="mi">1</span>
-    <span class="err">@</span><span class="nx">token</span> <span class="s1">&#39;NUMBER&#39;</span><span class="p">,</span> <span class="nx">number</span>
-    <span class="err">@</span><span class="nx">i</span> <span class="o">+=</span> <span class="nx">number</span><span class="p">.</span><span class="nx">length</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-10">#</a>               </div>               <p>Matches strings, including multi-line strings. Ensures that quotation marks
+    <span class="nv">tag: </span><span class="nx">id</span><span class="p">.</span><span class="nx">toUpperCase</span><span class="p">()</span>     <span class="k">if</span> <span class="o">not</span> <span class="nx">accessed</span> <span class="o">and</span> <span class="nx">include</span><span class="p">(</span><span class="nx">KEYWORDS</span><span class="p">,</span> <span class="nx">id</span><span class="p">)</span>
+    <span class="nx">@identifier_error</span> <span class="nx">id</span>      <span class="k">if</span> <span class="nx">include</span> <span class="nx">RESERVED</span><span class="p">,</span> <span class="nx">id</span>
+    <span class="nv">tag: </span><span class="s1">&#39;LEADING_WHEN&#39;</span>       <span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;WHEN&#39;</span> <span class="o">and</span> <span class="nx">include</span> <span class="nx">LINE_BREAK</span><span class="p">,</span> <span class="nx">@tag</span><span class="p">()</span>
+    <span class="vi">@i: </span><span class="o">+</span> <span class="nx">id</span><span class="p">.</span><span class="nx">length</span>
+    <span class="k">if</span> <span class="o">not</span> <span class="nx">accessed</span>
+      <span class="nv">tag: id: </span><span class="nx">CONVERSIONS</span><span class="p">[</span><span class="nx">id</span><span class="p">]</span>         <span class="k">if</span> <span class="nx">include</span> <span class="nx">COFFEE_ALIASES</span><span class="p">,</span> <span class="nx">id</span>
+      <span class="k">return</span> <span class="nx">@tag_half_assignment</span> <span class="nx">tag</span>  <span class="k">if</span> <span class="nx">@prev</span><span class="p">()</span> <span class="o">and</span> <span class="nx">@prev</span><span class="p">()[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;ASSIGN&#39;</span> <span class="o">and</span> <span class="nx">include</span> <span class="nx">HALF_ASSIGNMENTS</span><span class="p">,</span> <span class="nx">tag</span>
+    <span class="nx">@token</span> <span class="nx">tag</span><span class="p">,</span> <span class="nx">id</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-11">#</a>               </div>               <p>Matches numbers, including decimals, hex, and exponential notation.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">number_token: </span><span class="o">-&gt;</span>
+    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">number: </span><span class="nx">@match</span> <span class="nx">NUMBER</span><span class="p">,</span> <span class="mi">1</span>
+    <span class="nx">@token</span> <span class="s1">&#39;NUMBER&#39;</span><span class="p">,</span> <span class="nx">number</span>
+    <span class="vi">@i: </span><span class="o">+</span> <span class="nx">number</span><span class="p">.</span><span class="nx">length</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-12">#</a>               </div>               <p>Matches strings, including multi-line strings. Ensures that quotation marks
 are balanced within the string's contents, and within nested interpolations.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">string_token: </span><span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nx">starts</span><span class="p">(</span><span class="err">@</span><span class="nx">chunk</span><span class="p">,</span> <span class="s1">&#39;&quot;&#39;</span><span class="p">)</span> <span class="o">or</span> <span class="nx">starts</span><span class="p">(</span><span class="err">@</span><span class="nx">chunk</span><span class="p">,</span> <span class="s2">&quot;&#39;&quot;</span><span class="p">)</span>
-    <span class="nv">string: </span><span class="err">@</span><span class="nx">balanced_token</span> <span class="p">[</span><span class="s1">&#39;&quot;&#39;</span><span class="p">,</span> <span class="s1">&#39;&quot;&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;${&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">]</span>
-    <span class="nv">string: </span><span class="err">@</span><span class="nx">balanced_token</span> <span class="p">[</span><span class="s2">&quot;&#39;&quot;</span><span class="p">,</span> <span class="s2">&quot;&#39;&quot;</span><span class="p">]</span> <span class="nx">unless</span> <span class="nx">string</span>
-    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nx">string</span>
-    <span class="err">@</span><span class="nx">interpolate_string</span> <span class="nx">string</span><span class="p">.</span><span class="nx">replace</span> <span class="nx">STRING_NEWLINES</span><span class="p">,</span> <span class="s2">&quot; \\\n&quot;</span>
-    <span class="err">@</span><span class="nx">line</span> <span class="o">+=</span> <span class="nx">count</span> <span class="nx">string</span><span class="p">,</span> <span class="s2">&quot;\n&quot;</span>
-    <span class="err">@</span><span class="nx">i</span> <span class="o">+=</span> <span class="nx">string</span><span class="p">.</span><span class="nx">length</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-11">#</a>               </div>               <p>Matches heredocs, adjusting indentation to the correct level, as heredocs
+    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nx">starts</span><span class="p">(</span><span class="nx">@chunk</span><span class="p">,</span> <span class="s1">&#39;&quot;&#39;</span><span class="p">)</span> <span class="o">or</span> <span class="nx">starts</span><span class="p">(</span><span class="nx">@chunk</span><span class="p">,</span> <span class="s2">&quot;&#39;&quot;</span><span class="p">)</span>
+    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">string:</span>
+      <span class="nx">@balanced_token</span><span class="p">([</span><span class="s1">&#39;&quot;&#39;</span><span class="p">,</span> <span class="s1">&#39;&quot;&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;${&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">])</span> <span class="o">or</span>
+      <span class="nx">@balanced_token</span> <span class="p">[</span><span class="s2">&quot;&#39;&quot;</span><span class="p">,</span> <span class="s2">&quot;&#39;&quot;</span><span class="p">]</span>
+    <span class="nx">@interpolate_string</span> <span class="nx">string</span><span class="p">.</span><span class="nx">replace</span> <span class="nx">STRING_NEWLINES</span><span class="p">,</span> <span class="s2">&quot; \\\n&quot;</span>
+    <span class="vi">@line: </span><span class="o">+</span> <span class="nx">count</span> <span class="nx">string</span><span class="p">,</span> <span class="s2">&quot;\n&quot;</span>
+    <span class="vi">@i: </span><span class="o">+</span> <span class="nx">string</span><span class="p">.</span><span class="nx">length</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-13">#</a>               </div>               <p>Matches heredocs, adjusting indentation to the correct level, as heredocs
 preserve whitespace, but ignore indentation to the left.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">heredoc_token: </span><span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nx">match</span> <span class="o">=</span> <span class="err">@</span><span class="nx">chunk</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">HEREDOC</span><span class="p">)</span>
-    <span class="nv">doc: </span><span class="err">@</span><span class="nx">sanitize_heredoc</span> <span class="nx">match</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">or</span> <span class="nx">match</span><span class="p">[</span><span class="mi">4</span><span class="p">]</span>
-    <span class="err">@</span><span class="nx">token</span> <span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s2">&quot;\&quot;$doc\&quot;&quot;</span>
-    <span class="err">@</span><span class="nx">line</span> <span class="o">+=</span> <span class="nx">count</span> <span class="nx">match</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="s2">&quot;\n&quot;</span>
-    <span class="err">@</span><span class="nx">i</span> <span class="o">+=</span> <span class="nx">match</span><span class="p">[</span><span class="mi">1</span><span class="p">].</span><span class="nx">length</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-12">#</a>               </div>               <p>Matches JavaScript interpolated directly into the source via backticks.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">js_token: </span><span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nx">starts</span> <span class="err">@</span><span class="nx">chunk</span><span class="p">,</span> <span class="s1">&#39;`&#39;</span>
-    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">script: </span><span class="err">@</span><span class="nx">balanced_token</span> <span class="p">[</span><span class="s1">&#39;`&#39;</span><span class="p">,</span> <span class="s1">&#39;`&#39;</span><span class="p">]</span>
-    <span class="err">@</span><span class="nx">token</span> <span class="s1">&#39;JS&#39;</span><span class="p">,</span> <span class="nx">script</span><span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="nx">JS_CLEANER</span><span class="p">,</span> <span class="s1">&#39;&#39;</span><span class="p">)</span>
-    <span class="err">@</span><span class="nx">i</span> <span class="o">+=</span> <span class="nx">script</span><span class="p">.</span><span class="nx">length</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-13">#</a>               </div>               <p>Matches regular expression literals. Lexing regular expressions is difficult
+    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">match: </span><span class="nx">@chunk</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">HEREDOC</span><span class="p">)</span>
+    <span class="nv">quote: </span><span class="nx">match</span><span class="p">[</span><span class="mi">1</span><span class="p">].</span><span class="nx">substr</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span>
+    <span class="nv">doc: </span><span class="nx">@sanitize_heredoc</span> <span class="nx">match</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">or</span> <span class="nx">match</span><span class="p">[</span><span class="mi">4</span><span class="p">],</span> <span class="nx">quote</span>
+    <span class="nx">@interpolate_string</span> <span class="s2">&quot;$quote$doc$quote&quot;</span>
+    <span class="vi">@line: </span><span class="o">+</span> <span class="nx">count</span> <span class="nx">match</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="s2">&quot;\n&quot;</span>
+    <span class="vi">@i: </span><span class="o">+</span> <span class="nx">match</span><span class="p">[</span><span class="mi">1</span><span class="p">].</span><span class="nx">length</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-14">#</a>               </div>               <p>Matches JavaScript interpolated directly into the source via backticks.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">js_token: </span><span class="o">-&gt;</span>
+    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nx">starts</span> <span class="nx">@chunk</span><span class="p">,</span> <span class="s1">&#39;`&#39;</span>
+    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">script: </span><span class="nx">@balanced_token</span> <span class="p">[</span><span class="s1">&#39;`&#39;</span><span class="p">,</span> <span class="s1">&#39;`&#39;</span><span class="p">]</span>
+    <span class="nx">@token</span> <span class="s1">&#39;JS&#39;</span><span class="p">,</span> <span class="nx">script</span><span class="p">.</span><span class="nx">replace</span> <span class="nx">JS_CLEANER</span><span class="p">,</span> <span class="s1">&#39;&#39;</span>
+    <span class="vi">@i: </span><span class="o">+</span> <span class="nx">script</span><span class="p">.</span><span class="nx">length</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-15">#</a>               </div>               <p>Matches regular expression literals. Lexing regular expressions is difficult
 to distinguish from division, so we borrow some basic heuristics from
-JavaScript and Ruby.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">regex_token: </span><span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">regex: </span><span class="err">@</span><span class="nx">match</span> <span class="nx">REGEX</span><span class="p">,</span> <span class="mi">1</span>
-    <span class="k">return</span> <span class="kc">false</span> <span class="k">if</span> <span class="nx">include</span> <span class="nx">NOT_REGEX</span><span class="p">,</span> <span class="err">@</span><span class="nx">tag</span><span class="p">()</span>
-    <span class="err">@</span><span class="nx">token</span> <span class="s1">&#39;REGEX&#39;</span><span class="p">,</span> <span class="nx">regex</span>
-    <span class="err">@</span><span class="nx">i</span> <span class="o">+=</span> <span class="nx">regex</span><span class="p">.</span><span class="nx">length</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-14">#</a>               </div>               <p>Matches a token in which which the passed delimiter pairs must be correctly
+JavaScript and Ruby, borrow slash balancing from <code>@balanced_token</code>, and
+borrow interpolation from <code>@interpolate_string</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">regex_token: </span><span class="o">-&gt;</span>
+    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nx">@chunk</span><span class="p">.</span><span class="nx">match</span> <span class="nx">REGEX_START</span>
+    <span class="k">return</span> <span class="kc">false</span> <span class="k">if</span>     <span class="nx">include</span> <span class="nx">NOT_REGEX</span><span class="p">,</span> <span class="nx">@tag</span><span class="p">()</span>
+    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">regex: </span><span class="nx">@balanced_token</span> <span class="p">[</span><span class="s1">&#39;/&#39;</span><span class="p">,</span> <span class="s1">&#39;/&#39;</span><span class="p">]</span>
+    <span class="nv">regex: </span><span class="o">+</span> <span class="p">(</span><span class="nv">flags: </span><span class="nx">@chunk</span><span class="p">.</span><span class="nx">substr</span><span class="p">(</span><span class="nx">regex</span><span class="p">.</span><span class="nx">length</span><span class="p">).</span><span class="nx">match</span> <span class="nx">REGEX_FLAGS</span><span class="p">)</span>
+    <span class="k">if</span> <span class="nx">regex</span><span class="p">.</span><span class="nx">match</span> <span class="nx">REGEX_INTERPOLATION</span>
+      <span class="nv">str: </span><span class="nx">regex</span><span class="p">.</span><span class="nx">substring</span><span class="p">(</span><span class="mi">1</span><span class="p">).</span><span class="nx">split</span><span class="p">(</span><span class="s1">&#39;/&#39;</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span>
+      <span class="nv">str: </span><span class="nx">str</span><span class="p">.</span><span class="nx">replace</span> <span class="nx">REGEX_ESCAPE</span><span class="p">,</span> <span class="p">(</span><span class="nx">escaped</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="s1">&#39;\\&#39;</span> <span class="o">+</span> <span class="nx">escaped</span>
+      <span class="vi">@tokens: </span><span class="nx">@tokens</span><span class="p">.</span><span class="nx">concat</span> <span class="p">[[</span><span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="s1">&#39;(&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;NEW&#39;</span><span class="p">,</span> <span class="s1">&#39;new&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;RegExp&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;CALL_START&#39;</span><span class="p">,</span> <span class="s1">&#39;(&#39;</span><span class="p">]]</span>
+      <span class="nx">@interpolate_string</span> <span class="s2">&quot;\&quot;$str\&quot;&quot;</span><span class="p">,</span> <span class="kc">yes</span>
+      <span class="vi">@tokens: </span><span class="nx">@tokens</span><span class="p">.</span><span class="nx">concat</span> <span class="p">[[</span><span class="s1">&#39;,&#39;</span><span class="p">,</span> <span class="s1">&#39;,&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s2">&quot;\&quot;$flags\&quot;&quot;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">]]</span>
+    <span class="k">else</span>
+      <span class="nx">@token</span> <span class="s1">&#39;REGEX&#39;</span><span class="p">,</span> <span class="nx">regex</span>
+    <span class="vi">@i: </span><span class="o">+</span> <span class="nx">regex</span><span class="p">.</span><span class="nx">length</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-16">#</a>               </div>               <p>Matches a token in which which the passed delimiter pairs must be correctly
 balanced (ie. strings, JS literals).</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">balanced_token: </span><span class="p">(</span><span class="nx">delimited</span><span class="p">...)</span> <span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nx">balanced_string</span> <span class="err">@</span><span class="nx">chunk</span><span class="p">,</span> <span class="nx">delimited</span><span class="p">...</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-15">#</a>               </div>               <p>Matches and conumes comments. We pass through comments into JavaScript,
+    <span class="nx">balanced_string</span> <span class="nx">@chunk</span><span class="p">,</span> <span class="nx">delimited</span></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-17">#</a>               </div>               <p>Matches and conumes comments. We pass through comments into JavaScript,
 so they're treated as real tokens, like any other part of the language.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">comment_token: </span><span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">comment: </span><span class="err">@</span><span class="nx">match</span> <span class="nx">COMMENT</span><span class="p">,</span> <span class="mi">1</span>
-    <span class="err">@</span><span class="nx">line</span> <span class="o">+=</span> <span class="p">(</span><span class="nx">comment</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">MULTILINER</span><span class="p">)</span> <span class="o">or</span> <span class="p">[]).</span><span class="nx">length</span>
-    <span class="nv">lines: </span><span class="nx">comment</span><span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="nx">COMMENT_CLEANER</span><span class="p">,</span> <span class="s1">&#39;&#39;</span><span class="p">).</span><span class="nx">split</span><span class="p">(</span><span class="nx">MULTILINER</span><span class="p">)</span>
-    <span class="err">@</span><span class="nx">token</span> <span class="s1">&#39;COMMENT&#39;</span><span class="p">,</span> <span class="nx">compact</span> <span class="nx">lines</span>
-    <span class="err">@</span><span class="nx">token</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s2">&quot;\n&quot;</span>
-    <span class="err">@</span><span class="nx">i</span> <span class="o">+=</span> <span class="nx">comment</span><span class="p">.</span><span class="nx">length</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-16">#</a>               </div>               <p>Matches newlines, indents, and outdents, and determines which is which.
+    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">comment: </span><span class="nx">@match</span> <span class="nx">COMMENT</span><span class="p">,</span> <span class="mi">1</span>
+    <span class="vi">@line: </span><span class="o">+</span> <span class="p">(</span><span class="nx">comment</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">MULTILINER</span><span class="p">)</span> <span class="o">or</span> <span class="p">[]).</span><span class="nx">length</span>
+    <span class="nv">lines: </span><span class="nx">compact</span> <span class="nx">comment</span><span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="nx">COMMENT_CLEANER</span><span class="p">,</span> <span class="s1">&#39;&#39;</span><span class="p">).</span><span class="nx">split</span> <span class="nx">MULTILINER</span>
+    <span class="nv">i: </span><span class="nx">@tokens</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
+    <span class="k">if</span> <span class="nx">@unfinished</span><span class="p">()</span>
+      <span class="nv">i: </span><span class="o">-</span> <span class="mi">1</span> <span class="k">while</span> <span class="nx">@tokens</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">include</span> <span class="nx">LINE_BREAK</span><span class="p">,</span> <span class="nx">@tokens</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span>
+    <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;COMMENT&#39;</span><span class="p">,</span> <span class="nx">lines</span><span class="p">,</span> <span class="nx">@line</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;\n&#39;</span><span class="p">,</span> <span class="nx">@line</span><span class="p">])</span>
+    <span class="vi">@i: </span><span class="o">+</span> <span class="nx">comment</span><span class="p">.</span><span class="nx">length</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-18">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-18">#</a>               </div>               <p>Matches newlines, indents, and outdents, and determines which is which.
 If we can detect that the current line is continued onto the the next line,
 then the newline is suppressed:</p>
 
@@ -116,128 +144,107 @@ then the newline is suppressed:</p>
 
 <p>Keeps track of the level of indentation, because a single outdent token
 can close multiple indents, so we need to know how far in we happen to be.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">line_token: </span><span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">indent: </span><span class="err">@</span><span class="nx">match</span> <span class="nx">MULTI_DENT</span><span class="p">,</span> <span class="mi">1</span>
-    <span class="err">@</span><span class="nx">line</span> <span class="o">+=</span> <span class="nx">indent</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">MULTILINER</span><span class="p">).</span><span class="nx">length</span>
-    <span class="err">@</span><span class="nx">i</span>    <span class="o">+=</span> <span class="nx">indent</span><span class="p">.</span><span class="nx">length</span>
-    <span class="nv">prev: </span><span class="err">@</span><span class="nx">prev</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
+    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">indent: </span><span class="nx">@match</span> <span class="nx">MULTI_DENT</span><span class="p">,</span> <span class="mi">1</span>
+    <span class="vi">@line: </span><span class="o">+</span> <span class="nx">indent</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">MULTILINER</span><span class="p">).</span><span class="nx">length</span>
+    <span class="vi">@i   : </span><span class="o">+</span> <span class="nx">indent</span><span class="p">.</span><span class="nx">length</span>
+    <span class="nv">prev: </span><span class="nx">@prev</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
     <span class="nv">size: </span><span class="nx">indent</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">LAST_DENTS</span><span class="p">).</span><span class="nx">reverse</span><span class="p">()[</span><span class="mi">0</span><span class="p">].</span><span class="nx">match</span><span class="p">(</span><span class="nx">LAST_DENT</span><span class="p">)[</span><span class="mi">1</span><span class="p">].</span><span class="nx">length</span>
-    <span class="nv">next_character: </span><span class="err">@</span><span class="nx">chunk</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">MULTI_DENT</span><span class="p">)[</span><span class="mi">4</span><span class="p">]</span>
-    <span class="nv">no_newlines: </span><span class="nx">next_character</span> <span class="o">is</span> <span class="s1">&#39;.&#39;</span> <span class="o">or</span> <span class="p">(</span><span class="err">@</span><span class="nx">value</span><span class="p">()</span> <span class="o">and</span> <span class="err">@</span><span class="nx">value</span><span class="p">().</span><span class="nx">match</span><span class="p">(</span><span class="nx">NO_NEWLINE</span><span class="p">)</span> <span class="o">and</span>
-      <span class="nx">prev</span> <span class="o">and</span> <span class="p">(</span><span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">isnt</span> <span class="s1">&#39;.&#39;</span><span class="p">)</span> <span class="o">and</span> <span class="o">not</span> <span class="err">@</span><span class="nx">value</span><span class="p">().</span><span class="nx">match</span><span class="p">(</span><span class="nx">CODE</span><span class="p">))</span>
-    <span class="k">if</span> <span class="nx">size</span> <span class="o">is</span> <span class="err">@</span><span class="nx">indent</span>
-      <span class="k">return</span> <span class="err">@</span><span class="nx">suppress_newlines</span><span class="p">()</span> <span class="k">if</span> <span class="nx">no_newlines</span>
-      <span class="k">return</span> <span class="err">@</span><span class="nx">newline_token</span><span class="p">(</span><span class="nx">indent</span><span class="p">)</span>
-    <span class="k">else</span> <span class="k">if</span> <span class="nx">size</span> <span class="o">&gt;</span> <span class="err">@</span><span class="nx">indent</span>
-      <span class="k">return</span> <span class="err">@</span><span class="nx">suppress_newlines</span><span class="p">()</span> <span class="k">if</span> <span class="nx">no_newlines</span>
-      <span class="nv">diff: </span><span class="nx">size</span> <span class="o">-</span> <span class="err">@</span><span class="nx">indent</span>
-      <span class="err">@</span><span class="nx">token</span> <span class="s1">&#39;INDENT&#39;</span><span class="p">,</span> <span class="nx">diff</span>
-      <span class="err">@</span><span class="nx">indents</span><span class="p">.</span><span class="nx">push</span> <span class="nx">diff</span>
+    <span class="nv">next_character: </span><span class="nx">@chunk</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">MULTI_DENT</span><span class="p">)[</span><span class="mi">4</span><span class="p">]</span>
+    <span class="nv">no_newlines: </span><span class="nx">next_character</span> <span class="o">is</span> <span class="s1">&#39;.&#39;</span> <span class="o">or</span> <span class="nx">@unfinished</span><span class="p">()</span>
+    <span class="k">if</span> <span class="nx">size</span> <span class="o">is</span> <span class="nx">@indent</span>
+      <span class="k">return</span> <span class="nx">@suppress_newlines</span><span class="p">()</span> <span class="k">if</span> <span class="nx">no_newlines</span>
+      <span class="k">return</span> <span class="nx">@newline_token</span> <span class="nx">indent</span>
+    <span class="k">else</span> <span class="k">if</span> <span class="nx">size</span> <span class="o">&gt;</span> <span class="nx">@indent</span>
+      <span class="k">return</span> <span class="nx">@suppress_newlines</span><span class="p">()</span> <span class="k">if</span> <span class="nx">no_newlines</span>
+      <span class="nv">diff: </span><span class="nx">size</span> <span class="o">-</span> <span class="nx">@indent</span>
+      <span class="nx">@token</span> <span class="s1">&#39;INDENT&#39;</span><span class="p">,</span> <span class="nx">diff</span>
+      <span class="nx">@indents</span><span class="p">.</span><span class="nx">push</span> <span class="nx">diff</span>
     <span class="k">else</span>
-      <span class="err">@</span><span class="nx">outdent_token</span> <span class="err">@</span><span class="nx">indent</span> <span class="o">-</span> <span class="nx">size</span><span class="p">,</span> <span class="nx">no_newlines</span>
-    <span class="err">@</span><span class="nv">indent: </span><span class="nx">size</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-17">#</a>               </div>               <p>Record an outdent token or multiple tokens, if we happen to be moving back
+      <span class="nx">@outdent_token</span> <span class="nx">@indent</span> <span class="o">-</span> <span class="nx">size</span><span class="p">,</span> <span class="nx">no_newlines</span>
+    <span class="vi">@indent: </span><span class="nx">size</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-19">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-19">#</a>               </div>               <p>Record an outdent token or multiple tokens, if we happen to be moving back
 inwards past several recorded indents.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">outdent_token: </span><span class="p">(</span><span class="nx">move_out</span><span class="p">,</span> <span class="nx">no_newlines</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">while</span> <span class="nx">move_out</span> <span class="o">&gt;</span> <span class="mi">0</span> <span class="o">and</span> <span class="err">@</span><span class="nx">indents</span><span class="p">.</span><span class="nx">length</span>
-      <span class="nv">last_indent: </span><span class="err">@</span><span class="nx">indents</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
-      <span class="err">@</span><span class="nx">token</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">,</span> <span class="nx">last_indent</span>
-      <span class="nx">move_out</span> <span class="o">-=</span> <span class="nx">last_indent</span>
-    <span class="err">@</span><span class="nx">token</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s2">&quot;\n&quot;</span> <span class="nx">unless</span> <span class="err">@</span><span class="nx">tag</span><span class="p">()</span> <span class="o">is</span> <span class="s1">&#39;TERMINATOR&#39;</span> <span class="o">or</span> <span class="nx">no_newlines</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-18">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-18">#</a>               </div>               <p>Matches and consumes non-meaningful whitespace. Tag the previous token
+    <span class="k">while</span> <span class="nx">move_out</span> <span class="o">&gt;</span> <span class="mi">0</span> <span class="o">and</span> <span class="nx">@indents</span><span class="p">.</span><span class="nx">length</span>
+      <span class="nv">last_indent: </span><span class="nx">@indents</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
+      <span class="nx">@token</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">,</span> <span class="nx">last_indent</span>
+      <span class="nv">move_out: </span><span class="o">-</span> <span class="nx">last_indent</span>
+    <span class="nx">@token</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s2">&quot;\n&quot;</span> <span class="nx">unless</span> <span class="nx">@tag</span><span class="p">()</span> <span class="o">is</span> <span class="s1">&#39;TERMINATOR&#39;</span> <span class="o">or</span> <span class="nx">no_newlines</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-20">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-20">#</a>               </div>               <p>Matches and consumes non-meaningful whitespace. Tag the previous token
 as being "spaced", because there are some cases where it makes a difference.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">whitespace_token: </span><span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">space: </span><span class="err">@</span><span class="nx">match</span> <span class="nx">WHITESPACE</span><span class="p">,</span> <span class="mi">1</span>
-    <span class="nv">prev: </span><span class="err">@</span><span class="nx">prev</span><span class="p">()</span>
+    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">space: </span><span class="nx">@match</span> <span class="nx">WHITESPACE</span><span class="p">,</span> <span class="mi">1</span>
+    <span class="nv">prev: </span><span class="nx">@prev</span><span class="p">()</span>
     <span class="nv">prev.spaced: </span><span class="kc">true</span> <span class="k">if</span> <span class="nx">prev</span>
-    <span class="err">@</span><span class="nx">i</span> <span class="o">+=</span> <span class="nx">space</span><span class="p">.</span><span class="nx">length</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-19">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-19">#</a>               </div>               <p>Generate a newline token. Consecutive newlines get merged together.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">newline_token: </span><span class="p">(</span><span class="nx">newlines</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nx">token</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s2">&quot;\n&quot;</span> <span class="nx">unless</span> <span class="err">@</span><span class="nx">tag</span><span class="p">()</span> <span class="o">is</span> <span class="s1">&#39;TERMINATOR&#39;</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-20">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-20">#</a>               </div>               <p>Use a <code>\</code> at a line-ending to suppress the newline.
+    <span class="vi">@i: </span><span class="o">+</span> <span class="nx">space</span><span class="p">.</span><span class="nx">length</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-21">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-21">#</a>               </div>               <p>Generate a newline token. Consecutive newlines get merged together.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">newline_token: </span><span class="p">(</span><span class="nx">newlines</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="nx">@token</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s2">&quot;\n&quot;</span> <span class="nx">unless</span> <span class="nx">@tag</span><span class="p">()</span> <span class="o">is</span> <span class="s1">&#39;TERMINATOR&#39;</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-22">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-22">#</a>               </div>               <p>Use a <code>\</code> at a line-ending to suppress the newline.
 The slash is removed here once its job is done.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">suppress_newlines: </span><span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span> <span class="k">if</span> <span class="err">@</span><span class="nx">value</span><span class="p">()</span> <span class="o">is</span> <span class="s2">&quot;\\&quot;</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-21">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-21">#</a>               </div>               <p>We treat all other single characters as a token. Eg.: <code>( ) , . !</code>
+    <span class="nx">@tokens</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span> <span class="k">if</span> <span class="nx">@value</span><span class="p">()</span> <span class="o">is</span> <span class="s2">&quot;\\&quot;</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-23">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-23">#</a>               </div>               <p>We treat all other single characters as a token. Eg.: <code>( ) , . !</code>
 Multi-character operators are also literal tokens, so that Jison can assign
 the proper order of operations. There are some symbols that we tag specially
 here. <code>;</code> and newlines are both treated as a <code>TERMINATOR</code>, we distinguish
 parentheses that indicate a method call from regular parentheses, and so on.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">literal_token: </span><span class="o">-&gt;</span>
-    <span class="nv">match: </span><span class="err">@</span><span class="nx">chunk</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">OPERATOR</span><span class="p">)</span>
+    <span class="nv">match: </span><span class="nx">@chunk</span><span class="p">.</span><span class="nx">match</span> <span class="nx">OPERATOR</span>
     <span class="nv">value: </span><span class="nx">match</span> <span class="o">and</span> <span class="nx">match</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
-    <span class="err">@</span><span class="nx">tag_parameters</span><span class="p">()</span> <span class="k">if</span> <span class="nx">value</span> <span class="o">and</span> <span class="nx">value</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">CODE</span><span class="p">)</span>
-    <span class="nx">value</span> <span class="o">||=</span> <span class="err">@</span><span class="nx">chunk</span><span class="p">.</span><span class="nx">substr</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
-    <span class="nv">not_spaced: </span><span class="o">not</span> <span class="err">@</span><span class="nx">prev</span><span class="p">()</span> <span class="o">or</span> <span class="o">not</span> <span class="err">@</span><span class="nx">prev</span><span class="p">().</span><span class="nx">spaced</span>
+    <span class="nv">space: </span><span class="nx">match</span> <span class="o">and</span> <span class="nx">match</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
+    <span class="nx">@tag_parameters</span><span class="p">()</span> <span class="k">if</span> <span class="nx">value</span> <span class="o">and</span> <span class="nx">value</span><span class="p">.</span><span class="nx">match</span> <span class="nx">CODE</span>
+    <span class="nv">value: </span><span class="o">or</span> <span class="nx">@chunk</span><span class="p">.</span><span class="nx">substr</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span>
+    <span class="nv">prev_spaced: </span><span class="nx">@prev</span><span class="p">()</span> <span class="o">and</span> <span class="nx">@prev</span><span class="p">().</span><span class="nx">spaced</span>
     <span class="nv">tag: </span><span class="nx">value</span>
-    <span class="k">if</span> <span class="nx">value</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">ASSIGNMENT</span><span class="p">)</span>
+    <span class="k">if</span> <span class="nx">value</span><span class="p">.</span><span class="nx">match</span> <span class="nx">ASSIGNMENT</span>
       <span class="nv">tag: </span><span class="s1">&#39;ASSIGN&#39;</span>
-      <span class="err">@</span><span class="nx">assignment_error</span><span class="p">()</span> <span class="k">if</span> <span class="nx">include</span> <span class="nx">JS_FORBIDDEN</span><span class="p">,</span> <span class="err">@</span><span class="nx">value</span>
+      <span class="nx">@assignment_error</span><span class="p">()</span> <span class="k">if</span> <span class="nx">include</span> <span class="nx">JS_FORBIDDEN</span><span class="p">,</span> <span class="nx">@value</span>
     <span class="k">else</span> <span class="k">if</span> <span class="nx">value</span> <span class="o">is</span> <span class="s1">&#39;;&#39;</span>
       <span class="nv">tag: </span><span class="s1">&#39;TERMINATOR&#39;</span>
-    <span class="k">else</span> <span class="k">if</span> <span class="nx">value</span> <span class="o">is</span> <span class="s1">&#39;[&#39;</span> <span class="o">and</span> <span class="err">@</span><span class="nx">tag</span><span class="p">()</span> <span class="o">is</span> <span class="s1">&#39;?&#39;</span> <span class="o">and</span> <span class="nx">not_spaced</span>
+    <span class="k">else</span> <span class="k">if</span> <span class="nx">value</span> <span class="o">is</span> <span class="s1">&#39;[&#39;</span> <span class="o">and</span> <span class="nx">@tag</span><span class="p">()</span> <span class="o">is</span> <span class="s1">&#39;?&#39;</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">prev_spaced</span>
       <span class="nv">tag: </span><span class="s1">&#39;SOAKED_INDEX_START&#39;</span>
-      <span class="err">@</span><span class="nv">soaked_index: </span><span class="kc">true</span>
-      <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
-    <span class="k">else</span> <span class="k">if</span> <span class="nx">value</span> <span class="o">is</span> <span class="s1">&#39;]&#39;</span> <span class="o">and</span> <span class="err">@</span><span class="nx">soaked_index</span>
+      <span class="vi">@soaked_index: </span><span class="kc">true</span>
+      <span class="nx">@tokens</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
+    <span class="k">else</span> <span class="k">if</span> <span class="nx">value</span> <span class="o">is</span> <span class="s1">&#39;]&#39;</span> <span class="o">and</span> <span class="nx">@soaked_index</span>
       <span class="nv">tag: </span><span class="s1">&#39;SOAKED_INDEX_END&#39;</span>
-      <span class="err">@</span><span class="nv">soaked_index: </span><span class="kc">false</span>
-    <span class="k">else</span> <span class="k">if</span> <span class="nx">include</span><span class="p">(</span><span class="nx">CALLABLE</span><span class="p">,</span> <span class="err">@</span><span class="nx">tag</span><span class="p">())</span> <span class="o">and</span> <span class="nx">not_spaced</span>
+      <span class="vi">@soaked_index: </span><span class="kc">false</span>
+    <span class="k">else</span> <span class="k">if</span> <span class="nx">include</span><span class="p">(</span><span class="nx">CALLABLE</span><span class="p">,</span> <span class="nx">@tag</span><span class="p">())</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">prev_spaced</span>
       <span class="nv">tag: </span><span class="s1">&#39;CALL_START&#39;</span>  <span class="k">if</span> <span class="nx">value</span> <span class="o">is</span> <span class="s1">&#39;(&#39;</span>
       <span class="nv">tag: </span><span class="s1">&#39;INDEX_START&#39;</span> <span class="k">if</span> <span class="nx">value</span> <span class="o">is</span> <span class="s1">&#39;[&#39;</span>
-    <span class="err">@</span><span class="nx">token</span> <span class="nx">tag</span><span class="p">,</span> <span class="nx">value</span>
-    <span class="err">@</span><span class="nx">i</span> <span class="o">+=</span> <span class="nx">value</span><span class="p">.</span><span class="nx">length</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-22">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-22">#</a>               </div>               <h2>Token Manipulators</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-23">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-23">#</a>               </div>               <p>As we consume a new <code>IDENTIFIER</code>, look at the previous token to determine
+    <span class="vi">@i: </span><span class="o">+</span> <span class="nx">value</span><span class="p">.</span><span class="nx">length</span>
+    <span class="k">return</span> <span class="nx">@tag_half_assignment</span> <span class="nx">tag</span> <span class="k">if</span> <span class="nx">space</span> <span class="o">and</span> <span class="nx">prev_spaced</span> <span class="o">and</span> <span class="nx">@prev</span><span class="p">()[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;ASSIGN&#39;</span> <span class="o">and</span> <span class="nx">include</span> <span class="nx">HALF_ASSIGNMENTS</span><span class="p">,</span> <span class="nx">tag</span>
+    <span class="nx">@token</span> <span class="nx">tag</span><span class="p">,</span> <span class="nx">value</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-24">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-24">#</a>               </div>               <h2>Token Manipulators</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-25">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-25">#</a>               </div>               <p>As we consume a new <code>IDENTIFIER</code>, look at the previous token to determine
 if it's a special kind of accessor.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">name_access_type: </span><span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nx">tag</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="s1">&#39;PROTOTYPE_ACCESS&#39;</span><span class="p">)</span> <span class="k">if</span> <span class="err">@</span><span class="nx">value</span><span class="p">()</span> <span class="o">is</span> <span class="s1">&#39;::&#39;</span>
-    <span class="k">if</span> <span class="err">@</span><span class="nx">value</span><span class="p">()</span> <span class="o">is</span> <span class="s1">&#39;.&#39;</span> <span class="o">and</span> <span class="o">not</span> <span class="p">(</span><span class="err">@</span><span class="nx">value</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span> <span class="o">is</span> <span class="s1">&#39;.&#39;</span><span class="p">)</span>
-      <span class="k">if</span> <span class="err">@</span><span class="nx">tag</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span> <span class="o">is</span> <span class="s1">&#39;?&#39;</span>
-        <span class="err">@</span><span class="nx">tag</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="s1">&#39;SOAK_ACCESS&#39;</span><span class="p">)</span>
-        <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
+    <span class="nx">@tag</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="s1">&#39;PROTOTYPE_ACCESS&#39;</span><span class="p">)</span> <span class="k">if</span> <span class="nx">@value</span><span class="p">()</span> <span class="o">is</span> <span class="s1">&#39;::&#39;</span>
+    <span class="k">if</span> <span class="nx">@value</span><span class="p">()</span> <span class="o">is</span> <span class="s1">&#39;.&#39;</span> <span class="o">and</span> <span class="o">not</span> <span class="p">(</span><span class="nx">@value</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span> <span class="o">is</span> <span class="s1">&#39;.&#39;</span><span class="p">)</span>
+      <span class="k">if</span> <span class="nx">@tag</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span> <span class="o">is</span> <span class="s1">&#39;?&#39;</span>
+        <span class="nx">@tag</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="s1">&#39;SOAK_ACCESS&#39;</span><span class="p">)</span>
+        <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
       <span class="k">else</span>
-        <span class="err">@</span><span class="nx">tag</span> <span class="mi">1</span><span class="p">,</span> <span class="s1">&#39;PROPERTY_ACCESS&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-24">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-24">#</a>               </div>               <p>Sanitize a heredoc by escaping internal double quotes and erasing all
-external indentation on the left-hand side.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">sanitize_heredoc: </span><span class="p">(</span><span class="nx">doc</span><span class="p">)</span> <span class="o">-&gt;</span>
+        <span class="nx">@tag</span> <span class="mi">1</span><span class="p">,</span> <span class="s1">&#39;PROPERTY_ACCESS&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-26">#</a>               </div>               <p>Sanitize a heredoc by escaping internal double quotes and erasing all
+external indentation on the left-hand side.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">sanitize_heredoc: </span><span class="p">(</span><span class="nx">doc</span><span class="p">,</span> <span class="nx">quote</span><span class="p">)</span> <span class="o">-&gt;</span>
     <span class="nv">indent: </span><span class="p">(</span><span class="nx">doc</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">HEREDOC_INDENT</span><span class="p">)</span> <span class="o">or</span> <span class="p">[</span><span class="s1">&#39;&#39;</span><span class="p">]).</span><span class="nx">sort</span><span class="p">()[</span><span class="mi">0</span><span class="p">]</span>
     <span class="nx">doc</span><span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="k">new</span> <span class="nb">RegExp</span><span class="p">(</span><span class="s2">&quot;^&quot;</span> <span class="o">+</span><span class="nx">indent</span><span class="p">,</span> <span class="s1">&#39;gm&#39;</span><span class="p">),</span> <span class="s1">&#39;&#39;</span><span class="p">)</span>
        <span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="nx">MULTILINER</span><span class="p">,</span> <span class="s2">&quot;\\n&quot;</span><span class="p">)</span>
-       <span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="sr">/&quot;/g</span><span class="p">,</span> <span class="s1">&#39;\\&quot;&#39;</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-25">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-25">#</a>               </div>               <p>A source of ambiguity in our grammar used to be parameter lists in function
+       <span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="k">new</span> <span class="nb">RegExp</span><span class="p">(</span><span class="nx">quote</span><span class="p">,</span> <span class="s1">&#39;g&#39;</span><span class="p">),</span> <span class="s1">&#39;\\&quot;&#39;</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-27">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-27">#</a>               </div>               <p>Tag a half assignment.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">tag_half_assignment: </span><span class="p">(</span><span class="nx">tag</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="nv">last: </span><span class="nx">@tokens</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
+    <span class="nx">@tokens</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="s2">&quot;$tag=&quot;</span><span class="p">,</span> <span class="s2">&quot;$tag=&quot;</span><span class="p">,</span> <span class="nx">last</span><span class="p">[</span><span class="mi">2</span><span class="p">]]</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-28">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-28">#</a>               </div>               <p>A source of ambiguity in our grammar used to be parameter lists in function
 definitions versus argument lists in function calls. Walk backwards, tagging
 parameters specially in order to make things easier for the parser.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">tag_parameters: </span><span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="k">if</span> <span class="err">@</span><span class="nx">tag</span><span class="p">()</span> <span class="o">isnt</span> <span class="s1">&#39;)&#39;</span>
+    <span class="k">return</span> <span class="k">if</span> <span class="nx">@tag</span><span class="p">()</span> <span class="o">isnt</span> <span class="s1">&#39;)&#39;</span>
     <span class="nv">i: </span><span class="mi">0</span>
     <span class="k">while</span> <span class="kc">true</span>
-      <span class="nx">i</span> <span class="o">+=</span> <span class="mi">1</span>
-      <span class="nv">tok: </span><span class="err">@</span><span class="nx">prev</span><span class="p">(</span><span class="nx">i</span><span class="p">)</span>
+      <span class="nv">i: </span><span class="o">+</span> <span class="mi">1</span>
+      <span class="nv">tok: </span><span class="nx">@prev</span> <span class="nx">i</span>
       <span class="k">return</span> <span class="k">if</span> <span class="o">not</span> <span class="nx">tok</span>
       <span class="k">switch</span> <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
         <span class="k">when</span> <span class="s1">&#39;IDENTIFIER&#39;</span> <span class="k">then</span> <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">:</span> <span class="s1">&#39;PARAM&#39;</span>
         <span class="k">when</span> <span class="s1">&#39;)&#39;</span>          <span class="k">then</span> <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">:</span> <span class="s1">&#39;PARAM_END&#39;</span>
         <span class="k">when</span> <span class="s1">&#39;(&#39;</span>          <span class="k">then</span> <span class="k">return</span> <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">:</span> <span class="s1">&#39;PARAM_START&#39;</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-26">#</a>               </div>               <p>Close up all remaining open blocks at the end of the file.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">close_indentation: </span><span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nx">outdent_token</span><span class="p">(</span><span class="err">@</span><span class="nx">indent</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-27">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-27">#</a>               </div>               <p>The error for when you try to use a forbidden word in JavaScript as
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-29">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-29">#</a>               </div>               <p>Close up all remaining open blocks at the end of the file.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">close_indentation: </span><span class="o">-&gt;</span>
+    <span class="nx">@outdent_token</span> <span class="nx">@indent</span></pre></div>             </td>           </tr>                               <tr id="section-30">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-30">#</a>               </div>               <p>The error for when you try to use a forbidden word in JavaScript as
 an identifier.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">identifier_error: </span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;SyntaxError: Reserved word \&quot;$word\&quot; on line ${@line + 1}&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-28">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-28">#</a>               </div>               <p>The error for when you try to assign to a reserved word in JavaScript,
+    <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;SyntaxError: Reserved word \&quot;$word\&quot; on line ${@line + 1}&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-31">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-31">#</a>               </div>               <p>The error for when you try to assign to a reserved word in JavaScript,
 like "function" or "default".</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">assignment_error: </span><span class="o">-&gt;</span>
-    <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;SyntaxError: Reserved word \&quot;${@value()}\&quot; on line ${@line + 1} can&#39;t be assigned&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-29">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-29">#</a>               </div>               <p>Matches a balanced group such as a single or double-quoted string. Pass in
-a series of delimiters, all of which must be nested correctly within the
-contents of the string. This method allows us to have strings within
-interpolations within strings etc...</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">balanced_string: </span><span class="p">(</span><span class="nx">str</span><span class="p">,</span> <span class="nx">delimited</span><span class="p">...)</span> <span class="o">-&gt;</span>
-    <span class="nv">levels: </span><span class="p">[]</span>
-    <span class="nv">i: </span><span class="mi">0</span>
-    <span class="k">while</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">str</span><span class="p">.</span><span class="nx">length</span>
-      <span class="k">for</span> <span class="nx">pair</span> <span class="k">in</span> <span class="nx">delimited</span>
-        <span class="p">[</span><span class="nx">open</span><span class="p">,</span> <span class="nx">close</span><span class="p">]</span><span class="o">:</span> <span class="nx">pair</span>
-        <span class="k">if</span> <span class="nx">levels</span><span class="p">.</span><span class="nx">length</span> <span class="o">and</span> <span class="nx">starts</span> <span class="nx">str</span><span class="p">,</span> <span class="s1">&#39;\\&#39;</span><span class="p">,</span> <span class="nx">i</span>
-          <span class="nx">i</span> <span class="o">+=</span> <span class="mi">1</span>
-          <span class="k">break</span>
-        <span class="k">else</span> <span class="k">if</span> <span class="nx">levels</span><span class="p">.</span><span class="nx">length</span> <span class="o">and</span> <span class="nx">starts</span><span class="p">(</span><span class="nx">str</span><span class="p">,</span> <span class="nx">close</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">and</span> <span class="nx">levels</span><span class="p">[</span><span class="nx">levels</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">is</span> <span class="nx">pair</span>
-          <span class="nx">levels</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
-          <span class="nx">i</span> <span class="o">+=</span> <span class="nx">close</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
-          <span class="nx">i</span> <span class="o">+=</span> <span class="mi">1</span> <span class="nx">unless</span> <span class="nx">levels</span><span class="p">.</span><span class="nx">length</span>
-          <span class="k">break</span>
-        <span class="k">else</span> <span class="k">if</span> <span class="nx">starts</span> <span class="nx">str</span><span class="p">,</span> <span class="nx">open</span><span class="p">,</span> <span class="nx">i</span>
-          <span class="nx">levels</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">pair</span><span class="p">)</span>
-          <span class="nx">i</span> <span class="o">+=</span> <span class="nx">open</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
-          <span class="k">break</span>
-      <span class="k">break</span> <span class="nx">unless</span> <span class="nx">levels</span><span class="p">.</span><span class="nx">length</span>
-      <span class="nx">i</span> <span class="o">+=</span> <span class="mi">1</span>
-    <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;SyntaxError: Unterminated ${levels.pop()[0]} starting on line ${@line + 1}&quot;</span> <span class="k">if</span> <span class="nx">levels</span><span class="p">.</span><span class="nx">length</span>
-    <span class="k">return</span> <span class="kc">false</span> <span class="k">if</span> <span class="nx">i</span> <span class="o">is</span> <span class="mi">0</span>
-    <span class="k">return</span> <span class="nx">str</span><span class="p">.</span><span class="nx">substring</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-30">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-30">#</a>               </div>               <p>Expand variables and expressions inside double-quoted strings using
+    <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;SyntaxError: Reserved word \&quot;${@value()}\&quot; on line ${@line + 1} can&#39;t be assigned&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-32">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-32">#</a>               </div>               <p>Expand variables and expressions inside double-quoted strings using
 <a href="http://wiki.ecmascript.org/doku.php?id=strawman:string_interpolation">ECMA Harmony's interpolation syntax</a>
 for substitution of bare variables as well as arbitrary expressions.</p>
 
@@ -247,54 +254,63 @@ for substitution of bare variables as well as arbitrary expressions.</p>
 
 <p>If it encounters an interpolation, this method will recursively create a
 new Lexer, tokenize the interpolated contents, and merge them into the
-token stream.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">interpolate_string: </span><span class="p">(</span><span class="nx">str</span><span class="p">)</span> <span class="o">-&gt;</span>
+token stream.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">interpolate_string: </span><span class="p">(</span><span class="nx">str</span><span class="p">,</span> <span class="nx">escape_quotes</span><span class="p">)</span> <span class="o">-&gt;</span>
     <span class="k">if</span> <span class="nx">str</span><span class="p">.</span><span class="nx">length</span> <span class="o">&lt;</span> <span class="mi">3</span> <span class="o">or</span> <span class="o">not</span> <span class="nx">starts</span> <span class="nx">str</span><span class="p">,</span> <span class="s1">&#39;&quot;&#39;</span>
-      <span class="err">@</span><span class="nx">token</span> <span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="nx">str</span>
+      <span class="nx">@token</span> <span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="nx">str</span>
     <span class="k">else</span>
       <span class="nv">lexer: </span>   <span class="k">new</span> <span class="nx">Lexer</span><span class="p">()</span>
       <span class="nv">tokens: </span>  <span class="p">[]</span>
-      <span class="nv">quote: </span>   <span class="nx">str</span><span class="p">.</span><span class="nx">substring</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
+      <span class="nv">quote: </span>   <span class="nx">str</span><span class="p">.</span><span class="nx">substring</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span>
       <span class="p">[</span><span class="nx">i</span><span class="p">,</span> <span class="nx">pi</span><span class="p">]</span><span class="o">:</span>  <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">]</span>
       <span class="k">while</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">str</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
         <span class="k">if</span> <span class="nx">starts</span> <span class="nx">str</span><span class="p">,</span> <span class="s1">&#39;\\&#39;</span><span class="p">,</span> <span class="nx">i</span>
-          <span class="nx">i</span> <span class="o">+=</span> <span class="mi">1</span>
+          <span class="nv">i: </span><span class="o">+</span> <span class="mi">1</span>
         <span class="k">else</span> <span class="k">if</span> <span class="nv">match: </span><span class="nx">str</span><span class="p">.</span><span class="nx">substring</span><span class="p">(</span><span class="nx">i</span><span class="p">).</span><span class="nx">match</span> <span class="nx">INTERPOLATION</span>
           <span class="p">[</span><span class="nx">group</span><span class="p">,</span> <span class="nx">interp</span><span class="p">]</span><span class="o">:</span> <span class="nx">match</span>
           <span class="nv">interp: </span><span class="s2">&quot;this.${ interp.substring(1) }&quot;</span> <span class="k">if</span> <span class="nx">starts</span> <span class="nx">interp</span><span class="p">,</span> <span class="s1">&#39;@&#39;</span>
           <span class="nx">tokens</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s2">&quot;$quote${ str.substring(pi, i) }$quote&quot;</span><span class="p">]</span> <span class="k">if</span> <span class="nx">pi</span> <span class="o">&lt;</span> <span class="nx">i</span>
           <span class="nx">tokens</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="nx">interp</span><span class="p">]</span>
-          <span class="nx">i</span> <span class="o">+=</span> <span class="nx">group</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
+          <span class="nv">i: </span><span class="o">+</span> <span class="nx">group</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
           <span class="nv">pi: </span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span>
-        <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="nv">expr: </span><span class="err">@</span><span class="nx">balanced_string</span> <span class="nx">str</span><span class="p">.</span><span class="nx">substring</span><span class="p">(</span><span class="nx">i</span><span class="p">),</span> <span class="p">[</span><span class="s1">&#39;${&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">])</span>
+        <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="nv">expr: </span><span class="nx">balanced_string</span> <span class="nx">str</span><span class="p">.</span><span class="nx">substring</span><span class="p">(</span><span class="nx">i</span><span class="p">),</span> <span class="p">[[</span><span class="s1">&#39;${&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">]])</span>
           <span class="nx">tokens</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s2">&quot;$quote${ str.substring(pi, i) }$quote&quot;</span><span class="p">]</span> <span class="k">if</span> <span class="nx">pi</span> <span class="o">&lt;</span> <span class="nx">i</span>
           <span class="nv">inner: </span><span class="nx">expr</span><span class="p">.</span><span class="nx">substring</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span>
           <span class="k">if</span> <span class="nx">inner</span><span class="p">.</span><span class="nx">length</span>
-            <span class="nv">nested: </span><span class="nx">lexer</span><span class="p">.</span><span class="nx">tokenize</span> <span class="s2">&quot;($inner)&quot;</span><span class="p">,</span> <span class="p">{</span><span class="nv">rewrite: </span><span class="kc">no</span><span class="p">,</span> <span class="nv">line: </span><span class="err">@</span><span class="nx">line</span><span class="p">}</span>
+            <span class="nv">nested: </span><span class="nx">lexer</span><span class="p">.</span><span class="nx">tokenize</span> <span class="s2">&quot;($inner)&quot;</span><span class="p">,</span> <span class="p">{</span><span class="nv">rewrite: </span><span class="kc">no</span><span class="p">,</span> <span class="nv">line: </span><span class="nx">@line</span><span class="p">}</span>
             <span class="nx">nested</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
             <span class="nx">tokens</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="s1">&#39;TOKENS&#39;</span><span class="p">,</span> <span class="nx">nested</span><span class="p">]</span>
           <span class="k">else</span>
             <span class="nx">tokens</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s2">&quot;$quote$quote&quot;</span><span class="p">]</span>
-          <span class="nx">i</span> <span class="o">+=</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
+          <span class="nv">i: </span><span class="o">+</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
           <span class="nv">pi: </span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span>
-        <span class="nx">i</span> <span class="o">+=</span> <span class="mi">1</span>
+        <span class="nv">i: </span><span class="o">+</span> <span class="mi">1</span>
       <span class="nx">tokens</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s2">&quot;$quote${ str.substring(pi, i) }$quote&quot;</span><span class="p">]</span> <span class="k">if</span> <span class="nx">pi</span> <span class="o">&lt;</span> <span class="nx">i</span> <span class="o">and</span> <span class="nx">pi</span> <span class="o">&lt;</span> <span class="nx">str</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
-      <span class="k">for</span> <span class="nx">each</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">tokens</span>
-        <span class="k">if</span> <span class="nx">each</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;TOKENS&#39;</span>
-          <span class="err">@</span><span class="nv">tokens: </span><span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">each</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
+      <span class="nx">tokens</span><span class="p">.</span><span class="nx">unshift</span> <span class="p">[</span><span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s1">&#39;&quot;&quot;&#39;</span><span class="p">]</span> <span class="nx">unless</span> <span class="nx">tokens</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;STRING&#39;</span>
+      <span class="k">for</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">tokens</span>
+        <span class="p">[</span><span class="nx">tag</span><span class="p">,</span> <span class="nx">value</span><span class="p">]</span><span class="o">:</span> <span class="nx">token</span>
+        <span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;TOKENS&#39;</span>
+          <span class="vi">@tokens: </span><span class="nx">@tokens</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">value</span>
+        <span class="k">else</span> <span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;STRING&#39;</span> <span class="o">and</span> <span class="nx">escape_quotes</span>
+          <span class="nv">escaped: </span><span class="nx">value</span><span class="p">.</span><span class="nx">substring</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="nx">value</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">).</span><span class="nx">replace</span><span class="p">(</span><span class="sr">/&quot;/g</span><span class="p">,</span> <span class="s1">&#39;\\&quot;&#39;</span><span class="p">)</span>
+          <span class="nx">@token</span> <span class="nx">tag</span><span class="p">,</span> <span class="s2">&quot;\&quot;$escaped\&quot;&quot;</span>
         <span class="k">else</span>
-          <span class="err">@</span><span class="nx">token</span> <span class="nx">each</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nx">each</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
-        <span class="err">@</span><span class="nx">token</span> <span class="s1">&#39;+&#39;</span><span class="p">,</span> <span class="s1">&#39;+&#39;</span> <span class="k">if</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">tokens</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span></pre></div>             </td>           </tr>                               <tr id="section-31">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-31">#</a>               </div>               <h2>Helpers</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-32">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-32">#</a>               </div>               <p>Add a token to the results, taking note of the line number.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">token: </span><span class="p">(</span><span class="nx">tag</span><span class="p">,</span> <span class="nx">value</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">push</span><span class="p">([</span><span class="nx">tag</span><span class="p">,</span> <span class="nx">value</span><span class="p">,</span> <span class="err">@</span><span class="nx">line</span><span class="p">])</span></pre></div>             </td>           </tr>                               <tr id="section-33">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-33">#</a>               </div>               <p>Peek at a tag in the current token stream.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">tag: </span><span class="p">(</span><span class="nx">index</span><span class="p">,</span> <span class="nx">tag</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="nx">unless</span> <span class="nv">tok: </span><span class="err">@</span><span class="nx">prev</span><span class="p">(</span><span class="nx">index</span><span class="p">)</span>
+          <span class="nx">@token</span> <span class="nx">tag</span><span class="p">,</span> <span class="nx">value</span>
+        <span class="nx">@token</span> <span class="s1">&#39;+&#39;</span><span class="p">,</span> <span class="s1">&#39;+&#39;</span> <span class="k">if</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">tokens</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
+      <span class="nx">tokens</span></pre></div>             </td>           </tr>                               <tr id="section-33">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-33">#</a>               </div>               <h2>Helpers</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-34">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-34">#</a>               </div>               <p>Add a token to the results, taking note of the line number.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">token: </span><span class="p">(</span><span class="nx">tag</span><span class="p">,</span> <span class="nx">value</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="nx">@tokens</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="nx">tag</span><span class="p">,</span> <span class="nx">value</span><span class="p">,</span> <span class="nx">@line</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-35">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-35">#</a>               </div>               <p>Peek at a tag in the current token stream.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">tag: </span><span class="p">(</span><span class="nx">index</span><span class="p">,</span> <span class="nx">tag</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="k">return</span> <span class="nx">unless</span> <span class="nv">tok: </span><span class="nx">@prev</span> <span class="nx">index</span>
     <span class="k">return</span> <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">:</span> <span class="nx">tag</span> <span class="k">if</span> <span class="nx">tag</span><span class="o">?</span>
-    <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-34">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-34">#</a>               </div>               <p>Peek at a value in the current token stream.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">value: </span><span class="p">(</span><span class="nx">index</span><span class="p">,</span> <span class="nx">val</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="nx">unless</span> <span class="nv">tok: </span><span class="err">@</span><span class="nx">prev</span><span class="p">(</span><span class="nx">index</span><span class="p">)</span>
+    <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-36">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-36">#</a>               </div>               <p>Peek at a value in the current token stream.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">value: </span><span class="p">(</span><span class="nx">index</span><span class="p">,</span> <span class="nx">val</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="k">return</span> <span class="nx">unless</span> <span class="nv">tok: </span><span class="nx">@prev</span> <span class="nx">index</span>
     <span class="k">return</span> <span class="nx">tok</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">:</span> <span class="nx">val</span> <span class="k">if</span> <span class="nx">val</span><span class="o">?</span>
-    <span class="nx">tok</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-35">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-35">#</a>               </div>               <p>Peek at a previous token, entire.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">prev: </span><span class="p">(</span><span class="nx">index</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nx">tokens</span><span class="p">[</span><span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="p">(</span><span class="nx">index</span> <span class="o">or</span> <span class="mi">1</span><span class="p">)]</span></pre></div>             </td>           </tr>                               <tr id="section-36">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-36">#</a>               </div>               <p>Attempt to match a string against the current chunk, returning the indexed
+    <span class="nx">tok</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-37">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-37">#</a>               </div>               <p>Peek at a previous token, entire.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">prev: </span><span class="p">(</span><span class="nx">index</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="nx">@tokens</span><span class="p">[</span><span class="nx">@tokens</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="p">(</span><span class="nx">index</span> <span class="o">or</span> <span class="mi">1</span><span class="p">)]</span></pre></div>             </td>           </tr>                               <tr id="section-38">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-38">#</a>               </div>               <p>Attempt to match a string against the current chunk, returning the indexed
 match if successful, and <code>false</code> otherwise.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">match: </span><span class="p">(</span><span class="nx">regex</span><span class="p">,</span> <span class="nx">index</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">m: </span><span class="err">@</span><span class="nx">chunk</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">regex</span><span class="p">)</span>
-    <span class="k">if</span> <span class="nx">m</span> <span class="k">then</span> <span class="nx">m</span><span class="p">[</span><span class="nx">index</span><span class="p">]</span> <span class="k">else</span> <span class="kc">false</span></pre></div>             </td>           </tr>                               <tr id="section-37">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-37">#</a>               </div>               <h2>Constants</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-38">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-38">#</a>               </div>               <p>Keywords that CoffeeScript shares in common with JavaScript.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">JS_KEYWORDS: </span><span class="p">[</span>
+    <span class="k">return</span> <span class="kc">false</span> <span class="nx">unless</span> <span class="nv">m: </span><span class="nx">@chunk</span><span class="p">.</span><span class="nx">match</span> <span class="nx">regex</span>
+    <span class="k">if</span> <span class="nx">m</span> <span class="k">then</span> <span class="nx">m</span><span class="p">[</span><span class="nx">index</span><span class="p">]</span> <span class="k">else</span> <span class="kc">false</span></pre></div>             </td>           </tr>                               <tr id="section-39">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-39">#</a>               </div>               <p>Are we in the midst of an unfinished expression?</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">unfinished: </span><span class="o">-&gt;</span>
+    <span class="nv">prev: </span><span class="nx">@prev</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
+    <span class="nx">@value</span><span class="p">()</span> <span class="o">and</span> <span class="nx">@value</span><span class="p">().</span><span class="nx">match</span> <span class="o">and</span> <span class="nx">@value</span><span class="p">().</span><span class="nx">match</span><span class="p">(</span><span class="nx">NO_NEWLINE</span><span class="p">)</span> <span class="o">and</span>
+      <span class="nx">prev</span> <span class="o">and</span> <span class="p">(</span><span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">isnt</span> <span class="s1">&#39;.&#39;</span><span class="p">)</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">@value</span><span class="p">().</span><span class="nx">match</span><span class="p">(</span><span class="nx">CODE</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-40">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-40">#</a>               </div>               <h2>Lexer Properties</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-41">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-41">#</a>               </div>               <p>There are no exensions to the core lexer by default.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="vi">@extensions: </span><span class="p">[]</span></pre></div>             </td>           </tr>                               <tr id="section-42">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-42">#</a>               </div>               <h2>Constants</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-43">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-43">#</a>               </div>               <p>Keywords that CoffeeScript shares in common with JavaScript.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">JS_KEYWORDS: </span><span class="p">[</span>
   <span class="s2">&quot;if&quot;</span><span class="p">,</span> <span class="s2">&quot;else&quot;</span><span class="p">,</span>
   <span class="s2">&quot;true&quot;</span><span class="p">,</span> <span class="s2">&quot;false&quot;</span><span class="p">,</span>
   <span class="s2">&quot;new&quot;</span><span class="p">,</span> <span class="s2">&quot;return&quot;</span><span class="p">,</span>
@@ -302,58 +318,58 @@ match if successful, and <code>false</code> otherwise.</p>             </td>
   <span class="s2">&quot;break&quot;</span><span class="p">,</span> <span class="s2">&quot;continue&quot;</span><span class="p">,</span>
   <span class="s2">&quot;for&quot;</span><span class="p">,</span> <span class="s2">&quot;in&quot;</span><span class="p">,</span> <span class="s2">&quot;while&quot;</span><span class="p">,</span>
   <span class="s2">&quot;delete&quot;</span><span class="p">,</span> <span class="s2">&quot;instanceof&quot;</span><span class="p">,</span> <span class="s2">&quot;typeof&quot;</span><span class="p">,</span>
-  <span class="s2">&quot;switch&quot;</span><span class="p">,</span> <span class="s2">&quot;super&quot;</span><span class="p">,</span> <span class="s2">&quot;extends&quot;</span><span class="p">,</span> <span class="s2">&quot;class&quot;</span>
-<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-39">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-39">#</a>               </div>               <p>CoffeeScript-only keywords, which we're more relaxed about allowing. They can't
-be used standalone, but you can reference them as an attached property.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">COFFEE_KEYWORDS: </span><span class="p">[</span>
+  <span class="s2">&quot;switch&quot;</span><span class="p">,</span> <span class="s2">&quot;super&quot;</span><span class="p">,</span> <span class="s2">&quot;extends&quot;</span><span class="p">,</span> <span class="s2">&quot;class&quot;</span><span class="p">,</span>
+  <span class="s2">&quot;this&quot;</span><span class="p">,</span> <span class="s2">&quot;null&quot;</span>
+<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-44">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-44">#</a>               </div>               <p>CoffeeScript-only keywords, which we're more relaxed about allowing. They can't
+be used standalone, but you can reference them as an attached property.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">COFFEE_ALIASES: </span> <span class="p">[</span><span class="s2">&quot;and&quot;</span><span class="p">,</span> <span class="s2">&quot;or&quot;</span><span class="p">,</span> <span class="s2">&quot;is&quot;</span><span class="p">,</span> <span class="s2">&quot;isnt&quot;</span><span class="p">,</span> <span class="s2">&quot;not&quot;</span><span class="p">]</span>
+<span class="nv">COFFEE_KEYWORDS: </span><span class="nx">COFFEE_ALIASES</span><span class="p">.</span><span class="nx">concat</span> <span class="p">[</span>
   <span class="s2">&quot;then&quot;</span><span class="p">,</span> <span class="s2">&quot;unless&quot;</span><span class="p">,</span>
   <span class="s2">&quot;yes&quot;</span><span class="p">,</span> <span class="s2">&quot;no&quot;</span><span class="p">,</span> <span class="s2">&quot;on&quot;</span><span class="p">,</span> <span class="s2">&quot;off&quot;</span><span class="p">,</span>
-  <span class="s2">&quot;and&quot;</span><span class="p">,</span> <span class="s2">&quot;or&quot;</span><span class="p">,</span> <span class="s2">&quot;is&quot;</span><span class="p">,</span> <span class="s2">&quot;isnt&quot;</span><span class="p">,</span> <span class="s2">&quot;not&quot;</span><span class="p">,</span>
   <span class="s2">&quot;of&quot;</span><span class="p">,</span> <span class="s2">&quot;by&quot;</span><span class="p">,</span> <span class="s2">&quot;where&quot;</span><span class="p">,</span> <span class="s2">&quot;when&quot;</span>
-<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-40">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-40">#</a>               </div>               <p>The combined list of keywords is the superset that gets passed verbatim to
-the parser.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">KEYWORDS: </span><span class="nx">JS_KEYWORDS</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">COFFEE_KEYWORDS</span></pre></div>             </td>           </tr>                               <tr id="section-41">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-41">#</a>               </div>               <p>The list of keywords that are reserved by JavaScript, but not used, or are
+<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-45">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-45">#</a>               </div>               <p>The combined list of keywords is the superset that gets passed verbatim to
+the parser.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">KEYWORDS: </span><span class="nx">JS_KEYWORDS</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">COFFEE_KEYWORDS</span></pre></div>             </td>           </tr>                               <tr id="section-46">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-46">#</a>               </div>               <p>The list of keywords that are reserved by JavaScript, but not used, or are
 used by CoffeeScript internally. We throw an error when these are encountered,
 to avoid having a JavaScript error at runtime.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">RESERVED: </span><span class="p">[</span>
   <span class="s2">&quot;case&quot;</span><span class="p">,</span> <span class="s2">&quot;default&quot;</span><span class="p">,</span> <span class="s2">&quot;do&quot;</span><span class="p">,</span> <span class="s2">&quot;function&quot;</span><span class="p">,</span> <span class="s2">&quot;var&quot;</span><span class="p">,</span> <span class="s2">&quot;void&quot;</span><span class="p">,</span> <span class="s2">&quot;with&quot;</span>
-  <span class="s2">&quot;const&quot;</span><span class="p">,</span> <span class="s2">&quot;let&quot;</span><span class="p">,</span> <span class="s2">&quot;debugger&quot;</span><span class="p">,</span> <span class="s2">&quot;enum&quot;</span><span class="p">,</span> <span class="s2">&quot;export&quot;</span><span class="p">,</span> <span class="s2">&quot;import&quot;</span><span class="p">,</span> <span class="s2">&quot;native&quot;</span><span class="p">,</span>
-  <span class="s2">&quot;__extends&quot;</span><span class="p">,</span> <span class="s2">&quot;__hasProp&quot;</span>
-<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-42">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-42">#</a>               </div>               <p>The superset of both JavaScript keywords and reserved words, none of which may
-be used as identifiers or properties.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">JS_FORBIDDEN: </span><span class="nx">JS_KEYWORDS</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">RESERVED</span></pre></div>             </td>           </tr>                               <tr id="section-43">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-43">#</a>               </div>               <p>Token matching regexes.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nx">IDENTIFIER</span>    <span class="o">:</span> <span class="sr">/^([a-zA-Z$_](\w|\$)*)/</span>
-<span class="nx">NUMBER</span>        <span class="o">:</span> <span class="sr">/^(\b((0(x|X)[0-9a-fA-F]+)|([0-9]+(\.[0-9]+)?(e[+\-]?[0-9]+)?)))\b/i</span>
-<span class="nx">HEREDOC</span>       <span class="o">:</span> <span class="sr">/^(&quot;{6}|&#39;{6}|&quot;{3}\n?([\s\S]*?)\n?([ \t]*)&quot;{3}|&#39;{3}\n?([\s\S]*?)\n?([ \t]*)&#39;{3})/</span>
-<span class="nx">INTERPOLATION</span> <span class="o">:</span> <span class="sr">/^\$([a-zA-Z_@]\w*(\.\w+)*)/</span>
-<span class="nx">OPERATOR</span>      <span class="o">:</span> <span class="sr">/^([+\*&amp;|\/\-%=&lt;&gt;:!?]+)/</span>
-<span class="nx">WHITESPACE</span>    <span class="o">:</span> <span class="sr">/^([ \t]+)/</span>
-<span class="nx">COMMENT</span>       <span class="o">:</span> <span class="sr">/^(((\n?[ \t]*)?#[^\n]*)+)/</span>
-<span class="nx">CODE</span>          <span class="o">:</span> <span class="sr">/^((-|=)&gt;)/</span>
-<span class="nx">REGEX</span>         <span class="o">:</span> <span class="sr">/^(\/(\S.*?)?([^\\]|\\\\)\/[imgy]{0,4})/</span>
-<span class="nx">MULTI_DENT</span>    <span class="o">:</span> <span class="sr">/^((\n([ \t]*))+)(\.)?/</span>
-<span class="nx">LAST_DENTS</span>    <span class="o">:</span> <span class="sr">/\n([ \t]*)/g</span>
-<span class="nx">LAST_DENT</span>     <span class="o">:</span> <span class="sr">/\n([ \t]*)/</span>
-<span class="nx">ASSIGNMENT</span>    <span class="o">:</span> <span class="sr">/^(:|=)$/</span></pre></div>             </td>           </tr>                               <tr id="section-44">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-44">#</a>               </div>               <p>Token cleaning regexes.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nx">JS_CLEANER</span>      <span class="o">:</span> <span class="sr">/(^`|`$)/g</span>
-<span class="nx">MULTILINER</span>      <span class="o">:</span> <span class="sr">/\n/g</span>
-<span class="nx">STRING_NEWLINES</span> <span class="o">:</span> <span class="sr">/\n[ \t]*/g</span>
-<span class="nx">COMMENT_CLEANER</span> <span class="o">:</span> <span class="sr">/(^[ \t]*#|\n[ \t]*$)/mg</span>
-<span class="nx">NO_NEWLINE</span>      <span class="o">:</span> <span class="sr">/^([+\*&amp;|\/\-%=&lt;&gt;:!.\\][&lt;&gt;=&amp;|]*|and|or|is|isnt|not|delete|typeof|instanceof)$/</span>
-<span class="nx">HEREDOC_INDENT</span>  <span class="o">:</span> <span class="sr">/^[ \t]+/mg</span></pre></div>             </td>           </tr>                               <tr id="section-45">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-45">#</a>               </div>               <p>Tokens which a regular expression will never immediately follow, but which
+  <span class="s2">&quot;const&quot;</span><span class="p">,</span> <span class="s2">&quot;let&quot;</span><span class="p">,</span> <span class="s2">&quot;debugger&quot;</span><span class="p">,</span> <span class="s2">&quot;enum&quot;</span><span class="p">,</span> <span class="s2">&quot;export&quot;</span><span class="p">,</span> <span class="s2">&quot;import&quot;</span><span class="p">,</span> <span class="s2">&quot;native&quot;</span>
+<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-47">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-47">#</a>               </div>               <p>The superset of both JavaScript keywords and reserved words, none of which may
+be used as identifiers or properties.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">JS_FORBIDDEN: </span><span class="nx">JS_KEYWORDS</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">RESERVED</span></pre></div>             </td>           </tr>                               <tr id="section-48">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-48">#</a>               </div>               <p>Token matching regexes.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IDENTIFIER    : </span><span class="sr">/^([a-zA-Z\$_](\w|\$)*)/</span>
+<span class="nv">NUMBER        : </span><span class="sr">/^(\b((0(x|X)[0-9a-fA-F]+)|([0-9]+(\.[0-9]+)?(e[+\-]?[0-9]+)?)))\b/i</span>
+<span class="nv">HEREDOC       : </span><span class="sr">/^(&quot;{6}|&#39;{6}|&quot;{3}\n?([\s\S]*?)\n?([ \t]*)&quot;{3}|&#39;{3}\n?([\s\S]*?)\n?([ \t]*)&#39;{3})/</span>
+<span class="nv">INTERPOLATION : </span><span class="sr">/^\$([a-zA-Z_@]\w*(\.\w+)*)/</span>
+<span class="nv">OPERATOR      : </span><span class="sr">/^([+\*&amp;|\/\-%=&lt;&gt;:!?]+)([ \t]*)/</span>
+<span class="nv">WHITESPACE    : </span><span class="sr">/^([ \t]+)/</span>
+<span class="nv">COMMENT       : </span><span class="sr">/^(((\n?[ \t]*)?#[^\n]*)+)/</span>
+<span class="nv">CODE          : </span><span class="sr">/^((-|=)&gt;)/</span>
+<span class="nv">MULTI_DENT    : </span><span class="sr">/^((\n([ \t]*))+)(\.)?/</span>
+<span class="nv">LAST_DENTS    : </span><span class="sr">/\n([ \t]*)/g</span>
+<span class="nv">LAST_DENT     : </span><span class="sr">/\n([ \t]*)/</span>
+<span class="nv">ASSIGNMENT    : </span><span class="sr">/^(:|=)$/</span></pre></div>             </td>           </tr>                               <tr id="section-49">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-49">#</a>               </div>               <p>Regex-matching-regexes.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">REGEX_START        : </span><span class="sr">/^\/[^\/ ]/</span>
+<span class="nv">REGEX_INTERPOLATION: </span><span class="sr">/([^\\]\$[a-zA-Z_@]|[^\\]\$\{.*[^\\]\})/</span>
+<span class="nv">REGEX_FLAGS        : </span><span class="sr">/^[imgy]{0,4}/</span>
+<span class="nv">REGEX_ESCAPE       : </span><span class="sr">/\\[^\$]/g</span></pre></div>             </td>           </tr>                               <tr id="section-50">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-50">#</a>               </div>               <p>Token cleaning regexes.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">JS_CLEANER      : </span><span class="sr">/(^`|`$)/g</span>
+<span class="nv">MULTILINER      : </span><span class="sr">/\n/g</span>
+<span class="nv">STRING_NEWLINES : </span><span class="sr">/\n[ \t]*/g</span>
+<span class="nv">COMMENT_CLEANER : </span><span class="sr">/(^[ \t]*#|\n[ \t]*$)/mg</span>
+<span class="nv">NO_NEWLINE      : </span><span class="sr">/^([+\*&amp;|\/\-%=&lt;&gt;:!.\\][&lt;&gt;=&amp;|]*|and|or|is|isnt|not|delete|typeof|instanceof)$/</span>
+<span class="nv">HEREDOC_INDENT  : </span><span class="sr">/^[ \t]+/mg</span></pre></div>             </td>           </tr>                               <tr id="section-51">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-51">#</a>               </div>               <p>Tokens which a regular expression will never immediately follow, but which
 a division operator might.</p>
 
 <p>See: <a href='http://www.mozilla.org/js/language/js20-2002-04/rationale/syntax.html#regular-expressions'>http://www.mozilla.org/js/language/js20-2002-04/rationale/syntax.html#regular-expressions</a></p>
 
 <p>Our list is shorter, due to sans-parentheses method calls.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">NOT_REGEX: </span><span class="p">[</span>
   <span class="s1">&#39;NUMBER&#39;</span><span class="p">,</span> <span class="s1">&#39;REGEX&#39;</span><span class="p">,</span> <span class="s1">&#39;++&#39;</span><span class="p">,</span> <span class="s1">&#39;--&#39;</span><span class="p">,</span> <span class="s1">&#39;FALSE&#39;</span><span class="p">,</span> <span class="s1">&#39;NULL&#39;</span><span class="p">,</span> <span class="s1">&#39;TRUE&#39;</span>
-<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-46">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-46">#</a>               </div>               <p>Tokens which could legitimately be invoked or indexed. A opening
+<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-52">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-52">#</a>               </div>               <p>Tokens which could legitimately be invoked or indexed. A opening
 parentheses or bracket following these tokens will be recorded as the start
-of a function invocation or indexing operation.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CALLABLE: </span><span class="p">[</span><span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;SUPER&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="s1">&#39;]&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">,</span> <span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s1">&#39;@&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-47">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-47">#</a>               </div>               <p>Tokens that indicate an access -- keywords immediately following will be
-treated as identifiers.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">ACCESSORS: </span><span class="p">[</span><span class="s1">&#39;PROPERTY_ACCESS&#39;</span><span class="p">,</span> <span class="s1">&#39;PROTOTYPE_ACCESS&#39;</span><span class="p">,</span> <span class="s1">&#39;SOAK_ACCESS&#39;</span><span class="p">,</span> <span class="s1">&#39;@&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-48">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-48">#</a>               </div>               <p>Tokens that, when immediately preceding a <code>WHEN</code>, indicate that the <code>WHEN</code>
+of a function invocation or indexing operation.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CALLABLE: </span><span class="p">[</span><span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;SUPER&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="s1">&#39;]&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">,</span> <span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s1">&#39;@&#39;</span><span class="p">,</span> <span class="s1">&#39;THIS&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-53">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-53">#</a>               </div>               <p>Tokens that indicate an access -- keywords immediately following will be
+treated as identifiers.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">ACCESSORS: </span><span class="p">[</span><span class="s1">&#39;PROPERTY_ACCESS&#39;</span><span class="p">,</span> <span class="s1">&#39;PROTOTYPE_ACCESS&#39;</span><span class="p">,</span> <span class="s1">&#39;SOAK_ACCESS&#39;</span><span class="p">,</span> <span class="s1">&#39;@&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-54">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-54">#</a>               </div>               <p>Tokens that, when immediately preceding a <code>WHEN</code>, indicate that the <code>WHEN</code>
 occurs at the start of a line. We disambiguate these from trailing whens to
-avoid an ambiguity in the grammar.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">BEFORE_WHEN: </span><span class="p">[</span><span class="s1">&#39;INDENT&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">,</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-49">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-49">#</a>               </div>               <h2>Utility Functions</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-50">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-50">#</a>               </div>               <p>Does a list include a value?</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">include: </span><span class="p">(</span><span class="nx">list</span><span class="p">,</span> <span class="nx">value</span><span class="p">)</span> <span class="o">-&gt;</span>
-  <span class="nx">list</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">value</span><span class="p">)</span> <span class="o">&gt;=</span> <span class="mi">0</span></pre></div>             </td>           </tr>                               <tr id="section-51">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-51">#</a>               </div>               <p>Peek at the beginning of a given string to see if it matches a sequence.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">starts: </span><span class="p">(</span><span class="nx">string</span><span class="p">,</span> <span class="nx">literal</span><span class="p">,</span> <span class="nx">start</span><span class="p">)</span> <span class="o">-&gt;</span>
-  <span class="nx">string</span><span class="p">.</span><span class="nx">substring</span><span class="p">(</span><span class="nx">start</span><span class="p">,</span> <span class="p">(</span><span class="nx">start</span> <span class="o">or</span> <span class="mi">0</span><span class="p">)</span> <span class="o">+</span> <span class="nx">literal</span><span class="p">.</span><span class="nx">length</span><span class="p">)</span> <span class="o">is</span> <span class="nx">literal</span></pre></div>             </td>           </tr>                               <tr id="section-52">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-52">#</a>               </div>               <p>Trim out all falsy values from an array.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">compact: </span><span class="p">(</span><span class="nx">array</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">item</span> <span class="k">for</span> <span class="nx">item</span> <span class="k">in</span> <span class="nx">array</span> <span class="k">when</span> <span class="nx">item</span></pre></div>             </td>           </tr>                               <tr id="section-53">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-53">#</a>               </div>               <p>Count the number of occurences of a character in a string.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">count: </span><span class="p">(</span><span class="nx">string</span><span class="p">,</span> <span class="nx">letter</span><span class="p">)</span> <span class="o">-&gt;</span>
-  <span class="nv">num: </span><span class="mi">0</span>
-  <span class="nv">pos: </span><span class="nx">string</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">letter</span><span class="p">)</span>
-  <span class="k">while</span> <span class="nx">pos</span> <span class="o">isnt</span> <span class="o">-</span><span class="mi">1</span>
-    <span class="nx">num</span> <span class="o">+=</span> <span class="mi">1</span>
-    <span class="nv">pos: </span><span class="nx">string</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">letter</span><span class="p">,</span> <span class="nx">pos</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)</span>
-  <span class="nx">num</span>
+avoid an ambiguity in the grammar.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">LINE_BREAK: </span><span class="p">[</span><span class="s1">&#39;INDENT&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">,</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-55">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-55">#</a>               </div>               <p>Half-assignments...</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">HALF_ASSIGNMENTS: </span><span class="p">[</span><span class="s1">&#39;-&#39;</span><span class="p">,</span> <span class="s1">&#39;+&#39;</span><span class="p">,</span> <span class="s1">&#39;/&#39;</span><span class="p">,</span> <span class="s1">&#39;*&#39;</span><span class="p">,</span> <span class="s1">&#39;%&#39;</span><span class="p">,</span> <span class="s1">&#39;||&#39;</span><span class="p">,</span> <span class="s1">&#39;&amp;&amp;&#39;</span><span class="p">,</span> <span class="s1">&#39;?&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-56">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-56">#</a>               </div>               <p>Conversions from CoffeeScript operators into JavaScript ones.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CONVERSIONS: </span><span class="p">{</span>
+  <span class="s1">&#39;and&#39;</span><span class="o">:</span>  <span class="s1">&#39;&amp;&amp;&#39;</span>
+  <span class="s1">&#39;or&#39;</span><span class="o">:</span>   <span class="s1">&#39;||&#39;</span>
+  <span class="s1">&#39;is&#39;</span><span class="o">:</span>   <span class="s1">&#39;==&#39;</span>
+  <span class="s1">&#39;isnt&#39;</span><span class="o">:</span> <span class="s1">&#39;!=&#39;</span>
+  <span class="s1">&#39;not&#39;</span><span class="o">:</span>  <span class="s1">&#39;!&#39;</span>
+<span class="p">}</span>
 
 </pre></div>             </td>           </tr>                </tbody>     </table>   </div> </body> </html> 

documentation/docs/optparse.html

@@ -1,4 +1,4 @@
-<!DOCTYPE html>  <html> <head>   <title>optparse.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               optparse.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>A simple <strong>OptionParser</strong> class to parse option flags from the command-line.
+<!DOCTYPE html>  <html> <head>   <title>optparse.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="helpers.html">                 helpers.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               optparse.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>A simple <strong>OptionParser</strong> class to parse option flags from the command-line.
 Use it like so:</p>
 
 <pre><code>parser:  new OptionParser switches, help_banner
@@ -9,18 +9,18 @@ options: parser.parse process.argv
 </code></pre>
 
 <p>Along with an an optional banner for the usage help.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">constructor: </span><span class="p">(</span><span class="nx">rules</span><span class="p">,</span> <span class="nx">banner</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nv">banner: </span> <span class="nx">banner</span>
-    <span class="err">@</span><span class="nv">rules: </span>  <span class="nx">build_rules</span><span class="p">(</span><span class="nx">rules</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>Parse the list of arguments, populating an <code>options</code> object with all of the
+    <span class="vi">@banner: </span> <span class="nx">banner</span>
+    <span class="vi">@rules: </span>  <span class="nx">build_rules</span><span class="p">(</span><span class="nx">rules</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>Parse the list of arguments, populating an <code>options</code> object with all of the
 specified options, and returning it. <code>options.arguments</code> will be an array
 containing the remaning non-option arguments. This is a simpler API than
 many option parsers that allow you to attach callback actions for every
 flag. Instead, you're responsible for interpreting the options object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">parse: </span><span class="p">(</span><span class="nx">args</span><span class="p">)</span> <span class="o">-&gt;</span>
     <span class="nv">options: </span><span class="p">{</span><span class="nv">arguments: </span><span class="p">[]}</span>
     <span class="nv">args: </span><span class="nx">normalize_arguments</span> <span class="nx">args</span>
-    <span class="k">while</span> <span class="nv">arg: </span><span class="nx">args</span><span class="p">.</span><span class="nx">shift</span><span class="p">()</span>
+    <span class="k">while</span> <span class="p">(</span><span class="nv">arg: </span><span class="nx">args</span><span class="p">.</span><span class="nx">shift</span><span class="p">())</span>
       <span class="nv">is_option: </span><span class="o">!!</span><span class="p">(</span><span class="nx">arg</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">LONG_FLAG</span><span class="p">)</span> <span class="o">or</span> <span class="nx">arg</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">SHORT_FLAG</span><span class="p">))</span>
       <span class="nv">matched_rule: </span><span class="kc">no</span>
-      <span class="k">for</span> <span class="nx">rule</span> <span class="k">in</span> <span class="err">@</span><span class="nx">rules</span>
+      <span class="k">for</span> <span class="nx">rule</span> <span class="k">in</span> <span class="nx">@rules</span>
         <span class="k">if</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">short_flag</span> <span class="o">is</span> <span class="nx">arg</span> <span class="o">or</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">long_flag</span> <span class="o">is</span> <span class="nx">arg</span>
           <span class="nx">options</span><span class="p">[</span><span class="nx">rule</span><span class="p">.</span><span class="nx">name</span><span class="p">]</span><span class="o">:</span> <span class="k">if</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">has_argument</span> <span class="k">then</span> <span class="nx">args</span><span class="p">.</span><span class="nx">shift</span><span class="p">()</span> <span class="k">else</span> <span class="kc">true</span>
           <span class="nv">matched_rule: </span><span class="kc">yes</span>
@@ -30,8 +30,8 @@ flag. Instead, you're responsible for interpreting the options object.</p>
     <span class="nx">options</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <p>Return the help text for this <strong>OptionParser</strong>, listing and describing all
 of the valid options, for <code>--help</code> and such.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">help: </span><span class="o">-&gt;</span>
     <span class="nv">lines: </span><span class="p">[</span><span class="s1">&#39;Available options:&#39;</span><span class="p">]</span>
-    <span class="nx">lines</span><span class="p">.</span><span class="nx">unshift</span> <span class="s2">&quot;$@banner\n&quot;</span> <span class="k">if</span> <span class="err">@</span><span class="nx">banner</span>
-    <span class="k">for</span> <span class="nx">rule</span> <span class="k">in</span> <span class="err">@</span><span class="nx">rules</span>
+    <span class="nx">lines</span><span class="p">.</span><span class="nx">unshift</span> <span class="s2">&quot;$@banner\n&quot;</span> <span class="k">if</span> <span class="nx">@banner</span>
+    <span class="k">for</span> <span class="nx">rule</span> <span class="k">in</span> <span class="nx">@rules</span>
       <span class="nv">spaces: </span>  <span class="mi">15</span> <span class="o">-</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">long_flag</span><span class="p">.</span><span class="nx">length</span>
       <span class="nv">spaces: </span>  <span class="k">if</span> <span class="nx">spaces</span> <span class="o">&gt;</span> <span class="mi">0</span> <span class="k">then</span> <span class="p">(</span><span class="s1">&#39; &#39;</span> <span class="k">for</span> <span class="nx">i</span> <span class="k">in</span> <span class="p">[</span><span class="mi">0</span><span class="p">..</span><span class="nx">spaces</span><span class="p">]).</span><span class="nx">join</span><span class="p">(</span><span class="s1">&#39;&#39;</span><span class="p">)</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span>
       <span class="nv">let_part: </span><span class="k">if</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">short_flag</span> <span class="k">then</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">short_flag</span> <span class="o">+</span> <span class="s1">&#39;, &#39;</span> <span class="k">else</span> <span class="s1">&#39;    &#39;</span>

documentation/docs/repl.html

@@ -1,9 +1,10 @@
-<!DOCTYPE html>  <html> <head>   <title>repl.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               repl.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>A very simple Read-Eval-Print-Loop. Compiles one line at a time to JavaScript
+<!DOCTYPE html>  <html> <head>   <title>repl.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="helpers.html">                 helpers.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               repl.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>A very simple Read-Eval-Print-Loop. Compiles one line at a time to JavaScript
 and evaluates it. Good for simple tests, or poking around the <strong>Node.js</strong> API.
 Using it looks like this:</p>
 
 <pre><code>coffee&gt; puts "$num bottles of beer" for num in [99..1]
-</code></pre>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-2">#</a>               </div>               <p>Require the <strong>coffee-script</strong> module to get access to the compiler.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CoffeeScript: </span><span class="nx">require</span> <span class="s1">&#39;coffee-script&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>Our prompt.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">prompt: </span><span class="s1">&#39;coffee&gt; &#39;</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <p>Quick alias for quitting the REPL.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nx">process</span><span class="p">.</span><span class="nx">mixin</span> <span class="p">{</span>
+</code></pre>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-2">#</a>               </div>               <p>Require the <strong>coffee-script</strong> module to get access to the compiler.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CoffeeScript: </span><span class="nx">require</span> <span class="s1">&#39;./coffee-script&#39;</span>
+<span class="nv">helpers: </span>     <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./helpers&#39;</span><span class="p">).</span><span class="nx">helpers</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>Our prompt.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">prompt: </span><span class="s1">&#39;coffee&gt; &#39;</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <p>Quick alias for quitting the REPL.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nx">helpers</span><span class="p">.</span><span class="nx">extend</span> <span class="nx">global</span><span class="p">,</span> <span class="p">{</span>
   <span class="nv">quit: </span><span class="o">-&gt;</span> <span class="nx">process</span><span class="p">.</span><span class="nx">exit</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
 <span class="p">}</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-5">#</a>               </div>               <p>The main REPL function. <strong>run</strong> is called every time a line of code is entered.
 Attempt to evaluate the command. If there's an exception, print it out instead

documentation/docs/rewriter.html

@@ -1,140 +1,163 @@
-<!DOCTYPE html>  <html> <head>   <title>rewriter.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               rewriter.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>The CoffeeScript language has a decent amount of optional syntax,
-implicit syntax, and shorthand syntax. These things can greatly complicate a
-grammar and bloat the resulting parse table. Instead of making the parser
-handle it all, we take a series of passes over the token stream,
-using this <strong>Rewriter</strong> to convert shorthand into the unambiguous long form,
-add implicit indentation and parentheses, balance incorrect nestings, and
-generally clean things up.</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-2">#</a>               </div>               <p>Set up exported variables for both Node.js and the browser.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">this</span><span class="p">.</span><span class="nv">exports: </span><span class="k">this</span> <span class="nx">unless</span> <span class="nx">process</span><span class="o">?</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>The <strong>Rewriter</strong> class is used by the <a href="lexer.html">Lexer</a>, directly against
-its internal array of tokens.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Rewriter: </span><span class="nx">class</span> <span class="nx">Rewriter</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <p>Rewrite the token stream in multiple passes, one logical filter at
+<!DOCTYPE html>  <html> <head>   <title>rewriter.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="helpers.html">                 helpers.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               rewriter.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>The CoffeeScript language has a good deal of optional syntax, implicit syntax,
+and shorthand syntax. This can greatly complicate a grammar and bloat
+the resulting parse table. Instead of making the parser handle it all, we take
+a series of passes over the token stream, using this <strong>Rewriter</strong> to convert
+shorthand into the unambiguous long form, add implicit indentation and
+parentheses, balance incorrect nestings, and generally clean things up.</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-2">#</a>               </div>               <p>Set up exported variables for both Node.js and the browser.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">if</span> <span class="nx">process</span><span class="o">?</span>
+  <span class="nv">helpers: </span><span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./helpers&#39;</span><span class="p">).</span><span class="nx">helpers</span>
+<span class="k">else</span>
+  <span class="k">this</span><span class="p">.</span><span class="nv">exports: </span><span class="k">this</span>
+  <span class="nv">helpers: </span>     <span class="k">this</span><span class="p">.</span><span class="nx">helpers</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>Import the helpers we need.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">include: </span><span class="nx">helpers</span><span class="p">.</span><span class="nx">include</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <p>The <strong>Rewriter</strong> class is used by the <a href="lexer.html">Lexer</a>, directly against
+its internal array of tokens.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Rewriter: </span><span class="nx">class</span> <span class="nx">Rewriter</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-5">#</a>               </div>               <p>Rewrite the token stream in multiple passes, one logical filter at
 a time. This could certainly be changed into a single pass through the
 stream, with a big ol' efficient switch, but it's much nicer to work with
 like this. The order of these passes matters -- indentation must be
 corrected before implicit parentheses can be wrapped around blocks of code.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">rewrite: </span><span class="p">(</span><span class="nx">tokens</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nv">tokens: </span><span class="nx">tokens</span>
-    <span class="err">@</span><span class="nx">adjust_comments</span><span class="p">()</span>
-    <span class="err">@</span><span class="nx">remove_leading_newlines</span><span class="p">()</span>
-    <span class="err">@</span><span class="nx">remove_mid_expression_newlines</span><span class="p">()</span>
-    <span class="err">@</span><span class="nx">close_open_calls_and_indexes</span><span class="p">()</span>
-    <span class="err">@</span><span class="nx">add_implicit_indentation</span><span class="p">()</span>
-    <span class="err">@</span><span class="nx">add_implicit_parentheses</span><span class="p">()</span>
-    <span class="err">@</span><span class="nx">ensure_balance</span><span class="p">(</span><span class="nx">BALANCED_PAIRS</span><span class="p">)</span>
-    <span class="err">@</span><span class="nx">rewrite_closing_parens</span><span class="p">()</span>
-    <span class="err">@</span><span class="nx">tokens</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-5">#</a>               </div>               <p>Rewrite the token stream, looking one token ahead and behind.
+    <span class="vi">@tokens: </span><span class="nx">tokens</span>
+    <span class="nx">@adjust_comments</span><span class="p">()</span>
+    <span class="nx">@remove_leading_newlines</span><span class="p">()</span>
+    <span class="nx">@remove_mid_expression_newlines</span><span class="p">()</span>
+    <span class="nx">@close_open_calls_and_indexes</span><span class="p">()</span>
+    <span class="nx">@add_implicit_indentation</span><span class="p">()</span>
+    <span class="nx">@add_implicit_parentheses</span><span class="p">()</span>
+    <span class="nx">@ensure_balance</span> <span class="nx">BALANCED_PAIRS</span>
+    <span class="nx">@rewrite_closing_parens</span><span class="p">()</span>
+    <span class="nx">@tokens</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-6">#</a>               </div>               <p>Rewrite the token stream, looking one token ahead and behind.
 Allow the return value of the block to tell us how many tokens to move
 forwards (or backwards) in the stream, to make sure we don't miss anything
 as tokens are inserted and removed, and the stream changes length under
 our feet.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">scan_tokens: </span><span class="p">(</span><span class="nx">block</span><span class="p">)</span> <span class="o">-&gt;</span>
     <span class="nv">i: </span><span class="mi">0</span>
     <span class="k">while</span> <span class="kc">true</span>
-      <span class="k">break</span> <span class="nx">unless</span> <span class="err">@</span><span class="nx">tokens</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span>
-      <span class="nv">move: </span><span class="nx">block</span><span class="p">(</span><span class="err">@</span><span class="nx">tokens</span><span class="p">[</span><span class="nx">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">],</span> <span class="err">@</span><span class="nx">tokens</span><span class="p">[</span><span class="nx">i</span><span class="p">],</span> <span class="err">@</span><span class="nx">tokens</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">],</span> <span class="nx">i</span><span class="p">)</span>
-      <span class="nx">i</span> <span class="o">+=</span> <span class="nx">move</span>
-    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-6">#</a>               </div>               <p>Massage newlines and indentations so that comments don't have to be
+      <span class="k">break</span> <span class="nx">unless</span> <span class="nx">@tokens</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span>
+      <span class="nv">move: </span><span class="nx">block</span> <span class="nx">@tokens</span><span class="p">[</span><span class="nx">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">],</span> <span class="nx">@tokens</span><span class="p">[</span><span class="nx">i</span><span class="p">],</span> <span class="nx">@tokens</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">],</span> <span class="nx">i</span>
+      <span class="nv">i: </span><span class="o">+</span> <span class="nx">move</span>
+    <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-7">#</a>               </div>               <p>Massage newlines and indentations so that comments don't have to be
 correctly indented, or appear on a line of their own.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">adjust_comments: </span><span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nx">scan_tokens</span> <span class="p">(</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">post</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span>
+    <span class="nx">@scan_tokens</span> <span class="p">(</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">post</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span>
       <span class="k">return</span> <span class="mi">1</span> <span class="nx">unless</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;COMMENT&#39;</span>
-      <span class="nv">after: </span> <span class="err">@</span><span class="nx">tokens</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">2</span><span class="p">]</span>
+      <span class="nv">after: </span> <span class="nx">@tokens</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">2</span><span class="p">]</span>
       <span class="k">if</span> <span class="nx">after</span> <span class="o">and</span> <span class="nx">after</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;INDENT&#39;</span>
-        <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
-        <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">after</span><span class="p">)</span>
+        <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span>
+        <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">after</span>
         <span class="k">return</span> <span class="mi">1</span>
       <span class="k">else</span> <span class="k">if</span> <span class="nx">prev</span> <span class="o">and</span> <span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">isnt</span> <span class="s1">&#39;TERMINATOR&#39;</span> <span class="o">and</span> <span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">isnt</span> <span class="s1">&#39;INDENT&#39;</span> <span class="o">and</span> <span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">isnt</span> <span class="s1">&#39;OUTDENT&#39;</span>
-        <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s2">&quot;\n&quot;</span><span class="p">,</span> <span class="nx">prev</span><span class="p">[</span><span class="mi">2</span><span class="p">]])</span>
+        <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s2">&quot;\n&quot;</span><span class="p">,</span> <span class="nx">prev</span><span class="p">[</span><span class="mi">2</span><span class="p">]]</span>
         <span class="k">return</span> <span class="mi">2</span>
       <span class="k">else</span>
-        <span class="k">return</span> <span class="mi">1</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-7">#</a>               </div>               <p>Leading newlines would introduce an ambiguity in the grammar, so we
+        <span class="k">return</span> <span class="mi">1</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-8">#</a>               </div>               <p>Leading newlines would introduce an ambiguity in the grammar, so we
 dispatch them here.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">remove_leading_newlines: </span><span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">shift</span><span class="p">()</span> <span class="k">while</span> <span class="err">@</span><span class="nx">tokens</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;TERMINATOR&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-8">#</a>               </div>               <p>Some blocks occur in the middle of expressions -- when we're expecting
+    <span class="nx">@tokens</span><span class="p">.</span><span class="nx">shift</span><span class="p">()</span> <span class="k">while</span> <span class="nx">@tokens</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">and</span> <span class="nx">@tokens</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;TERMINATOR&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-9">#</a>               </div>               <p>Some blocks occur in the middle of expressions -- when we're expecting
 this, remove their trailing newlines.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">remove_mid_expression_newlines: </span><span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nx">scan_tokens</span> <span class="p">(</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">post</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span>
+    <span class="nx">@scan_tokens</span> <span class="p">(</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">post</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span>
       <span class="k">return</span> <span class="mi">1</span> <span class="nx">unless</span> <span class="nx">post</span> <span class="o">and</span> <span class="nx">include</span><span class="p">(</span><span class="nx">EXPRESSION_CLOSE</span><span class="p">,</span> <span class="nx">post</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="o">and</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;TERMINATOR&#39;</span>
-      <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
-      <span class="k">return</span> <span class="mi">0</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-9">#</a>               </div>               <p>The lexer has tagged the opening parenthesis of a method call, and the
+      <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">1</span>
+      <span class="k">return</span> <span class="mi">0</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-10">#</a>               </div>               <p>The lexer has tagged the opening parenthesis of a method call, and the
 opening bracket of an indexing operation. Match them with their paired
 close.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">close_open_calls_and_indexes: </span><span class="o">-&gt;</span>
     <span class="nv">parens: </span>  <span class="p">[</span><span class="mi">0</span><span class="p">]</span>
     <span class="nv">brackets: </span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
-    <span class="err">@</span><span class="nx">scan_tokens</span> <span class="p">(</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">post</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span>
+    <span class="nx">@scan_tokens</span> <span class="p">(</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">post</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span>
       <span class="k">switch</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
-        <span class="k">when</span> <span class="s1">&#39;CALL_START&#39;</span>  <span class="k">then</span> <span class="nx">parens</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
-        <span class="k">when</span> <span class="s1">&#39;INDEX_START&#39;</span> <span class="k">then</span> <span class="nx">brackets</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
-        <span class="k">when</span> <span class="s1">&#39;(&#39;</span>           <span class="k">then</span> <span class="nx">parens</span><span class="p">[</span><span class="nx">parens</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span>
-        <span class="k">when</span> <span class="s1">&#39;[&#39;</span>           <span class="k">then</span> <span class="nx">brackets</span><span class="p">[</span><span class="nx">brackets</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span>
+        <span class="k">when</span> <span class="s1">&#39;CALL_START&#39;</span>  <span class="k">then</span> <span class="nx">parens</span><span class="p">.</span><span class="nx">push</span> <span class="mi">0</span>
+        <span class="k">when</span> <span class="s1">&#39;INDEX_START&#39;</span> <span class="k">then</span> <span class="nx">brackets</span><span class="p">.</span><span class="nx">push</span> <span class="mi">0</span>
+        <span class="k">when</span> <span class="s1">&#39;(&#39;</span>           <span class="k">then</span> <span class="nx">parens</span><span class="p">[</span><span class="nx">parens</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span><span class="o">:</span> <span class="o">+</span> <span class="mi">1</span>
+        <span class="k">when</span> <span class="s1">&#39;[&#39;</span>           <span class="k">then</span> <span class="nx">brackets</span><span class="p">[</span><span class="nx">brackets</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span><span class="o">:</span> <span class="o">+</span> <span class="mi">1</span>
         <span class="k">when</span> <span class="s1">&#39;)&#39;</span>
           <span class="k">if</span> <span class="nx">parens</span><span class="p">[</span><span class="nx">parens</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">is</span> <span class="mi">0</span>
             <span class="nx">parens</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
             <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">:</span> <span class="s1">&#39;CALL_END&#39;</span>
           <span class="k">else</span>
-            <span class="nx">parens</span><span class="p">[</span><span class="nx">parens</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">-=</span> <span class="mi">1</span>
+            <span class="nx">parens</span><span class="p">[</span><span class="nx">parens</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span><span class="o">:</span> <span class="o">-</span> <span class="mi">1</span>
         <span class="k">when</span> <span class="s1">&#39;]&#39;</span>
           <span class="k">if</span> <span class="nx">brackets</span><span class="p">[</span><span class="nx">brackets</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">==</span> <span class="mi">0</span>
             <span class="nx">brackets</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
             <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">:</span> <span class="s1">&#39;INDEX_END&#39;</span>
           <span class="k">else</span>
-            <span class="nx">brackets</span><span class="p">[</span><span class="nx">brackets</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">-=</span> <span class="mi">1</span>
-      <span class="k">return</span> <span class="mi">1</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-10">#</a>               </div>               <p>Methods may be optionally called without parentheses, for simple cases.
+            <span class="nx">brackets</span><span class="p">[</span><span class="nx">brackets</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span><span class="o">:</span> <span class="o">-</span> <span class="mi">1</span>
+      <span class="k">return</span> <span class="mi">1</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-11">#</a>               </div>               <p>Methods may be optionally called without parentheses, for simple cases.
 Insert the implicit parentheses here, so that the parser doesn't have to
 deal with them.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">add_implicit_parentheses: </span><span class="o">-&gt;</span>
     <span class="nv">stack: </span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
-    <span class="err">@</span><span class="nx">scan_tokens</span> <span class="p">(</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">post</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span>
+    <span class="nv">calls: </span> <span class="mi">0</span>
+    <span class="nv">parens: </span><span class="mi">0</span>
+    <span class="nv">start_parens: </span><span class="mi">0</span>
+    <span class="nx">@scan_tokens</span> <span class="p">(</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">post</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span>
       <span class="nv">tag: </span><span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
-      <span class="nx">stack</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> <span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;INDENT&#39;</span>
-      <span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;OUTDENT&#39;</span>
-        <span class="nv">last: </span><span class="nx">stack</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
-        <span class="nx">stack</span><span class="p">[</span><span class="nx">stack</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">+=</span> <span class="nx">last</span>
-      <span class="k">if</span> <span class="o">!</span><span class="nx">post</span><span class="o">?</span> <span class="o">or</span> <span class="nx">include</span> <span class="nx">IMPLICIT_END</span><span class="p">,</span> <span class="nx">tag</span>
+      <span class="k">switch</span> <span class="nx">tag</span>
+        <span class="k">when</span> <span class="s1">&#39;CALL_START&#39;</span> <span class="k">then</span> <span class="nv">calls: </span><span class="o">+</span> <span class="mi">1</span>
+        <span class="k">when</span> <span class="s1">&#39;CALL_END&#39;</span>   <span class="k">then</span> <span class="nv">calls: </span><span class="o">-</span> <span class="mi">1</span>
+        <span class="k">when</span> <span class="s1">&#39;(&#39;</span>          <span class="k">then</span> <span class="nv">parens: </span><span class="o">+</span> <span class="mi">1</span>
+        <span class="k">when</span> <span class="s1">&#39;)&#39;</span>          <span class="k">then</span> <span class="nv">parens: </span><span class="o">-</span> <span class="mi">1</span>
+        <span class="k">when</span> <span class="s1">&#39;INDENT&#39;</span>     <span class="k">then</span> <span class="nx">stack</span><span class="p">.</span><span class="nx">push</span> <span class="mi">0</span>
+        <span class="k">when</span> <span class="s1">&#39;OUTDENT&#39;</span>
+          <span class="nv">last: </span><span class="nx">stack</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
+          <span class="nx">stack</span><span class="p">[</span><span class="nx">stack</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span><span class="o">:</span> <span class="o">+</span> <span class="nx">last</span>
+      <span class="nv">open: </span><span class="nx">stack</span><span class="p">[</span><span class="nx">stack</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">&gt;</span> <span class="mi">0</span>
+      <span class="k">if</span> <span class="o">!</span><span class="nx">post</span><span class="o">?</span> <span class="o">or</span> <span class="p">(</span><span class="nx">start_parens</span> <span class="o">&gt;</span> <span class="nx">parens</span><span class="p">)</span> <span class="o">or</span> <span class="p">(</span><span class="nx">parens</span> <span class="o">is</span> <span class="mi">0</span> <span class="o">and</span> <span class="nx">include</span> <span class="nx">IMPLICIT_END</span><span class="p">,</span> <span class="nx">tag</span><span class="p">)</span>
         <span class="k">return</span> <span class="mi">1</span> <span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;INDENT&#39;</span> <span class="o">and</span> <span class="nx">prev</span> <span class="o">and</span> <span class="nx">include</span> <span class="nx">IMPLICIT_BLOCK</span><span class="p">,</span> <span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
-        <span class="k">if</span> <span class="nx">stack</span><span class="p">[</span><span class="nx">stack</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">&gt;</span> <span class="mi">0</span> <span class="o">or</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;INDENT&#39;</span>
+        <span class="k">return</span> <span class="mi">1</span> <span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;OUTDENT&#39;</span> <span class="o">and</span> <span class="nx">token</span><span class="p">.</span><span class="nx">generated</span>
+        <span class="k">if</span> <span class="nx">open</span> <span class="o">or</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;INDENT&#39;</span>
           <span class="nv">idx: </span><span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;OUTDENT&#39;</span> <span class="k">then</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span> <span class="k">else</span> <span class="nx">i</span>
           <span class="nv">stack_pointer: </span><span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;INDENT&#39;</span> <span class="k">then</span> <span class="mi">2</span> <span class="k">else</span> <span class="mi">1</span>
           <span class="k">for</span> <span class="nx">tmp</span> <span class="k">in</span> <span class="p">[</span><span class="mi">0</span><span class="p">...</span><span class="nx">stack</span><span class="p">[</span><span class="nx">stack</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="nx">stack_pointer</span><span class="p">]]</span>
-            <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="nx">idx</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;CALL_END&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]])</span>
+            <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="nx">idx</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;CALL_END&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]])</span>
           <span class="nv">size: </span><span class="nx">stack</span><span class="p">[</span><span class="nx">stack</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="nx">stack_pointer</span><span class="p">]</span> <span class="o">+</span> <span class="mi">1</span>
           <span class="nx">stack</span><span class="p">[</span><span class="nx">stack</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="nx">stack_pointer</span><span class="p">]</span><span class="o">:</span> <span class="mi">0</span>
           <span class="k">return</span> <span class="nx">size</span>
-      <span class="k">return</span> <span class="mi">1</span> <span class="nx">unless</span> <span class="nx">prev</span> <span class="o">and</span> <span class="nx">include</span><span class="p">(</span><span class="nx">IMPLICIT_FUNC</span><span class="p">,</span> <span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="o">and</span> <span class="nx">include</span> <span class="nx">IMPLICIT_CALL</span><span class="p">,</span> <span class="nx">tag</span>
-      <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;CALL_START&#39;</span><span class="p">,</span> <span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]])</span>
-      <span class="nx">stack</span><span class="p">[</span><span class="nx">stack</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span>
-      <span class="k">return</span> <span class="mi">2</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-11">#</a>               </div>               <p>Because our grammar is LALR(1), it can't handle some single-line
+      <span class="k">return</span> <span class="mi">1</span> <span class="nx">unless</span> <span class="nx">prev</span> <span class="o">and</span> <span class="nx">include</span><span class="p">(</span><span class="nx">IMPLICIT_FUNC</span><span class="p">,</span> <span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="o">and</span> <span class="nx">include</span><span class="p">(</span><span class="nx">IMPLICIT_CALL</span><span class="p">,</span> <span class="nx">tag</span><span class="p">)</span>
+      <span class="nv">calls: </span><span class="mi">0</span>
+      <span class="nv">start_parens: </span><span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;(&#39;</span> <span class="k">then</span> <span class="nx">parens</span> <span class="o">-</span> <span class="mi">1</span> <span class="k">else</span> <span class="nx">parens</span>
+      <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;CALL_START&#39;</span><span class="p">,</span> <span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]]</span>
+      <span class="nx">stack</span><span class="p">[</span><span class="nx">stack</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span><span class="o">:</span> <span class="o">+</span> <span class="mi">1</span>
+      <span class="k">return</span> <span class="mi">2</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-12">#</a>               </div>               <p>Because our grammar is LALR(1), it can't handle some single-line
 expressions that lack ending delimiters. The <strong>Rewriter</strong> adds the implicit
 blocks, so it doesn't need to. ')' can close a single-line block,
 but we need to make sure it's balanced.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">add_implicit_indentation: </span><span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nx">scan_tokens</span> <span class="p">(</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">post</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span>
+    <span class="nx">@scan_tokens</span> <span class="p">(</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">post</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span>
       <span class="k">return</span> <span class="mi">1</span> <span class="nx">unless</span> <span class="nx">include</span><span class="p">(</span><span class="nx">SINGLE_LINERS</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="o">and</span>
         <span class="nx">post</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">isnt</span> <span class="s1">&#39;INDENT&#39;</span> <span class="o">and</span>
         <span class="o">not</span> <span class="p">(</span><span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;ELSE&#39;</span> <span class="o">and</span> <span class="nx">post</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;IF&#39;</span><span class="p">)</span>
       <span class="nv">starter: </span><span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
-      <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;INDENT&#39;</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]])</span>
+      <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;INDENT&#39;</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]]</span>
       <span class="nv">idx: </span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span>
       <span class="nv">parens: </span><span class="mi">0</span>
       <span class="k">while</span> <span class="kc">true</span>
-        <span class="nx">idx</span> <span class="o">+=</span> <span class="mi">1</span>
-        <span class="nv">tok: </span><span class="err">@</span><span class="nx">tokens</span><span class="p">[</span><span class="nx">idx</span><span class="p">]</span>
-        <span class="nv">pre: </span><span class="err">@</span><span class="nx">tokens</span><span class="p">[</span><span class="nx">idx</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span>
+        <span class="nv">idx: </span><span class="o">+</span> <span class="mi">1</span>
+        <span class="nv">tok: </span><span class="nx">@tokens</span><span class="p">[</span><span class="nx">idx</span><span class="p">]</span>
+        <span class="nv">pre: </span><span class="nx">@tokens</span><span class="p">[</span><span class="nx">idx</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span>
         <span class="k">if</span> <span class="p">(</span><span class="o">not</span> <span class="nx">tok</span> <span class="o">or</span>
             <span class="p">(</span><span class="nx">include</span><span class="p">(</span><span class="nx">SINGLE_CLOSERS</span><span class="p">,</span> <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="o">and</span> <span class="nx">tok</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">isnt</span> <span class="s1">&#39;;&#39;</span><span class="p">)</span> <span class="o">or</span>
-            <span class="p">(</span><span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;)&#39;</span> <span class="o">&amp;&amp;</span> <span class="nx">parens</span> <span class="o">is</span> <span class="mi">0</span><span class="p">))</span> <span class="o">and</span>
+            <span class="p">(</span><span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;)&#39;</span> <span class="o">and</span> <span class="nx">parens</span> <span class="o">is</span> <span class="mi">0</span><span class="p">))</span> <span class="o">and</span>
             <span class="o">not</span> <span class="p">(</span><span class="nx">starter</span> <span class="o">is</span> <span class="s1">&#39;ELSE&#39;</span> <span class="o">and</span> <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;ELSE&#39;</span><span class="p">)</span>
           <span class="nv">insertion: </span><span class="k">if</span> <span class="nx">pre</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s2">&quot;,&quot;</span> <span class="k">then</span> <span class="nx">idx</span> <span class="o">-</span> <span class="mi">1</span> <span class="k">else</span> <span class="nx">idx</span>
-          <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="nx">insertion</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;OUTDENT&#39;</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]])</span>
+          <span class="nv">outdent: </span><span class="p">[</span><span class="s1">&#39;OUTDENT&#39;</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]]</span>
+          <span class="nv">outdent.generated: </span><span class="kc">true</span>
+          <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">insertion</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">outdent</span>
           <span class="k">break</span>
-        <span class="nx">parens</span> <span class="o">+=</span> <span class="mi">1</span> <span class="k">if</span> <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;(&#39;</span>
-        <span class="nx">parens</span> <span class="o">-=</span> <span class="mi">1</span> <span class="k">if</span> <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;)&#39;</span>
+        <span class="nv">parens: </span><span class="o">+</span> <span class="mi">1</span> <span class="k">if</span> <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;(&#39;</span>
+        <span class="nv">parens: </span><span class="o">-</span> <span class="mi">1</span> <span class="k">if</span> <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;)&#39;</span>
       <span class="k">return</span> <span class="mi">1</span> <span class="nx">unless</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;THEN&#39;</span>
-      <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
-      <span class="k">return</span> <span class="mi">0</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-12">#</a>               </div>               <p>Ensure that all listed pairs of tokens are correctly balanced throughout
+      <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">1</span>
+      <span class="k">return</span> <span class="mi">0</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-13">#</a>               </div>               <p>Ensure that all listed pairs of tokens are correctly balanced throughout
 the course of the token stream.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">ensure_balance: </span><span class="p">(</span><span class="nx">pairs</span><span class="p">)</span> <span class="o">-&gt;</span>
     <span class="nv">levels: </span><span class="p">{}</span>
-    <span class="err">@</span><span class="nx">scan_tokens</span> <span class="p">(</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">post</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span>
+    <span class="nv">open_line: </span><span class="p">{}</span>
+    <span class="nx">@scan_tokens</span> <span class="p">(</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">post</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span>
       <span class="k">for</span> <span class="nx">pair</span> <span class="k">in</span> <span class="nx">pairs</span>
         <span class="p">[</span><span class="nx">open</span><span class="p">,</span> <span class="nx">close</span><span class="p">]</span><span class="o">:</span> <span class="nx">pair</span>
-        <span class="nx">levels</span><span class="p">[</span><span class="nx">open</span><span class="p">]</span> <span class="o">||=</span> <span class="mi">0</span>
-        <span class="nx">levels</span><span class="p">[</span><span class="nx">open</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span> <span class="k">if</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="nx">open</span>
-        <span class="nx">levels</span><span class="p">[</span><span class="nx">open</span><span class="p">]</span> <span class="o">-=</span> <span class="mi">1</span> <span class="k">if</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="nx">close</span>
+        <span class="nx">levels</span><span class="p">[</span><span class="nx">open</span><span class="p">]</span><span class="o">:</span> <span class="o">or</span> <span class="mi">0</span>
+        <span class="k">if</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="nx">open</span>
+          <span class="nx">open_line</span><span class="p">[</span><span class="nx">open</span><span class="p">]</span><span class="o">:</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="k">if</span> <span class="nx">levels</span><span class="p">[</span><span class="nx">open</span><span class="p">]</span> <span class="o">==</span> <span class="mi">0</span>
+          <span class="nx">levels</span><span class="p">[</span><span class="nx">open</span><span class="p">]</span><span class="o">:</span> <span class="o">+</span> <span class="mi">1</span>
+        <span class="nx">levels</span><span class="p">[</span><span class="nx">open</span><span class="p">]</span><span class="o">:</span> <span class="o">-</span> <span class="mi">1</span> <span class="k">if</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="nx">close</span>
         <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span><span class="p">(</span><span class="s2">&quot;too many ${token[1]} on line ${token[2] + 1}&quot;</span><span class="p">)</span> <span class="k">if</span> <span class="nx">levels</span><span class="p">[</span><span class="nx">open</span><span class="p">]</span> <span class="o">&lt;</span> <span class="mi">0</span>
       <span class="k">return</span> <span class="mi">1</span>
     <span class="nv">unclosed: </span><span class="nx">key</span> <span class="k">for</span> <span class="nx">key</span><span class="p">,</span> <span class="nx">value</span> <span class="k">of</span> <span class="nx">levels</span> <span class="k">when</span> <span class="nx">value</span> <span class="o">&gt;</span> <span class="mi">0</span>
-    <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span><span class="p">(</span><span class="s2">&quot;unclosed ${unclosed[0]}&quot;</span><span class="p">)</span> <span class="k">if</span> <span class="nx">unclosed</span><span class="p">.</span><span class="nx">length</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-13">#</a>               </div>               <p>We'd like to support syntax like this:</p>
+    <span class="k">if</span> <span class="nx">unclosed</span><span class="p">.</span><span class="nx">length</span>
+      <span class="nv">open: </span><span class="nx">unclosed</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
+      <span class="nv">line: </span><span class="nx">open_line</span><span class="p">[</span><span class="nx">open</span><span class="p">]</span> <span class="o">+</span> <span class="mi">1</span>
+      <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;unclosed $open on line $line&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-14">#</a>               </div>               <p>We'd like to support syntax like this:</p>
 
 <pre><code>el.click((event) -&gt;
   el.hide())
@@ -145,16 +168,16 @@ inwards, safely. The steps to accomplish this are:</p>
 
 <ol>
 <li>Check that all paired tokens are balanced and in order.</li>
-<li>Rewrite the stream with a stack: if you see an '(' or INDENT, add it
-to the stack. If you see an ')' or OUTDENT, pop the stack and replace
+<li>Rewrite the stream with a stack: if you see an <code>EXPRESSION_START</code>, add it
+to the stack. If you see an <code>EXPRESSION_END</code>, pop the stack and replace
 it with the inverse of what we've just popped.</li>
-<li>Keep track of "debt" for tokens that we fake, to make sure we end
+<li>Keep track of "debt" for tokens that we manufacture, to make sure we end
 up balanced in the end.</li>
 </ol>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">rewrite_closing_parens: </span><span class="o">-&gt;</span>
     <span class="nv">stack: </span><span class="p">[]</span>
     <span class="nv">debt: </span> <span class="p">{}</span>
     <span class="p">(</span><span class="nx">debt</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span><span class="o">:</span> <span class="mi">0</span><span class="p">)</span> <span class="k">for</span> <span class="nx">key</span><span class="p">,</span> <span class="nx">val</span> <span class="k">of</span> <span class="nx">INVERSES</span>
-    <span class="err">@</span><span class="nx">scan_tokens</span> <span class="p">(</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">post</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span>
+    <span class="nx">@scan_tokens</span> <span class="p">(</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">token</span><span class="p">,</span> <span class="nx">post</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span>
       <span class="nv">tag: </span><span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
       <span class="nv">inv: </span><span class="nx">INVERSES</span><span class="p">[</span><span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]]</span>
       <span class="k">if</span> <span class="nx">include</span> <span class="nx">EXPRESSION_START</span><span class="p">,</span> <span class="nx">tag</span>
@@ -162,30 +185,30 @@ up balanced in the end.</li>
         <span class="k">return</span> <span class="mi">1</span>
       <span class="k">else</span> <span class="k">if</span> <span class="nx">include</span> <span class="nx">EXPRESSION_END</span><span class="p">,</span> <span class="nx">tag</span>
         <span class="k">if</span> <span class="nx">debt</span><span class="p">[</span><span class="nx">inv</span><span class="p">]</span> <span class="o">&gt;</span> <span class="mi">0</span>
-          <span class="nx">debt</span><span class="p">[</span><span class="nx">inv</span><span class="p">]</span> <span class="o">-=</span> <span class="mi">1</span>
-          <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">1</span>
+          <span class="nx">debt</span><span class="p">[</span><span class="nx">inv</span><span class="p">]</span><span class="o">:</span> <span class="o">-</span> <span class="mi">1</span>
+          <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">1</span>
           <span class="k">return</span> <span class="mi">0</span>
         <span class="k">else</span>
           <span class="nv">match: </span><span class="nx">stack</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
           <span class="nv">mtag: </span> <span class="nx">match</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
           <span class="k">return</span> <span class="mi">1</span> <span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="nx">INVERSES</span><span class="p">[</span><span class="nx">mtag</span><span class="p">]</span>
-          <span class="nx">debt</span><span class="p">[</span><span class="nx">mtag</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span>
+          <span class="nx">debt</span><span class="p">[</span><span class="nx">mtag</span><span class="p">]</span><span class="o">:</span> <span class="o">+</span> <span class="mi">1</span>
           <span class="nv">val: </span><span class="k">if</span> <span class="nx">mtag</span> <span class="o">is</span> <span class="s1">&#39;INDENT&#39;</span> <span class="k">then</span> <span class="nx">match</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="k">else</span> <span class="nx">INVERSES</span><span class="p">[</span><span class="nx">mtag</span><span class="p">]</span>
-          <span class="err">@</span><span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="nx">INVERSES</span><span class="p">[</span><span class="nx">mtag</span><span class="p">],</span> <span class="nx">val</span><span class="p">]</span>
+          <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="nx">INVERSES</span><span class="p">[</span><span class="nx">mtag</span><span class="p">],</span> <span class="nx">val</span><span class="p">]</span>
           <span class="k">return</span> <span class="mi">1</span>
       <span class="k">else</span>
-        <span class="k">return</span> <span class="mi">1</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-14">#</a>               </div>               <h2>Constants</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-15">#</a>               </div>               <p>List of the token pairs that must be balanced.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">BALANCED_PAIRS: </span><span class="p">[[</span><span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;[&#39;</span><span class="p">,</span> <span class="s1">&#39;]&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;{&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;INDENT&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">],</span>
+        <span class="k">return</span> <span class="mi">1</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-15">#</a>               </div>               <h2>Constants</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-16">#</a>               </div>               <p>List of the token pairs that must be balanced.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">BALANCED_PAIRS: </span><span class="p">[[</span><span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;[&#39;</span><span class="p">,</span> <span class="s1">&#39;]&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;{&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;INDENT&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">],</span>
   <span class="p">[</span><span class="s1">&#39;PARAM_START&#39;</span><span class="p">,</span> <span class="s1">&#39;PARAM_END&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;CALL_START&#39;</span><span class="p">,</span> <span class="s1">&#39;CALL_END&#39;</span><span class="p">],</span>
-  <span class="p">[</span><span class="s1">&#39;INDEX_START&#39;</span><span class="p">,</span> <span class="s1">&#39;INDEX_END&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;SOAKED_INDEX_START&#39;</span><span class="p">,</span> <span class="s1">&#39;SOAKED_INDEX_END&#39;</span><span class="p">]]</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-16">#</a>               </div>               <p>The inverse mappings of <code>BALANCED_PAIRS</code> we're trying to fix up, so we can
+  <span class="p">[</span><span class="s1">&#39;INDEX_START&#39;</span><span class="p">,</span> <span class="s1">&#39;INDEX_END&#39;</span><span class="p">],</span> <span class="p">[</span><span class="s1">&#39;SOAKED_INDEX_START&#39;</span><span class="p">,</span> <span class="s1">&#39;SOAKED_INDEX_END&#39;</span><span class="p">]]</span></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-17">#</a>               </div>               <p>The inverse mappings of <code>BALANCED_PAIRS</code> we're trying to fix up, so we can
 look things up from either end.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">INVERSES: </span><span class="p">{}</span>
 <span class="k">for</span> <span class="nx">pair</span> <span class="k">in</span> <span class="nx">BALANCED_PAIRS</span>
   <span class="nx">INVERSES</span><span class="p">[</span><span class="nx">pair</span><span class="p">[</span><span class="mi">0</span><span class="p">]]</span><span class="o">:</span> <span class="nx">pair</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
-  <span class="nx">INVERSES</span><span class="p">[</span><span class="nx">pair</span><span class="p">[</span><span class="mi">1</span><span class="p">]]</span><span class="o">:</span> <span class="nx">pair</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-17">#</a>               </div>               <p>The tokens that signal the start of a balanced pair.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">EXPRESSION_START: </span><span class="nx">pair</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">for</span> <span class="nx">pair</span> <span class="k">in</span> <span class="nx">BALANCED_PAIRS</span></pre></div>             </td>           </tr>                               <tr id="section-18">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-18">#</a>               </div>               <p>The tokens that signal the end of a balanced pair.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">EXPRESSION_END: </span>  <span class="nx">pair</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="k">for</span> <span class="nx">pair</span> <span class="k">in</span> <span class="nx">BALANCED_PAIRS</span></pre></div>             </td>           </tr>                               <tr id="section-19">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-19">#</a>               </div>               <p>Tokens that indicate the close of a clause of an expression.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">EXPRESSION_CLOSE: </span><span class="p">[</span><span class="s1">&#39;CATCH&#39;</span><span class="p">,</span> <span class="s1">&#39;WHEN&#39;</span><span class="p">,</span> <span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s1">&#39;FINALLY&#39;</span><span class="p">].</span><span class="nx">concat</span> <span class="nx">EXPRESSION_END</span></pre></div>             </td>           </tr>                               <tr id="section-20">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-20">#</a>               </div>               <p>Tokens that, if followed by an <code>IMPLICIT_CALL</code>, indicate a function invocation.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_FUNC: </span> <span class="p">[</span><span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;SUPER&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="s1">&#39;CALL_END&#39;</span><span class="p">,</span> <span class="s1">&#39;]&#39;</span><span class="p">,</span> <span class="s1">&#39;INDEX_END&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-21">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-21">#</a>               </div>               <p>If preceded by an <code>IMPLICIT_FUNC</code>, indicates a function invocation.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_CALL: </span> <span class="p">[</span><span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;NUMBER&#39;</span><span class="p">,</span> <span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s1">&#39;JS&#39;</span><span class="p">,</span> <span class="s1">&#39;REGEX&#39;</span><span class="p">,</span> <span class="s1">&#39;NEW&#39;</span><span class="p">,</span> <span class="s1">&#39;PARAM_START&#39;</span><span class="p">,</span>
-                 <span class="s1">&#39;TRY&#39;</span><span class="p">,</span> <span class="s1">&#39;DELETE&#39;</span><span class="p">,</span> <span class="s1">&#39;TYPEOF&#39;</span><span class="p">,</span> <span class="s1">&#39;SWITCH&#39;</span><span class="p">,</span>
+  <span class="nx">INVERSES</span><span class="p">[</span><span class="nx">pair</span><span class="p">[</span><span class="mi">1</span><span class="p">]]</span><span class="o">:</span> <span class="nx">pair</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-18">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-18">#</a>               </div>               <p>The tokens that signal the start of a balanced pair.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">EXPRESSION_START: </span><span class="nx">pair</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">for</span> <span class="nx">pair</span> <span class="k">in</span> <span class="nx">BALANCED_PAIRS</span></pre></div>             </td>           </tr>                               <tr id="section-19">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-19">#</a>               </div>               <p>The tokens that signal the end of a balanced pair.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">EXPRESSION_END: </span>  <span class="nx">pair</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="k">for</span> <span class="nx">pair</span> <span class="k">in</span> <span class="nx">BALANCED_PAIRS</span></pre></div>             </td>           </tr>                               <tr id="section-20">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-20">#</a>               </div>               <p>Tokens that indicate the close of a clause of an expression.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">EXPRESSION_CLOSE: </span><span class="p">[</span><span class="s1">&#39;CATCH&#39;</span><span class="p">,</span> <span class="s1">&#39;WHEN&#39;</span><span class="p">,</span> <span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s1">&#39;FINALLY&#39;</span><span class="p">].</span><span class="nx">concat</span> <span class="nx">EXPRESSION_END</span></pre></div>             </td>           </tr>                               <tr id="section-21">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-21">#</a>               </div>               <p>Tokens that, if followed by an <code>IMPLICIT_CALL</code>, indicate a function invocation.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_FUNC: </span> <span class="p">[</span><span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;SUPER&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="s1">&#39;CALL_END&#39;</span><span class="p">,</span> <span class="s1">&#39;]&#39;</span><span class="p">,</span> <span class="s1">&#39;INDEX_END&#39;</span><span class="p">,</span> <span class="s1">&#39;&lt;-&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-22">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-22">#</a>               </div>               <p>If preceded by an <code>IMPLICIT_FUNC</code>, indicates a function invocation.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_CALL: </span> <span class="p">[</span><span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;NUMBER&#39;</span><span class="p">,</span> <span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s1">&#39;JS&#39;</span><span class="p">,</span> <span class="s1">&#39;REGEX&#39;</span><span class="p">,</span> <span class="s1">&#39;NEW&#39;</span><span class="p">,</span> <span class="s1">&#39;PARAM_START&#39;</span><span class="p">,</span>
+                 <span class="s1">&#39;TRY&#39;</span><span class="p">,</span> <span class="s1">&#39;DELETE&#39;</span><span class="p">,</span> <span class="s1">&#39;TYPEOF&#39;</span><span class="p">,</span> <span class="s1">&#39;SWITCH&#39;</span><span class="p">,</span> <span class="s1">&#39;EXTENSION&#39;</span><span class="p">,</span>
                  <span class="s1">&#39;TRUE&#39;</span><span class="p">,</span> <span class="s1">&#39;FALSE&#39;</span><span class="p">,</span> <span class="s1">&#39;YES&#39;</span><span class="p">,</span> <span class="s1">&#39;NO&#39;</span><span class="p">,</span> <span class="s1">&#39;ON&#39;</span><span class="p">,</span> <span class="s1">&#39;OFF&#39;</span><span class="p">,</span> <span class="s1">&#39;!&#39;</span><span class="p">,</span> <span class="s1">&#39;!!&#39;</span><span class="p">,</span> <span class="s1">&#39;NOT&#39;</span><span class="p">,</span>
-                 <span class="s1">&#39;@&#39;</span><span class="p">,</span> <span class="s1">&#39;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;[&#39;</span><span class="p">,</span> <span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="s1">&#39;{&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-22">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-22">#</a>               </div>               <p>Tokens indicating that the implicit call must enclose a block of expressions.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_BLOCK: </span><span class="p">[</span><span class="s1">&#39;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;{&#39;</span><span class="p">,</span> <span class="s1">&#39;[&#39;</span><span class="p">,</span> <span class="s1">&#39;,&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-23">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-23">#</a>               </div>               <p>Tokens that always mark the end of an implicit call for single-liners.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_END: </span>  <span class="p">[</span><span class="s1">&#39;IF&#39;</span><span class="p">,</span> <span class="s1">&#39;UNLESS&#39;</span><span class="p">,</span> <span class="s1">&#39;FOR&#39;</span><span class="p">,</span> <span class="s1">&#39;WHILE&#39;</span><span class="p">,</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;INDENT&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-24">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-24">#</a>               </div>               <p>Single-line flavors of block expressions that have unclosed endings.
+                 <span class="s1">&#39;THIS&#39;</span><span class="p">,</span> <span class="s1">&#39;NULL&#39;</span><span class="p">,</span>
+                 <span class="s1">&#39;@&#39;</span><span class="p">,</span> <span class="s1">&#39;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;[&#39;</span><span class="p">,</span> <span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="s1">&#39;{&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-23">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-23">#</a>               </div>               <p>Tokens indicating that the implicit call must enclose a block of expressions.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_BLOCK: </span><span class="p">[</span><span class="s1">&#39;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;{&#39;</span><span class="p">,</span> <span class="s1">&#39;[&#39;</span><span class="p">,</span> <span class="s1">&#39;,&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-24">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-24">#</a>               </div>               <p>Tokens that always mark the end of an implicit call for single-liners.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_END: </span>  <span class="p">[</span><span class="s1">&#39;IF&#39;</span><span class="p">,</span> <span class="s1">&#39;UNLESS&#39;</span><span class="p">,</span> <span class="s1">&#39;FOR&#39;</span><span class="p">,</span> <span class="s1">&#39;WHILE&#39;</span><span class="p">,</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;INDENT&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-25">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-25">#</a>               </div>               <p>Single-line flavors of block expressions that have unclosed endings.
 The grammar can't disambiguate them, so we insert the implicit indentation.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">SINGLE_LINERS: </span><span class="p">[</span><span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s2">&quot;-&gt;&quot;</span><span class="p">,</span> <span class="s2">&quot;=&gt;&quot;</span><span class="p">,</span> <span class="s1">&#39;TRY&#39;</span><span class="p">,</span> <span class="s1">&#39;FINALLY&#39;</span><span class="p">,</span> <span class="s1">&#39;THEN&#39;</span><span class="p">]</span>
-<span class="nv">SINGLE_CLOSERS: </span><span class="p">[</span><span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;CATCH&#39;</span><span class="p">,</span> <span class="s1">&#39;FINALLY&#39;</span><span class="p">,</span> <span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">,</span> <span class="s1">&#39;LEADING_WHEN&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-25">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-25">#</a>               </div>               <h2>Utility Functions</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-26">#</a>               </div>               <p>Does a list include a value?</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">include: </span><span class="p">(</span><span class="nx">list</span><span class="p">,</span> <span class="nx">value</span><span class="p">)</span> <span class="o">-&gt;</span>
-  <span class="nx">list</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">value</span><span class="p">)</span> <span class="o">&gt;=</span> <span class="mi">0</span>
+<span class="nv">SINGLE_CLOSERS: </span><span class="p">[</span><span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;CATCH&#39;</span><span class="p">,</span> <span class="s1">&#39;FINALLY&#39;</span><span class="p">,</span> <span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">,</span> <span class="s1">&#39;LEADING_WHEN&#39;</span><span class="p">]</span>
 
 </pre></div>             </td>           </tr>                </tbody>     </table>   </div> </body> </html> 

documentation/docs/scope.html

@@ -1,42 +1,48 @@
-<!DOCTYPE html>  <html> <head>   <title>scope.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               scope.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>The <strong>Scope</strong> class regulates lexical scoping within CoffeeScript. As you
+<!DOCTYPE html>  <html> <head>   <title>scope.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="helpers.html">                 helpers.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               scope.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>               <p>The <strong>Scope</strong> class regulates lexical scoping within CoffeeScript. As you
 generate code, you create a tree of scopes in the same shape as the nested
 function bodies. Each scope knows about the variables declared within it,
 and has a reference to its parent enclosing scope. In this way, we know which
 variables are new and need to be declared with <code>var</code>, and which are shared
 with the outside.</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-2">#</a>               </div>               <p>Set up exported variables for both <strong>Node.js</strong> and the browser.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">this</span><span class="p">.</span><span class="nv">exports: </span><span class="k">this</span> <span class="nx">unless</span> <span class="nx">process</span><span class="o">?</span>
 
-<span class="nv">exports.Scope: </span><span class="nx">class</span> <span class="nx">Scope</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>Initialize a scope with its parent, for lookups up the chain,
+<span class="nv">exports.Scope: </span><span class="nx">class</span> <span class="nx">Scope</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <p>The top-level <strong>Scope</strong> object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="vi">@root: </span><span class="kc">null</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <p>Initialize a scope with its parent, for lookups up the chain,
 as well as a reference to the <strong>Expressions</strong> node is belongs to, which is
 where it should declare its variables, and a reference to the function that
 it wraps.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">constructor: </span><span class="p">(</span><span class="nx">parent</span><span class="p">,</span> <span class="nx">expressions</span><span class="p">,</span> <span class="nx">method</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="p">[</span><span class="err">@</span><span class="nx">parent</span><span class="p">,</span> <span class="err">@</span><span class="nx">expressions</span><span class="p">,</span> <span class="err">@</span><span class="nx">method</span><span class="p">]</span><span class="o">:</span> <span class="p">[</span><span class="nx">parent</span><span class="p">,</span> <span class="nx">expressions</span><span class="p">,</span> <span class="nx">method</span><span class="p">]</span>
-    <span class="err">@</span><span class="nv">variables: </span><span class="p">{}</span>
-    <span class="err">@</span><span class="nv">temp_var: </span><span class="k">if</span> <span class="err">@</span><span class="nx">parent</span> <span class="k">then</span> <span class="err">@</span><span class="nx">parent</span><span class="p">.</span><span class="nx">temp_var</span> <span class="k">else</span> <span class="s1">&#39;_a&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <p>Look up a variable name in lexical scope, and declare it if it does not
+    <span class="p">[</span><span class="nx">@parent</span><span class="p">,</span> <span class="nx">@expressions</span><span class="p">,</span> <span class="nx">@method</span><span class="p">]</span><span class="o">:</span> <span class="p">[</span><span class="nx">parent</span><span class="p">,</span> <span class="nx">expressions</span><span class="p">,</span> <span class="nx">method</span><span class="p">]</span>
+    <span class="vi">@variables: </span><span class="p">{}</span>
+    <span class="k">if</span> <span class="nx">@parent</span>
+      <span class="vi">@temp_var: </span><span class="nx">@parent</span><span class="p">.</span><span class="nx">temp_var</span>
+    <span class="k">else</span>
+      <span class="nv">Scope.root: </span><span class="k">this</span>
+      <span class="vi">@temp_var: </span><span class="s1">&#39;_a&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-5">#</a>               </div>               <p>Look up a variable name in lexical scope, and declare it if it does not
 already exist.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">find: </span><span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="kc">true</span> <span class="k">if</span> <span class="err">@</span><span class="nx">check</span> <span class="nx">name</span>
-    <span class="err">@</span><span class="nx">variables</span><span class="p">[</span><span class="nx">name</span><span class="p">]</span><span class="o">:</span> <span class="s1">&#39;var&#39;</span>
-    <span class="kc">false</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-5">#</a>               </div>               <p>Reserve a variable name as originating from a function parameter for this
+    <span class="k">return</span> <span class="kc">true</span> <span class="k">if</span> <span class="nx">@check</span> <span class="nx">name</span>
+    <span class="nx">@variables</span><span class="p">[</span><span class="nx">name</span><span class="p">]</span><span class="o">:</span> <span class="s1">&#39;var&#39;</span>
+    <span class="kc">false</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-6">#</a>               </div>               <p>Test variables and return true the first time fn(v, k) returns true</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">any: </span><span class="p">(</span><span class="nx">fn</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="k">for</span> <span class="nx">v</span><span class="p">,</span> <span class="nx">k</span> <span class="k">of</span> <span class="nx">@variables</span> <span class="k">when</span> <span class="nx">fn</span><span class="p">(</span><span class="nx">v</span><span class="p">,</span> <span class="nx">k</span><span class="p">)</span>
+      <span class="k">return</span> <span class="kc">true</span>
+    <span class="k">return</span> <span class="kc">false</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-7">#</a>               </div>               <p>Reserve a variable name as originating from a function parameter for this
 scope. No <code>var</code> required for internal references.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">parameter: </span><span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nx">variables</span><span class="p">[</span><span class="nx">name</span><span class="p">]</span><span class="o">:</span> <span class="s1">&#39;param&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-6">#</a>               </div>               <p>Just check to see if a variable has already been declared, without reserving.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">check: </span><span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="kc">true</span> <span class="k">if</span> <span class="err">@</span><span class="nx">variables</span><span class="p">[</span><span class="nx">name</span><span class="p">]</span>
-    <span class="o">!!</span><span class="p">(</span><span class="err">@</span><span class="nx">parent</span> <span class="o">and</span> <span class="err">@</span><span class="nx">parent</span><span class="p">.</span><span class="nx">check</span><span class="p">(</span><span class="nx">name</span><span class="p">))</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-7">#</a>               </div>               <p>If we need to store an intermediate result, find an available name for a
+    <span class="nx">@variables</span><span class="p">[</span><span class="nx">name</span><span class="p">]</span><span class="o">:</span> <span class="s1">&#39;param&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-8">#</a>               </div>               <p>Just check to see if a variable has already been declared, without reserving.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">check: </span><span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="k">return</span> <span class="kc">true</span> <span class="k">if</span> <span class="nx">@variables</span><span class="p">[</span><span class="nx">name</span><span class="p">]</span>
+    <span class="o">!!</span><span class="p">(</span><span class="nx">@parent</span> <span class="o">and</span> <span class="nx">@parent</span><span class="p">.</span><span class="nx">check</span><span class="p">(</span><span class="nx">name</span><span class="p">))</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-9">#</a>               </div>               <p>If we need to store an intermediate result, find an available name for a
 compiler-generated variable. <code>_a</code>, <code>_b</code>, and so on...</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">free_variable: </span><span class="o">-&gt;</span>
-    <span class="k">while</span> <span class="err">@</span><span class="nx">check</span> <span class="err">@</span><span class="nx">temp_var</span>
-      <span class="nv">ordinal: </span><span class="mi">1</span> <span class="o">+</span> <span class="nb">parseInt</span> <span class="err">@</span><span class="nx">temp_var</span><span class="p">.</span><span class="nx">substr</span><span class="p">(</span><span class="mi">1</span><span class="p">),</span> <span class="mi">36</span>
-      <span class="err">@</span><span class="nv">temp_var: </span><span class="s1">&#39;_&#39;</span> <span class="o">+</span> <span class="nx">ordinal</span><span class="p">.</span><span class="nx">toString</span><span class="p">(</span><span class="mi">36</span><span class="p">).</span><span class="nx">replace</span><span class="p">(</span><span class="sr">/\d/g</span><span class="p">,</span> <span class="s1">&#39;a&#39;</span><span class="p">)</span>
-    <span class="err">@</span><span class="nx">variables</span><span class="p">[</span><span class="err">@</span><span class="nx">temp_var</span><span class="p">]</span><span class="o">:</span> <span class="s1">&#39;var&#39;</span>
-    <span class="err">@</span><span class="nx">temp_var</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-8">#</a>               </div>               <p>Ensure that an assignment is made at the top of this scope
-(or at the top-level scope, if requested).</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">assign: </span><span class="p">(</span><span class="nx">name</span><span class="p">,</span> <span class="nx">value</span><span class="p">,</span> <span class="nx">top_level</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">return</span> <span class="err">@</span><span class="nx">parent</span><span class="p">.</span><span class="nx">assign</span><span class="p">(</span><span class="nx">name</span><span class="p">,</span> <span class="nx">value</span><span class="p">,</span> <span class="nx">top_level</span><span class="p">)</span> <span class="k">if</span> <span class="nx">top_level</span> <span class="o">and</span> <span class="err">@</span><span class="nx">parent</span>
-    <span class="err">@</span><span class="nx">variables</span><span class="p">[</span><span class="nx">name</span><span class="p">]</span><span class="o">:</span> <span class="p">{</span><span class="nv">value: </span><span class="nx">value</span><span class="p">,</span> <span class="nv">assigned: </span><span class="kc">true</span><span class="p">}</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-9">#</a>               </div>               <p>Does this scope reference any variables that need to be declared in the
+    <span class="k">while</span> <span class="nx">@check</span> <span class="nx">@temp_var</span>
+      <span class="nv">ordinal: </span><span class="mi">1</span> <span class="o">+</span> <span class="nb">parseInt</span> <span class="nx">@temp_var</span><span class="p">.</span><span class="nx">substr</span><span class="p">(</span><span class="mi">1</span><span class="p">),</span> <span class="mi">36</span>
+      <span class="vi">@temp_var: </span><span class="s1">&#39;_&#39;</span> <span class="o">+</span> <span class="nx">ordinal</span><span class="p">.</span><span class="nx">toString</span><span class="p">(</span><span class="mi">36</span><span class="p">).</span><span class="nx">replace</span><span class="p">(</span><span class="sr">/\d/g</span><span class="p">,</span> <span class="s1">&#39;a&#39;</span><span class="p">)</span>
+    <span class="nx">@variables</span><span class="p">[</span><span class="nx">@temp_var</span><span class="p">]</span><span class="o">:</span> <span class="s1">&#39;var&#39;</span>
+    <span class="nx">@temp_var</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-10">#</a>               </div>               <p>Ensure that an assignment is made at the top of this scope
+(or at the top-level scope, if requested).</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">assign: </span><span class="p">(</span><span class="nx">name</span><span class="p">,</span> <span class="nx">value</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="nx">@variables</span><span class="p">[</span><span class="nx">name</span><span class="p">]</span><span class="o">:</span> <span class="p">{</span><span class="nv">value: </span><span class="nx">value</span><span class="p">,</span> <span class="nv">assigned: </span><span class="kc">true</span><span class="p">}</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-11">#</a>               </div>               <p>Does this scope reference any variables that need to be declared in the
 given function body?</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">has_declarations: </span><span class="p">(</span><span class="nx">body</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="nx">body</span> <span class="o">is</span> <span class="err">@</span><span class="nx">expressions</span> <span class="o">and</span> <span class="err">@</span><span class="nx">declared_variables</span><span class="p">().</span><span class="nx">length</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-10">#</a>               </div>               <p>Does this scope reference any assignments that need to be declared at the
+    <span class="nx">body</span> <span class="o">is</span> <span class="nx">@expressions</span> <span class="o">and</span> <span class="nx">@any</span> <span class="p">(</span><span class="nx">k</span><span class="p">,</span> <span class="nx">val</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">val</span> <span class="o">is</span> <span class="s1">&#39;var&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-12">#</a>               </div>               <p>Does this scope reference any assignments that need to be declared at the
 top of the given function body?</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">has_assignments: </span><span class="p">(</span><span class="nx">body</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="nx">body</span> <span class="o">is</span> <span class="err">@</span><span class="nx">expressions</span> <span class="o">and</span> <span class="err">@</span><span class="nx">assigned_variables</span><span class="p">().</span><span class="nx">length</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-11">#</a>               </div>               <p>Return the list of variables first declared in this scope.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">declared_variables: </span><span class="o">-&gt;</span>
-    <span class="p">(</span><span class="nx">key</span> <span class="k">for</span> <span class="nx">key</span><span class="p">,</span> <span class="nx">val</span> <span class="k">of</span> <span class="err">@</span><span class="nx">variables</span> <span class="k">when</span> <span class="nx">val</span> <span class="o">is</span> <span class="s1">&#39;var&#39;</span><span class="p">).</span><span class="nx">sort</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-12">#</a>               </div>               <p>Return the list of assignments that are supposed to be made at the top
+    <span class="nx">body</span> <span class="o">is</span> <span class="nx">@expressions</span> <span class="o">and</span> <span class="nx">@any</span> <span class="p">(</span><span class="nx">k</span><span class="p">,</span> <span class="nx">val</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">val</span><span class="p">.</span><span class="nx">assigned</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-13">#</a>               </div>               <p>Return the list of variables first declared in this scope.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">declared_variables: </span><span class="o">-&gt;</span>
+    <span class="p">(</span><span class="nx">key</span> <span class="k">for</span> <span class="nx">key</span><span class="p">,</span> <span class="nx">val</span> <span class="k">of</span> <span class="nx">@variables</span> <span class="k">when</span> <span class="nx">val</span> <span class="o">is</span> <span class="s1">&#39;var&#39;</span><span class="p">).</span><span class="nx">sort</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-14">#</a>               </div>               <p>Return the list of assignments that are supposed to be made at the top
 of this scope.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">assigned_variables: </span><span class="o">-&gt;</span>
-    <span class="s2">&quot;$key = ${val.value}&quot;</span> <span class="k">for</span> <span class="nx">key</span><span class="p">,</span> <span class="nx">val</span> <span class="k">of</span> <span class="err">@</span><span class="nx">variables</span> <span class="k">when</span> <span class="nx">val</span><span class="p">.</span><span class="nx">assigned</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-13">#</a>               </div>               <p>Compile the JavaScript for all of the variable declarations in this scope.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">compiled_declarations: </span><span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nx">declared_variables</span><span class="p">().</span><span class="nx">join</span> <span class="s1">&#39;, &#39;</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-14">#</a>               </div>               <p>Compile the JavaScript for all of the variable assignments in this scope.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">compiled_assignments: </span><span class="o">-&gt;</span>
-    <span class="err">@</span><span class="nx">assigned_variables</span><span class="p">().</span><span class="nx">join</span> <span class="s1">&#39;, &#39;</span>
+    <span class="s2">&quot;$key = ${val.value}&quot;</span> <span class="k">for</span> <span class="nx">key</span><span class="p">,</span> <span class="nx">val</span> <span class="k">of</span> <span class="nx">@variables</span> <span class="k">when</span> <span class="nx">val</span><span class="p">.</span><span class="nx">assigned</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-15">#</a>               </div>               <p>Compile the JavaScript for all of the variable declarations in this scope.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">compiled_declarations: </span><span class="o">-&gt;</span>
+    <span class="nx">@declared_variables</span><span class="p">().</span><span class="nx">join</span> <span class="s1">&#39;, &#39;</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-16">#</a>               </div>               <p>Compile the JavaScript for all of the variable assignments in this scope.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">compiled_assignments: </span><span class="o">-&gt;</span>
+    <span class="nx">@assigned_variables</span><span class="p">().</span><span class="nx">join</span> <span class="s1">&#39;, &#39;</span>
 
 </pre></div>             </td>           </tr>                </tbody>     </table>   </div> </body> </html> 

documentation/index.html.erb

@@ -46,7 +46,6 @@
         <a href="#conditionals">Conditionals, Ternaries, and Conditional Assignment</a>
         <a href="#aliases">Aliases</a>
         <a href="#splats">Splats...</a>
-        <a href="#arguments">Arguments are Arrays</a>
         <a href="#while">While Loops</a>
         <a href="#comprehensions">Comprehensions (Arrays, Objects, and Ranges)</a>
         <a href="#slice_splice">Array Slicing and Splicing with Ranges</a>
@@ -59,8 +58,8 @@
         <a href="#switch">Switch/When/Else</a>
         <a href="#try">Try/Catch/Finally</a>
         <a href="#comparisons">Chained Comparisons</a>
+        <a href="#interpolation">String and RegExp Interpolation</a>
         <a href="#strings">Multiline Strings and Heredocs</a>
-        <a href="#interpolation">String Interpolation</a>
         <a href="#cake">Cake, and Cakefiles</a>
         <a href="#scripts">"text/coffeescript" Script Tags</a>
         <a href="#resources">Resources</a>
@@ -76,7 +75,7 @@
           <div id="repl_source_wrap"><textarea id="repl_source">reverse: (string) ->
   string.split('').reverse().join ''
 
-alert reverse '!tpircseeffoC'</textarea></div>
+alert reverse '.eeffoC yrT'</textarea></div>
           <pre id="repl_results"></pre>
           <button class="full_screen">go full screen</button>
           <button class="minimize">minimize</button>
@@ -90,11 +89,12 @@ alert reverse '!tpircseeffoC'</textarea></div>
         Annotated Source
       </div>
       <div class="contents">
-        <a href="documentation/docs/grammar.html">The Grammar &mdash; src/grammar</a>
-        <a href="documentation/docs/lexer.html">The Lexer &mdash; src/lexer</a>
+        <a href="documentation/docs/grammar.html">Grammar Rules &mdash; src/grammar</a>
+        <a href="documentation/docs/lexer.html">Lexing Tokens &mdash; src/lexer</a>
         <a href="documentation/docs/rewriter.html">The Rewriter &mdash; src/rewriter</a>
         <a href="documentation/docs/nodes.html">The Syntax Tree &mdash; src/nodes</a>
         <a href="documentation/docs/scope.html">Lexical Scope &mdash; src/scope</a>
+        <a href="documentation/docs/helpers.html">Helpers &amp; Utility Functions &mdash; src/helpers</a>
         <a href="documentation/docs/coffee-script.html">The CoffeeScript Module &mdash; src/coffee-script</a>
         <a href="documentation/docs/cake.html">Cake &amp; Cakefiles &mdash; src/cake</a>
         <a href="documentation/docs/command.html">"coffee" Command-Line Utility &mdash; src/command</a>
@@ -129,7 +129,7 @@ alert reverse '!tpircseeffoC'</textarea></div>
 
     <p>
       <b>Latest Version:</b>
-      <a href="http://github.com/jashkenas/coffee-script/tarball/0.5.5">0.5.5</a>
+      <a href="http://github.com/jashkenas/coffee-script/tarball/0.6.0">0.6.0</a>
     </p>
 
     <h2>
@@ -143,7 +143,7 @@ alert reverse '!tpircseeffoC'</textarea></div>
 
     <p>
       For a longer CoffeeScript example, check out
-      <a href="documentation/underscore.html">Underscore.coffee</a>, a port
+      <a href="documentation/docs/underscore.html">Underscore.coffee</a>, a port
       of the <a href="http://documentcloud.github.com/underscore/">Underscore.js</a>
       library of helper functions. Underscore.coffee can pass the entire Underscore.js
       test suite. The CoffeeScript version is faster than the original for a number
@@ -161,7 +161,7 @@ alert reverse '!tpircseeffoC'</textarea></div>
 
     <p>
       The CoffeeScript compiler is written in pure CoffeeScript, using a
-      <a href="http://github.com/jashkenas/coffee-script/blob/master/src/grammar.coffee">small DSL</a>
+      <a href="documentation/docs/grammar.html">small DSL</a>
       on top of the <a href="http://github.com/zaach/jison">Jison parser generator</a>, and is available
       as a <a href="http://nodejs.org/">Node.js</a> utility. The core compiler however,
       does not depend on Node, and can be run in other server-side-JavaScript environments,
@@ -170,12 +170,12 @@ alert reverse '!tpircseeffoC'</textarea></div>
     </p>
 
     <p>
-      To install, first make sure you have a working version of
-      <a href="http://nodejs.org/">Node.js</a> version 0.1.31 or higher.
+      To install, first make sure you have a working copy of the latest tagged version of
+      <a href="http://nodejs.org/">Node.js</a>, currently <b>0.1.33</b> or higher.
       Then clone the CoffeeScript
       <a href="http://github.com/jashkenas/coffee-script">source repository</a>
       from GitHub, or download the latest
-      release: <a href="http://github.com/jashkenas/coffee-script/tarball/0.5.5">0.5.5</a>.
+      release: <a href="http://github.com/jashkenas/coffee-script/tarball/0.6.0">0.6.0</a>.
       To install the CoffeeScript compiler system-wide
       under <tt>/usr/local</tt>, open the directory and run:
     </p>
@@ -244,14 +244,14 @@ sudo bin/cake install</pre>
         <td>
           Pipe in CoffeeScript to STDIN and get back JavaScript over STDOUT.
           Good for use with processes written in other languages. An example:<br />
-          <tt>cat src/cake.coffee | coffee -s</tt>
+          <tt>cat src/cake.coffee | coffee -sc</tt>
         </td>
       </tr>
       <tr>
         <td><code>-e, --eval</code></td>
         <td>
           Compile and print a little snippet of CoffeeScript directly from the
-          command line. For example:<br /><tt>coffee -e "square: (x) -> x * x"</tt>
+          command line. For example:<br /><tt>coffee -e "puts num for num in [10..1]"</tt>
         </td>
       </tr>
       <tr>
@@ -395,6 +395,13 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
       should not be able to change the value of the external variable of the same name, and
       therefore has a declaration of its own.
     </p>
+    <p>
+      This behavior is effectively identical to Ruby's scope for local variables.
+      Because you don't have direct access to the <tt>var</tt> keyword,
+      it's impossible to shadow an outer variable on purpose, you may only refer
+      to it. So be careful that you're not reusing the name of an external
+      variable accidentally, if you're writing a deeply nested function.
+    </p>
     <p>
       Although suppressed within this documentation for clarity, all
       CoffeeScript output is wrapped in an anonymous function:
@@ -424,10 +431,9 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
     </p>
     <%= code_for('conditionals') %>
     <p>
-      The conditional assignment operators are included: <tt>||=</tt>,
-      which only assigns a value to a variable if the variable's current value
-      is falsy, and <tt>&amp;&amp;=</tt>, which only replaces the value of
-      truthy variables.
+      You can assign a variable to a half-expression to perform an operation
+      like Ruby's <tt>||=</tt>, which only assigns a value to a variable 
+      if the variable's current value is falsy.
     </p>
 
     <p>
@@ -474,16 +480,6 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
     </p>
     <%= code_for('splats', true) %>
 
-    <p>
-      <span id="arguments" class="bookmark"></span>
-      <b class="header">Arguments are Arrays</b>
-      If you reference the <b>arguments object</b> directly, it will be converted
-      into a real Array, making all of the
-      <a href="https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Objects/Array">Array methods</a>
-      available.
-    </p>
-    <%= code_for('arguments', true) %>
-
     <p>
       <span id="while" class="bookmark"></span>
       <b class="header">While Loops</b>
@@ -637,11 +633,15 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
     <p>
       If structuring your prototypes classically isn't your cup of tea, CoffeeScript
       provides a couple of lower-level conveniences. The <tt>extends</tt> operator
-      helps with proper prototype setup, as seen above, <tt>::</tt> gives you
+      helps with proper prototype setup, <tt>::</tt> gives you
       quick access to an object's prototype, and <tt>super()</tt>
       is converted into a call against the immediate ancestor's method of the same name.
     </p>
     <%= code_for('prototypes', '"one_two".dasherize()') %>
+    <p>
+      Finally, you may assign Class-level (static) properties within a class
+      definition by using<br /><tt>@property: value</tt>
+    </p>
 
     <p>
       <span id="pattern_matching" class="bookmark"></span>
@@ -665,6 +665,10 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
       to help pull out deeply nested properties.
     </p>
     <%= code_for('object_extraction', 'poet + " — " + street') %>
+    <p>
+      Pattern matching can even be combined with splats.
+    </p>
+    <%= code_for('patterns_and_splats', 'contents.join("")') %>
 
     <p>
       <span id="fat_arrow" class="bookmark"></span>
@@ -677,7 +681,7 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
       gives a good overview of the quirks.
     </p>
     <p>
-      The fat arrow <tt>=></tt> can be used to both define a function, and to bind
+      The fat arrow <tt>=&gt;</tt> can be used to both define a function, and to bind
       it to the current value of <tt>this</tt>, right on the spot. This is helpful
       when using callback-based libraries like Prototype or jQuery, for creating
       iterator functions to pass to <tt>each</tt>, or event-handler functions
@@ -690,6 +694,15 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
       have referred to the undefined "customer" property of the DOM element,
       and trying to call <tt>purchase()</tt> on it would have raised an exception.
     </p>
+    <p>
+      If you have more custom needs for function binding, CoffeeScript includes
+      the <tt>&lt;-</tt> bind operator, which works the same as ECMAScript 5
+      and Prototype.js's <tt>Function#bind</tt>. The first argument is the <tt>this</tt>
+      value, and the remainder are curried arguments. In the example below,
+      we curry a jQuery request for a URL, and then execute the bound function
+      with the missing callback argument.
+    </p>
+    <%= code_for('binding', true) %>
 
     <p>
       <span id="embedded" class="bookmark"></span>
@@ -736,6 +749,20 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
     </p>
     <%= code_for('comparisons', 'healthy') %>
 
+    <p>
+      <span id="interpolation" class="bookmark"></span>
+      <b class="header">String and RegExp Interpolation</b>
+      A version of <a href="http://wiki.ecmascript.org/doku.php?id=strawman:string_interpolation">ECMAScript Harmony's proposed string interpolation</a>
+      is included in CoffeeScript. Simple variables can be included by marking
+      them with a dollar sign.
+    </p>
+    <%= code_for('interpolation', 'quote') %>
+    <p>
+      And arbitrary expressions can be interpolated by using brackets <tt>${ ... }</tt><br />
+      Interpolation works the same way within regular expressions.
+    </p>
+    <%= code_for('interpolation_expression', 'sentence') %>
+
     <p>
       <span id="strings" class="bookmark"></span>
       <b class="header">Multiline Strings and Heredocs</b>
@@ -749,19 +776,9 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
       you can keep it all aligned with the body of your code.
     </p>
     <%= code_for('heredocs') %>
-
     <p>
-      <span id="interpolation" class="bookmark"></span>
-      <b class="header">String Interpolation</b>
-      A version of <a href="http://wiki.ecmascript.org/doku.php?id=strawman:string_interpolation">ECMAScript Harmony's proposed string interpolation</a>
-      is included in CoffeeScript. Simple variables can be included by marking
-      them with a dollar sign.
+      Double-quoted heredocs, like double-quoted strings, allow interpolation.
     </p>
-    <%= code_for('interpolation', 'quote') %>
-    <p>
-      And arbitrary expressions can be interpolated by using brackets <tt>${ ... }</tt>
-    </p>
-    <%= code_for('interpolation_expression', 'sentence') %>
 
     <h2>
       <span id="cake" class="bookmark"></span>
@@ -825,7 +842,7 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
         <tt>bin/cake build</tt> to rebuild the CoffeeScript compiler, and <br />
         <tt>bin/cake build:parser</tt> to regenerate the Jison parser if you're
         working on the grammar. <br /><br />
-        <tt>bin/cake build:full</tt> is a good command to run when you're working
+        <tt>git checkout lib &amp;&amp; bin/cake build:full</tt> is a good command to run when you're working
         on the core language. It'll refresh the lib directory
         (in case you broke something), build your altered compiler, use that to
         rebuild itself (a good sanity test) and then run all of the tests. If
@@ -843,20 +860,51 @@ coffee --print app/scripts/*.coffee > concatenation.js</pre>
       <li>
         <b>defunkt</b>'s <a href="http://github.com/defunkt/coffee-mode">CoffeeScript Major Mode</a>
         &mdash; a Emacs major mode that provides syntax highlighting, indentation
-        support, and some bonus commands. (For Vim and TextMate highlighters,
-        see the <tt>extras</tt> directory of the main repository.)
+        support, and some bonus commands.
+      </li>
+      <li>
+        <b>jashkenas</b>'s <a href="http://github.com/jashkenas/coffee-script-tmbundle">CoffeeScript TextMate Bundle</a>
+        &mdash; which provides syntax highlighting, snippet expansion, and the
+        ability to run bits of CoffeeScript from within TextMate itself.
+      </li>
+      <li>
+        <b>kchmck</b>'s <a href="http://github.com/kchmck/vim-coffee-script">Vim CoffeeScript</a>
+        &mdash; which adds Vim syntax highlighting and indentation support.
       </li>
       <li>
         <b>mattly</b>'s <a href="http://github.com/mattly/rack-coffee">rack-coffee</a>
         &mdash; a small Rack middleware for serving CoffeeScript files as
         compiled JavaScript on the fly.
       </li>
+      <li>
+        <b>jnicklas</b>'s <a href="http://github.com/jnicklas/bistro_car">BistroCar</a>
+        &mdash; a plugin that serves and bundles CoffeeScript from within your
+        Rails application.
+      </li>
     </ul>
 
     <h2>
       <span id="change_log" class="bookmark"></span>
       Change Log
     </h2>
+    
+    <p>
+      <b class="header" style="margin-top: 20px;">0.6.0</b>
+      Trailing commas are now allowed, a-la Python. Static 
+      properties may be assigned directly within class definitions, 
+      using <tt>@property</tt> notation.
+    </p>
+
+    <p>
+      <b class="header" style="margin-top: 20px;">0.5.6</b>
+      Interpolation can now be used within regular expressions and heredocs, as well as
+      strings. Added the <tt>&lt;-</tt> bind operator.
+      Allowing assignment to half-expressions instead of special <tt>||=</tt>-style
+      operators. The arguments object is no longer automatically converted into
+      an array. After requiring <tt>coffee-script</tt>, Node.js can now directly
+      load <tt>.coffee</tt> files, thanks to <b>registerExtension</b>. Multiple
+      splats can now be used in function calls, arrays, and pattern matching.
+    </p>
 
     <p>
       <b class="header" style="margin-top: 20px;">0.5.5</b>

documentation/js/arguments.js

@@ -1,8 +0,0 @@
-(function(){
-  var backwards;
-  backwards = function backwards() {
-    arguments = Array.prototype.slice.call(arguments, 0);
-    return alert(arguments.reverse());
-  };
-  backwards("stairway", "to", "heaven");
-})();

documentation/js/array_comprehensions.js

@@ -2,20 +2,20 @@
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, food, lunch, roid, roid2;
   // Eat lunch.
   lunch = (function() {
-    _a = []; _b = ['toast', 'cheese', 'wine'];
-    for (_c = 0, _d = _b.length; _c < _d; _c++) {
-      food = _b[_c];
+    _a = []; _c = ['toast', 'cheese', 'wine'];
+    for (_b = 0, _d = _c.length; _b < _d; _b++) {
+      food = _c[_b];
       _a.push(eat(food));
     }
     return _a;
   }).call(this);
   // Naive collision detection.
-  _e = asteroids;
-  for (_f = 0, _g = _e.length; _f < _g; _f++) {
-    roid = _e[_f];
-    _h = asteroids;
-    for (_i = 0, _j = _h.length; _i < _j; _i++) {
-      roid2 = _h[_i];
+  _f = asteroids;
+  for (_e = 0, _g = _f.length; _e < _g; _e++) {
+    roid = _f[_e];
+    _i = asteroids;
+    for (_h = 0, _j = _i.length; _h < _j; _h++) {
+      roid2 = _i[_h];
       if (roid !== roid2) {
         if (roid.overlaps(roid2)) {
           roid.explode();

documentation/js/binding.js

@@ -0,0 +1,13 @@
+(function(){
+  var get_source, url;
+  var __slice = Array.prototype.slice, __bind = function(func, obj, args) {
+    return function() {
+      return func.apply(obj || {}, args ? args.concat(__slice.call(arguments, 0)) : arguments);
+    };
+  };
+  url = "documentation/coffee/binding.coffee";
+  get_source = __bind(jQuery.get, jQuery, [url]);
+  get_source(function(response) {
+    return alert(response);
+  });
+})();

documentation/js/cake_tasks.js

@@ -1,10 +1,9 @@
 (function(){
-  process.mixin(require('assert'));
   task('test', 'run each of the unit tests', function() {
     var _a, _b, _c, _d, test;
-    _a = []; _b = test_files;
-    for (_c = 0, _d = _b.length; _c < _d; _c++) {
-      test = _b[_c];
+    _a = []; _c = test_files;
+    for (_b = 0, _d = _c.length; _b < _d; _b++) {
+      test = _c[_b];
       _a.push(fs.readFile(test, function(err, code) {
         return eval(coffee.compile(code));
       }));

documentation/js/expressions.js

@@ -4,7 +4,11 @@
     if (student.excellent_work) {
       return "A+";
     } else if (student.okay_stuff) {
-      return student.tried_hard ? "B" : "B-";
+      if (student.tried_hard) {
+        return "B";
+      } else {
+        return "B-";
+      }
     } else {
       return "C";
     }

documentation/js/expressions_assignment.js

@@ -1,4 +1,4 @@
 (function(){
   var one, six, three, two;
-  six = ((one = 1)) + ((two = 2)) + ((three = 3));
+  six = (one = 1) + (two = 2) + (three = 3);
 })();

documentation/js/fat_arrow.js

@@ -1,15 +1,15 @@
 (function(){
   var Account;
+  var __slice = Array.prototype.slice, __bind = function(func, obj, args) {
+    return function() {
+      return func.apply(obj || {}, args ? args.concat(__slice.call(arguments, 0)) : arguments);
+    };
+  };
   Account = function Account(customer, cart) {
     this.customer = customer;
     this.cart = cart;
-    return $('.shopping_cart').bind('click', (function(__this) {
-      var __func = function(event) {
+    return $('.shopping_cart').bind('click', __bind(function(event) {
         return this.customer.purchase(this.cart);
-      };
-      return (function() {
-        return __func.apply(__this, arguments);
-      });
-    })(this));
+      }, this));
   };
 })();

documentation/js/heredocs.js

@@ -1,4 +1,4 @@
 (function(){
   var html;
-  html = "<strong>\n  cup of coffeescript\n</strong>";
+  html = '<strong>\n  cup of coffeescript\n</strong>';
 })();

documentation/js/interpolation_expression.js

@@ -1,4 +1,6 @@
 (function(){
-  var sentence;
-  sentence = (22 / 7) + " is a decent approximation of π";
+  var dates, sentence, sep;
+  sentence = "" + (22 / 7) + " is a decent approximation of π";
+  sep = "[.\\/\\- ]";
+  dates = (new RegExp("\\d+" + sep + "\\d+" + sep + "\\d+", "g"));
 })();

documentation/js/overview.js

@@ -1,5 +1,6 @@
 (function(){
   var _a, _b, _c, _d, cubed_list, list, math, num, number, opposite_day, race, square;
+  var __slice = Array.prototype.slice;
   // Assignment:
   number = 42;
   opposite_day = true;
@@ -24,7 +25,7 @@
   // Splats:
   race = function race(winner) {
     var runners;
-    runners = Array.prototype.slice.call(arguments, 1);
+    runners = __slice.call(arguments, 1, arguments.length - 0);
     return print(winner, runners);
   };
   // Existence:
@@ -33,9 +34,9 @@
   }
   // Array comprehensions:
   cubed_list = (function() {
-    _a = []; _b = list;
-    for (_c = 0, _d = _b.length; _c < _d; _c++) {
-      num = _b[_c];
+    _a = []; _c = list;
+    for (_b = 0, _d = _c.length; _b < _d; _b++) {
+      num = _c[_b];
       _a.push(math.cube(num));
     }
     return _a;

documentation/js/patterns_and_splats.js

@@ -0,0 +1,9 @@
+(function(){
+  var _a, close, contents, open, tag;
+  var __slice = Array.prototype.slice;
+  tag = "<impossible>";
+  _a = tag.split("");
+  open = _a[0];
+  contents = __slice.call(_a, 1, _a.length - 1);
+  close = _a[_a.length - 1];
+})();

documentation/js/range_comprehensions.js

@@ -1,21 +1,21 @@
 (function(){
-  var _a, _b, _c, _d, _e, countdown, egg_delivery, num;
+  var _a, _b, _c, _d, countdown, egg_delivery, num;
   countdown = (function() {
-    _a = []; _d = 10; _e = 1;
-    for (_c = 0, num = _d; (_d <= _e ? num <= _e : num >= _e); (_d <= _e ? num += 1 : num -= 1), _c++) {
+    _a = []; _c = 10; _d = 1;
+    for (_b = 0, num = _c; (_c <= _d ? num <= _d : num >= _d); (_c <= _d ? num += 1 : num -= 1), _b++) {
       _a.push(num);
     }
     return _a;
   }).call(this);
   egg_delivery = function egg_delivery() {
-    var _f, _g, _h, _i, _j, dozen_eggs, i;
-    _f = []; _i = 0; _j = eggs.length;
-    for (_h = 0, i = _i; (_i <= _j ? i < _j : i > _j); (_i <= _j ? i += 12 : i -= 12), _h++) {
-      _f.push((function() {
+    var _e, _f, _g, _h, dozen_eggs, i;
+    _e = []; _g = 0; _h = eggs.length;
+    for (_f = 0, i = _g; (_g <= _h ? i < _h : i > _h); (_g <= _h ? i += 12 : i -= 12), _f++) {
+      _e.push((function() {
         dozen_eggs = eggs.slice(i, i + 12);
         return deliver(new egg_carton(dozen));
       }).call(this));
     }
-    return _f;
+    return _e;
   };
 })();

documentation/js/scope.js

@@ -4,7 +4,8 @@
   change_numbers = function change_numbers() {
     var new_num;
     new_num = -1;
-    return num = 10;
+    num = 10;
+    return num;
   };
   new_num = change_numbers();
 })();

documentation/js/splats.js

@@ -1,12 +1,14 @@
 (function(){
   var award_medals, contenders, gold, silver, the_field;
+  var __slice = Array.prototype.slice;
   gold = (silver = (the_field = "unknown"));
   award_medals = function award_medals(first, second) {
     var rest;
-    rest = Array.prototype.slice.call(arguments, 2);
+    rest = __slice.call(arguments, 2, arguments.length - 0);
     gold = first;
     silver = second;
-    return the_field = rest;
+    the_field = rest;
+    return the_field;
   };
   contenders = ["Michael Phelps", "Liu Xiang", "Yao Ming", "Allyson Felix", "Shawn Johnson", "Roman Sebrle", "Guo Jingjing", "Tyson Gay", "Asafa Powell", "Usain Bolt"];
   award_medals.apply(this, contenders);

documentation/underscore.html

@@ -1,668 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
-
-<head>
-  <meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
-  <link rel="stylesheet" type="text/css" media="screen,projection,print" href="css/idle.css" />
-  <title>Underscore.coffee</title>
-</head>
-
-<body>
-<pre class="idle"><span class="line-numbers">   1 </span> 
-<span class="line-numbers">   2 </span>   <span class="Comment"><span class="Comment">#</span> Underscore.coffee</span>
-<span class="line-numbers">   3 </span>   <span class="Comment"><span class="Comment">#</span> (c) 2010 Jeremy Ashkenas, DocumentCloud Inc.</span>
-<span class="line-numbers">   4 </span>   <span class="Comment"><span class="Comment">#</span> Underscore is freely distributable under the terms of the MIT license.</span>
-<span class="line-numbers">   5 </span>   <span class="Comment"><span class="Comment">#</span> Portions of Underscore are inspired by or borrowed from Prototype.js,</span>
-<span class="line-numbers">   6 </span>   <span class="Comment"><span class="Comment">#</span> Oliver Steele's Functional, and John Resig's Micro-Templating.</span>
-<span class="line-numbers">   7 </span>   <span class="Comment"><span class="Comment">#</span> For all details and documentation:</span>
-<span class="line-numbers">   8 </span>   <span class="Comment"><span class="Comment">#</span> http://documentcloud.github.com/underscore/</span>
-<span class="line-numbers">   9 </span> 
-<span class="line-numbers">  10 </span> 
-<span class="line-numbers">  11 </span>   <span class="Comment"><span class="Comment">#</span> ------------------------- Baseline setup ---------------------------------</span>
-<span class="line-numbers">  12 </span> 
-<span class="line-numbers">  13 </span>   <span class="Comment"><span class="Comment">#</span> Establish the root object, &quot;window&quot; in the browser, or &quot;global&quot; on the server.</span>
-<span class="line-numbers">  14 </span>   <span class="FunctionName">root</span><span class="Keyword">:</span> <span class="Variable">this</span>
-<span class="line-numbers">  15 </span> 
-<span class="line-numbers">  16 </span> 
-<span class="line-numbers">  17 </span>   <span class="Comment"><span class="Comment">#</span> Save the previous value of the &quot;_&quot; variable.</span>
-<span class="line-numbers">  18 </span>   <span class="FunctionName">previousUnderscore</span><span class="Keyword">:</span> root._
-<span class="line-numbers">  19 </span> 
-<span class="line-numbers">  20 </span> 
-<span class="line-numbers">  21 </span>   <span class="Comment"><span class="Comment">#</span> Establish the object that gets thrown to break out of a loop iteration.</span>
-<span class="line-numbers">  22 </span>   <span class="FunctionName">breaker</span><span class="Keyword">:</span> <span class="Keyword">if</span> <span class="Keyword">typeof</span>(StopIteration) <span class="Keyword">is</span> <span class="String"><span class="String">'</span>undefined<span class="String">'</span></span> <span class="Keyword">then</span> <span class="String"><span class="String">'</span>__break__<span class="String">'</span></span> <span class="Keyword">else</span> StopIteration
-<span class="line-numbers">  23 </span> 
-<span class="line-numbers">  24 </span> 
-<span class="line-numbers">  25 </span>   <span class="Comment"><span class="Comment">#</span> Quick regexp-escaping function, because JS doesn't have RegExp.escape().</span>
-<span class="line-numbers">  26 </span>   <span class="FunctionName">escapeRegExp</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">string</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> string.replace(<span class="String"><span class="String">/</span>([.*+?^${}()|[<span class="UserDefinedConstant">\]</span><span class="UserDefinedConstant">\/</span><span class="UserDefinedConstant">\\</span>])<span class="String">/</span>g</span>, <span class="String"><span class="String">'</span><span class="UserDefinedConstant">\\</span>$1<span class="String">'</span></span>)
-<span class="line-numbers">  27 </span> 
-<span class="line-numbers">  28 </span> 
-<span class="line-numbers">  29 </span>   <span class="Comment"><span class="Comment">#</span> Save bytes in the minified (but not gzipped) version:</span>
-<span class="line-numbers">  30 </span>   <span class="FunctionName">ArrayProto</span><span class="Keyword">:</span>           Array.prototype
-<span class="line-numbers">  31 </span>   <span class="FunctionName">ObjProto</span><span class="Keyword">:</span>             Object.prototype
-<span class="line-numbers">  32 </span> 
-<span class="line-numbers">  33 </span> 
-<span class="line-numbers">  34 </span>   <span class="Comment"><span class="Comment">#</span>Create quick reference variables for speed access to core prototypes.</span>
-<span class="line-numbers">  35 </span>   <span class="FunctionName">slice</span><span class="Keyword">:</span>                ArrayProto.slice
-<span class="line-numbers">  36 </span>   <span class="FunctionName">unshift</span><span class="Keyword">:</span>              ArrayProto.unshift
-<span class="line-numbers">  37 </span>   <span class="FunctionName">toString</span><span class="Keyword">:</span>             ObjProto.toString
-<span class="line-numbers">  38 </span>   <span class="FunctionName">hasOwnProperty</span><span class="Keyword">:</span>       ObjProto.hasOwnProperty
-<span class="line-numbers">  39 </span>   <span class="FunctionName">propertyIsEnumerable</span><span class="Keyword">:</span> ObjProto.propertyIsEnumerable
-<span class="line-numbers">  40 </span> 
-<span class="line-numbers">  41 </span> 
-<span class="line-numbers">  42 </span>   <span class="Comment"><span class="Comment">#</span> All ECMA5 native implementations we hope to use are declared here.</span>
-<span class="line-numbers">  43 </span>   <span class="FunctionName">nativeForEach</span><span class="Keyword">:</span>        ArrayProto.forEach
-<span class="line-numbers">  44 </span>   <span class="FunctionName">nativeMap</span><span class="Keyword">:</span>            ArrayProto.map
-<span class="line-numbers">  45 </span>   <span class="FunctionName">nativeReduce</span><span class="Keyword">:</span>         ArrayProto.reduce
-<span class="line-numbers">  46 </span>   <span class="FunctionName">nativeReduceRight</span><span class="Keyword">:</span>    ArrayProto.reduceRight
-<span class="line-numbers">  47 </span>   <span class="FunctionName">nativeFilter</span><span class="Keyword">:</span>         ArrayProto.filter
-<span class="line-numbers">  48 </span>   <span class="FunctionName">nativeEvery</span><span class="Keyword">:</span>          ArrayProto.every
-<span class="line-numbers">  49 </span>   <span class="FunctionName">nativeSome</span><span class="Keyword">:</span>           ArrayProto.some
-<span class="line-numbers">  50 </span>   <span class="FunctionName">nativeIndexOf</span><span class="Keyword">:</span>        ArrayProto.indexOf
-<span class="line-numbers">  51 </span>   <span class="FunctionName">nativeLastIndexOf</span><span class="Keyword">:</span>    ArrayProto.lastIndexOf
-<span class="line-numbers">  52 </span>   <span class="FunctionName">nativeIsArray</span><span class="Keyword">:</span>        Array.isArray
-<span class="line-numbers">  53 </span>   <span class="FunctionName">nativeKeys</span><span class="Keyword">:</span>           Object.keys
-<span class="line-numbers">  54 </span> 
-<span class="line-numbers">  55 </span> 
-<span class="line-numbers">  56 </span>   <span class="Comment"><span class="Comment">#</span> Create a safe reference to the Underscore object for use below.</span>
-<span class="line-numbers">  57 </span>   <span class="FunctionName">_</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> <span class="Keyword">new</span> <span class="TypeName">wrapper</span>(obj)
-<span class="line-numbers">  58 </span> 
-<span class="line-numbers">  59 </span> 
-<span class="line-numbers">  60 </span>   <span class="Comment"><span class="Comment">#</span> Export the Underscore object for CommonJS.</span>
-<span class="line-numbers">  61 </span>   <span class="Keyword">if</span> <span class="Keyword">typeof</span>(exports) <span class="Keyword">!</span><span class="Keyword">=</span> <span class="String"><span class="String">'</span>undefined<span class="String">'</span></span> <span class="Keyword">then</span> <span class="FunctionName">exports._</span><span class="Keyword">:</span> _
-<span class="line-numbers">  62 </span> 
-<span class="line-numbers">  63 </span> 
-<span class="line-numbers">  64 </span>   <span class="Comment"><span class="Comment">#</span> Export Underscore to global scope.</span>
-<span class="line-numbers">  65 </span>   <span class="FunctionName">root._</span><span class="Keyword">:</span> _
-<span class="line-numbers">  66 </span> 
-<span class="line-numbers">  67 </span> 
-<span class="line-numbers">  68 </span>   <span class="Comment"><span class="Comment">#</span> Current version.</span>
-<span class="line-numbers">  69 </span>   <span class="FunctionName">_.VERSION</span><span class="Keyword">:</span> <span class="String"><span class="String">'</span>0.6.0<span class="String">'</span></span>
-<span class="line-numbers">  70 </span> 
-<span class="line-numbers">  71 </span> 
-<span class="line-numbers">  72 </span>   <span class="Comment"><span class="Comment">#</span> ------------------------ Collection Functions: ---------------------------</span>
-<span class="line-numbers">  73 </span> 
-<span class="line-numbers">  74 </span>   <span class="Comment"><span class="Comment">#</span> The cornerstone, an each implementation.</span>
-<span class="line-numbers">  75 </span>   <span class="Comment"><span class="Comment">#</span> Handles objects implementing forEach, arrays, and raw objects.</span>
-<span class="line-numbers">  76 </span>   <span class="FunctionName">_.each</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, iterator, context</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers">  77 </span>     <span class="Keyword">try</span>
-<span class="line-numbers">  78 </span>       <span class="Keyword">if</span> nativeForEach <span class="Keyword">and</span> obj.forEach <span class="Keyword">is</span> nativeForEach
-<span class="line-numbers">  79 </span>         obj.forEach iterator, context
-<span class="line-numbers">  80 </span>       <span class="Keyword">else</span> <span class="Keyword">if</span> _.isNumber obj.length
-<span class="line-numbers">  81 </span>         iterator.call(context, obj[i], i, obj) <span class="Keyword">for</span> i <span class="Keyword">in</span> [<span class="Number">0</span>...obj.length]
-<span class="line-numbers">  82 </span>       <span class="Keyword">else</span>
-<span class="line-numbers">  83 </span>         iterator.call(context, val, key, obj) <span class="Keyword">for</span> key, val <span class="Keyword">of</span> obj
-<span class="line-numbers">  84 </span>     <span class="Keyword">catch</span> e
-<span class="line-numbers">  85 </span>       <span class="Keyword">throw</span> e <span class="Keyword">if</span> e <span class="Keyword">isnt</span> breaker
-<span class="line-numbers">  86 </span>     obj
-<span class="line-numbers">  87 </span> 
-<span class="line-numbers">  88 </span> 
-<span class="line-numbers">  89 </span>   <span class="Comment"><span class="Comment">#</span> Return the results of applying the iterator to each element. Use JavaScript</span>
-<span class="line-numbers">  90 </span>   <span class="Comment"><span class="Comment">#</span> 1.6's version of map, if possible.</span>
-<span class="line-numbers">  91 </span>   <span class="FunctionName">_.map</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, iterator, context</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers">  92 </span>     <span class="Keyword">return</span> obj.map(iterator, context) <span class="Keyword">if</span> nativeMap <span class="Keyword">and</span> obj.map <span class="Keyword">is</span> nativeMap
-<span class="line-numbers">  93 </span>     <span class="FunctionName">results</span><span class="Keyword">:</span> []
-<span class="line-numbers">  94 </span>     _.each obj, <span class="FunctionArgument">(</span><span class="FunctionArgument">value, index, list</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers">  95 </span>       results.push iterator.call context, value, index, list
-<span class="line-numbers">  96 </span>     results
-<span class="line-numbers">  97 </span> 
-<span class="line-numbers">  98 </span> 
-<span class="line-numbers">  99 </span>   <span class="Comment"><span class="Comment">#</span> Reduce builds up a single result from a list of values. Also known as</span>
-<span class="line-numbers"> 100 </span>   <span class="Comment"><span class="Comment">#</span> inject, or foldl. Uses JavaScript 1.8's version of reduce, if possible.</span>
-<span class="line-numbers"> 101 </span>   <span class="FunctionName">_.reduce</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, memo, iterator, context</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 102 </span>     <span class="Keyword">return</span> obj.reduce(_.bind(iterator, context), memo) <span class="Keyword">if</span> nativeReduce <span class="Keyword">and</span> obj.reduce <span class="Keyword">is</span> nativeReduce
-<span class="line-numbers"> 103 </span>     _.each obj, <span class="FunctionArgument">(</span><span class="FunctionArgument">value, index, list</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 104 </span>       <span class="FunctionName">memo</span><span class="Keyword">:</span> iterator.call context, memo, value, index, list
-<span class="line-numbers"> 105 </span>     memo
-<span class="line-numbers"> 106 </span> 
-<span class="line-numbers"> 107 </span> 
-<span class="line-numbers"> 108 </span>   <span class="Comment"><span class="Comment">#</span> The right-associative version of reduce, also known as foldr. Uses</span>
-<span class="line-numbers"> 109 </span>   <span class="Comment"><span class="Comment">#</span> JavaScript 1.8's version of reduceRight, if available.</span>
-<span class="line-numbers"> 110 </span>   <span class="FunctionName">_.reduceRight</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, memo, iterator, context</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 111 </span>     <span class="Keyword">return</span> obj.reduceRight(_.bind(iterator, context), memo) <span class="Keyword">if</span> nativeReduceRight <span class="Keyword">and</span> obj.reduceRight <span class="Keyword">is</span> nativeReduceRight
-<span class="line-numbers"> 112 </span>     _.each _.clone(_.toArray(obj)).reverse(), <span class="FunctionArgument">(</span><span class="FunctionArgument">value, index</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 113 </span>       <span class="FunctionName">memo</span><span class="Keyword">:</span> iterator.call context, memo, value, index, obj
-<span class="line-numbers"> 114 </span>     memo
-<span class="line-numbers"> 115 </span> 
-<span class="line-numbers"> 116 </span> 
-<span class="line-numbers"> 117 </span>   <span class="Comment"><span class="Comment">#</span> Return the first value which passes a truth test.</span>
-<span class="line-numbers"> 118 </span>   <span class="FunctionName">_.detect</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, iterator, context</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 119 </span>     <span class="FunctionName">result</span><span class="Keyword">:</span> <span class="BuiltInConstant">null</span>
-<span class="line-numbers"> 120 </span>     _.each obj, <span class="FunctionArgument">(</span><span class="FunctionArgument">value, index, list</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 121 </span>       <span class="Keyword">if</span> iterator.call context, value, index, list
-<span class="line-numbers"> 122 </span>         <span class="FunctionName">result</span><span class="Keyword">:</span> value
-<span class="line-numbers"> 123 </span>         _.breakLoop()
-<span class="line-numbers"> 124 </span>     result
-<span class="line-numbers"> 125 </span> 
-<span class="line-numbers"> 126 </span> 
-<span class="line-numbers"> 127 </span>   <span class="Comment"><span class="Comment">#</span> Return all the elements that pass a truth test. Use JavaScript 1.6's</span>
-<span class="line-numbers"> 128 </span>   <span class="Comment"><span class="Comment">#</span> filter(), if it exists.</span>
-<span class="line-numbers"> 129 </span>   <span class="FunctionName">_.filter</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, iterator, context</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 130 </span>     <span class="Keyword">return</span> obj.filter iterator, context <span class="Keyword">if</span> nativeFilter <span class="Keyword">and</span> obj.filter <span class="Keyword">is</span> nativeFilter
-<span class="line-numbers"> 131 </span>     <span class="FunctionName">results</span><span class="Keyword">:</span> []
-<span class="line-numbers"> 132 </span>     _.each obj, <span class="FunctionArgument">(</span><span class="FunctionArgument">value, index, list</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 133 </span>       results.push value <span class="Keyword">if</span> iterator.call context, value, index, list
-<span class="line-numbers"> 134 </span>     results
-<span class="line-numbers"> 135 </span> 
-<span class="line-numbers"> 136 </span> 
-<span class="line-numbers"> 137 </span>   <span class="Comment"><span class="Comment">#</span> Return all the elements for which a truth test fails.</span>
-<span class="line-numbers"> 138 </span>   <span class="FunctionName">_.reject</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, iterator, context</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 139 </span>     <span class="FunctionName">results</span><span class="Keyword">:</span> []
-<span class="line-numbers"> 140 </span>     _.each obj, <span class="FunctionArgument">(</span><span class="FunctionArgument">value, index, list</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 141 </span>       results.push value <span class="Keyword">if</span> <span class="Keyword">not</span> iterator.call context, value, index, list
-<span class="line-numbers"> 142 </span>     results
-<span class="line-numbers"> 143 </span> 
-<span class="line-numbers"> 144 </span> 
-<span class="line-numbers"> 145 </span>   <span class="Comment"><span class="Comment">#</span> Determine whether all of the elements match a truth test. Delegate to</span>
-<span class="line-numbers"> 146 </span>   <span class="Comment"><span class="Comment">#</span> JavaScript 1.6's every(), if it is present.</span>
-<span class="line-numbers"> 147 </span>   <span class="FunctionName">_.every</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, iterator, context</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 148 </span>     iterator <span class="Keyword">||</span><span class="Keyword">=</span> _.identity
-<span class="line-numbers"> 149 </span>     <span class="Keyword">return</span> obj.every iterator, context <span class="Keyword">if</span> nativeEvery <span class="Keyword">and</span> obj.every <span class="Keyword">is</span> nativeEvery
-<span class="line-numbers"> 150 </span>     <span class="FunctionName">result</span><span class="Keyword">:</span> <span class="BuiltInConstant">true</span>
-<span class="line-numbers"> 151 </span>     _.each obj, <span class="FunctionArgument">(</span><span class="FunctionArgument">value, index, list</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 152 </span>       _.breakLoop() <span class="Keyword">unless</span> (<span class="FunctionName">result</span><span class="Keyword">:</span> result <span class="Keyword">and</span> iterator.call(context, value, index, list))
-<span class="line-numbers"> 153 </span>     result
-<span class="line-numbers"> 154 </span> 
-<span class="line-numbers"> 155 </span> 
-<span class="line-numbers"> 156 </span>   <span class="Comment"><span class="Comment">#</span> Determine if at least one element in the object matches a truth test. Use</span>
-<span class="line-numbers"> 157 </span>   <span class="Comment"><span class="Comment">#</span> JavaScript 1.6's some(), if it exists.</span>
-<span class="line-numbers"> 158 </span>   <span class="FunctionName">_.some</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, iterator, context</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 159 </span>     iterator <span class="Keyword">||</span><span class="Keyword">=</span> _.identity
-<span class="line-numbers"> 160 </span>     <span class="Keyword">return</span> obj.some iterator, context <span class="Keyword">if</span> nativeSome <span class="Keyword">and</span> obj.some <span class="Keyword">is</span> nativeSome
-<span class="line-numbers"> 161 </span>     <span class="FunctionName">result</span><span class="Keyword">:</span> <span class="BuiltInConstant">false</span>
-<span class="line-numbers"> 162 </span>     _.each obj, <span class="FunctionArgument">(</span><span class="FunctionArgument">value, index, list</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 163 </span>       _.breakLoop() <span class="Keyword">if</span> (<span class="FunctionName">result</span><span class="Keyword">:</span> iterator.call(context, value, index, list))
-<span class="line-numbers"> 164 </span>     result
-<span class="line-numbers"> 165 </span> 
-<span class="line-numbers"> 166 </span> 
-<span class="line-numbers"> 167 </span>   <span class="Comment"><span class="Comment">#</span> Determine if a given value is included in the array or object,</span>
-<span class="line-numbers"> 168 </span>   <span class="Comment"><span class="Comment">#</span> based on '==='.</span>
-<span class="line-numbers"> 169 </span>   <span class="FunctionName">_.include</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, target</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 170 </span>     <span class="Keyword">return</span> _.indexOf(obj, target) <span class="Keyword">isnt</span> <span class="Keyword">-</span><span class="Number">1</span> <span class="Keyword">if</span> nativeIndexOf <span class="Keyword">and</span> obj.indexOf <span class="Keyword">is</span> nativeIndexOf
-<span class="line-numbers"> 171 </span>     <span class="Keyword">for</span> key, val <span class="Keyword">of</span> obj
-<span class="line-numbers"> 172 </span>       <span class="Keyword">return</span> <span class="BuiltInConstant">true</span> <span class="Keyword">if</span> val <span class="Keyword">is</span> target
-<span class="line-numbers"> 173 </span>     <span class="BuiltInConstant">false</span>
-<span class="line-numbers"> 174 </span> 
-<span class="line-numbers"> 175 </span> 
-<span class="line-numbers"> 176 </span>   <span class="Comment"><span class="Comment">#</span> Invoke a method with arguments on every item in a collection.</span>
-<span class="line-numbers"> 177 </span>   <span class="FunctionName">_.invoke</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, method</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 178 </span>     <span class="FunctionName">args</span><span class="Keyword">:</span> _.rest arguments, <span class="Number">2</span>
-<span class="line-numbers"> 179 </span>     (<span class="Keyword">if</span> method <span class="Keyword">then</span> val[method] <span class="Keyword">else</span> val).apply(val, args) <span class="Keyword">for</span> val <span class="Keyword">in</span> obj
-<span class="line-numbers"> 180 </span> 
-<span class="line-numbers"> 181 </span> 
-<span class="line-numbers"> 182 </span>   <span class="Comment"><span class="Comment">#</span> Convenience version of a common use case of map: fetching a property.</span>
-<span class="line-numbers"> 183 </span>   <span class="FunctionName">_.pluck</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, key</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 184 </span>     _.map(obj, <span class="FunctionArgument">(</span><span class="FunctionArgument">val</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> val[key])
-<span class="line-numbers"> 185 </span> 
-<span class="line-numbers"> 186 </span> 
-<span class="line-numbers"> 187 </span>   <span class="Comment"><span class="Comment">#</span> Return the maximum item or (item-based computation).</span>
-<span class="line-numbers"> 188 </span>   <span class="FunctionName">_.max</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, iterator, context</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 189 </span>     <span class="Keyword">return</span> Math.max.apply(Math, obj) <span class="Keyword">if</span> <span class="Keyword">not</span> iterator <span class="Keyword">and</span> _.isArray(obj)
-<span class="line-numbers"> 190 </span>     <span class="FunctionName">result</span><span class="Keyword">:</span> {<span class="FunctionName">computed</span><span class="Keyword">:</span> <span class="Keyword">-</span><span class="BuiltInConstant">Infinity</span>}
-<span class="line-numbers"> 191 </span>     _.each obj, <span class="FunctionArgument">(</span><span class="FunctionArgument">value, index, list</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 192 </span>       <span class="FunctionName">computed</span><span class="Keyword">:</span> <span class="Keyword">if</span> iterator <span class="Keyword">then</span> iterator.call(context, value, index, list) <span class="Keyword">else</span> value
-<span class="line-numbers"> 193 </span>       computed <span class="Keyword">&gt;=</span> result.computed <span class="Keyword">and</span> (<span class="FunctionName">result</span><span class="Keyword">:</span> {<span class="FunctionName">value</span><span class="Keyword">:</span> value, <span class="FunctionName">computed</span><span class="Keyword">:</span> computed})
-<span class="line-numbers"> 194 </span>     result.value
-<span class="line-numbers"> 195 </span> 
-<span class="line-numbers"> 196 </span> 
-<span class="line-numbers"> 197 </span>   <span class="Comment"><span class="Comment">#</span> Return the minimum element (or element-based computation).</span>
-<span class="line-numbers"> 198 </span>   <span class="FunctionName">_.min</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, iterator, context</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 199 </span>     <span class="Keyword">return</span> Math.min.apply(Math, obj) <span class="Keyword">if</span> <span class="Keyword">not</span> iterator <span class="Keyword">and</span> _.isArray(obj)
-<span class="line-numbers"> 200 </span>     <span class="FunctionName">result</span><span class="Keyword">:</span> {<span class="FunctionName">computed</span><span class="Keyword">:</span> <span class="BuiltInConstant">Infinity</span>}
-<span class="line-numbers"> 201 </span>     _.each obj, <span class="FunctionArgument">(</span><span class="FunctionArgument">value, index, list</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 202 </span>       <span class="FunctionName">computed</span><span class="Keyword">:</span> <span class="Keyword">if</span> iterator <span class="Keyword">then</span> iterator.call(context, value, index, list) <span class="Keyword">else</span> value
-<span class="line-numbers"> 203 </span>       computed <span class="Keyword">&lt;</span> result.computed <span class="Keyword">and</span> (<span class="FunctionName">result</span><span class="Keyword">:</span> {<span class="FunctionName">value</span><span class="Keyword">:</span> value, <span class="FunctionName">computed</span><span class="Keyword">:</span> computed})
-<span class="line-numbers"> 204 </span>     result.value
-<span class="line-numbers"> 205 </span> 
-<span class="line-numbers"> 206 </span> 
-<span class="line-numbers"> 207 </span>   <span class="Comment"><span class="Comment">#</span> Sort the object's values by a criterion produced by an iterator.</span>
-<span class="line-numbers"> 208 </span>   <span class="FunctionName">_.sortBy</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, iterator, context</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 209 </span>     _.pluck(((_.map obj, <span class="FunctionArgument">(</span><span class="FunctionArgument">value, index, list</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 210 </span>       {<span class="FunctionName">value</span><span class="Keyword">:</span> value, <span class="FunctionName">criteria</span><span class="Keyword">:</span> iterator.call(context, value, index, list)}
-<span class="line-numbers"> 211 </span>     ).sort(<span class="FunctionArgument">(</span><span class="FunctionArgument">left, right</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 212 </span>       <span class="FunctionName">a</span><span class="Keyword">:</span> left.criteria; <span class="FunctionName">b</span><span class="Keyword">:</span> right.criteria
-<span class="line-numbers"> 213 </span>       <span class="Keyword">if</span> a <span class="Keyword">&lt;</span> b <span class="Keyword">then</span> <span class="Keyword">-</span><span class="Number">1</span> <span class="Keyword">else</span> <span class="Keyword">if</span> a <span class="Keyword">&gt;</span> b <span class="Keyword">then</span> <span class="Number">1</span> <span class="Keyword">else</span> <span class="Number">0</span>
-<span class="line-numbers"> 214 </span>     )), <span class="String"><span class="String">'</span>value<span class="String">'</span></span>)
-<span class="line-numbers"> 215 </span> 
-<span class="line-numbers"> 216 </span> 
-<span class="line-numbers"> 217 </span>   <span class="Comment"><span class="Comment">#</span> Use a comparator function to figure out at what index an object should</span>
-<span class="line-numbers"> 218 </span>   <span class="Comment"><span class="Comment">#</span> be inserted so as to maintain order. Uses binary search.</span>
-<span class="line-numbers"> 219 </span>   <span class="FunctionName">_.sortedIndex</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">array, obj, iterator</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 220 </span>     iterator <span class="Keyword">||</span><span class="Keyword">=</span> _.identity
-<span class="line-numbers"> 221 </span>     <span class="FunctionName">low</span><span class="Keyword">:</span>  <span class="Number">0</span>
-<span class="line-numbers"> 222 </span>     <span class="FunctionName">high</span><span class="Keyword">:</span> array.length
-<span class="line-numbers"> 223 </span>     <span class="Keyword">while</span> low <span class="Keyword">&lt;</span> high
-<span class="line-numbers"> 224 </span>       <span class="FunctionName">mid</span><span class="Keyword">:</span> (low <span class="Keyword">+</span> high) <span class="Keyword">&gt;</span><span class="Keyword">&gt;</span> <span class="Number">1</span>
-<span class="line-numbers"> 225 </span>       <span class="Keyword">if</span> iterator(array[mid]) <span class="Keyword">&lt;</span> iterator(obj) <span class="Keyword">then</span> <span class="FunctionName">low</span><span class="Keyword">:</span> mid <span class="Keyword">+</span> <span class="Number">1</span> <span class="Keyword">else</span> <span class="FunctionName">high</span><span class="Keyword">:</span> mid
-<span class="line-numbers"> 226 </span>     low
-<span class="line-numbers"> 227 </span> 
-<span class="line-numbers"> 228 </span> 
-<span class="line-numbers"> 229 </span>   <span class="Comment"><span class="Comment">#</span> Convert anything iterable into a real, live array.</span>
-<span class="line-numbers"> 230 </span>   <span class="FunctionName">_.toArray</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">iterable</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 231 </span>     <span class="Keyword">return</span> []                   <span class="Keyword">if</span> (<span class="Keyword">!</span>iterable)
-<span class="line-numbers"> 232 </span>     <span class="Keyword">return</span> iterable.toArray()   <span class="Keyword">if</span> (iterable.toArray)
-<span class="line-numbers"> 233 </span>     <span class="Keyword">return</span> iterable             <span class="Keyword">if</span> (_.isArray(iterable))
-<span class="line-numbers"> 234 </span>     <span class="Keyword">return</span> slice.call(iterable) <span class="Keyword">if</span> (_.isArguments(iterable))
-<span class="line-numbers"> 235 </span>     _.values(iterable)
-<span class="line-numbers"> 236 </span> 
-<span class="line-numbers"> 237 </span> 
-<span class="line-numbers"> 238 </span>   <span class="Comment"><span class="Comment">#</span> Return the number of elements in an object.</span>
-<span class="line-numbers"> 239 </span>   <span class="FunctionName">_.size</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> _.toArray(obj).length
-<span class="line-numbers"> 240 </span> 
-<span class="line-numbers"> 241 </span> 
-<span class="line-numbers"> 242 </span>   <span class="Comment"><span class="Comment">#</span> -------------------------- Array Functions: ------------------------------</span>
-<span class="line-numbers"> 243 </span> 
-<span class="line-numbers"> 244 </span>   <span class="Comment"><span class="Comment">#</span> Get the first element of an array. Passing &quot;n&quot; will return the first N</span>
-<span class="line-numbers"> 245 </span>   <span class="Comment"><span class="Comment">#</span> values in the array. Aliased as &quot;head&quot;. The &quot;guard&quot; check allows it to work</span>
-<span class="line-numbers"> 246 </span>   <span class="Comment"><span class="Comment">#</span> with _.map.</span>
-<span class="line-numbers"> 247 </span>   <span class="FunctionName">_.first</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">array, n, guard</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 248 </span>     <span class="Keyword">if</span> n <span class="Keyword">and</span> <span class="Keyword">not</span> guard <span class="Keyword">then</span> slice.call(array, <span class="Number">0</span>, n) <span class="Keyword">else</span> array[<span class="Number">0</span>]
-<span class="line-numbers"> 249 </span> 
-<span class="line-numbers"> 250 </span> 
-<span class="line-numbers"> 251 </span>   <span class="Comment"><span class="Comment">#</span> Returns everything but the first entry of the array. Aliased as &quot;tail&quot;.</span>
-<span class="line-numbers"> 252 </span>   <span class="Comment"><span class="Comment">#</span> Especially useful on the arguments object. Passing an &quot;index&quot; will return</span>
-<span class="line-numbers"> 253 </span>   <span class="Comment"><span class="Comment">#</span> the rest of the values in the array from that index onward. The &quot;guard&quot;</span>
-<span class="line-numbers"> 254 </span>   <span class="Comment"><span class="Comment">#</span> check allows it to work with _.map.</span>
-<span class="line-numbers"> 255 </span>   <span class="FunctionName">_.rest</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">array, index, guard</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 256 </span>     slice.call(array, <span class="Keyword">if</span> _.isUndefined(index) <span class="Keyword">or</span> guard <span class="Keyword">then</span> <span class="Number">1</span> <span class="Keyword">else</span> index)
-<span class="line-numbers"> 257 </span> 
-<span class="line-numbers"> 258 </span> 
-<span class="line-numbers"> 259 </span>   <span class="Comment"><span class="Comment">#</span> Get the last element of an array.</span>
-<span class="line-numbers"> 260 </span>   <span class="FunctionName">_.last</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">array</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> array[array.length <span class="Keyword">-</span> <span class="Number">1</span>]
-<span class="line-numbers"> 261 </span> 
-<span class="line-numbers"> 262 </span> 
-<span class="line-numbers"> 263 </span>   <span class="Comment"><span class="Comment">#</span> Trim out all falsy values from an array.</span>
-<span class="line-numbers"> 264 </span>   <span class="FunctionName">_.compact</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">array</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> item <span class="Keyword">for</span> item <span class="Keyword">in</span> array <span class="Keyword">when</span> item
-<span class="line-numbers"> 265 </span> 
-<span class="line-numbers"> 266 </span> 
-<span class="line-numbers"> 267 </span>   <span class="Comment"><span class="Comment">#</span> Return a completely flattened version of an array.</span>
-<span class="line-numbers"> 268 </span>   <span class="FunctionName">_.flatten</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">array</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 269 </span>     _.reduce array, [], <span class="FunctionArgument">(</span><span class="FunctionArgument">memo, value</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 270 </span>       <span class="Keyword">return</span> memo.concat(_.flatten(value)) <span class="Keyword">if</span> _.isArray value
-<span class="line-numbers"> 271 </span>       memo.push value
-<span class="line-numbers"> 272 </span>       memo
-<span class="line-numbers"> 273 </span> 
-<span class="line-numbers"> 274 </span> 
-<span class="line-numbers"> 275 </span>   <span class="Comment"><span class="Comment">#</span> Return a version of the array that does not contain the specified value(s).</span>
-<span class="line-numbers"> 276 </span>   <span class="FunctionName">_.without</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">array</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 277 </span>     <span class="FunctionName">values</span><span class="Keyword">:</span> _.rest arguments
-<span class="line-numbers"> 278 </span>     val <span class="Keyword">for</span> val <span class="Keyword">in</span> _.toArray(array) <span class="Keyword">when</span> <span class="Keyword">not</span> _.include values, val
-<span class="line-numbers"> 279 </span> 
-<span class="line-numbers"> 280 </span> 
-<span class="line-numbers"> 281 </span>   <span class="Comment"><span class="Comment">#</span> Produce a duplicate-free version of the array. If the array has already</span>
-<span class="line-numbers"> 282 </span>   <span class="Comment"><span class="Comment">#</span> been sorted, you have the option of using a faster algorithm.</span>
-<span class="line-numbers"> 283 </span>   <span class="FunctionName">_.uniq</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">array, isSorted</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 284 </span>     <span class="FunctionName">memo</span><span class="Keyword">:</span> []
-<span class="line-numbers"> 285 </span>     <span class="Keyword">for</span> el, i <span class="Keyword">in</span> _.toArray array
-<span class="line-numbers"> 286 </span>       memo.push el <span class="Keyword">if</span> i <span class="Keyword">is</span> <span class="Number">0</span> <span class="Keyword">||</span> (<span class="Keyword">if</span> isSorted <span class="Keyword">is</span> <span class="BuiltInConstant">true</span> <span class="Keyword">then</span> _.last(memo) <span class="Keyword">isnt</span> el <span class="Keyword">else</span> <span class="Keyword">not</span> _.include(memo, el))
-<span class="line-numbers"> 287 </span>     memo
-<span class="line-numbers"> 288 </span> 
-<span class="line-numbers"> 289 </span> 
-<span class="line-numbers"> 290 </span>   <span class="Comment"><span class="Comment">#</span> Produce an array that contains every item shared between all the</span>
-<span class="line-numbers"> 291 </span>   <span class="Comment"><span class="Comment">#</span> passed-in arrays.</span>
-<span class="line-numbers"> 292 </span>   <span class="FunctionName">_.intersect</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">array</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 293 </span>     <span class="FunctionName">rest</span><span class="Keyword">:</span> _.rest arguments
-<span class="line-numbers"> 294 </span>     _.select _.uniq(array), <span class="FunctionArgument">(</span><span class="FunctionArgument">item</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 295 </span>       _.all rest, <span class="FunctionArgument">(</span><span class="FunctionArgument">other</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 296 </span>         _.indexOf(other, item) <span class="Keyword">&gt;=</span> <span class="Number">0</span>
-<span class="line-numbers"> 297 </span> 
-<span class="line-numbers"> 298 </span> 
-<span class="line-numbers"> 299 </span>   <span class="Comment"><span class="Comment">#</span> Zip together multiple lists into a single array -- elements that share</span>
-<span class="line-numbers"> 300 </span>   <span class="Comment"><span class="Comment">#</span> an index go together.</span>
-<span class="line-numbers"> 301 </span>   <span class="FunctionName">_.zip</span><span class="Keyword">:</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 302 </span>     <span class="FunctionName">length</span><span class="Keyword">:</span>  _.max _.pluck arguments, <span class="String"><span class="String">'</span>length<span class="String">'</span></span>
-<span class="line-numbers"> 303 </span>     <span class="FunctionName">results</span><span class="Keyword">:</span> <span class="Keyword">new</span> <span class="TypeName">Array</span> length
-<span class="line-numbers"> 304 </span>     <span class="Keyword">for</span> i <span class="Keyword">in</span> [<span class="Number">0</span>...length]
-<span class="line-numbers"> 305 </span>       results[i]<span class="Keyword">:</span> _.pluck arguments, String i
-<span class="line-numbers"> 306 </span>     results
-<span class="line-numbers"> 307 </span> 
-<span class="line-numbers"> 308 </span> 
-<span class="line-numbers"> 309 </span>   <span class="Comment"><span class="Comment">#</span> If the browser doesn't supply us with indexOf (I'm looking at you, MSIE),</span>
-<span class="line-numbers"> 310 </span>   <span class="Comment"><span class="Comment">#</span> we need this function. Return the position of the first occurence of an</span>
-<span class="line-numbers"> 311 </span>   <span class="Comment"><span class="Comment">#</span> item in an array, or -1 if the item is not included in the array.</span>
-<span class="line-numbers"> 312 </span>   <span class="FunctionName">_.indexOf</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">array, item</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 313 </span>     <span class="Keyword">return</span> array.indexOf item <span class="Keyword">if</span> nativeIndexOf <span class="Keyword">and</span> array.indexOf <span class="Keyword">is</span> nativeIndexOf
-<span class="line-numbers"> 314 </span>     <span class="FunctionName">i</span><span class="Keyword">:</span> <span class="Number">0</span>; <span class="FunctionName">l</span><span class="Keyword">:</span> array.length
-<span class="line-numbers"> 315 </span>     <span class="Keyword">while</span> l <span class="Keyword">-</span> i
-<span class="line-numbers"> 316 </span>       <span class="Keyword">if</span> array[i] <span class="Keyword">is</span> item <span class="Keyword">then</span> <span class="Keyword">return</span> i <span class="Keyword">else</span> i<span class="Keyword">++</span>
-<span class="line-numbers"> 317 </span>     <span class="Keyword">-</span><span class="Number">1</span>
-<span class="line-numbers"> 318 </span> 
-<span class="line-numbers"> 319 </span> 
-<span class="line-numbers"> 320 </span>   <span class="Comment"><span class="Comment">#</span> Provide JavaScript 1.6's lastIndexOf, delegating to the native function,</span>
-<span class="line-numbers"> 321 </span>   <span class="Comment"><span class="Comment">#</span> if possible.</span>
-<span class="line-numbers"> 322 </span>   <span class="FunctionName">_.lastIndexOf</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">array, item</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 323 </span>     <span class="Keyword">return</span> array.lastIndexOf(item) <span class="Keyword">if</span> nativeLastIndexOf <span class="Keyword">and</span> array.lastIndexOf <span class="Keyword">is</span> nativeLastIndexOf
-<span class="line-numbers"> 324 </span>     <span class="FunctionName">i</span><span class="Keyword">:</span> array.length
-<span class="line-numbers"> 325 </span>     <span class="Keyword">while</span> i
-<span class="line-numbers"> 326 </span>       <span class="Keyword">if</span> array[i] <span class="Keyword">is</span> item <span class="Keyword">then</span> <span class="Keyword">return</span> i <span class="Keyword">else</span> i<span class="Keyword">--</span>
-<span class="line-numbers"> 327 </span>     <span class="Keyword">-</span><span class="Number">1</span>
-<span class="line-numbers"> 328 </span> 
-<span class="line-numbers"> 329 </span> 
-<span class="line-numbers"> 330 </span>   <span class="Comment"><span class="Comment">#</span> Generate an integer Array containing an arithmetic progression. A port of</span>
-<span class="line-numbers"> 331 </span>   <span class="Comment"><span class="Comment">#</span> the native Python range() function. See:</span>
-<span class="line-numbers"> 332 </span>   <span class="Comment"><span class="Comment">#</span> http://docs.python.org/library/functions.html#range</span>
-<span class="line-numbers"> 333 </span>   <span class="FunctionName">_.range</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">start, stop, step</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 334 </span>     <span class="FunctionName">a</span><span class="Keyword">:</span>        arguments
-<span class="line-numbers"> 335 </span>     <span class="FunctionName">solo</span><span class="Keyword">:</span>     a.length <span class="Keyword">&lt;=</span> <span class="Number">1</span>
-<span class="line-numbers"> 336 </span>     <span class="FunctionName">i</span><span class="Keyword">:</span> <span class="FunctionName">start</span><span class="Keyword">:</span> <span class="Keyword">if</span> solo <span class="Keyword">then</span> <span class="Number">0</span> <span class="Keyword">else</span> a[<span class="Number">0</span>]
-<span class="line-numbers"> 337 </span>     <span class="FunctionName">stop</span><span class="Keyword">:</span>     <span class="Keyword">if</span> solo <span class="Keyword">then</span> a[<span class="Number">0</span>] <span class="Keyword">else</span> a[<span class="Number">1</span>]
-<span class="line-numbers"> 338 </span>     <span class="FunctionName">step</span><span class="Keyword">:</span>     a[<span class="Number">2</span>] <span class="Keyword">or</span> <span class="Number">1</span>
-<span class="line-numbers"> 339 </span>     <span class="FunctionName">len</span><span class="Keyword">:</span>      Math.ceil((stop <span class="Keyword">-</span> start) <span class="Keyword">/</span> step)
-<span class="line-numbers"> 340 </span>     <span class="Keyword">return</span> [] <span class="Keyword">if</span> len <span class="Keyword">&lt;=</span> <span class="Number">0</span>
-<span class="line-numbers"> 341 </span>     <span class="FunctionName">range</span><span class="Keyword">:</span>    <span class="Keyword">new</span> <span class="TypeName">Array</span> len
-<span class="line-numbers"> 342 </span>     <span class="FunctionName">idx</span><span class="Keyword">:</span>      <span class="Number">0</span>
-<span class="line-numbers"> 343 </span>     <span class="Keyword">while</span> <span class="BuiltInConstant">true</span>
-<span class="line-numbers"> 344 </span>       <span class="Keyword">return</span> range <span class="Keyword">if</span> (<span class="Keyword">if</span> step <span class="Keyword">&gt;</span> <span class="Number">0</span> <span class="Keyword">then</span> i <span class="Keyword">-</span> stop <span class="Keyword">else</span> stop <span class="Keyword">-</span> i) <span class="Keyword">&gt;=</span> <span class="Number">0</span>
-<span class="line-numbers"> 345 </span>       range[idx]<span class="Keyword">:</span> i
-<span class="line-numbers"> 346 </span>       idx<span class="Keyword">++</span>
-<span class="line-numbers"> 347 </span>       i<span class="Keyword">+</span><span class="Keyword">=</span> step
-<span class="line-numbers"> 348 </span> 
-<span class="line-numbers"> 349 </span> 
-<span class="line-numbers"> 350 </span>   <span class="Comment"><span class="Comment">#</span> ----------------------- Function Functions: -----------------------------</span>
-<span class="line-numbers"> 351 </span> 
-<span class="line-numbers"> 352 </span>   <span class="Comment"><span class="Comment">#</span> Create a function bound to a given object (assigning 'this', and arguments,</span>
-<span class="line-numbers"> 353 </span>   <span class="Comment"><span class="Comment">#</span> optionally). Binding with arguments is also known as 'curry'.</span>
-<span class="line-numbers"> 354 </span>   <span class="FunctionName">_.bind</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">func, obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 355 </span>     <span class="FunctionName">args</span><span class="Keyword">:</span> _.rest arguments, <span class="Number">2</span>
-<span class="line-numbers"> 356 </span>     <span class="Storage">-&gt;</span> func.apply obj <span class="Keyword">or</span> root, args.concat arguments
-<span class="line-numbers"> 357 </span> 
-<span class="line-numbers"> 358 </span> 
-<span class="line-numbers"> 359 </span>   <span class="Comment"><span class="Comment">#</span> Bind all of an object's methods to that object. Useful for ensuring that</span>
-<span class="line-numbers"> 360 </span>   <span class="Comment"><span class="Comment">#</span> all callbacks defined on an object belong to it.</span>
-<span class="line-numbers"> 361 </span>   <span class="FunctionName">_.bindAll</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 362 </span>     <span class="FunctionName">funcs</span><span class="Keyword">:</span> <span class="Keyword">if</span> arguments.length <span class="Keyword">&gt;</span> <span class="Number">1</span> <span class="Keyword">then</span> _.rest(arguments) <span class="Keyword">else</span> _.functions(obj)
-<span class="line-numbers"> 363 </span>     _.each funcs, <span class="FunctionArgument">(</span><span class="FunctionArgument">f</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> obj[f]<span class="Keyword">:</span> _.bind obj[f], obj
-<span class="line-numbers"> 364 </span>     obj
-<span class="line-numbers"> 365 </span> 
-<span class="line-numbers"> 366 </span> 
-<span class="line-numbers"> 367 </span>   <span class="Comment"><span class="Comment">#</span> Delays a function for the given number of milliseconds, and then calls</span>
-<span class="line-numbers"> 368 </span>   <span class="Comment"><span class="Comment">#</span> it with the arguments supplied.</span>
-<span class="line-numbers"> 369 </span>   <span class="FunctionName">_.delay</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">func, wait</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 370 </span>     <span class="FunctionName">args</span><span class="Keyword">:</span> _.rest arguments, <span class="Number">2</span>
-<span class="line-numbers"> 371 </span>     setTimeout((<span class="Storage">-&gt;</span> func.apply(func, args)), wait)
-<span class="line-numbers"> 372 </span> 
-<span class="line-numbers"> 373 </span> 
-<span class="line-numbers"> 374 </span>   <span class="Comment"><span class="Comment">#</span> Defers a function, scheduling it to run after the current call stack has</span>
-<span class="line-numbers"> 375 </span>   <span class="Comment"><span class="Comment">#</span> cleared.</span>
-<span class="line-numbers"> 376 </span>   <span class="FunctionName">_.defer</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">func</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 377 </span>     _.delay.apply _, [func, <span class="Number">1</span>].concat _.rest arguments
-<span class="line-numbers"> 378 </span> 
-<span class="line-numbers"> 379 </span> 
-<span class="line-numbers"> 380 </span>   <span class="Comment"><span class="Comment">#</span> Returns the first function passed as an argument to the second,</span>
-<span class="line-numbers"> 381 </span>   <span class="Comment"><span class="Comment">#</span> allowing you to adjust arguments, run code before and after, and</span>
-<span class="line-numbers"> 382 </span>   <span class="Comment"><span class="Comment">#</span> conditionally execute the original function.</span>
-<span class="line-numbers"> 383 </span>   <span class="FunctionName">_.wrap</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">func, wrapper</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 384 </span>     <span class="Storage">-&gt;</span> wrapper.apply wrapper, [func].concat arguments
-<span class="line-numbers"> 385 </span> 
-<span class="line-numbers"> 386 </span> 
-<span class="line-numbers"> 387 </span>   <span class="Comment"><span class="Comment">#</span> Returns a function that is the composition of a list of functions, each</span>
-<span class="line-numbers"> 388 </span>   <span class="Comment"><span class="Comment">#</span> consuming the return value of the function that follows.</span>
-<span class="line-numbers"> 389 </span>   <span class="FunctionName">_.compose</span><span class="Keyword">:</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 390 </span>     <span class="FunctionName">funcs</span><span class="Keyword">:</span> arguments
-<span class="line-numbers"> 391 </span>     <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 392 </span>       <span class="FunctionName">args</span><span class="Keyword">:</span> arguments
-<span class="line-numbers"> 393 </span>       <span class="Keyword">for</span> i <span class="Keyword">in</span> [(funcs.length <span class="Keyword">-</span> <span class="Number">1</span>)..<span class="Number">0</span>]
-<span class="line-numbers"> 394 </span>         <span class="FunctionName">args</span><span class="Keyword">:</span> [funcs[i].apply(<span class="Variable">this</span>, args)]
-<span class="line-numbers"> 395 </span>       args[<span class="Number">0</span>]
-<span class="line-numbers"> 396 </span> 
-<span class="line-numbers"> 397 </span> 
-<span class="line-numbers"> 398 </span>   <span class="Comment"><span class="Comment">#</span> ------------------------- Object Functions: ----------------------------</span>
-<span class="line-numbers"> 399 </span> 
-<span class="line-numbers"> 400 </span>   <span class="Comment"><span class="Comment">#</span> Retrieve the names of an object's properties.</span>
-<span class="line-numbers"> 401 </span>   <span class="FunctionName">_.keys</span><span class="Keyword">:</span> nativeKeys <span class="Keyword">or</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 402 </span>     <span class="Keyword">return</span> _.range <span class="Number">0</span>, obj.length <span class="Keyword">if</span> _.isArray(obj)
-<span class="line-numbers"> 403 </span>     key <span class="Keyword">for</span> key, val <span class="Keyword">of</span> obj
-<span class="line-numbers"> 404 </span> 
-<span class="line-numbers"> 405 </span> 
-<span class="line-numbers"> 406 </span>   <span class="Comment"><span class="Comment">#</span> Retrieve the values of an object's properties.</span>
-<span class="line-numbers"> 407 </span>   <span class="FunctionName">_.values</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 408 </span>     _.map obj, _.identity
-<span class="line-numbers"> 409 </span> 
-<span class="line-numbers"> 410 </span> 
-<span class="line-numbers"> 411 </span>   <span class="Comment"><span class="Comment">#</span> Return a sorted list of the function names available in Underscore.</span>
-<span class="line-numbers"> 412 </span>   <span class="FunctionName">_.functions</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 413 </span>     _.filter(_.keys(obj), <span class="FunctionArgument">(</span><span class="FunctionArgument">key</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> _.isFunction(obj[key])).sort()
-<span class="line-numbers"> 414 </span> 
-<span class="line-numbers"> 415 </span> 
-<span class="line-numbers"> 416 </span>   <span class="Comment"><span class="Comment">#</span> Extend a given object with all of the properties in a source object.</span>
-<span class="line-numbers"> 417 </span>   <span class="FunctionName">_.extend</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">destination, source</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 418 </span>     (destination[key]<span class="Keyword">:</span> val) <span class="Keyword">for</span> key, val <span class="Keyword">of</span> source
-<span class="line-numbers"> 419 </span>     destination
-<span class="line-numbers"> 420 </span> 
-<span class="line-numbers"> 421 </span> 
-<span class="line-numbers"> 422 </span>   <span class="Comment"><span class="Comment">#</span> Create a (shallow-cloned) duplicate of an object.</span>
-<span class="line-numbers"> 423 </span>   <span class="FunctionName">_.clone</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 424 </span>     <span class="Keyword">return</span> obj.slice <span class="Number">0</span> <span class="Keyword">if</span> _.isArray obj
-<span class="line-numbers"> 425 </span>     _.extend {}, obj
-<span class="line-numbers"> 426 </span> 
-<span class="line-numbers"> 427 </span> 
-<span class="line-numbers"> 428 </span>   <span class="Comment"><span class="Comment">#</span> Invokes interceptor with the obj, and then returns obj.</span>
-<span class="line-numbers"> 429 </span>   <span class="Comment"><span class="Comment">#</span> The primary purpose of this method is to &quot;tap into&quot; a method chain, in order to perform operations on intermediate results within the chain.</span>
-<span class="line-numbers"> 430 </span>   <span class="FunctionName">_.tap</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, interceptor</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 431 </span>     interceptor obj
-<span class="line-numbers"> 432 </span>     obj
-<span class="line-numbers"> 433 </span> 
-<span class="line-numbers"> 434 </span> 
-<span class="line-numbers"> 435 </span>   <span class="Comment"><span class="Comment">#</span> Perform a deep comparison to check if two objects are equal.</span>
-<span class="line-numbers"> 436 </span>   <span class="FunctionName">_.isEqual</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">a, b</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 437 </span>     <span class="Comment"><span class="Comment">#</span> Check object identity.</span>
-<span class="line-numbers"> 438 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">true</span> <span class="Keyword">if</span> a <span class="Keyword">is</span> b
-<span class="line-numbers"> 439 </span>     <span class="Comment"><span class="Comment">#</span> Different types?</span>
-<span class="line-numbers"> 440 </span>     <span class="FunctionName">atype</span><span class="Keyword">:</span> <span class="Keyword">typeof</span>(a); <span class="FunctionName">btype</span><span class="Keyword">:</span> <span class="Keyword">typeof</span>(b)
-<span class="line-numbers"> 441 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">false</span> <span class="Keyword">if</span> atype <span class="Keyword">isnt</span> btype
-<span class="line-numbers"> 442 </span>     <span class="Comment"><span class="Comment">#</span> Basic equality test (watch out for coercions).</span>
-<span class="line-numbers"> 443 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">true</span> <span class="Keyword">if</span> <span class="String"><span class="String">`</span>a == b<span class="String">`</span></span>
-<span class="line-numbers"> 444 </span>     <span class="Comment"><span class="Comment">#</span> One is falsy and the other truthy.</span>
-<span class="line-numbers"> 445 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">false</span> <span class="Keyword">if</span> (<span class="Keyword">!</span>a <span class="Keyword">and</span> b) <span class="Keyword">or</span> (a <span class="Keyword">and</span> <span class="Keyword">!</span>b)
-<span class="line-numbers"> 446 </span>     <span class="Comment"><span class="Comment">#</span> One of them implements an isEqual()?</span>
-<span class="line-numbers"> 447 </span>     <span class="Keyword">return</span> a.isEqual(b) <span class="Keyword">if</span> a.isEqual
-<span class="line-numbers"> 448 </span>     <span class="Comment"><span class="Comment">#</span> Check dates' integer values.</span>
-<span class="line-numbers"> 449 </span>     <span class="Keyword">return</span> a.getTime() <span class="Keyword">is</span> b.getTime() <span class="Keyword">if</span> _.isDate(a) <span class="Keyword">and</span> _.isDate(b)
-<span class="line-numbers"> 450 </span>     <span class="Comment"><span class="Comment">#</span> Both are NaN?</span>
-<span class="line-numbers"> 451 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">true</span> <span class="Keyword">if</span> _.isNaN(a) <span class="Keyword">and</span> _.isNaN(b)
-<span class="line-numbers"> 452 </span>     <span class="Comment"><span class="Comment">#</span> Compare regular expressions.</span>
-<span class="line-numbers"> 453 </span>     <span class="Keyword">if</span> _.isRegExp(a) <span class="Keyword">and</span> _.isRegExp(b)
-<span class="line-numbers"> 454 </span>       <span class="Keyword">return</span> a.source     <span class="Keyword">is</span> b.source <span class="Keyword">and</span>
-<span class="line-numbers"> 455 </span>              a.global     <span class="Keyword">is</span> b.global <span class="Keyword">and</span>
-<span class="line-numbers"> 456 </span>              a.ignoreCase <span class="Keyword">is</span> b.ignoreCase <span class="Keyword">and</span>
-<span class="line-numbers"> 457 </span>              a.multiline  <span class="Keyword">is</span> b.multiline
-<span class="line-numbers"> 458 </span>     <span class="Comment"><span class="Comment">#</span> If a is not an object by this point, we can't handle it.</span>
-<span class="line-numbers"> 459 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">false</span> <span class="Keyword">if</span> atype <span class="Keyword">isnt</span> <span class="String"><span class="String">'</span>object<span class="String">'</span></span>
-<span class="line-numbers"> 460 </span>     <span class="Comment"><span class="Comment">#</span> Check for different array lengths before comparing contents.</span>
-<span class="line-numbers"> 461 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">false</span> <span class="Keyword">if</span> a.length <span class="Keyword">and</span> (a.length <span class="Keyword">isnt</span> b.length)
-<span class="line-numbers"> 462 </span>     <span class="Comment"><span class="Comment">#</span> Nothing else worked, deep compare the contents.</span>
-<span class="line-numbers"> 463 </span>     <span class="FunctionName">aKeys</span><span class="Keyword">:</span> _.keys(a); <span class="FunctionName">bKeys</span><span class="Keyword">:</span> _.keys(b)
-<span class="line-numbers"> 464 </span>     <span class="Comment"><span class="Comment">#</span> Different object sizes?</span>
-<span class="line-numbers"> 465 </span>     <span class="Keyword">return</span> <span class="BuiltInConstant">false</span> <span class="Keyword">if</span> aKeys.length <span class="Keyword">isnt</span> bKeys.length
-<span class="line-numbers"> 466 </span>     <span class="Comment"><span class="Comment">#</span> Recursive comparison of contents.</span>
-<span class="line-numbers"> 467 </span>     (<span class="Keyword">return</span> <span class="BuiltInConstant">false</span>) <span class="Keyword">for</span> key, val <span class="Keyword">of</span> a <span class="Keyword">when</span> <span class="Keyword">!</span>_.isEqual(val, b[key])
-<span class="line-numbers"> 468 </span>     <span class="BuiltInConstant">true</span>
-<span class="line-numbers"> 469 </span> 
-<span class="line-numbers"> 470 </span> 
-<span class="line-numbers"> 471 </span>   <span class="Comment"><span class="Comment">#</span> Is a given array or object empty?</span>
-<span class="line-numbers"> 472 </span>   <span class="FunctionName">_.isEmpty</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 473 </span>     <span class="Keyword">return</span> obj.length <span class="Keyword">is</span> <span class="Number">0</span> <span class="Keyword">if</span> _.isArray obj
-<span class="line-numbers"> 474 </span>     (<span class="Keyword">return</span> <span class="BuiltInConstant">false</span>) <span class="Keyword">for</span> key <span class="Keyword">of</span> obj <span class="Keyword">when</span> hasOwnProperty.call(obj, key)
-<span class="line-numbers"> 475 </span>     <span class="BuiltInConstant">true</span>
-<span class="line-numbers"> 476 </span> 
-<span class="line-numbers"> 477 </span> 
-<span class="line-numbers"> 478 </span>   <span class="Comment"><span class="Comment">#</span> Is a given value a DOM element?</span>
-<span class="line-numbers"> 479 </span>   <span class="FunctionName">_.isElement</span><span class="Keyword">:</span>    <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> obj <span class="Keyword">and</span> obj.nodeType <span class="Keyword">is</span> <span class="Number">1</span>
-<span class="line-numbers"> 480 </span> 
-<span class="line-numbers"> 481 </span> 
-<span class="line-numbers"> 482 </span>   <span class="Comment"><span class="Comment">#</span> Is a given value an array?</span>
-<span class="line-numbers"> 483 </span>   <span class="FunctionName">_.isArray</span><span class="Keyword">:</span>      nativeIsArray <span class="Keyword">or</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> <span class="Keyword">!</span><span class="Keyword">!</span>(obj <span class="Keyword">and</span> obj.concat <span class="Keyword">and</span> obj.unshift)
-<span class="line-numbers"> 484 </span> 
-<span class="line-numbers"> 485 </span> 
-<span class="line-numbers"> 486 </span>   <span class="Comment"><span class="Comment">#</span> Is a given variable an arguments object?</span>
-<span class="line-numbers"> 487 </span>   <span class="FunctionName">_.isArguments</span><span class="Keyword">:</span>  <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> obj <span class="Keyword">and</span> _.isNumber(obj.length) <span class="Keyword">and</span> <span class="Keyword">not</span> obj.concat <span class="Keyword">and</span>
-<span class="line-numbers"> 488 </span>                            <span class="Keyword">not</span> obj.substr <span class="Keyword">and</span> <span class="Keyword">not</span> obj.apply <span class="Keyword">and</span> <span class="Keyword">not</span> propertyIsEnumerable.call(obj, <span class="String"><span class="String">'</span>length<span class="String">'</span></span>)
-<span class="line-numbers"> 489 </span> 
-<span class="line-numbers"> 490 </span> 
-<span class="line-numbers"> 491 </span>   <span class="Comment"><span class="Comment">#</span> Is the given value a function?</span>
-<span class="line-numbers"> 492 </span>   <span class="FunctionName">_.isFunction</span><span class="Keyword">:</span>   <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> <span class="Keyword">!</span><span class="Keyword">!</span>(obj <span class="Keyword">and</span> obj.constructor <span class="Keyword">and</span> obj.call <span class="Keyword">and</span> obj.apply)
-<span class="line-numbers"> 493 </span> 
-<span class="line-numbers"> 494 </span> 
-<span class="line-numbers"> 495 </span>   <span class="Comment"><span class="Comment">#</span> Is the given value a string?</span>
-<span class="line-numbers"> 496 </span>   <span class="FunctionName">_.isString</span><span class="Keyword">:</span>     <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> <span class="Keyword">!</span><span class="Keyword">!</span>(obj <span class="Keyword">is</span> <span class="String"><span class="String">'</span><span class="String">'</span></span> <span class="Keyword">or</span> (obj <span class="Keyword">and</span> obj.charCodeAt <span class="Keyword">and</span> obj.substr))
-<span class="line-numbers"> 497 </span> 
-<span class="line-numbers"> 498 </span> 
-<span class="line-numbers"> 499 </span>   <span class="Comment"><span class="Comment">#</span> Is a given value a number?</span>
-<span class="line-numbers"> 500 </span>   <span class="FunctionName">_.isNumber</span><span class="Keyword">:</span>     <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> (obj <span class="Keyword">is</span> <span class="Keyword">+</span>obj) <span class="Keyword">or</span> toString.call(obj) <span class="Keyword">is</span> <span class="String"><span class="String">'</span>[object Number]<span class="String">'</span></span>
-<span class="line-numbers"> 501 </span> 
-<span class="line-numbers"> 502 </span> 
-<span class="line-numbers"> 503 </span>   <span class="Comment"><span class="Comment">#</span> Is a given value a boolean?</span>
-<span class="line-numbers"> 504 </span>   <span class="FunctionName">_.isBoolean</span><span class="Keyword">:</span>    <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> obj <span class="Keyword">is</span> <span class="BuiltInConstant">true</span> <span class="Keyword">or</span> obj <span class="Keyword">is</span> <span class="BuiltInConstant">false</span>
-<span class="line-numbers"> 505 </span> 
-<span class="line-numbers"> 506 </span> 
-<span class="line-numbers"> 507 </span>   <span class="Comment"><span class="Comment">#</span> Is a given value a Date?</span>
-<span class="line-numbers"> 508 </span>   <span class="FunctionName">_.isDate</span><span class="Keyword">:</span>       <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> <span class="Keyword">!</span><span class="Keyword">!</span>(obj <span class="Keyword">and</span> obj.getTimezoneOffset <span class="Keyword">and</span> obj.setUTCFullYear)
-<span class="line-numbers"> 509 </span> 
-<span class="line-numbers"> 510 </span> 
-<span class="line-numbers"> 511 </span>   <span class="Comment"><span class="Comment">#</span> Is the given value a regular expression?</span>
-<span class="line-numbers"> 512 </span>   <span class="FunctionName">_.isRegExp</span><span class="Keyword">:</span>     <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> <span class="Keyword">!</span><span class="Keyword">!</span>(obj <span class="Keyword">and</span> obj.exec <span class="Keyword">and</span> (obj.ignoreCase <span class="Keyword">or</span> obj.ignoreCase <span class="Keyword">is</span> <span class="BuiltInConstant">false</span>))
-<span class="line-numbers"> 513 </span> 
-<span class="line-numbers"> 514 </span> 
-<span class="line-numbers"> 515 </span>   <span class="Comment"><span class="Comment">#</span> Is the given value NaN -- this one is interesting. NaN != NaN, and</span>
-<span class="line-numbers"> 516 </span>   <span class="Comment"><span class="Comment">#</span> isNaN(undefined) == true, so we make sure it's a number first.</span>
-<span class="line-numbers"> 517 </span>   <span class="FunctionName">_.isNaN</span><span class="Keyword">:</span>        <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> _.isNumber(obj) <span class="Keyword">and</span> window.isNaN(obj)
-<span class="line-numbers"> 518 </span> 
-<span class="line-numbers"> 519 </span> 
-<span class="line-numbers"> 520 </span>   <span class="Comment"><span class="Comment">#</span> Is a given value equal to null?</span>
-<span class="line-numbers"> 521 </span>   <span class="FunctionName">_.isNull</span><span class="Keyword">:</span>       <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> obj <span class="Keyword">is</span> <span class="BuiltInConstant">null</span>
-<span class="line-numbers"> 522 </span> 
-<span class="line-numbers"> 523 </span> 
-<span class="line-numbers"> 524 </span>   <span class="Comment"><span class="Comment">#</span> Is a given variable undefined?</span>
-<span class="line-numbers"> 525 </span>   <span class="FunctionName">_.isUndefined</span><span class="Keyword">:</span>  <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> <span class="Keyword">typeof</span> obj <span class="Keyword">is</span> <span class="String"><span class="String">'</span>undefined<span class="String">'</span></span>
-<span class="line-numbers"> 526 </span> 
-<span class="line-numbers"> 527 </span> 
-<span class="line-numbers"> 528 </span>   <span class="Comment"><span class="Comment">#</span> -------------------------- Utility Functions: --------------------------</span>
-<span class="line-numbers"> 529 </span> 
-<span class="line-numbers"> 530 </span>   <span class="Comment"><span class="Comment">#</span> Run Underscore.js in noConflict mode, returning the '_' variable to its</span>
-<span class="line-numbers"> 531 </span>   <span class="Comment"><span class="Comment">#</span> previous owner. Returns a reference to the Underscore object.</span>
-<span class="line-numbers"> 532 </span>   <span class="FunctionName">_.noConflict</span><span class="Keyword">:</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 533 </span>     <span class="FunctionName">root._</span><span class="Keyword">:</span> previousUnderscore
-<span class="line-numbers"> 534 </span>     <span class="Variable">this</span>
-<span class="line-numbers"> 535 </span> 
-<span class="line-numbers"> 536 </span> 
-<span class="line-numbers"> 537 </span>   <span class="Comment"><span class="Comment">#</span> Keep the identity function around for default iterators.</span>
-<span class="line-numbers"> 538 </span>   <span class="FunctionName">_.identity</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">value</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> value
-<span class="line-numbers"> 539 </span> 
-<span class="line-numbers"> 540 </span> 
-<span class="line-numbers"> 541 </span>   <span class="Comment"><span class="Comment">#</span> Run a function n times.</span>
-<span class="line-numbers"> 542 </span>   <span class="FunctionName">_.times</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">n, iterator, context</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 543 </span>     iterator.call(context, i) <span class="Keyword">for</span> i <span class="Keyword">in</span> [<span class="Number">0</span>...n]
-<span class="line-numbers"> 544 </span> 
-<span class="line-numbers"> 545 </span> 
-<span class="line-numbers"> 546 </span>   <span class="Comment"><span class="Comment">#</span> Break out of the middle of an iteration.</span>
-<span class="line-numbers"> 547 </span>   <span class="FunctionName">_.breakLoop</span><span class="Keyword">:</span> <span class="Storage">-&gt;</span> <span class="Keyword">throw</span> breaker
-<span class="line-numbers"> 548 </span> 
-<span class="line-numbers"> 549 </span> 
-<span class="line-numbers"> 550 </span>   <span class="Comment"><span class="Comment">#</span> Add your own custom functions to the Underscore object, ensuring that</span>
-<span class="line-numbers"> 551 </span>   <span class="Comment"><span class="Comment">#</span> they're correctly added to the OOP wrapper as well.</span>
-<span class="line-numbers"> 552 </span>   <span class="FunctionName">_.mixin</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 553 </span>     <span class="Keyword">for</span> name <span class="Keyword">in</span> _.functions(obj)
-<span class="line-numbers"> 554 </span>       addToWrapper name, _[name]<span class="Keyword">:</span> obj[name]
-<span class="line-numbers"> 555 </span> 
-<span class="line-numbers"> 556 </span> 
-<span class="line-numbers"> 557 </span>   <span class="Comment"><span class="Comment">#</span> Generate a unique integer id (unique within the entire client session).</span>
-<span class="line-numbers"> 558 </span>   <span class="Comment"><span class="Comment">#</span> Useful for temporary DOM ids.</span>
-<span class="line-numbers"> 559 </span>   <span class="FunctionName">idCounter</span><span class="Keyword">:</span> <span class="Number">0</span>
-<span class="line-numbers"> 560 </span>   <span class="FunctionName">_.uniqueId</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">prefix</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 561 </span>     (prefix <span class="Keyword">or</span> <span class="String"><span class="String">'</span><span class="String">'</span></span>) <span class="Keyword">+</span> idCounter<span class="Keyword">++</span>
-<span class="line-numbers"> 562 </span> 
-<span class="line-numbers"> 563 </span> 
-<span class="line-numbers"> 564 </span>   <span class="Comment"><span class="Comment">#</span> By default, Underscore uses ERB-style template delimiters, change the</span>
-<span class="line-numbers"> 565 </span>   <span class="Comment"><span class="Comment">#</span> following template settings to use alternative delimiters.</span>
-<span class="line-numbers"> 566 </span>   <span class="FunctionName">_.templateSettings</span><span class="Keyword">:</span> {
-<span class="line-numbers"> 567 </span>     <span class="FunctionName">start</span><span class="Keyword">:</span>        <span class="String"><span class="String">'</span>&lt;%<span class="String">'</span></span>
-<span class="line-numbers"> 568 </span>     <span class="FunctionName">end</span><span class="Keyword">:</span>          <span class="String"><span class="String">'</span>%&gt;<span class="String">'</span></span>
-<span class="line-numbers"> 569 </span>     <span class="FunctionName">interpolate</span><span class="Keyword">:</span><span class="String">  <span class="String">/</span>&lt;%=(.+?)%&gt;<span class="String">/</span>g</span>
-<span class="line-numbers"> 570 </span>   }
-<span class="line-numbers"> 571 </span> 
-<span class="line-numbers"> 572 </span> 
-<span class="line-numbers"> 573 </span>   <span class="Comment"><span class="Comment">#</span> JavaScript templating a-la ERB, pilfered from John Resig's</span>
-<span class="line-numbers"> 574 </span>   <span class="Comment"><span class="Comment">#</span> &quot;Secrets of the JavaScript Ninja&quot;, page 83.</span>
-<span class="line-numbers"> 575 </span>   <span class="Comment"><span class="Comment">#</span> Single-quote fix from Rick Strahl's version.</span>
-<span class="line-numbers"> 576 </span>   <span class="FunctionName">_.template</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">str, data</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 577 </span>     <span class="FunctionName">c</span><span class="Keyword">:</span> _.templateSettings
-<span class="line-numbers"> 578 </span>     <span class="FunctionName">endMatch</span><span class="Keyword">:</span> <span class="Keyword">new</span> <span class="TypeName">RegExp</span>(<span class="String"><span class="String">&quot;</span>'(?=[^<span class="String">&quot;</span></span><span class="Keyword">+</span>c.end.substr(<span class="Number">0</span>, <span class="Number">1</span>)<span class="Keyword">+</span><span class="String"><span class="String">&quot;</span>]*<span class="String">&quot;</span></span><span class="Keyword">+</span>escapeRegExp(c.end)<span class="Keyword">+</span><span class="String"><span class="String">&quot;</span>)<span class="String">&quot;</span></span>,<span class="String"><span class="String">&quot;</span>g<span class="String">&quot;</span></span>)
-<span class="line-numbers"> 579 </span>     <span class="FunctionName">fn</span><span class="Keyword">:</span> <span class="Keyword">new</span> <span class="TypeName">Function</span> <span class="String"><span class="String">'</span>obj<span class="String">'</span></span>,
-<span class="line-numbers"> 580 </span>       <span class="String"><span class="String">'</span>var p=[],print=function(){p.push.apply(p,arguments);};<span class="String">'</span></span> <span class="Keyword">+</span>
-<span class="line-numbers"> 581 </span>       <span class="String"><span class="String">'</span>with(obj){p.push(<span class="UserDefinedConstant">\'</span><span class="String">'</span></span> <span class="Keyword">+</span>
-<span class="line-numbers"> 582 </span>       str.replace(<span class="String"><span class="String">/</span>[<span class="UserDefinedConstant">\r</span><span class="UserDefinedConstant">\t</span><span class="UserDefinedConstant">\n</span>]<span class="String">/</span>g</span>, <span class="String"><span class="String">&quot;</span> <span class="String">&quot;</span></span>)
-<span class="line-numbers"> 583 </span>          .replace(endMatch,<span class="String"><span class="String">&quot;</span><span class="UserDefinedConstant">\t</span><span class="String">&quot;</span></span>)
-<span class="line-numbers"> 584 </span>          .split(<span class="String"><span class="String">&quot;</span>'<span class="String">&quot;</span></span>).join(<span class="String"><span class="String">&quot;</span><span class="UserDefinedConstant">\\</span>'<span class="String">&quot;</span></span>)
-<span class="line-numbers"> 585 </span>          .split(<span class="String"><span class="String">&quot;</span><span class="UserDefinedConstant">\t</span><span class="String">&quot;</span></span>).join(<span class="String"><span class="String">&quot;</span>'<span class="String">&quot;</span></span>)
-<span class="line-numbers"> 586 </span>          .replace(c.interpolate, <span class="String"><span class="String">&quot;</span>',$1,'<span class="String">&quot;</span></span>)
-<span class="line-numbers"> 587 </span>          .split(c.start).join(<span class="String"><span class="String">&quot;</span>');<span class="String">&quot;</span></span>)
-<span class="line-numbers"> 588 </span>          .split(c.end).join(<span class="String"><span class="String">&quot;</span>p.push('<span class="String">&quot;</span></span>) <span class="Keyword">+</span>
-<span class="line-numbers"> 589 </span>          <span class="String"><span class="String">&quot;</span>');}return p.join('');<span class="String">&quot;</span></span>
-<span class="line-numbers"> 590 </span>     <span class="Keyword">if</span> data <span class="Keyword">then</span> fn(data) <span class="Keyword">else</span> fn
-<span class="line-numbers"> 591 </span> 
-<span class="line-numbers"> 592 </span> 
-<span class="line-numbers"> 593 </span>   <span class="Comment"><span class="Comment">#</span> ------------------------------- Aliases ----------------------------------</span>
-<span class="line-numbers"> 594 </span> 
-<span class="line-numbers"> 595 </span>   <span class="FunctionName">_.forEach</span><span class="Keyword">:</span> _.each
-<span class="line-numbers"> 596 </span>   <span class="FunctionName">_.foldl</span><span class="Keyword">:</span>   <span class="FunctionName">_.inject</span><span class="Keyword">:</span>      _.reduce
-<span class="line-numbers"> 597 </span>   <span class="FunctionName">_.foldr</span><span class="Keyword">:</span>   _.reduceRight
-<span class="line-numbers"> 598 </span>   <span class="FunctionName">_.select</span><span class="Keyword">:</span>  _.filter
-<span class="line-numbers"> 599 </span>   <span class="FunctionName">_.all</span><span class="Keyword">:</span>     _.every
-<span class="line-numbers"> 600 </span>   <span class="FunctionName">_.any</span><span class="Keyword">:</span>     _.some
-<span class="line-numbers"> 601 </span>   <span class="FunctionName">_.head</span><span class="Keyword">:</span>    _.first
-<span class="line-numbers"> 602 </span>   <span class="FunctionName">_.tail</span><span class="Keyword">:</span>    _.rest
-<span class="line-numbers"> 603 </span>   <span class="FunctionName">_.methods</span><span class="Keyword">:</span> _.functions
-<span class="line-numbers"> 604 </span> 
-<span class="line-numbers"> 605 </span> 
-<span class="line-numbers"> 606 </span>   <span class="Comment"><span class="Comment">#</span> ------------------------ Setup the OOP Wrapper: --------------------------</span>
-<span class="line-numbers"> 607 </span> 
-<span class="line-numbers"> 608 </span>   <span class="Comment"><span class="Comment">#</span> If Underscore is called as a function, it returns a wrapped object that</span>
-<span class="line-numbers"> 609 </span>   <span class="Comment"><span class="Comment">#</span> can be used OO-style. This wrapper holds altered versions of all the</span>
-<span class="line-numbers"> 610 </span>   <span class="Comment"><span class="Comment">#</span> underscore functions. Wrapped objects may be chained.</span>
-<span class="line-numbers"> 611 </span>   <span class="FunctionName">wrapper</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 612 </span>     <span class="FunctionName">this._wrapped</span><span class="Keyword">:</span> obj
-<span class="line-numbers"> 613 </span>     <span class="Variable">this</span>
-<span class="line-numbers"> 614 </span> 
-<span class="line-numbers"> 615 </span> 
-<span class="line-numbers"> 616 </span>   <span class="Comment"><span class="Comment">#</span> Helper function to continue chaining intermediate results.</span>
-<span class="line-numbers"> 617 </span>   <span class="FunctionName">result</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">obj, chain</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 618 </span>     <span class="Keyword">if</span> chain <span class="Keyword">then</span> _(obj).chain() <span class="Keyword">else</span> obj
-<span class="line-numbers"> 619 </span> 
-<span class="line-numbers"> 620 </span> 
-<span class="line-numbers"> 621 </span>   <span class="Comment"><span class="Comment">#</span> A method to easily add functions to the OOP wrapper.</span>
-<span class="line-numbers"> 622 </span>   <span class="FunctionName">addToWrapper</span><span class="Keyword">:</span> <span class="FunctionArgument">(</span><span class="FunctionArgument">name, func</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 623 </span>     wrapper.prototype[name]<span class="Keyword">:</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 624 </span>       <span class="FunctionName">args</span><span class="Keyword">:</span> _.toArray arguments
-<span class="line-numbers"> 625 </span>       unshift.call args, <span class="Variable">this</span>._wrapped
-<span class="line-numbers"> 626 </span>       result func.apply(_, args), <span class="Variable">this</span>._chain
-<span class="line-numbers"> 627 </span> 
-<span class="line-numbers"> 628 </span> 
-<span class="line-numbers"> 629 </span>   <span class="Comment"><span class="Comment">#</span> Add all of the Underscore functions to the wrapper object.</span>
-<span class="line-numbers"> 630 </span>   _.mixin _
-<span class="line-numbers"> 631 </span> 
-<span class="line-numbers"> 632 </span> 
-<span class="line-numbers"> 633 </span>   <span class="Comment"><span class="Comment">#</span> Add all mutator Array functions to the wrapper.</span>
-<span class="line-numbers"> 634 </span>   _.each [<span class="String"><span class="String">'</span>pop<span class="String">'</span></span>, <span class="String"><span class="String">'</span>push<span class="String">'</span></span>, <span class="String"><span class="String">'</span>reverse<span class="String">'</span></span>, <span class="String"><span class="String">'</span>shift<span class="String">'</span></span>, <span class="String"><span class="String">'</span>sort<span class="String">'</span></span>, <span class="String"><span class="String">'</span>splice<span class="String">'</span></span>, <span class="String"><span class="String">'</span>unshift<span class="String">'</span></span>], <span class="FunctionArgument">(</span><span class="FunctionArgument">name</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 635 </span>     <span class="FunctionName">method</span><span class="Keyword">:</span> Array.prototype[name]
-<span class="line-numbers"> 636 </span>     wrapper.prototype[name]<span class="Keyword">:</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 637 </span>       method.apply(<span class="Variable">this</span>._wrapped, arguments)
-<span class="line-numbers"> 638 </span>       result(<span class="Variable">this</span>._wrapped, <span class="Variable">this</span>._chain)
-<span class="line-numbers"> 639 </span> 
-<span class="line-numbers"> 640 </span> 
-<span class="line-numbers"> 641 </span>   <span class="Comment"><span class="Comment">#</span> Add all accessor Array functions to the wrapper.</span>
-<span class="line-numbers"> 642 </span>   _.each [<span class="String"><span class="String">'</span>concat<span class="String">'</span></span>, <span class="String"><span class="String">'</span>join<span class="String">'</span></span>, <span class="String"><span class="String">'</span>slice<span class="String">'</span></span>], <span class="FunctionArgument">(</span><span class="FunctionArgument">name</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 643 </span>     <span class="FunctionName">method</span><span class="Keyword">:</span> Array.prototype[name]
-<span class="line-numbers"> 644 </span>     wrapper.prototype[name]<span class="Keyword">:</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 645 </span>       result(method.apply(<span class="Variable">this</span>._wrapped, arguments), <span class="Variable">this</span>._chain)
-<span class="line-numbers"> 646 </span> 
-<span class="line-numbers"> 647 </span> 
-<span class="line-numbers"> 648 </span>   <span class="Comment"><span class="Comment">#</span> Start chaining a wrapped Underscore object.</span>
-<span class="line-numbers"> 649 </span>   <span class="FunctionName">wrapper::chain</span><span class="Keyword">:</span> <span class="Storage">-&gt;</span>
-<span class="line-numbers"> 650 </span>     <span class="FunctionName">this._chain</span><span class="Keyword">:</span> <span class="BuiltInConstant">true</span>
-<span class="line-numbers"> 651 </span>     <span class="Variable">this</span>
-<span class="line-numbers"> 652 </span> 
-<span class="line-numbers"> 653 </span> 
-<span class="line-numbers"> 654 </span>   <span class="Comment"><span class="Comment">#</span> Extracts the result from a wrapped and chained object.</span>
-<span class="line-numbers"> 655 </span>   <span class="FunctionName">wrapper::value</span><span class="Keyword">:</span> <span class="Storage">-&gt;</span> <span class="Variable">this</span>._wrapped
-</pre>
-</body>
-</html>

examples/underscore.coffee

@@ -1,28 +1,33 @@
 
-  # Underscore.coffee
-  # (c) 2010 Jeremy Ashkenas, DocumentCloud Inc.
-  # Underscore is freely distributable under the terms of the MIT license.
-  # Portions of Underscore are inspired by or borrowed from Prototype.js,
-  # Oliver Steele's Functional, and John Resig's Micro-Templating.
+  # **Underscore.coffee
+  # (c) 2010 Jeremy Ashkenas, DocumentCloud Inc.**
+  # Underscore is freely distributable under the terms of the
+  # [MIT license](http://en.wikipedia.org/wiki/MIT_License).
+  # Portions of Underscore are inspired by or borrowed from
+  # [Prototype.js](http://prototypejs.org/api), Oliver Steele's
+  # [Functional](http://osteele.com), and John Resig's
+  # [Micro-Templating](http://ejohn.com).
   # For all details and documentation:
   # http://documentcloud.github.com/underscore/
 
 
-  # ------------------------- Baseline setup ---------------------------------
+  # Baseline setup
+  # --------------
 
-  # Establish the root object, "window" in the browser, or "global" on the server.
+  # Establish the root object, `window` in the browser, or `global` on the server.
   root: this
 
 
-  # Save the previous value of the "_" variable.
+  # Save the previous value of the `_` variable.
   previousUnderscore: root._
 
 
   # Establish the object that gets thrown to break out of a loop iteration.
+  # `StopIteration` is SOP on Mozilla.
   breaker: if typeof(StopIteration) is 'undefined' then '__break__' else StopIteration
 
 
-  # Quick regexp-escaping function, because JS doesn't have RegExp.escape().
+  # Helper function to escape **RegExp** contents, because JS doesn't have one.
   escapeRegExp: (string) -> string.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1')
 
 
@@ -31,7 +36,7 @@
   ObjProto:             Object.prototype
 
 
-  #Create quick reference variables for speed access to core prototypes.
+  # Create quick reference variables for speed access to core prototypes.
   slice:                ArrayProto.slice
   unshift:              ArrayProto.unshift
   toString:             ObjProto.toString
@@ -39,7 +44,7 @@
   propertyIsEnumerable: ObjProto.propertyIsEnumerable
 
 
-  # All ECMA5 native implementations we hope to use are declared here.
+  # All **ECMA5** native implementations we hope to use are declared here.
   nativeForEach:        ArrayProto.forEach
   nativeMap:            ArrayProto.map
   nativeReduce:         ArrayProto.reduce
@@ -57,7 +62,7 @@
   _: (obj) -> new wrapper(obj)
 
 
-  # Export the Underscore object for CommonJS.
+  # Export the Underscore object for **CommonJS**.
   if typeof(exports) != 'undefined' then exports._: _
 
 
@@ -66,13 +71,14 @@
 
 
   # Current version.
-  _.VERSION: '0.6.0'
+  _.VERSION: '1.0.2'
 
 
-  # ------------------------ Collection Functions: ---------------------------
+  # Collection Functions
+  # --------------------
 
-  # The cornerstone, an each implementation.
-  # Handles objects implementing forEach, arrays, and raw objects.
+  # The cornerstone, an **each** implementation.
+  # Handles objects implementing **forEach**, arrays, and raw objects.
   _.each: (obj, iterator, context) ->
     try
       if nativeForEach and obj.forEach is nativeForEach
@@ -87,7 +93,7 @@
 
 
   # Return the results of applying the iterator to each element. Use JavaScript
-  # 1.6's version of map, if possible.
+  # 1.6's version of **map**, if possible.
   _.map: (obj, iterator, context) ->
     return obj.map(iterator, context) if nativeMap and obj.map is nativeMap
     results: []
@@ -96,8 +102,8 @@
     results
 
 
-  # Reduce builds up a single result from a list of values. Also known as
-  # inject, or foldl. Uses JavaScript 1.8's version of reduce, if possible.
+  # **Reduce** builds up a single result from a list of values. Also known as
+  # **inject**, or **foldl**. Uses JavaScript 1.8's version of **reduce**, if possible.
   _.reduce: (obj, memo, iterator, context) ->
     return obj.reduce(_.bind(iterator, context), memo) if nativeReduce and obj.reduce is nativeReduce
     _.each obj, (value, index, list) ->
@@ -105,8 +111,8 @@
     memo
 
 
-  # The right-associative version of reduce, also known as foldr. Uses
-  # JavaScript 1.8's version of reduceRight, if available.
+  # The right-associative version of **reduce**, also known as **foldr**. Uses
+  # JavaScript 1.8's version of **reduceRight**, if available.
   _.reduceRight: (obj, memo, iterator, context) ->
     return obj.reduceRight(_.bind(iterator, context), memo) if nativeReduceRight and obj.reduceRight is nativeReduceRight
     _.each _.clone(_.toArray(obj)).reverse(), (value, index) ->
@@ -125,7 +131,7 @@
 
 
   # Return all the elements that pass a truth test. Use JavaScript 1.6's
-  # filter(), if it exists.
+  # **filter**, if it exists.
   _.filter: (obj, iterator, context) ->
     return obj.filter iterator, context if nativeFilter and obj.filter is nativeFilter
     results: []
@@ -143,7 +149,7 @@
 
 
   # Determine whether all of the elements match a truth test. Delegate to
-  # JavaScript 1.6's every(), if it is present.
+  # JavaScript 1.6's **every**, if it is present.
   _.every: (obj, iterator, context) ->
     iterator ||= _.identity
     return obj.every iterator, context if nativeEvery and obj.every is nativeEvery
@@ -154,7 +160,7 @@
 
 
   # Determine if at least one element in the object matches a truth test. Use
-  # JavaScript 1.6's some(), if it exists.
+  # JavaScript 1.6's **some**, if it exists.
   _.some: (obj, iterator, context) ->
     iterator ||= _.identity
     return obj.some iterator, context if nativeSome and obj.some is nativeSome
@@ -165,7 +171,7 @@
 
 
   # Determine if a given value is included in the array or object,
-  # based on '==='.
+  # based on `===`.
   _.include: (obj, target) ->
     return _.indexOf(obj, target) isnt -1 if nativeIndexOf and obj.indexOf is nativeIndexOf
     for key, val of obj
@@ -179,7 +185,7 @@
     (if method then val[method] else val).apply(val, args) for val in obj
 
 
-  # Convenience version of a common use case of map: fetching a property.
+  # Convenience version of a common use case of **map**: fetching a property.
   _.pluck: (obj, key) ->
     _.map(obj, (val) -> val[key])
 
@@ -239,19 +245,20 @@
   _.size: (obj) -> _.toArray(obj).length
 
 
-  # -------------------------- Array Functions: ------------------------------
+  # Array Functions
+  # ---------------
 
-  # Get the first element of an array. Passing "n" will return the first N
-  # values in the array. Aliased as "head". The "guard" check allows it to work
-  # with _.map.
+  # Get the first element of an array. Passing `n` will return the first N
+  # values in the array. Aliased as **head**. The `guard` check allows it to work
+  # with **map**.
   _.first: (array, n, guard) ->
     if n and not guard then slice.call(array, 0, n) else array[0]
 
 
-  # Returns everything but the first entry of the array. Aliased as "tail".
-  # Especially useful on the arguments object. Passing an "index" will return
-  # the rest of the values in the array from that index onward. The "guard"
-  # check allows it to work with _.map.
+  # Returns everything but the first entry of the array. Aliased as **tail**.
+  # Especially useful on the arguments object. Passing an `index` will return
+  # the rest of the values in the array from that index onward. The `guard`
+  # check allows it to work with **map**.
   _.rest: (array, index, guard) ->
     slice.call(array, if _.isUndefined(index) or guard then 1 else index)
 
@@ -306,7 +313,7 @@
     results
 
 
-  # If the browser doesn't supply us with indexOf (I'm looking at you, MSIE),
+  # If the browser doesn't supply us with **indexOf** (I'm looking at you, MSIE),
   # we need this function. Return the position of the first occurence of an
   # item in an array, or -1 if the item is not included in the array.
   _.indexOf: (array, item) ->
@@ -317,7 +324,7 @@
     -1
 
 
-  # Provide JavaScript 1.6's lastIndexOf, delegating to the native function,
+  # Provide JavaScript 1.6's **lastIndexOf**, delegating to the native function,
   # if possible.
   _.lastIndexOf: (array, item) ->
     return array.lastIndexOf(item) if nativeLastIndexOf and array.lastIndexOf is nativeLastIndexOf
@@ -328,8 +335,7 @@
 
 
   # Generate an integer Array containing an arithmetic progression. A port of
-  # the native Python range() function. See:
-  # http://docs.python.org/library/functions.html#range
+  # [the native Python **range** function](http://docs.python.org/library/functions.html#range).
   _.range: (start, stop, step) ->
     a:        arguments
     solo:     a.length <= 1
@@ -347,10 +353,11 @@
       i+= step
 
 
-  # ----------------------- Function Functions: -----------------------------
+  # Function Functions
+  # ------------------
 
-  # Create a function bound to a given object (assigning 'this', and arguments,
-  # optionally). Binding with arguments is also known as 'curry'.
+  # Create a function bound to a given object (assigning `this`, and arguments,
+  # optionally). Binding with arguments is also known as **curry**.
   _.bind: (func, obj) ->
     args: _.rest arguments, 2
     -> func.apply obj or root, args.concat arguments
@@ -395,7 +402,8 @@
       args[0]
 
 
-  # ------------------------- Object Functions: ----------------------------
+  # Object Functions
+  # ----------------
 
   # Retrieve the names of an object's properties.
   _.keys: nativeKeys or (obj) ->
@@ -414,9 +422,10 @@
 
 
   # Extend a given object with all of the properties in a source object.
-  _.extend: (destination, source) ->
-    (destination[key]: val) for key, val of source
-    destination
+  _.extend: (obj) ->
+    for source in _.rest(arguments)
+      (obj[key]: val) for key, val of source
+    obj
 
 
   # Create a (shallow-cloned) duplicate of an object.
@@ -443,7 +452,7 @@
     return true if `a == b`
     # One is falsy and the other truthy.
     return false if (!a and b) or (a and !b)
-    # One of them implements an isEqual()?
+    # One of them implements an `isEqual()`?
     return a.isEqual(b) if a.isEqual
     # Check dates' integer values.
     return a.getTime() is b.getTime() if _.isDate(a) and _.isDate(b)
@@ -464,7 +473,7 @@
     # Different object sizes?
     return false if aKeys.length isnt bKeys.length
     # Recursive comparison of contents.
-    (return false) for key, val of a when !_.isEqual(val, b[key])
+    (return false) for key, val of a when !(key in b) or !_.isEqual(val, b[key])
     true
 
 
@@ -480,12 +489,11 @@
 
 
   # Is a given value an array?
-  _.isArray:      nativeIsArray or (obj) -> !!(obj and obj.concat and obj.unshift)
+  _.isArray:      nativeIsArray or (obj) -> !!(obj and obj.concat and obj.unshift and not obj.callee)
 
 
   # Is a given variable an arguments object?
-  _.isArguments:  (obj) -> obj and _.isNumber(obj.length) and not obj.concat and
-                           not obj.substr and not obj.apply and not propertyIsEnumerable.call(obj, 'length')
+  _.isArguments:  (obj) -> obj and obj.callee
 
 
   # Is the given value a function?
@@ -512,8 +520,8 @@
   _.isRegExp:     (obj) -> !!(obj and obj.exec and (obj.ignoreCase or obj.ignoreCase is false))
 
 
-  # Is the given value NaN -- this one is interesting. NaN != NaN, and
-  # isNaN(undefined) == true, so we make sure it's a number first.
+  # Is the given value NaN -- this one is interesting. `NaN != NaN`, and
+  # `isNaN(undefined) == true`, so we make sure it's a number first.
   _.isNaN:        (obj) -> _.isNumber(obj) and window.isNaN(obj)
 
 
@@ -525,9 +533,10 @@
   _.isUndefined:  (obj) -> typeof obj is 'undefined'
 
 
-  # -------------------------- Utility Functions: --------------------------
+  # Utility Functions
+  # -----------------
 
-  # Run Underscore.js in noConflict mode, returning the '_' variable to its
+  # Run Underscore.js in noConflict mode, returning the `_` variable to its
   # previous owner. Returns a reference to the Underscore object.
   _.noConflict: ->
     root._: previousUnderscore
@@ -538,7 +547,7 @@
   _.identity: (value) -> value
 
 
-  # Run a function n times.
+  # Run a function `n` times.
   _.times: (n, iterator, context) ->
     iterator.call(context, i) for i in [0...n]
 
@@ -561,7 +570,7 @@
     (prefix or '') + idCounter++
 
 
-  # By default, Underscore uses ERB-style template delimiters, change the
+  # By default, Underscore uses **ERB**-style template delimiters, change the
   # following template settings to use alternative delimiters.
   _.templateSettings: {
     start:        '<%'
@@ -570,9 +579,9 @@
   }
 
 
-  # JavaScript templating a-la ERB, pilfered from John Resig's
-  # "Secrets of the JavaScript Ninja", page 83.
-  # Single-quote fix from Rick Strahl's version.
+  # JavaScript templating a-la **ERB**, pilfered from John Resig's
+  # *Secrets of the JavaScript Ninja*, page 83.
+  # Single-quote fix from Rick Strahl.
   _.template: (str, data) ->
     c: _.templateSettings
     endMatch: new RegExp("'(?=[^"+c.end.substr(0, 1)+"]*"+escapeRegExp(c.end)+")","g")
@@ -590,7 +599,8 @@
     if data then fn(data) else fn
 
 
-  # ------------------------------- Aliases ----------------------------------
+  # Aliases
+  # -------
 
   _.forEach: _.each
   _.foldl:   _.inject:      _.reduce
@@ -603,7 +613,8 @@
   _.methods: _.functions
 
 
-  # ------------------------ Setup the OOP Wrapper: --------------------------
+  # Setup the OOP Wrapper
+  # ---------------------
 
   # If Underscore is called as a function, it returns a wrapped object that
   # can be used OO-style. This wrapper holds altered versions of all the

examples/web_server.coffee

@@ -1,5 +1,6 @@
 # Contributed by Jason Huggins
 
+sys:  require 'sys'
 http: require 'http'
 
 server: http.createServer (req, res) ->
@@ -9,4 +10,4 @@ server: http.createServer (req, res) ->
 
 server.listen 3000
 
-puts "Server running at http://localhost:3000/"
+sys.puts "Server running at http://localhost:3000/"

extras/CoffeeScript.tmbundle/CoffeeScript.tmPreferences

@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>name</key>
-	<string>comments</string>
-	<key>scope</key>
-	<string>source.coffee</string>
-	<key>settings</key>
-	<dict>
-		<key>shellVariables</key>
-		<array>
-			<dict>
-				<key>name</key>
-				<string>TM_COMMENT_START</string>
-				<key>value</key>
-				<string># </string>
-			</dict>
-		</array>
-	</dict>
-	<key>uuid</key>
-	<string>0A92C6F6-4D73-4859-B38C-4CC19CBC191F</string>
-</dict>
-</plist>

extras/CoffeeScript.tmbundle/Macros/Overwrite '}' in ${ __ }.tmMacro

@@ -1,54 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>commands</key>
-	<array>
-		<dict>
-			<key>command</key>
-			<string>moveRightAndModifySelection:</string>
-		</dict>
-		<dict>
-			<key>argument</key>
-			<dict>
-				<key>action</key>
-				<string>replaceAll</string>
-				<key>findInProjectIgnoreCase</key>
-				<false/>
-				<key>findString</key>
-				<string>((?m:.){2,})|\}|([^}])</string>
-				<key>ignoreCase</key>
-				<false/>
-				<key>regularExpression</key>
-				<true/>
-				<key>replaceAllScope</key>
-				<string>selection</string>
-				<key>replaceString</key>
-				<string>$1}$2</string>
-				<key>wrapAround</key>
-				<false/>
-			</dict>
-			<key>command</key>
-			<string>findWithOptions:</string>
-		</dict>
-		<dict>
-			<key>command</key>
-			<string>moveLeft:</string>
-		</dict>
-		<dict>
-			<key>command</key>
-			<string>moveRight:</string>
-		</dict>
-	</array>
-	<key>keyEquivalent</key>
-	<string>}</string>
-	<key>name</key>
-	<string>Overwrite '}' in ${ .. }</string>
-	<key>scope</key>
-	<string>source.coffee string.quoted.double source.coffee.embedded</string>
-	<key>scopeType</key>
-	<string>local</string>
-	<key>uuid</key>
-	<string>D7ADBF4B-B25B-4CF6-8FC0-C4FB0C3DBE64</string>
-</dict>
-</plist>

extras/CoffeeScript.tmbundle/Preferences/CoffeeScript.tmPreferences

@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>name</key>
-	<string>comments</string>
-	<key>scope</key>
-	<string>source.coffee</string>
-	<key>settings</key>
-	<dict>
-		<key>shellVariables</key>
-		<array>
-			<dict>
-				<key>name</key>
-				<string>TM_COMMENT_START</string>
-				<key>value</key>
-				<string># </string>
-			</dict>
-		</array>
-	</dict>
-	<key>uuid</key>
-	<string>0A92C6F6-4D73-4859-B38C-4CC19CBC191F</string>
-</dict>
-</plist>

extras/CoffeeScript.tmbundle/Snippets/Embedded Code — ${…}.tmSnippet

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>content</key>
-	<string>\${${1:$TM_SELECTED_TEXT}}</string>
-	<key>keyEquivalent</key>
-	<string>$</string>
-	<key>name</key>
-	<string>Embedded Code — ${…}</string>
-	<key>scope</key>
-	<string>string.quoted.double.coffee - string source</string>
-	<key>uuid</key>
-	<string>17C8BFF6-25F2-4F00-8E7E-768D3D186A23</string>
-</dict>
-</plist>

extras/CoffeeScript.tmbundle/Symbol List: Method.tmPreferences

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>name</key>
-	<string>Symbol List: Method</string>
-	<key>scope</key>
-	<string>source.coffee entity.name.type.instance</string>
-	<key>settings</key>
-	<dict>
-		<key>showInSymbolList</key>
-		<integer>0</integer>
-	</dict>
-	<key>uuid</key>
-	<string>B087AF2F-8946-4EA9-8409-49E7C4A2EEF0</string>
-</dict>
-</plist>

extras/CoffeeScript.tmbundle/Syntaxes/CoffeeScript.tmLanguage

@@ -1,576 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>comment</key>
-	<string>CoffeeScript Syntax: version 1</string>
-	<key>fileTypes</key>
-	<array>
-		<string>coffee</string>
-		<string>Cakefile</string>
-	</array>
-	<key>foldingStartMarker</key>
-	<string>^.*[:=] \{[^\}]*$</string>
-	<key>foldingStopMarker</key>
-	<string>\s*\}</string>
-	<key>name</key>
-	<string>CoffeeScript</string>
-	<key>patterns</key>
-	<array>
-		<dict>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>variable.parameter.function.coffee</string>
-				</dict>
-				<key>2</key>
-				<dict>
-					<key>name</key>
-					<string>variable.parameter.function.coffee</string>
-				</dict>
-				<key>4</key>
-				<dict>
-					<key>name</key>
-					<string>variable.parameter.function.coffee</string>
-				</dict>
-				<key>5</key>
-				<dict>
-					<key>name</key>
-					<string>storage.type.function.coffee</string>
-				</dict>
-			</dict>
-			<key>comment</key>
-			<string>match stuff like: a -&gt; … </string>
-			<key>match</key>
-			<string>(\()([a-zA-Z0-9_?.\$]*(,\s*[a-zA-Z0-9_?.\$]+)*)(\))\s*((=|-)&gt;)</string>
-			<key>name</key>
-			<string>meta.inline.function.coffee</string>
-		</dict>
-		<dict>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>keyword.operator.new.coffee</string>
-				</dict>
-				<key>2</key>
-				<dict>
-					<key>name</key>
-					<string>entity.name.type.instance.coffee</string>
-				</dict>
-			</dict>
-			<key>match</key>
-			<string>(new)\s+(\w+(?:\.\w*)?)</string>
-			<key>name</key>
-			<string>meta.class.instance.constructor</string>
-		</dict>
-		<dict>
-			<key>begin</key>
-			<string>("""|''')</string>
-			<key>beginCaptures</key>
-			<dict>
-				<key>0</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.begin.coffee</string>
-				</dict>
-			</dict>
-			<key>end</key>
-			<string>("""|''')</string>
-			<key>endCaptures</key>
-			<dict>
-				<key>0</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.end.coffee</string>
-				</dict>
-			</dict>
-			<key>name</key>
-			<string>string.quoted.heredoc.coffee</string>
-		</dict>
-		<dict>
-			<key>begin</key>
-			<string>`</string>
-			<key>beginCaptures</key>
-			<dict>
-				<key>0</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.begin.coffee</string>
-				</dict>
-			</dict>
-			<key>end</key>
-			<string>`</string>
-			<key>endCaptures</key>
-			<dict>
-				<key>0</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.end.coffee</string>
-				</dict>
-			</dict>
-			<key>name</key>
-			<string>string.quoted.script.coffee</string>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>match</key>
-					<string>\\(x\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]|37[0-7]?|[4-7][0-7]?|.)</string>
-					<key>name</key>
-					<string>constant.character.escape.coffee</string>
-				</dict>
-			</array>
-		</dict>
-		<dict>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.comment.coffee</string>
-				</dict>
-			</dict>
-			<key>match</key>
-			<string>(#).*$\n?</string>
-			<key>name</key>
-			<string>comment.line.coffee</string>
-		</dict>
-		<dict>
-			<key>begin</key>
-			<string>(?&lt;=[=(:]|^|return)\s*(/)(?![/*+{}?])</string>
-			<key>beginCaptures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.begin.coffee</string>
-				</dict>
-			</dict>
-			<key>end</key>
-			<string>(/)[igm]*</string>
-			<key>endCaptures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.string.end.coffee</string>
-				</dict>
-			</dict>
-			<key>name</key>
-			<string>string.regexp.coffee</string>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>match</key>
-					<string>\\.</string>
-					<key>name</key>
-					<string>constant.character.escape.coffee</string>
-				</dict>
-			</array>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>\b(break|by|catch|continue|else|finally|for|in|of|if|return|switch|then|throw|try|unless|when|while)\b</string>
-			<key>name</key>
-			<string>keyword.control.coffee</string>
-		</dict>
-		<dict>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>variable.assignment.coffee</string>
-				</dict>
-			</dict>
-			<key>match</key>
-			<string>(?=[a-zA-Z\$_])([a-zA-Z\$_](\w|\$|\.)*\s*(?=(?!\::)\:(?!(\s*\(.*\))?\s*((=|-)&gt;))))</string>
-			<key>name</key>
-			<string>variable.assignment.coffee</string>
-		</dict>
-		<dict>
-			<key>begin</key>
-			<string>(\[)(?=.*?\]\s*:)</string>
-			<key>beginCaptures</key>
-			<dict>
-				<key>0</key>
-				<dict>
-					<key>name</key>
-					<string>keyword.operator.coffee</string>
-				</dict>
-			</dict>
-			<key>end</key>
-			<string>(\]\s*:)</string>
-			<key>endCaptures</key>
-			<dict>
-				<key>0</key>
-				<dict>
-					<key>name</key>
-					<string>keyword.operator.coffee</string>
-				</dict>
-			</dict>
-			<key>name</key>
-			<string>meta.variable.assignment.destructured.coffee</string>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>include</key>
-					<string>#variable_name</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#instance_variable</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#single_quoted_string</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#double_quoted_string</string>
-				</dict>
-				<dict>
-					<key>include</key>
-					<string>#numeric</string>
-				</dict>
-			</array>
-		</dict>
-		<dict>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>entity.name.function.coffee</string>
-				</dict>
-			</dict>
-			<key>match</key>
-			<string>(?=[a-zA-Z\$_])([a-zA-Z\$_](\w|\$|:|\.)*\s*(?=\:(\s*\(.*\))?\s*((=|-)&gt;)))</string>
-			<key>name</key>
-			<string>meta.function.coffee</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>(=|-)&gt;</string>
-			<key>name</key>
-			<string>storage.type.function.coffee</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>\b(true|on|yes)\b</string>
-			<key>name</key>
-			<string>constant.language.boolean.true.coffee</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>\b(false|off|no)\b</string>
-			<key>name</key>
-			<string>constant.language.boolean.false.coffee</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>\bnull\b</string>
-			<key>name</key>
-			<string>constant.language.null.coffee</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>\b(super|this|extends)\b</string>
-			<key>name</key>
-			<string>variable.language.coffee</string>
-		</dict>
-		<dict>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>storage.type.class.coffee</string>
-				</dict>
-				<key>2</key>
-				<dict>
-					<key>name</key>
-					<string>entity.name.type.class.coffee</string>
-				</dict>
-				<key>3</key>
-				<dict>
-					<key>name</key>
-					<string>entity.other.inherited-class.coffee</string>
-				</dict>
-				<key>4</key>
-				<dict>
-					<key>name</key>
-					<string>keyword.control.inheritance.coffee</string>
-				</dict>
-			</dict>
-			<key>match</key>
-			<string>(class)\s+([a-zA-Z\$_]\w+)(\s+(extends)\s+[a-zA-Z\$_]\w*)?</string>
-			<key>name</key>
-			<string>meta.class.coffee</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>\b(debugger|\\)\b</string>
-			<key>name</key>
-			<string>keyword.other.coffee</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>!|%|&amp;|\*|\/|\-\-|\-|\+\+|\+|~|===|==|=|!=|!==|&lt;=|&gt;=|&lt;&lt;=|&gt;&gt;=|&gt;&gt;&gt;=|&lt;&gt;|&lt;|&gt;|!|&amp;&amp;|\?|\|\||\:|\*=|(?&lt;!\()/=|%=|\+=|\-=|&amp;=|\^=|\b(instanceof|new|delete|typeof|and|or|is|isnt|not)\b</string>
-			<key>name</key>
-			<string>keyword.operator.coffee</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>\b(Infinity|NaN|undefined)\b</string>
-			<key>name</key>
-			<string>constant.language.coffee</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>\;</string>
-			<key>name</key>
-			<string>punctuation.terminator.statement.coffee</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>,[ |\t]*</string>
-			<key>name</key>
-			<string>meta.delimiter.object.comma.coffee</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>\.</string>
-			<key>name</key>
-			<string>meta.delimiter.method.period.coffee</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>\{|\}</string>
-			<key>name</key>
-			<string>meta.brace.curly.coffee</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>\(|\)</string>
-			<key>name</key>
-			<string>meta.brace.round.coffee</string>
-		</dict>
-		<dict>
-			<key>match</key>
-			<string>\[|\]\s*</string>
-			<key>name</key>
-			<string>meta.brace.square.coffee</string>
-		</dict>
-		<dict>
-			<key>include</key>
-			<string>#instance_variable</string>
-		</dict>
-		<dict>
-			<key>include</key>
-			<string>#single_quoted_string</string>
-		</dict>
-		<dict>
-			<key>include</key>
-			<string>#double_quoted_string</string>
-		</dict>
-		<dict>
-			<key>include</key>
-			<string>#numeric</string>
-		</dict>
-	</array>
-	<key>repository</key>
-	<dict>
-		<key>double_quoted_string</key>
-		<dict>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>begin</key>
-					<string>"</string>
-					<key>beginCaptures</key>
-					<dict>
-						<key>0</key>
-						<dict>
-							<key>name</key>
-							<string>punctuation.definition.string.begin.coffee</string>
-						</dict>
-					</dict>
-					<key>end</key>
-					<string>"</string>
-					<key>endCaptures</key>
-					<dict>
-						<key>0</key>
-						<dict>
-							<key>name</key>
-							<string>punctuation.definition.string.end.coffee</string>
-						</dict>
-					</dict>
-					<key>name</key>
-					<string>string.quoted.double.coffee</string>
-					<key>patterns</key>
-					<array>
-						<dict>
-							<key>match</key>
-							<string>\\(x\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]|37[0-7]?|[4-7][0-7]?|.)</string>
-							<key>name</key>
-							<string>constant.character.escape.coffee</string>
-						</dict>
-						<dict>
-							<key>include</key>
-							<string>#interpolated_coffee</string>
-						</dict>
-					</array>
-				</dict>
-			</array>
-		</dict>
-		<key>instance_variable</key>
-		<dict>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>match</key>
-					<string>(@)([a-zA-Z_\$]\w*)?</string>
-					<key>name</key>
-					<string>variable.other.readwrite.instance.coffee</string>
-				</dict>
-			</array>
-		</dict>
-		<key>interpolated_coffee</key>
-		<dict>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>begin</key>
-					<string>\$\{</string>
-					<key>captures</key>
-					<dict>
-						<key>0</key>
-						<dict>
-							<key>name</key>
-							<string>punctuation.section.embedded.coffee</string>
-						</dict>
-					</dict>
-					<key>end</key>
-					<string>\}</string>
-					<key>name</key>
-					<string>source.coffee.embedded.source</string>
-					<key>patterns</key>
-					<array>
-						<dict>
-							<key>include</key>
-							<string>$self</string>
-						</dict>
-					</array>
-				</dict>
-				<dict>
-					<key>captures</key>
-					<dict>
-						<key>1</key>
-						<dict>
-							<key>name</key>
-							<string>punctuation.definition.variable.coffee</string>
-						</dict>
-					</dict>
-					<key>match</key>
-					<string>(\$)@[a-zA-Z_]\w*(\.\w+)*</string>
-					<key>name</key>
-					<string>variable.other.readwrite.coffee</string>
-				</dict>
-				<dict>
-					<key>captures</key>
-					<dict>
-						<key>1</key>
-						<dict>
-							<key>name</key>
-							<string>punctuation.definition.variable.coffee</string>
-						</dict>
-					</dict>
-					<key>match</key>
-					<string>(\$)(?!@)[a-zA-Z_]\w*(\.\w+)*</string>
-					<key>name</key>
-					<string>source.coffee.embedded.source</string>
-				</dict>
-			</array>
-		</dict>
-		<key>numeric</key>
-		<dict>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>match</key>
-					<string>(?&lt;!\$)\b((0(x|X)[0-9a-fA-F]+)|([0-9]+(\.[0-9]+)?(e[+\-]?[0-9]+)?))\b</string>
-					<key>name</key>
-					<string>constant.numeric.coffee</string>
-				</dict>
-			</array>
-		</dict>
-		<key>single_quoted_string</key>
-		<dict>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>begin</key>
-					<string>'</string>
-					<key>beginCaptures</key>
-					<dict>
-						<key>0</key>
-						<dict>
-							<key>name</key>
-							<string>punctuation.definition.string.begin.coffee</string>
-						</dict>
-					</dict>
-					<key>end</key>
-					<string>'</string>
-					<key>endCaptures</key>
-					<dict>
-						<key>0</key>
-						<dict>
-							<key>name</key>
-							<string>punctuation.definition.string.end.coffee</string>
-						</dict>
-					</dict>
-					<key>name</key>
-					<string>string.quoted.single.coffee</string>
-					<key>patterns</key>
-					<array>
-						<dict>
-							<key>match</key>
-							<string>\\(x\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.)</string>
-							<key>name</key>
-							<string>constant.character.escape.coffee</string>
-						</dict>
-					</array>
-				</dict>
-			</array>
-		</dict>
-		<key>variable_name</key>
-		<dict>
-			<key>patterns</key>
-			<array>
-				<dict>
-					<key>captures</key>
-					<dict>
-						<key>1</key>
-						<dict>
-							<key>name</key>
-							<string>variable.assignment.coffee</string>
-						</dict>
-					</dict>
-					<key>match</key>
-					<string>([a-zA-Z\$_]\w*(\.\w+)*)</string>
-					<key>name</key>
-					<string>variable.assignment.coffee</string>
-				</dict>
-			</array>
-		</dict>
-	</dict>
-	<key>scopeName</key>
-	<string>source.coffee</string>
-	<key>uuid</key>
-	<string>5B520980-A7D5-4E10-8582-1A4C889A8DE5</string>
-</dict>
-</plist>

extras/CoffeeScript.tmbundle/info.plist

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>name</key>
-	<string>CoffeeScript</string>
-	<key>uuid</key>
-	<string>A46E4382-F1AC-405B-8F22-65FF470F34D7</string>
-</dict>
-</plist>

extras/EXTRAS

@@ -5,24 +5,3 @@ CoffeeScript compiler. To use it in the browser, include the script after any
 inline script tags of type "text/coffeescript" on the page. It will compile
 and evaluate all of the scripts in order.
 
-
-This folder also includes rough cuts of CoffeeScript syntax highlighters for 
-TextMate and Vim. Improvements to their lexing ability are always welcome.
-
-To install the TextMate bundle, drop it into:
-  ~/Library/Application Support/TextMate/Bundles
-
-To install the Vim highlighter, copy "coffee.vim" into the "syntax" directory of
-your vim72, and enable it in either of the following two ways:
-
-  * Manually, by running `:set syntax=coffee`
-  
-  * Or automatically, by creating a "filetype.vim" file within "~/.vim", which
-    contains something along these lines:
-    
-    if exists("did_load_filetypes")
-      finish
-    end
-    augroup filetypedetect
-      au! BufRead,BufNewFile *.coffee setfiletype coffee
-    augroup END

extras/coffee.vim

@@ -1,117 +0,0 @@
-" Vim syntax file
-" Language:	CoffeeScript
-" Maintainer:	Jeff Olson <olson.jeffery@gmail.com>
-" URL:		http://github.com/olsonjeffery
-" Changes:	(jro) initial port from javascript
-" Last Change:	2006 Jun 19
-" Adaptation of javascript.vim syntax file (distro'd w/ vim72), 
-" maintained by Claudio Fleiner <claudio@fleiner.com>
-" with updates from Scott Shattuck (ss) <ss@technicalpursuit.com>
-
-if !exists("main_syntax")
-  if version < 600
-    syntax clear
-  elseif exists("b:current_syntax")
-    finish
-  endif
-  let main_syntax = 'coffee'
-endif
-
-syn case ignore
-
-syn match   coffeeLineComment      "#.*" contains=@Spell,CoffeeCommentTodo
-syn match   coffeeSpecial	       "\\\d\d\d\|\\."
-syn region  coffeeStringD	       start=+"+  skip=+\\\\\|\\"+  end=+"\|$+  contains=coffeeSpecial,@htmlPreproc
-syn region  coffeeStringS	       start=+'+  skip=+\\\\\|\\'+  end=+'\|$+  contains=coffeeSpecial,@htmlPreproc
-
-syn match   coffeeSpecialCharacter "'\\.'"
-syn match   coffeeNumber	       "-\=\<\d\+L\=\>\|0[xX][0-9a-fA-F]\+\>"
-syn region  coffeeRegexpString     start=+/[^/*]+me=e-1 skip=+\\\\\|\\/+ end=+/[gi]\{0,2\}\s*$+ end=+/[gi]\{0,2\}\s*[;.,)\]}]+me=e-1 contains=@htmlPreproc oneline
-
-syn match coffeeFunctionParams "([^)]*)\s*->"
-syn match coffeeBindFunctionParams "([^)]*)\s*=>"
-syn match coffeePrototypeAccess "::"
-syn match coffeeBindFunction "=[1]>[1]"
-syn match coffeeFunction "->"
-
-syn keyword coffeeExtends   extends
-syn keyword coffeeConditional	if else switch then not
-syn keyword coffeeRepeat		while for in of
-syn keyword coffeeBranch		break continue
-syn keyword coffeeOperator		delete instanceof typeof
-syn keyword coffeeType		Array Boolean Date Function Number Object String RegExp
-syn keyword coffeeStatement		return with
-syn keyword coffeeBoolean		true false
-syn keyword coffeeNull		null undefined
-syn keyword coffeeIdentifier	arguments this var
-syn keyword coffeeLabel		case default
-syn keyword coffeeException		try catch finally throw
-syn keyword coffeeMessage		alert confirm prompt status
-syn keyword coffeeGlobal		self window top parent
-syn keyword coffeeMember		document event location 
-syn keyword coffeeDeprecated	escape unescape
-syn keyword coffeeReserved		abstract boolean byte char class const debugger double enum export final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile 
-
-syn sync fromstart
-syn sync maxlines=100
-
-if main_syntax == "coffee"
-  syn sync ccomment coffeeComment
-endif
-
-" Define the default highlighting.
-" For version 5.7 and earlier: only when not done already
-" For version 5.8 and later: only when an item doesn't have highlighting yet
-if version >= 508 || !exists("did_coffee_syn_inits")
-  if version < 508
-    let did_coffee_syn_inits = 1
-    command -nargs=+ HiLink hi link <args>
-  else
-    command -nargs=+ HiLink hi def link <args>
-  endif
-  HiLink coffeePrototypeAccess Keyword
-  HiLink coffeeExtends        Keyword
-  HiLink coffeeLineComment		Comment
-  HiLink coffeeSpecial		Special
-  HiLink coffeeStringS		String
-  HiLink coffeeStringD		String
-  HiLink coffeeCharacter		Character
-  HiLink coffeeSpecialCharacter	coffeeSpecial
-  HiLink coffeeNumber		coffeeValue
-  HiLink coffeeConditional		Conditional
-  HiLink coffeeRepeat		Repeat
-  HiLink coffeeBranch		Conditional
-  HiLink coffeeOperator		Operator
-  HiLink coffeeType			Type
-  HiLink coffeeStatement		Statement
-  HiLink coffeeBindFunctionParams		Function
-  HiLink coffeeFunctionParams		Function
-  HiLink coffeeFunction		Function
-  HiLink coffeeBindFunction		Function
-  HiLink coffeeBraces		Function
-  HiLink coffeeError		Error
-  HiLink coffeeScrParenError		coffeeError
-  HiLink coffeeNull			Keyword
-  HiLink coffeeBoolean		Boolean
-  HiLink coffeeRegexpString		String
-
-  HiLink coffeeIdentifier		Identifier
-  HiLink coffeeLabel		Label
-  HiLink coffeeException		Exception
-  HiLink coffeeMessage		Keyword
-  HiLink coffeeGlobal		Keyword
-  HiLink coffeeMember		Keyword
-  HiLink coffeeDeprecated		Exception 
-  HiLink coffeeReserved		Keyword
-  HiLink coffeeDebug		Debug
-  HiLink coffeeConstant		Label
-
-  delcommand HiLink
-endif
-
-let b:current_syntax = "coffee"
-if main_syntax == 'coffee'
-  unlet main_syntax
-endif
-
-" vim: ts=8

index.html

@@ -32,7 +32,6 @@
         <a href="#conditionals">Conditionals, Ternaries, and Conditional Assignment</a>
         <a href="#aliases">Aliases</a>
         <a href="#splats">Splats...</a>
-        <a href="#arguments">Arguments are Arrays</a>
         <a href="#while">While Loops</a>
         <a href="#comprehensions">Comprehensions (Arrays, Objects, and Ranges)</a>
         <a href="#slice_splice">Array Slicing and Splicing with Ranges</a>
@@ -45,8 +44,8 @@
         <a href="#switch">Switch/When/Else</a>
         <a href="#try">Try/Catch/Finally</a>
         <a href="#comparisons">Chained Comparisons</a>
+        <a href="#interpolation">String and RegExp Interpolation</a>
         <a href="#strings">Multiline Strings and Heredocs</a>
-        <a href="#interpolation">String Interpolation</a>
         <a href="#cake">Cake, and Cakefiles</a>
         <a href="#scripts">"text/coffeescript" Script Tags</a>
         <a href="#resources">Resources</a>
@@ -62,7 +61,7 @@
           <div id="repl_source_wrap"><textarea id="repl_source">reverse: (string) ->
   string.split('').reverse().join ''
 
-alert reverse '!tpircseeffoC'</textarea></div>
+alert reverse '.eeffoC yrT'</textarea></div>
           <pre id="repl_results"></pre>
           <button class="full_screen">go full screen</button>
           <button class="minimize">minimize</button>
@@ -76,11 +75,12 @@ alert reverse '!tpircseeffoC'</textarea></div>
         Annotated Source
       </div>
       <div class="contents">
-        <a href="documentation/docs/grammar.html">The Grammar &mdash; src/grammar</a>
-        <a href="documentation/docs/lexer.html">The Lexer &mdash; src/lexer</a>
+        <a href="documentation/docs/grammar.html">Grammar Rules &mdash; src/grammar</a>
+        <a href="documentation/docs/lexer.html">Lexing Tokens &mdash; src/lexer</a>
         <a href="documentation/docs/rewriter.html">The Rewriter &mdash; src/rewriter</a>
         <a href="documentation/docs/nodes.html">The Syntax Tree &mdash; src/nodes</a>
         <a href="documentation/docs/scope.html">Lexical Scope &mdash; src/scope</a>
+        <a href="documentation/docs/helpers.html">Helpers &amp; Utility Functions &mdash; src/helpers</a>
         <a href="documentation/docs/coffee-script.html">The CoffeeScript Module &mdash; src/coffee-script</a>
         <a href="documentation/docs/cake.html">Cake &amp; Cakefiles &mdash; src/cake</a>
         <a href="documentation/docs/command.html">"coffee" Command-Line Utility &mdash; src/command</a>
@@ -115,7 +115,7 @@ alert reverse '!tpircseeffoC'</textarea></div>
 
     <p>
       <b>Latest Version:</b>
-      <a href="http://github.com/jashkenas/coffee-script/tarball/0.5.5">0.5.5</a>
+      <a href="http://github.com/jashkenas/coffee-script/tarball/0.6.0">0.6.0</a>
     </p>
 
     <h2>
@@ -155,6 +155,7 @@ alert <span class="String"><span class="String">&quot;</span>I knew it!<span cla
 <span class="Comment"><span class="Comment">#</span> Array comprehensions:</span>
 cubed_list<span class="Keyword">:</span> math.cube num <span class="Keyword">for</span> num <span class="Keyword">in</span> list
 </pre><pre class="idle"><span class="Storage">var</span> _a, _b, _c, _d, cubed_list, list, math, num, number, opposite_day, race, square;
+<span class="Storage">var</span> __slice <span class="Keyword">=</span> <span class="LibraryClassType">Array</span>.<span class="LibraryConstant">prototype</span>.slice;
 <span class="Comment"><span class="Comment">//</span> Assignment:</span>
 number <span class="Keyword">=</span> <span class="Number">42</span>;
 opposite_day <span class="Keyword">=</span> <span class="BuiltInConstant">true</span>;
@@ -179,7 +180,7 @@ math <span class="Keyword">=</span> {
 <span class="Comment"><span class="Comment">//</span> Splats:</span>
 race <span class="Keyword">=</span> <span class="Storage">function</span> <span class="FunctionName">race</span>(<span class="FunctionArgument">winner</span>) {
   <span class="Storage">var</span> runners;
-  runners <span class="Keyword">=</span> <span class="LibraryClassType">Array</span>.<span class="LibraryConstant">prototype</span>.slice.<span class="LibraryFunction">call</span>(arguments, <span class="Number">1</span>);
+  runners <span class="Keyword">=</span> __slice.<span class="LibraryFunction">call</span>(arguments, <span class="Number">1</span>, arguments.<span class="LibraryConstant">length</span> <span class="Keyword">-</span> <span class="Number">0</span>);
   <span class="Keyword">return</span> <span class="LibraryFunction">print</span>(winner, runners);
 };
 <span class="Comment"><span class="Comment">//</span> Existence:</span>
@@ -188,14 +189,15 @@ race <span class="Keyword">=</span> <span class="Storage">function</span> <span
 }
 <span class="Comment"><span class="Comment">//</span> Array comprehensions:</span>
 cubed_list <span class="Keyword">=</span> (<span class="Storage">function</span>() {
-  _a <span class="Keyword">=</span> []; _b <span class="Keyword">=</span> list;
-  <span class="Keyword">for</span> (_c <span class="Keyword">=</span> <span class="Number">0</span>, _d <span class="Keyword">=</span> _b.<span class="LibraryConstant">length</span>; _c <span class="Keyword">&lt;</span> _d; _c<span class="Keyword">++</span>) {
-    num <span class="Keyword">=</span> _b[_c];
+  _a <span class="Keyword">=</span> []; _c <span class="Keyword">=</span> list;
+  <span class="Keyword">for</span> (_b <span class="Keyword">=</span> <span class="Number">0</span>, _d <span class="Keyword">=</span> _c.<span class="LibraryConstant">length</span>; _b <span class="Keyword">&lt;</span> _d; _b<span class="Keyword">++</span>) {
+    num <span class="Keyword">=</span> _c[_b];
     _a.<span class="LibraryFunction">push</span>(math.cube(num));
   }
   <span class="Keyword">return</span> _a;
 }).<span class="LibraryFunction">call</span>(<span class="Variable">this</span>);
 </pre><button onclick='javascript: var _a, _b, _c, _d, cubed_list, list, math, num, number, opposite_day, race, square;
+var __slice = Array.prototype.slice;
 // Assignment:
 number = 42;
 opposite_day = true;
@@ -220,7 +222,7 @@ math = {
 // Splats:
 race = function race(winner) {
   var runners;
-  runners = Array.prototype.slice.call(arguments, 1);
+  runners = __slice.call(arguments, 1, arguments.length - 0);
   return print(winner, runners);
 };
 // Existence:
@@ -229,9 +231,9 @@ if ((typeof elvis !== "undefined" && elvis !== null)) {
 }
 // Array comprehensions:
 cubed_list = (function() {
-  _a = []; _b = list;
-  for (_c = 0, _d = _b.length; _c < _d; _c++) {
-    num = _b[_c];
+  _a = []; _c = list;
+  for (_b = 0, _d = _c.length; _b < _d; _b++) {
+    num = _c[_b];
     _a.push(math.cube(num));
   }
   return _a;
@@ -240,7 +242,7 @@ cubed_list = (function() {
 
     <p>
       For a longer CoffeeScript example, check out
-      <a href="documentation/underscore.html">Underscore.coffee</a>, a port
+      <a href="documentation/docs/underscore.html">Underscore.coffee</a>, a port
       of the <a href="http://documentcloud.github.com/underscore/">Underscore.js</a>
       library of helper functions. Underscore.coffee can pass the entire Underscore.js
       test suite. The CoffeeScript version is faster than the original for a number
@@ -258,7 +260,7 @@ cubed_list = (function() {
 
     <p>
       The CoffeeScript compiler is written in pure CoffeeScript, using a
-      <a href="http://github.com/jashkenas/coffee-script/blob/master/src/grammar.coffee">small DSL</a>
+      <a href="documentation/docs/grammar.html">small DSL</a>
       on top of the <a href="http://github.com/zaach/jison">Jison parser generator</a>, and is available
       as a <a href="http://nodejs.org/">Node.js</a> utility. The core compiler however,
       does not depend on Node, and can be run in other server-side-JavaScript environments,
@@ -267,12 +269,12 @@ cubed_list = (function() {
     </p>
 
     <p>
-      To install, first make sure you have a working version of
-      <a href="http://nodejs.org/">Node.js</a> version 0.1.31 or higher.
+      To install, first make sure you have a working copy of the latest tagged version of
+      <a href="http://nodejs.org/">Node.js</a>, currently <b>0.1.33</b> or higher.
       Then clone the CoffeeScript
       <a href="http://github.com/jashkenas/coffee-script">source repository</a>
       from GitHub, or download the latest
-      release: <a href="http://github.com/jashkenas/coffee-script/tarball/0.5.5">0.5.5</a>.
+      release: <a href="http://github.com/jashkenas/coffee-script/tarball/0.6.0">0.6.0</a>.
       To install the CoffeeScript compiler system-wide
       under <tt>/usr/local</tt>, open the directory and run:
     </p>
@@ -341,14 +343,14 @@ sudo bin/cake install</pre>
         <td>
           Pipe in CoffeeScript to STDIN and get back JavaScript over STDOUT.
           Good for use with processes written in other languages. An example:<br />
-          <tt>cat src/cake.coffee | coffee -s</tt>
+          <tt>cat src/cake.coffee | coffee -sc</tt>
         </td>
       </tr>
       <tr>
         <td><code>-e, --eval</code></td>
         <td>
           Compile and print a little snippet of CoffeeScript directly from the
-          command line. For example:<br /><tt>coffee -e "square: (x) -> x * x"</tt>
+          command line. For example:<br /><tt>coffee -e "puts num for num in [10..1]"</tt>
         </td>
       </tr>
       <tr>
@@ -546,7 +548,8 @@ num <span class="Keyword">=</span> <span class="Number">1</span>;
 change_numbers <span class="Keyword">=</span> <span class="Storage">function</span> <span class="FunctionName">change_numbers</span>() {
   <span class="Storage">var</span> new_num;
   new_num <span class="Keyword">=</span> <span class="Keyword">-</span><span class="Number">1</span>;
-  <span class="Keyword">return</span> num <span class="Keyword">=</span> <span class="Number">10</span>;
+  num <span class="Keyword">=</span> <span class="Number">10</span>;
+  <span class="Keyword">return</span> num;
 };
 new_num <span class="Keyword">=</span> change_numbers();
 </pre><button onclick='javascript: var change_numbers, new_num, num;
@@ -554,7 +557,8 @@ num = 1;
 change_numbers = function change_numbers() {
   var new_num;
   new_num = -1;
-  return num = 10;
+  num = 10;
+  return num;
 };
 new_num = change_numbers();
 ;alert(new_num);'>run: new_num</button><br class='clear' /></div>
@@ -566,6 +570,13 @@ new_num = change_numbers();
       should not be able to change the value of the external variable of the same name, and
       therefore has a declaration of its own.
     </p>
+    <p>
+      This behavior is effectively identical to Ruby's scope for local variables.
+      Because you don't have direct access to the <tt>var</tt> keyword,
+      it's impossible to shadow an outer variable on purpose, you may only refer
+      to it. So be careful that you're not reusing the name of an external
+      variable accidentally, if you're writing a deeply nested function.
+    </p>
     <p>
       Although suppressed within this documentation for clarity, all
       CoffeeScript output is wrapped in an anonymous function:
@@ -601,7 +612,7 @@ new_num = change_numbers();
 
 date<span class="Keyword">:</span> <span class="Keyword">if</span> friday <span class="Keyword">then</span> sue <span class="Keyword">else</span> jill
 
-expensive <span class="Keyword">||</span><span class="Keyword">=</span> do_the_math()
+expensive<span class="Keyword">:</span> <span class="Keyword">or</span> do_the_math()
 </pre><pre class="idle"><span class="Storage">var</span> date, expensive, mood;
 <span class="Keyword">if</span> (singing) {
   mood <span class="Keyword">=</span> greatly_improved;
@@ -614,10 +625,9 @@ date <span class="Keyword">=</span> friday ? sue : jill;
 expensive <span class="Keyword">=</span> expensive <span class="Keyword">||</span> do_the_math();
 </pre><br class='clear' /></div>
     <p>
-      The conditional assignment operators are included: <tt>||=</tt>,
-      which only assigns a value to a variable if the variable's current value
-      is falsy, and <tt>&amp;&amp;=</tt>, which only replaces the value of
-      truthy variables.
+      You can assign a variable to a half-expression to perform an operation
+      like Ruby's <tt>||=</tt>, which only assigns a value to a variable 
+      if the variable's current value is falsy.
     </p>
 
     <p>
@@ -709,13 +719,15 @@ alert <span class="String"><span class="String">&quot;</span>Gold: <span class="
 alert <span class="String"><span class="String">&quot;</span>Silver: <span class="String">&quot;</span></span> <span class="Keyword">+</span> silver
 alert <span class="String"><span class="String">&quot;</span>The Field: <span class="String">&quot;</span></span> <span class="Keyword">+</span> the_field
 </pre><pre class="idle"><span class="Storage">var</span> award_medals, contenders, gold, silver, the_field;
+<span class="Storage">var</span> __slice <span class="Keyword">=</span> <span class="LibraryClassType">Array</span>.<span class="LibraryConstant">prototype</span>.slice;
 gold <span class="Keyword">=</span> (silver <span class="Keyword">=</span> (the_field <span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>unknown<span class="String">&quot;</span></span>));
 award_medals <span class="Keyword">=</span> <span class="Storage">function</span> <span class="FunctionName">award_medals</span>(<span class="FunctionArgument">first, second</span>) {
   <span class="Storage">var</span> rest;
-  rest <span class="Keyword">=</span> <span class="LibraryClassType">Array</span>.<span class="LibraryConstant">prototype</span>.slice.<span class="LibraryFunction">call</span>(arguments, <span class="Number">2</span>);
+  rest <span class="Keyword">=</span> __slice.<span class="LibraryFunction">call</span>(arguments, <span class="Number">2</span>, arguments.<span class="LibraryConstant">length</span> <span class="Keyword">-</span> <span class="Number">0</span>);
   gold <span class="Keyword">=</span> first;
   silver <span class="Keyword">=</span> second;
-  <span class="Keyword">return</span> the_field <span class="Keyword">=</span> rest;
+  the_field <span class="Keyword">=</span> rest;
+  <span class="Keyword">return</span> the_field;
 };
 contenders <span class="Keyword">=</span> [<span class="String"><span class="String">&quot;</span>Michael Phelps<span class="String">&quot;</span></span>, <span class="String"><span class="String">&quot;</span>Liu Xiang<span class="String">&quot;</span></span>, <span class="String"><span class="String">&quot;</span>Yao Ming<span class="String">&quot;</span></span>, <span class="String"><span class="String">&quot;</span>Allyson Felix<span class="String">&quot;</span></span>, <span class="String"><span class="String">&quot;</span>Shawn Johnson<span class="String">&quot;</span></span>, <span class="String"><span class="String">&quot;</span>Roman Sebrle<span class="String">&quot;</span></span>, <span class="String"><span class="String">&quot;</span>Guo Jingjing<span class="String">&quot;</span></span>, <span class="String"><span class="String">&quot;</span>Tyson Gay<span class="String">&quot;</span></span>, <span class="String"><span class="String">&quot;</span>Asafa Powell<span class="String">&quot;</span></span>, <span class="String"><span class="String">&quot;</span>Usain Bolt<span class="String">&quot;</span></span>];
 award_medals.<span class="LibraryFunction">apply</span>(<span class="Variable">this</span>, contenders);
@@ -723,45 +735,21 @@ award_medals.<span class="LibraryFunction">apply</span>(<span class="Variable">t
 <span class="LibraryFunction">alert</span>(<span class="String"><span class="String">&quot;</span>Silver: <span class="String">&quot;</span></span> <span class="Keyword">+</span> silver);
 <span class="LibraryFunction">alert</span>(<span class="String"><span class="String">&quot;</span>The Field: <span class="String">&quot;</span></span> <span class="Keyword">+</span> the_field);
 </pre><button onclick='javascript: var award_medals, contenders, gold, silver, the_field;
+var __slice = Array.prototype.slice;
 gold = (silver = (the_field = "unknown"));
 award_medals = function award_medals(first, second) {
   var rest;
-  rest = Array.prototype.slice.call(arguments, 2);
+  rest = __slice.call(arguments, 2, arguments.length - 0);
   gold = first;
   silver = second;
-  return the_field = rest;
+  the_field = rest;
+  return the_field;
 };
 contenders = ["Michael Phelps", "Liu Xiang", "Yao Ming", "Allyson Felix", "Shawn Johnson", "Roman Sebrle", "Guo Jingjing", "Tyson Gay", "Asafa Powell", "Usain Bolt"];
 award_medals.apply(this, contenders);
 alert("Gold: " + gold);
 alert("Silver: " + silver);
 alert("The Field: " + the_field);
-;'>run</button><br class='clear' /></div>
-
-    <p>
-      <span id="arguments" class="bookmark"></span>
-      <b class="header">Arguments are Arrays</b>
-      If you reference the <b>arguments object</b> directly, it will be converted
-      into a real Array, making all of the
-      <a href="https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Objects/Array">Array methods</a>
-      available.
-    </p>
-    <div class='code'><pre class="idle"><span class="FunctionName">backwards</span><span class="Keyword">:</span> <span class="Storage">-&gt;</span>
-  alert arguments.reverse()
-
-backwards <span class="String"><span class="String">&quot;</span>stairway<span class="String">&quot;</span></span>, <span class="String"><span class="String">&quot;</span>to<span class="String">&quot;</span></span>, <span class="String"><span class="String">&quot;</span>heaven<span class="String">&quot;</span></span>
-</pre><pre class="idle"><span class="Storage">var</span> backwards;
-backwards <span class="Keyword">=</span> <span class="Storage">function</span> <span class="FunctionName">backwards</span>() {
-  arguments <span class="Keyword">=</span> <span class="LibraryClassType">Array</span>.<span class="LibraryConstant">prototype</span>.slice.<span class="LibraryFunction">call</span>(arguments, <span class="Number">0</span>);
-  <span class="Keyword">return</span> <span class="LibraryFunction">alert</span>(arguments.<span class="LibraryFunction">reverse</span>());
-};
-backwards(<span class="String"><span class="String">&quot;</span>stairway<span class="String">&quot;</span></span>, <span class="String"><span class="String">&quot;</span>to<span class="String">&quot;</span></span>, <span class="String"><span class="String">&quot;</span>heaven<span class="String">&quot;</span></span>);
-</pre><button onclick='javascript: var backwards;
-backwards = function backwards() {
-  arguments = Array.prototype.slice.call(arguments, 0);
-  return alert(arguments.reverse());
-};
-backwards("stairway", "to", "heaven");
 ;'>run</button><br class='clear' /></div>
 
     <p>
@@ -850,20 +838,20 @@ lunch<span class="Keyword">:</span> eat food <span class="Keyword">for</span> fo
 </pre><pre class="idle"><span class="Storage">var</span> _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, food, lunch, roid, roid2;
 <span class="Comment"><span class="Comment">//</span> Eat lunch.</span>
 lunch <span class="Keyword">=</span> (<span class="Storage">function</span>() {
-  _a <span class="Keyword">=</span> []; _b <span class="Keyword">=</span> [<span class="String"><span class="String">'</span>toast<span class="String">'</span></span>, <span class="String"><span class="String">'</span>cheese<span class="String">'</span></span>, <span class="String"><span class="String">'</span>wine<span class="String">'</span></span>];
-  <span class="Keyword">for</span> (_c <span class="Keyword">=</span> <span class="Number">0</span>, _d <span class="Keyword">=</span> _b.<span class="LibraryConstant">length</span>; _c <span class="Keyword">&lt;</span> _d; _c<span class="Keyword">++</span>) {
-    food <span class="Keyword">=</span> _b[_c];
+  _a <span class="Keyword">=</span> []; _c <span class="Keyword">=</span> [<span class="String"><span class="String">'</span>toast<span class="String">'</span></span>, <span class="String"><span class="String">'</span>cheese<span class="String">'</span></span>, <span class="String"><span class="String">'</span>wine<span class="String">'</span></span>];
+  <span class="Keyword">for</span> (_b <span class="Keyword">=</span> <span class="Number">0</span>, _d <span class="Keyword">=</span> _c.<span class="LibraryConstant">length</span>; _b <span class="Keyword">&lt;</span> _d; _b<span class="Keyword">++</span>) {
+    food <span class="Keyword">=</span> _c[_b];
     _a.<span class="LibraryFunction">push</span>(eat(food));
   }
   <span class="Keyword">return</span> _a;
 }).<span class="LibraryFunction">call</span>(<span class="Variable">this</span>);
 <span class="Comment"><span class="Comment">//</span> Naive collision detection.</span>
-_e <span class="Keyword">=</span> asteroids;
-<span class="Keyword">for</span> (_f <span class="Keyword">=</span> <span class="Number">0</span>, _g <span class="Keyword">=</span> _e.<span class="LibraryConstant">length</span>; _f <span class="Keyword">&lt;</span> _g; _f<span class="Keyword">++</span>) {
-  roid <span class="Keyword">=</span> _e[_f];
-  _h <span class="Keyword">=</span> asteroids;
-  <span class="Keyword">for</span> (_i <span class="Keyword">=</span> <span class="Number">0</span>, _j <span class="Keyword">=</span> _h.<span class="LibraryConstant">length</span>; _i <span class="Keyword">&lt;</span> _j; _i<span class="Keyword">++</span>) {
-    roid2 <span class="Keyword">=</span> _h[_i];
+_f <span class="Keyword">=</span> asteroids;
+<span class="Keyword">for</span> (_e <span class="Keyword">=</span> <span class="Number">0</span>, _g <span class="Keyword">=</span> _f.<span class="LibraryConstant">length</span>; _e <span class="Keyword">&lt;</span> _g; _e<span class="Keyword">++</span>) {
+  roid <span class="Keyword">=</span> _f[_e];
+  _i <span class="Keyword">=</span> asteroids;
+  <span class="Keyword">for</span> (_h <span class="Keyword">=</span> <span class="Number">0</span>, _j <span class="Keyword">=</span> _i.<span class="LibraryConstant">length</span>; _h <span class="Keyword">&lt;</span> _j; _h<span class="Keyword">++</span>) {
+    roid2 <span class="Keyword">=</span> _i[_h];
     <span class="Keyword">if</span> (roid <span class="Keyword">!</span><span class="Keyword">==</span> roid2) {
       <span class="Keyword">if</span> (roid.overlaps(roid2)) {
         roid.explode();
@@ -884,43 +872,43 @@ _e <span class="Keyword">=</span> asteroids;
   <span class="Keyword">for</span> i <span class="Keyword">in</span> [<span class="Number">0</span>...eggs.length] <span class="Keyword">by</span> <span class="Number">12</span>
     dozen_eggs<span class="Keyword">:</span> eggs[i...i<span class="Keyword">+</span><span class="Number">12</span>]
     deliver <span class="Keyword">new</span> <span class="TypeName">egg_carton</span>(dozen)
-</pre><pre class="idle"><span class="Storage">var</span> _a, _b, _c, _d, _e, countdown, egg_delivery, num;
+</pre><pre class="idle"><span class="Storage">var</span> _a, _b, _c, _d, countdown, egg_delivery, num;
 countdown <span class="Keyword">=</span> (<span class="Storage">function</span>() {
-  _a <span class="Keyword">=</span> []; _d <span class="Keyword">=</span> <span class="Number">10</span>; _e <span class="Keyword">=</span> <span class="Number">1</span>;
-  <span class="Keyword">for</span> (_c <span class="Keyword">=</span> <span class="Number">0</span>, num <span class="Keyword">=</span> _d; (_d <span class="Keyword">&lt;=</span> _e ? num <span class="Keyword">&lt;=</span> _e : num <span class="Keyword">&gt;=</span> _e); (_d <span class="Keyword">&lt;=</span> _e ? num <span class="Keyword">+</span><span class="Keyword">=</span> <span class="Number">1</span> : num <span class="Keyword">-</span><span class="Keyword">=</span> <span class="Number">1</span>), _c<span class="Keyword">++</span>) {
+  _a <span class="Keyword">=</span> []; _c <span class="Keyword">=</span> <span class="Number">10</span>; _d <span class="Keyword">=</span> <span class="Number">1</span>;
+  <span class="Keyword">for</span> (_b <span class="Keyword">=</span> <span class="Number">0</span>, num <span class="Keyword">=</span> _c; (_c <span class="Keyword">&lt;=</span> _d ? num <span class="Keyword">&lt;=</span> _d : num <span class="Keyword">&gt;=</span> _d); (_c <span class="Keyword">&lt;=</span> _d ? num <span class="Keyword">+</span><span class="Keyword">=</span> <span class="Number">1</span> : num <span class="Keyword">-</span><span class="Keyword">=</span> <span class="Number">1</span>), _b<span class="Keyword">++</span>) {
     _a.<span class="LibraryFunction">push</span>(num);
   }
   <span class="Keyword">return</span> _a;
 }).<span class="LibraryFunction">call</span>(<span class="Variable">this</span>);
 egg_delivery <span class="Keyword">=</span> <span class="Storage">function</span> <span class="FunctionName">egg_delivery</span>() {
-  <span class="Storage">var</span> _f, _g, _h, _i, _j, dozen_eggs, i;
-  _f <span class="Keyword">=</span> []; _i <span class="Keyword">=</span> <span class="Number">0</span>; _j <span class="Keyword">=</span> eggs.<span class="LibraryConstant">length</span>;
-  <span class="Keyword">for</span> (_h <span class="Keyword">=</span> <span class="Number">0</span>, i <span class="Keyword">=</span> _i; (_i <span class="Keyword">&lt;=</span> _j ? i <span class="Keyword">&lt;</span> _j : i <span class="Keyword">&gt;</span> _j); (_i <span class="Keyword">&lt;=</span> _j ? i <span class="Keyword">+</span><span class="Keyword">=</span> <span class="Number">12</span> : i <span class="Keyword">-</span><span class="Keyword">=</span> <span class="Number">12</span>), _h<span class="Keyword">++</span>) {
-    _f.<span class="LibraryFunction">push</span>((<span class="Storage">function</span>() {
+  <span class="Storage">var</span> _e, _f, _g, _h, dozen_eggs, i;
+  _e <span class="Keyword">=</span> []; _g <span class="Keyword">=</span> <span class="Number">0</span>; _h <span class="Keyword">=</span> eggs.<span class="LibraryConstant">length</span>;
+  <span class="Keyword">for</span> (_f <span class="Keyword">=</span> <span class="Number">0</span>, i <span class="Keyword">=</span> _g; (_g <span class="Keyword">&lt;=</span> _h ? i <span class="Keyword">&lt;</span> _h : i <span class="Keyword">&gt;</span> _h); (_g <span class="Keyword">&lt;=</span> _h ? i <span class="Keyword">+</span><span class="Keyword">=</span> <span class="Number">12</span> : i <span class="Keyword">-</span><span class="Keyword">=</span> <span class="Number">12</span>), _f<span class="Keyword">++</span>) {
+    _e.<span class="LibraryFunction">push</span>((<span class="Storage">function</span>() {
       dozen_eggs <span class="Keyword">=</span> eggs.<span class="LibraryFunction">slice</span>(i, i <span class="Keyword">+</span> <span class="Number">12</span>);
       <span class="Keyword">return</span> deliver(<span class="Keyword">new</span> <span class="TypeName">egg_carton</span>(dozen));
     }).<span class="LibraryFunction">call</span>(<span class="Variable">this</span>));
   }
-  <span class="Keyword">return</span> _f;
+  <span class="Keyword">return</span> _e;
 };
-</pre><button onclick='javascript: var _a, _b, _c, _d, _e, countdown, egg_delivery, num;
+</pre><button onclick='javascript: var _a, _b, _c, _d, countdown, egg_delivery, num;
 countdown = (function() {
-  _a = []; _d = 10; _e = 1;
-  for (_c = 0, num = _d; (_d <= _e ? num <= _e : num >= _e); (_d <= _e ? num += 1 : num -= 1), _c++) {
+  _a = []; _c = 10; _d = 1;
+  for (_b = 0, num = _c; (_c <= _d ? num <= _d : num >= _d); (_c <= _d ? num += 1 : num -= 1), _b++) {
     _a.push(num);
   }
   return _a;
 }).call(this);
 egg_delivery = function egg_delivery() {
-  var _f, _g, _h, _i, _j, dozen_eggs, i;
-  _f = []; _i = 0; _j = eggs.length;
-  for (_h = 0, i = _i; (_i <= _j ? i < _j : i > _j); (_i <= _j ? i += 12 : i -= 12), _h++) {
-    _f.push((function() {
+  var _e, _f, _g, _h, dozen_eggs, i;
+  _e = []; _g = 0; _h = eggs.length;
+  for (_f = 0, i = _g; (_g <= _h ? i < _h : i > _h); (_g <= _h ? i += 12 : i -= 12), _f++) {
+    _e.push((function() {
       dozen_eggs = eggs.slice(i, i + 12);
       return deliver(new egg_carton(dozen));
     }).call(this));
   }
-  return _f;
+  return _e;
 };
 ;alert(countdown);'>run: countdown</button><br class='clear' /></div>
     <p>
@@ -995,7 +983,7 @@ numbers_copy = numbers.slice(0, numbers.length);
     </p>
     <div class='code'><pre class="idle">numbers<span class="Keyword">:</span> [<span class="Number">0</span>, <span class="Number">1</span>, <span class="Number">2</span>, <span class="Number">3</span>, <span class="Number">4</span>, <span class="Number">5</span>, <span class="Number">6</span>, <span class="Number">7</span>, <span class="Number">8</span>, <span class="Number">9</span>]
 
-numbers<span class="Keyword">[</span><span class="Number">3</span>..<span class="Number">6</span><span class="Keyword">]:</span> [<span class="Keyword">-</span><span class="Number">3</span>, <span class="Keyword">-</span><span class="Number">4</span>, <span class="Keyword">-</span><span class="Number">5</span>, <span class="Keyword">-</span><span class="Number">6</span>]
+numbers[<span class="Number">3</span>..<span class="Number">6</span>]<span class="Keyword">:</span> [<span class="Keyword">-</span><span class="Number">3</span>, <span class="Keyword">-</span><span class="Number">4</span>, <span class="Keyword">-</span><span class="Number">5</span>, <span class="Keyword">-</span><span class="Number">6</span>]
 
 
 </pre><pre class="idle"><span class="Storage">var</span> numbers;
@@ -1030,7 +1018,11 @@ grade <span class="Keyword">=</span> <span class="Storage">function</span> <span
   <span class="Keyword">if</span> (student.excellent_work) {
     <span class="Keyword">return</span> <span class="String"><span class="String">&quot;</span>A+<span class="String">&quot;</span></span>;
   } <span class="Keyword">else</span> <span class="Keyword">if</span> (student.okay_stuff) {
-    <span class="Keyword">return</span> student.tried_hard ? <span class="String"><span class="String">&quot;</span>B<span class="String">&quot;</span></span> : <span class="String"><span class="String">&quot;</span>B-<span class="String">&quot;</span></span>;
+    <span class="Keyword">if</span> (student.tried_hard) {
+      <span class="Keyword">return</span> <span class="String"><span class="String">&quot;</span>B<span class="String">&quot;</span></span>;
+    } <span class="Keyword">else</span> {
+      <span class="Keyword">return</span> <span class="String"><span class="String">&quot;</span>B-<span class="String">&quot;</span></span>;
+    }
   } <span class="Keyword">else</span> {
     <span class="Keyword">return</span> <span class="String"><span class="String">&quot;</span>C<span class="String">&quot;</span></span>;
   }
@@ -1041,7 +1033,11 @@ grade = function grade(student) {
   if (student.excellent_work) {
     return "A+";
   } else if (student.okay_stuff) {
-    return student.tried_hard ? "B" : "B-";
+    if (student.tried_hard) {
+      return "B";
+    } else {
+      return "B-";
+    }
   } else {
     return "C";
   }
@@ -1059,9 +1055,9 @@ eldest = 24 > 21 ? "Liz" : "Ike";
     </p>
     <div class='code'><pre class="idle">six<span class="Keyword">:</span> (one<span class="Keyword">:</span> <span class="Number">1</span>) <span class="Keyword">+</span> (two<span class="Keyword">:</span> <span class="Number">2</span>) <span class="Keyword">+</span> (three<span class="Keyword">:</span> <span class="Number">3</span>)
 </pre><pre class="idle"><span class="Storage">var</span> one, six, three, two;
-six <span class="Keyword">=</span> ((one <span class="Keyword">=</span> <span class="Number">1</span>)) <span class="Keyword">+</span> ((two <span class="Keyword">=</span> <span class="Number">2</span>)) <span class="Keyword">+</span> ((three <span class="Keyword">=</span> <span class="Number">3</span>));
+six <span class="Keyword">=</span> (one <span class="Keyword">=</span> <span class="Number">1</span>) <span class="Keyword">+</span> (two <span class="Keyword">=</span> <span class="Number">2</span>) <span class="Keyword">+</span> (three <span class="Keyword">=</span> <span class="Number">3</span>);
 </pre><button onclick='javascript: var one, six, three, two;
-six = ((one = 1)) + ((two = 2)) + ((three = 3));
+six = (one = 1) + (two = 2) + (three = 3);
 ;alert(six);'>run: six</button><br class='clear' /></div>
     <p>
       Things that would otherwise be statements in JavaScript, when used
@@ -1298,7 +1294,7 @@ tom.move();
     <p>
       If structuring your prototypes classically isn't your cup of tea, CoffeeScript
       provides a couple of lower-level conveniences. The <tt>extends</tt> operator
-      helps with proper prototype setup, as seen above, <tt>::</tt> gives you
+      helps with proper prototype setup, <tt>::</tt> gives you
       quick access to an object's prototype, and <tt>super()</tt>
       is converted into a call against the immediate ancestor's method of the same name.
     </p>
@@ -1311,6 +1307,10 @@ tom.move();
   return this.replace(/_/g, "-");
 };
 ;alert("one_two".dasherize());'>run: "one_two".dasherize()</button><br class='clear' /></div>
+    <p>
+      Finally, you may assign Class-level (static) properties within a class
+      definition by using<br /><tt>@property: value</tt>
+    </p>
 
     <p>
       <span id="pattern_matching" class="bookmark"></span>
@@ -1416,6 +1416,31 @@ _c = _b.address;
 street = _c[0];
 city = _c[1];
 ;alert(poet + " — " + street);'>run: poet + " — " + street</button><br class='clear' /></div>
+    <p>
+      Pattern matching can even be combined with splats.
+    </p>
+    <div class='code'><pre class="idle">tag<span class="Keyword">:</span> <span class="String"><span class="String">&quot;</span>&lt;impossible&gt;<span class="String">&quot;</span></span>
+
+<span class="Keyword">[</span>open, contents..., close<span class="Keyword">]:</span> tag.split(<span class="String"><span class="String">&quot;</span><span class="String">&quot;</span></span>)
+
+
+
+
+</pre><pre class="idle"><span class="Storage">var</span> _a, close, contents, open, tag;
+<span class="Storage">var</span> __slice <span class="Keyword">=</span> <span class="LibraryClassType">Array</span>.<span class="LibraryConstant">prototype</span>.slice;
+tag <span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>&lt;impossible&gt;<span class="String">&quot;</span></span>;
+_a <span class="Keyword">=</span> tag.<span class="LibraryFunction">split</span>(<span class="String"><span class="String">&quot;</span><span class="String">&quot;</span></span>);
+open <span class="Keyword">=</span> _a[<span class="Number">0</span>];
+contents <span class="Keyword">=</span> __slice.<span class="LibraryFunction">call</span>(_a, <span class="Number">1</span>, _a.<span class="LibraryConstant">length</span> <span class="Keyword">-</span> <span class="Number">1</span>);
+close <span class="Keyword">=</span> _a[_a.<span class="LibraryConstant">length</span> <span class="Keyword">-</span> <span class="Number">1</span>];
+</pre><button onclick='javascript: var _a, close, contents, open, tag;
+var __slice = Array.prototype.slice;
+tag = "<impossible>";
+_a = tag.split("");
+open = _a[0];
+contents = __slice.call(_a, 1, _a.length - 1);
+close = _a[_a.length - 1];
+;alert(contents.join(""));'>run: contents.join("")</button><br class='clear' /></div>
 
     <p>
       <span id="fat_arrow" class="bookmark"></span>
@@ -1428,7 +1453,7 @@ city = _c[1];
       gives a good overview of the quirks.
     </p>
     <p>
-      The fat arrow <tt>=></tt> can be used to both define a function, and to bind
+      The fat arrow <tt>=&gt;</tt> can be used to both define a function, and to bind
       it to the current value of <tt>this</tt>, right on the spot. This is helpful
       when using callback-based libraries like Prototype or jQuery, for creating
       iterator functions to pass to <tt>each</tt>, or event-handler functions
@@ -1442,17 +1467,17 @@ city = _c[1];
   $(<span class="String"><span class="String">'</span>.shopping_cart<span class="String">'</span></span>).bind <span class="String"><span class="String">'</span>click<span class="String">'</span></span>, <span class="FunctionArgument">(</span><span class="FunctionArgument">event</span><span class="FunctionArgument">)</span> <span class="Storage">=&gt;</span>
     <span class="Variable">@customer</span>.purchase <span class="Variable">@cart</span>
 </pre><pre class="idle"><span class="Storage">var</span> Account;
+<span class="Storage">var</span> __slice <span class="Keyword">=</span> <span class="LibraryClassType">Array</span>.<span class="LibraryConstant">prototype</span>.slice, <span class="FunctionName">__bind</span> = <span class="Storage">function</span>(<span class="FunctionArgument">func, obj, args</span>) {
+  <span class="Keyword">return</span> <span class="Storage">function</span>() {
+    <span class="Keyword">return</span> func.<span class="LibraryFunction">apply</span>(obj <span class="Keyword">||</span> {}, args ? args.<span class="LibraryFunction">concat</span>(__slice.<span class="LibraryFunction">call</span>(arguments, <span class="Number">0</span>)) : arguments);
+  };
+};
 Account <span class="Keyword">=</span> <span class="Storage">function</span> <span class="FunctionName">Account</span>(<span class="FunctionArgument">customer, cart</span>) {
   <span class="Variable">this</span>.customer <span class="Keyword">=</span> customer;
   <span class="Variable">this</span>.cart <span class="Keyword">=</span> cart;
-  <span class="Keyword">return</span> <span class="Keyword">$</span>(<span class="String"><span class="String">'</span>.shopping_cart<span class="String">'</span></span>).bind(<span class="String"><span class="String">'</span>click<span class="String">'</span></span>, (<span class="Storage">function</span>(__this) {
-    <span class="Storage">var</span> <span class="FunctionName">__func</span> = <span class="Storage">function</span>(<span class="FunctionArgument">event</span>) {
+  <span class="Keyword">return</span> <span class="Keyword">$</span>(<span class="String"><span class="String">'</span>.shopping_cart<span class="String">'</span></span>).bind(<span class="String"><span class="String">'</span>click<span class="String">'</span></span>, __bind(<span class="Storage">function</span>(<span class="LibraryClassType">event</span>) {
       <span class="Keyword">return</span> <span class="Variable">this</span>.customer.purchase(<span class="Variable">this</span>.cart);
-    };
-    <span class="Keyword">return</span> (<span class="Storage">function</span>() {
-      <span class="Keyword">return</span> __func.<span class="LibraryFunction">apply</span>(__this, arguments);
-    });
-  })(<span class="Variable">this</span>));
+    }, <span class="Variable">this</span>));
 };
 </pre><br class='clear' /></div>
     <p>
@@ -1460,6 +1485,42 @@ Account <span class="Keyword">=</span> <span class="Storage">function</span> <sp
       have referred to the undefined "customer" property of the DOM element,
       and trying to call <tt>purchase()</tt> on it would have raised an exception.
     </p>
+    <p>
+      If you have more custom needs for function binding, CoffeeScript includes
+      the <tt>&lt;-</tt> bind operator, which works the same as ECMAScript 5
+      and Prototype.js's <tt>Function#bind</tt>. The first argument is the <tt>this</tt>
+      value, and the remainder are curried arguments. In the example below,
+      we curry a jQuery request for a URL, and then execute the bound function
+      with the missing callback argument.
+    </p>
+    <div class='code'><pre class="idle">url<span class="Keyword">:</span> <span class="String"><span class="String">&quot;</span>documentation/coffee/binding.coffee<span class="String">&quot;</span></span>
+
+get_source<span class="Keyword">:</span> jQuery.get <span class="Keyword">&lt;</span><span class="Keyword">-</span> jQuery, url
+
+get_source <span class="FunctionArgument">(</span><span class="FunctionArgument">response</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> alert response
+</pre><pre class="idle"><span class="Storage">var</span> get_source, url;
+<span class="Storage">var</span> __slice <span class="Keyword">=</span> <span class="LibraryClassType">Array</span>.<span class="LibraryConstant">prototype</span>.slice, <span class="FunctionName">__bind</span> = <span class="Storage">function</span>(<span class="FunctionArgument">func, obj, args</span>) {
+  <span class="Keyword">return</span> <span class="Storage">function</span>() {
+    <span class="Keyword">return</span> func.<span class="LibraryFunction">apply</span>(obj <span class="Keyword">||</span> {}, args ? args.<span class="LibraryFunction">concat</span>(__slice.<span class="LibraryFunction">call</span>(arguments, <span class="Number">0</span>)) : arguments);
+  };
+};
+url <span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>documentation/coffee/binding.coffee<span class="String">&quot;</span></span>;
+get_source <span class="Keyword">=</span> __bind(jQuery.get, jQuery, [url]);
+get_source(<span class="Storage">function</span>(response) {
+  <span class="Keyword">return</span> <span class="LibraryFunction">alert</span>(response);
+});
+</pre><button onclick='javascript: var get_source, url;
+var __slice = Array.prototype.slice, __bind = function(func, obj, args) {
+  return function() {
+    return func.apply(obj || {}, args ? args.concat(__slice.call(arguments, 0)) : arguments);
+  };
+};
+url = "documentation/coffee/binding.coffee";
+get_source = __bind(jQuery.get, jQuery, [url]);
+get_source(function(response) {
+  return alert(response);
+});
+;'>run</button><br class='clear' /></div>
 
     <p>
       <span id="embedded" class="bookmark"></span>
@@ -1571,6 +1632,42 @@ cholesterol = 127;
 healthy = (200 > cholesterol) && (cholesterol > 60);
 ;alert(healthy);'>run: healthy</button><br class='clear' /></div>
 
+    <p>
+      <span id="interpolation" class="bookmark"></span>
+      <b class="header">String and RegExp Interpolation</b>
+      A version of <a href="http://wiki.ecmascript.org/doku.php?id=strawman:string_interpolation">ECMAScript Harmony's proposed string interpolation</a>
+      is included in CoffeeScript. Simple variables can be included by marking
+      them with a dollar sign.
+    </p>
+    <div class='code'><pre class="idle">author<span class="Keyword">:</span> <span class="String"><span class="String">&quot;</span>Wittgenstein<span class="String">&quot;</span></span>
+quote<span class="Keyword">:</span>  <span class="String"><span class="String">&quot;</span>A picture is a fact. -- <span class="String"><span class="String">$</span>author</span><span class="String">&quot;</span></span>
+</pre><pre class="idle"><span class="Storage">var</span> author, quote;
+author <span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>Wittgenstein<span class="String">&quot;</span></span>;
+quote <span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>A picture is a fact. -- <span class="String">&quot;</span></span> <span class="Keyword">+</span> author;
+</pre><button onclick='javascript: var author, quote;
+author = "Wittgenstein";
+quote = "A picture is a fact. -- " + author;
+;alert(quote);'>run: quote</button><br class='clear' /></div>
+    <p>
+      And arbitrary expressions can be interpolated by using brackets <tt>${ ... }</tt><br />
+      Interpolation works the same way within regular expressions.
+    </p>
+    <div class='code'><pre class="idle">sentence<span class="Keyword">:</span> <span class="String"><span class="String">&quot;</span><span class="String"><span class="String">${</span> <span class="Number">22</span> <span class="Keyword">/</span> <span class="Number">7</span> <span class="String">}</span></span> is a decent approximation of π<span class="String">&quot;</span></span>
+
+sep<span class="Keyword">:</span>   <span class="String"><span class="String">&quot;</span>[.<span class="UserDefinedConstant">\\</span>/<span class="UserDefinedConstant">\\</span>- ]<span class="String">&quot;</span></span>
+dates<span class="Keyword">:</span><span class="String"> <span class="String">/</span><span class="UserDefinedConstant">\d</span>+<span class="String"><span class="String">$</span>sep</span><span class="UserDefinedConstant">\d</span>+<span class="String"><span class="String">$</span>sep</span><span class="UserDefinedConstant">\d</span>+<span class="String">/</span>g</span>
+
+
+</pre><pre class="idle"><span class="Storage">var</span> dates, sentence, sep;
+sentence <span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span><span class="String">&quot;</span></span> <span class="Keyword">+</span> (<span class="Number">22</span> / <span class="Number">7</span>) <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> is a decent approximation of π<span class="String">&quot;</span></span>;
+sep <span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>[.<span class="UserDefinedConstant">\\</span>/<span class="UserDefinedConstant">\\</span>- ]<span class="String">&quot;</span></span>;
+dates <span class="Keyword">=</span> (<span class="Keyword">new</span> <span class="TypeName">RegExp</span>(<span class="String"><span class="String">&quot;</span><span class="UserDefinedConstant">\\</span>d+<span class="String">&quot;</span></span> <span class="Keyword">+</span> sep <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span><span class="UserDefinedConstant">\\</span>d+<span class="String">&quot;</span></span> <span class="Keyword">+</span> sep <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span><span class="UserDefinedConstant">\\</span>d+<span class="String">&quot;</span></span>, <span class="String"><span class="String">&quot;</span>g<span class="String">&quot;</span></span>));
+</pre><button onclick='javascript: var dates, sentence, sep;
+sentence = "" + (22 / 7) + " is a decent approximation of π";
+sep = "[.\\/\\- ]";
+dates = (new RegExp("\\d+" + sep + "\\d+" + sep + "\\d+", "g"));
+;alert(sentence);'>run: sentence</button><br class='clear' /></div>
+
     <p>
       <span id="strings" class="bookmark"></span>
       <b class="header">Multiline Strings and Heredocs</b>
@@ -1611,37 +1708,11 @@ world...";
 <span class="String">      &lt;/strong&gt;</span>
 <span class="String">      <span class="String">'''</span></span>
 </pre><pre class="idle"><span class="Storage">var</span> html;
-html <span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>&lt;strong&gt;<span class="UserDefinedConstant">\n</span>  cup of coffeescript<span class="UserDefinedConstant">\n</span>&lt;/strong&gt;<span class="String">&quot;</span></span>;
+html <span class="Keyword">=</span> <span class="String"><span class="String">'</span>&lt;strong&gt;<span class="UserDefinedConstant">\n</span>  cup of coffeescript<span class="UserDefinedConstant">\n</span>&lt;/strong&gt;<span class="String">'</span></span>;
 </pre><br class='clear' /></div>
-
     <p>
-      <span id="interpolation" class="bookmark"></span>
-      <b class="header">String Interpolation</b>
-      A version of <a href="http://wiki.ecmascript.org/doku.php?id=strawman:string_interpolation">ECMAScript Harmony's proposed string interpolation</a>
-      is included in CoffeeScript. Simple variables can be included by marking
-      them with a dollar sign.
+      Double-quoted heredocs, like double-quoted strings, allow interpolation.
     </p>
-    <div class='code'><pre class="idle">author<span class="Keyword">:</span> <span class="String"><span class="String">&quot;</span>Wittgenstein<span class="String">&quot;</span></span>
-quote<span class="Keyword">:</span>  <span class="String"><span class="String">&quot;</span>A picture is a fact. -- <span class="String"><span class="String">$</span>author</span><span class="String">&quot;</span></span>
-</pre><pre class="idle"><span class="Storage">var</span> author, quote;
-author <span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>Wittgenstein<span class="String">&quot;</span></span>;
-quote <span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>A picture is a fact. -- <span class="String">&quot;</span></span> <span class="Keyword">+</span> author;
-</pre><button onclick='javascript: var author, quote;
-author = "Wittgenstein";
-quote = "A picture is a fact. -- " + author;
-;alert(quote);'>run: quote</button><br class='clear' /></div>
-    <p>
-      And arbitrary expressions can be interpolated by using brackets <tt>${ ... }</tt>
-    </p>
-    <div class='code'><pre class="idle">sentence<span class="Keyword">:</span> <span class="String"><span class="String">&quot;</span><span class="String"><span class="String">${</span> <span class="Number">22</span> <span class="Keyword">/</span> <span class="Number">7</span> <span class="String">}</span></span> is a decent approximation of π<span class="String">&quot;</span></span>
-
-
-
-</pre><pre class="idle"><span class="Storage">var</span> sentence;
-sentence <span class="Keyword">=</span> (<span class="Number">22</span> / <span class="Number">7</span>) <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> is a decent approximation of π<span class="String">&quot;</span></span>;
-</pre><button onclick='javascript: var sentence;
-sentence = (22 / 7) + " is a decent approximation of π";
-;alert(sentence);'>run: sentence</button><br class='clear' /></div>
 
     <h2>
       <span id="cake" class="bookmark"></span>
@@ -1662,17 +1733,14 @@ sentence = (22 / 7) + " is a decent approximation of π";
       function to invoke when the task is run. Here's a hypothetical task
       that uses the Node.js API.
     </p>
-    <div class='code'><pre class="idle">process.mixin require <span class="String"><span class="String">'</span>assert<span class="String">'</span></span>
-
-task <span class="String"><span class="String">'</span>test<span class="String">'</span></span>, <span class="String"><span class="String">'</span>run each of the unit tests<span class="String">'</span></span>, <span class="Storage">-&gt;</span>
+    <div class='code'><pre class="idle">task <span class="String"><span class="String">'</span>test<span class="String">'</span></span>, <span class="String"><span class="String">'</span>run each of the unit tests<span class="String">'</span></span>, <span class="Storage">-&gt;</span>
   <span class="Keyword">for</span> test <span class="Keyword">in</span> test_files
     fs.readFile test, <span class="FunctionArgument">(</span><span class="FunctionArgument">err, code</span><span class="FunctionArgument">)</span> <span class="Storage">-&gt;</span> eval coffee.compile code
-</pre><pre class="idle">process.mixin(require(<span class="String"><span class="String">'</span>assert<span class="String">'</span></span>));
-task(<span class="String"><span class="String">'</span>test<span class="String">'</span></span>, <span class="String"><span class="String">'</span>run each of the unit tests<span class="String">'</span></span>, <span class="Storage">function</span>() {
+</pre><pre class="idle">task(<span class="String"><span class="String">'</span>test<span class="String">'</span></span>, <span class="String"><span class="String">'</span>run each of the unit tests<span class="String">'</span></span>, <span class="Storage">function</span>() {
   <span class="Storage">var</span> _a, _b, _c, _d, test;
-  _a <span class="Keyword">=</span> []; _b <span class="Keyword">=</span> test_files;
-  <span class="Keyword">for</span> (_c <span class="Keyword">=</span> <span class="Number">0</span>, _d <span class="Keyword">=</span> _b.<span class="LibraryConstant">length</span>; _c <span class="Keyword">&lt;</span> _d; _c<span class="Keyword">++</span>) {
-    test <span class="Keyword">=</span> _b[_c];
+  _a <span class="Keyword">=</span> []; _c <span class="Keyword">=</span> test_files;
+  <span class="Keyword">for</span> (_b <span class="Keyword">=</span> <span class="Number">0</span>, _d <span class="Keyword">=</span> _c.<span class="LibraryConstant">length</span>; _b <span class="Keyword">&lt;</span> _d; _b<span class="Keyword">++</span>) {
+    test <span class="Keyword">=</span> _c[_b];
     _a.<span class="LibraryFunction">push</span>(fs.readFile(test, <span class="Storage">function</span>(err, code) {
       <span class="Keyword">return</span> <span class="LibraryFunction">eval</span>(coffee.<span class="LibraryFunction">compile</span>(code));
     }));
@@ -1722,7 +1790,7 @@ task(<span class="String"><span class="String">'</span>test<span class="String">
         <tt>bin/cake build</tt> to rebuild the CoffeeScript compiler, and <br />
         <tt>bin/cake build:parser</tt> to regenerate the Jison parser if you're
         working on the grammar. <br /><br />
-        <tt>bin/cake build:full</tt> is a good command to run when you're working
+        <tt>git checkout lib &amp;&amp; bin/cake build:full</tt> is a good command to run when you're working
         on the core language. It'll refresh the lib directory
         (in case you broke something), build your altered compiler, use that to
         rebuild itself (a good sanity test) and then run all of the tests. If
@@ -1740,20 +1808,51 @@ task(<span class="String"><span class="String">'</span>test<span class="String">
       <li>
         <b>defunkt</b>'s <a href="http://github.com/defunkt/coffee-mode">CoffeeScript Major Mode</a>
         &mdash; a Emacs major mode that provides syntax highlighting, indentation
-        support, and some bonus commands. (For Vim and TextMate highlighters,
-        see the <tt>extras</tt> directory of the main repository.)
+        support, and some bonus commands.
+      </li>
+      <li>
+        <b>jashkenas</b>'s <a href="http://github.com/jashkenas/coffee-script-tmbundle">CoffeeScript TextMate Bundle</a>
+        &mdash; which provides syntax highlighting, snippet expansion, and the
+        ability to run bits of CoffeeScript from within TextMate itself.
+      </li>
+      <li>
+        <b>kchmck</b>'s <a href="http://github.com/kchmck/vim-coffee-script">Vim CoffeeScript</a>
+        &mdash; which adds Vim syntax highlighting and indentation support.
       </li>
       <li>
         <b>mattly</b>'s <a href="http://github.com/mattly/rack-coffee">rack-coffee</a>
         &mdash; a small Rack middleware for serving CoffeeScript files as
         compiled JavaScript on the fly.
       </li>
+      <li>
+        <b>jnicklas</b>'s <a href="http://github.com/jnicklas/bistro_car">BistroCar</a>
+        &mdash; a plugin that serves and bundles CoffeeScript from within your
+        Rails application.
+      </li>
     </ul>
 
     <h2>
       <span id="change_log" class="bookmark"></span>
       Change Log
     </h2>
+    
+    <p>
+      <b class="header" style="margin-top: 20px;">0.6.0</b>
+      Trailing commas are now allowed, a-la Python. Static 
+      properties may be assigned directly within class definitions, 
+      using <tt>@property</tt> notation.
+    </p>
+
+    <p>
+      <b class="header" style="margin-top: 20px;">0.5.6</b>
+      Interpolation can now be used within regular expressions and heredocs, as well as
+      strings. Added the <tt>&lt;-</tt> bind operator.
+      Allowing assignment to half-expressions instead of special <tt>||=</tt>-style
+      operators. The arguments object is no longer automatically converted into
+      an array. After requiring <tt>coffee-script</tt>, Node.js can now directly
+      load <tt>.coffee</tt> files, thanks to <b>registerExtension</b>. Multiple
+      splats can now be used in function calls, arrays, and pattern matching.
+    </p>
 
     <p>
       <b class="header" style="margin-top: 20px;">0.5.5</b>

lib/cake.js

@@ -1,5 +1,5 @@
 (function(){
-  var CoffeeScript, fs, no_such_task, oparse, options, optparse, path, print_tasks, switches, tasks;
+  var CoffeeScript, fs, helpers, no_such_task, oparse, options, optparse, path, print_tasks, switches, tasks;
   var __hasProp = Object.prototype.hasOwnProperty;
   // `cake` is a simplified version of [Make](http://www.gnu.org/software/make/)
   // ([Rake](http://rake.rubyforge.org/), [Jake](http://github.com/280north/jake))
@@ -10,23 +10,25 @@
   // External dependencies.
   fs = require('fs');
   path = require('path');
-  optparse = require('optparse');
-  CoffeeScript = require('coffee-script');
+  helpers = require('./helpers').helpers;
+  optparse = require('./optparse');
+  CoffeeScript = require('./coffee-script');
   // Keep track of the list of defined tasks, the accepted options, and so on.
   tasks = {};
   options = {};
   switches = [];
   oparse = null;
   // Mixin the top-level Cake functions for Cakefiles to use directly.
-  process.mixin({
+  helpers.extend(global, {
     // Define a Cake task with a short name, a sentence description,
     // and the function to run as the action itself.
     task: function task(name, description, action) {
-      return tasks[name] = {
+      tasks[name] = {
         name: name,
         description: description,
         action: action
       };
+      return tasks[name];
     },
     // Define an option that the Cakefile accepts. The parsed options hash,
     // containing all of the command-line options passed, will be made available
@@ -60,9 +62,9 @@
         return print_tasks();
       }
       options = oparse.parse(args);
-      _a = []; _b = options.arguments;
-      for (_c = 0, _d = _b.length; _c < _d; _c++) {
-        arg = _b[_c];
+      _a = []; _c = options.arguments;
+      for (_b = 0, _d = _c.length; _b < _d; _b++) {
+        arg = _c[_b];
         _a.push(invoke(arg));
       }
       return _a;
@@ -70,15 +72,15 @@
   };
   // Display the list of Cake tasks in a format similar to `rake -T`
   print_tasks = function print_tasks() {
-    var _a, _b, _c, _d, _e, _f, i, name, spaces, task;
+    var _a, _b, _c, _d, _e, i, name, spaces, task;
     puts('');
     _a = tasks;
     for (name in _a) { if (__hasProp.call(_a, name)) {
       task = _a[name];
       spaces = 20 - name.length;
       spaces = spaces > 0 ? (function() {
-        _b = []; _e = 0; _f = spaces;
-        for (_d = 0, i = _e; (_e <= _f ? i <= _f : i >= _f); (_e <= _f ? i += 1 : i -= 1), _d++) {
+        _b = []; _d = 0; _e = spaces;
+        for (_c = 0, i = _d; (_d <= _e ? i <= _e : i >= _e); (_d <= _e ? i += 1 : i -= 1), _c++) {
           _b.push(' ');
         }
         return _b;

lib/coffee-script.js

@@ -1,5 +1,5 @@
 (function(){
-  var lexer, parser, path, process_scripts;
+  var Lexer, compile, helpers, lexer, parser, path, process_scripts;
   // CoffeeScript can be used both on the server, as a command-line compiler based
   // on Node.js/V8, or to run CoffeeScripts directly in the browser. This module
   // contains the main entry functions for tokenzing, parsing, and compiling source
@@ -8,20 +8,28 @@
   // execute all scripts present in `text/coffeescript` tags.
   // Set up dependencies correctly for both the server and the browser.
   if ((typeof process !== "undefined" && process !== null)) {
-    process.mixin(require('nodes'));
     path = require('path');
-    lexer = new (require('lexer').Lexer)();
-    parser = require('parser').parser;
+    Lexer = require('./lexer').Lexer;
+    parser = require('./parser').parser;
+    helpers = require('./helpers').helpers;
+    helpers.extend(global, require('./nodes'));
+    require.registerExtension ? require.registerExtension('.coffee', function(content) {
+      return compile(content);
+    }) : null;
   } else {
-    lexer = new Lexer();
-    parser = exports.parser;
     this.exports = (this.CoffeeScript = {});
+    Lexer = this.Lexer;
+    parser = this.parser;
+    helpers = this.helpers;
   }
   // The current CoffeeScript version number.
-  exports.VERSION = '0.5.5';
+  exports.VERSION = '0.6.0';
+  // Instantiate a Lexer for our use here.
+  lexer = new Lexer();
   // Compile a string of CoffeeScript code to JavaScript, using the Coffee/Jison
   // compiler.
-  exports.compile = function compile(code, options) {
+  exports.compile = (compile = function compile(code, options) {
+    options = options || {};
     try {
       return (parser.parse(lexer.tokenize(code))).compile(options);
     } catch (err) {
@@ -30,7 +38,7 @@
       }
       throw err;
     }
-  };
+  });
   // Tokenize a string of CoffeeScript code, and return the array of tokens.
   exports.tokens = function tokens(code) {
     return lexer.tokenize(code);
@@ -43,11 +51,18 @@
   };
   // Compile and execute a string of CoffeeScript (on the server), correctly
   // setting `__filename`, `__dirname`, and relative `require()`.
-  exports.run = function run(code, options) {
+  exports.run = (function(code, options) {
     var __dirname, __filename;
     module.filename = (__filename = options.source);
     __dirname = path.dirname(__filename);
     return eval(exports.compile(code, options));
+  });
+  // Extend CoffeeScript with a custom language extension. It should hook in to
+  // the **Lexer** (as a peer of any of the lexer's tokenizing methods), and
+  // push a token on to the stack that contains a **Node** as the value (as a
+  // peer of the nodes in [nodes.coffee](nodes.html)).
+  exports.extend = function extend(func) {
+    return Lexer.extensions.push(func);
   };
   // The real Lexer produces a generic stream of tokens. This object provides a
   // thin wrapper around it, compatible with the Jison API. We can then pass it
@@ -63,7 +78,8 @@
     },
     setInput: function setInput(tokens) {
       this.tokens = tokens;
-      return this.pos = 0;
+      this.pos = 0;
+      return this.pos;
     },
     upcomingInput: function upcomingInput() {
       return "";
@@ -79,12 +95,10 @@
   if ((typeof document !== "undefined" && document !== null) && document.getElementsByTagName) {
     process_scripts = function process_scripts() {
       var _a, _b, _c, _d, tag;
-      _a = []; _b = document.getElementsByTagName('script');
-      for (_c = 0, _d = _b.length; _c < _d; _c++) {
-        tag = _b[_c];
-        if (tag.type === 'text/coffeescript') {
-          _a.push(eval(exports.compile(tag.innerHTML)));
-        }
+      _a = []; _c = document.getElementsByTagName('script');
+      for (_b = 0, _d = _c.length; _b < _d; _b++) {
+        tag = _c[_b];
+        tag.type === 'text/coffeescript' ? _a.push(eval(exports.compile(tag.innerHTML))) : null;
       }
       return _a;
     };

lib/command.js

@@ -8,10 +8,10 @@
   // External dependencies.
   fs = require('fs');
   path = require('path');
-  optparse = require('optparse');
-  CoffeeScript = require('coffee-script');
+  optparse = require('./optparse');
+  CoffeeScript = require('./coffee-script');
   // The help banner that is printed when `coffee` is called without arguments.
-  BANNER = "coffee compiles CoffeeScript source files into JavaScript.\n\nUsage:\n  coffee path/to/script.coffee";
+  BANNER = 'coffee compiles CoffeeScript source files into JavaScript.\n\nUsage:\n  coffee path/to/script.coffee';
   // The list of all the valid option flags that `coffee` knows how to handle.
   SWITCHES = [['-c', '--compile', 'compile to JavaScript and save as .js files'], ['-i', '--interactive', 'run an interactive CoffeeScript REPL'], ['-o', '--output [DIR]', 'set the directory for compiled JavaScript'], ['-w', '--watch', 'watch scripts for changes, and recompile'], ['-p', '--print', 'print the compiled JavaScript to stdout'], ['-l', '--lint', 'pipe the compiled JavaScript through JSLint'], ['-s', '--stdio', 'listen for and compile scripts over stdio'], ['-e', '--eval', 'compile a string from the command line'], ['--no-wrap', 'compile without the top-level function wrapper'], ['-t', '--tokens', 'print the tokens that the lexer produces'], ['-n', '--nodes', 'print the parse tree that Jison produces'], ['-v', '--version', 'display CoffeeScript version'], ['-h', '--help', 'display this help message']];
   // Top-level objects shared by all the functions.
@@ -31,7 +31,7 @@
       return version();
     }
     if (options.interactive) {
-      return require('repl');
+      return require('./repl');
     }
     if (options.stdio) {
       return compile_stdio();
@@ -68,9 +68,9 @@
         });
       });
     };
-    _a = []; _b = sources;
-    for (_c = 0, _d = _b.length; _c < _d; _c++) {
-      source = _b[_c];
+    _a = []; _c = sources;
+    for (_b = 0, _d = _c.length; _b < _d; _b++) {
+      source = _c[_b];
       _a.push(compile(source));
     }
     return _a;
@@ -141,9 +141,9 @@
         });
       });
     };
-    _a = []; _b = sources;
-    for (_c = 0, _d = _b.length; _c < _d; _c++) {
-      source = _b[_c];
+    _a = []; _c = sources;
+    for (_b = 0, _d = _c.length; _b < _d; _b++) {
+      source = _c[_b];
       _a.push(watch(source));
     }
     return _a;
@@ -180,9 +180,9 @@
   print_tokens = function print_tokens(tokens) {
     var _a, _b, _c, _d, _e, strings, tag, token, value;
     strings = (function() {
-      _a = []; _b = tokens;
-      for (_c = 0, _d = _b.length; _c < _d; _c++) {
-        token = _b[_c];
+      _a = []; _c = tokens;
+      for (_b = 0, _d = _c.length; _b < _d; _b++) {
+        token = _c[_b];
         _a.push((function() {
           _e = [token[0], token[1].toString().replace(/\n/, '\\n')];
           tag = _e[0];
@@ -202,7 +202,8 @@
     o = (options = option_parser.parse(process.argv));
     options.run = !(o.compile || o.print || o.lint);
     options.print = !!(o.print || (o.eval || o.stdio && o.compile));
-    return sources = options.arguments.slice(2, options.arguments.length);
+    sources = options.arguments.slice(2, options.arguments.length);
+    return sources;
   };
   // The compile-time options to pass to the CoffeeScript compiler.
   compile_options = function compile_options(source) {

lib/grammar.js

@@ -67,7 +67,7 @@
     // CoffeeScript is the **Expression** -- you'll notice that there is no
     // "statement" nonterminal. Expressions serve as the building blocks
     // of many other rules, making them somewhat circular.
-    Expression: [o("Value"), o("Call"), o("Code"), o("Operation"), o("Assign"), o("If"), o("Try"), o("Throw"), o("Return"), o("While"), o("For"), o("Switch"), o("Extends"), o("Class"), o("Splat"), o("Existence"), o("Comment")],
+    Expression: [o("Value"), o("Call"), o("Curry"), o("Code"), o("Operation"), o("Assign"), o("If"), o("Try"), o("Throw"), o("Return"), o("While"), o("For"), o("Switch"), o("Extends"), o("Class"), o("Splat"), o("Existence"), o("Comment"), o("Extension")],
     // A an indented block of expressions. Note that the [Rewriter](rewriter.html)
     // will convert some postfix forms into blocks for us, by adjusting the
     // token stream.
@@ -75,6 +75,8 @@
         return $2;
       }), o("INDENT OUTDENT", function() {
         return new Expressions();
+      }), o("TERMINATOR Comment", function() {
+        return Expressions.wrap([$2]);
       })
     ],
     // A literal identifier, a variable name or property.
@@ -115,7 +117,7 @@
       })
     ],
     // Assignment of a variable, property, or index to a value.
-    Assign: [o("Value ASSIGN Expression", function() {
+    Assign: [o("Assignable ASSIGN Expression", function() {
         return new AssignNode($1, $3);
       })
     ],
@@ -185,24 +187,32 @@
         return new SplatNode($1);
       })
     ],
-    // The types of things that can be treated as values -- assigned to, invoked
-    // as functions, indexed into, named as a class, etc.
-    Value: [o("Identifier", function() {
+    // Variables and properties that can be assigned to.
+    SimpleAssignable: [o("Identifier", function() {
         return new ValueNode($1);
-      }), o("Literal", function() {
-        return new ValueNode($1);
-      }), o("Array", function() {
+      }), o("Value Accessor", function() {
+        return $1.push($2);
+      }), o("Invocation Accessor", function() {
+        return new ValueNode($1, [$2]);
+      }), o("ThisProperty")
+    ],
+    // Everything that can be assigned to.
+    Assignable: [o("SimpleAssignable"), o("Array", function() {
         return new ValueNode($1);
       }), o("Object", function() {
         return new ValueNode($1);
+      })
+    ],
+    // The types of things that can be treated as values -- assigned to, invoked
+    // as functions, indexed into, named as a class, etc.
+    Value: [o("Assignable"), o("Literal", function() {
+        return new ValueNode($1);
       }), o("Parenthetical", function() {
         return new ValueNode($1);
       }), o("Range", function() {
         return new ValueNode($1);
-      }), o("This"), o("Value Accessor", function() {
-        return $1.push($2);
-      }), o("Invocation Accessor", function() {
-        return new ValueNode($1, [$2]);
+      }), o("This"), o("NULL", function() {
+        return new ValueNode(new LiteralNode('null'));
       })
     ],
     // The general group of accessors into an object, by property, by prototype
@@ -211,6 +221,8 @@
         return new AccessorNode($2);
       }), o("PROTOTYPE_ACCESS Identifier", function() {
         return new AccessorNode($2, 'prototype');
+      }), o("::", function() {
+        return new AccessorNode(new LiteralNode('prototype'));
       }), o("SOAK_ACCESS Identifier", function() {
         return new AccessorNode($2, 'soak');
       }), o("Index"), o("Slice", function() {
@@ -229,18 +241,10 @@
         return new ObjectNode($2);
       }), o("{ IndentedAssignList }", function() {
         return new ObjectNode($2);
-      })
-    ],
-    // Class definitions have optional bodies of prototype property assignments,
-    // and optional references to the superclass.
-    Class: [o("CLASS Value", function() {
-        return new ClassNode($2);
-      }), o("CLASS Value EXTENDS Value", function() {
-        return new ClassNode($2, $4);
-      }), o("CLASS Value IndentedAssignList", function() {
-        return new ClassNode($2, null, $3);
-      }), o("CLASS Value EXTENDS Value IndentedAssignList", function() {
-        return new ClassNode($2, $4, $5);
+      }), o("{ AssignList , }", function() {
+        return new ObjectNode($2);
+      }), o("{ IndentedAssignList , }", function() {
+        return new ObjectNode($2);
       })
     ],
     // Assignment of properties within an object literal can be separated by
@@ -260,6 +264,36 @@
     // An **AssignList** within a block indentation.
     IndentedAssignList: [o("INDENT AssignList OUTDENT", function() {
         return $2;
+      }), o("INDENT AssignList , OUTDENT", function() {
+        return $2;
+      })
+    ],
+    // Class definitions have optional bodies of prototype property assignments,
+    // and optional references to the superclass.
+    Class: [o("CLASS SimpleAssignable", function() {
+        return new ClassNode($2);
+      }), o("CLASS SimpleAssignable EXTENDS Value", function() {
+        return new ClassNode($2, $4);
+      }), o("CLASS SimpleAssignable INDENT ClassBody OUTDENT", function() {
+        return new ClassNode($2, null, $4);
+      }), o("CLASS SimpleAssignable EXTENDS Value INDENT ClassBody OUTDENT", function() {
+        return new ClassNode($2, $4, $6);
+      })
+    ],
+    // Assignments that can happen directly inside a class declaration.
+    ClassAssign: [o("AssignObj", function() {
+        return $1;
+      }), o("ThisProperty ASSIGN Expression", function() {
+        return new AssignNode(new ValueNode($1), $3, 'this');
+      })
+    ],
+    // A list of assignments to a class.
+    ClassBody: [o("", function() {
+        return [];
+      }), o("ClassAssign", function() {
+        return [$1];
+      }), o("ClassBody TERMINATOR ClassAssign", function() {
+        return $1.concat($3);
       })
     ],
     // The three flavors of function call: normal, object instantiation with `new`,
@@ -268,9 +302,14 @@
         return $2.new_instance();
       }), o("Super")
     ],
+    // Binds a function call to a context and/or arguments.
+    Curry: [o("Value <- Arguments", function() {
+        return new CurryNode($1, $3);
+      })
+    ],
     // Extending an object by setting its prototype chain to reference a parent
     // object.
-    Extends: [o("Value EXTENDS Value", function() {
+    Extends: [o("SimpleAssignable EXTENDS Value", function() {
         return new ExtendsNode($1, $3);
       })
     ],
@@ -284,17 +323,26 @@
     // The list of arguments to a function call.
     Arguments: [o("CALL_START ArgList CALL_END", function() {
         return $2;
+      }), o("CALL_START ArgList , CALL_END", function() {
+        return $2;
       })
     ],
     // Calling super.
     Super: [o("SUPER CALL_START ArgList CALL_END", function() {
         return new CallNode('super', $3);
+      }), o("SUPER CALL_START ArgList , CALL_END", function() {
+        return new CallNode('super', $3);
       })
     ],
-    // A reference to the *this* current object, either naked or to a property.
-    This: [o("@", function() {
+    // A reference to the *this* current object.
+    This: [o("THIS", function() {
         return new ValueNode(new LiteralNode('this'));
-      }), o("@ Identifier", function() {
+      }), o("@", function() {
+        return new ValueNode(new LiteralNode('this'));
+      })
+    ],
+    // A reference to a property on *this*.
+    ThisProperty: [o("@ Identifier", function() {
         return new ValueNode(new LiteralNode('this'), [new AccessorNode($2)]);
       })
     ],
@@ -315,6 +363,8 @@
     // The array literal.
     Array: [o("[ ArgList ]", function() {
         return new ArrayNode($2);
+      }), o("[ ArgList , ]", function() {
+        return new ArrayNode($2);
       })
     ],
     // The **ArgList** is both the list of objects passed into a function call,
@@ -334,13 +384,17 @@
         return $1.concat([$4]);
       }), o("ArgList , INDENT Expression", function() {
         return $1.concat([$4]);
-      }), o("ArgList OUTDENT")
+      }), o("ArgList OUTDENT"), o("ArgList , OUTDENT")
     ],
     // Just simple, comma-separated, required arguments (no fancy syntax). We need
     // this to be separate from the **ArgList** for use in **Switch** blocks, where
     // having the newlines wouldn't make sense.
     SimpleArgs: [o("Expression"), o("SimpleArgs , Expression", function() {
-        return $1 instanceof Array ? $1.concat([$3]) : [$1].concat([$3]);
+        if ($1 instanceof Array) {
+          return $1.concat([$3]);
+        } else {
+          return [$1].concat([$3]);
+        }
       })
     ],
     // The variants of *try/catch/finally* exception handling blocks.
@@ -370,6 +424,12 @@
         return new ParentheticalNode($2);
       })
     ],
+    // A language extension to CoffeeScript from the outside. We simply pass
+    // it through unaltered.
+    Extension: [o("EXTENSION", function() {
+        return yytext;
+      })
+    ],
     // The condition portion of a while loop.
     WhileSource: [o("WHILE Expression", function() {
         return new WhileNode($2);
@@ -384,7 +444,7 @@
     While: [o("WhileSource Block", function() {
         return $1.add_body($2);
       }), o("Expression WhileSource", function() {
-        return $2.add_body($1);
+        return $2.add_body(Expressions.wrap([$1]));
       })
     ],
     // Array, object, and range comprehensions, at the most generic level.
@@ -406,7 +466,7 @@
       })
     ],
     // The source of a comprehension is an array or object with an optional filter
-    // clause. If it's an array comprehension, you can also choose to step throug
+    // clause. If it's an array comprehension, you can also choose to step through
     // in fixed-size increments.
     ForSource: [o("IN Expression", function() {
         return {
@@ -417,12 +477,34 @@
           source: $2,
           object: true
         };
-      }), o("ForSource WHEN Expression", function() {
-        $1.filter = $3;
-        return $1;
-      }), o("ForSource BY Expression", function() {
-        $1.step = $3;
-        return $1;
+      }), o("IN Expression WHEN Expression", function() {
+        return {
+          source: $2,
+          filter: $4
+        };
+      }), o("OF Expression WHEN Expression", function() {
+        return {
+          source: $2,
+          filter: $4,
+          object: true
+        };
+      }), o("IN Expression BY Expression", function() {
+        return {
+          source: $2,
+          step: $4
+        };
+      }), o("IN Expression WHEN Expression BY Expression", function() {
+        return {
+          source: $2,
+          filter: $4,
+          step: $6
+        };
+      }), o("IN Expression BY Expression WHEN Expression", function() {
+        return {
+          source: $2,
+          step: $4,
+          filter: $6
+        };
       })
     ],
     // The CoffeeScript switch/when/else block replaces the JavaScript
@@ -503,8 +585,6 @@
         return new OpNode('+', $2);
       }), {
         prec: 'UPLUS'
-      }), o("NOT Expression", function() {
-        return new OpNode('not', $2);
       }), o("~ Expression", function() {
         return new OpNode('~', $2);
       }), o("-- Expression", function() {
@@ -553,18 +633,10 @@
         return new OpNode('==', $1, $3);
       }), o("Expression != Expression", function() {
         return new OpNode('!=', $1, $3);
-      }), o("Expression IS Expression", function() {
-        return new OpNode('is', $1, $3);
-      }), o("Expression ISNT Expression", function() {
-        return new OpNode('isnt', $1, $3);
       }), o("Expression && Expression", function() {
         return new OpNode('&&', $1, $3);
       }), o("Expression || Expression", function() {
         return new OpNode('||', $1, $3);
-      }), o("Expression AND Expression", function() {
-        return new OpNode('and', $1, $3);
-      }), o("Expression OR Expression", function() {
-        return new OpNode('or', $1, $3);
       }), o("Expression ? Expression", function() {
         return new OpNode('?', $1, $3);
       }), o("Expression -= Expression", function() {
@@ -597,7 +669,7 @@
   //     2 + (3 * 4)
   // And not:
   //     (2 + 3) * 4
-  operators = [["left", '?'], ["nonassoc", 'UMINUS', 'UPLUS', 'NOT', '!', '!!', '~', '++', '--'], ["left", '*', '/', '%'], ["left", '+', '-'], ["left", '<<', '>>', '>>>'], ["left", '&', '|', '^'], ["left", '<=', '<', '>', '>='], ["right", 'DELETE', 'INSTANCEOF', 'TYPEOF'], ["left", '==', '!=', 'IS', 'ISNT'], ["left", '&&', '||', 'AND', 'OR'], ["right", '-=', '+=', '/=', '*=', '%=', '||=', '&&=', '?='], ["left", '.'], ["right", 'INDENT'], ["left", 'OUTDENT'], ["right", 'WHEN', 'LEADING_WHEN', 'IN', 'OF', 'BY', 'THROW'], ["right", 'FOR', 'NEW', 'SUPER', 'CLASS'], ["left", 'EXTENDS'], ["right", 'ASSIGN', 'RETURN'], ["right", '->', '=>', 'UNLESS', 'IF', 'ELSE', 'WHILE']];
+  operators = [["left", '?'], ["nonassoc", 'UMINUS', 'UPLUS', '!', '!!', '~', '++', '--'], ["left", '*', '/', '%'], ["left", '+', '-'], ["left", '<<', '>>', '>>>'], ["left", '&', '|', '^'], ["left", '<=', '<', '>', '>='], ["right", 'DELETE', 'INSTANCEOF', 'TYPEOF'], ["left", '==', '!='], ["left", '&&', '||'], ["right", '-=', '+=', '/=', '*=', '%=', '||=', '&&=', '?='], ["left", '.'], ["right", 'INDENT'], ["left", 'OUTDENT'], ["right", 'WHEN', 'LEADING_WHEN', 'IN', 'OF', 'BY', 'THROW'], ["right", 'FOR', 'NEW', 'SUPER', 'CLASS'], ["left", 'EXTENDS'], ["right", 'ASSIGN', 'RETURN'], ["right", '->', '=>', '<-', 'UNLESS', 'IF', 'ELSE', 'WHILE']];
   // Wrapping Up
   // -----------
   // Finally, now what we have our **grammar** and our **operators**, we can create
@@ -609,13 +681,13 @@
   for (name in _a) { if (__hasProp.call(_a, name)) {
     alternatives = _a[name];
     grammar[name] = (function() {
-      _b = []; _c = alternatives;
-      for (_d = 0, _e = _c.length; _d < _e; _d++) {
-        alt = _c[_d];
+      _b = []; _d = alternatives;
+      for (_c = 0, _e = _d.length; _c < _e; _c++) {
+        alt = _d[_c];
         _b.push((function() {
-          _f = alt[0].split(' ');
-          for (_g = 0, _h = _f.length; _g < _h; _g++) {
-            token = _f[_g];
+          _g = alt[0].split(' ');
+          for (_f = 0, _h = _g.length; _f < _h; _f++) {
+            token = _g[_f];
             if (!(grammar[token])) {
               tokens.push(token);
             }

lib/helpers.js

@@ -0,0 +1,143 @@
+(function(){
+  var balanced_string, compact, count, del, extend, flatten, helpers, include, merge, starts;
+  var __hasProp = Object.prototype.hasOwnProperty;
+  // This file contains the common helper functions that we'd like to share among
+  // the **Lexer**, **Rewriter**, and the **Nodes**. Merge objects, flatten
+  // arrays, count characters, that sort of thing.
+  // Set up exported variables for both **Node.js** and the browser.
+  if (!((typeof process !== "undefined" && process !== null))) {
+    this.exports = this;
+  }
+  helpers = (exports.helpers = {});
+  // Does a list include a value?
+  helpers.include = (include = function include(list, value) {
+    return list.indexOf(value) >= 0;
+  });
+  // Peek at the beginning of a given string to see if it matches a sequence.
+  helpers.starts = (starts = function starts(string, literal, start) {
+    return string.substring(start, (start || 0) + literal.length) === literal;
+  });
+  // Trim out all falsy values from an array.
+  helpers.compact = (compact = function compact(array) {
+    var _a, _b, _c, _d, item;
+    _a = []; _c = array;
+    for (_b = 0, _d = _c.length; _b < _d; _b++) {
+      item = _c[_b];
+      item ? _a.push(item) : null;
+    }
+    return _a;
+  });
+  // Count the number of occurences of a character in a string.
+  helpers.count = (count = function count(string, letter) {
+    var num, pos;
+    num = 0;
+    pos = string.indexOf(letter);
+    while (pos !== -1) {
+      num += 1;
+      pos = string.indexOf(letter, pos + 1);
+    }
+    return num;
+  });
+  // Merge objects, returning a fresh copy with attributes from both sides.
+  // Used every time `BaseNode#compile` is called, to allow properties in the
+  // options hash to propagate down the tree without polluting other branches.
+  helpers.merge = (merge = function merge(options, overrides) {
+    var _a, _b, fresh, key, val;
+    fresh = {};
+    _a = options;
+    for (key in _a) { if (__hasProp.call(_a, key)) {
+      val = _a[key];
+      (fresh[key] = val);
+    }}
+    if (overrides) {
+      _b = overrides;
+      for (key in _b) { if (__hasProp.call(_b, key)) {
+        val = _b[key];
+        (fresh[key] = val);
+      }}
+    }
+    return fresh;
+  });
+  // Extend a source object with the properties of another object (shallow copy).
+  // We use this to simulate Node's deprecated `process.mixin`
+  helpers.extend = (extend = function extend(object, properties) {
+    var _a, _b, key, val;
+    _a = []; _b = properties;
+    for (key in _b) { if (__hasProp.call(_b, key)) {
+      val = _b[key];
+      _a.push((object[key] = val));
+    }}
+    return _a;
+  });
+  // Return a completely flattened version of an array. Handy for getting a
+  // list of `children` from the nodes.
+  helpers.flatten = (flatten = function flatten(array) {
+    var _a, _b, _c, item, memo;
+    memo = [];
+    _b = array;
+    for (_a = 0, _c = _b.length; _a < _c; _a++) {
+      item = _b[_a];
+      item instanceof Array ? (memo = memo.concat(item)) : memo.push(item);
+    }
+    return memo;
+  });
+  // Delete a key from an object, returning the value. Useful when a node is
+  // looking for a particular method in an options hash.
+  helpers.del = (del = function del(obj, key) {
+    var val;
+    val = obj[key];
+    delete obj[key];
+    return val;
+  });
+  // Matches a balanced group such as a single or double-quoted string. Pass in
+  // a series of delimiters, all of which must be nested correctly within the
+  // contents of the string. This method allows us to have strings within
+  // interpolations within strings, ad infinitum.
+  helpers.balanced_string = (balanced_string = function balanced_string(str, delimited, options) {
+    var _a, _b, _c, _d, close, i, levels, open, pair, slash;
+    options = options || {};
+    slash = delimited[0][0] === '/';
+    levels = [];
+    i = 0;
+    while (i < str.length) {
+      if (levels.length && starts(str, '\\', i)) {
+        i += 1;
+      } else {
+        _b = delimited;
+        for (_a = 0, _c = _b.length; _a < _c; _a++) {
+          pair = _b[_a];
+          _d = pair;
+          open = _d[0];
+          close = _d[1];
+          if (levels.length && starts(str, close, i) && levels[levels.length - 1] === pair) {
+            levels.pop();
+            i += close.length - 1;
+            if (!(levels.length)) {
+              i += 1;
+            }
+            break;
+          } else if (starts(str, open, i)) {
+            levels.push(pair);
+            i += open.length - 1;
+            break;
+          }
+        }
+      }
+      if (!levels.length || slash && starts(str, '\n', i)) {
+        break;
+      }
+      i += 1;
+    }
+    if (levels.length) {
+      if (slash) {
+        return false;
+      }
+      throw new Error("SyntaxError: Unterminated " + (levels.pop()[0]) + " starting on line " + (this.line + 1));
+    }
+    if (!i) {
+      return false;
+    } else {
+      return str.substring(0, i);
+    }
+  });
+})();

lib/lexer.js

@@ -1,5 +1,6 @@
 (function(){
-  var ACCESSORS, ASSIGNMENT, BEFORE_WHEN, CALLABLE, CODE, COFFEE_KEYWORDS, COMMENT, COMMENT_CLEANER, HEREDOC, HEREDOC_INDENT, IDENTIFIER, INTERPOLATION, JS_CLEANER, JS_FORBIDDEN, JS_KEYWORDS, KEYWORDS, LAST_DENT, LAST_DENTS, Lexer, MULTILINER, MULTI_DENT, NOT_REGEX, NO_NEWLINE, NUMBER, OPERATOR, REGEX, RESERVED, Rewriter, STRING_NEWLINES, WHITESPACE, compact, count, include, starts;
+  var ACCESSORS, ASSIGNMENT, CALLABLE, CODE, COFFEE_ALIASES, COFFEE_KEYWORDS, COMMENT, COMMENT_CLEANER, CONVERSIONS, HALF_ASSIGNMENTS, HEREDOC, HEREDOC_INDENT, IDENTIFIER, INTERPOLATION, JS_CLEANER, JS_FORBIDDEN, JS_KEYWORDS, KEYWORDS, LAST_DENT, LAST_DENTS, LINE_BREAK, Lexer, MULTILINER, MULTI_DENT, NOT_REGEX, NO_NEWLINE, NUMBER, OPERATOR, REGEX_ESCAPE, REGEX_FLAGS, REGEX_INTERPOLATION, REGEX_START, RESERVED, Rewriter, STRING_NEWLINES, WHITESPACE, balanced_string, compact, count, helpers, include, starts;
+  var __slice = Array.prototype.slice;
   // The CoffeeScript Lexer. Uses a series of token-matching regexes to attempt
   // matches against the beginning of the source code. When a match is found,
   // a token is produced, we consume the match, and start again. Tokens are in the
@@ -9,10 +10,18 @@
   // Set up the Lexer for both Node.js and the browser, depending on where we are.
   if ((typeof process !== "undefined" && process !== null)) {
     Rewriter = require('./rewriter').Rewriter;
+    helpers = require('./helpers').helpers;
   } else {
     this.exports = this;
     Rewriter = this.Rewriter;
+    helpers = this.helpers;
   }
+  // Import the helpers we need.
+  include = helpers.include;
+  count = helpers.count;
+  starts = helpers.starts;
+  compact = helpers.compact;
+  balanced_string = helpers.balanced_string;
   // The Lexer Class
   // ---------------
   // The Lexer class reads a stream of CoffeeScript and divvys it up into tagged
@@ -32,6 +41,7 @@
     // unless explicitly asked not to.
     Lexer.prototype.tokenize = function tokenize(code, options) {
       var o;
+      code = code.replace(/(\r|\s+$)/g, '');
       o = options || {};
       this.code = code;
       // The remainder of the source code.
@@ -59,6 +69,9 @@
     // short-circuiting if any of them succeed. Their order determines precedence:
     // `@literal_token` is the fallback catch-all.
     Lexer.prototype.extract_next_token = function extract_next_token() {
+      if (this.extension_token()) {
+        return null;
+      }
       if (this.identifier_token()) {
         return null;
       }
@@ -90,6 +103,19 @@
     };
     // Tokenizers
     // ----------
+    // Language extensions get the highest priority, first chance to tag tokens
+    // as something else.
+    Lexer.prototype.extension_token = function extension_token() {
+      var _a, _b, _c, extension;
+      _b = Lexer.extensions;
+      for (_a = 0, _c = _b.length; _a < _c; _a++) {
+        extension = _b[_a];
+        if (extension.call(this)) {
+          return true;
+        }
+      }
+      return false;
+    };
     // Matches identifying literals: variables, keywords, method names, etc.
     // Check to ensure that JavaScript reserved words aren't being used as
     // identifiers. Because CoffeeScript reserves a handful of keywords that are
@@ -97,29 +123,38 @@
     // referenced as property names here, so you can still do `jQuery.is()` even
     // though `is` means `===` otherwise.
     Lexer.prototype.identifier_token = function identifier_token() {
-      var id, tag;
-      if (!((id = this.match(IDENTIFIER, 1)))) {
+      var accessed, id, tag;
+      if (!(id = this.match(IDENTIFIER, 1))) {
         return false;
       }
       this.name_access_type();
+      accessed = include(ACCESSORS, this.tag(0));
       tag = 'IDENTIFIER';
-      if (include(KEYWORDS, id) && !(include(ACCESSORS, this.tag(0)) && !this.prev().spaced)) {
+      if (!accessed && include(KEYWORDS, id)) {
         tag = id.toUpperCase();
       }
       if (include(RESERVED, id)) {
         this.identifier_error(id);
       }
-      if (tag === 'WHEN' && include(BEFORE_WHEN, this.tag())) {
+      if (tag === 'WHEN' && include(LINE_BREAK, this.tag())) {
         tag = 'LEADING_WHEN';
       }
-      this.token(tag, id);
       this.i += id.length;
+      if (!accessed) {
+        if (include(COFFEE_ALIASES, id)) {
+          tag = (id = CONVERSIONS[id]);
+        }
+        if (this.prev() && this.prev()[0] === 'ASSIGN' && include(HALF_ASSIGNMENTS, tag)) {
+          return this.tag_half_assignment(tag);
+        }
+      }
+      this.token(tag, id);
       return true;
     };
     // Matches numbers, including decimals, hex, and exponential notation.
     Lexer.prototype.number_token = function number_token() {
       var number;
-      if (!((number = this.match(NUMBER, 1)))) {
+      if (!(number = this.match(NUMBER, 1))) {
         return false;
       }
       this.token('NUMBER', number);
@@ -133,11 +168,7 @@
       if (!(starts(this.chunk, '"') || starts(this.chunk, "'"))) {
         return false;
       }
-      string = this.balanced_token(['"', '"'], ['${', '}']);
-      if (!(string)) {
-        string = this.balanced_token(["'", "'"]);
-      }
-      if (!(string)) {
+      if (!(string = this.balanced_token(['"', '"'], ['${', '}']) || this.balanced_token(["'", "'"]))) {
         return false;
       }
       this.interpolate_string(string.replace(STRING_NEWLINES, " \\\n"));
@@ -148,12 +179,13 @@
     // Matches heredocs, adjusting indentation to the correct level, as heredocs
     // preserve whitespace, but ignore indentation to the left.
     Lexer.prototype.heredoc_token = function heredoc_token() {
-      var doc, match;
-      if (!((match = this.chunk.match(HEREDOC)))) {
+      var doc, match, quote;
+      if (!(match = this.chunk.match(HEREDOC))) {
         return false;
       }
-      doc = this.sanitize_heredoc(match[2] || match[4]);
-      this.token('STRING', "\"" + doc + "\"");
+      quote = match[1].substr(0, 1);
+      doc = this.sanitize_heredoc(match[2] || match[4], quote);
+      this.interpolate_string("" + quote + doc + quote);
       this.line += count(match[1], "\n");
       this.i += match[1].length;
       return true;
@@ -164,7 +196,7 @@
       if (!(starts(this.chunk, '`'))) {
         return false;
       }
-      if (!((script = this.balanced_token(['`', '`'])))) {
+      if (!(script = this.balanced_token(['`', '`']))) {
         return false;
       }
       this.token('JS', script.replace(JS_CLEANER, ''));
@@ -173,16 +205,31 @@
     };
     // Matches regular expression literals. Lexing regular expressions is difficult
     // to distinguish from division, so we borrow some basic heuristics from
-    // JavaScript and Ruby.
+    // JavaScript and Ruby, borrow slash balancing from `@balanced_token`, and
+    // borrow interpolation from `@interpolate_string`.
     Lexer.prototype.regex_token = function regex_token() {
-      var regex;
-      if (!((regex = this.match(REGEX, 1)))) {
+      var flags, regex, str;
+      if (!(this.chunk.match(REGEX_START))) {
         return false;
       }
       if (include(NOT_REGEX, this.tag())) {
         return false;
       }
-      this.token('REGEX', regex);
+      if (!(regex = this.balanced_token(['/', '/']))) {
+        return false;
+      }
+      regex += (flags = this.chunk.substr(regex.length).match(REGEX_FLAGS));
+      if (regex.match(REGEX_INTERPOLATION)) {
+        str = regex.substring(1).split('/')[0];
+        str = str.replace(REGEX_ESCAPE, function(escaped) {
+          return '\\' + escaped;
+        });
+        this.tokens = this.tokens.concat([['(', '('], ['NEW', 'new'], ['IDENTIFIER', 'RegExp'], ['CALL_START', '(']]);
+        this.interpolate_string("\"" + str + "\"", true);
+        this.tokens = this.tokens.concat([[',', ','], ['STRING', "\"" + flags + "\""], [')', ')'], [')', ')']]);
+      } else {
+        this.token('REGEX', regex);
+      }
       this.i += regex.length;
       return true;
     };
@@ -190,20 +237,25 @@
     // balanced (ie. strings, JS literals).
     Lexer.prototype.balanced_token = function balanced_token() {
       var delimited;
-      delimited = Array.prototype.slice.call(arguments, 0);
-      return this.balanced_string.apply(this, [this.chunk].concat(delimited));
+      delimited = __slice.call(arguments, 0, arguments.length - 0);
+      return balanced_string(this.chunk, delimited);
     };
     // Matches and conumes comments. We pass through comments into JavaScript,
     // so they're treated as real tokens, like any other part of the language.
     Lexer.prototype.comment_token = function comment_token() {
-      var comment, lines;
-      if (!((comment = this.match(COMMENT, 1)))) {
+      var comment, i, lines;
+      if (!(comment = this.match(COMMENT, 1))) {
         return false;
       }
       this.line += (comment.match(MULTILINER) || []).length;
-      lines = comment.replace(COMMENT_CLEANER, '').split(MULTILINER);
-      this.token('COMMENT', compact(lines));
-      this.token('TERMINATOR', "\n");
+      lines = compact(comment.replace(COMMENT_CLEANER, '').split(MULTILINER));
+      i = this.tokens.length - 1;
+      if (this.unfinished()) {
+        while (this.tokens[i] && !include(LINE_BREAK, this.tokens[i][0])) {
+          i -= 1;
+        }
+      }
+      this.tokens.splice(i + 1, 0, ['COMMENT', lines, this.line], ['TERMINATOR', '\n', this.line]);
       this.i += comment.length;
       return true;
     };
@@ -217,7 +269,7 @@
     // can close multiple indents, so we need to know how far in we happen to be.
     Lexer.prototype.line_token = function line_token() {
       var diff, indent, next_character, no_newlines, prev, size;
-      if (!((indent = this.match(MULTI_DENT, 1)))) {
+      if (!(indent = this.match(MULTI_DENT, 1))) {
         return false;
       }
       this.line += indent.match(MULTILINER).length;
@@ -225,7 +277,7 @@
       prev = this.prev(2);
       size = indent.match(LAST_DENTS).reverse()[0].match(LAST_DENT)[1].length;
       next_character = this.chunk.match(MULTI_DENT)[4];
-      no_newlines = next_character === '.' || (this.value() && this.value().match(NO_NEWLINE) && prev && (prev[0] !== '.') && !this.value().match(CODE));
+      no_newlines = next_character === '.' || this.unfinished();
       if (size === this.indent) {
         if (no_newlines) {
           return this.suppress_newlines();
@@ -262,7 +314,7 @@
     // as being "spaced", because there are some cases where it makes a difference.
     Lexer.prototype.whitespace_token = function whitespace_token() {
       var prev, space;
-      if (!((space = this.match(WHITESPACE, 1)))) {
+      if (!(space = this.match(WHITESPACE, 1))) {
         return false;
       }
       prev = this.prev();
@@ -293,14 +345,15 @@
     // here. `;` and newlines are both treated as a `TERMINATOR`, we distinguish
     // parentheses that indicate a method call from regular parentheses, and so on.
     Lexer.prototype.literal_token = function literal_token() {
-      var match, not_spaced, tag, value;
+      var match, prev_spaced, space, tag, value;
       match = this.chunk.match(OPERATOR);
       value = match && match[1];
+      space = match && match[2];
       if (value && value.match(CODE)) {
         this.tag_parameters();
       }
       value = value || this.chunk.substr(0, 1);
-      not_spaced = !this.prev() || !this.prev().spaced;
+      prev_spaced = this.prev() && this.prev().spaced;
       tag = value;
       if (value.match(ASSIGNMENT)) {
         tag = 'ASSIGN';
@@ -309,14 +362,14 @@
         }
       } else if (value === ';') {
         tag = 'TERMINATOR';
-      } else if (value === '[' && this.tag() === '?' && not_spaced) {
+      } else if (value === '[' && this.tag() === '?' && !prev_spaced) {
         tag = 'SOAKED_INDEX_START';
         this.soaked_index = true;
         this.tokens.pop();
       } else if (value === ']' && this.soaked_index) {
         tag = 'SOAKED_INDEX_END';
         this.soaked_index = false;
-      } else if (include(CALLABLE, this.tag()) && not_spaced) {
+      } else if (include(CALLABLE, this.tag()) && !prev_spaced) {
         if (value === '(') {
           tag = 'CALL_START';
         }
@@ -324,8 +377,11 @@
           tag = 'INDEX_START';
         }
       }
-      this.token(tag, value);
       this.i += value.length;
+      if (space && prev_spaced && this.prev()[0] === 'ASSIGN' && include(HALF_ASSIGNMENTS, tag)) {
+        return this.tag_half_assignment(tag);
+      }
+      this.token(tag, value);
       return true;
     };
     // Token Manipulators
@@ -347,10 +403,17 @@
     };
     // Sanitize a heredoc by escaping internal double quotes and erasing all
     // external indentation on the left-hand side.
-    Lexer.prototype.sanitize_heredoc = function sanitize_heredoc(doc) {
+    Lexer.prototype.sanitize_heredoc = function sanitize_heredoc(doc, quote) {
       var indent;
       indent = (doc.match(HEREDOC_INDENT) || ['']).sort()[0];
-      return doc.replace(new RegExp("^" + indent, 'gm'), '').replace(MULTILINER, "\\n").replace(/"/g, '\\"');
+      return doc.replace(new RegExp("^" + indent, 'gm'), '').replace(MULTILINER, "\\n").replace(new RegExp(quote, 'g'), '\\"');
+    };
+    // Tag a half assignment.
+    Lexer.prototype.tag_half_assignment = function tag_half_assignment(tag) {
+      var last;
+      last = this.tokens.pop();
+      this.tokens.push(["" + tag + "=", "" + tag + "=", last[2]]);
+      return true;
     };
     // A source of ambiguity in our grammar used to be parameter lists in function
     // definitions versus argument lists in function calls. Walk backwards, tagging
@@ -372,7 +435,8 @@
         } else if (_a === ')') {
           tok[0] = 'PARAM_END';
         } else if (_a === '(') {
-          return (tok[0] = 'PARAM_START');
+          tok[0] = 'PARAM_START';
+          return tok[0];
         }
       }
       return true;
@@ -391,51 +455,6 @@
     Lexer.prototype.assignment_error = function assignment_error() {
       throw new Error("SyntaxError: Reserved word \"" + (this.value()) + "\" on line " + (this.line + 1) + " can't be assigned");
     };
-    // Matches a balanced group such as a single or double-quoted string. Pass in
-    // a series of delimiters, all of which must be nested correctly within the
-    // contents of the string. This method allows us to have strings within
-    // interpolations within strings etc...
-    Lexer.prototype.balanced_string = function balanced_string(str) {
-      var _a, _b, _c, _d, close, delimited, i, levels, open, pair;
-      delimited = Array.prototype.slice.call(arguments, 1);
-      levels = [];
-      i = 0;
-      while (i < str.length) {
-        _a = delimited;
-        for (_b = 0, _c = _a.length; _b < _c; _b++) {
-          pair = _a[_b];
-          _d = pair;
-          open = _d[0];
-          close = _d[1];
-          if (levels.length && starts(str, '\\', i)) {
-            i += 1;
-            break;
-          } else if (levels.length && starts(str, close, i) && levels[levels.length - 1] === pair) {
-            levels.pop();
-            i += close.length - 1;
-            if (!(levels.length)) {
-              i += 1;
-            }
-            break;
-          } else if (starts(str, open, i)) {
-            levels.push(pair);
-            i += open.length - 1;
-            break;
-          }
-        }
-        if (!(levels.length)) {
-          break;
-        }
-        i += 1;
-      }
-      if (levels.length) {
-        throw new Error("SyntaxError: Unterminated " + (levels.pop()[0]) + " starting on line " + (this.line + 1));
-      }
-      if (i === 0) {
-        return false;
-      }
-      return str.substring(0, i);
-    };
     // Expand variables and expressions inside double-quoted strings using
     // [ECMA Harmony's interpolation syntax](http://wiki.ecmascript.org/doku.php?id=strawman:string_interpolation)
     // for substitution of bare variables as well as arbitrary expressions.
@@ -444,8 +463,8 @@
     // If it encounters an interpolation, this method will recursively create a
     // new Lexer, tokenize the interpolated contents, and merge them into the
     // token stream.
-    Lexer.prototype.interpolate_string = function interpolate_string(str) {
-      var _a, _b, _c, _d, _e, each, expr, group, i, inner, interp, lexer, match, nested, pi, quote, tokens;
+    Lexer.prototype.interpolate_string = function interpolate_string(str, escape_quotes) {
+      var _a, _b, _c, _d, _e, escaped, expr, group, i, inner, interp, lexer, match, nested, pi, quote, tag, token, tokens, value;
       if (str.length < 3 || !starts(str, '"')) {
         return this.token('STRING', str);
       } else {
@@ -466,14 +485,14 @@
               interp = "this." + (interp.substring(1));
             }
             if (pi < i) {
-              tokens.push(['STRING', quote + (str.substring(pi, i)) + quote]);
+              tokens.push(['STRING', "" + quote + (str.substring(pi, i)) + quote]);
             }
             tokens.push(['IDENTIFIER', interp]);
             i += group.length - 1;
             pi = i + 1;
-          } else if (((expr = this.balanced_string(str.substring(i), ['${', '}'])))) {
+          } else if ((expr = balanced_string(str.substring(i), [['${', '}']]))) {
             if (pi < i) {
-              tokens.push(['STRING', quote + (str.substring(pi, i)) + quote]);
+              tokens.push(['STRING', "" + quote + (str.substring(pi, i)) + quote]);
             }
             inner = expr.substring(2, expr.length - 1);
             if (inner.length) {
@@ -484,7 +503,7 @@
               nested.pop();
               tokens.push(['TOKENS', nested]);
             } else {
-              tokens.push(['STRING', quote + quote]);
+              tokens.push(['STRING', "" + quote + quote]);
             }
             i += expr.length - 1;
             pi = i + 1;
@@ -492,19 +511,30 @@
           i += 1;
         }
         if (pi < i && pi < str.length - 1) {
-          tokens.push(['STRING', quote + (str.substring(pi, i)) + quote]);
+          tokens.push(['STRING', "" + quote + (str.substring(pi, i)) + quote]);
         }
-        _c = []; _d = tokens;
-        for (i = 0, _e = _d.length; i < _e; i++) {
-          each = _d[i];
-          _c.push((function() {
-            each[0] === 'TOKENS' ? (this.tokens = this.tokens.concat(each[1])) : this.token(each[0], each[1]);
-            if (i < tokens.length - 1) {
-              return this.token('+', '+');
-            }
-          }).call(this));
+        if (!(tokens[0][0] === 'STRING')) {
+          tokens.unshift(['STRING', '""']);
         }
-        return _c;
+        _c = tokens;
+        for (i = 0, _d = _c.length; i < _d; i++) {
+          token = _c[i];
+          _e = token;
+          tag = _e[0];
+          value = _e[1];
+          if (tag === 'TOKENS') {
+            this.tokens = this.tokens.concat(value);
+          } else if (tag === 'STRING' && escape_quotes) {
+            escaped = value.substring(1, value.length - 1).replace(/"/g, '\\"');
+            this.token(tag, "\"" + escaped + "\"");
+          } else {
+            this.token(tag, value);
+          }
+          if (i < tokens.length - 1) {
+            this.token('+', '+');
+          }
+        }
+        return tokens;
       }
     };
     // Helpers
@@ -516,22 +546,24 @@
     // Peek at a tag in the current token stream.
     Lexer.prototype.tag = function tag(index, tag) {
       var tok;
-      if (!((tok = this.prev(index)))) {
+      if (!(tok = this.prev(index))) {
         return null;
       }
       if ((typeof tag !== "undefined" && tag !== null)) {
-        return (tok[0] = tag);
+        tok[0] = tag;
+        return tok[0];
       }
       return tok[0];
     };
     // Peek at a value in the current token stream.
     Lexer.prototype.value = function value(index, val) {
       var tok;
-      if (!((tok = this.prev(index)))) {
+      if (!(tok = this.prev(index))) {
         return null;
       }
       if ((typeof val !== "undefined" && val !== null)) {
-        return (tok[1] = val);
+        tok[1] = val;
+        return tok[1];
       }
       return tok[1];
     };
@@ -543,44 +575,63 @@
     // match if successful, and `false` otherwise.
     Lexer.prototype.match = function match(regex, index) {
       var m;
-      if (!((m = this.chunk.match(regex)))) {
+      if (!(m = this.chunk.match(regex))) {
+        return false;
+      }
+      if (m) {
+        return m[index];
+      } else {
         return false;
       }
-      return m ? m[index] : false;
     };
+    // Are we in the midst of an unfinished expression?
+    Lexer.prototype.unfinished = function unfinished() {
+      var prev;
+      prev = this.prev(2);
+      return this.value() && this.value().match && this.value().match(NO_NEWLINE) && prev && (prev[0] !== '.') && !this.value().match(CODE);
+    };
+    // Lexer Properties
+    // ----------------
+    // There are no exensions to the core lexer by default.
+    Lexer.extensions = [];
     return Lexer;
   }).call(this);
   // Constants
   // ---------
   // Keywords that CoffeeScript shares in common with JavaScript.
-  JS_KEYWORDS = ["if", "else", "true", "false", "new", "return", "try", "catch", "finally", "throw", "break", "continue", "for", "in", "while", "delete", "instanceof", "typeof", "switch", "super", "extends", "class"];
+  JS_KEYWORDS = ["if", "else", "true", "false", "new", "return", "try", "catch", "finally", "throw", "break", "continue", "for", "in", "while", "delete", "instanceof", "typeof", "switch", "super", "extends", "class", "this", "null"];
   // CoffeeScript-only keywords, which we're more relaxed about allowing. They can't
   // be used standalone, but you can reference them as an attached property.
-  COFFEE_KEYWORDS = ["then", "unless", "yes", "no", "on", "off", "and", "or", "is", "isnt", "not", "of", "by", "where", "when"];
+  COFFEE_ALIASES = ["and", "or", "is", "isnt", "not"];
+  COFFEE_KEYWORDS = COFFEE_ALIASES.concat(["then", "unless", "yes", "no", "on", "off", "of", "by", "where", "when"]);
   // The combined list of keywords is the superset that gets passed verbatim to
   // the parser.
   KEYWORDS = JS_KEYWORDS.concat(COFFEE_KEYWORDS);
   // The list of keywords that are reserved by JavaScript, but not used, or are
   // used by CoffeeScript internally. We throw an error when these are encountered,
   // to avoid having a JavaScript error at runtime.
-  RESERVED = ["case", "default", "do", "function", "var", "void", "with", "const", "let", "debugger", "enum", "export", "import", "native", "__extends", "__hasProp"];
+  RESERVED = ["case", "default", "do", "function", "var", "void", "with", "const", "let", "debugger", "enum", "export", "import", "native"];
   // The superset of both JavaScript keywords and reserved words, none of which may
   // be used as identifiers or properties.
   JS_FORBIDDEN = JS_KEYWORDS.concat(RESERVED);
   // Token matching regexes.
-  IDENTIFIER = /^([a-zA-Z$_](\w|\$)*)/;
+  IDENTIFIER = /^([a-zA-Z\$_](\w|\$)*)/;
   NUMBER = /^(\b((0(x|X)[0-9a-fA-F]+)|([0-9]+(\.[0-9]+)?(e[+\-]?[0-9]+)?)))\b/i;
   HEREDOC = /^("{6}|'{6}|"{3}\n?([\s\S]*?)\n?([ \t]*)"{3}|'{3}\n?([\s\S]*?)\n?([ \t]*)'{3})/;
   INTERPOLATION = /^\$([a-zA-Z_@]\w*(\.\w+)*)/;
-  OPERATOR = /^([+\*&|\/\-%=<>:!?]+)/;
+  OPERATOR = /^([+\*&|\/\-%=<>:!?]+)([ \t]*)/;
   WHITESPACE = /^([ \t]+)/;
   COMMENT = /^(((\n?[ \t]*)?#[^\n]*)+)/;
   CODE = /^((-|=)>)/;
-  REGEX = /^(\/(\S.*?)?([^\\]|\\\\)\/[imgy]{0,4})/;
   MULTI_DENT = /^((\n([ \t]*))+)(\.)?/;
   LAST_DENTS = /\n([ \t]*)/g;
   LAST_DENT = /\n([ \t]*)/;
   ASSIGNMENT = /^(:|=)$/;
+  // Regex-matching-regexes.
+  REGEX_START = /^\/[^\/ ]/;
+  REGEX_INTERPOLATION = /([^\\]\$[a-zA-Z_@]|[^\\]\$\{.*[^\\]\})/;
+  REGEX_FLAGS = /^[imgy]{0,4}/;
+  REGEX_ESCAPE = /\\[^\$]/g;
   // Token cleaning regexes.
   JS_CLEANER = /(^`|`$)/g;
   MULTILINER = /\n/g;
@@ -596,45 +647,22 @@
   // Tokens which could legitimately be invoked or indexed. A opening
   // parentheses or bracket following these tokens will be recorded as the start
   // of a function invocation or indexing operation.
-  CALLABLE = ['IDENTIFIER', 'SUPER', ')', ']', '}', 'STRING', '@'];
+  CALLABLE = ['IDENTIFIER', 'SUPER', ')', ']', '}', 'STRING', '@', 'THIS'];
   // Tokens that indicate an access -- keywords immediately following will be
   // treated as identifiers.
   ACCESSORS = ['PROPERTY_ACCESS', 'PROTOTYPE_ACCESS', 'SOAK_ACCESS', '@'];
   // Tokens that, when immediately preceding a `WHEN`, indicate that the `WHEN`
   // occurs at the start of a line. We disambiguate these from trailing whens to
   // avoid an ambiguity in the grammar.
-  BEFORE_WHEN = ['INDENT', 'OUTDENT', 'TERMINATOR'];
-  // Utility Functions
-  // -----------------
-  // Does a list include a value?
-  include = function include(list, value) {
-    return list.indexOf(value) >= 0;
-  };
-  // Peek at the beginning of a given string to see if it matches a sequence.
-  starts = function starts(string, literal, start) {
-    return string.substring(start, (start || 0) + literal.length) === literal;
-  };
-  // Trim out all falsy values from an array.
-  compact = function compact(array) {
-    var _a, _b, _c, _d, item;
-    _a = []; _b = array;
-    for (_c = 0, _d = _b.length; _c < _d; _c++) {
-      item = _b[_c];
-      if (item) {
-        _a.push(item);
-      }
-    }
-    return _a;
-  };
-  // Count the number of occurences of a character in a string.
-  count = function count(string, letter) {
-    var num, pos;
-    num = 0;
-    pos = string.indexOf(letter);
-    while (pos !== -1) {
-      num += 1;
-      pos = string.indexOf(letter, pos + 1);
-    }
-    return num;
+  LINE_BREAK = ['INDENT', 'OUTDENT', 'TERMINATOR'];
+  // Half-assignments...
+  HALF_ASSIGNMENTS = ['-', '+', '/', '*', '%', '||', '&&', '?'];
+  // Conversions from CoffeeScript operators into JavaScript ones.
+  CONVERSIONS = {
+    'and': '&&',
+    'or': '||',
+    'is': '==',
+    'isnt': '!=',
+    'not': '!'
   };
 })();

lib/optparse.js

@@ -20,17 +20,16 @@
     // flag. Instead, you're responsible for interpreting the options object.
     OptionParser.prototype.parse = function parse(args) {
       var _a, _b, _c, arg, is_option, matched_rule, options, rule;
-      arguments = Array.prototype.slice.call(arguments, 0);
       options = {
         arguments: []
       };
       args = normalize_arguments(args);
-      while (arg = args.shift()) {
+      while ((arg = args.shift())) {
         is_option = !!(arg.match(LONG_FLAG) || arg.match(SHORT_FLAG));
         matched_rule = false;
-        _a = this.rules;
-        for (_b = 0, _c = _a.length; _b < _c; _b++) {
-          rule = _a[_b];
+        _b = this.rules;
+        for (_a = 0, _c = _b.length; _a < _c; _a++) {
+          rule = _b[_a];
           if (rule.short_flag === arg || rule.long_flag === arg) {
             options[rule.name] = rule.has_argument ? args.shift() : true;
             matched_rule = true;
@@ -49,18 +48,18 @@
     // Return the help text for this **OptionParser**, listing and describing all
     // of the valid options, for `--help` and such.
     OptionParser.prototype.help = function help() {
-      var _a, _b, _c, _d, _e, _f, _g, _h, i, let_part, lines, rule, spaces;
+      var _a, _b, _c, _d, _e, _f, _g, i, let_part, lines, rule, spaces;
       lines = ['Available options:'];
       if (this.banner) {
-        lines.unshift(this.banner + "\n");
+        lines.unshift("" + this.banner + "\n");
       }
-      _a = this.rules;
-      for (_b = 0, _c = _a.length; _b < _c; _b++) {
-        rule = _a[_b];
+      _b = this.rules;
+      for (_a = 0, _c = _b.length; _a < _c; _a++) {
+        rule = _b[_a];
         spaces = 15 - rule.long_flag.length;
         spaces = spaces > 0 ? (function() {
-          _d = []; _g = 0; _h = spaces;
-          for (_f = 0, i = _g; (_g <= _h ? i <= _h : i >= _h); (_g <= _h ? i += 1 : i -= 1), _f++) {
+          _d = []; _f = 0; _g = spaces;
+          for (_e = 0, i = _f; (_f <= _g ? i <= _g : i >= _g); (_f <= _g ? i += 1 : i -= 1), _e++) {
             _d.push(' ');
           }
           return _d;
@@ -83,9 +82,9 @@
   // unspecified, leave it out by padding with `null`.
   build_rules = function build_rules(rules) {
     var _a, _b, _c, _d, tuple;
-    _a = []; _b = rules;
-    for (_c = 0, _d = _b.length; _c < _d; _c++) {
-      tuple = _b[_c];
+    _a = []; _c = rules;
+    for (_b = 0, _d = _c.length; _b < _d; _b++) {
+      tuple = _c[_b];
       _a.push((function() {
         if (tuple.length < 3) {
           tuple.unshift(null);
@@ -115,13 +114,13 @@
     var _a, _b, _c, _d, _e, _f, arg, l, match, result;
     args = args.slice(0);
     result = [];
-    _a = args;
-    for (_b = 0, _c = _a.length; _b < _c; _b++) {
-      arg = _a[_b];
+    _b = args;
+    for (_a = 0, _c = _b.length; _a < _c; _a++) {
+      arg = _b[_a];
       if ((match = arg.match(MULTI_FLAG))) {
-        _d = match[1].split('');
-        for (_e = 0, _f = _d.length; _e < _f; _e++) {
-          l = _d[_e];
+        _e = match[1].split('');
+        for (_d = 0, _f = _e.length; _d < _f; _d++) {
+          l = _e[_d];
           result.push('-' + l);
         }
       } else {

lib/repl.js

@@ -1,15 +1,16 @@
 (function(){
-  var CoffeeScript, prompt, run;
+  var CoffeeScript, helpers, prompt, run;
   // A very simple Read-Eval-Print-Loop. Compiles one line at a time to JavaScript
   // and evaluates it. Good for simple tests, or poking around the **Node.js** API.
   // Using it looks like this:
   //     coffee> puts "$num bottles of beer" for num in [99..1]
   // Require the **coffee-script** module to get access to the compiler.
-  CoffeeScript = require('coffee-script');
+  CoffeeScript = require('./coffee-script');
+  helpers = require('./helpers').helpers;
   // Our prompt.
   prompt = 'coffee> ';
   // Quick alias for quitting the REPL.
-  process.mixin({
+  helpers.extend(global, {
     quit: function quit() {
       return process.exit(0);
     }

lib/rewriter.js

@@ -1,17 +1,25 @@
 (function(){
-  var BALANCED_PAIRS, EXPRESSION_CLOSE, EXPRESSION_END, EXPRESSION_START, IMPLICIT_BLOCK, IMPLICIT_CALL, IMPLICIT_END, IMPLICIT_FUNC, INVERSES, Rewriter, SINGLE_CLOSERS, SINGLE_LINERS, _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, include, pair;
-  var __hasProp = Object.prototype.hasOwnProperty;
-  // The CoffeeScript language has a decent amount of optional syntax,
-  // implicit syntax, and shorthand syntax. These things can greatly complicate a
-  // grammar and bloat the resulting parse table. Instead of making the parser
-  // handle it all, we take a series of passes over the token stream,
-  // using this **Rewriter** to convert shorthand into the unambiguous long form,
-  // add implicit indentation and parentheses, balance incorrect nestings, and
-  // generally clean things up.
+  var BALANCED_PAIRS, EXPRESSION_CLOSE, EXPRESSION_END, EXPRESSION_START, IMPLICIT_BLOCK, IMPLICIT_CALL, IMPLICIT_END, IMPLICIT_FUNC, INVERSES, Rewriter, SINGLE_CLOSERS, SINGLE_LINERS, _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, helpers, include, pair;
+  var __slice = Array.prototype.slice, __bind = function(func, obj, args) {
+    return function() {
+      return func.apply(obj || {}, args ? args.concat(__slice.call(arguments, 0)) : arguments);
+    };
+  }, __hasProp = Object.prototype.hasOwnProperty;
+  // The CoffeeScript language has a good deal of optional syntax, implicit syntax,
+  // and shorthand syntax. This can greatly complicate a grammar and bloat
+  // the resulting parse table. Instead of making the parser handle it all, we take
+  // a series of passes over the token stream, using this **Rewriter** to convert
+  // shorthand into the unambiguous long form, add implicit indentation and
+  // parentheses, balance incorrect nestings, and generally clean things up.
   // Set up exported variables for both Node.js and the browser.
-  if (!((typeof process !== "undefined" && process !== null))) {
+  if ((typeof process !== "undefined" && process !== null)) {
+    helpers = require('./helpers').helpers;
+  } else {
     this.exports = this;
+    helpers = this.helpers;
   }
+  // Import the helpers we need.
+  include = helpers.include;
   // The **Rewriter** class is used by the [Lexer](lexer.html), directly against
   // its internal array of tokens.
   exports.Rewriter = (function() {
@@ -53,8 +61,7 @@
     // Massage newlines and indentations so that comments don't have to be
     // correctly indented, or appear on a line of their own.
     Rewriter.prototype.adjust_comments = function adjust_comments() {
-      return this.scan_tokens((function(__this) {
-        var __func = function(prev, token, post, i) {
+      return this.scan_tokens(__bind(function(prev, token, post, i) {
           var after;
           if (!(token[0] === 'COMMENT')) {
             return 1;
@@ -70,18 +77,14 @@
           } else {
             return 1;
           }
-        };
-        return (function() {
-          return __func.apply(__this, arguments);
-        });
-      })(this));
+        }, this));
     };
     // Leading newlines would introduce an ambiguity in the grammar, so we
     // dispatch them here.
     Rewriter.prototype.remove_leading_newlines = function remove_leading_newlines() {
       var _a;
       _a = [];
-      while (this.tokens[0][0] === 'TERMINATOR') {
+      while (this.tokens[0] && this.tokens[0][0] === 'TERMINATOR') {
         _a.push(this.tokens.shift());
       }
       return _a;
@@ -89,18 +92,13 @@
     // Some blocks occur in the middle of expressions -- when we're expecting
     // this, remove their trailing newlines.
     Rewriter.prototype.remove_mid_expression_newlines = function remove_mid_expression_newlines() {
-      return this.scan_tokens((function(__this) {
-        var __func = function(prev, token, post, i) {
+      return this.scan_tokens(__bind(function(prev, token, post, i) {
           if (!(post && include(EXPRESSION_CLOSE, post[0]) && token[0] === 'TERMINATOR')) {
             return 1;
           }
           this.tokens.splice(i, 1);
           return 0;
-        };
-        return (function() {
-          return __func.apply(__this, arguments);
-        });
-      })(this));
+        }, this));
     };
     // The lexer has tagged the opening parenthesis of a method call, and the
     // opening bracket of an indexing operation. Match them with their paired
@@ -109,8 +107,7 @@
       var brackets, parens;
       parens = [0];
       brackets = [0];
-      return this.scan_tokens((function(__this) {
-        var __func = function(prev, token, post, i) {
+      return this.scan_tokens(__bind(function(prev, token, post, i) {
           var _a;
           if ((_a = token[0]) === 'CALL_START') {
             parens.push(0);
@@ -136,38 +133,47 @@
             }
           }
           return 1;
-        };
-        return (function() {
-          return __func.apply(__this, arguments);
-        });
-      })(this));
+        }, this));
     };
     // Methods may be optionally called without parentheses, for simple cases.
     // Insert the implicit parentheses here, so that the parser doesn't have to
     // deal with them.
     Rewriter.prototype.add_implicit_parentheses = function add_implicit_parentheses() {
-      var stack;
+      var calls, parens, stack, start_parens;
       stack = [0];
-      return this.scan_tokens((function(__this) {
-        var __func = function(prev, token, post, i) {
-          var _a, _b, _c, _d, idx, last, size, stack_pointer, tag, tmp;
+      calls = 0;
+      parens = 0;
+      start_parens = 0;
+      return this.scan_tokens(__bind(function(prev, token, post, i) {
+          var _a, _b, _c, idx, last, open, size, stack_pointer, tag, tmp;
           tag = token[0];
-          if (tag === 'INDENT') {
+          if (tag === 'CALL_START') {
+            calls += 1;
+          } else if (tag === 'CALL_END') {
+            calls -= 1;
+          } else if (tag === '(') {
+            parens += 1;
+          } else if (tag === ')') {
+            parens -= 1;
+          } else if (tag === 'INDENT') {
             stack.push(0);
-          }
-          if (tag === 'OUTDENT') {
+          } else if (tag === 'OUTDENT') {
             last = stack.pop();
             stack[stack.length - 1] += last;
           }
-          if (!(typeof post !== "undefined" && post !== null) || include(IMPLICIT_END, tag)) {
+          open = stack[stack.length - 1] > 0;
+          if (!(typeof post !== "undefined" && post !== null) || (start_parens > parens) || (parens === 0 && include(IMPLICIT_END, tag))) {
             if (tag === 'INDENT' && prev && include(IMPLICIT_BLOCK, prev[0])) {
               return 1;
             }
-            if (stack[stack.length - 1] > 0 || tag === 'INDENT') {
+            if (tag === 'OUTDENT' && token.generated) {
+              return 1;
+            }
+            if (open || tag === 'INDENT') {
               idx = tag === 'OUTDENT' ? i + 1 : i;
               stack_pointer = tag === 'INDENT' ? 2 : 1;
-              _c = 0; _d = stack[stack.length - stack_pointer];
-              for (_b = 0, tmp = _c; (_c <= _d ? tmp < _d : tmp > _d); (_c <= _d ? tmp += 1 : tmp -= 1), _b++) {
+              _b = 0; _c = stack[stack.length - stack_pointer];
+              for (_a = 0, tmp = _b; (_b <= _c ? tmp < _c : tmp > _c); (_b <= _c ? tmp += 1 : tmp -= 1), _a++) {
                 this.tokens.splice(idx, 0, ['CALL_END', ')', token[2]]);
               }
               size = stack[stack.length - stack_pointer] + 1;
@@ -178,23 +184,20 @@
           if (!(prev && include(IMPLICIT_FUNC, prev[0]) && include(IMPLICIT_CALL, tag))) {
             return 1;
           }
+          calls = 0;
+          start_parens = tag === '(' ? parens - 1 : parens;
           this.tokens.splice(i, 0, ['CALL_START', '(', token[2]]);
           stack[stack.length - 1] += 1;
           return 2;
-        };
-        return (function() {
-          return __func.apply(__this, arguments);
-        });
-      })(this));
+        }, this));
     };
     // Because our grammar is LALR(1), it can't handle some single-line
     // expressions that lack ending delimiters. The **Rewriter** adds the implicit
     // blocks, so it doesn't need to. ')' can close a single-line block,
     // but we need to make sure it's balanced.
     Rewriter.prototype.add_implicit_indentation = function add_implicit_indentation() {
-      return this.scan_tokens((function(__this) {
-        var __func = function(prev, token, post, i) {
-          var idx, insertion, parens, pre, starter, tok;
+      return this.scan_tokens(__bind(function(prev, token, post, i) {
+          var idx, insertion, outdent, parens, pre, starter, tok;
           if (!(include(SINGLE_LINERS, token[0]) && post[0] !== 'INDENT' && !(token[0] === 'ELSE' && post[0] === 'IF'))) {
             return 1;
           }
@@ -208,7 +211,9 @@
             pre = this.tokens[idx - 1];
             if ((!tok || (include(SINGLE_CLOSERS, tok[0]) && tok[1] !== ';') || (tok[0] === ')' && parens === 0)) && !(starter === 'ELSE' && tok[0] === 'ELSE')) {
               insertion = pre[0] === "," ? idx - 1 : idx;
-              this.tokens.splice(insertion, 0, ['OUTDENT', 2, token[2]]);
+              outdent = ['OUTDENT', 2, token[2]];
+              outdent.generated = true;
+              this.tokens.splice(insertion, 0, outdent);
               break;
             }
             if (tok[0] === '(') {
@@ -223,28 +228,27 @@
           }
           this.tokens.splice(i, 1);
           return 0;
-        };
-        return (function() {
-          return __func.apply(__this, arguments);
-        });
-      })(this));
+        }, this));
     };
     // Ensure that all listed pairs of tokens are correctly balanced throughout
     // the course of the token stream.
     Rewriter.prototype.ensure_balance = function ensure_balance(pairs) {
-      var _a, _b, key, levels, unclosed, value;
+      var _a, _b, key, levels, line, open, open_line, unclosed, value;
       levels = {};
-      this.scan_tokens((function(__this) {
-        var __func = function(prev, token, post, i) {
+      open_line = {};
+      this.scan_tokens(__bind(function(prev, token, post, i) {
           var _a, _b, _c, _d, close, open, pair;
-          _a = pairs;
-          for (_b = 0, _c = _a.length; _b < _c; _b++) {
-            pair = _a[_b];
+          _b = pairs;
+          for (_a = 0, _c = _b.length; _a < _c; _a++) {
+            pair = _b[_a];
             _d = pair;
             open = _d[0];
             close = _d[1];
             levels[open] = levels[open] || 0;
             if (token[0] === open) {
+              if (levels[open] === 0) {
+                open_line[open] = token[2];
+              }
               levels[open] += 1;
             }
             if (token[0] === close) {
@@ -255,23 +259,19 @@
             }
           }
           return 1;
-        };
-        return (function() {
-          return __func.apply(__this, arguments);
-        });
-      })(this));
+        }, this));
       unclosed = (function() {
         _a = []; _b = levels;
         for (key in _b) { if (__hasProp.call(_b, key)) {
           value = _b[key];
-          if (value > 0) {
-            _a.push(key);
-          }
+          value > 0 ? _a.push(key) : null;
         }}
         return _a;
       }).call(this);
       if (unclosed.length) {
-        throw new Error("unclosed " + (unclosed[0]));
+        open = unclosed[0];
+        line = open_line[open] + 1;
+        throw new Error("unclosed " + open + " on line " + line);
       }
     };
     // We'd like to support syntax like this:
@@ -280,10 +280,10 @@
     // In order to accomplish this, move outdents that follow closing parens
     // inwards, safely. The steps to accomplish this are:
     // 1. Check that all paired tokens are balanced and in order.
-    // 2. Rewrite the stream with a stack: if you see an '(' or INDENT, add it
-    //    to the stack. If you see an ')' or OUTDENT, pop the stack and replace
+    // 2. Rewrite the stream with a stack: if you see an `EXPRESSION_START`, add it
+    //    to the stack. If you see an `EXPRESSION_END`, pop the stack and replace
     //    it with the inverse of what we've just popped.
-    // 3. Keep track of "debt" for tokens that we fake, to make sure we end
+    // 3. Keep track of "debt" for tokens that we manufacture, to make sure we end
     //    up balanced in the end.
     Rewriter.prototype.rewrite_closing_parens = function rewrite_closing_parens() {
       var _a, debt, key, stack, val;
@@ -292,10 +292,9 @@
       _a = INVERSES;
       for (key in _a) { if (__hasProp.call(_a, key)) {
         val = _a[key];
-        ((debt[key] = 0));
+        (debt[key] = 0);
       }}
-      return this.scan_tokens((function(__this) {
-        var __func = function(prev, token, post, i) {
+      return this.scan_tokens(__bind(function(prev, token, post, i) {
           var inv, match, mtag, tag;
           tag = token[0];
           inv = INVERSES[token[0]];
@@ -321,11 +320,7 @@
           } else {
             return 1;
           }
-        };
-        return (function() {
-          return __func.apply(__this, arguments);
-        });
-      })(this));
+        }, this));
     };
     return Rewriter;
   }).call(this);
@@ -336,26 +331,26 @@
   // The inverse mappings of `BALANCED_PAIRS` we're trying to fix up, so we can
   // look things up from either end.
   INVERSES = {};
-  _a = BALANCED_PAIRS;
-  for (_b = 0, _c = _a.length; _b < _c; _b++) {
-    pair = _a[_b];
+  _b = BALANCED_PAIRS;
+  for (_a = 0, _c = _b.length; _a < _c; _a++) {
+    pair = _b[_a];
     INVERSES[pair[0]] = pair[1];
     INVERSES[pair[1]] = pair[0];
   }
   // The tokens that signal the start of a balanced pair.
   EXPRESSION_START = (function() {
-    _d = []; _e = BALANCED_PAIRS;
-    for (_f = 0, _g = _e.length; _f < _g; _f++) {
-      pair = _e[_f];
+    _d = []; _f = BALANCED_PAIRS;
+    for (_e = 0, _g = _f.length; _e < _g; _e++) {
+      pair = _f[_e];
       _d.push(pair[0]);
     }
     return _d;
   }).call(this);
   // The tokens that signal the end of a balanced pair.
   EXPRESSION_END = (function() {
-    _h = []; _i = BALANCED_PAIRS;
-    for (_j = 0, _k = _i.length; _j < _k; _j++) {
-      pair = _i[_j];
+    _h = []; _j = BALANCED_PAIRS;
+    for (_i = 0, _k = _j.length; _i < _k; _i++) {
+      pair = _j[_i];
       _h.push(pair[1]);
     }
     return _h;
@@ -363,9 +358,9 @@
   // Tokens that indicate the close of a clause of an expression.
   EXPRESSION_CLOSE = ['CATCH', 'WHEN', 'ELSE', 'FINALLY'].concat(EXPRESSION_END);
   // Tokens that, if followed by an `IMPLICIT_CALL`, indicate a function invocation.
-  IMPLICIT_FUNC = ['IDENTIFIER', 'SUPER', ')', 'CALL_END', ']', 'INDEX_END'];
+  IMPLICIT_FUNC = ['IDENTIFIER', 'SUPER', ')', 'CALL_END', ']', 'INDEX_END', '<-'];
   // If preceded by an `IMPLICIT_FUNC`, indicates a function invocation.
-  IMPLICIT_CALL = ['IDENTIFIER', 'NUMBER', 'STRING', 'JS', 'REGEX', 'NEW', 'PARAM_START', 'TRY', 'DELETE', 'TYPEOF', 'SWITCH', 'TRUE', 'FALSE', 'YES', 'NO', 'ON', 'OFF', '!', '!!', 'NOT', '@', '->', '=>', '[', '(', '{'];
+  IMPLICIT_CALL = ['IDENTIFIER', 'NUMBER', 'STRING', 'JS', 'REGEX', 'NEW', 'PARAM_START', 'TRY', 'DELETE', 'TYPEOF', 'SWITCH', 'EXTENSION', 'TRUE', 'FALSE', 'YES', 'NO', 'ON', 'OFF', '!', '!!', 'NOT', 'THIS', 'NULL', '@', '->', '=>', '[', '(', '{'];
   // Tokens indicating that the implicit call must enclose a block of expressions.
   IMPLICIT_BLOCK = ['->', '=>', '{', '[', ','];
   // Tokens that always mark the end of an implicit call for single-liners.
@@ -374,10 +369,4 @@
   // The grammar can't disambiguate them, so we insert the implicit indentation.
   SINGLE_LINERS = ['ELSE', "->", "=>", 'TRY', 'FINALLY', 'THEN'];
   SINGLE_CLOSERS = ['TERMINATOR', 'CATCH', 'FINALLY', 'ELSE', 'OUTDENT', 'LEADING_WHEN'];
-  // Utility Functions
-  // -----------------
-  // Does a list include a value?
-  include = function include(list, value) {
-    return list.indexOf(value) >= 0;
-  };
 })();

lib/scope.js

@@ -19,9 +19,16 @@
       this.expressions = _a[1];
       this.method = _a[2];
       this.variables = {};
-      this.temp_var = this.parent ? this.parent.temp_var : '_a';
+      if (this.parent) {
+        this.temp_var = this.parent.temp_var;
+      } else {
+        Scope.root = this;
+        this.temp_var = '_a';
+      }
       return this;
     };
+    // The top-level **Scope** object.
+    Scope.root = null;
     // Initialize a scope with its parent, for lookups up the chain,
     // as well as a reference to the **Expressions** node is belongs to, which is
     // where it should declare its variables, and a reference to the function that
@@ -35,10 +42,23 @@
       this.variables[name] = 'var';
       return false;
     };
+    // Test variables and return true the first time fn(v, k) returns true
+    Scope.prototype.any = function any(fn) {
+      var _a, k, v;
+      _a = this.variables;
+      for (v in _a) { if (__hasProp.call(_a, v)) {
+        k = _a[v];
+        if (fn(v, k)) {
+          return true;
+        }
+      }}
+      return false;
+    };
     // Reserve a variable name as originating from a function parameter for this
     // scope. No `var` required for internal references.
     Scope.prototype.parameter = function parameter(name) {
-      return this.variables[name] = 'param';
+      this.variables[name] = 'param';
+      return this.variables[name];
     };
     // Just check to see if a variable has already been declared, without reserving.
     Scope.prototype.check = function check(name) {
@@ -60,24 +80,26 @@
     };
     // Ensure that an assignment is made at the top of this scope
     // (or at the top-level scope, if requested).
-    Scope.prototype.assign = function assign(name, value, top_level) {
-      if (top_level && this.parent) {
-        return this.parent.assign(name, value, top_level);
-      }
-      return this.variables[name] = {
+    Scope.prototype.assign = function assign(name, value) {
+      this.variables[name] = {
         value: value,
         assigned: true
       };
+      return this.variables[name];
     };
     // Does this scope reference any variables that need to be declared in the
     // given function body?
     Scope.prototype.has_declarations = function has_declarations(body) {
-      return body === this.expressions && this.declared_variables().length;
+      return body === this.expressions && this.any(function(k, val) {
+        return val === 'var';
+      });
     };
     // Does this scope reference any assignments that need to be declared at the
     // top of the given function body?
     Scope.prototype.has_assignments = function has_assignments(body) {
-      return body === this.expressions && this.assigned_variables().length;
+      return body === this.expressions && this.any(function(k, val) {
+        return val.assigned;
+      });
     };
     // Return the list of variables first declared in this scope.
     Scope.prototype.declared_variables = function declared_variables() {
@@ -86,9 +108,7 @@
         _a = []; _b = this.variables;
         for (key in _b) { if (__hasProp.call(_b, key)) {
           val = _b[key];
-          if (val === 'var') {
-            _a.push(key);
-          }
+          val === 'var' ? _a.push(key) : null;
         }}
         return _a;
       }).call(this).sort();
@@ -100,9 +120,7 @@
       _a = []; _b = this.variables;
       for (key in _b) { if (__hasProp.call(_b, key)) {
         val = _b[key];
-        if (val.assigned) {
-          _a.push(key + " = " + (val.value));
-        }
+        val.assigned ? _a.push("" + key + " = " + (val.value)) : null;
       }}
       return _a;
     };

lib/utilities.js

@@ -0,0 +1,12 @@
+(function(){
+  if (!((typeof process !== "undefined" && process !== null))) {
+    this.exports = this;
+  }
+  exports.utilities = {
+    extend: "function(child, parent) {\n    var ctor = function(){ };\n    ctor.prototype = parent.prototype;\n    child.__superClass__ = parent.prototype;\n    child.prototype = new ctor();\n    child.prototype.constructor = child;\n  }",
+    bind: "function(func, obj, args) {\n    return function() {\n      return func.apply(obj || {}, args ? args.concat(__slice.call(arguments, 0)) : arguments);\n    };\n  }",
+    range: "function(array, from, to, exclusive) {\n    return [\n      (from < 0 ? from + array.length : from || 0),\n      (to < 0 ? to + array.length : to || array.length) + (exclusive ? 0 : 1)\n    ];\n  }",
+    hasProp: 'Object.prototype.hasOwnProperty',
+    slice: 'Array.prototype.slice'
+  };
+})();

package.json

@@ -3,5 +3,5 @@
     "description":  "Unfancy JavaScript",
     "keywords":     ["javascript", "language"],
     "author":       "Jeremy Ashkenas",
-    "version":      "0.5.5"
+    "version":      "0.6.0"
 }

src/cake.coffee

@@ -9,8 +9,9 @@
 # External dependencies.
 fs:           require 'fs'
 path:         require 'path'
-optparse:     require 'optparse'
-CoffeeScript: require 'coffee-script'
+helpers:      require('./helpers').helpers
+optparse:     require './optparse'
+CoffeeScript: require './coffee-script'
 
 # Keep track of the list of defined tasks, the accepted options, and so on.
 tasks: {}
@@ -19,7 +20,7 @@ switches: []
 oparse: null
 
 # Mixin the top-level Cake functions for Cakefiles to use directly.
-process.mixin {
+helpers.extend global, {
 
   # Define a Cake task with a short name, a sentence description,
   # and the function to run as the action itself.

src/coffee-script.coffee

@@ -8,21 +8,29 @@
 
 # Set up dependencies correctly for both the server and the browser.
 if process?
-  process.mixin require 'nodes'
   path:         require 'path'
-  lexer:   new (require('lexer').Lexer)()
-  parser:       require('parser').parser
+  Lexer:        require('./lexer').Lexer
+  parser:       require('./parser').parser
+  helpers:      require('./helpers').helpers
+  helpers.extend global, require './nodes'
+  if require.registerExtension
+    require.registerExtension '.coffee', (content) -> compile content
 else
-  lexer: new Lexer()
-  parser: exports.parser
   this.exports: this.CoffeeScript: {}
+  Lexer:        this.Lexer
+  parser:       this.parser
+  helpers:      this.helpers
 
 # The current CoffeeScript version number.
-exports.VERSION: '0.5.5'
+exports.VERSION: '0.6.0'
+
+# Instantiate a Lexer for our use here.
+lexer: new Lexer()
 
 # Compile a string of CoffeeScript code to JavaScript, using the Coffee/Jison
 # compiler.
-exports.compile: (code, options) ->
+exports.compile: compile: (code, options) ->
+  options: or {}
   try
     (parser.parse lexer.tokenize code).compile options
   catch err
@@ -41,10 +49,18 @@ exports.nodes: (code) ->
 
 # Compile and execute a string of CoffeeScript (on the server), correctly
 # setting `__filename`, `__dirname`, and relative `require()`.
-exports.run: (code, options) ->
+exports.run: ((code, options) ->
   module.filename: __filename: options.source
-  __dirname: path.dirname __filename
+  __dirname: path.dirname(__filename)
   eval exports.compile code, options
+)
+
+# Extend CoffeeScript with a custom language extension. It should hook in to
+# the **Lexer** (as a peer of any of the lexer's tokenizing methods), and
+# push a token on to the stack that contains a **Node** as the value (as a
+# peer of the nodes in [nodes.coffee](nodes.html)).
+exports.extend: (func) ->
+  Lexer.extensions.push func
 
 # The real Lexer produces a generic stream of tokens. This object provides a
 # thin wrapper around it, compatible with the Jison API. We can then pass it
@@ -52,7 +68,7 @@ exports.run: (code, options) ->
 parser.lexer: {
   lex: ->
     token: @tokens[@pos] or [""]
-    @pos += 1
+    @pos: + 1
     this.yylineno: token[2]
     this.yytext:   token[1]
     token[0]

src/command.coffee

@@ -7,8 +7,8 @@
 # External dependencies.
 fs:           require 'fs'
 path:         require 'path'
-optparse:     require 'optparse'
-CoffeeScript: require 'coffee-script'
+optparse:     require './optparse'
+CoffeeScript: require './coffee-script'
 
 # The help banner that is printed when `coffee` is called without arguments.
 BANNER: '''
@@ -47,7 +47,7 @@ exports.run: ->
   parse_options()
   return usage()                              if options.help
   return version()                            if options.version
-  return require 'repl'                       if options.interactive
+  return require './repl'                     if options.interactive
   return compile_stdio()                      if options.stdio
   return compile_script 'console', sources[0] if options.eval
   return usage()                              unless sources.length
@@ -94,7 +94,7 @@ compile_stdio: ->
   code: ''
   process.stdio.open()
   process.stdio.addListener 'data', (string) ->
-    code += string if string
+    code: + string if string
   process.stdio.addListener 'close', ->
     compile_script 'stdio', code
 

src/grammar.coffee

@@ -53,8 +53,8 @@ grammar: {
   # The **Root** is the top-level node in the syntax tree. Since we parse bottom-up,
   # all parsing must end here.
   Root: [
-    o "",                                  -> new Expressions()
-    o "TERMINATOR",                        -> new Expressions()
+    o "",                                       -> new Expressions()
+    o "TERMINATOR",                             -> new Expressions()
     o "Expressions"
     o "Block TERMINATOR"
   ]
@@ -62,8 +62,8 @@ grammar: {
   # Any list of expressions or method body, seperated by line breaks or
   # semicolons.
   Expressions: [
-    o "Expression",                        -> Expressions.wrap [$1]
-    o "Expressions TERMINATOR Expression", -> $1.push $3
+    o "Expression",                             -> Expressions.wrap [$1]
+    o "Expressions TERMINATOR Expression",      -> $1.push $3
     o "Expressions TERMINATOR"
   ]
 
@@ -74,6 +74,7 @@ grammar: {
   Expression: [
     o "Value"
     o "Call"
+    o "Curry"
     o "Code"
     o "Operation"
     o "Assign"
@@ -89,6 +90,7 @@ grammar: {
     o "Splat"
     o "Existence"
     o "Comment"
+    o "Extension"
   ]
 
   # A an indented block of expressions. Note that the [Rewriter](rewriter.html)
@@ -97,6 +99,7 @@ grammar: {
   Block: [
     o "INDENT Expressions OUTDENT",             -> $2
     o "INDENT OUTDENT",                         -> new Expressions()
+    o "TERMINATOR Comment",                     -> Expressions.wrap [$2]
   ]
 
   # A literal identifier, a variable name or property.
@@ -129,7 +132,7 @@ grammar: {
 
   # Assignment of a variable, property, or index to a value.
   Assign: [
-    o "Value ASSIGN Expression",                -> new AssignNode $1, $3
+    o "Assignable ASSIGN Expression",           -> new AssignNode $1, $3
   ]
 
   # Assignment when it happens within an object literal. The difference from
@@ -192,18 +195,30 @@ grammar: {
     o "Expression . . .",                       -> new SplatNode $1
   ]
 
+  # Variables and properties that can be assigned to.
+  SimpleAssignable: [
+    o "Identifier",                             -> new ValueNode $1
+    o "Value Accessor",                         -> $1.push $2
+    o "Invocation Accessor",                    -> new ValueNode $1, [$2]
+    o "ThisProperty"
+  ]
+
+  # Everything that can be assigned to.
+  Assignable: [
+    o "SimpleAssignable"
+    o "Array",                                  -> new ValueNode $1
+    o "Object",                                 -> new ValueNode $1
+  ]
+
   # The types of things that can be treated as values -- assigned to, invoked
   # as functions, indexed into, named as a class, etc.
   Value: [
-    o "Identifier",                             -> new ValueNode $1
+    o "Assignable"
     o "Literal",                                -> new ValueNode $1
-    o "Array",                                  -> new ValueNode $1
-    o "Object",                                 -> new ValueNode $1
     o "Parenthetical",                          -> new ValueNode $1
     o "Range",                                  -> new ValueNode $1
     o "This"
-    o "Value Accessor",                         -> $1.push $2
-    o "Invocation Accessor",                    -> new ValueNode $1, [$2]
+    o "NULL",                                   -> new ValueNode new LiteralNode 'null'
   ]
 
   # The general group of accessors into an object, by property, by prototype
@@ -211,6 +226,7 @@ grammar: {
   Accessor: [
     o "PROPERTY_ACCESS Identifier",             -> new AccessorNode $2
     o "PROTOTYPE_ACCESS Identifier",            -> new AccessorNode $2, 'prototype'
+    o "::",                                     -> new AccessorNode(new LiteralNode('prototype'))
     o "SOAK_ACCESS Identifier",                 -> new AccessorNode $2, 'soak'
     o "Index"
     o "Slice",                                  -> new SliceNode $1
@@ -226,15 +242,8 @@ grammar: {
   Object: [
     o "{ AssignList }",                         -> new ObjectNode $2
     o "{ IndentedAssignList }",                 -> new ObjectNode $2
-  ]
-
-  # Class definitions have optional bodies of prototype property assignments,
-  # and optional references to the superclass.
-  Class: [
-    o "CLASS Value",                            -> new ClassNode $2
-    o "CLASS Value EXTENDS Value",              -> new ClassNode $2, $4
-    o "CLASS Value IndentedAssignList",         -> new ClassNode $2, null, $3
-    o "CLASS Value EXTENDS Value IndentedAssignList", -> new ClassNode $2, $4, $5
+    o "{ AssignList , }",                       -> new ObjectNode $2
+    o "{ IndentedAssignList , }",               -> new ObjectNode $2
   ]
 
   # Assignment of properties within an object literal can be separated by
@@ -250,6 +259,29 @@ grammar: {
   # An **AssignList** within a block indentation.
   IndentedAssignList: [
     o "INDENT AssignList OUTDENT",              -> $2
+    o "INDENT AssignList , OUTDENT",            -> $2
+  ]
+
+  # Class definitions have optional bodies of prototype property assignments,
+  # and optional references to the superclass.
+  Class: [
+    o "CLASS SimpleAssignable",                 -> new ClassNode $2
+    o "CLASS SimpleAssignable EXTENDS Value",   -> new ClassNode $2, $4
+    o "CLASS SimpleAssignable INDENT ClassBody OUTDENT", -> new ClassNode $2, null, $4
+    o "CLASS SimpleAssignable EXTENDS Value INDENT ClassBody OUTDENT", -> new ClassNode $2, $4, $6
+  ]
+
+  # Assignments that can happen directly inside a class declaration.
+  ClassAssign: [
+    o "AssignObj",                              -> $1
+    o "ThisProperty ASSIGN Expression",         -> new AssignNode new ValueNode($1), $3, 'this'
+  ]
+
+  # A list of assignments to a class.
+  ClassBody: [
+    o "",                                       -> []
+    o "ClassAssign",                            -> [$1]
+    o "ClassBody TERMINATOR ClassAssign", -> $1.concat $3
   ]
 
   # The three flavors of function call: normal, object instantiation with `new`,
@@ -260,10 +292,15 @@ grammar: {
     o "Super"
   ]
 
+  # Binds a function call to a context and/or arguments.
+  Curry: [
+    o "Value <- Arguments",                     -> new CurryNode $1, $3
+  ]
+
   # Extending an object by setting its prototype chain to reference a parent
   # object.
   Extends: [
-    o "Value EXTENDS Value",                    -> new ExtendsNode $1, $3
+    o "SimpleAssignable EXTENDS Value",         -> new ExtendsNode $1, $3
   ]
 
   # Ordinary function invocation, or a chained series of calls.
@@ -275,16 +312,23 @@ grammar: {
   # The list of arguments to a function call.
   Arguments: [
     o "CALL_START ArgList CALL_END",            -> $2
+    o "CALL_START ArgList , CALL_END",          -> $2
   ]
 
   # Calling super.
   Super: [
     o "SUPER CALL_START ArgList CALL_END",      -> new CallNode 'super', $3
+    o "SUPER CALL_START ArgList , CALL_END",    -> new CallNode 'super', $3
   ]
 
-  # A reference to the *this* current object, either naked or to a property.
+  # A reference to the *this* current object.
   This: [
+    o "THIS",                                   -> new ValueNode new LiteralNode 'this'
     o "@",                                      -> new ValueNode new LiteralNode 'this'
+  ]
+
+  # A reference to a property on *this*.
+  ThisProperty: [
     o "@ Identifier",                           -> new ValueNode new LiteralNode('this'), [new AccessorNode($2)]
   ]
 
@@ -303,6 +347,7 @@ grammar: {
   # The array literal.
   Array: [
     o "[ ArgList ]",                            -> new ArrayNode $2
+    o "[ ArgList , ]",                          -> new ArrayNode $2
   ]
 
   # The **ArgList** is both the list of objects passed into a function call,
@@ -317,6 +362,7 @@ grammar: {
     o "ArgList , TERMINATOR Expression",        -> $1.concat [$4]
     o "ArgList , INDENT Expression",            -> $1.concat [$4]
     o "ArgList OUTDENT"
+    o "ArgList , OUTDENT"
   ]
 
   # Just simple, comma-separated, required arguments (no fancy syntax). We need
@@ -353,6 +399,12 @@ grammar: {
     o "( Expression )",                         -> new ParentheticalNode $2
   ]
 
+  # A language extension to CoffeeScript from the outside. We simply pass
+  # it through unaltered.
+  Extension: [
+    o "EXTENSION",                              -> yytext
+  ]
+
   # The condition portion of a while loop.
   WhileSource: [
     o "WHILE Expression",                       -> new WhileNode $2
@@ -363,7 +415,7 @@ grammar: {
   # or postfix, with a single expression. There is no do..while.
   While: [
     o "WhileSource Block",                      -> $1.add_body $2
-    o "Expression WhileSource",                 -> $2.add_body $1
+    o "Expression WhileSource",                 -> $2.add_body Expressions.wrap [$1]
   ]
 
   # Array, object, and range comprehensions, at the most generic level.
@@ -383,13 +435,16 @@ grammar: {
   ]
 
   # The source of a comprehension is an array or object with an optional filter
-  # clause. If it's an array comprehension, you can also choose to step throug
+  # clause. If it's an array comprehension, you can also choose to step through
   # in fixed-size increments.
   ForSource: [
-    o "IN Expression",                          -> {source:   $2}
-    o "OF Expression",                          -> {source:   $2, object: true}
-    o "ForSource WHEN Expression",              -> $1.filter: $3; $1
-    o "ForSource BY Expression",                -> $1.step:   $3; $1
+    o "IN Expression",                               -> {source: $2}
+    o "OF Expression",                               -> {source: $2, object: true}
+    o "IN Expression WHEN Expression",               -> {source: $2, filter: $4}
+    o "OF Expression WHEN Expression",               -> {source: $2, filter: $4, object: true}
+    o "IN Expression BY Expression",                 -> {source: $2, step:   $4}
+    o "IN Expression WHEN Expression BY Expression", -> {source: $2, filter: $4; step:   $6}
+    o "IN Expression BY Expression WHEN Expression", -> {source: $2, step:   $4, filter: $6}
   ]
 
   # The CoffeeScript switch/when/else block replaces the JavaScript
@@ -408,9 +463,9 @@ grammar: {
 
   # An individual **When** clause, with action.
   When: [
-    o "LEADING_WHEN SimpleArgs Block",          -> new IfNode $2, $3, null, {statement: true}
+    o "LEADING_WHEN SimpleArgs Block",            -> new IfNode $2, $3, null, {statement: true}
     o "LEADING_WHEN SimpleArgs Block TERMINATOR", -> new IfNode $2, $3, null, {statement: true}
-    o "Comment TERMINATOR When",                -> $3.comment: $1; $3
+    o "Comment TERMINATOR When",                  -> $3.comment: $1; $3
   ]
 
   # The most basic form of *if* is a condition and an action. The following
@@ -451,7 +506,6 @@ grammar: {
     o "!! Expression",                          -> new OpNode '!!', $2
     o("- Expression",                           (-> new OpNode('-', $2)), {prec: 'UMINUS'})
     o("+ Expression",                           (-> new OpNode('+', $2)), {prec: 'UPLUS'})
-    o "NOT Expression",                         -> new OpNode 'not', $2
     o "~ Expression",                           -> new OpNode '~', $2
     o "-- Expression",                          -> new OpNode '--', $2
     o "++ Expression",                          -> new OpNode '++', $2
@@ -481,13 +535,9 @@ grammar: {
 
     o "Expression == Expression",               -> new OpNode '==', $1, $3
     o "Expression != Expression",               -> new OpNode '!=', $1, $3
-    o "Expression IS Expression",               -> new OpNode 'is', $1, $3
-    o "Expression ISNT Expression",             -> new OpNode 'isnt', $1, $3
 
     o "Expression && Expression",               -> new OpNode '&&', $1, $3
     o "Expression || Expression",               -> new OpNode '||', $1, $3
-    o "Expression AND Expression",              -> new OpNode 'and', $1, $3
-    o "Expression OR Expression",               -> new OpNode 'or', $1, $3
     o "Expression ? Expression",                -> new OpNode '?', $1, $3
 
     o "Expression -= Expression",               -> new OpNode '-=', $1, $3
@@ -518,15 +568,15 @@ grammar: {
 #     (2 + 3) * 4
 operators: [
   ["left",      '?']
-  ["nonassoc",  'UMINUS', 'UPLUS', 'NOT', '!', '!!', '~', '++', '--']
+  ["nonassoc",  'UMINUS', 'UPLUS', '!', '!!', '~', '++', '--']
   ["left",      '*', '/', '%']
   ["left",      '+', '-']
   ["left",      '<<', '>>', '>>>']
   ["left",      '&', '|', '^']
   ["left",      '<=', '<', '>', '>=']
   ["right",     'DELETE', 'INSTANCEOF', 'TYPEOF']
-  ["left",      '==', '!=', 'IS', 'ISNT']
-  ["left",      '&&', '||', 'AND', 'OR']
+  ["left",      '==', '!=']
+  ["left",      '&&', '||']
   ["right",     '-=', '+=', '/=', '*=', '%=', '||=', '&&=', '?=']
   ["left",      '.']
   ["right",     'INDENT']
@@ -535,7 +585,7 @@ operators: [
   ["right",     'FOR', 'NEW', 'SUPER', 'CLASS']
   ["left",      'EXTENDS']
   ["right",     'ASSIGN', 'RETURN']
-  ["right",     '->', '=>', 'UNLESS', 'IF', 'ELSE', 'WHILE']
+  ["right",     '->', '=>', '<-', 'UNLESS', 'IF', 'ELSE', 'WHILE']
 ]
 
 # Wrapping Up

src/helpers.coffee

@@ -0,0 +1,87 @@
+# This file contains the common helper functions that we'd like to share among
+# the **Lexer**, **Rewriter**, and the **Nodes**. Merge objects, flatten
+# arrays, count characters, that sort of thing.
+
+# Set up exported variables for both **Node.js** and the browser.
+this.exports: this unless process?
+helpers: exports.helpers: {}
+
+# Does a list include a value?
+helpers.include: include: (list, value) ->
+  list.indexOf(value) >= 0
+
+# Peek at the beginning of a given string to see if it matches a sequence.
+helpers.starts: starts: (string, literal, start) ->
+  string.substring(start, (start or 0) + literal.length) is literal
+
+# Trim out all falsy values from an array.
+helpers.compact: compact: (array) -> item for item in array when item
+
+# Count the number of occurences of a character in a string.
+helpers.count: count: (string, letter) ->
+  num: 0
+  pos: string.indexOf(letter)
+  while pos isnt -1
+    num: + 1
+    pos: string.indexOf(letter, pos + 1)
+  num
+
+# Merge objects, returning a fresh copy with attributes from both sides.
+# Used every time `BaseNode#compile` is called, to allow properties in the
+# options hash to propagate down the tree without polluting other branches.
+helpers.merge: merge: (options, overrides) ->
+  fresh: {}
+  (fresh[key]: val) for key, val of options
+  (fresh[key]: val) for key, val of overrides if overrides
+  fresh
+
+# Extend a source object with the properties of another object (shallow copy).
+# We use this to simulate Node's deprecated `process.mixin`
+helpers.extend: extend: (object, properties) ->
+  (object[key]: val) for key, val of properties
+
+# Return a completely flattened version of an array. Handy for getting a
+# list of `children` from the nodes.
+helpers.flatten: flatten: (array) ->
+  memo: []
+  for item in array
+    if item instanceof Array then memo: memo.concat(item) else memo.push(item)
+  memo
+
+# Delete a key from an object, returning the value. Useful when a node is
+# looking for a particular method in an options hash.
+helpers.del: del: (obj, key) ->
+  val: obj[key]
+  delete obj[key]
+  val
+
+# Matches a balanced group such as a single or double-quoted string. Pass in
+# a series of delimiters, all of which must be nested correctly within the
+# contents of the string. This method allows us to have strings within
+# interpolations within strings, ad infinitum.
+helpers.balanced_string: balanced_string: (str, delimited, options) ->
+  options: or {}
+  slash: delimited[0][0] is '/'
+  levels: []
+  i: 0
+  while i < str.length
+    if levels.length and starts str, '\\', i
+      i: + 1
+    else
+      for pair in delimited
+        [open, close]: pair
+        if levels.length and starts(str, close, i) and levels[levels.length - 1] is pair
+          levels.pop()
+          i: + close.length - 1
+          i: + 1 unless levels.length
+          break
+        else if starts str, open, i
+          levels.push(pair)
+          i: + open.length - 1
+          break
+    break if not levels.length or slash and starts str, '\n', i
+    i: + 1
+  if levels.length
+    return false if slash
+    throw new Error "SyntaxError: Unterminated ${levels.pop()[0]} starting on line ${@line + 1}"
+  if not i then false else str.substring(0, i)

src/lexer.coffee

@@ -10,9 +10,18 @@
 # Set up the Lexer for both Node.js and the browser, depending on where we are.
 if process?
   Rewriter: require('./rewriter').Rewriter
+  helpers:  require('./helpers').helpers
 else
   this.exports: this
-  Rewriter: this.Rewriter
+  Rewriter:     this.Rewriter
+  helpers:      this.helpers
+
+# Import the helpers we need.
+include:          helpers.include
+count:            helpers.count
+starts:           helpers.starts
+compact:          helpers.compact
+balanced_string:  helpers.balanced_string
 
 # The Lexer Class
 # ---------------
@@ -35,6 +44,7 @@ exports.Lexer: class Lexer
   # Before returning the token stream, run it through the [Rewriter](rewriter.html)
   # unless explicitly asked not to.
   tokenize: (code, options) ->
+    code     : code.replace /(\r|\s+$)/g, ''
     o        : options or {}
     @code    : code         # The remainder of the source code.
     @i       : 0            # Current character position we're parsing.
@@ -43,7 +53,7 @@ exports.Lexer: class Lexer
     @indents : []           # The stack of all current indentation levels.
     @tokens  : []           # Stream of parsed tokens in the form ['TYPE', value, line]
     while @i < @code.length
-      @chunk: @code.slice(@i)
+      @chunk: @code.slice @i
       @extract_next_token()
     @close_indentation()
     return @tokens if o.rewrite is off
@@ -53,6 +63,7 @@ exports.Lexer: class Lexer
   # short-circuiting if any of them succeed. Their order determines precedence:
   # `@literal_token` is the fallback catch-all.
   extract_next_token: ->
+    return if @extension_token()
     return if @identifier_token()
     return if @number_token()
     return if @heredoc_token()
@@ -67,6 +78,13 @@ exports.Lexer: class Lexer
   # Tokenizers
   # ----------
 
+  # Language extensions get the highest priority, first chance to tag tokens
+  # as something else.
+  extension_token: ->
+    for extension in Lexer.extensions
+      return true if extension.call this
+    false
+
   # Matches identifying literals: variables, keywords, method names, etc.
   # Check to ensure that JavaScript reserved words aren't being used as
   # identifiers. Because CoffeeScript reserves a handful of keywords that are
@@ -76,76 +94,92 @@ exports.Lexer: class Lexer
   identifier_token: ->
     return false unless id: @match IDENTIFIER, 1
     @name_access_type()
+    accessed: include ACCESSORS, @tag 0
     tag: 'IDENTIFIER'
-    tag: id.toUpperCase() if include(KEYWORDS, id) and
-      not (include(ACCESSORS, @tag(0)) and not @prev().spaced)
-    @identifier_error id  if include RESERVED, id
-    tag: 'LEADING_WHEN'   if tag is 'WHEN' and include BEFORE_WHEN, @tag()
-    @token(tag, id)
-    @i += id.length
+    tag: id.toUpperCase()     if not accessed and include(KEYWORDS, id)
+    @identifier_error id      if include RESERVED, id
+    tag: 'LEADING_WHEN'       if tag is 'WHEN' and include LINE_BREAK, @tag()
+    @i: + id.length
+    if not accessed
+      tag: id: CONVERSIONS[id]         if include COFFEE_ALIASES, id
+      return @tag_half_assignment tag  if @prev() and @prev()[0] is 'ASSIGN' and include HALF_ASSIGNMENTS, tag
+    @token tag, id
     true
 
   # Matches numbers, including decimals, hex, and exponential notation.
   number_token: ->
     return false unless number: @match NUMBER, 1
     @token 'NUMBER', number
-    @i += number.length
+    @i: + number.length
     true
 
   # Matches strings, including multi-line strings. Ensures that quotation marks
   # are balanced within the string's contents, and within nested interpolations.
   string_token: ->
     return false unless starts(@chunk, '"') or starts(@chunk, "'")
-    string: @balanced_token ['"', '"'], ['${', '}']
-    string: @balanced_token ["'", "'"] unless string
-    return false unless string
+    return false unless string:
+      @balanced_token(['"', '"'], ['${', '}']) or
+      @balanced_token ["'", "'"]
     @interpolate_string string.replace STRING_NEWLINES, " \\\n"
-    @line += count string, "\n"
-    @i += string.length
+    @line: + count string, "\n"
+    @i: + string.length
     true
 
   # Matches heredocs, adjusting indentation to the correct level, as heredocs
   # preserve whitespace, but ignore indentation to the left.
   heredoc_token: ->
-    return false unless match = @chunk.match(HEREDOC)
-    doc: @sanitize_heredoc match[2] or match[4]
-    @token 'STRING', "\"$doc\""
-    @line += count match[1], "\n"
-    @i += match[1].length
+    return false unless match: @chunk.match(HEREDOC)
+    quote: match[1].substr 0, 1
+    doc: @sanitize_heredoc match[2] or match[4], quote
+    @interpolate_string "$quote$doc$quote"
+    @line: + count match[1], "\n"
+    @i: + match[1].length
     true
 
   # Matches JavaScript interpolated directly into the source via backticks.
   js_token: ->
     return false unless starts @chunk, '`'
     return false unless script: @balanced_token ['`', '`']
-    @token 'JS', script.replace(JS_CLEANER, '')
-    @i += script.length
+    @token 'JS', script.replace JS_CLEANER, ''
+    @i: + script.length
     true
 
   # Matches regular expression literals. Lexing regular expressions is difficult
   # to distinguish from division, so we borrow some basic heuristics from
-  # JavaScript and Ruby.
+  # JavaScript and Ruby, borrow slash balancing from `@balanced_token`, and
+  # borrow interpolation from `@interpolate_string`.
   regex_token: ->
-    return false unless regex: @match REGEX, 1
-    return false if include NOT_REGEX, @tag()
-    @token 'REGEX', regex
-    @i += regex.length
+    return false unless @chunk.match REGEX_START
+    return false if     include NOT_REGEX, @tag()
+    return false unless regex: @balanced_token ['/', '/']
+    regex: + (flags: @chunk.substr(regex.length).match REGEX_FLAGS)
+    if regex.match REGEX_INTERPOLATION
+      str: regex.substring(1).split('/')[0]
+      str: str.replace REGEX_ESCAPE, (escaped) -> '\\' + escaped
+      @tokens: @tokens.concat [['(', '('], ['NEW', 'new'], ['IDENTIFIER', 'RegExp'], ['CALL_START', '(']]
+      @interpolate_string "\"$str\"", yes
+      @tokens: @tokens.concat [[',', ','], ['STRING', "\"$flags\""], [')', ')'], [')', ')']]
+    else
+      @token 'REGEX', regex
+    @i: + regex.length
     true
 
   # Matches a token in which which the passed delimiter pairs must be correctly
   # balanced (ie. strings, JS literals).
   balanced_token: (delimited...) ->
-    @balanced_string @chunk, delimited...
+    balanced_string @chunk, delimited
 
   # Matches and conumes comments. We pass through comments into JavaScript,
   # so they're treated as real tokens, like any other part of the language.
   comment_token: ->
     return false unless comment: @match COMMENT, 1
-    @line += (comment.match(MULTILINER) or []).length
-    lines: comment.replace(COMMENT_CLEANER, '').split(MULTILINER)
-    @token 'COMMENT', compact lines
-    @token 'TERMINATOR', "\n"
-    @i += comment.length
+    @line: + (comment.match(MULTILINER) or []).length
+    lines: compact comment.replace(COMMENT_CLEANER, '').split MULTILINER
+    i: @tokens.length - 1
+    if @unfinished()
+      i: - 1 while @tokens[i] and not include LINE_BREAK, @tokens[i][0]
+    @tokens.splice(i + 1, 0, ['COMMENT', lines, @line], ['TERMINATOR', '\n', @line])
+    @i: + comment.length
     true
 
   # Matches newlines, indents, and outdents, and determines which is which.
@@ -160,16 +194,15 @@ exports.Lexer: class Lexer
   # can close multiple indents, so we need to know how far in we happen to be.
   line_token: ->
     return false unless indent: @match MULTI_DENT, 1
-    @line += indent.match(MULTILINER).length
-    @i    += indent.length
+    @line: + indent.match(MULTILINER).length
+    @i   : + indent.length
     prev: @prev(2)
     size: indent.match(LAST_DENTS).reverse()[0].match(LAST_DENT)[1].length
     next_character: @chunk.match(MULTI_DENT)[4]
-    no_newlines: next_character is '.' or (@value() and @value().match(NO_NEWLINE) and
-      prev and (prev[0] isnt '.') and not @value().match(CODE))
+    no_newlines: next_character is '.' or @unfinished()
     if size is @indent
       return @suppress_newlines() if no_newlines
-      return @newline_token(indent)
+      return @newline_token indent
     else if size > @indent
       return @suppress_newlines() if no_newlines
       diff: size - @indent
@@ -186,7 +219,7 @@ exports.Lexer: class Lexer
     while move_out > 0 and @indents.length
       last_indent: @indents.pop()
       @token 'OUTDENT', last_indent
-      move_out -= last_indent
+      move_out: - last_indent
     @token 'TERMINATOR', "\n" unless @tag() is 'TERMINATOR' or no_newlines
     true
 
@@ -196,7 +229,7 @@ exports.Lexer: class Lexer
     return false unless space: @match WHITESPACE, 1
     prev: @prev()
     prev.spaced: true if prev
-    @i += space.length
+    @i: + space.length
     true
 
   # Generate a newline token. Consecutive newlines get merged together.
@@ -216,29 +249,31 @@ exports.Lexer: class Lexer
   # here. `;` and newlines are both treated as a `TERMINATOR`, we distinguish
   # parentheses that indicate a method call from regular parentheses, and so on.
   literal_token: ->
-    match: @chunk.match(OPERATOR)
+    match: @chunk.match OPERATOR
     value: match and match[1]
-    @tag_parameters() if value and value.match(CODE)
-    value ||= @chunk.substr(0, 1)
-    not_spaced: not @prev() or not @prev().spaced
+    space: match and match[2]
+    @tag_parameters() if value and value.match CODE
+    value: or @chunk.substr 0, 1
+    prev_spaced: @prev() and @prev().spaced
     tag: value
-    if value.match(ASSIGNMENT)
+    if value.match ASSIGNMENT
       tag: 'ASSIGN'
       @assignment_error() if include JS_FORBIDDEN, @value
     else if value is ';'
       tag: 'TERMINATOR'
-    else if value is '[' and @tag() is '?' and not_spaced
+    else if value is '[' and @tag() is '?' and not prev_spaced
       tag: 'SOAKED_INDEX_START'
       @soaked_index: true
       @tokens.pop()
     else if value is ']' and @soaked_index
       tag: 'SOAKED_INDEX_END'
       @soaked_index: false
-    else if include(CALLABLE, @tag()) and not_spaced
+    else if include(CALLABLE, @tag()) and not prev_spaced
       tag: 'CALL_START'  if value is '('
       tag: 'INDEX_START' if value is '['
+    @i: + value.length
+    return @tag_half_assignment tag if space and prev_spaced and @prev()[0] is 'ASSIGN' and include HALF_ASSIGNMENTS, tag
     @token tag, value
-    @i += value.length
     true
 
   # Token Manipulators
@@ -257,11 +292,17 @@ exports.Lexer: class Lexer
 
   # Sanitize a heredoc by escaping internal double quotes and erasing all
   # external indentation on the left-hand side.
-  sanitize_heredoc: (doc) ->
+  sanitize_heredoc: (doc, quote) ->
     indent: (doc.match(HEREDOC_INDENT) or ['']).sort()[0]
     doc.replace(new RegExp("^" +indent, 'gm'), '')
        .replace(MULTILINER, "\\n")
-       .replace(/"/g, '\\"')
+       .replace(new RegExp(quote, 'g'), '\\"')
+
+  # Tag a half assignment.
+  tag_half_assignment: (tag) ->
+    last: @tokens.pop()
+    @tokens.push ["$tag=", "$tag=", last[2]]
+    true
 
   # A source of ambiguity in our grammar used to be parameter lists in function
   # definitions versus argument lists in function calls. Walk backwards, tagging
@@ -270,8 +311,8 @@ exports.Lexer: class Lexer
     return if @tag() isnt ')'
     i: 0
     while true
-      i += 1
-      tok: @prev(i)
+      i: + 1
+      tok: @prev i
       return if not tok
       switch tok[0]
         when 'IDENTIFIER' then tok[0]: 'PARAM'
@@ -281,7 +322,7 @@ exports.Lexer: class Lexer
 
   # Close up all remaining open blocks at the end of the file.
   close_indentation: ->
-    @outdent_token(@indent)
+    @outdent_token @indent
 
   # The error for when you try to use a forbidden word in JavaScript as
   # an identifier.
@@ -293,34 +334,6 @@ exports.Lexer: class Lexer
   assignment_error: ->
     throw new Error "SyntaxError: Reserved word \"${@value()}\" on line ${@line + 1} can't be assigned"
 
-  # Matches a balanced group such as a single or double-quoted string. Pass in
-  # a series of delimiters, all of which must be nested correctly within the
-  # contents of the string. This method allows us to have strings within
-  # interpolations within strings etc...
-  balanced_string: (str, delimited...) ->
-    levels: []
-    i: 0
-    while i < str.length
-      for pair in delimited
-        [open, close]: pair
-        if levels.length and starts str, '\\', i
-          i += 1
-          break
-        else if levels.length and starts(str, close, i) and levels[levels.length - 1] is pair
-          levels.pop()
-          i += close.length - 1
-          i += 1 unless levels.length
-          break
-        else if starts str, open, i
-          levels.push(pair)
-          i += open.length - 1
-          break
-      break unless levels.length
-      i += 1
-    throw new Error "SyntaxError: Unterminated ${levels.pop()[0]} starting on line ${@line + 1}" if levels.length
-    return false if i is 0
-    return str.substring(0, i)
-
   # Expand variables and expressions inside double-quoted strings using
   # [ECMA Harmony's interpolation syntax](http://wiki.ecmascript.org/doku.php?id=strawman:string_interpolation)
   # for substitution of bare variables as well as arbitrary expressions.
@@ -331,25 +344,25 @@ exports.Lexer: class Lexer
   # If it encounters an interpolation, this method will recursively create a
   # new Lexer, tokenize the interpolated contents, and merge them into the
   # token stream.
-  interpolate_string: (str) ->
+  interpolate_string: (str, escape_quotes) ->
     if str.length < 3 or not starts str, '"'
       @token 'STRING', str
     else
       lexer:    new Lexer()
       tokens:   []
-      quote:    str.substring(0, 1)
+      quote:    str.substring 0, 1
       [i, pi]:  [1, 1]
       while i < str.length - 1
         if starts str, '\\', i
-          i += 1
+          i: + 1
         else if match: str.substring(i).match INTERPOLATION
           [group, interp]: match
           interp: "this.${ interp.substring(1) }" if starts interp, '@'
           tokens.push ['STRING', "$quote${ str.substring(pi, i) }$quote"] if pi < i
           tokens.push ['IDENTIFIER', interp]
-          i += group.length - 1
+          i: + group.length - 1
           pi: i + 1
-        else if (expr: @balanced_string str.substring(i), ['${', '}'])
+        else if (expr: balanced_string str.substring(i), [['${', '}']])
           tokens.push ['STRING', "$quote${ str.substring(pi, i) }$quote"] if pi < i
           inner: expr.substring(2, expr.length - 1)
           if inner.length
@@ -358,33 +371,39 @@ exports.Lexer: class Lexer
             tokens.push ['TOKENS', nested]
           else
             tokens.push ['STRING', "$quote$quote"]
-          i += expr.length - 1
+          i: + expr.length - 1
           pi: i + 1
-        i += 1
+        i: + 1
       tokens.push ['STRING', "$quote${ str.substring(pi, i) }$quote"] if pi < i and pi < str.length - 1
-      for each, i in tokens
-        if each[0] is 'TOKENS'
-          @tokens: @tokens.concat each[1]
+      tokens.unshift ['STRING', '""'] unless tokens[0][0] is 'STRING'
+      for token, i in tokens
+        [tag, value]: token
+        if tag is 'TOKENS'
+          @tokens: @tokens.concat value
+        else if tag is 'STRING' and escape_quotes
+          escaped: value.substring(1, value.length - 1).replace(/"/g, '\\"')
+          @token tag, "\"$escaped\""
         else
-          @token each[0], each[1]
+          @token tag, value
         @token '+', '+' if i < tokens.length - 1
+      tokens
 
   # Helpers
   # -------
 
   # Add a token to the results, taking note of the line number.
   token: (tag, value) ->
-    @tokens.push([tag, value, @line])
+    @tokens.push [tag, value, @line]
 
   # Peek at a tag in the current token stream.
   tag: (index, tag) ->
-    return unless tok: @prev(index)
+    return unless tok: @prev index
     return tok[0]: tag if tag?
     tok[0]
 
   # Peek at a value in the current token stream.
   value: (index, val) ->
-    return unless tok: @prev(index)
+    return unless tok: @prev index
     return tok[1]: val if val?
     tok[1]
 
@@ -395,9 +414,21 @@ exports.Lexer: class Lexer
   # Attempt to match a string against the current chunk, returning the indexed
   # match if successful, and `false` otherwise.
   match: (regex, index) ->
-    return false unless m: @chunk.match(regex)
+    return false unless m: @chunk.match regex
     if m then m[index] else false
 
+  # Are we in the midst of an unfinished expression?
+  unfinished: ->
+    prev: @prev(2)
+    @value() and @value().match and @value().match(NO_NEWLINE) and
+      prev and (prev[0] isnt '.') and not @value().match(CODE)
+
+  # Lexer Properties
+  # ----------------
+
+  # There are no exensions to the core lexer by default.
+  @extensions: []
+
 # Constants
 # ---------
 
@@ -410,15 +441,16 @@ JS_KEYWORDS: [
   "break", "continue",
   "for", "in", "while",
   "delete", "instanceof", "typeof",
-  "switch", "super", "extends", "class"
+  "switch", "super", "extends", "class",
+  "this", "null"
 ]
 
 # CoffeeScript-only keywords, which we're more relaxed about allowing. They can't
 # be used standalone, but you can reference them as an attached property.
-COFFEE_KEYWORDS: [
+COFFEE_ALIASES:  ["and", "or", "is", "isnt", "not"]
+COFFEE_KEYWORDS: COFFEE_ALIASES.concat [
   "then", "unless",
   "yes", "no", "on", "off",
-  "and", "or", "is", "isnt", "not",
   "of", "by", "where", "when"
 ]
 
@@ -431,8 +463,7 @@ KEYWORDS: JS_KEYWORDS.concat COFFEE_KEYWORDS
 # to avoid having a JavaScript error at runtime.
 RESERVED: [
   "case", "default", "do", "function", "var", "void", "with"
-  "const", "let", "debugger", "enum", "export", "import", "native",
-  "__extends", "__hasProp"
+  "const", "let", "debugger", "enum", "export", "import", "native"
 ]
 
 # The superset of both JavaScript keywords and reserved words, none of which may
@@ -440,20 +471,25 @@ RESERVED: [
 JS_FORBIDDEN: JS_KEYWORDS.concat RESERVED
 
 # Token matching regexes.
-IDENTIFIER    : /^([a-zA-Z$_](\w|\$)*)/
+IDENTIFIER    : /^([a-zA-Z\$_](\w|\$)*)/
 NUMBER        : /^(\b((0(x|X)[0-9a-fA-F]+)|([0-9]+(\.[0-9]+)?(e[+\-]?[0-9]+)?)))\b/i
 HEREDOC       : /^("{6}|'{6}|"{3}\n?([\s\S]*?)\n?([ \t]*)"{3}|'{3}\n?([\s\S]*?)\n?([ \t]*)'{3})/
 INTERPOLATION : /^\$([a-zA-Z_@]\w*(\.\w+)*)/
-OPERATOR      : /^([+\*&|\/\-%=<>:!?]+)/
+OPERATOR      : /^([+\*&|\/\-%=<>:!?]+)([ \t]*)/
 WHITESPACE    : /^([ \t]+)/
 COMMENT       : /^(((\n?[ \t]*)?#[^\n]*)+)/
 CODE          : /^((-|=)>)/
-REGEX         : /^(\/(\S.*?)?([^\\]|\\\\)\/[imgy]{0,4})/
 MULTI_DENT    : /^((\n([ \t]*))+)(\.)?/
 LAST_DENTS    : /\n([ \t]*)/g
 LAST_DENT     : /\n([ \t]*)/
 ASSIGNMENT    : /^(:|=)$/
 
+# Regex-matching-regexes.
+REGEX_START        : /^\/[^\/ ]/
+REGEX_INTERPOLATION: /([^\\]\$[a-zA-Z_@]|[^\\]\$\{.*[^\\]\})/
+REGEX_FLAGS        : /^[imgy]{0,4}/
+REGEX_ESCAPE       : /\\[^\$]/g
+
 # Token cleaning regexes.
 JS_CLEANER      : /(^`|`$)/g
 MULTILINER      : /\n/g
@@ -475,7 +511,7 @@ NOT_REGEX: [
 # Tokens which could legitimately be invoked or indexed. A opening
 # parentheses or bracket following these tokens will be recorded as the start
 # of a function invocation or indexing operation.
-CALLABLE: ['IDENTIFIER', 'SUPER', ')', ']', '}', 'STRING', '@']
+CALLABLE: ['IDENTIFIER', 'SUPER', ')', ']', '}', 'STRING', '@', 'THIS']
 
 # Tokens that indicate an access -- keywords immediately following will be
 # treated as identifiers.
@@ -484,27 +520,16 @@ ACCESSORS: ['PROPERTY_ACCESS', 'PROTOTYPE_ACCESS', 'SOAK_ACCESS', '@']
 # Tokens that, when immediately preceding a `WHEN`, indicate that the `WHEN`
 # occurs at the start of a line. We disambiguate these from trailing whens to
 # avoid an ambiguity in the grammar.
-BEFORE_WHEN: ['INDENT', 'OUTDENT', 'TERMINATOR']
+LINE_BREAK: ['INDENT', 'OUTDENT', 'TERMINATOR']
 
-# Utility Functions
-# -----------------
+# Half-assignments...
+HALF_ASSIGNMENTS: ['-', '+', '/', '*', '%', '||', '&&', '?']
 
-# Does a list include a value?
-include: (list, value) ->
-  list.indexOf(value) >= 0
-
-# Peek at the beginning of a given string to see if it matches a sequence.
-starts: (string, literal, start) ->
-  string.substring(start, (start or 0) + literal.length) is literal
-
-# Trim out all falsy values from an array.
-compact: (array) -> item for item in array when item
-
-# Count the number of occurences of a character in a string.
-count: (string, letter) ->
-  num: 0
-  pos: string.indexOf(letter)
-  while pos isnt -1
-    num += 1
-    pos: string.indexOf(letter, pos + 1)
-  num
+# Conversions from CoffeeScript operators into JavaScript ones.
+CONVERSIONS: {
+  'and':  '&&'
+  'or':   '||'
+  'is':   '=='
+  'isnt': '!='
+  'not':  '!'
+}

src/optparse.coffee

@@ -22,7 +22,7 @@ exports.OptionParser: class OptionParser
   parse: (args) ->
     options: {arguments: []}
     args: normalize_arguments args
-    while arg: args.shift()
+    while (arg: args.shift())
       is_option: !!(arg.match(LONG_FLAG) or arg.match(SHORT_FLAG))
       matched_rule: no
       for rule in @rules

src/repl.coffee

@@ -5,13 +5,14 @@
 #     coffee> puts "$num bottles of beer" for num in [99..1]
 
 # Require the **coffee-script** module to get access to the compiler.
-CoffeeScript: require 'coffee-script'
+CoffeeScript: require './coffee-script'
+helpers:      require('./helpers').helpers
 
 # Our prompt.
 prompt: 'coffee> '
 
 # Quick alias for quitting the REPL.
-process.mixin {
+helpers.extend global, {
   quit: -> process.exit(0)
 }
 

src/rewriter.coffee

@@ -1,13 +1,19 @@
-# The CoffeeScript language has a decent amount of optional syntax,
-# implicit syntax, and shorthand syntax. These things can greatly complicate a
-# grammar and bloat the resulting parse table. Instead of making the parser
-# handle it all, we take a series of passes over the token stream,
-# using this **Rewriter** to convert shorthand into the unambiguous long form,
-# add implicit indentation and parentheses, balance incorrect nestings, and
-# generally clean things up.
+# The CoffeeScript language has a good deal of optional syntax, implicit syntax,
+# and shorthand syntax. This can greatly complicate a grammar and bloat
+# the resulting parse table. Instead of making the parser handle it all, we take
+# a series of passes over the token stream, using this **Rewriter** to convert
+# shorthand into the unambiguous long form, add implicit indentation and
+# parentheses, balance incorrect nestings, and generally clean things up.
 
 # Set up exported variables for both Node.js and the browser.
-this.exports: this unless process?
+if process?
+  helpers: require('./helpers').helpers
+else
+  this.exports: this
+  helpers:      this.helpers
+
+# Import the helpers we need.
+include: helpers.include
 
 # The **Rewriter** class is used by the [Lexer](lexer.html), directly against
 # its internal array of tokens.
@@ -26,7 +32,7 @@ exports.Rewriter: class Rewriter
     @close_open_calls_and_indexes()
     @add_implicit_indentation()
     @add_implicit_parentheses()
-    @ensure_balance(BALANCED_PAIRS)
+    @ensure_balance BALANCED_PAIRS
     @rewrite_closing_parens()
     @tokens
 
@@ -39,8 +45,8 @@ exports.Rewriter: class Rewriter
     i: 0
     while true
       break unless @tokens[i]
-      move: block(@tokens[i - 1], @tokens[i], @tokens[i + 1], i)
-      i += move
+      move: block @tokens[i - 1], @tokens[i], @tokens[i + 1], i
+      i: + move
     true
 
   # Massage newlines and indentations so that comments don't have to be
@@ -50,11 +56,11 @@ exports.Rewriter: class Rewriter
       return 1 unless token[0] is 'COMMENT'
       after:  @tokens[i + 2]
       if after and after[0] is 'INDENT'
-        @tokens.splice(i + 2, 1)
-        @tokens.splice(i, 0, after)
+        @tokens.splice i + 2, 1
+        @tokens.splice i, 0, after
         return 1
       else if prev and prev[0] isnt 'TERMINATOR' and prev[0] isnt 'INDENT' and prev[0] isnt 'OUTDENT'
-        @tokens.splice(i, 0, ['TERMINATOR', "\n", prev[2]])
+        @tokens.splice i, 0, ['TERMINATOR', "\n", prev[2]]
         return 2
       else
         return 1
@@ -62,14 +68,14 @@ exports.Rewriter: class Rewriter
   # Leading newlines would introduce an ambiguity in the grammar, so we
   # dispatch them here.
   remove_leading_newlines: ->
-    @tokens.shift() while @tokens[0][0] is 'TERMINATOR'
+    @tokens.shift() while @tokens[0] and @tokens[0][0] is 'TERMINATOR'
 
   # Some blocks occur in the middle of expressions -- when we're expecting
   # this, remove their trailing newlines.
   remove_mid_expression_newlines: ->
     @scan_tokens (prev, token, post, i) =>
       return 1 unless post and include(EXPRESSION_CLOSE, post[0]) and token[0] is 'TERMINATOR'
-      @tokens.splice(i, 1)
+      @tokens.splice i, 1
       return 0
 
   # The lexer has tagged the opening parenthesis of a method call, and the
@@ -80,22 +86,22 @@ exports.Rewriter: class Rewriter
     brackets: [0]
     @scan_tokens (prev, token, post, i) =>
       switch token[0]
-        when 'CALL_START'  then parens.push(0)
-        when 'INDEX_START' then brackets.push(0)
-        when '('           then parens[parens.length - 1] += 1
-        when '['           then brackets[brackets.length - 1] += 1
+        when 'CALL_START'  then parens.push 0
+        when 'INDEX_START' then brackets.push 0
+        when '('           then parens[parens.length - 1]: + 1
+        when '['           then brackets[brackets.length - 1]: + 1
         when ')'
           if parens[parens.length - 1] is 0
             parens.pop()
             token[0]: 'CALL_END'
           else
-            parens[parens.length - 1] -= 1
+            parens[parens.length - 1]: - 1
         when ']'
           if brackets[brackets.length - 1] == 0
             brackets.pop()
             token[0]: 'INDEX_END'
           else
-            brackets[brackets.length - 1] -= 1
+            brackets[brackets.length - 1]: - 1
       return 1
 
   # Methods may be optionally called without parentheses, for simple cases.
@@ -103,15 +109,25 @@ exports.Rewriter: class Rewriter
   # deal with them.
   add_implicit_parentheses: ->
     stack: [0]
+    calls:  0
+    parens: 0
+    start_parens: 0
     @scan_tokens (prev, token, post, i) =>
       tag: token[0]
-      stack.push(0) if tag is 'INDENT'
-      if tag is 'OUTDENT'
-        last: stack.pop()
-        stack[stack.length - 1] += last
-      if !post? or include IMPLICIT_END, tag
+      switch tag
+        when 'CALL_START' then calls: + 1
+        when 'CALL_END'   then calls: - 1
+        when '('          then parens: + 1
+        when ')'          then parens: - 1
+        when 'INDENT'     then stack.push 0
+        when 'OUTDENT'
+          last: stack.pop()
+          stack[stack.length - 1]: + last
+      open: stack[stack.length - 1] > 0
+      if !post? or (start_parens > parens) or (parens is 0 and include IMPLICIT_END, tag)
         return 1 if tag is 'INDENT' and prev and include IMPLICIT_BLOCK, prev[0]
-        if stack[stack.length - 1] > 0 or tag is 'INDENT'
+        return 1 if tag is 'OUTDENT' and token.generated
+        if open or tag is 'INDENT'
           idx: if tag is 'OUTDENT' then i + 1 else i
           stack_pointer: if tag is 'INDENT' then 2 else 1
           for tmp in [0...stack[stack.length - stack_pointer]]
@@ -119,9 +135,11 @@ exports.Rewriter: class Rewriter
           size: stack[stack.length - stack_pointer] + 1
           stack[stack.length - stack_pointer]: 0
           return size
-      return 1 unless prev and include(IMPLICIT_FUNC, prev[0]) and include IMPLICIT_CALL, tag
-      @tokens.splice(i, 0, ['CALL_START', '(', token[2]])
-      stack[stack.length - 1] += 1
+      return 1 unless prev and include(IMPLICIT_FUNC, prev[0]) and include(IMPLICIT_CALL, tag)
+      calls: 0
+      start_parens: if tag is '(' then parens - 1 else parens
+      @tokens.splice i, 0, ['CALL_START', '(', token[2]]
+      stack[stack.length - 1]: + 1
       return 2
 
   # Because our grammar is LALR(1), it can't handle some single-line
@@ -134,40 +152,48 @@ exports.Rewriter: class Rewriter
         post[0] isnt 'INDENT' and
         not (token[0] is 'ELSE' and post[0] is 'IF')
       starter: token[0]
-      @tokens.splice(i + 1, 0, ['INDENT', 2, token[2]])
+      @tokens.splice i + 1, 0, ['INDENT', 2, token[2]]
       idx: i + 1
       parens: 0
       while true
-        idx += 1
+        idx: + 1
         tok: @tokens[idx]
         pre: @tokens[idx - 1]
         if (not tok or
             (include(SINGLE_CLOSERS, tok[0]) and tok[1] isnt ';') or
-            (tok[0] is ')' && parens is 0)) and
+            (tok[0] is ')' and parens is 0)) and
             not (starter is 'ELSE' and tok[0] is 'ELSE')
           insertion: if pre[0] is "," then idx - 1 else idx
-          @tokens.splice(insertion, 0, ['OUTDENT', 2, token[2]])
+          outdent: ['OUTDENT', 2, token[2]]
+          outdent.generated: true
+          @tokens.splice insertion, 0, outdent
           break
-        parens += 1 if tok[0] is '('
-        parens -= 1 if tok[0] is ')'
+        parens: + 1 if tok[0] is '('
+        parens: - 1 if tok[0] is ')'
       return 1 unless token[0] is 'THEN'
-      @tokens.splice(i, 1)
+      @tokens.splice i, 1
       return 0
 
   # Ensure that all listed pairs of tokens are correctly balanced throughout
   # the course of the token stream.
   ensure_balance: (pairs) ->
     levels: {}
+    open_line: {}
     @scan_tokens (prev, token, post, i) =>
       for pair in pairs
         [open, close]: pair
-        levels[open] ||= 0
-        levels[open] += 1 if token[0] is open
-        levels[open] -= 1 if token[0] is close
+        levels[open]: or 0
+        if token[0] is open
+          open_line[open]: token[2] if levels[open] == 0
+          levels[open]: + 1
+        levels[open]: - 1 if token[0] is close
         throw new Error("too many ${token[1]} on line ${token[2] + 1}") if levels[open] < 0
       return 1
     unclosed: key for key, value of levels when value > 0
-    throw new Error("unclosed ${unclosed[0]}") if unclosed.length
+    if unclosed.length
+      open: unclosed[0]
+      line: open_line[open] + 1
+      throw new Error "unclosed $open on line $line"
 
   # We'd like to support syntax like this:
   #
@@ -178,10 +204,10 @@ exports.Rewriter: class Rewriter
   # inwards, safely. The steps to accomplish this are:
   #
   # 1. Check that all paired tokens are balanced and in order.
-  # 2. Rewrite the stream with a stack: if you see an '(' or INDENT, add it
-  #    to the stack. If you see an ')' or OUTDENT, pop the stack and replace
+  # 2. Rewrite the stream with a stack: if you see an `EXPRESSION_START`, add it
+  #    to the stack. If you see an `EXPRESSION_END`, pop the stack and replace
   #    it with the inverse of what we've just popped.
-  # 3. Keep track of "debt" for tokens that we fake, to make sure we end
+  # 3. Keep track of "debt" for tokens that we manufacture, to make sure we end
   #    up balanced in the end.
   #
   rewrite_closing_parens: ->
@@ -196,14 +222,14 @@ exports.Rewriter: class Rewriter
         return 1
       else if include EXPRESSION_END, tag
         if debt[inv] > 0
-          debt[inv] -= 1
+          debt[inv]: - 1
           @tokens.splice i, 1
           return 0
         else
           match: stack.pop()
           mtag:  match[0]
           return 1 if tag is INVERSES[mtag]
-          debt[mtag] += 1
+          debt[mtag]: + 1
           val: if mtag is 'INDENT' then match[1] else INVERSES[mtag]
           @tokens.splice i, 0, [INVERSES[mtag], val]
           return 1
@@ -235,12 +261,13 @@ EXPRESSION_END:   pair[1] for pair in BALANCED_PAIRS
 EXPRESSION_CLOSE: ['CATCH', 'WHEN', 'ELSE', 'FINALLY'].concat EXPRESSION_END
 
 # Tokens that, if followed by an `IMPLICIT_CALL`, indicate a function invocation.
-IMPLICIT_FUNC:  ['IDENTIFIER', 'SUPER', ')', 'CALL_END', ']', 'INDEX_END']
+IMPLICIT_FUNC:  ['IDENTIFIER', 'SUPER', ')', 'CALL_END', ']', 'INDEX_END', '<-']
 
 # If preceded by an `IMPLICIT_FUNC`, indicates a function invocation.
 IMPLICIT_CALL:  ['IDENTIFIER', 'NUMBER', 'STRING', 'JS', 'REGEX', 'NEW', 'PARAM_START',
-                 'TRY', 'DELETE', 'TYPEOF', 'SWITCH',
+                 'TRY', 'DELETE', 'TYPEOF', 'SWITCH', 'EXTENSION',
                  'TRUE', 'FALSE', 'YES', 'NO', 'ON', 'OFF', '!', '!!', 'NOT',
+                 'THIS', 'NULL',
                  '@', '->', '=>', '[', '(', '{']
 
 # Tokens indicating that the implicit call must enclose a block of expressions.
@@ -253,10 +280,3 @@ IMPLICIT_END:   ['IF', 'UNLESS', 'FOR', 'WHILE', 'TERMINATOR', 'INDENT', 'OUTDEN
 # The grammar can't disambiguate them, so we insert the implicit indentation.
 SINGLE_LINERS: ['ELSE', "->", "=>", 'TRY', 'FINALLY', 'THEN']
 SINGLE_CLOSERS: ['TERMINATOR', 'CATCH', 'FINALLY', 'ELSE', 'OUTDENT', 'LEADING_WHEN']
-
-# Utility Functions
-# -----------------
-
-# Does a list include a value?
-include: (list, value) ->
-  list.indexOf(value) >= 0

src/scope.coffee

@@ -10,6 +10,9 @@ this.exports: this unless process?
 
 exports.Scope: class Scope
 
+  # The top-level **Scope** object.
+  @root: null
+
   # Initialize a scope with its parent, for lookups up the chain,
   # as well as a reference to the **Expressions** node is belongs to, which is
   # where it should declare its variables, and a reference to the function that
@@ -17,7 +20,11 @@ exports.Scope: class Scope
   constructor: (parent, expressions, method) ->
     [@parent, @expressions, @method]: [parent, expressions, method]
     @variables: {}
-    @temp_var: if @parent then @parent.temp_var else '_a'
+    if @parent
+      @temp_var: @parent.temp_var
+    else
+      Scope.root: this
+      @temp_var: '_a'
 
   # Look up a variable name in lexical scope, and declare it if it does not
   # already exist.
@@ -26,6 +33,12 @@ exports.Scope: class Scope
     @variables[name]: 'var'
     false
 
+  # Test variables and return true the first time fn(v, k) returns true
+  any: (fn) ->
+    for v, k of @variables when fn(v, k)
+      return true
+    return false
+
   # Reserve a variable name as originating from a function parameter for this
   # scope. No `var` required for internal references.
   parameter: (name) ->
@@ -47,19 +60,18 @@ exports.Scope: class Scope
 
   # Ensure that an assignment is made at the top of this scope
   # (or at the top-level scope, if requested).
-  assign: (name, value, top_level) ->
-    return @parent.assign(name, value, top_level) if top_level and @parent
+  assign: (name, value) ->
     @variables[name]: {value: value, assigned: true}
 
   # Does this scope reference any variables that need to be declared in the
   # given function body?
   has_declarations: (body) ->
-    body is @expressions and @declared_variables().length
+    body is @expressions and @any (k, val) -> val is 'var'
 
   # Does this scope reference any assignments that need to be declared at the
   # top of the given function body?
   has_assignments: (body) ->
-    body is @expressions and @assigned_variables().length
+    body is @expressions and @any (k, val) -> val.assigned
 
   # Return the list of variables first declared in this scope.
   declared_variables: ->

test/test_arguments.coffee

@@ -4,31 +4,22 @@ area: (x, y, x1, y1) ->
 x:  y:  10
 x1: y1: 20
 
-ok area(x, y, x1, y1) is 100, 'basic arguments'
+ok area(x, y, x1, y1) is 100
 
 ok(area(x, y,
-           x1, y1) is 100, 'arguments on split lines')
+           x1, y1) is 100)
 
 ok(area(
   x
   y
   x1
   y1
-) is 100, 'newline delimited arguments')
+) is 100)
 
 
-curried: ->
-  ok area.apply(this, arguments.concat(20, 20)) is 100, 'arguments converted into an array'
+sum_of_args: ->
+  sum: 0
+  sum: + val for val in arguments
+  sum
 
-curried 10, 10
-
-
-func: ->
-  arguments: 25
-  arguments
-
-ok func(100) is 25, 'arguments as a regular identifier'
-
-
-this.arguments: 10
-ok @arguments is 10, 'arguments accessed as a property'
+ok sum_of_args(1, 2, 3, 4, 5) is 15

test/test_array_comprehension.coffee

@@ -1,42 +0,0 @@
-nums:    n * n for n in [1, 2, 3] when n % 2 isnt 0
-results: n * 2 for n in nums
-
-ok results.join(',') is '2,18', 'basic array comprehension'
-
-
-obj:   {one: 1, two: 2, three: 3}
-names: prop + '!' for prop of obj
-odds:  prop + '!' for prop, value of obj when value % 2 isnt 0
-
-ok names.join(' ') is "one! two! three!", 'basic object comprehension'
-ok odds.join(' ')  is "one! three!", 'object comprehension with a filter'
-
-
-evens: for num in [1, 2, 3, 4, 5, 6] when num % 2 is 0
-           num *= -1
-           num -= 2
-           num * -1
-
-ok evens.join(', ') is '4, 6, 8', 'multiline array comprehension with filter'
-
-
-ok 2 in evens, 'the in operator still works, standalone'
-
-
-# Ensure that the closure wrapper preserves local variables.
-obj: {}
-
-methods: ['one', 'two', 'three']
-
-for method in methods
-  name: method
-  obj[name]: ->
-    "I'm " + name
-
-ok obj.one()   is "I'm one"
-ok obj.two()   is "I'm two"
-ok obj.three() is "I'm three"
-
-
-array: [0..10]
-ok(num % 2 is 0 for num in array by 2, 'naked ranges are expanded into arrays')

test/test_assignment.coffee

@@ -1,3 +1,4 @@
+# Can assign the result of a try/catch block.
 result: try
   nonexistent * missing
 catch error
@@ -5,20 +6,22 @@ catch error
 
 result2: try nonexistent * missing catch error then true
 
-ok result is true and result2 is true, 'can assign the result of a try/catch block'
+ok result is true and result2 is true
 
 
+# Can assign a conditional statement.
 get_x: -> 10
 
 if x: get_x() then 100
 
-ok x is 10, 'can assign a conditional statement'
+ok x is 10
 
 x: if get_x() then 100
 
-ok x is 100, 'can assign a conditional statement'
+ok x is 100
 
 
+# This-assignment.
 tester: ->
   @example: -> puts 'example function'
   this

test/test_bind.coffee

@@ -0,0 +1,20 @@
+f: (x,y,z) ->
+  x * y * z * ((@num or 4) + 5)
+
+obj: {num: 5}
+
+func: f <- obj, 1, 1
+ok func(2) is 20
+
+func: f <- {}, 1, 2
+ok func(2) is 36
+
+func: f <- obj
+ok func(1, 2, 3) is 60
+
+in_first_ten: helpers.include <- null, [0...10]
+
+ok in_first_ten 3
+ok in_first_ten 9
+ok not in_first_ten -1
+ok not in_first_ten 12

test/test_blocks.coffee

@@ -1,7 +1,8 @@
+# Basic blocks.
 results: [1, 2, 3].map (x) ->
   x * x
 
-ok results.join(' ') is '1 4 9', 'basic block syntax'
+ok results.join(' ') is '1 4 9'
 
 
 # Chained blocks, with proper indentation levels:

test/test_break.coffee

@@ -0,0 +1,28 @@
+# Test with break at the top level.
+array: [1,2,3]
+call_with_lambda: (l) -> null
+for i in array
+  result: call_with_lambda(->)
+  if i == 2
+    puts "i = 2"
+  else
+    break
+
+ok result is null
+
+
+# Test with break *not* at the top level.
+some_func: (input) ->
+  takes_lambda: (l) -> null
+  for i in [1,2]
+    result: takes_lambda(->)
+    if input == 1
+      return 1
+    else
+      break
+
+  return 2
+
+ok some_func(1) is 1
+ok some_func(2) is 2
+

test/test_chained_calls.coffee

@@ -1,25 +0,0 @@
-identity_wrap: (x) ->
-  -> x
-
-result: identity_wrap(identity_wrap(true))()()
-
-ok result, 'basic chained function calls'
-
-
-str: 'god'
-
-result: str.
-  split('').
-  reverse().
-  reverse().
-  reverse()
-
-ok result.join('') is 'dog', 'chained accesses split on period/newline'
-
-result: str
-  .split('')
-  .reverse()
-  .reverse()
-  .reverse()
-
-ok result.join('') is 'dog', 'chained accesses split on newline/period'

test/test_chaining.coffee

@@ -0,0 +1,36 @@
+# Basic chained function calls.
+identity_wrap: (x) ->
+  -> x
+
+result: identity_wrap(identity_wrap(true))()()
+
+ok result
+
+
+# Chained accesses split on period/newline, backwards and forwards.
+str: 'god'
+
+result: str.
+  split('').
+  reverse().
+  reverse().
+  reverse()
+
+ok result.join('') is 'dog'
+
+result: str
+  .split('')
+  .reverse()
+  .reverse()
+  .reverse()
+
+ok result.join('') is 'dog'
+
+
+# Newline suppression for operators.
+six:
+  1 +
+  2 +
+  3
+
+ok six is 6

test/test_classes.coffee

@@ -1,6 +1,10 @@
+# Test classes with a four-level inheritance chain.
 class Base
   func: (string) ->
-    'zero/' + string
+    "zero/$string"
+
+  @static: (string) ->
+    "static/$string"
 
 class FirstChild extends Base
   func: (string) ->
@@ -21,6 +25,7 @@ class ThirdChild extends SecondChild
 result: (new ThirdChild()).func 'four'
 
 ok result is 'zero/one/two/three/four'
+ok Base.static('word') is 'static/word'
 
 
 class TopClass
@@ -43,4 +48,49 @@ class OneClass
 
 class TwoClass extends OneClass
 
-ok (new TwoClass('three')).name is 'three'
+ok (new TwoClass('three')).name is 'three'
+
+
+# And now the same tests, but written in the manual style:
+Base: ->
+Base::func: (string) ->
+  'zero/' + string
+
+FirstChild: ->
+FirstChild extends Base
+FirstChild::func: (string) ->
+  super('one/') + string
+
+SecondChild: ->
+SecondChild extends FirstChild
+SecondChild::func: (string) ->
+  super('two/') + string
+
+ThirdChild: ->
+  @array: [1, 2, 3]
+  this
+ThirdChild extends SecondChild
+ThirdChild::func: (string) ->
+  super('three/') + string
+
+result: (new ThirdChild()).func 'four'
+
+ok result is 'zero/one/two/three/four'
+
+
+TopClass: (arg) ->
+  @prop: 'top-' + arg
+  this
+
+SuperClass: (arg) ->
+  super 'super-' + arg
+  this
+
+SubClass: ->
+  super 'sub'
+  this
+
+SuperClass extends TopClass
+SubClass extends SuperClass
+
+ok (new SubClass()).prop is 'top-super-sub'

test/test_comments.coffee

@@ -33,3 +33,23 @@ obj: {
   two: 2
     # comment
 }
+
+result: if true # comment
+  false
+
+ok not result
+
+result: if false
+  false
+else # comment
+  45
+
+ok result is 45
+
+
+test:
+  'test ' +
+  'test ' + # comment
+  'test'
+
+ok test is 'test test test'

test/test_compilation.coffee

@@ -0,0 +1,71 @@
+# Ensure that carriage returns don't break compilation on Windows.
+
+js: CoffeeScript.compile("one\r\ntwo", {no_wrap: on})
+
+ok js is "one;\ntwo;"
+
+
+# Try out language extensions to CoffeeScript.
+
+# Create the Node were going to add -- a literal syntax for splitting
+# strings into letters.
+class SplitNode extends BaseNode
+  type: 'Split'
+
+  constructor: (variable) ->
+    @variable: variable
+
+  compile_node: (o) ->
+    "'${@variable}'.split('')"
+
+# Extend CoffeeScript with our lexing function that matches --wordgoeshere--
+# and creates a SplitNode.
+CoffeeScript.extend ->
+  return false unless variable: @match(/^--(\w+)--/, 1)
+  @i: + variable.length + 4
+  @token 'EXTENSION', new SplitNode(variable)
+  true
+
+# Compile with the extension.
+js: CoffeeScript.compile 'return --tobesplit--', {no_wrap: on}
+
+ok js is "return 'tobesplit'.split('');"
+
+
+# Let's try a different extension, for Ruby-style array literals.
+
+class WordArrayNode extends BaseNode
+  type: 'WordArray'
+
+  constructor: (words) ->
+    @words: words
+
+  compile_node: (o) ->
+    strings = ("\"$word\"" for word in @words).join ', '
+    "[$strings]"
+
+CoffeeScript.extend ->
+  return false unless words: @chunk.match(/^%w\{(.*?)\}/)
+  @i: + words[0].length
+  @token 'EXTENSION', new WordArrayNode(words[1].split(/\s+/))
+  true
+
+js: CoffeeScript.compile 'puts %w{one two three}', {no_wrap: on}
+
+ok js is 'puts(["one", "two", "three"]);'
+
+
+# Finally, let's try an extension that converts `a << b` into `a.push(b)`.
+
+CoffeeScript.extend ->
+  return false unless @chunk.match(/^<</)
+  @i: + 2
+  @token 'PROPERTY_ACCESS', '.'
+  @token 'IDENTIFIER', 'push'
+
+js: CoffeeScript.compile 'a << b', {no_wrap: on}
+
+ok js is 'a.push(b);'
+
+Lexer.extensions: []
+

test/test_compound_assignment.coffee

@@ -0,0 +1,45 @@
+num: 10
+num: - 5
+
+ok num is 5
+
+num: -3
+
+ok num is -3
+
+num: +3
+
+ok num is 3
+
+num = * 10
+
+ok num is 30
+
+num: / 10
+
+ok num is 3
+
+
+val: false
+val: or 'value'
+
+ok val is 'value'
+
+val = and 'other'
+
+ok val is 'other'
+
+
+val: null
+val: ? 'value'
+
+ok val is 'value'
+
+
+val: 6
+val: -(10)
+
+ok val is -10
+
+val: - (10)
+ok val is -20

test/test_comprehensions.coffee

@@ -0,0 +1,94 @@
+# Basic array comprehensions.
+nums:    n * n for n in [1, 2, 3] when n % 2 isnt 0
+results: n * 2 for n in nums
+
+ok results.join(',') is '2,18'
+
+
+# Basic object comprehensions.
+obj:   {one: 1, two: 2, three: 3}
+names: prop + '!' for prop of obj
+odds:  prop + '!' for prop, value of obj when value % 2 isnt 0
+
+ok names.join(' ') is "one! two! three!"
+ok odds.join(' ')  is "one! three!"
+
+
+# Basic range comprehensions.
+nums: i * 3 for i in [1..3]
+
+negs: x for x in [-20..-5*2]
+negs: negs[0..2]
+
+result: nums.concat(negs).join(', ')
+
+ok result is '3, 6, 9, -20, -19, -18'
+
+
+# Ensure that ranges are safe. This used to infinite loop:
+j = 5
+result: for j in [j..(j+3)]
+  j
+
+ok result.join(' ') is '5 6 7 8'
+
+
+# With range comprehensions, you can loop in steps.
+results: x for x in [0..25] by 5
+
+ok results.join(' ') is '0 5 10 15 20 25'
+
+
+# Multiline array comprehension with filter.
+evens: for num in [1, 2, 3, 4, 5, 6] when num % 2 is 0
+           num *= -1
+           num -= 2
+           num * -1
+
+ok evens.join(', ') is '4, 6, 8'
+
+
+# The in operator still works, standalone.
+ok 2 in evens
+
+
+# Ensure that the closure wrapper preserves local variables.
+obj: {}
+
+methods: ['one', 'two', 'three']
+
+for method in methods
+  name: method
+  obj[name]: ->
+    "I'm " + name
+
+ok obj.one()   is "I'm one"
+ok obj.two()   is "I'm two"
+ok obj.three() is "I'm three"
+
+
+# Naked ranges are expanded into arrays.
+array: [0..10]
+ok(num % 2 is 0 for num in array by 2)
+
+
+# Nested comprehensions.
+multi_liner:
+  for x in [3..5]
+    for y in [3..5]
+      [x, y]
+
+single_liner:
+  [x, y] for y in [3..5] for x in [3..5]
+
+ok multi_liner.length is single_liner.length
+ok 5 is multi_liner[2][2][1]
+ok 5 is single_liner[2][2][1]
+
+
+# Comprehensions within parentheses.
+result: null
+store: (obj) -> result: obj
+store (x * 2 for x in [3, 2, 1])
+
+ok result.join(' ') is '6 4 2'

test/test_everything.coffee

@@ -1,31 +0,0 @@
-
-
-func: ->
-  a: 3
-  b: []
-
-  while a >= 0
-    b.push 'o'
-    a--
-
-  c: {
-    "text": b
-    other: null
-    something_else: (x) -> x + 5
-  }
-
-  c: 'error' unless 42 > 41
-
-  c.text: if false
-    'error'
-  else
-    c.text + '---'
-  d = {
-    text = c.text
-  }
-
-  c.list: l for l in d.text.split('') when l is '-'
-
-  c.single: c.list[1..1][0]
-
-ok func() is '-'

test/test_exceptions.coffee

@@ -1,2 +1,19 @@
+# Basic exception throwing.
 block: -> (throw 'up')
-throws block, 'up'
+throws block, 'up'
+
+
+# Basic try/catch.
+result: try
+  10
+finally
+  15
+
+ok result is 10
+
+result: try
+  throw 'up'
+catch err
+  err.length
+
+ok result is 2

test/test_existence.coffee

@@ -6,7 +6,6 @@ ok(if my_special_variable? then true else false)
 
 
 # Existential assignment.
-
 a: 5
 a: null
 a ?= 10
@@ -16,7 +15,6 @@ ok a is 10 and b is 10
 
 
 # The existential operator.
-
 z: null
 x: z ? "EX"
 
@@ -24,7 +22,6 @@ ok z is null and x is "EX"
 
 
 # Only evaluate once.
-
 counter: 0
 get_next_node: ->
   throw "up" if counter
@@ -34,7 +31,6 @@ ok(if get_next_node()? then true else false)
 
 
 # Existence chains, soaking up undefined properties:
-
 obj: {
   prop: "hello"
 }
@@ -53,7 +49,6 @@ ok obj?['non']?['existent'].property is undefined
 
 
 # Soaks and caches method calls as well.
-
 arr: ["--", "----"]
 
 ok arr.pop()?.length is 4

test/test_expressions.coffee

@@ -1,5 +1,4 @@
 # Ensure that we don't wrap Nodes that are "pure_statement" in a closure.
-
 items: [1, 2, 3, "bacon", 4, 5]
 
 for item in items
@@ -14,7 +13,6 @@ ok findit(items) is "bacon"
 
 # When when a closure wrapper is generated for expression conversion, make sure
 # that references to "this" within the wrapper are safely converted as well.
-
 obj: {
   num: 5
   func: ->

test/test_functions.coffee

@@ -33,8 +33,6 @@ obj.unbound()
 obj.bound()
 
 
-# The named function should be cleared out before a call occurs:
-
 # Python decorator style wrapper that memoizes any function
 memoize: (fn) ->
   cache: {}
@@ -73,8 +71,22 @@ result: call ->
 ok result is 10
 
 
-# And even with strange things like this:
+# More fun with optional parens.
+fn: (arg) -> arg
 
+ok fn(fn {prop: 101}).prop is 101
+
+
+# Multi-blocks with optional parens.
+result: fn( ->
+  fn ->
+    "Wrapped"
+)
+
+ok result()() is 'Wrapped'
+
+
+# And even with strange things like this:
 funcs:  [((x) -> x), ((x) -> x * x)]
 result: funcs[1] 5
 
@@ -86,6 +98,34 @@ ok result is 'lo'
 
 
 # And with multiple single-line functions on the same line.
-
 func: (x) -> (x) -> (x) -> x
 ok func(1)(2)(3) is 3
+
+
+# Ensure that functions with the same name don't clash with helper functions.
+del: -> 5
+ok del() is 5
+
+# Ensure that functions can have a trailing comma in their argument list
+mult: (x, mids..., y) ->
+  x: * n for n in mids
+  x: * y
+
+ok mult(1, 2,) is 2
+ok mult(1, 2, 3,) is 6
+ok mult(10,[1..6]...,) is 7200
+
+
+# Test for inline functions with parentheses and implicit calls.
+combine: (func, num) -> func() * num
+result:  combine (-> 1 + 2), 3
+
+ok result is 9
+
+
+# Test for calls/parens/multiline-chains.
+f: (x) -> x
+result: (f 1).toString()
+  .length
+
+ok result is 1

test/test_heredocs.coffee

@@ -49,4 +49,20 @@ ok a is "a\n\n\nb c"
 
 a: '''more"than"one"quote'''
 
-ok a is 'more"than"one"quote'
+ok a is 'more"than"one"quote'
+
+
+val: 10
+
+a: """
+   basic heredoc $val
+   on two lines
+   """
+
+b: '''
+   basic heredoc $val
+   on two lines
+   '''
+
+ok a is "basic heredoc 10\non two lines"
+ok b is "basic heredoc \$val\non two lines"

test/test_if.coffee

@@ -23,4 +23,13 @@ else if NaN
 else
   true
 
-ok result
+ok result
+
+
+# If statement with a comment-only clause.
+result: if false
+  # comment
+else
+  27
+
+ok result is 27

test/test_importing.coffee

@@ -0,0 +1,2 @@
+# Check if we can import and execute a CoffeeScript-only module successfully.
+ok require('./test_module').func() is "from over there"