CoffeeScript 1.1.2

Merge pull request #1542 from MichaelBlume/master
Check for existence of this.context. Avoid build error.
2026-01-14 09:17:55 -05:00 · 2011-08-04 23:17:23 -04:00 · 2011-08-04 13:23:33 -07:00 · 2011-08-01 17:28:52 -04:00 · 2011-07-31 18:45:30 +00:00 · 2011-07-31 13:25:57 -04:00
59 changed files with 1519 additions and 914 deletions
--- a/.npmignore
+++ b/.npmignore
@@ -5,7 +5,7 @@
 Cakefile
 documentation/
 examples/
-extras/
+extras/coffee-script.js
 raw/
 src/
 test/
--- a/50
+++ b/50
@@ -28,10 +28,12 @@ sources = [
 ]

 # Run a CoffeeScript through our node/coffee interpreter.
-run = (args) ->
+run = (args, cb) ->
  proc =         spawn 'bin/coffee', args
  proc.stderr.on 'data', (buffer) -> console.log buffer.toString()
-  proc.on        'exit', (status) -> process.exit(1) if status != 0
+  proc.on        'exit', (status) ->
+    process.exit(1) if status != 0
+    cb() if typeof cb is 'function'

 # Log a message with a color.
 log = (message, color, explanation) ->
@@ -59,17 +61,16 @@ task 'install', 'install CoffeeScript into /usr/local (or --prefix)', (options)
  )


-task 'build', 'build the CoffeeScript language from source', ->
+task 'build', 'build the CoffeeScript language from source', build = (cb) ->
  files = fs.readdirSync 'src'
  files = ('src/' + file for file in files when file.match(/\.coffee$/))
-  run ['-c', '-o', 'lib'].concat(files)
+  run ['-c', '-o', 'lib'].concat(files), cb


 task 'build:full', 'rebuild the source twice, and run the tests', ->
-  exec 'bin/cake build && bin/cake build && bin/cake test', (err, stdout, stderr) ->
-    console.log stdout.trim() if stdout
-    console.log stderr.trim() if stderr
-    throw err    if err
+  build ->
+    build ->
+      process.exit 1 unless runTests CoffeeScript


 task 'build:parser', 'rebuild the Jison parser (run build first)', ->
@@ -152,7 +153,7 @@ runTests = (CoffeeScript) ->
  passedTests = 0
  failures    = []

-  # make "global" reference available to tests
+  # Make "global" reference available to tests
  global.global = global

  # Mix in the assert module globally, to make it available for tests.
@@ -175,7 +176,7 @@ runTests = (CoffeeScript) ->
    catch e
      e.description = description if description?
      e.source      = fn.toString() if fn.toString?
-      failures.push file: currentFile, error: e
+      failures.push filename: currentFile, error: e

  # A recursive functional equivalence helper; uses egal for testing equivalence.
  # See http://wiki.ecmascript.org/doku.php?id=harmony:egal
@@ -201,27 +202,28 @@ runTests = (CoffeeScript) ->
    return log(message, green) unless failures.length
    log "failed #{failures.length} and #{message}", red
    for fail in failures
-      {error, file}      = fail
-      jsFile             = file.replace(/\.coffee$/,'.js')
+      {error, filename}  = fail
+      jsFilename         = filename.replace(/\.coffee$/,'.js')
      match              = error.stack?.match(new RegExp(fail.file+":(\\d+):(\\d+)"))
      match              = error.stack?.match(/on line (\d+):/) unless match
      [match, line, col] = match if match
-      log "\n  #{error.toString()}", red
+      console.log ''
      log "  #{error.description}", red if error.description
-      log "  #{jsFile}: line #{line or 'unknown'}, column #{col or 'unknown'}", red
+      log "  #{error.stack}", red
+      log "  #{jsFilename}: line #{line ? 'unknown'}, column #{col ? 'unknown'}", red
      console.log "  #{error.source}" if error.source
+    return

  # Run every test in the `test` folder, recording failures.
-  fs.readdir 'test', (err, files) ->
-    files.forEach (file) ->
-      return unless file.match(/\.coffee$/i)
-      filename = path.join 'test', file
-      fs.readFile filename, (err, code) ->
-        currentFile = filename
-        try
-          CoffeeScript.run code.toString(), {filename}
-        catch e
-          failures.push file: currentFile, error: e
+  files = fs.readdirSync 'test'
+  for file in files when file.match /\.coffee$/i
+    currentFile = filename = path.join 'test', file
+    code = fs.readFileSync filename
+    try
+      CoffeeScript.run code.toString(), {filename}
+    catch error
+      failures.push {filename, error}
+  return !failures.length


 task 'test', 'run the CoffeeScript language test suite', ->
--- a/documentation/coffee/aliases.coffee
+++ b/documentation/coffee/aliases.coffee
@@ -8,4 +8,4 @@ if car.speed < limit then accelerate()

 winner = yes if pick in [47, 92, 13]

-print inspect "My name is " + @name
+print inspect "My name is #{@name}"
--- a/documentation/coffee/block_comment.coffee
+++ b/documentation/coffee/block_comment.coffee
@@ -1,5 +1,5 @@
 ###
-CoffeeScript Compiler v1.1.0
+CoffeeScript Compiler v1.1.2
 Released under the MIT License
 ###

--- a/documentation/coffee/classes.coffee
+++ b/documentation/coffee/classes.coffee
@@ -2,7 +2,7 @@ class Animal
  constructor: (@name) ->

  move: (meters) ->
-    alert @name + " moved " + meters + "m."
+    alert @name + " moved #{meters}m."

 class Snake extends Animal
  move: ->
--- a/documentation/coffee/expressions_try.coffee
+++ b/documentation/coffee/expressions_try.coffee
@@ -2,6 +2,6 @@ alert(
  try
    nonexistent / undefined
  catch error
-    "And the error is ... " + error
+    "And the error is ... #{error}"
 )

--- a/documentation/coffee/object_comprehensions.coffee
+++ b/documentation/coffee/object_comprehensions.coffee
@@ -1,4 +1,4 @@
 yearsOld = max: 10, ida: 9, tim: 11

 ages = for child, age of yearsOld
-  child + " is " + age
+  "#{child} is #{age}"
--- a/documentation/coffee/while.coffee
+++ b/documentation/coffee/while.coffee
@@ -6,5 +6,5 @@ if this.studyingEconomics
 # Nursery Rhyme
 num = 6
 lyrics = while num -= 1
-  num + " little monkeys, jumping on the bed.
+  "#{num} little monkeys, jumping on the bed.
    One fell out and bumped his head."
--- a/documentation/css/docs.css
+++ b/documentation/css/docs.css
@@ -85,6 +85,10 @@ code, pre, tt, textarea {
  font-weight: normal;
  color: black;
 }
+  .timestamp small {
+    font-size: 11px;
+    text-transform: uppercase;
+  }
 div.code {
  position: relative;
  background: #fff;
--- a/documentation/docs/browser.html
+++ b/documentation/docs/browser.html
@@ -9,10 +9,10 @@
  <span class="nv">xhr.onreadystatechange = </span><span class="o">-&gt;</span>
    <span class="k">if</span> <span class="nx">xhr</span><span class="p">.</span><span class="nx">readyState</span> <span class="o">is</span> <span class="mi">4</span>
      <span class="k">if</span> <span class="nx">xhr</span><span class="p">.</span><span class="nx">status</span> <span class="k">in</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">200</span><span class="p">]</span>
-        <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">run</span> <span class="nx">xhr</span><span class="p">.</span><span class="nx">responseText</span> 
+        <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">run</span> <span class="nx">xhr</span><span class="p">.</span><span class="nx">responseText</span>
      <span class="k">else</span>
        <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;Could not load #{url}&quot;</span>
-      <span class="nx">callback</span><span class="p">()</span> <span class="k">if</span> <span class="nx">callback</span>  
+      <span class="nx">callback</span><span class="p">()</span> <span class="k">if</span> <span class="nx">callback</span>
  <span class="nx">xhr</span><span class="p">.</span><span class="nx">send</span> <span class="kc">null</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-6">&#182;</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.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">runScripts = </span><span class="o">-&gt;</span>
--- a/documentation/docs/cake.html
+++ b/documentation/docs/cake.html
@@ -36,7 +36,7 @@ If no tasks are passed, print the help screen.</p>             </td>
    <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="nb">Array</span><span class="p">(</span><span class="nx">spaces</span> <span class="o">+</span> <span class="mi">1</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">desc   = </span><span class="k">if</span> <span class="nx">task</span><span class="p">.</span><span class="nx">description</span> <span class="k">then</span> <span class="s2">&quot;# #{task.description}&quot;</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span>
    <span class="nx">console</span><span class="p">.</span><span class="nx">log</span> <span class="s2">&quot;cake #{name}#{spaces} #{desc}&quot;</span>
-  <span class="nx">console</span><span class="p">.</span><span class="nx">log</span> <span class="nx">oparse</span><span class="p">.</span><span class="nx">help</span><span class="p">()</span> <span class="k">if</span> <span class="nx">switches</span><span class="p">.</span><span class="nx">length</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#182;</a>               </div>               <p>Print an error and exit when attempting to all an undefined task.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">missingTask = </span><span class="p">(</span><span class="nx">task</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">console</span><span class="p">.</span><span class="nx">log</span> <span class="nx">oparse</span><span class="p">.</span><span class="nx">help</span><span class="p">()</span> <span class="k">if</span> <span class="nx">switches</span><span class="p">.</span><span class="nx">length</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#182;</a>               </div>               <p>Print an error and exit when attempting to call an undefined task.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">missingTask = </span><span class="p">(</span><span class="nx">task</span><span class="p">)</span> <span class="o">-&gt;</span>
  <span class="nx">console</span><span class="p">.</span><span class="nx">log</span> <span class="s2">&quot;No such task: \&quot;#{task}\&quot;&quot;</span>
  <span class="nx">process</span><span class="p">.</span><span class="nx">exit</span> <span class="mi">1</span>

--- a/documentation/docs/coffee-script.html
+++ b/documentation/docs/coffee-script.html
@@ -6,14 +6,15 @@ 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><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">vm               = </span><span class="nx">require</span> <span class="s1">&#39;vm&#39;</span>
+<span class="p">{</span><span class="nx">Script</span><span class="p">}</span>         <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;vm&#39;</span>
+<span class="nv">Module           = </span><span class="nx">require</span> <span class="s1">&#39;module&#39;</span>
 <span class="p">{</span><span class="nx">Lexer</span><span class="p">,</span><span class="nx">RESERVED</span><span class="p">}</span> <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;./lexer&#39;</span>
 <span class="p">{</span><span class="nx">parser</span><span class="p">}</span>         <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;./parser&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-2">&#182;</a>               </div>               <p>TODO: Remove registerExtension when fully deprecated.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">if</span> <span class="nx">require</span><span class="p">.</span><span class="nx">extensions</span>
  <span class="nx">require</span><span class="p">.</span><span class="nx">extensions</span><span class="p">[</span><span class="s1">&#39;.coffee&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="p">(</span><span class="nx">module</span><span class="p">,</span> <span class="nx">filename</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nv">content = </span><span class="nx">compile</span> <span class="nx">fs</span><span class="p">.</span><span class="nx">readFileSync</span><span class="p">(</span><span class="nx">filename</span><span class="p">,</span> <span class="s1">&#39;utf8&#39;</span><span class="p">),</span> <span class="p">{</span><span class="nx">filename</span><span class="p">}</span>
    <span class="nx">module</span><span class="p">.</span><span class="nx">_compile</span> <span class="nx">content</span><span class="p">,</span> <span class="nx">filename</span>
 <span class="k">else</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></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-3">&#182;</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;1.1.0&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>Words that cannot be used as identifiers in CoffeeScript code</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.RESERVED = </span><span class="nx">RESERVED</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-5">&#182;</a>               </div>               <p>Expose helpers for testing.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.helpers = </span><span class="nx">require</span> <span class="s1">&#39;./helpers&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-6">&#182;</a>               </div>               <p>Compile a string of CoffeeScript code to JavaScript, using the Coffee/Jison
+  <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></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-3">&#182;</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;1.1.2&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>Words that cannot be used as identifiers in CoffeeScript code</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.RESERVED = </span><span class="nx">RESERVED</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-5">&#182;</a>               </div>               <p>Expose helpers for testing.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.helpers = </span><span class="nx">require</span> <span class="s1">&#39;./helpers&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-6">&#182;</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="nv">options = </span><span class="p">{})</span> <span class="o">-&gt;</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>
@@ -27,28 +28,36 @@ or traverse it by using <code>.traverse()</code> with a callback.</p>
    <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">source</span><span class="p">,</span> <span class="nx">options</span>
  <span class="k">else</span>
    <span class="nx">parser</span><span class="p">.</span><span class="nx">parse</span> <span class="nx">source</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-9">&#182;</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></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#182;</a>               </div>               <p>We want the root module.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">root = </span><span class="nx">module</span>
-  <span class="k">while</span> <span class="nx">root</span><span class="p">.</span><span class="nx">parent</span>
-    <span class="nv">root = </span><span class="nx">root</span><span class="p">.</span><span class="nx">parent</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-11">&#182;</a>               </div>               <p>Set the filename.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">root.filename = </span><span class="nx">process</span><span class="p">.</span><span class="nx">argv</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span>
-      <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">filename</span> <span class="k">then</span> <span class="nx">fs</span><span class="p">.</span><span class="nx">realpathSync</span><span class="p">(</span><span class="nx">options</span><span class="p">.</span><span class="nx">filename</span><span class="p">)</span> <span class="k">else</span> <span class="s1">&#39;.&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-12">&#182;</a>               </div>               <p>Clear the module cache.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">root.moduleCache = </span><span class="p">{}</span> <span class="k">if</span> <span class="nx">root</span><span class="p">.</span><span class="nx">moduleCache</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-13">&#182;</a>               </div>               <p>Assign paths for node_modules loading</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">if</span> <span class="nx">process</span><span class="p">.</span><span class="nx">binding</span><span class="p">(</span><span class="s1">&#39;natives&#39;</span><span class="p">).</span><span class="nx">module</span>
+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">mainModule = </span><span class="nx">require</span><span class="p">.</span><span class="nx">main</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#182;</a>               </div>               <p>Set the filename.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">mainModule.filename = </span><span class="nx">process</span><span class="p">.</span><span class="nx">argv</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span>
+      <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">filename</span> <span class="k">then</span> <span class="nx">fs</span><span class="p">.</span><span class="nx">realpathSync</span><span class="p">(</span><span class="nx">options</span><span class="p">.</span><span class="nx">filename</span><span class="p">)</span> <span class="k">else</span> <span class="s1">&#39;.&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-11">&#182;</a>               </div>               <p>Clear the module cache.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">mainModule</span><span class="p">.</span><span class="nx">moduleCache</span> <span class="o">and=</span> <span class="p">{}</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-12">&#182;</a>               </div>               <p>Assign paths for node_modules loading</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">if</span> <span class="nx">process</span><span class="p">.</span><span class="nx">binding</span><span class="p">(</span><span class="s1">&#39;natives&#39;</span><span class="p">).</span><span class="nx">module</span>
    <span class="p">{</span><span class="nx">Module</span><span class="p">}</span> <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;module&#39;</span>
-    <span class="nv">root.paths = </span><span class="nx">Module</span><span class="p">.</span><span class="nx">_nodeModulePaths</span> <span class="nx">path</span><span class="p">.</span><span class="nx">dirname</span> <span class="nx">options</span><span class="p">.</span><span class="nx">filename</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-14">&#182;</a>               </div>               <p>Compile.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">if</span> <span class="nx">path</span><span class="p">.</span><span class="nx">extname</span><span class="p">(</span><span class="nx">root</span><span class="p">.</span><span class="nx">filename</span><span class="p">)</span> <span class="o">isnt</span> <span class="s1">&#39;.coffee&#39;</span> <span class="o">or</span> <span class="nx">require</span><span class="p">.</span><span class="nx">extensions</span>
-    <span class="nx">root</span><span class="p">.</span><span class="nx">_compile</span> <span class="nx">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="nx">root</span><span class="p">.</span><span class="nx">filename</span>
+    <span class="nv">mainModule.paths = </span><span class="nx">Module</span><span class="p">.</span><span class="nx">_nodeModulePaths</span> <span class="nx">path</span><span class="p">.</span><span class="nx">dirname</span> <span class="nx">options</span><span class="p">.</span><span class="nx">filename</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-13">&#182;</a>               </div>               <p>Compile.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">if</span> <span class="nx">path</span><span class="p">.</span><span class="nx">extname</span><span class="p">(</span><span class="nx">mainModule</span><span class="p">.</span><span class="nx">filename</span><span class="p">)</span> <span class="o">isnt</span> <span class="s1">&#39;.coffee&#39;</span> <span class="o">or</span> <span class="nx">require</span><span class="p">.</span><span class="nx">extensions</span>
+    <span class="nx">mainModule</span><span class="p">.</span><span class="nx">_compile</span> <span class="nx">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="nx">mainModule</span><span class="p">.</span><span class="nx">filename</span>
  <span class="k">else</span>
-    <span class="nx">root</span><span class="p">.</span><span class="nx">_compile</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">root</span><span class="p">.</span><span class="nx">filename</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-15">&#182;</a>               </div>               <p>Compile and evaluate a string of CoffeeScript (in a Node.js-like environment).
+    <span class="nx">mainModule</span><span class="p">.</span><span class="nx">_compile</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">mainModule</span><span class="p">.</span><span class="nx">filename</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-14">&#182;</a>               </div>               <p>Compile and evaluate a string of CoffeeScript (in a Node.js-like environment).
 The CoffeeScript REPL uses this to run the input.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.eval = </span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nv">options = </span><span class="p">{})</span> <span class="o">-&gt;</span>
-  <span class="nv">sandbox = </span><span class="nx">options</span><span class="p">.</span><span class="nx">sandbox</span>
-  <span class="nx">unless</span> <span class="nx">sandbox</span>
-    <span class="nv">sandbox =</span>
-      <span class="nx">require</span><span class="o">:</span> <span class="nx">require</span>
-      <span class="nx">module</span> <span class="o">:</span> <span class="p">{</span> <span class="nx">exports</span><span class="o">:</span> <span class="p">{}</span> <span class="p">}</span>
-    <span class="nx">sandbox</span><span class="p">[</span><span class="nx">g</span><span class="p">]</span> <span class="o">=</span> <span class="nx">global</span><span class="p">[</span><span class="nx">g</span><span class="p">]</span> <span class="k">for</span> <span class="nx">g</span> <span class="k">of</span> <span class="nx">global</span>
-    <span class="nv">sandbox.global = </span><span class="nx">sandbox</span>
-    <span class="nv">sandbox.global.global = sandbox.global.root = sandbox.global.GLOBAL = </span><span class="nx">sandbox</span>
+  <span class="k">return</span> <span class="nx">unless</span> <span class="nv">code = </span><span class="nx">code</span><span class="p">.</span><span class="nx">trim</span><span class="p">()</span>
+  <span class="nv">sandbox = </span><span class="nx">Script</span><span class="p">.</span><span class="nx">createContext</span><span class="p">()</span>
+  <span class="nv">sandbox.global = sandbox.root = sandbox.GLOBAL = </span><span class="nx">sandbox</span>
+  <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">sandbox</span><span class="o">?</span>
+    <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">sandbox</span> <span class="k">instanceof</span> <span class="nx">sandbox</span><span class="p">.</span><span class="nx">constructor</span>
+      <span class="nv">sandbox = </span><span class="nx">options</span><span class="p">.</span><span class="nx">sandbox</span>
+    <span class="k">else</span>
+      <span class="nx">sandbox</span><span class="p">[</span><span class="nx">k</span><span class="p">]</span> <span class="o">=</span> <span class="nx">v</span> <span class="k">for</span> <span class="nx">own</span> <span class="nx">k</span><span class="p">,</span> <span class="nx">v</span> <span class="k">of</span> <span class="nx">options</span><span class="p">.</span><span class="nx">sandbox</span>
  <span class="nv">sandbox.__filename = </span><span class="nx">options</span><span class="p">.</span><span class="nx">filename</span> <span class="o">||</span> <span class="s1">&#39;eval&#39;</span>
-  <span class="nv">sandbox.__dirname  = </span><span class="nx">path</span><span class="p">.</span><span class="nx">dirname</span> <span class="nx">sandbox</span><span class="p">.</span><span class="nx">__filename</span>
-  <span class="nv">js = </span><span class="nx">compile</span> <span class="s2">&quot;_=(#{code.trim()})&quot;</span><span class="p">,</span> <span class="nx">options</span>
-  <span class="nx">vm</span><span class="p">.</span><span class="nx">runInNewContext</span> <span class="nx">js</span><span class="p">,</span> <span class="nx">sandbox</span><span class="p">,</span> <span class="nx">sandbox</span><span class="p">.</span><span class="nx">__filename</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-16">&#182;</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></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-17">&#182;</a>               </div>               <p>The real Lexer produces a generic stream of tokens. This object provides a
+  <span class="nv">sandbox.__dirname  = </span><span class="nx">path</span><span class="p">.</span><span class="nx">dirname</span> <span class="nx">sandbox</span><span class="p">.</span><span class="nx">__filename</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-15">&#182;</a>               </div>               <p>define module/require only if they chose not to specify their own</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">unless</span> <span class="nx">sandbox</span><span class="p">.</span><span class="nx">module</span> <span class="o">or</span> <span class="nx">sandbox</span><span class="p">.</span><span class="nx">require</span>
+    <span class="nv">Module = </span><span class="nx">require</span> <span class="s1">&#39;module&#39;</span>
+    <span class="nv">sandbox.module  = _module  = </span><span class="k">new</span> <span class="nx">Module</span><span class="p">(</span><span class="nx">options</span><span class="p">.</span><span class="nx">modulename</span> <span class="o">||</span> <span class="s1">&#39;eval&#39;</span><span class="p">)</span>
+    <span class="nv">sandbox.require = _require = </span><span class="p">(</span><span class="nx">path</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">Module</span><span class="p">.</span><span class="nx">_load</span> <span class="nx">path</span><span class="p">,</span> <span class="nx">_module</span>
+    <span class="nv">_module.filename = </span><span class="nx">sandbox</span><span class="p">.</span><span class="nx">__filename</span>
+    <span class="nx">_require</span><span class="p">[</span><span class="nx">r</span><span class="p">]</span> <span class="o">=</span> <span class="nx">require</span><span class="p">[</span><span class="nx">r</span><span class="p">]</span> <span class="k">for</span> <span class="nx">r</span> <span class="k">in</span> <span class="nb">Object</span><span class="p">.</span><span class="nx">getOwnPropertyNames</span> <span class="nx">require</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-16">&#182;</a>               </div>               <p>use the same hack node currently uses for their own REPL</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="nv">_require.paths = _module.paths = </span><span class="nx">Module</span><span class="p">.</span><span class="nx">_nodeModulePaths</span> <span class="nx">process</span><span class="p">.</span><span class="nx">cwd</span><span class="p">()</span>
+    <span class="nv">_require.resolve = </span><span class="p">(</span><span class="nx">request</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">Module</span><span class="p">.</span><span class="nx">_resolveFilename</span> <span class="nx">request</span><span class="p">,</span> <span class="nx">_module</span>
+  <span class="nv">o = </span><span class="p">{}</span>
+  <span class="nx">o</span><span class="p">[</span><span class="nx">k</span><span class="p">]</span> <span class="o">=</span> <span class="nx">v</span> <span class="k">for</span> <span class="nx">own</span> <span class="nx">k</span><span class="p">,</span> <span class="nx">v</span> <span class="k">of</span> <span class="nx">options</span>
+  <span class="nv">o.bare = </span><span class="kc">on</span> <span class="c1"># ensure return value</span>
+  <span class="nv">js = </span><span class="nx">compile</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">o</span>
+  <span class="nx">Script</span><span class="p">.</span><span class="nx">runInContext</span> <span class="nx">js</span><span class="p">,</span> <span class="nx">sandbox</span></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-17">&#182;</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></pre></div>             </td>           </tr>                               <tr id="section-18">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-18">&#182;</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="nx">lex</span><span class="o">:</span> <span class="o">-&gt;</span>
--- a/documentation/docs/command.html
+++ b/documentation/docs/command.html
@@ -1,6 +1,6 @@
 <!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="browser.html">                 browser.coffee               </a>                                           <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="index.html">                 index.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="pilwrap">                 <a class="pilcrow" href="#section-1">&#182;</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
+<a href="http://javascriptlint.com/">JavaScript Lint</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="pilwrap">                 <a class="pilcrow" href="#section-2">&#182;</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>
@@ -20,7 +20,7 @@ interactive REPL.</p>             </td>             <td class="code">
  <span class="p">[</span><span class="s1">&#39;-j&#39;</span><span class="p">,</span> <span class="s1">&#39;--join [FILE]&#39;</span><span class="p">,</span>     <span class="s1">&#39;concatenate the scripts before compiling&#39;</span><span class="p">]</span>
  <span class="p">[</span><span class="s1">&#39;-w&#39;</span><span class="p">,</span> <span class="s1">&#39;--watch&#39;</span><span class="p">,</span>           <span class="s1">&#39;watch scripts for changes, and recompile&#39;</span><span class="p">]</span>
  <span class="p">[</span><span class="s1">&#39;-p&#39;</span><span class="p">,</span> <span class="s1">&#39;--print&#39;</span><span class="p">,</span>           <span class="s1">&#39;print the compiled JavaScript to stdout&#39;</span><span class="p">]</span>
-  <span class="p">[</span><span class="s1">&#39;-l&#39;</span><span class="p">,</span> <span class="s1">&#39;--lint&#39;</span><span class="p">,</span>            <span class="s1">&#39;pipe the compiled JavaScript through JSLint&#39;</span><span class="p">]</span>
+  <span class="p">[</span><span class="s1">&#39;-l&#39;</span><span class="p">,</span> <span class="s1">&#39;--lint&#39;</span><span class="p">,</span>            <span class="s1">&#39;pipe the compiled JavaScript through JavaScript Lint&#39;</span><span class="p">]</span>
  <span class="p">[</span><span class="s1">&#39;-s&#39;</span><span class="p">,</span> <span class="s1">&#39;--stdio&#39;</span><span class="p">,</span>           <span class="s1">&#39;listen for and compile scripts over stdio&#39;</span><span class="p">]</span>
  <span class="p">[</span><span class="s1">&#39;-e&#39;</span><span class="p">,</span> <span class="s1">&#39;--eval&#39;</span><span class="p">,</span>            <span class="s1">&#39;compile a string from the command line&#39;</span><span class="p">]</span>
  <span class="p">[</span><span class="s1">&#39;-r&#39;</span><span class="p">,</span> <span class="s1">&#39;--require [FILE*]&#39;</span><span class="p">,</span> <span class="s1">&#39;require a library before executing your script&#39;</span><span class="p">]</span>
@@ -49,30 +49,48 @@ Many flags cause us to divert before compiling anything. Flags passed after
    <span class="nv">opts.literals = </span><span class="nx">sources</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="mi">1</span><span class="p">).</span><span class="nx">concat</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">literals</span>
  <span class="nv">process.ARGV = process.argv = </span><span class="nx">process</span><span class="p">.</span><span class="nx">argv</span><span class="p">.</span><span class="nx">slice</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">).</span><span class="nx">concat</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">literals</span>
  <span class="nx">process</span><span class="p">.</span><span class="nx">argv</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;coffee&#39;</span>
-  <span class="nv">process.execPath = </span><span class="nx">process</span><span class="p">.</span><span class="nx">mainModule</span><span class="p">.</span><span class="nx">filename</span>
+  <span class="nv">process.execPath = </span><span class="nx">require</span><span class="p">.</span><span class="nx">main</span><span class="p">.</span><span class="nx">filename</span>
  <span class="nx">compileScripts</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-8">&#182;</a>               </div>               <p>Asynchronously read in each CoffeeScript in a list of source files and
 compile them. If a directory is passed, recursively compile all
 '.coffee' extension source files in it and all subdirectories.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">compileScripts = </span><span class="o">-&gt;</span>
+  <span class="nv">unprocessed = </span><span class="p">[]</span>
+  <span class="k">for</span> <span class="nx">source</span> <span class="k">in</span> <span class="nx">sources</span>
+    <span class="nx">unprocessed</span><span class="p">[</span><span class="nx">sources</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">source</span><span class="p">)]</span><span class="o">=</span><span class="mi">1</span>
  <span class="k">for</span> <span class="nx">source</span> <span class="k">in</span> <span class="nx">sources</span>
    <span class="nv">base = </span><span class="nx">path</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="nx">source</span><span class="p">)</span>
-    <span class="nv">compile = </span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">topLevel</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="nv">compile = </span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">sourceIndex</span><span class="p">,</span> <span class="nx">topLevel</span><span class="p">)</span> <span class="o">-&gt;</span>
+      <span class="nv">remaining_files = </span><span class="o">-&gt;</span>
+        <span class="nv">total = </span><span class="mi">0</span>
+        <span class="nx">total</span> <span class="o">+=</span> <span class="nx">x</span> <span class="k">for</span> <span class="nx">x</span> <span class="k">in</span> <span class="nx">unprocessed</span>
+        <span class="nx">total</span>
      <span class="nx">path</span><span class="p">.</span><span class="nx">exists</span> <span class="nx">source</span><span class="p">,</span> <span class="p">(</span><span class="nx">exists</span><span class="p">)</span> <span class="o">-&gt;</span>
+        <span class="k">if</span> <span class="nx">topLevel</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">exists</span> <span class="o">and</span> <span class="nx">source</span><span class="p">[</span><span class="o">-</span><span class="mi">7</span><span class="p">..]</span> <span class="o">isnt</span> <span class="s1">&#39;.coffee&#39;</span>
+            <span class="k">return</span> <span class="nx">compile</span> <span class="s2">&quot;#{source}.coffee&quot;</span><span class="p">,</span> <span class="nx">sourceIndex</span><span class="p">,</span> <span class="nx">topLevel</span>
+                
        <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;File not found: #{source}&quot;</span> <span class="k">if</span> <span class="nx">topLevel</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">exists</span>
        <span class="nx">fs</span><span class="p">.</span><span class="nx">stat</span> <span class="nx">source</span><span class="p">,</span> <span class="p">(</span><span class="nx">err</span><span class="p">,</span> <span class="nx">stats</span><span class="p">)</span> <span class="o">-&gt;</span>
          <span class="k">throw</span> <span class="nx">err</span> <span class="k">if</span> <span class="nx">err</span>
          <span class="k">if</span> <span class="nx">stats</span><span class="p">.</span><span class="nx">isDirectory</span><span class="p">()</span>
            <span class="nx">fs</span><span class="p">.</span><span class="nx">readdir</span> <span class="nx">source</span><span class="p">,</span> <span class="p">(</span><span class="nx">err</span><span class="p">,</span> <span class="nx">files</span><span class="p">)</span> <span class="o">-&gt;</span>
+              <span class="k">throw</span> <span class="nx">err</span> <span class="k">if</span> <span class="nx">err</span>
+              <span class="nx">unprocessed</span><span class="p">[</span><span class="nx">sourceIndex</span><span class="p">]</span> <span class="o">+=</span> <span class="nx">files</span><span class="p">.</span><span class="nx">length</span>
              <span class="k">for</span> <span class="nx">file</span> <span class="k">in</span> <span class="nx">files</span>
-                <span class="nx">compile</span> <span class="nx">path</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">file</span><span class="p">)</span>
+                <span class="nx">compile</span> <span class="nx">path</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">file</span><span class="p">),</span> <span class="nx">sourceIndex</span>
+              <span class="nx">unprocessed</span><span class="p">[</span><span class="nx">sourceIndex</span><span class="p">]</span> <span class="o">-=</span> <span class="mi">1</span>
          <span class="k">else</span> <span class="k">if</span> <span class="nx">topLevel</span> <span class="o">or</span> <span class="nx">path</span><span class="p">.</span><span class="nx">extname</span><span class="p">(</span><span class="nx">source</span><span class="p">)</span> <span class="o">is</span> <span class="s1">&#39;.coffee&#39;</span>
            <span class="nx">fs</span><span class="p">.</span><span class="nx">readFile</span> <span class="nx">source</span><span class="p">,</span> <span class="p">(</span><span class="nx">err</span><span class="p">,</span> <span class="nx">code</span><span class="p">)</span> <span class="o">-&gt;</span>
+              <span class="k">throw</span> <span class="nx">err</span> <span class="k">if</span> <span class="nx">err</span>
+              <span class="nx">unprocessed</span><span class="p">[</span><span class="nx">sourceIndex</span><span class="p">]</span> <span class="o">-=</span> <span class="mi">1</span>
              <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">join</span>
-                <span class="nx">contents</span><span class="p">[</span><span class="nx">sources</span><span class="p">.</span><span class="nx">indexOf</span> <span class="nx">source</span><span class="p">]</span> <span class="o">=</span> <span class="nx">code</span><span class="p">.</span><span class="nx">toString</span><span class="p">()</span>
-                <span class="nx">compileJoin</span><span class="p">()</span> <span class="k">if</span> <span class="nx">helpers</span><span class="p">.</span><span class="nx">compact</span><span class="p">(</span><span class="nx">contents</span><span class="p">).</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="mi">0</span>
+                <span class="nx">contents</span><span class="p">[</span><span class="nx">sourceIndex</span><span class="p">]</span> <span class="o">=</span> <span class="nx">helpers</span><span class="p">.</span><span class="nx">compact</span><span class="p">([</span><span class="nx">contents</span><span class="p">[</span><span class="nx">sourceIndex</span><span class="p">],</span> <span class="nx">code</span><span class="p">.</span><span class="nx">toString</span><span class="p">()]).</span><span class="nx">join</span><span class="p">(</span><span class="s1">&#39;\n&#39;</span><span class="p">)</span>
+                <span class="k">if</span> <span class="nx">helpers</span><span class="p">.</span><span class="nx">compact</span><span class="p">(</span><span class="nx">contents</span><span class="p">).</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="mi">0</span> <span class="o">and</span> <span class="nx">remaining_files</span><span class="p">()</span> <span class="o">==</span> <span class="mi">0</span>
+                  <span class="nx">compileJoin</span><span class="p">()</span>
              <span class="k">else</span>
                <span class="nx">compileScript</span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">code</span><span class="p">.</span><span class="nx">toString</span><span class="p">(),</span> <span class="nx">base</span><span class="p">)</span>
            <span class="nx">watch</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">base</span> <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">watch</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">join</span>
-    <span class="nx">compile</span> <span class="nx">source</span><span class="p">,</span> <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-9">&#182;</a>               </div>               <p>Compile a single source script, containing the given code, according to the
+          <span class="k">else</span>
+            <span class="nx">unprocessed</span><span class="p">[</span><span class="nx">sourceIndex</span><span class="p">]</span> <span class="o">-=</span> <span class="mi">1</span>
+    <span class="nx">compile</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">sources</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">source</span><span class="p">),</span> <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-9">&#182;</a>               </div>               <p>Compile a single source script, containing the given code, according to the
 requested options. If evaluating the script directly sets <code>__filename</code>,
 <code>__dirname</code> and <code>module.filename</code> to be correct relative to the script's path.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">compileScript = </span><span class="p">(</span><span class="nx">file</span><span class="p">,</span> <span class="nx">input</span><span class="p">,</span> <span class="nx">base</span><span class="p">)</span> <span class="o">-&gt;</span>
  <span class="nv">o = </span><span class="nx">opts</span>
--- a/documentation/docs/docco.css
+++ b/documentation/docs/docco.css
@@ -115,7 +115,7 @@ table td {
  }
    pre, tt, code {
      font-size: 12px; line-height: 18px;
-      font-family: Menlo, Monaco, Consolas, "Lucida Console", monospace;
+      font-family: Monaco, Consolas, "Lucida Console", monospace;
      margin: 0; padding: 0;
    }

--- a/documentation/docs/grammar.html
+++ b/documentation/docs/grammar.html
@@ -53,7 +53,7 @@ all parsing must end here.</p>             </td>             <td class="code">
    <span class="nx">o</span> <span class="s1">&#39;STATEMENT&#39;</span><span class="p">,</span>                              <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="nx">$1</span>
  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-12">&#182;</a>               </div>               <p>All the different types of expressions in our language. The basic unit of
 CoffeeScript is the <strong>Expression</strong> -- everything that can be an expression
-is one. Block serve as the building blocks of many other rules, making
+is one. Blocks serve as the building blocks of many other rules, making
 them somewhat circular.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Expression</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;Value&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;Invocation&#39;</span>
@@ -77,7 +77,7 @@ token stream.</p>             </td>             <td class="code">
 they can also serve as keys in object literals.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">AlphaNumeric</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;NUMBER&#39;</span><span class="p">,</span>                                 <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="nx">$1</span>
    <span class="nx">o</span> <span class="s1">&#39;STRING&#39;</span><span class="p">,</span>                                 <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-16">&#182;</a>               </div>               <p>All of our immediate values. These can (in general), be passed straight
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-16">&#182;</a>               </div>               <p>All of our immediate values. Generally these can be passed straight
 through and printed to JavaScript.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Literal</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;AlphaNumeric&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;JS&#39;</span><span class="p">,</span>                                     <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="nx">$1</span>
@@ -128,57 +128,55 @@ that hoovers up the remaining arguments.</p>             </td>             <td c
    <span class="nx">o</span> <span class="s1">&#39;ParamVar&#39;</span><span class="p">,</span>                               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Param</span> <span class="nx">$1</span>
    <span class="nx">o</span> <span class="s1">&#39;ParamVar ...&#39;</span><span class="p">,</span>                           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Param</span> <span class="nx">$1</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="kc">on</span>
    <span class="nx">o</span> <span class="s1">&#39;ParamVar = Expression&#39;</span><span class="p">,</span>                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Param</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
-  <span class="p">]</span>
-
-  <span class="nx">ParamVar</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-26">&#182;</a>               </div>               <p>Function Parameters</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">ParamVar</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;Identifier&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;ThisProperty&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;Array&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;Object&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-26">&#182;</a>               </div>               <p>A splat that occurs outside of a parameter list.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Splat</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-27">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-27">&#182;</a>               </div>               <p>A splat that occurs outside of a parameter list.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Splat</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;Expression ...&#39;</span><span class="p">,</span>                         <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Splat</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-27">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-27">&#182;</a>               </div>               <p>Variables and properties that can be assigned to.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">SimpleAssignable</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-28">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-28">&#182;</a>               </div>               <p>Variables and properties that can be assigned to.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">SimpleAssignable</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;Identifier&#39;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
    <span class="nx">o</span> <span class="s1">&#39;Value Accessor&#39;</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="s1">&#39;Invocation Accessor&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</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="s1">&#39;ThisProperty&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-28">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-28">&#182;</a>               </div>               <p>Everything that can be assigned to.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Assignable</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-29">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-29">&#182;</a>               </div>               <p>Everything that can be assigned to.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Assignable</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;SimpleAssignable&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;Array&#39;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
    <span class="nx">o</span> <span class="s1">&#39;Object&#39;</span><span class="p">,</span>                                 <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-29">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-29">&#182;</a>               </div>               <p>The types of things that can be treated as values -- assigned to, invoked
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-30">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-30">&#182;</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="nx">Value</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;Assignable&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;Literal&#39;</span><span class="p">,</span>                                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
    <span class="nx">o</span> <span class="s1">&#39;Parenthetical&#39;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
    <span class="nx">o</span> <span class="s1">&#39;Range&#39;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
    <span class="nx">o</span> <span class="s1">&#39;This&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-30">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-30">&#182;</a>               </div>               <p>The general group of accessors into an object, by property, by prototype
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-31">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-31">&#182;</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="nx">Accessor</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;.  Identifier&#39;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Access</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;?. Identifier&#39;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Access</span> <span class="nx">$2</span><span class="p">,</span> <span class="s1">&#39;soak&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;:: Identifier&#39;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Access</span> <span class="nx">$2</span><span class="p">,</span> <span class="s1">&#39;proto&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;::&#39;</span><span class="p">,</span>                                     <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Access</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;prototype&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;Index&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-31">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-31">&#182;</a>               </div>               <p>Indexing into an object or array using bracket notation.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Index</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-32">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-32">&#182;</a>               </div>               <p>Indexing into an object or array using bracket notation.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Index</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;INDEX_START IndexValue INDEX_END&#39;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;INDEX_SOAK  Index&#39;</span><span class="p">,</span>                      <span class="o">-&gt;</span> <span class="nx">extend</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">soak</span> <span class="o">:</span> <span class="kc">yes</span>
    <span class="nx">o</span> <span class="s1">&#39;INDEX_PROTO Index&#39;</span><span class="p">,</span>                      <span class="o">-&gt;</span> <span class="nx">extend</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">proto</span><span class="o">:</span> <span class="kc">yes</span>
  <span class="p">]</span>
-  
+
  <span class="nx">IndexValue</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;Expression&#39;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Index</span> <span class="nx">$1</span>
    <span class="nx">o</span> <span class="s1">&#39;Slice&#39;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Slice</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-32">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-32">&#182;</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-33">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-33">&#182;</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="s1">&#39;{ AssignList OptComma }&#39;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Obj</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">generated</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-33">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-33">&#182;</a>               </div>               <p>Assignment of properties within an object literal can be separated by
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-34">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-34">&#182;</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="nx">AssignList</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;&#39;</span><span class="p">,</span>                                                       <span class="o">-&gt;</span> <span class="p">[]</span>
    <span class="nx">o</span> <span class="s1">&#39;AssignObj&#39;</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="s1">&#39;AssignList , AssignObj&#39;</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="nx">o</span> <span class="s1">&#39;AssignList OptComma TERMINATOR AssignObj&#39;</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">$4</span>
    <span class="nx">o</span> <span class="s1">&#39;AssignList OptComma INDENT AssignList OptComma OUTDENT&#39;</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">$4</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-34">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-34">&#182;</a>               </div>               <p>Class definitions have optional bodies of prototype property assignments,
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-35">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-35">&#182;</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="nx">Class</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;CLASS&#39;</span><span class="p">,</span>                                      <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Class</span>
    <span class="nx">o</span> <span class="s1">&#39;CLASS Block&#39;</span><span class="p">,</span>                                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Class</span> <span class="kc">null</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">$2</span>
@@ -188,35 +186,35 @@ and optional references to the superclass.</p>             </td>             <td
    <span class="nx">o</span> <span class="s1">&#39;CLASS SimpleAssignable Block&#39;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Class</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="s1">&#39;CLASS SimpleAssignable EXTENDS Value&#39;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Class</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$4</span>
    <span class="nx">o</span> <span class="s1">&#39;CLASS SimpleAssignable EXTENDS Value Block&#39;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Class</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-35">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-35">&#182;</a>               </div>               <p>Ordinary function invocation, or a chained series of calls.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Invocation</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-36">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-36">&#182;</a>               </div>               <p>Ordinary function invocation, or a chained series of calls.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Invocation</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;Value OptFuncExist Arguments&#39;</span><span class="p">,</span>           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Call</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;Invocation OptFuncExist Arguments&#39;</span><span class="p">,</span>      <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Call</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;SUPER&#39;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Call</span> <span class="s1">&#39;super&#39;</span><span class="p">,</span> <span class="p">[</span><span class="k">new</span> <span class="nx">Splat</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;arguments&#39;</span><span class="p">]</span>
    <span class="nx">o</span> <span class="s1">&#39;SUPER Arguments&#39;</span><span class="p">,</span>                        <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Call</span> <span class="s1">&#39;super&#39;</span><span class="p">,</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-36">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-36">&#182;</a>               </div>               <p>An optional existence check on a function.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">OptFuncExist</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-37">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-37">&#182;</a>               </div>               <p>An optional existence check on a function.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">OptFuncExist</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;&#39;</span><span class="p">,</span>                                       <span class="o">-&gt;</span> <span class="kc">no</span>
    <span class="nx">o</span> <span class="s1">&#39;FUNC_EXIST&#39;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="kc">yes</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-37">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-37">&#182;</a>               </div>               <p>The list of arguments to a function call.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Arguments</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-38">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-38">&#182;</a>               </div>               <p>The list of arguments to a function call.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Arguments</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;CALL_START CALL_END&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="p">[]</span>
    <span class="nx">o</span> <span class="s1">&#39;CALL_START ArgList OptComma CALL_END&#39;</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-38">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-38">&#182;</a>               </div>               <p>A reference to the <em>this</em> current object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">This</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-39">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-39">&#182;</a>               </div>               <p>A reference to the <em>this</em> current object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">This</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;THIS&#39;</span><span class="p">,</span>                                   <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;this&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;@&#39;</span><span class="p">,</span>                                      <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;this&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-39">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-39">&#182;</a>               </div>               <p>A reference to a property on <em>this</em>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">ThisProperty</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-40">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-40">&#182;</a>               </div>               <p>A reference to a property on <em>this</em>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">ThisProperty</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;@ Identifier&#39;</span><span class="p">,</span>                           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="k">new</span> <span class="nx">Literal</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">Access</span><span class="p">(</span><span class="nx">$2</span><span class="p">)],</span> <span class="s1">&#39;this&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-40">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-40">&#182;</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-41">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-41">&#182;</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="s1">&#39;[ ]&#39;</span><span class="p">,</span>                                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Arr</span> <span class="p">[]</span>
    <span class="nx">o</span> <span class="s1">&#39;[ ArgList OptComma ]&#39;</span><span class="p">,</span>                   <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Arr</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-41">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-41">&#182;</a>               </div>               <p>Inclusive and exclusive range dots.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">RangeDots</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-42">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-42">&#182;</a>               </div>               <p>Inclusive and exclusive range dots.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">RangeDots</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;..&#39;</span><span class="p">,</span>                                     <span class="o">-&gt;</span> <span class="s1">&#39;inclusive&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;...&#39;</span><span class="p">,</span>                                    <span class="o">-&gt;</span> <span class="s1">&#39;exclusive&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-42">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-42">&#182;</a>               </div>               <p>The CoffeeScript range literal.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Range</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-43">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-43">&#182;</a>               </div>               <p>The CoffeeScript range literal.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Range</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;[ Expression RangeDots Expression ]&#39;</span><span class="p">,</span>    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Range</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$4</span><span class="p">,</span> <span class="nx">$3</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-43">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-43">&#182;</a>               </div>               <p>Array slice literals.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Slice</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-44">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-44">&#182;</a>               </div>               <p>Array slice literals.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Slice</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;Expression RangeDots Expression&#39;</span><span class="p">,</span>        <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Range</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;Expression RangeDots&#39;</span><span class="p">,</span>                   <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Range</span> <span class="nx">$1</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;RangeDots Expression&#39;</span><span class="p">,</span>                   <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Range</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-44">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-44">&#182;</a>               </div>               <p>The <strong>ArgList</strong> is both the list of objects passed into a function call,
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-45">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-45">&#182;</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="nx">ArgList</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;Arg&#39;</span><span class="p">,</span>                                              <span class="o">-&gt;</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
@@ -224,35 +222,35 @@ as well as the contents of an array literal
    <span class="nx">o</span> <span class="s1">&#39;ArgList OptComma TERMINATOR Arg&#39;</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">$4</span>
    <span class="nx">o</span> <span class="s1">&#39;INDENT ArgList OptComma OUTDENT&#39;</span><span class="p">,</span>                  <span class="o">-&gt;</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;ArgList OptComma INDENT ArgList OptComma OUTDENT&#39;</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">$4</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-45">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-45">&#182;</a>               </div>               <p>Valid arguments are Block or Splats.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Arg</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="pilwrap">                 <a class="pilcrow" href="#section-46">&#182;</a>               </div>               <p>Valid arguments are Blocks or Splats.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Arg</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;Expression&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;Splat&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-46">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-46">&#182;</a>               </div>               <p>Just simple, comma-separated, required arguments (no fancy syntax). We need
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-47">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-47">&#182;</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="nx">SimpleArgs</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;Expression&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;SimpleArgs , Expression&#39;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="p">[].</span><span class="nx">concat</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-47">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-47">&#182;</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="nx">Try</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-48">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-48">&#182;</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="nx">Try</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;TRY Block&#39;</span><span class="p">,</span>                              <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Try</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;TRY Block Catch&#39;</span><span class="p">,</span>                        <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Try</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="s1">&#39;TRY Block FINALLY Block&#39;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Try</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="s1">&#39;TRY Block Catch FINALLY Block&#39;</span><span class="p">,</span>          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Try</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-48">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-48">&#182;</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="nx">Catch</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-49">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-49">&#182;</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="nx">Catch</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;CATCH Identifier Block&#39;</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-49">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-49">&#182;</a>               </div>               <p>Throw an exception object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Throw</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-50">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-50">&#182;</a>               </div>               <p>Throw an exception object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Throw</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;THROW Expression&#39;</span><span class="p">,</span>                       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Throw</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-50">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-50">&#182;</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-51">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-51">&#182;</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="nx">Parenthetical</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;( Body )&#39;</span><span class="p">,</span>                               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Parens</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;( INDENT Body OUTDENT )&#39;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Parens</span> <span class="nx">$3</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-51">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-51">&#182;</a>               </div>               <p>The condition portion of a while loop.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">WhileSource</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-52">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-52">&#182;</a>               </div>               <p>The condition portion of a while loop.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">WhileSource</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;WHILE Expression&#39;</span><span class="p">,</span>                       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">While</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;WHILE Expression WHEN Expression&#39;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">While</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">guard</span><span class="o">:</span> <span class="nx">$4</span>
    <span class="nx">o</span> <span class="s1">&#39;UNTIL Expression&#39;</span><span class="p">,</span>                       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">While</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">invert</span><span class="o">:</span> <span class="kc">true</span>
    <span class="nx">o</span> <span class="s1">&#39;UNTIL Expression WHEN Expression&#39;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">While</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">invert</span><span class="o">:</span> <span class="kc">true</span><span class="p">,</span> <span class="nx">guard</span><span class="o">:</span> <span class="nx">$4</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-52">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-52">&#182;</a>               </div>               <p>The while loop can either be normal, with a block of expressions to execute,
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-53">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-53">&#182;</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="nx">While</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;WhileSource Block&#39;</span><span class="p">,</span>                      <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">addBody</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;Statement  WhileSource&#39;</span><span class="p">,</span>                 <span class="o">-&gt;</span> <span class="nx">$2</span><span class="p">.</span><span class="nx">addBody</span> <span class="nx">Block</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
@@ -263,7 +261,7 @@ or postfix, with a single expression. There is no do..while.</p>             </t
  <span class="nx">Loop</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;LOOP Block&#39;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">While</span><span class="p">(</span><span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;true&#39;</span><span class="p">).</span><span class="nx">addBody</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;LOOP Expression&#39;</span><span class="p">,</span>                        <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">While</span><span class="p">(</span><span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;true&#39;</span><span class="p">).</span><span class="nx">addBody</span> <span class="nx">Block</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-53">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-53">&#182;</a>               </div>               <p>Array, object, and range comprehensions, at the most generic level.
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-54">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-54">&#182;</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="nx">For</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;Statement  ForBody&#39;</span><span class="p">,</span>                     <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">For</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$2</span>
@@ -279,17 +277,17 @@ or postfix, with a single expression.</p>             </td>             <td clas
  <span class="nx">ForStart</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;FOR ForVariables&#39;</span><span class="p">,</span>                       <span class="o">-&gt;</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;FOR OWN ForVariables&#39;</span><span class="p">,</span>                   <span class="o">-&gt;</span> <span class="nv">$3.own = </span><span class="kc">yes</span><span class="p">;</span> <span class="nx">$3</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-54">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-54">&#182;</a>               </div>               <p>An array of all accepted values for a variable inside the loop.
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-55">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-55">&#182;</a>               </div>               <p>An array of all accepted values for a variable inside the loop.
 This enables support for pattern matching.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">ForValue</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;Identifier&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;Array&#39;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
    <span class="nx">o</span> <span class="s1">&#39;Object&#39;</span><span class="p">,</span>                                 <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-55">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-55">&#182;</a>               </div>               <p>An array or range comprehension has variables for the current element
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-56">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-56">&#182;</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="nx">ForVariables</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;ForValue&#39;</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="s1">&#39;ForValue , ForValue&#39;</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-56">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-56">&#182;</a>               </div>               <p>The source of a comprehension is an array or object with an optional guard
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-57">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-57">&#182;</a>               </div>               <p>The source of a comprehension is an array or object with an optional guard
 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="nx">ForSource</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;FORIN Expression&#39;</span><span class="p">,</span>                               <span class="o">-&gt;</span> <span class="nx">source</span><span class="o">:</span> <span class="nx">$2</span>
@@ -311,21 +309,21 @@ in fixed-size increments.</p>             </td>             <td class="code">
  <span class="nx">Whens</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;When&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;Whens When&#39;</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">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-57">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-57">&#182;</a>               </div>               <p>An individual <strong>When</strong> clause, with action.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">When</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-58">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-58">&#182;</a>               </div>               <p>An individual <strong>When</strong> clause, with action.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">When</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;LEADING_WHEN SimpleArgs Block&#39;</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="nx">o</span> <span class="s1">&#39;LEADING_WHEN SimpleArgs Block TERMINATOR&#39;</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-58">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-58">&#182;</a>               </div>               <p>The most basic form of <em>if</em> is a condition and an action. The following
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-59">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-59">&#182;</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="nx">IfBlock</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;IF Expression Block&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">If</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">type</span><span class="o">:</span> <span class="nx">$1</span>
    <span class="nx">o</span> <span class="s1">&#39;IfBlock ELSE IF Expression Block&#39;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">addElse</span> <span class="k">new</span> <span class="nx">If</span> <span class="nx">$4</span><span class="p">,</span> <span class="nx">$5</span><span class="p">,</span> <span class="nx">type</span><span class="o">:</span> <span class="nx">$3</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-59">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-59">&#182;</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-60">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-60">&#182;</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="nx">If</span><span class="o">:</span> <span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;IfBlock&#39;</span>
    <span class="nx">o</span> <span class="s1">&#39;IfBlock ELSE Block&#39;</span><span class="p">,</span>                     <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">addElse</span> <span class="nx">$3</span>
    <span class="nx">o</span> <span class="s1">&#39;Statement  POST_IF Expression&#39;</span><span class="p">,</span>          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">If</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">Block</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">type</span><span class="o">:</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">statement</span><span class="o">:</span> <span class="kc">true</span>
    <span class="nx">o</span> <span class="s1">&#39;Expression POST_IF Expression&#39;</span><span class="p">,</span>          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">If</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">Block</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">type</span><span class="o">:</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">statement</span><span class="o">:</span> <span class="kc">true</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-60">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-60">&#182;</a>               </div>               <p>Arithmetic and logical operators, working on one or more operands.
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-61">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-61">&#182;</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>
@@ -338,7 +336,7 @@ rules are necessary.</p>             </td>             <td class="code">
    <span class="nx">o</span> <span class="s1">&#39;-- SimpleAssignable&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</span> <span class="s1">&#39;--&#39;</span><span class="p">,</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;++ SimpleAssignable&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</span> <span class="s1">&#39;++&#39;</span><span class="p">,</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;SimpleAssignable --&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</span> <span class="s1">&#39;--&#39;</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="kc">true</span>
-    <span class="nx">o</span> <span class="s1">&#39;SimpleAssignable ++&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</span> <span class="s1">&#39;++&#39;</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="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-61">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-61">&#182;</a>               </div>               <p><a href="http://jashkenas.github.com/coffee-script/#existence">The existential operator</a>.</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="nx">o</span> <span class="s1">&#39;Expression ?&#39;</span><span class="p">,</span>                           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Existence</span> <span class="nx">$1</span>
+    <span class="nx">o</span> <span class="s1">&#39;SimpleAssignable ++&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</span> <span class="s1">&#39;++&#39;</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="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-62">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-62">&#182;</a>               </div>               <p><a href="http://jashkenas.github.com/coffee-script/#existence">The existential operator</a>.</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="nx">o</span> <span class="s1">&#39;Expression ?&#39;</span><span class="p">,</span>                           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Existence</span> <span class="nx">$1</span>

    <span class="nx">o</span> <span class="s1">&#39;Expression +  Expression&#39;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</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="s1">&#39;Expression -  Expression&#39;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</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>
@@ -358,7 +356,7 @@ rules are necessary.</p>             </td>             <td class="code">
    <span class="nx">o</span> <span class="s1">&#39;SimpleAssignable COMPOUND_ASSIGN</span>
 <span class="s1">       INDENT Expression OUTDENT&#39;</span><span class="p">,</span>              <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Assign</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$4</span><span class="p">,</span> <span class="nx">$2</span>
    <span class="nx">o</span> <span class="s1">&#39;SimpleAssignable EXTENDS Expression&#39;</span><span class="p">,</span>    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Extends</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="pilwrap">                 <a class="pilcrow" href="#section-62">&#182;</a>               </div>               <h2>Precedence</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-63">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-63">&#182;</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-63">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-63">&#182;</a>               </div>               <h2>Precedence</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-64">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-64">&#182;</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)
@@ -384,7 +382,7 @@ down. Following these rules is what makes <code>2 + 3 * 4</code> parse as:</p>
  <span class="p">[</span><span class="s1">&#39;right&#39;</span><span class="p">,</span>     <span class="s1">&#39;FORIN&#39;</span><span class="p">,</span> <span class="s1">&#39;FOROF&#39;</span><span class="p">,</span> <span class="s1">&#39;BY&#39;</span><span class="p">,</span> <span class="s1">&#39;WHEN&#39;</span><span class="p">]</span>
  <span class="p">[</span><span class="s1">&#39;right&#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;FOR&#39;</span><span class="p">,</span> <span class="s1">&#39;DO&#39;</span><span class="p">,</span> <span class="s1">&#39;WHILE&#39;</span><span class="p">,</span> <span class="s1">&#39;UNTIL&#39;</span><span class="p">,</span> <span class="s1">&#39;LOOP&#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="s1">&#39;right&#39;</span><span class="p">,</span>     <span class="s1">&#39;POST_IF&#39;</span><span class="p">]</span>
-<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-64">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-64">&#182;</a>               </div>               <h2>Wrapping Up</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-65">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-65">&#182;</a>               </div>               <p>Finally, now what we have our <strong>grammar</strong> and our <strong>operators</strong>, we can create
+<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-65">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-65">&#182;</a>               </div>               <h2>Wrapping Up</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-66">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-66">&#182;</a>               </div>               <p>Finally, now that 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>
@@ -393,7 +391,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-66">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-66">&#182;</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-67">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-67">&#182;</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>
--- a/documentation/docs/lexer.html
+++ b/documentation/docs/lexer.html
@@ -62,8 +62,7 @@ though <code>is</code> means <code>===</code> otherwise.</p>             </td>
      <span class="o">not</span> <span class="nx">prev</span><span class="p">.</span><span class="nx">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;@&#39;</span><span class="p">)</span>
    <span class="nv">tag = </span><span class="s1">&#39;IDENTIFIER&#39;</span>

-    <span class="k">if</span> <span class="nx">id</span> <span class="k">in</span> <span class="nx">JS_KEYWORDS</span> <span class="o">or</span>
-       <span class="o">not</span> <span class="nx">forcedIdentifier</span> <span class="o">and</span> <span class="nx">id</span> <span class="k">in</span> <span class="nx">COFFEE_KEYWORDS</span>
+    <span class="k">if</span> <span class="o">not</span> <span class="nx">forcedIdentifier</span> <span class="o">and</span> <span class="p">(</span><span class="nx">id</span> <span class="k">in</span> <span class="nx">JS_KEYWORDS</span> <span class="o">or</span> <span class="nx">id</span> <span class="k">in</span> <span class="nx">COFFEE_KEYWORDS</span><span class="p">)</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">tag</span> <span class="o">is</span> <span class="s1">&#39;WHEN&#39;</span> <span class="o">and</span> <span class="nx">@tag</span><span class="p">()</span> <span class="k">in</span> <span class="nx">LINE_BREAK</span>
        <span class="nv">tag = </span><span class="s1">&#39;LEADING_WHEN&#39;</span>
@@ -149,7 +148,11 @@ preserve whitespace, but ignore indentation to the left.</p>             </td>
 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="nx">regexToken</span><span class="o">:</span> <span class="o">-&gt;</span>
    <span class="k">return</span> <span class="mi">0</span> <span class="k">if</span> <span class="nx">@chunk</span><span class="p">.</span><span class="nx">charAt</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="k">return</span> <span class="nx">@heregexToken</span> <span class="nx">match</span> <span class="k">if</span> <span class="nv">match = </span><span class="nx">HEREGEX</span><span class="p">.</span><span class="nx">exec</span> <span class="nx">@chunk</span>
+    <span class="k">if</span> <span class="nv">match = </span><span class="nx">HEREGEX</span><span class="p">.</span><span class="nx">exec</span> <span class="nx">@chunk</span>
+      <span class="nv">length = </span><span class="nx">@heregexToken</span> <span class="nx">match</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">0</span><span class="p">],</span> <span class="s1">&#39;\n&#39;</span>
+      <span class="k">return</span> <span class="nx">length</span>
+
    <span class="nv">prev = </span><span class="nx">last</span> <span class="nx">@tokens</span>
    <span class="k">return</span> <span class="mi">0</span> <span class="k">if</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="k">in</span> <span class="p">(</span><span class="k">if</span> <span class="nx">prev</span><span class="p">.</span><span class="nx">spaced</span> <span class="k">then</span> <span class="nx">NOT_REGEX</span> <span class="k">else</span> <span class="nx">NOT_SPACED_REGEX</span><span class="p">))</span>
    <span class="k">return</span> <span class="mi">0</span> <span class="nx">unless</span> <span class="nv">match = </span><span class="nx">REGEX</span><span class="p">.</span><span class="nx">exec</span> <span class="nx">@chunk</span>
@@ -305,6 +308,7 @@ parameters specially in order to make things easier for the parser.</p>
          <span class="k">else</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">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="k">return</span> <span class="k">this</span>
+          <span class="k">else</span> <span class="k">return</span> <span class="k">this</span>
    <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-25">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-25">&#182;</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="nx">closeIndentation</span><span class="o">:</span> <span class="o">-&gt;</span>
    <span class="nx">@outdentToken</span> <span class="nx">@indent</span></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-26">&#182;</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="nx">identifierError</span><span class="o">:</span> <span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="o">-&gt;</span>
@@ -328,6 +332,8 @@ interpolations within strings, ad infinitum.</p>             </td>             <
          <span class="k">continue</span>
      <span class="k">if</span> <span class="nx">end</span> <span class="o">is</span> <span class="s1">&#39;}&#39;</span> <span class="o">and</span> <span class="nx">letter</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;&quot;&#39;</span><span class="p">,</span> <span class="s2">&quot;&#39;&quot;</span><span class="p">]</span>
        <span class="nx">stack</span><span class="p">.</span><span class="nx">push</span> <span class="nv">end = </span><span class="nx">letter</span>
+      <span class="k">else</span> <span class="k">if</span> <span class="nx">end</span> <span class="o">is</span> <span class="s1">&#39;}&#39;</span> <span class="o">and</span> <span class="nx">letter</span> <span class="o">is</span> <span class="s1">&#39;/&#39;</span> <span class="o">and</span> <span class="nv">match = </span><span class="p">(</span><span class="nx">HEREGEX</span><span class="p">.</span><span class="nx">exec</span><span class="p">(</span><span class="nx">str</span><span class="p">.</span><span class="nx">slice</span> <span class="nx">i</span><span class="p">)</span> <span class="o">or</span> <span class="nx">REGEX</span><span class="p">.</span><span class="nx">exec</span><span class="p">(</span><span class="nx">str</span><span class="p">.</span><span class="nx">slice</span> <span class="nx">i</span><span class="p">))</span>
+        <span class="nx">i</span> <span class="o">+=</span> <span class="nx">match</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
      <span class="k">else</span> <span class="k">if</span> <span class="nx">end</span> <span class="o">is</span> <span class="s1">&#39;}&#39;</span> <span class="o">and</span> <span class="nx">letter</span> <span class="o">is</span> <span class="s1">&#39;{&#39;</span>
        <span class="nx">stack</span><span class="p">.</span><span class="nx">push</span> <span class="nv">end = </span><span class="s1">&#39;}&#39;</span>
      <span class="k">else</span> <span class="k">if</span> <span class="nx">end</span> <span class="o">is</span> <span class="s1">&#39;&quot;&#39;</span> <span class="o">and</span> <span class="nx">prev</span> <span class="o">is</span> <span class="s1">&#39;#&#39;</span> <span class="o">and</span> <span class="nx">letter</span> <span class="o">is</span> <span class="s1">&#39;{&#39;</span>
@@ -409,7 +415,7 @@ token stream.</p>             </td>             <td class="code">
  <span class="kc">no</span>   <span class="o">:</span> <span class="s1">&#39;false&#39;</span>
  <span class="kc">on</span>   <span class="o">:</span> <span class="s1">&#39;true&#39;</span>
  <span class="kc">off</span>  <span class="o">:</span> <span class="s1">&#39;false&#39;</span>
-  
+
 <span class="nv">COFFEE_ALIASES  = </span><span class="p">(</span><span class="nx">key</span> <span class="k">for</span> <span class="nx">key</span> <span class="k">of</span> <span class="nx">COFFEE_ALIAS_MAP</span><span class="p">)</span>
 <span class="nv">COFFEE_KEYWORDS = </span><span class="nx">COFFEE_KEYWORDS</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">COFFEE_ALIASES</span></pre></div>             </td>           </tr>                               <tr id="section-40">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-40">&#182;</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,
@@ -427,7 +433,7 @@ be used as identifiers or properties.</p>             </td>             <td clas

 <span class="nv">NUMBER     = </span><span class="err">///</span>
  <span class="o">^</span> <span class="mi">0</span><span class="nx">x</span><span class="p">[</span><span class="err">\</span><span class="nx">da</span><span class="o">-</span><span class="nx">f</span><span class="p">]</span><span class="o">+</span> <span class="o">|</span>                              <span class="c1"># hex</span>
-  <span class="o">^</span> <span class="p">(</span><span class="o">?:</span> <span class="err">\</span><span class="nx">d</span><span class="o">+</span><span class="p">(</span><span class="err">\</span><span class="p">.</span><span class="err">\</span><span class="nx">d</span><span class="o">+</span><span class="p">)</span><span class="o">?</span> <span class="o">|</span> <span class="err">\</span><span class="p">.</span><span class="err">\</span><span class="nx">d</span><span class="o">+</span> <span class="p">)</span> <span class="p">(</span><span class="o">?:</span><span class="nx">e</span><span class="p">[</span><span class="o">+-</span><span class="p">]</span><span class="o">?</span><span class="err">\</span><span class="nx">d</span><span class="o">+</span><span class="p">)</span><span class="o">?</span>  <span class="c1"># decimal</span>
+  <span class="o">^</span> <span class="err">\</span><span class="nx">d</span><span class="o">*</span><span class="err">\</span><span class="p">.</span><span class="o">?</span><span class="err">\</span><span class="nx">d</span><span class="o">+</span> <span class="p">(</span><span class="o">?:</span><span class="nx">e</span><span class="p">[</span><span class="o">+-</span><span class="p">]</span><span class="o">?</span><span class="err">\</span><span class="nx">d</span><span class="o">+</span><span class="p">)</span><span class="o">?</span>  <span class="c1"># decimal</span>
 <span class="err">///i</span>

 <span class="nv">HEREDOC    = </span><span class="err">/// ^ (&quot;&quot;&quot;|&#39;&#39;&#39;) ([\s\S]*?) (?:\n[^\n\S]*)? \1 ///</span>
@@ -492,7 +498,7 @@ a division operator might.</p>
 <p>See: http://www.mozilla.org/js/language/js20-2002-04/rationale/syntax.html#regular-expressions</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;BOOL&#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-54">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-54">&#182;</a>               </div>               <p>If the previous token is not spaced, there are more preceding tokens that
-force a division parse:</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">NOT_SPACED_REGEX = </span><span class="nx">NOT_REGEX</span><span class="p">.</span><span class="nx">concat</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;THIS&#39;</span><span class="p">,</span> <span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;STRING&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-55">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-55">&#182;</a>               </div>               <p>Tokens which could legitimately be invoked or indexed. A opening
+force a division parse:</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">NOT_SPACED_REGEX = </span><span class="nx">NOT_REGEX</span><span class="p">.</span><span class="nx">concat</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;THIS&#39;</span><span class="p">,</span> <span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;STRING&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-55">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-55">&#182;</a>               </div>               <p>Tokens which could legitimately be invoked or indexed. An 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;STRING&#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;}&#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;THIS&#39;</span><span class="p">,</span> <span class="s1">&#39;SUPER&#39;</span><span class="p">]</span>
 <span class="nv">INDEXABLE = </span><span class="nx">CALLABLE</span><span class="p">.</span><span class="nx">concat</span> <span class="s1">&#39;NUMBER&#39;</span><span class="p">,</span> <span class="s1">&#39;BOOL&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-56">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-56">&#182;</a>               </div>               <p>Tokens that, when immediately preceding a <code>WHEN</code>, indicate that the <code>WHEN</code>
--- a/documentation/docs/nodes.html
+++ b/documentation/docs/nodes.html
@@ -117,7 +117,7 @@ it back out.</p>             </td>             <td class="code">               <

  <span class="nx">jumps</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">for</span> <span class="nx">exp</span> <span class="k">in</span> <span class="nx">@expressions</span>
-      <span class="k">return</span> <span class="nx">exp</span> <span class="k">if</span> <span class="nx">exp</span><span class="p">.</span><span class="nx">jumps</span> <span class="nx">o</span></pre></div>             </td>           </tr>                               <tr id="section-25">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-25">&#182;</a>               </div>               <p>An Block node does not return its entire body, rather it
+      <span class="k">return</span> <span class="nx">exp</span> <span class="k">if</span> <span class="nx">exp</span><span class="p">.</span><span class="nx">jumps</span> <span class="nx">o</span></pre></div>             </td>           </tr>                               <tr id="section-25">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-25">&#182;</a>               </div>               <p>A Block node does not return its entire body, rather it
 ensures that the final expression is returned.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">makeReturn</span><span class="o">:</span> <span class="o">-&gt;</span>
    <span class="nv">len = </span><span class="nx">@expressions</span><span class="p">.</span><span class="nx">length</span>
    <span class="k">while</span> <span class="nx">len</span><span class="o">--</span>
@@ -126,7 +126,7 @@ ensures that the final expression is returned.</p>             </td>
        <span class="nx">@expressions</span><span class="p">[</span><span class="nx">len</span><span class="p">]</span> <span class="o">=</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">makeReturn</span><span class="p">()</span>
        <span class="nx">@expressions</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="nx">len</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span> <span class="k">if</span> <span class="nx">expr</span> <span class="k">instanceof</span> <span class="nx">Return</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">expression</span>
        <span class="k">break</span>
-    <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-26">&#182;</a>               </div>               <p>An <strong>Block</strong> is the only node that can serve as the root.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compile</span><span class="o">:</span> <span class="p">(</span><span class="nv">o = </span><span class="p">{},</span> <span class="nx">level</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-26">&#182;</a>               </div>               <p>A <strong>Block</strong> is the only node that can serve as the root.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compile</span><span class="o">:</span> <span class="p">(</span><span class="nv">o = </span><span class="p">{},</span> <span class="nx">level</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span> <span class="k">then</span> <span class="k">super</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">level</span> <span class="k">else</span> <span class="nx">@compileRoot</span> <span class="nx">o</span></pre></div>             </td>           </tr>                               <tr id="section-27">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-27">&#182;</a>               </div>               <p>Compile all expressions within the <strong>Block</strong> body. If we need to
 return the result, and it's an expression, simply return it. If it's a
 statement, ask the statement to do so.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
@@ -136,7 +136,10 @@ statement, ask the statement to do so.</p>             </td>             <td cla
    <span class="k">for</span> <span class="nx">node</span> <span class="k">in</span> <span class="nx">@expressions</span>
      <span class="nv">node = </span><span class="nx">node</span><span class="p">.</span><span class="nx">unwrapAll</span><span class="p">()</span>
      <span class="nv">node = </span><span class="p">(</span><span class="nx">node</span><span class="p">.</span><span class="nx">unfoldSoak</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">or</span> <span class="nx">node</span><span class="p">)</span>
-      <span class="k">if</span> <span class="nx">top</span>
+      <span class="k">if</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Block</span></pre></div>             </td>           </tr>                               <tr id="section-28">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-28">&#182;</a>               </div>               <p>This is a nested block.  We don't do anything special here like enclose
+it in a new scope; we just compile the statements in this block along with
+our own</p>             </td>             <td class="code">               <div class="highlight"><pre>        <span class="nx">codes</span><span class="p">.</span><span class="nx">push</span> <span class="nx">node</span><span class="p">.</span><span class="nx">compileNode</span> <span class="nx">o</span>
+      <span class="k">else</span> <span class="k">if</span> <span class="nx">top</span>
        <span class="nv">node.front = </span><span class="kc">true</span>
        <span class="nv">code = </span><span class="nx">node</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span>
        <span class="nx">codes</span><span class="p">.</span><span class="nx">push</span> <span class="k">if</span> <span class="nx">node</span><span class="p">.</span><span class="nx">isStatement</span> <span class="nx">o</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="nx">@tab</span> <span class="o">+</span> <span class="nx">code</span> <span class="o">+</span> <span class="s1">&#39;;&#39;</span>
@@ -144,7 +147,7 @@ statement, ask the statement to do so.</p>             </td>             <td cla
        <span class="nx">codes</span><span class="p">.</span><span class="nx">push</span> <span class="nx">node</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
    <span class="k">return</span> <span class="nx">codes</span><span class="p">.</span><span class="nx">join</span> <span class="s1">&#39;\n&#39;</span> <span class="k">if</span> <span class="nx">top</span>
    <span class="nv">code = </span><span class="nx">codes</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="o">or</span> <span class="s1">&#39;void 0&#39;</span>
-    <span class="k">if</span> <span class="nx">codes</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="mi">1</span> <span class="o">and</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&gt;=</span> <span class="nx">LEVEL_LIST</span> <span class="k">then</span> <span class="s2">&quot;(#{code})&quot;</span> <span class="k">else</span> <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-28">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-28">&#182;</a>               </div>               <p>If we happen to be the top-level <strong>Block</strong>, wrap everything in
+    <span class="k">if</span> <span class="nx">codes</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="mi">1</span> <span class="o">and</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&gt;=</span> <span class="nx">LEVEL_LIST</span> <span class="k">then</span> <span class="s2">&quot;(#{code})&quot;</span> <span class="k">else</span> <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-29">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-29">&#182;</a>               </div>               <p>If we happen to be the top-level <strong>Block</strong>, wrap everything in
 a safety closure, unless requested not to.
 It would be better not to generate them in the first place, but for now,
 clean up obvious double-parentheses.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileRoot</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
@@ -152,7 +155,7 @@ clean up obvious double-parentheses.</p>             </td>             <td class
    <span class="nv">o.scope  = </span><span class="k">new</span> <span class="nx">Scope</span> <span class="kc">null</span><span class="p">,</span> <span class="k">this</span><span class="p">,</span> <span class="kc">null</span>
    <span class="nv">o.level  = </span><span class="nx">LEVEL_TOP</span>
    <span class="nv">code     = </span><span class="nx">@compileWithDeclarations</span> <span class="nx">o</span>
-    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">bare</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">&quot;(function() {\n#{code}\n}).call(this);\n&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-29">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-29">&#182;</a>               </div>               <p>Compile the expressions body for the contents of a function, with
+    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">bare</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">&quot;(function() {\n#{code}\n}).call(this);\n&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-30">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-30">&#182;</a>               </div>               <p>Compile the expressions body for the contents of a function, with
 declarations of all inner variables pushed up to the top.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileWithDeclarations</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nv">code = post = </span><span class="s1">&#39;&#39;</span>
    <span class="k">for</span> <span class="nx">exp</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">@expressions</span>
@@ -161,19 +164,23 @@ declarations of all inner variables pushed up to the top.</p>             </td>
    <span class="nv">o = </span><span class="nx">merge</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">level</span><span class="o">:</span> <span class="nx">LEVEL_TOP</span><span class="p">)</span>
    <span class="k">if</span> <span class="nx">i</span>
      <span class="nv">rest = </span><span class="nx">@expressions</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="nx">@expressions</span><span class="p">.</span><span class="nx">length</span>
-      <span class="nv">code = </span><span class="nx">@compileNode</span> <span class="nx">o</span>
+      <span class="nv">code = </span><span class="nx">@compileNode</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
      <span class="vi">@expressions = </span><span class="nx">rest</span>
    <span class="nv">post = </span><span class="nx">@compileNode</span> <span class="nx">o</span>
    <span class="p">{</span><span class="nx">scope</span><span class="p">}</span> <span class="o">=</span> <span class="nx">o</span>
    <span class="k">if</span> <span class="nx">scope</span><span class="p">.</span><span class="nx">expressions</span> <span class="o">is</span> <span class="k">this</span>
-      <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">hasDeclarations</span><span class="p">()</span>
+      <span class="nv">declars = </span><span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">hasDeclarations</span><span class="p">()</span>
+      <span class="nv">assigns = </span><span class="nx">scope</span><span class="p">.</span><span class="nx">hasAssignments</span>
+      <span class="k">if</span> <span class="p">(</span><span class="nx">declars</span> <span class="o">or</span> <span class="nx">assigns</span><span class="p">)</span> <span class="o">and</span> <span class="nx">i</span>
+        <span class="nx">code</span> <span class="o">+=</span> <span class="s1">&#39;\n&#39;</span>
+      <span class="k">if</span> <span class="nx">declars</span>
        <span class="nx">code</span> <span class="o">+=</span> <span class="s2">&quot;#{@tab}var #{ scope.declaredVariables().join(&#39;, &#39;) };\n&quot;</span>
-      <span class="k">if</span> <span class="nx">scope</span><span class="p">.</span><span class="nx">hasAssignments</span>
+      <span class="k">if</span> <span class="nx">assigns</span>
        <span class="nx">code</span> <span class="o">+=</span> <span class="s2">&quot;#{@tab}var #{ multident scope.assignedVariables().join(&#39;, &#39;), @tab };\n&quot;</span>
-    <span class="nx">code</span> <span class="o">+</span> <span class="nx">post</span></pre></div>             </td>           </tr>                               <tr id="section-30">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-30">&#182;</a>               </div>               <p>Wrap up the given nodes as an <strong>Block</strong>, unless it already happens
+    <span class="nx">code</span> <span class="o">+</span> <span class="nx">post</span></pre></div>             </td>           </tr>                               <tr id="section-31">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-31">&#182;</a>               </div>               <p>Wrap up the given nodes as a <strong>Block</strong>, unless it already happens
 to be one.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">@wrap</span><span class="o">:</span> <span class="p">(</span><span class="nx">nodes</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">return</span> <span class="nx">nodes</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">if</span> <span class="nx">nodes</span><span class="p">.</span><span class="nx">length</span> <span class="o">is</span> <span class="mi">1</span> <span class="o">and</span> <span class="nx">nodes</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">instanceof</span> <span class="nx">Block</span>
-    <span class="k">new</span> <span class="nx">Block</span> <span class="nx">nodes</span></pre></div>             </td>           </tr>                               <tr id="section-31">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-31">&#182;</a>               </div>               <h3>Literal</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-32">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-32">&#182;</a>               </div>               <p>Literals are static values that can be passed through directly into
+    <span class="k">new</span> <span class="nx">Block</span> <span class="nx">nodes</span></pre></div>             </td>           </tr>                               <tr id="section-32">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-32">&#182;</a>               </div>               <h3>Literal</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-33">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-33">&#182;</a>               </div>               <p>Literals are static values that can be passed through directly into
 JavaScript without translation, such as: strings, numbers,
 <code>true</code>, <code>false</code>, <code>null</code>...</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Literal = </span><span class="nx">class</span> <span class="nx">Literal</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@value</span><span class="p">)</span> <span class="o">-&gt;</span>
@@ -206,7 +213,7 @@ JavaScript without translation, such as: strings, numbers,
    <span class="k">if</span> <span class="nx">@isStatement</span><span class="p">()</span> <span class="k">then</span> <span class="s2">&quot;#{@tab}#{code};&quot;</span> <span class="k">else</span> <span class="nx">code</span>

  <span class="nx">toString</span><span class="o">:</span> <span class="o">-&gt;</span>
-    <span class="s1">&#39; &quot;&#39;</span> <span class="o">+</span> <span class="nx">@value</span> <span class="o">+</span> <span class="s1">&#39;&quot;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-33">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-33">&#182;</a>               </div>               <h3>Return</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-34">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-34">&#182;</a>               </div>               <p>A <code>return</code> is a <em>pureStatement</em> -- wrapping it in a closure wouldn't
+    <span class="s1">&#39; &quot;&#39;</span> <span class="o">+</span> <span class="nx">@value</span> <span class="o">+</span> <span class="s1">&#39;&quot;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-34">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-34">&#182;</a>               </div>               <h3>Return</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-35">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-35">&#182;</a>               </div>               <p>A <code>return</code> is a <em>pureStatement</em> -- wrapping it in a closure wouldn't
 make sense.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Return = </span><span class="nx">class</span> <span class="nx">Return</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">expr</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="vi">@expression = </span><span class="nx">expr</span> <span class="k">if</span> <span class="nx">expr</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">().</span><span class="nx">isUndefined</span>
@@ -222,7 +229,7 @@ make sense.</p>             </td>             <td class="code">               <d
    <span class="k">if</span> <span class="nx">expr</span> <span class="o">and</span> <span class="nx">expr</span> <span class="o">not</span> <span class="k">instanceof</span> <span class="nx">Return</span> <span class="k">then</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">level</span> <span class="k">else</span> <span class="k">super</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">level</span>

  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="nx">@tab</span> <span class="o">+</span> <span class="s2">&quot;return#{ if @expression then &#39; &#39; + @expression.compile(o, LEVEL_PAREN) else &#39;&#39; };&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-35">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-35">&#182;</a>               </div>               <h3>Value</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-36">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-36">&#182;</a>               </div>               <p>A value, variable or literal or parenthesized, indexed or dotted into,
+    <span class="nx">@tab</span> <span class="o">+</span> <span class="s2">&quot;return#{ if @expression then &#39; &#39; + @expression.compile(o, LEVEL_PAREN) else &#39;&#39; };&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-36">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-36">&#182;</a>               </div>               <h3>Value</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-37">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-37">&#182;</a>               </div>               <p>A value, variable or literal or parenthesized, indexed or dotted into,
 or vanilla.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Value = </span><span class="nx">class</span> <span class="nx">Value</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">base</span><span class="p">,</span> <span class="nx">props</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">base</span> <span class="k">if</span> <span class="o">not</span> <span class="nx">props</span> <span class="o">and</span> <span class="nx">base</span> <span class="k">instanceof</span> <span class="nx">Value</span>
@@ -231,12 +238,12 @@ or vanilla.</p>             </td>             <td class="code">               <d
    <span class="err">@</span><span class="p">[</span><span class="nx">tag</span><span class="p">]</span>      <span class="o">=</span> <span class="kc">true</span> <span class="k">if</span> <span class="nx">tag</span>
    <span class="k">return</span> <span class="k">this</span>

-  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;base&#39;</span><span class="p">,</span> <span class="s1">&#39;properties&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-37">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-37">&#182;</a>               </div>               <p>Add a property access to the list.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">push</span><span class="o">:</span> <span class="p">(</span><span class="nx">prop</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;base&#39;</span><span class="p">,</span> <span class="s1">&#39;properties&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-38">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-38">&#182;</a>               </div>               <p>Add a property access to the list.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">push</span><span class="o">:</span> <span class="p">(</span><span class="nx">prop</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nx">@properties</span><span class="p">.</span><span class="nx">push</span> <span class="nx">prop</span>
    <span class="k">this</span>

  <span class="nx">hasProperties</span><span class="o">:</span> <span class="o">-&gt;</span>
-    <span class="o">!!</span><span class="nx">@properties</span><span class="p">.</span><span class="nx">length</span></pre></div>             </td>           </tr>                               <tr id="section-38">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-38">&#182;</a>               </div>               <p>Some boolean checks for the benefit of other nodes.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">isArray</span>        <span class="o">:</span> <span class="o">-&gt;</span> <span class="o">not</span> <span class="nx">@properties</span><span class="p">.</span><span class="nx">length</span> <span class="o">and</span> <span class="nx">@base</span> <span class="k">instanceof</span> <span class="nx">Arr</span>
+    <span class="o">!!</span><span class="nx">@properties</span><span class="p">.</span><span class="nx">length</span></pre></div>             </td>           </tr>                               <tr id="section-39">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-39">&#182;</a>               </div>               <p>Some boolean checks for the benefit of other nodes.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">isArray</span>        <span class="o">:</span> <span class="o">-&gt;</span> <span class="o">not</span> <span class="nx">@properties</span><span class="p">.</span><span class="nx">length</span> <span class="o">and</span> <span class="nx">@base</span> <span class="k">instanceof</span> <span class="nx">Arr</span>
  <span class="nx">isComplex</span>      <span class="o">:</span> <span class="o">-&gt;</span> <span class="nx">@hasProperties</span><span class="p">()</span> <span class="o">or</span> <span class="nx">@base</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span>
  <span class="nx">isAssignable</span>   <span class="o">:</span> <span class="o">-&gt;</span> <span class="nx">@hasProperties</span><span class="p">()</span> <span class="o">or</span> <span class="nx">@base</span><span class="p">.</span><span class="nx">isAssignable</span><span class="p">()</span>
  <span class="nx">isSimpleNumber</span> <span class="o">:</span> <span class="o">-&gt;</span> <span class="nx">@base</span> <span class="k">instanceof</span> <span class="nx">Literal</span> <span class="o">and</span> <span class="nx">SIMPLENUM</span><span class="p">.</span><span class="nx">test</span> <span class="nx">@base</span><span class="p">.</span><span class="nx">value</span>
@@ -257,15 +264,15 @@ or vanilla.</p>             </td>             <td class="code">               <d
    <span class="nx">last</span><span class="p">(</span><span class="nx">@properties</span><span class="p">)</span> <span class="k">instanceof</span> <span class="nx">Slice</span>

  <span class="nx">makeReturn</span><span class="o">:</span> <span class="o">-&gt;</span>
-    <span class="k">if</span> <span class="nx">@properties</span><span class="p">.</span><span class="nx">length</span> <span class="k">then</span> <span class="k">super</span><span class="p">()</span> <span class="k">else</span> <span class="nx">@base</span><span class="p">.</span><span class="nx">makeReturn</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-39">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-39">&#182;</a>               </div>               <p>The value can be unwrapped as its inner node, if there are no attached
+    <span class="k">if</span> <span class="nx">@properties</span><span class="p">.</span><span class="nx">length</span> <span class="k">then</span> <span class="k">super</span><span class="p">()</span> <span class="k">else</span> <span class="nx">@base</span><span class="p">.</span><span class="nx">makeReturn</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-40">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-40">&#182;</a>               </div>               <p>The value can be unwrapped as its inner node, if there are no attached
 properties.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">unwrap</span><span class="o">:</span> <span class="o">-&gt;</span>
-    <span class="k">if</span> <span class="nx">@properties</span><span class="p">.</span><span class="nx">length</span> <span class="k">then</span> <span class="k">this</span> <span class="k">else</span> <span class="nx">@base</span></pre></div>             </td>           </tr>                               <tr id="section-40">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-40">&#182;</a>               </div>               <p>A reference has base part (<code>this</code> value) and name part.
+    <span class="k">if</span> <span class="nx">@properties</span><span class="p">.</span><span class="nx">length</span> <span class="k">then</span> <span class="k">this</span> <span class="k">else</span> <span class="nx">@base</span></pre></div>             </td>           </tr>                               <tr id="section-41">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-41">&#182;</a>               </div>               <p>A reference has base part (<code>this</code> value) and name part.
 We cache them separately for compiling complex expressions.
 <code>a()[b()] ?= c</code> -> <code>(_base = a())[_name = b()] ? _base[_name] = c</code></p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">cacheReference</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nv">name = </span><span class="nx">last</span> <span class="nx">@properties</span>
    <span class="k">if</span> <span class="nx">@properties</span><span class="p">.</span><span class="nx">length</span> <span class="o">&lt;</span> <span class="mi">2</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">@base</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">name</span><span class="o">?</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span>
      <span class="k">return</span> <span class="p">[</span><span class="k">this</span><span class="p">,</span> <span class="k">this</span><span class="p">]</span>  <span class="c1"># `a` `a.b`</span>
-    <span class="nv">base = </span><span class="k">new</span> <span class="nx">Value</span> <span class="nx">@base</span><span class="p">,</span> <span class="nx">@properties</span><span class="p">.</span><span class="nx">slice</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span>
+    <span class="nv">base = </span><span class="k">new</span> <span class="nx">Value</span> <span class="nx">@base</span><span class="p">,</span> <span class="nx">@properties</span><span class="p">[...</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
    <span class="k">if</span> <span class="nx">base</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span>  <span class="c1"># `a().b`</span>
      <span class="nv">bref = </span><span class="k">new</span> <span class="nx">Literal</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span> <span class="s1">&#39;base&#39;</span>
      <span class="nv">base = </span><span class="k">new</span> <span class="nx">Value</span> <span class="k">new</span> <span class="nx">Parens</span> <span class="k">new</span> <span class="nx">Assign</span> <span class="nx">bref</span><span class="p">,</span> <span class="nx">base</span>
@@ -274,32 +281,32 @@ We cache them separately for compiling complex expressions.
      <span class="nv">nref = </span><span class="k">new</span> <span class="nx">Literal</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span> <span class="s1">&#39;name&#39;</span>
      <span class="nv">name = </span><span class="k">new</span> <span class="nx">Index</span> <span class="k">new</span> <span class="nx">Assign</span> <span class="nx">nref</span><span class="p">,</span> <span class="nx">name</span><span class="p">.</span><span class="nx">index</span>
      <span class="nv">nref = </span><span class="k">new</span> <span class="nx">Index</span> <span class="nx">nref</span>
-    <span class="p">[</span><span class="nx">base</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">name</span><span class="p">),</span> <span class="k">new</span> <span class="nx">Value</span><span class="p">(</span><span class="nx">bref</span> <span class="o">or</span> <span class="nx">base</span><span class="p">.</span><span class="nx">base</span><span class="p">,</span> <span class="p">[</span><span class="nx">nref</span> <span class="o">or</span> <span class="nx">name</span><span class="p">])]</span></pre></div>             </td>           </tr>                               <tr id="section-41">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-41">&#182;</a>               </div>               <p>We compile a value to JavaScript by compiling and joining each property.
+    <span class="p">[</span><span class="nx">base</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">name</span><span class="p">),</span> <span class="k">new</span> <span class="nx">Value</span><span class="p">(</span><span class="nx">bref</span> <span class="o">or</span> <span class="nx">base</span><span class="p">.</span><span class="nx">base</span><span class="p">,</span> <span class="p">[</span><span class="nx">nref</span> <span class="o">or</span> <span class="nx">name</span><span class="p">])]</span></pre></div>             </td>           </tr>                               <tr id="section-42">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-42">&#182;</a>               </div>               <p>We compile a value to JavaScript by compiling and joining each property.
 Things get much more interesting if the chain of properties has <em>soak</em>
 operators <code>?.</code> interspersed. Then we have to take care not to accidentally
 evaluate anything twice when building the soak chain.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="vi">@base.front = </span><span class="nx">@front</span>
    <span class="nv">props = </span><span class="nx">@properties</span>
    <span class="nv">code  = </span><span class="nx">@base</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="k">if</span> <span class="nx">props</span><span class="p">.</span><span class="nx">length</span> <span class="k">then</span> <span class="nx">LEVEL_ACCESS</span> <span class="k">else</span> <span class="kc">null</span>
-    <span class="nv">code  = </span><span class="s2">&quot;(#{code})&quot;</span> <span class="k">if</span> <span class="nx">props</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">instanceof</span> <span class="nx">Access</span> <span class="o">and</span> <span class="nx">@isSimpleNumber</span><span class="p">()</span>
+    <span class="nv">code  = </span><span class="s2">&quot;#{code}.&quot;</span> <span class="k">if</span> <span class="p">(</span><span class="nx">@base</span> <span class="k">instanceof</span> <span class="nx">Parens</span> <span class="o">or</span> <span class="nx">props</span><span class="p">.</span><span class="nx">length</span><span class="p">)</span> <span class="o">and</span> <span class="nx">SIMPLENUM</span><span class="p">.</span><span class="nx">test</span> <span class="nx">code</span>
    <span class="nx">code</span> <span class="o">+=</span> <span class="nx">prop</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span> <span class="k">for</span> <span class="nx">prop</span> <span class="k">in</span> <span class="nx">props</span>
-    <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-42">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-42">&#182;</a>               </div>               <p>Unfold a soak into an <code>If</code>: <code>a?.b</code> -> <code>a.b if a?</code></p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">unfoldSoak</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-43">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-43">&#182;</a>               </div>               <p>Unfold a soak into an <code>If</code>: <code>a?.b</code> -> <code>a.b if a?</code></p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">unfoldSoak</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">return</span> <span class="nx">@unfoldedSoak</span> <span class="k">if</span> <span class="nx">@unfoldedSoak</span><span class="o">?</span>
-    <span class="nv">result = </span><span class="nx">do</span> <span class="o">=&gt;</span> 
+    <span class="nv">result = </span><span class="nx">do</span> <span class="o">=&gt;</span>
      <span class="k">if</span> <span class="nv">ifn = </span><span class="nx">@base</span><span class="p">.</span><span class="nx">unfoldSoak</span> <span class="nx">o</span>
        <span class="nb">Array</span><span class="o">::</span><span class="nx">push</span><span class="p">.</span><span class="nx">apply</span> <span class="nx">ifn</span><span class="p">.</span><span class="nx">body</span><span class="p">.</span><span class="nx">properties</span><span class="p">,</span> <span class="nx">@properties</span>
        <span class="k">return</span> <span class="nx">ifn</span>
      <span class="k">for</span> <span class="nx">prop</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">@properties</span> <span class="k">when</span> <span class="nx">prop</span><span class="p">.</span><span class="nx">soak</span>
        <span class="nv">prop.soak = </span><span class="kc">off</span>
-        <span class="nv">fst = </span><span class="k">new</span> <span class="nx">Value</span> <span class="nx">@base</span><span class="p">,</span> <span class="nx">@properties</span><span class="p">.</span><span class="nx">slice</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">i</span>
-        <span class="nv">snd = </span><span class="k">new</span> <span class="nx">Value</span> <span class="nx">@base</span><span class="p">,</span> <span class="nx">@properties</span><span class="p">.</span><span class="nx">slice</span> <span class="nx">i</span>
+        <span class="nv">fst = </span><span class="k">new</span> <span class="nx">Value</span> <span class="nx">@base</span><span class="p">,</span> <span class="nx">@properties</span><span class="p">[...</span><span class="nx">i</span><span class="p">]</span>
+        <span class="nv">snd = </span><span class="k">new</span> <span class="nx">Value</span> <span class="nx">@base</span><span class="p">,</span> <span class="nx">@properties</span><span class="p">[</span><span class="nx">i</span><span class="p">..]</span>
        <span class="k">if</span> <span class="nx">fst</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span>
          <span class="nv">ref = </span><span class="k">new</span> <span class="nx">Literal</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span> <span class="s1">&#39;ref&#39;</span>
          <span class="nv">fst = </span><span class="k">new</span> <span class="nx">Parens</span> <span class="k">new</span> <span class="nx">Assign</span> <span class="nx">ref</span><span class="p">,</span> <span class="nx">fst</span>
          <span class="nv">snd.base = </span><span class="nx">ref</span>
        <span class="k">return</span> <span class="k">new</span> <span class="nx">If</span> <span class="k">new</span> <span class="nx">Existence</span><span class="p">(</span><span class="nx">fst</span><span class="p">),</span> <span class="nx">snd</span><span class="p">,</span> <span class="nx">soak</span><span class="o">:</span> <span class="kc">on</span>
      <span class="kc">null</span>
-    <span class="vi">@unfoldedSoak = </span><span class="nx">result</span> <span class="o">or</span> <span class="kc">no</span></pre></div>             </td>           </tr>                               <tr id="section-43">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-43">&#182;</a>               </div>               <h3>Comment</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-44">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-44">&#182;</a>               </div>               <p>CoffeeScript passes through block comments as JavaScript block comments
+    <span class="vi">@unfoldedSoak = </span><span class="nx">result</span> <span class="o">or</span> <span class="kc">no</span></pre></div>             </td>           </tr>                               <tr id="section-44">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-44">&#182;</a>               </div>               <h3>Comment</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-45">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-45">&#182;</a>               </div>               <p>CoffeeScript passes through block comments as JavaScript block comments
 at the same position.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Comment = </span><span class="nx">class</span> <span class="nx">Comment</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@comment</span><span class="p">)</span> <span class="o">-&gt;</span>

@@ -309,29 +316,29 @@ at the same position.</p>             </td>             <td class="code">
  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">level</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nv">code = </span><span class="s1">&#39;/*&#39;</span> <span class="o">+</span> <span class="nx">multident</span><span class="p">(</span><span class="nx">@comment</span><span class="p">,</span> <span class="nx">@tab</span><span class="p">)</span> <span class="o">+</span> <span class="s1">&#39;*/&#39;</span>
    <span class="nv">code = </span><span class="nx">o</span><span class="p">.</span><span class="nx">indent</span> <span class="o">+</span> <span class="nx">code</span> <span class="k">if</span> <span class="p">(</span><span class="nx">level</span> <span class="o">or</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span><span class="p">)</span> <span class="o">is</span> <span class="nx">LEVEL_TOP</span>
-    <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-45">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-45">&#182;</a>               </div>               <h3>Call</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-46">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-46">&#182;</a>               </div>               <p>Node for a function invocation. Takes care of converting <code>super()</code> calls into
+    <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-46">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-46">&#182;</a>               </div>               <h3>Call</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-47">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-47">&#182;</a>               </div>               <p>Node for a function invocation. Takes care of converting <code>super()</code> calls into
 calls against the prototype's function of the same name.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Call = </span><span class="nx">class</span> <span class="nx">Call</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">variable</span><span class="p">,</span> <span class="vi">@args = </span><span class="p">[],</span> <span class="nx">@soak</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="vi">@isNew    = </span><span class="kc">false</span>
    <span class="vi">@isSuper  = </span><span class="nx">variable</span> <span class="o">is</span> <span class="s1">&#39;super&#39;</span>
    <span class="vi">@variable = </span><span class="k">if</span> <span class="nx">@isSuper</span> <span class="k">then</span> <span class="kc">null</span> <span class="k">else</span> <span class="nx">variable</span>

-  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;variable&#39;</span><span class="p">,</span> <span class="s1">&#39;args&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-47">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-47">&#182;</a>               </div>               <p>Tag this invocation as creating a new instance.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">newInstance</span><span class="o">:</span> <span class="o">-&gt;</span>
+  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;variable&#39;</span><span class="p">,</span> <span class="s1">&#39;args&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-48">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-48">&#182;</a>               </div>               <p>Tag this invocation as creating a new instance.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">newInstance</span><span class="o">:</span> <span class="o">-&gt;</span>
    <span class="nv">base = </span><span class="nx">@variable</span><span class="p">.</span><span class="nx">base</span> <span class="o">or</span> <span class="nx">@variable</span>
-    <span class="k">if</span> <span class="nx">base</span> <span class="k">instanceof</span> <span class="nx">Call</span>
+    <span class="k">if</span> <span class="nx">base</span> <span class="k">instanceof</span> <span class="nx">Call</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">base</span><span class="p">.</span><span class="nx">isNew</span>
      <span class="nx">base</span><span class="p">.</span><span class="nx">newInstance</span><span class="p">()</span>
    <span class="k">else</span>
      <span class="vi">@isNew = </span><span class="kc">true</span>
-    <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-48">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-48">&#182;</a>               </div>               <p>Grab the reference to the superclass's implementation of the current
+    <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-49">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-49">&#182;</a>               </div>               <p>Grab the reference to the superclass's implementation of the current
 method.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">superReference</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="p">{</span><span class="nx">method</span><span class="p">}</span> <span class="o">=</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span>
    <span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s1">&#39;cannot call super outside of a function.&#39;</span> <span class="nx">unless</span> <span class="nx">method</span>
    <span class="p">{</span><span class="nx">name</span><span class="p">}</span> <span class="o">=</span> <span class="nx">method</span>
-    <span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s1">&#39;cannot call super on an anonymous function.&#39;</span> <span class="nx">unless</span> <span class="nx">name</span>
+    <span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s1">&#39;cannot call super on an anonymous function.&#39;</span> <span class="nx">unless</span> <span class="nx">name</span><span class="o">?</span>
    <span class="k">if</span> <span class="nx">method</span><span class="p">.</span><span class="nx">klass</span>
-      <span class="s2">&quot;#{method.klass}.__super__.#{name}&quot;</span>
+      <span class="p">(</span><span class="k">new</span> <span class="nx">Value</span> <span class="p">(</span><span class="k">new</span> <span class="nx">Literal</span> <span class="nx">method</span><span class="p">.</span><span class="nx">klass</span><span class="p">),</span> <span class="p">[</span><span class="k">new</span> <span class="nx">Access</span><span class="p">(</span><span class="k">new</span> <span class="nx">Literal</span> <span class="s2">&quot;__super__&quot;</span><span class="p">),</span> <span class="k">new</span> <span class="nx">Access</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="nx">name</span><span class="p">]).</span><span class="nx">compile</span> <span class="nx">o</span>
    <span class="k">else</span>
-      <span class="s2">&quot;#{name}.__super__.constructor&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-49">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-49">&#182;</a>               </div>               <p>Soaked chained invocations unfold into if/else ternary structures.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">unfoldSoak</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
+      <span class="s2">&quot;#{name}.__super__.constructor&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-50">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-50">&#182;</a>               </div>               <p>Soaked chained invocations unfold into if/else ternary structures.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">unfoldSoak</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">if</span> <span class="nx">@soak</span>
      <span class="k">if</span> <span class="nx">@variable</span>
        <span class="k">return</span> <span class="nx">ifn</span> <span class="k">if</span> <span class="nv">ifn = </span><span class="nx">unfoldSoak</span> <span class="nx">o</span><span class="p">,</span> <span class="k">this</span><span class="p">,</span> <span class="s1">&#39;variable&#39;</span>
@@ -360,7 +367,7 @@ method.</p>             </td>             <td class="code">               <div c
        <span class="k">else</span>
          <span class="nv">call.variable.base = </span><span class="nx">ifn</span>
      <span class="nv">ifn = </span><span class="nx">unfoldSoak</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">call</span><span class="p">,</span> <span class="s1">&#39;variable&#39;</span>
-    <span class="nx">ifn</span></pre></div>             </td>           </tr>                               <tr id="section-50">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-50">&#182;</a>               </div>               <p>Walk through the objects in the arguments, moving over simple values.
+    <span class="nx">ifn</span></pre></div>             </td>           </tr>                               <tr id="section-51">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-51">&#182;</a>               </div>               <p>Walk through the objects in the arguments, moving over simple values.
 This allows syntax like <code>call a: b, c</code> into <code>call({a: b}, c);</code></p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">filterImplicitObjects</span><span class="o">:</span> <span class="p">(</span><span class="nx">list</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nv">nodes = </span><span class="p">[]</span>
    <span class="k">for</span> <span class="nx">node</span> <span class="k">in</span> <span class="nx">list</span>
@@ -369,13 +376,13 @@ This allows syntax like <code>call a: b, c</code> into <code>call({a: b}, c);</c
        <span class="k">continue</span>
      <span class="nv">obj = </span><span class="kc">null</span>
      <span class="k">for</span> <span class="nx">prop</span> <span class="k">in</span> <span class="nx">node</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">properties</span>
-        <span class="k">if</span> <span class="nx">prop</span> <span class="k">instanceof</span> <span class="nx">Assign</span>
+        <span class="k">if</span> <span class="nx">prop</span> <span class="k">instanceof</span> <span class="nx">Assign</span> <span class="o">or</span> <span class="nx">prop</span> <span class="k">instanceof</span> <span class="nx">Comment</span>
          <span class="nx">nodes</span><span class="p">.</span><span class="nx">push</span> <span class="nv">obj = </span><span class="k">new</span> <span class="nx">Obj</span> <span class="nv">properties = </span><span class="p">[],</span> <span class="kc">true</span> <span class="k">if</span> <span class="o">not</span> <span class="nx">obj</span>
          <span class="nx">properties</span><span class="p">.</span><span class="nx">push</span> <span class="nx">prop</span>
        <span class="k">else</span>
          <span class="nx">nodes</span><span class="p">.</span><span class="nx">push</span> <span class="nx">prop</span>
          <span class="nv">obj = </span><span class="kc">null</span>
-    <span class="nx">nodes</span></pre></div>             </td>           </tr>                               <tr id="section-51">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-51">&#182;</a>               </div>               <p>Compile a vanilla function call.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="nx">nodes</span></pre></div>             </td>           </tr>                               <tr id="section-52">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-52">&#182;</a>               </div>               <p>Compile a vanilla function call.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nx">@variable</span><span class="o">?</span><span class="p">.</span><span class="nv">front = </span><span class="nx">@front</span>
    <span class="k">if</span> <span class="nv">code = </span><span class="nx">Splat</span><span class="p">.</span><span class="nx">compileSplattedArray</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">@args</span><span class="p">,</span> <span class="kc">true</span>
      <span class="k">return</span> <span class="nx">@compileSplat</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">code</span>
@@ -384,9 +391,9 @@ This allows syntax like <code>call a: b, c</code> into <code>call({a: b}, c);</c
    <span class="k">if</span> <span class="nx">@isSuper</span>
      <span class="nx">@superReference</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">+</span> <span class="s2">&quot;.call(this#{ args and &#39;, &#39; + args })&quot;</span>
    <span class="k">else</span>
-      <span class="p">(</span><span class="k">if</span> <span class="nx">@isNew</span> <span class="k">then</span> <span class="s1">&#39;new &#39;</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span><span class="p">)</span> <span class="o">+</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_ACCESS</span><span class="p">)</span> <span class="o">+</span> <span class="s2">&quot;(#{args})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-52">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-52">&#182;</a>               </div>               <p><code>super()</code> is converted into a call against the superclass's implementation
+      <span class="p">(</span><span class="k">if</span> <span class="nx">@isNew</span> <span class="k">then</span> <span class="s1">&#39;new &#39;</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span><span class="p">)</span> <span class="o">+</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_ACCESS</span><span class="p">)</span> <span class="o">+</span> <span class="s2">&quot;(#{args})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-53">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-53">&#182;</a>               </div>               <p><code>super()</code> is converted into a call against the superclass's implementation
 of the current function.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileSuper</span><span class="o">:</span> <span class="p">(</span><span class="nx">args</span><span class="p">,</span> <span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="s2">&quot;#{@superReference(o)}.call(this#{ if args.length then &#39;, &#39; else &#39;&#39; }#{args})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-53">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-53">&#182;</a>               </div>               <p>If you call a function with a splat, it's converted into a JavaScript
+    <span class="s2">&quot;#{@superReference(o)}.call(this#{ if args.length then &#39;, &#39; else &#39;&#39; }#{args})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-54">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-54">&#182;</a>               </div>               <p>If you call a function with a splat, it's converted into a JavaScript
 <code>.apply()</code> call to allow an array of arguments to be passed.
 If it's a constructor, then things get real tricky. We have to inject an
 inner constructor in order to be able to pass the varargs.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileSplat</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">splatArgs</span><span class="p">)</span> <span class="o">-&gt;</span>
@@ -412,14 +419,14 @@ inner constructor in order to be able to pass the varargs.</p>             </td>
        <span class="nx">fun</span> <span class="o">+=</span> <span class="nx">name</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span>
      <span class="k">else</span>
        <span class="nv">ref = </span><span class="s1">&#39;null&#39;</span>
-    <span class="s2">&quot;#{fun}.apply(#{ref}, #{splatArgs})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-54">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-54">&#182;</a>               </div>               <h3>Extends</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-55">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-55">&#182;</a>               </div>               <p>Node to extend an object's prototype with an ancestor object.
+    <span class="s2">&quot;#{fun}.apply(#{ref}, #{splatArgs})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-55">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-55">&#182;</a>               </div>               <h3>Extends</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-56">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-56">&#182;</a>               </div>               <p>Node to extend an object's prototype with an ancestor object.
 After <code>goog.inherits</code> from the
 <a href="http://closure-library.googlecode.com/svn/docs/closureGoogBase.js.html">Closure Library</a>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Extends = </span><span class="nx">class</span> <span class="nx">Extends</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@child</span><span class="p">,</span> <span class="nx">@parent</span><span class="p">)</span> <span class="o">-&gt;</span>

-  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;child&#39;</span><span class="p">,</span> <span class="s1">&#39;parent&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-56">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-56">&#182;</a>               </div>               <p>Hooks one constructor into another's prototype chain.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compile</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;child&#39;</span><span class="p">,</span> <span class="s1">&#39;parent&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-57">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-57">&#182;</a>               </div>               <p>Hooks one constructor into another's prototype chain.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compile</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nx">utility</span> <span class="s1">&#39;hasProp&#39;</span>
-    <span class="k">new</span> <span class="nx">Call</span><span class="p">(</span><span class="k">new</span> <span class="nx">Value</span><span class="p">(</span><span class="k">new</span> <span class="nx">Literal</span> <span class="nx">utility</span> <span class="s1">&#39;extends&#39;</span><span class="p">),</span> <span class="p">[</span><span class="nx">@child</span><span class="p">,</span> <span class="nx">@parent</span><span class="p">]).</span><span class="nx">compile</span> <span class="nx">o</span></pre></div>             </td>           </tr>                               <tr id="section-57">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-57">&#182;</a>               </div>               <h3>Access</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-58">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-58">&#182;</a>               </div>               <p>A <code>.</code> access into a property of a value, or the <code>::</code> shorthand for
+    <span class="k">new</span> <span class="nx">Call</span><span class="p">(</span><span class="k">new</span> <span class="nx">Value</span><span class="p">(</span><span class="k">new</span> <span class="nx">Literal</span> <span class="nx">utility</span> <span class="s1">&#39;extends&#39;</span><span class="p">),</span> <span class="p">[</span><span class="nx">@child</span><span class="p">,</span> <span class="nx">@parent</span><span class="p">]).</span><span class="nx">compile</span> <span class="nx">o</span></pre></div>             </td>           </tr>                               <tr id="section-58">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-58">&#182;</a>               </div>               <h3>Access</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-59">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-59">&#182;</a>               </div>               <p>A <code>.</code> access into a property of a value, or the <code>::</code> shorthand for
 an access into the object's prototype.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Access = </span><span class="nx">class</span> <span class="nx">Access</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@name</span><span class="p">,</span> <span class="nx">tag</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="vi">@name.asKey = </span><span class="kc">yes</span>
@@ -430,9 +437,9 @@ an access into the object's prototype.</p>             </td>             <td cla

  <span class="nx">compile</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nv">name = </span><span class="nx">@name</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span>
-    <span class="nx">@proto</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">IS_STRING</span><span class="p">.</span><span class="nx">test</span> <span class="nx">name</span> <span class="k">then</span> <span class="s2">&quot;[#{name}]&quot;</span> <span class="k">else</span> <span class="s2">&quot;.#{name}&quot;</span>
+    <span class="nx">@proto</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">IDENTIFIER</span><span class="p">.</span><span class="nx">test</span> <span class="nx">name</span> <span class="k">then</span> <span class="s2">&quot;.#{name}&quot;</span> <span class="k">else</span> <span class="s2">&quot;[#{name}]&quot;</span>

-  <span class="nx">isComplex</span><span class="o">:</span> <span class="nx">NO</span></pre></div>             </td>           </tr>                               <tr id="section-59">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-59">&#182;</a>               </div>               <h3>Index</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-60">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-60">&#182;</a>               </div>               <p>A <code>[ ... ]</code> indexed access into an array or object.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Index = </span><span class="nx">class</span> <span class="nx">Index</span> <span class="k">extends</span> <span class="nx">Base</span>
+  <span class="nx">isComplex</span><span class="o">:</span> <span class="nx">NO</span></pre></div>             </td>           </tr>                               <tr id="section-60">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-60">&#182;</a>               </div>               <h3>Index</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-61">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-61">&#182;</a>               </div>               <p>A <code>[ ... ]</code> indexed access into an array or object.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Index = </span><span class="nx">class</span> <span class="nx">Index</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@index</span><span class="p">)</span> <span class="o">-&gt;</span>

  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;index&#39;</span><span class="p">]</span>
@@ -441,7 +448,7 @@ an access into the object's prototype.</p>             </td>             <td cla
    <span class="p">(</span><span class="k">if</span> <span class="nx">@proto</span> <span class="k">then</span> <span class="s1">&#39;.prototype&#39;</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span><span class="p">)</span> <span class="o">+</span> <span class="s2">&quot;[#{ @index.compile o, LEVEL_PAREN }]&quot;</span>

  <span class="nx">isComplex</span><span class="o">:</span> <span class="o">-&gt;</span>
-    <span class="nx">@index</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-61">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-61">&#182;</a>               </div>               <h3>Range</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-62">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-62">&#182;</a>               </div>               <p>A range literal. Ranges can be used to extract portions (slices) of arrays,
+    <span class="nx">@index</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-62">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-62">&#182;</a>               </div>               <h3>Range</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-63">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-63">&#182;</a>               </div>               <p>A range literal. Ranges can be used to extract portions (slices) of arrays,
 to specify a range for comprehensions, or as a value, to be expanded into the
 corresponding array of integers at runtime.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Range = </span><span class="nx">class</span> <span class="nx">Range</span> <span class="k">extends</span> <span class="nx">Base</span>

@@ -449,34 +456,34 @@ corresponding array of integers at runtime.</p>             </td>             <t

  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@from</span><span class="p">,</span> <span class="nx">@to</span><span class="p">,</span> <span class="nx">tag</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="vi">@exclusive = </span><span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;exclusive&#39;</span>
-    <span class="vi">@equals = </span><span class="k">if</span> <span class="nx">@exclusive</span> <span class="k">then</span> <span class="s1">&#39;&#39;</span> <span class="k">else</span> <span class="s1">&#39;=&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-63">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-63">&#182;</a>               </div>               <p>Compiles the range's source variables -- where it starts and where it ends.
+    <span class="vi">@equals = </span><span class="k">if</span> <span class="nx">@exclusive</span> <span class="k">then</span> <span class="s1">&#39;&#39;</span> <span class="k">else</span> <span class="s1">&#39;=&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-64">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-64">&#182;</a>               </div>               <p>Compiles the range's source variables -- where it starts and where it ends.
 But only if they need to be cached to avoid double evaluation.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileVariables</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="nv">o = </span><span class="nx">merge</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">top</span><span class="o">:</span> <span class="kc">true</span><span class="p">)</span>
-    <span class="p">[</span><span class="nx">@from</span><span class="p">,</span> <span class="nx">@fromVar</span><span class="p">]</span> <span class="o">=</span>  <span class="nx">@from</span><span class="p">.</span><span class="nx">cache</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
-    <span class="p">[</span><span class="nx">@to</span><span class="p">,</span> <span class="nx">@toVar</span><span class="p">]</span> <span class="o">=</span>      <span class="nx">@to</span><span class="p">.</span><span class="nx">cache</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
-    <span class="p">[</span><span class="nx">@fromNum</span><span class="p">,</span> <span class="nx">@toNum</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="nx">@fromVar</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">SIMPLENUM</span><span class="p">),</span> <span class="nx">@toVar</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">SIMPLENUM</span><span class="p">)]</span>
-    <span class="nv">parts = </span><span class="p">[]</span>
-    <span class="nx">parts</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@from</span> <span class="k">if</span> <span class="nx">@from</span> <span class="o">isnt</span> <span class="nx">@fromVar</span>
-    <span class="nx">parts</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@to</span> <span class="k">if</span> <span class="nx">@to</span> <span class="o">isnt</span> <span class="nx">@toVar</span></pre></div>             </td>           </tr>                               <tr id="section-64">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-64">&#182;</a>               </div>               <p>When compiled normally, the range returns the contents of the <em>for loop</em>
+    <span class="nv">o = </span><span class="nx">merge</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">top</span><span class="o">:</span> <span class="kc">true</span>
+    <span class="p">[</span><span class="nx">@fromC</span><span class="p">,</span> <span class="nx">@fromVar</span><span class="p">]</span>  <span class="o">=</span>  <span class="nx">@from</span><span class="p">.</span><span class="nx">cache</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
+    <span class="p">[</span><span class="nx">@toC</span><span class="p">,</span> <span class="nx">@toVar</span><span class="p">]</span>      <span class="o">=</span>  <span class="nx">@to</span><span class="p">.</span><span class="nx">cache</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
+    <span class="p">[</span><span class="nx">@step</span><span class="p">,</span> <span class="nx">@stepVar</span><span class="p">]</span>   <span class="o">=</span>  <span class="nx">step</span><span class="p">.</span><span class="nx">cache</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span> <span class="k">if</span> <span class="nv">step = </span><span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s1">&#39;step&#39;</span>
+    <span class="p">[</span><span class="nx">@fromNum</span><span class="p">,</span> <span class="nx">@toNum</span><span class="p">]</span>  <span class="o">=</span> <span class="p">[</span><span class="nx">@fromVar</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">SIMPLENUM</span><span class="p">),</span> <span class="nx">@toVar</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">SIMPLENUM</span><span class="p">)]</span>
+    <span class="vi">@stepNum            = </span><span class="nx">@stepVar</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">SIMPLENUM</span><span class="p">)</span> <span class="k">if</span> <span class="nx">@stepVar</span></pre></div>             </td>           </tr>                               <tr id="section-65">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-65">&#182;</a>               </div>               <p>When compiled normally, the range returns the contents of the <em>for loop</em>
 needed to iterate over the values in the range. Used by comprehensions.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="nx">@compileVariables</span> <span class="nx">o</span>
-    <span class="k">return</span>    <span class="nx">@compileArray</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>  <span class="nx">unless</span> <span class="nx">o</span><span class="p">.</span><span class="nx">index</span>
-    <span class="k">return</span>    <span class="nx">@compileSimple</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="k">if</span> <span class="nx">@fromNum</span> <span class="o">and</span> <span class="nx">@toNum</span>
+    <span class="nx">@compileVariables</span> <span class="nx">o</span> <span class="nx">unless</span> <span class="nx">@fromVar</span>
+    <span class="k">return</span> <span class="nx">@compileArray</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="nx">unless</span> <span class="nx">o</span><span class="p">.</span><span class="nx">index</span></pre></div>             </td>           </tr>                               <tr id="section-66">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-66">&#182;</a>               </div>               <p>Set up endpoints.</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="nv">known    = </span><span class="nx">@fromNum</span> <span class="o">and</span> <span class="nx">@toNum</span>
    <span class="nv">idx      = </span><span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s1">&#39;index&#39;</span>
-    <span class="nv">step     = </span><span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s1">&#39;step&#39;</span>
-    <span class="nv">vars     = </span><span class="s2">&quot;#{idx} = #{@from}&quot;</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">@to</span> <span class="o">isnt</span> <span class="nx">@toVar</span> <span class="k">then</span> <span class="s2">&quot;, #{@to}&quot;</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span>
-    <span class="nv">cond     = </span><span class="s2">&quot;#{@fromVar} &lt;= #{@toVar}&quot;</span>
-    <span class="nv">compare  = </span><span class="s2">&quot;#{cond} ? #{idx} &lt;#{@equals} #{@toVar} : #{idx} &gt;#{@equals} #{@toVar}&quot;</span>
-    <span class="nv">incr     = </span><span class="k">if</span> <span class="nx">step</span> <span class="k">then</span> <span class="s2">&quot;#{idx} += #{step.compile(o)}&quot;</span> <span class="k">else</span> <span class="s2">&quot;#{cond} ? #{idx}++ : #{idx}--&quot;</span>
-    <span class="s2">&quot;#{vars}; #{compare}; #{incr}&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-65">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-65">&#182;</a>               </div>               <p>Compile a simple range comprehension, with integers.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileSimple</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="p">[</span><span class="nx">from</span><span class="p">,</span> <span class="nx">to</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="o">+</span><span class="nx">@fromNum</span><span class="p">,</span> <span class="o">+</span><span class="nx">@toNum</span><span class="p">]</span>
-    <span class="nv">idx        = </span><span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s1">&#39;index&#39;</span>
-    <span class="nv">step       = </span><span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s1">&#39;step&#39;</span>
-    <span class="nx">step</span>       <span class="o">and=</span> <span class="s2">&quot;#{idx} += #{step.compile(o)}&quot;</span>
-    <span class="k">if</span> <span class="nx">from</span> <span class="o">&lt;=</span> <span class="nx">to</span>
-      <span class="s2">&quot;#{idx} = #{from}; #{idx} &lt;#{@equals} #{to}; #{step or &quot;</span><span class="c1">#{idx}++&quot;}&quot;</span>
+    <span class="nv">varPart  = </span><span class="s2">&quot;#{idx} = #{@fromC}&quot;</span>
+    <span class="nx">varPart</span> <span class="o">+=</span> <span class="s2">&quot;, #{@toC}&quot;</span> <span class="k">if</span> <span class="nx">@toC</span> <span class="o">isnt</span> <span class="nx">@toVar</span>
+    <span class="nx">varPart</span> <span class="o">+=</span> <span class="s2">&quot;, #{@step}&quot;</span> <span class="k">if</span> <span class="nx">@step</span> <span class="o">isnt</span> <span class="nx">@stepVar</span>
+    <span class="p">[</span><span class="nx">lt</span><span class="p">,</span> <span class="nx">gt</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&quot;#{idx} &lt;#{@equals}&quot;</span><span class="p">,</span> <span class="s2">&quot;#{idx} &gt;#{@equals}&quot;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-67">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-67">&#182;</a>               </div>               <p>Generate the condition.</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="nv">condPart = </span><span class="k">if</span> <span class="nx">@stepNum</span>
+      <span class="nv">condPart = </span><span class="k">if</span> <span class="o">+</span><span class="nx">@stepNum</span> <span class="o">&gt;</span> <span class="mi">0</span> <span class="k">then</span> <span class="s2">&quot;#{lt} #{@toVar}&quot;</span> <span class="k">else</span> <span class="s2">&quot;#{gt} #{@toVar}&quot;</span>
+    <span class="k">else</span> <span class="k">if</span> <span class="nx">known</span>
+      <span class="p">[</span><span class="nx">from</span><span class="p">,</span> <span class="nx">to</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="o">+</span><span class="nx">@fromNum</span><span class="p">,</span> <span class="o">+</span><span class="nx">@toNum</span><span class="p">]</span>
+      <span class="nv">condPart   = </span><span class="k">if</span> <span class="nx">from</span> <span class="o">&lt;=</span> <span class="nx">to</span> <span class="k">then</span> <span class="s2">&quot;#{lt} #{to}&quot;</span> <span class="k">else</span> <span class="s2">&quot;#{gt} #{to}&quot;</span>
    <span class="k">else</span>
-      <span class="s2">&quot;#{idx} = #{from}; #{idx} &gt;#{@equals} #{to}; #{step or &quot;</span><span class="c1">#{idx}--&quot;}&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-66">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-66">&#182;</a>               </div>               <p>When used as a value, expand the range into the equivalent array.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileArray</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
+      <span class="nv">cond     = </span><span class="s2">&quot;#{@fromVar} &lt;= #{@toVar}&quot;</span>
+      <span class="nv">condPart = </span><span class="s2">&quot;#{cond} ? #{lt} #{@toVar} : #{gt} #{@toVar}&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-68">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-68">&#182;</a>               </div>               <p>Generate the step.</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="nv">stepPart = </span><span class="k">if</span> <span class="nx">@stepVar</span>
+      <span class="s2">&quot;#{idx} += #{@stepVar}&quot;</span>
+    <span class="k">else</span> <span class="k">if</span> <span class="nx">known</span>
+      <span class="k">if</span> <span class="nx">from</span> <span class="o">&lt;=</span> <span class="nx">to</span> <span class="k">then</span> <span class="s2">&quot;#{idx}++&quot;</span> <span class="k">else</span> <span class="s2">&quot;#{idx}--&quot;</span>
+    <span class="k">else</span>
+      <span class="s2">&quot;#{cond} ? #{idx}++ : #{idx}--&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-69">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-69">&#182;</a>               </div>               <p>The final loop body.</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="s2">&quot;#{varPart}; #{condPart}; #{stepPart}&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-70">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-70">&#182;</a>               </div>               <p>When used as a value, expand the range into the equivalent array.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileArray</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">if</span> <span class="nx">@fromNum</span> <span class="o">and</span> <span class="nx">@toNum</span> <span class="o">and</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">abs</span><span class="p">(</span><span class="nx">@fromNum</span> <span class="o">-</span> <span class="nx">@toNum</span><span class="p">)</span> <span class="o">&lt;=</span> <span class="mi">20</span>
      <span class="nv">range = </span><span class="p">[</span><span class="o">+</span><span class="nx">@fromNum</span><span class="p">..</span><span class="o">+</span><span class="nx">@toNum</span><span class="p">]</span>
      <span class="nx">range</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span> <span class="k">if</span> <span class="nx">@exclusive</span>
@@ -487,20 +494,22 @@ needed to iterate over the values in the range. Used by comprehensions.</p>
    <span class="nv">pre    = </span><span class="s2">&quot;\n#{idt}#{result} = [];&quot;</span>
    <span class="k">if</span> <span class="nx">@fromNum</span> <span class="o">and</span> <span class="nx">@toNum</span>
      <span class="nv">o.index = </span><span class="nx">i</span>
-      <span class="nv">body    = </span><span class="nx">@compileSimple</span> <span class="nx">o</span>
+      <span class="nv">body    = </span><span class="nx">@compileNode</span> <span class="nx">o</span>
    <span class="k">else</span>
-      <span class="nv">vars    = </span><span class="s2">&quot;#{i} = #{@from}&quot;</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">@to</span> <span class="o">isnt</span> <span class="nx">@toVar</span> <span class="k">then</span> <span class="s2">&quot;, #{@to}&quot;</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span>
+      <span class="nv">vars    = </span><span class="s2">&quot;#{i} = #{@fromC}&quot;</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">@toC</span> <span class="o">isnt</span> <span class="nx">@toVar</span> <span class="k">then</span> <span class="s2">&quot;, #{@toC}&quot;</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span>
      <span class="nv">cond    = </span><span class="s2">&quot;#{@fromVar} &lt;= #{@toVar}&quot;</span>
      <span class="nv">body    = </span><span class="s2">&quot;var #{vars}; #{cond} ? #{i} &lt;#{@equals} #{@toVar} : #{i} &gt;#{@equals} #{@toVar}; #{cond} ? #{i}++ : #{i}--&quot;</span>
    <span class="nv">post   = </span><span class="s2">&quot;{ #{result}.push(#{i}); }\n#{idt}return #{result};\n#{o.indent}&quot;</span>
-    <span class="s2">&quot;(function() {#{pre}\n#{idt}for (#{body})#{post}}).apply(this, arguments)&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-67">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-67">&#182;</a>               </div>               <h3>Slice</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-68">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-68">&#182;</a>               </div>               <p>An array slice literal. Unlike JavaScript's <code>Array#slice</code>, the second parameter
+    <span class="nv">hasArgs = </span><span class="p">(</span><span class="nx">node</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">node</span><span class="o">?</span><span class="p">.</span><span class="nx">contains</span> <span class="p">(</span><span class="nx">n</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">n</span> <span class="k">instanceof</span> <span class="nx">Literal</span> <span class="o">and</span> <span class="nx">n</span><span class="p">.</span><span class="nx">value</span> <span class="o">is</span> <span class="s1">&#39;arguments&#39;</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">n</span><span class="p">.</span><span class="nx">asKey</span>
+    <span class="nv">args   = </span><span class="s1">&#39;, arguments&#39;</span> <span class="k">if</span> <span class="nx">hasArgs</span><span class="p">(</span><span class="nx">@from</span><span class="p">)</span> <span class="o">or</span> <span class="nx">hasArgs</span><span class="p">(</span><span class="nx">@to</span><span class="p">)</span>
+    <span class="s2">&quot;(function() {#{pre}\n#{idt}for (#{body})#{post}}).apply(this#{args ? &#39;&#39;})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-71">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-71">&#182;</a>               </div>               <h3>Slice</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-72">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-72">&#182;</a>               </div>               <p>An array slice literal. Unlike JavaScript's <code>Array#slice</code>, the second parameter
 specifies the index of the end of the slice, just as the first parameter
 is the index of the beginning.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Slice = </span><span class="nx">class</span> <span class="nx">Slice</span> <span class="k">extends</span> <span class="nx">Base</span>

  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;range&#39;</span><span class="p">]</span>

  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@range</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">super</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-69">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-69">&#182;</a>               </div>               <p>We have to be careful when trying to slice through the end of the array,
+    <span class="k">super</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-73">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-73">&#182;</a>               </div>               <p>We have to be careful when trying to slice through the end of the array,
 <code>9e9</code> is used because not all implementations respect <code>undefined</code> or <code>1/0</code>.
 <code>9e9</code> should be safe because <code>9e9</code> > <code>2**32</code>, the max array length.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="p">{</span><span class="nx">to</span><span class="p">,</span> <span class="nx">from</span><span class="p">}</span> <span class="o">=</span> <span class="nx">@range</span>
@@ -513,7 +522,7 @@ is the index of the beginning.</p>             </td>             <td class="code
        <span class="p">(</span><span class="o">+</span><span class="nx">compiled</span> <span class="o">+</span> <span class="mi">1</span><span class="p">).</span><span class="nx">toString</span><span class="p">()</span>
      <span class="k">else</span>
        <span class="s2">&quot;(#{compiled} + 1) || 9e9&quot;</span>
-    <span class="s2">&quot;.slice(#{ fromStr }#{ toStr or &#39;&#39; })&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-70">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-70">&#182;</a>               </div>               <h3>Obj</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-71">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-71">&#182;</a>               </div>               <p>An object literal, nothing fancy.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Obj = </span><span class="nx">class</span> <span class="nx">Obj</span> <span class="k">extends</span> <span class="nx">Base</span>
+    <span class="s2">&quot;.slice(#{ fromStr }#{ toStr or &#39;&#39; })&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-74">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-74">&#182;</a>               </div>               <h3>Obj</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-75">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-75">&#182;</a>               </div>               <p>An object literal, nothing fancy.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Obj = </span><span class="nx">class</span> <span class="nx">Obj</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">props</span><span class="p">,</span> <span class="vi">@generated = </span><span class="kc">false</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="vi">@objects = @properties = </span><span class="nx">props</span> <span class="o">or</span> <span class="p">[]</span>

@@ -548,7 +557,7 @@ is the index of the beginning.</p>             </td>             <td class="code

  <span class="nx">assigns</span><span class="o">:</span> <span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">for</span> <span class="nx">prop</span> <span class="k">in</span> <span class="nx">@properties</span> <span class="k">when</span> <span class="nx">prop</span><span class="p">.</span><span class="nx">assigns</span> <span class="nx">name</span> <span class="k">then</span> <span class="k">return</span> <span class="kc">yes</span>
-    <span class="kc">no</span></pre></div>             </td>           </tr>                               <tr id="section-72">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-72">&#182;</a>               </div>               <h3>Arr</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-73">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-73">&#182;</a>               </div>               <p>An array literal.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Arr = </span><span class="nx">class</span> <span class="nx">Arr</span> <span class="k">extends</span> <span class="nx">Base</span>
+    <span class="kc">no</span></pre></div>             </td>           </tr>                               <tr id="section-76">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-76">&#182;</a>               </div>               <h3>Arr</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-77">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-77">&#182;</a>               </div>               <p>An array literal.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Arr = </span><span class="nx">class</span> <span class="nx">Arr</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">objs</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="vi">@objects = </span><span class="nx">objs</span> <span class="o">or</span> <span class="p">[]</span>

@@ -569,20 +578,20 @@ is the index of the beginning.</p>             </td>             <td class="code

  <span class="nx">assigns</span><span class="o">:</span> <span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">for</span> <span class="nx">obj</span> <span class="k">in</span> <span class="nx">@objects</span> <span class="k">when</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">assigns</span> <span class="nx">name</span> <span class="k">then</span> <span class="k">return</span> <span class="kc">yes</span>
-    <span class="kc">no</span></pre></div>             </td>           </tr>                               <tr id="section-74">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-74">&#182;</a>               </div>               <h3>Class</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-75">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-75">&#182;</a>               </div>               <p>The CoffeeScript class definition.
+    <span class="kc">no</span></pre></div>             </td>           </tr>                               <tr id="section-78">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-78">&#182;</a>               </div>               <h3>Class</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-79">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-79">&#182;</a>               </div>               <p>The CoffeeScript class definition.
 Initialize a <strong>Class</strong> with its name, an optional superclass, and a
 list of prototype property assignments.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Class = </span><span class="nx">class</span> <span class="nx">Class</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@variable</span><span class="p">,</span> <span class="nx">@parent</span><span class="p">,</span> <span class="vi">@body = </span><span class="k">new</span> <span class="nx">Block</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="vi">@boundFuncs = </span><span class="p">[]</span>
    <span class="vi">@body.classBody = </span><span class="kc">yes</span>

-  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;variable&#39;</span><span class="p">,</span> <span class="s1">&#39;parent&#39;</span><span class="p">,</span> <span class="s1">&#39;body&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-76">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-76">&#182;</a>               </div>               <p>Figure out the appropriate name for the constructor function of this class.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">determineName</span><span class="o">:</span> <span class="o">-&gt;</span>
+  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;variable&#39;</span><span class="p">,</span> <span class="s1">&#39;parent&#39;</span><span class="p">,</span> <span class="s1">&#39;body&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-80">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-80">&#182;</a>               </div>               <p>Figure out the appropriate name for the constructor function of this class.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">determineName</span><span class="o">:</span> <span class="o">-&gt;</span>
    <span class="k">return</span> <span class="kc">null</span> <span class="nx">unless</span> <span class="nx">@variable</span>
    <span class="nv">decl = </span><span class="k">if</span> <span class="nv">tail = </span><span class="nx">last</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">properties</span>
      <span class="nx">tail</span> <span class="k">instanceof</span> <span class="nx">Access</span> <span class="o">and</span> <span class="nx">tail</span><span class="p">.</span><span class="nx">name</span><span class="p">.</span><span class="nx">value</span>
    <span class="k">else</span>
      <span class="nx">@variable</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">value</span>
-    <span class="nx">decl</span> <span class="o">and=</span> <span class="nx">IDENTIFIER</span><span class="p">.</span><span class="nx">test</span><span class="p">(</span><span class="nx">decl</span><span class="p">)</span> <span class="o">and</span> <span class="nx">decl</span></pre></div>             </td>           </tr>                               <tr id="section-77">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-77">&#182;</a>               </div>               <p>For all <code>this</code>-references and bound functions in the class definition,
+    <span class="nx">decl</span> <span class="o">and=</span> <span class="nx">IDENTIFIER</span><span class="p">.</span><span class="nx">test</span><span class="p">(</span><span class="nx">decl</span><span class="p">)</span> <span class="o">and</span> <span class="nx">decl</span></pre></div>             </td>           </tr>                               <tr id="section-81">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-81">&#182;</a>               </div>               <p>For all <code>this</code>-references and bound functions in the class definition,
 <code>this</code> is the Class being constructed.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">setContext</span><span class="o">:</span> <span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nx">@body</span><span class="p">.</span><span class="nx">traverseChildren</span> <span class="kc">false</span><span class="p">,</span> <span class="p">(</span><span class="nx">node</span><span class="p">)</span> <span class="o">-&gt;</span>
      <span class="k">return</span> <span class="kc">false</span> <span class="k">if</span> <span class="nx">node</span><span class="p">.</span><span class="nx">classBody</span>
@@ -590,15 +599,15 @@ list of prototype property assignments.</p>             </td>             <td cl
        <span class="nv">node.value    = </span><span class="nx">name</span>
      <span class="k">else</span> <span class="k">if</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Code</span>
        <span class="nv">node.klass    = </span><span class="nx">name</span>
-        <span class="nv">node.context  = </span><span class="nx">name</span> <span class="k">if</span> <span class="nx">node</span><span class="p">.</span><span class="nx">bound</span></pre></div>             </td>           </tr>                               <tr id="section-78">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-78">&#182;</a>               </div>               <p>Ensure that all functions bound to the instance are proxied in the
+        <span class="nv">node.context  = </span><span class="nx">name</span> <span class="k">if</span> <span class="nx">node</span><span class="p">.</span><span class="nx">bound</span></pre></div>             </td>           </tr>                               <tr id="section-82">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-82">&#182;</a>               </div>               <p>Ensure that all functions bound to the instance are proxied in the
 constructor.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">addBoundFunctions</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">if</span> <span class="nx">@boundFuncs</span><span class="p">.</span><span class="nx">length</span>
      <span class="k">for</span> <span class="nx">bvar</span> <span class="k">in</span> <span class="nx">@boundFuncs</span>
-        <span class="nv">bname = </span><span class="nx">bvar</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span>
-        <span class="nx">@ctor</span><span class="p">.</span><span class="nx">body</span><span class="p">.</span><span class="nx">unshift</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s2">&quot;this.#{bname} = #{utility &#39;bind&#39;}(this.#{bname}, this);&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-79">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-79">&#182;</a>               </div>               <p>Merge the properties from a top-level object as prototypal properties
-on the class.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">addProperties</span><span class="o">:</span> <span class="p">(</span><span class="nx">node</span><span class="p">,</span> <span class="nx">name</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="nv">props = </span><span class="nx">node</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">properties</span><span class="p">.</span><span class="nx">slice</span> <span class="mi">0</span>
-    <span class="k">while</span> <span class="nv">assign = </span><span class="nx">props</span><span class="p">.</span><span class="nx">shift</span><span class="p">()</span>
+        <span class="nv">lhs = </span><span class="p">(</span><span class="k">new</span> <span class="nx">Value</span> <span class="p">(</span><span class="k">new</span> <span class="nx">Literal</span> <span class="s2">&quot;this&quot;</span><span class="p">),</span> <span class="p">[</span><span class="k">new</span> <span class="nx">Access</span> <span class="nx">bvar</span><span class="p">]).</span><span class="nx">compile</span> <span class="nx">o</span>
+        <span class="nx">@ctor</span><span class="p">.</span><span class="nx">body</span><span class="p">.</span><span class="nx">unshift</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s2">&quot;#{lhs} = #{utility &#39;bind&#39;}(#{lhs}, this)&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-83">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-83">&#182;</a>               </div>               <p>Merge the properties from a top-level object as prototypal properties
+on the class.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">addProperties</span><span class="o">:</span> <span class="p">(</span><span class="nx">node</span><span class="p">,</span> <span class="nx">name</span><span class="p">,</span> <span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="nv">props = </span><span class="nx">node</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">properties</span><span class="p">[</span><span class="mi">0</span><span class="p">..]</span>
+    <span class="nv">exprs = </span><span class="k">while</span> <span class="nv">assign = </span><span class="nx">props</span><span class="p">.</span><span class="nx">shift</span><span class="p">()</span>
      <span class="k">if</span> <span class="nx">assign</span> <span class="k">instanceof</span> <span class="nx">Assign</span>
        <span class="nv">base = </span><span class="nx">assign</span><span class="p">.</span><span class="nx">variable</span><span class="p">.</span><span class="nx">base</span>
        <span class="k">delete</span> <span class="nx">assign</span><span class="p">.</span><span class="nx">context</span>
@@ -611,29 +620,32 @@ on the class.</p>             </td>             <td class="code">
          <span class="k">if</span> <span class="nx">func</span> <span class="k">instanceof</span> <span class="nx">Code</span>
            <span class="nv">assign = </span><span class="vi">@ctor = </span><span class="nx">func</span>
          <span class="k">else</span>
-            <span class="nv">assign = </span><span class="vi">@ctor = </span><span class="k">new</span> <span class="nx">Assign</span><span class="p">(</span><span class="k">new</span> <span class="nx">Value</span><span class="p">(</span><span class="k">new</span> <span class="nx">Literal</span> <span class="nx">name</span><span class="p">),</span> <span class="nx">func</span><span class="p">)</span>
+            <span class="vi">@externalCtor = </span><span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span> <span class="s1">&#39;class&#39;</span>
+            <span class="nv">assign = </span><span class="k">new</span> <span class="nx">Assign</span> <span class="k">new</span> <span class="nx">Literal</span><span class="p">(</span><span class="nx">@externalCtor</span><span class="p">),</span> <span class="nx">func</span>
        <span class="k">else</span>
          <span class="nx">unless</span> <span class="nx">assign</span><span class="p">.</span><span class="nx">variable</span><span class="p">.</span><span class="k">this</span>
            <span class="nv">assign.variable = </span><span class="k">new</span> <span class="nx">Value</span><span class="p">(</span><span class="k">new</span> <span class="nx">Literal</span><span class="p">(</span><span class="nx">name</span><span class="p">),</span> <span class="p">[</span><span class="k">new</span> <span class="nx">Access</span><span class="p">(</span><span class="nx">base</span><span class="p">,</span> <span class="s1">&#39;proto&#39;</span><span class="p">)])</span>
          <span class="k">if</span> <span class="nx">func</span> <span class="k">instanceof</span> <span class="nx">Code</span> <span class="o">and</span> <span class="nx">func</span><span class="p">.</span><span class="nx">bound</span>
            <span class="nx">@boundFuncs</span><span class="p">.</span><span class="nx">push</span> <span class="nx">base</span>
            <span class="nv">func.bound = </span><span class="kc">no</span>
-      <span class="nx">assign</span></pre></div>             </td>           </tr>                               <tr id="section-80">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-80">&#182;</a>               </div>               <p>Walk the body of the class, looking for prototype properties to be converted.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">walkBody</span><span class="o">:</span> <span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-&gt;</span>
+      <span class="nx">assign</span>
+    <span class="nx">compact</span> <span class="nx">exprs</span></pre></div>             </td>           </tr>                               <tr id="section-84">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-84">&#182;</a>               </div>               <p>Walk the body of the class, looking for prototype properties to be converted.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">walkBody</span><span class="o">:</span> <span class="p">(</span><span class="nx">name</span><span class="p">,</span> <span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nx">@traverseChildren</span> <span class="kc">false</span><span class="p">,</span> <span class="p">(</span><span class="nx">child</span><span class="p">)</span> <span class="o">=&gt;</span>
      <span class="k">return</span> <span class="kc">false</span> <span class="k">if</span> <span class="nx">child</span> <span class="k">instanceof</span> <span class="nx">Class</span>
      <span class="k">if</span> <span class="nx">child</span> <span class="k">instanceof</span> <span class="nx">Block</span>
        <span class="k">for</span> <span class="nx">node</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nv">exps = </span><span class="nx">child</span><span class="p">.</span><span class="nx">expressions</span>
          <span class="k">if</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Value</span> <span class="o">and</span> <span class="nx">node</span><span class="p">.</span><span class="nx">isObject</span><span class="p">(</span><span class="kc">true</span><span class="p">)</span>
-            <span class="nx">exps</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">=</span> <span class="nx">@addProperties</span> <span class="nx">node</span><span class="p">,</span> <span class="nx">name</span>
-        <span class="nv">child.expressions = exps = </span><span class="nx">flatten</span> <span class="nx">exps</span></pre></div>             </td>           </tr>                               <tr id="section-81">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-81">&#182;</a>               </div>               <p>Make sure that a constructor is defined for the class, and properly
+            <span class="nx">exps</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">=</span> <span class="nx">@addProperties</span> <span class="nx">node</span><span class="p">,</span> <span class="nx">name</span><span class="p">,</span> <span class="nx">o</span>
+        <span class="nv">child.expressions = exps = </span><span class="nx">flatten</span> <span class="nx">exps</span></pre></div>             </td>           </tr>                               <tr id="section-85">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-85">&#182;</a>               </div>               <p>Make sure that a constructor is defined for the class, and properly
 configured.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">ensureConstructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">if</span> <span class="o">not</span> <span class="nx">@ctor</span>
      <span class="vi">@ctor = </span><span class="k">new</span> <span class="nx">Code</span>
-      <span class="nx">@ctor</span><span class="p">.</span><span class="nx">body</span><span class="p">.</span><span class="nx">push</span> <span class="k">new</span> <span class="nx">Call</span> <span class="s1">&#39;super&#39;</span><span class="p">,</span> <span class="p">[</span><span class="k">new</span> <span class="nx">Splat</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;arguments&#39;</span><span class="p">]</span> <span class="k">if</span> <span class="nx">@parent</span>
+      <span class="nx">@ctor</span><span class="p">.</span><span class="nx">body</span><span class="p">.</span><span class="nx">push</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s2">&quot;#{name}.__super__.constructor.apply(this, arguments)&quot;</span> <span class="k">if</span> <span class="nx">@parent</span>
+      <span class="nx">@ctor</span><span class="p">.</span><span class="nx">body</span><span class="p">.</span><span class="nx">push</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s2">&quot;#{@externalCtor}.apply(this, arguments)&quot;</span> <span class="k">if</span> <span class="nx">@externalCtor</span>
      <span class="nx">@body</span><span class="p">.</span><span class="nx">expressions</span><span class="p">.</span><span class="nx">unshift</span> <span class="nx">@ctor</span>
    <span class="vi">@ctor.ctor     = @ctor.name = </span><span class="nx">name</span>
    <span class="vi">@ctor.klass    = </span><span class="kc">null</span>
-    <span class="vi">@ctor.noReturn = </span><span class="kc">yes</span></pre></div>             </td>           </tr>                               <tr id="section-82">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-82">&#182;</a>               </div>               <p>Instead of generating the JavaScript string directly, we build up the
+    <span class="vi">@ctor.noReturn = </span><span class="kc">yes</span></pre></div>             </td>           </tr>                               <tr id="section-86">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-86">&#182;</a>               </div>               <p>Instead of generating the JavaScript string directly, we build up the
 equivalent syntax tree and compile that, in pieces. You can see the
 constructor, property assignments, and inheritance getting built out below.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nv">decl  = </span><span class="nx">@determineName</span><span class="p">()</span>
@@ -641,26 +653,30 @@ constructor, property assignments, and inheritance getting built out below.</p>
    <span class="nv">lname = </span><span class="k">new</span> <span class="nx">Literal</span> <span class="nx">name</span>

    <span class="nx">@setContext</span> <span class="nx">name</span>
-    <span class="nx">@walkBody</span> <span class="nx">name</span>
+    <span class="nx">@walkBody</span> <span class="nx">name</span><span class="p">,</span> <span class="nx">o</span>
    <span class="nx">@ensureConstructor</span> <span class="nx">name</span>
-    <span class="nx">@body</span><span class="p">.</span><span class="nx">expressions</span><span class="p">.</span><span class="nx">splice</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="k">new</span> <span class="nx">Extends</span><span class="p">(</span><span class="nx">lname</span><span class="p">,</span> <span class="nx">@parent</span><span class="p">)</span> <span class="k">if</span> <span class="nx">@parent</span>
+    <span class="nx">@body</span><span class="p">.</span><span class="nx">expressions</span><span class="p">.</span><span class="nx">unshift</span> <span class="k">new</span> <span class="nx">Extends</span> <span class="nx">lname</span><span class="p">,</span> <span class="nx">@parent</span> <span class="k">if</span> <span class="nx">@parent</span>
+    <span class="nx">@body</span><span class="p">.</span><span class="nx">expressions</span><span class="p">.</span><span class="nx">unshift</span> <span class="nx">@ctor</span> <span class="nx">unless</span> <span class="nx">@ctor</span> <span class="k">instanceof</span> <span class="nx">Code</span>
    <span class="nx">@body</span><span class="p">.</span><span class="nx">expressions</span><span class="p">.</span><span class="nx">push</span> <span class="nx">lname</span>
    <span class="nx">@addBoundFunctions</span> <span class="nx">o</span>

    <span class="nv">klass = </span><span class="k">new</span> <span class="nx">Parens</span> <span class="nx">Closure</span><span class="p">.</span><span class="nx">wrap</span><span class="p">(</span><span class="nx">@body</span><span class="p">),</span> <span class="kc">true</span>
    <span class="nv">klass = </span><span class="k">new</span> <span class="nx">Assign</span> <span class="nx">@variable</span><span class="p">,</span> <span class="nx">klass</span> <span class="k">if</span> <span class="nx">@variable</span>
-    <span class="nx">klass</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span></pre></div>             </td>           </tr>                               <tr id="section-83">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-83">&#182;</a>               </div>               <h3>Assign</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-84">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-84">&#182;</a>               </div>               <p>The <strong>Assign</strong> is used to assign a local variable to value, or to set the
+    <span class="nx">klass</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span></pre></div>             </td>           </tr>                               <tr id="section-87">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-87">&#182;</a>               </div>               <h3>Assign</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-88">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-88">&#182;</a>               </div>               <p>The <strong>Assign</strong> is used to assign a local variable to value, or to set the
 property of an object -- including within object literals.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Assign = </span><span class="nx">class</span> <span class="nx">Assign</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@variable</span><span class="p">,</span> <span class="nx">@value</span><span class="p">,</span> <span class="nx">@context</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="vi">@param = </span><span class="nx">options</span> <span class="o">and</span> <span class="nx">options</span><span class="p">.</span><span class="nx">param</span></pre></div>             </td>           </tr>                               <tr id="section-85">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-85">&#182;</a>               </div>               <p>Matchers for detecting class/method names</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">METHOD_DEF</span><span class="o">:</span> <span class="sr">/^(?:(\S+)\.prototype\.|\S+?)?\b([$A-Za-z_][$\w\x7f-\uffff]*)$/</span>
+    <span class="vi">@param = </span><span class="nx">options</span> <span class="o">and</span> <span class="nx">options</span><span class="p">.</span><span class="nx">param</span>

  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;variable&#39;</span><span class="p">,</span> <span class="s1">&#39;value&#39;</span><span class="p">]</span>

+  <span class="nx">isStatement</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="nx">o</span><span class="o">?</span><span class="p">.</span><span class="nx">level</span> <span class="o">is</span> <span class="nx">LEVEL_TOP</span> <span class="o">and</span> <span class="nx">@context</span><span class="o">?</span> <span class="o">and</span> <span class="s2">&quot;?&quot;</span> <span class="k">in</span> <span class="nx">@context</span>
+
  <span class="nx">assigns</span><span class="o">:</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="p">[</span><span class="k">if</span> <span class="nx">@context</span> <span class="o">is</span> <span class="s1">&#39;object&#39;</span> <span class="k">then</span> <span class="s1">&#39;value&#39;</span> <span class="k">else</span> <span class="s1">&#39;variable&#39;</span><span class="p">].</span><span class="nx">assigns</span> <span class="nx">name</span>

  <span class="nx">unfoldSoak</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="nx">unfoldSoak</span> <span class="nx">o</span><span class="p">,</span> <span class="k">this</span><span class="p">,</span> <span class="s1">&#39;variable&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-86">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-86">&#182;</a>               </div>               <p>Compile an assignment, delegating to <code>compilePatternMatch</code> or
+    <span class="nx">unfoldSoak</span> <span class="nx">o</span><span class="p">,</span> <span class="k">this</span><span class="p">,</span> <span class="s1">&#39;variable&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-89">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-89">&#182;</a>               </div>               <p>Compile an assignment, delegating to <code>compilePatternMatch</code> or
 <code>compileSplice</code> if appropriate. Keep track of the name of the base object
 we've been assigned to, for correct internal references. If the variable
 has not been seen yet within the current scope, declare it.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
@@ -676,13 +692,13 @@ has not been seen yet within the current scope, declare it.</p>             </td
        <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">add</span> <span class="nx">name</span><span class="p">,</span> <span class="s1">&#39;var&#39;</span>
      <span class="k">else</span>
        <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">find</span> <span class="nx">name</span>
-    <span class="k">if</span> <span class="nx">@value</span> <span class="k">instanceof</span> <span class="nx">Code</span> <span class="o">and</span> <span class="nv">match = </span><span class="nx">@METHOD_DEF</span><span class="p">.</span><span class="nx">exec</span> <span class="nx">name</span>
-      <span class="vi">@value.name  = </span><span class="nx">match</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
+    <span class="k">if</span> <span class="nx">@value</span> <span class="k">instanceof</span> <span class="nx">Code</span> <span class="o">and</span> <span class="nv">match = </span><span class="nx">METHOD_DEF</span><span class="p">.</span><span class="nx">exec</span> <span class="nx">name</span>
      <span class="vi">@value.klass = </span><span class="nx">match</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="k">if</span> <span class="nx">match</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
+      <span class="vi">@value.name  = </span><span class="nx">match</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">?</span> <span class="nx">match</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="o">?</span> <span class="nx">match</span><span class="p">[</span><span class="mi">4</span><span class="p">]</span> <span class="o">?</span> <span class="nx">match</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span>
    <span class="nv">val = </span><span class="nx">@value</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
    <span class="k">return</span> <span class="s2">&quot;#{name}: #{val}&quot;</span> <span class="k">if</span> <span class="nx">@context</span> <span class="o">is</span> <span class="s1">&#39;object&#39;</span>
    <span class="nv">val = </span><span class="nx">name</span> <span class="o">+</span> <span class="s2">&quot; #{ @context or &#39;=&#39; } &quot;</span> <span class="o">+</span> <span class="nx">val</span>
-    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&lt;=</span> <span class="nx">LEVEL_LIST</span> <span class="k">then</span> <span class="nx">val</span> <span class="k">else</span> <span class="s2">&quot;(#{val})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-87">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-87">&#182;</a>               </div>               <p>Brief implementation of recursive pattern matching, when assigning array or
+    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&lt;=</span> <span class="nx">LEVEL_LIST</span> <span class="k">then</span> <span class="nx">val</span> <span class="k">else</span> <span class="s2">&quot;(#{val})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-90">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-90">&#182;</a>               </div>               <p>Brief implementation of recursive pattern matching, when assigning array or
 object literals to a value. Peeks at their properties to assign inner names.
 See the <a href="http://wiki.ecmascript.org/doku.php?id=harmony:destructuring">ECMAScript Harmony Wiki</a>
 for details.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compilePatternMatch</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
@@ -693,7 +709,7 @@ for details.</p>             </td>             <td class="code">               <
      <span class="nv">code = </span><span class="nx">value</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span>
      <span class="k">return</span> <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&gt;=</span> <span class="nx">LEVEL_OP</span> <span class="k">then</span> <span class="s2">&quot;(#{code})&quot;</span> <span class="k">else</span> <span class="nx">code</span>
    <span class="nv">isObject = </span><span class="nx">@variable</span><span class="p">.</span><span class="nx">isObject</span><span class="p">()</span>
-    <span class="k">if</span> <span class="nx">top</span> <span class="o">and</span> <span class="nx">olen</span> <span class="o">is</span> <span class="mi">1</span> <span class="o">and</span> <span class="p">(</span><span class="nv">obj = </span><span class="nx">objects</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="o">not</span> <span class="k">instanceof</span> <span class="nx">Splat</span></pre></div>             </td>           </tr>                               <tr id="section-88">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-88">&#182;</a>               </div>               <p>Unroll simplest cases: <code>{v} = x</code> -> <code>v = x.v</code></p>             </td>             <td class="code">               <div class="highlight"><pre>      <span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Assign</span>
+    <span class="k">if</span> <span class="nx">top</span> <span class="o">and</span> <span class="nx">olen</span> <span class="o">is</span> <span class="mi">1</span> <span class="o">and</span> <span class="p">(</span><span class="nv">obj = </span><span class="nx">objects</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="o">not</span> <span class="k">instanceof</span> <span class="nx">Splat</span></pre></div>             </td>           </tr>                               <tr id="section-91">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-91">&#182;</a>               </div>               <p>Unroll simplest cases: <code>{v} = x</code> -> <code>v = x.v</code></p>             </td>             <td class="code">               <div class="highlight"><pre>      <span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Assign</span>
        <span class="p">{</span><span class="nx">variable</span><span class="o">:</span> <span class="p">{</span><span class="nx">base</span><span class="o">:</span> <span class="nx">idx</span><span class="p">},</span> <span class="nx">value</span><span class="o">:</span> <span class="nx">obj</span><span class="p">}</span> <span class="o">=</span> <span class="nx">obj</span>
      <span class="k">else</span>
        <span class="k">if</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">base</span> <span class="k">instanceof</span> <span class="nx">Parens</span>
@@ -706,17 +722,17 @@ for details.</p>             </td>             <td class="code">               <
      <span class="nv">acc   = </span><span class="nx">IDENTIFIER</span><span class="p">.</span><span class="nx">test</span> <span class="nx">idx</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">().</span><span class="nx">value</span> <span class="o">or</span> <span class="mi">0</span>
      <span class="nv">value = </span><span class="k">new</span> <span class="nx">Value</span> <span class="nx">value</span>
      <span class="nx">value</span><span class="p">.</span><span class="nx">properties</span><span class="p">.</span><span class="nx">push</span> <span class="k">new</span> <span class="p">(</span><span class="k">if</span> <span class="nx">acc</span> <span class="k">then</span> <span class="nx">Access</span> <span class="k">else</span> <span class="nx">Index</span><span class="p">)</span> <span class="nx">idx</span>
-      <span class="k">return</span> <span class="k">new</span> <span class="nx">Assign</span><span class="p">(</span><span class="nx">obj</span><span class="p">,</span> <span class="nx">value</span><span class="p">).</span><span class="nx">compile</span> <span class="nx">o</span>
+      <span class="k">return</span> <span class="k">new</span> <span class="nx">Assign</span><span class="p">(</span><span class="nx">obj</span><span class="p">,</span> <span class="nx">value</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">param</span><span class="o">:</span> <span class="nx">@param</span><span class="p">).</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_TOP</span>
    <span class="nv">vvar    = </span><span class="nx">value</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
    <span class="nv">assigns = </span><span class="p">[]</span>
    <span class="nv">splat   = </span><span class="kc">false</span>
    <span class="k">if</span> <span class="o">not</span> <span class="nx">IDENTIFIER</span><span class="p">.</span><span class="nx">test</span><span class="p">(</span><span class="nx">vvar</span><span class="p">)</span> <span class="o">or</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">assigns</span><span class="p">(</span><span class="nx">vvar</span><span class="p">)</span>
      <span class="nx">assigns</span><span class="p">.</span><span class="nx">push</span> <span class="s2">&quot;#{ ref = o.scope.freeVariable &#39;ref&#39; } = #{vvar}&quot;</span>
      <span class="nv">vvar = </span><span class="nx">ref</span>
-    <span class="k">for</span> <span class="nx">obj</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">objects</span></pre></div>             </td>           </tr>                               <tr id="section-89">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-89">&#182;</a>               </div>               <p>A regular array pattern-match.</p>             </td>             <td class="code">               <div class="highlight"><pre>      <span class="nv">idx = </span><span class="nx">i</span>
+    <span class="k">for</span> <span class="nx">obj</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">objects</span></pre></div>             </td>           </tr>                               <tr id="section-92">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-92">&#182;</a>               </div>               <p>A regular array pattern-match.</p>             </td>             <td class="code">               <div class="highlight"><pre>      <span class="nv">idx = </span><span class="nx">i</span>
      <span class="k">if</span> <span class="nx">isObject</span>
-        <span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Assign</span></pre></div>             </td>           </tr>                               <tr id="section-90">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-90">&#182;</a>               </div>               <p>A regular object pattern-match.</p>             </td>             <td class="code">               <div class="highlight"><pre>          <span class="p">{</span><span class="nx">variable</span><span class="o">:</span> <span class="p">{</span><span class="nx">base</span><span class="o">:</span> <span class="nx">idx</span><span class="p">},</span> <span class="nx">value</span><span class="o">:</span> <span class="nx">obj</span><span class="p">}</span> <span class="o">=</span> <span class="nx">obj</span>
-        <span class="k">else</span></pre></div>             </td>           </tr>                               <tr id="section-91">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-91">&#182;</a>               </div>               <p>A shorthand <code>{a, b, @c} = val</code> pattern-match.</p>             </td>             <td class="code">               <div class="highlight"><pre>          <span class="k">if</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">base</span> <span class="k">instanceof</span> <span class="nx">Parens</span>
+        <span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Assign</span></pre></div>             </td>           </tr>                               <tr id="section-93">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-93">&#182;</a>               </div>               <p>A regular object pattern-match.</p>             </td>             <td class="code">               <div class="highlight"><pre>          <span class="p">{</span><span class="nx">variable</span><span class="o">:</span> <span class="p">{</span><span class="nx">base</span><span class="o">:</span> <span class="nx">idx</span><span class="p">},</span> <span class="nx">value</span><span class="o">:</span> <span class="nx">obj</span><span class="p">}</span> <span class="o">=</span> <span class="nx">obj</span>
+        <span class="k">else</span></pre></div>             </td>           </tr>                               <tr id="section-94">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-94">&#182;</a>               </div>               <p>A shorthand <code>{a, b, @c} = val</code> pattern-match.</p>             </td>             <td class="code">               <div class="highlight"><pre>          <span class="k">if</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">base</span> <span class="k">instanceof</span> <span class="nx">Parens</span>
            <span class="p">[</span><span class="nx">obj</span><span class="p">,</span> <span class="nx">idx</span><span class="p">]</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Value</span><span class="p">(</span><span class="nx">obj</span><span class="p">.</span><span class="nx">unwrapAll</span><span class="p">()).</span><span class="nx">cacheReference</span> <span class="nx">o</span>
          <span class="k">else</span>
            <span class="nv">idx = </span><span class="k">if</span> <span class="nx">obj</span><span class="p">.</span><span class="k">this</span> <span class="k">then</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">properties</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="nx">name</span> <span class="k">else</span> <span class="nx">obj</span>
@@ -743,11 +759,12 @@ for details.</p>             </td>             <td class="code">               <
      <span class="nx">assigns</span><span class="p">.</span><span class="nx">push</span> <span class="k">new</span> <span class="nx">Assign</span><span class="p">(</span><span class="nx">obj</span><span class="p">,</span> <span class="nx">val</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">param</span><span class="o">:</span> <span class="nx">@param</span><span class="p">).</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_TOP</span>
    <span class="nx">assigns</span><span class="p">.</span><span class="nx">push</span> <span class="nx">vvar</span> <span class="nx">unless</span> <span class="nx">top</span>
    <span class="nv">code = </span><span class="nx">assigns</span><span class="p">.</span><span class="nx">join</span> <span class="s1">&#39;, &#39;</span>
-    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&lt;</span> <span class="nx">LEVEL_LIST</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">&quot;(#{code})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-92">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-92">&#182;</a>               </div>               <p>When compiling a conditional assignment, take care to ensure that the
+    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&lt;</span> <span class="nx">LEVEL_LIST</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">&quot;(#{code})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-95">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-95">&#182;</a>               </div>               <p>When compiling a conditional assignment, take care to ensure that the
 operands are only evaluated once, even though we have to reference them
 more than once.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileConditional</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="p">[</span><span class="nx">left</span><span class="p">,</span> <span class="nx">rite</span><span class="p">]</span> <span class="o">=</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">cacheReference</span> <span class="nx">o</span>
-    <span class="k">new</span> <span class="nx">Op</span><span class="p">(</span><span class="nx">@context</span><span class="p">.</span><span class="nx">slice</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">),</span> <span class="nx">left</span><span class="p">,</span> <span class="k">new</span> <span class="nx">Assign</span><span class="p">(</span><span class="nx">rite</span><span class="p">,</span> <span class="nx">@value</span><span class="p">,</span> <span class="s1">&#39;=&#39;</span><span class="p">)).</span><span class="nx">compile</span> <span class="nx">o</span></pre></div>             </td>           </tr>                               <tr id="section-93">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-93">&#182;</a>               </div>               <p>Compile the assignment from an array splice literal, using JavaScript's
+    <span class="k">if</span> <span class="s2">&quot;?&quot;</span> <span class="k">in</span> <span class="nx">@context</span> <span class="k">then</span> <span class="nv">o.isExistentialEquals = </span><span class="kc">true</span>
+    <span class="k">new</span> <span class="nx">Op</span><span class="p">(</span><span class="nx">@context</span><span class="p">[</span><span class="mi">0</span><span class="p">...</span><span class="o">-</span><span class="mi">1</span><span class="p">],</span> <span class="nx">left</span><span class="p">,</span> <span class="k">new</span> <span class="nx">Assign</span><span class="p">(</span><span class="nx">rite</span><span class="p">,</span> <span class="nx">@value</span><span class="p">,</span> <span class="s1">&#39;=&#39;</span><span class="p">)</span> <span class="p">).</span><span class="nx">compile</span> <span class="nx">o</span></pre></div>             </td>           </tr>                               <tr id="section-96">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-96">&#182;</a>               </div>               <p>Compile the assignment from an array splice literal, using JavaScript's
 <code>Array#splice</code> method.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileSplice</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="p">{</span><span class="nx">range</span><span class="o">:</span> <span class="p">{</span><span class="nx">from</span><span class="p">,</span> <span class="nx">to</span><span class="p">,</span> <span class="nx">exclusive</span><span class="p">}}</span> <span class="o">=</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">properties</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
    <span class="nv">name = </span><span class="nx">@variable</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span>
@@ -763,7 +780,7 @@ more than once.</p>             </td>             <td class="code">
      <span class="nv">to = </span><span class="s2">&quot;9e9&quot;</span>
    <span class="p">[</span><span class="nx">valDef</span><span class="p">,</span> <span class="nx">valRef</span><span class="p">]</span> <span class="o">=</span> <span class="nx">@value</span><span class="p">.</span><span class="nx">cache</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
    <span class="nv">code = </span><span class="s2">&quot;[].splice.apply(#{name}, [#{fromDecl}, #{to}].concat(#{valDef})), #{valRef}&quot;</span>
-    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&gt;</span> <span class="nx">LEVEL_TOP</span> <span class="k">then</span> <span class="s2">&quot;(#{code})&quot;</span> <span class="k">else</span> <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-94">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-94">&#182;</a>               </div>               <h3>Code</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-95">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-95">&#182;</a>               </div>               <p>A function definition. This is the only node that creates a new Scope.
+    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&gt;</span> <span class="nx">LEVEL_TOP</span> <span class="k">then</span> <span class="s2">&quot;(#{code})&quot;</span> <span class="k">else</span> <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-97">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-97">&#182;</a>               </div>               <h3>Code</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-98">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-98">&#182;</a>               </div>               <p>A function definition. This is the only node that creates a new Scope.
 When for the purposes of walking the contents of a function body, the Code
 has no <em>children</em> -- they're within the inner scope.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Code = </span><span class="nx">class</span> <span class="nx">Code</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">params</span><span class="p">,</span> <span class="nx">body</span><span class="p">,</span> <span class="nx">tag</span><span class="p">)</span> <span class="o">-&gt;</span>
@@ -776,9 +793,9 @@ has no <em>children</em> -- they're within the inner scope.</p>             </td

  <span class="nx">isStatement</span><span class="o">:</span> <span class="o">-&gt;</span> <span class="o">!!</span><span class="nx">@ctor</span>

-  <span class="nx">jumps</span><span class="o">:</span> <span class="nx">NO</span></pre></div>             </td>           </tr>                               <tr id="section-96">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-96">&#182;</a>               </div>               <p>Compilation creates a new scope unless explicitly asked to share with the
+  <span class="nx">jumps</span><span class="o">:</span> <span class="nx">NO</span></pre></div>             </td>           </tr>                               <tr id="section-99">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-99">&#182;</a>               </div>               <p>Compilation creates a new scope unless explicitly asked to share with the
 outer scope. Handles splat parameters in the parameter list by peeking at
-the JavaScript <code>arguments</code> objects. If the function is bound with the <code>=&gt;</code>
+the JavaScript <code>arguments</code> object. If the function is bound with the <code>=&gt;</code>
 arrow, generates a wrapper that saves the current value of <code>this</code> through
 a closure.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nv">o.scope         = </span><span class="k">new</span> <span class="nx">Scope</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">,</span> <span class="nx">@body</span><span class="p">,</span> <span class="k">this</span>
@@ -788,7 +805,7 @@ a closure.</p>             </td>             <td class="code">               <di
    <span class="nv">vars   = </span><span class="p">[]</span>
    <span class="nv">exprs  = </span><span class="p">[]</span>
    <span class="k">for</span> <span class="nx">param</span> <span class="k">in</span> <span class="nx">@params</span> <span class="k">when</span> <span class="nx">param</span><span class="p">.</span><span class="nx">splat</span>
-      <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">add</span> <span class="nx">param</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="s1">&#39;var&#39;</span> <span class="k">if</span> <span class="nx">param</span><span class="p">.</span><span class="nx">name</span><span class="p">.</span><span class="nx">value</span>
+      <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">add</span> <span class="nx">p</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="s1">&#39;var&#39;</span><span class="p">,</span> <span class="kc">yes</span> <span class="k">for</span> <span class="nx">p</span> <span class="k">in</span> <span class="nx">@params</span> <span class="k">when</span> <span class="nx">p</span><span class="p">.</span><span class="nx">name</span><span class="p">.</span><span class="nx">value</span>
      <span class="nv">splats = </span><span class="k">new</span> <span class="nx">Assign</span> <span class="k">new</span> <span class="nx">Value</span><span class="p">(</span><span class="k">new</span> <span class="nx">Arr</span><span class="p">(</span><span class="nx">p</span><span class="p">.</span><span class="nx">asReference</span> <span class="nx">o</span> <span class="k">for</span> <span class="nx">p</span> <span class="k">in</span> <span class="nx">@params</span><span class="p">)),</span>
                          <span class="k">new</span> <span class="nx">Value</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;arguments&#39;</span>
      <span class="k">break</span>
@@ -817,9 +834,9 @@ a closure.</p>             </td>             <td class="code">               <di
    <span class="nx">code</span>  <span class="o">+=</span> <span class="s1">&#39;}&#39;</span>
    <span class="k">return</span> <span class="nx">@tab</span> <span class="o">+</span> <span class="nx">code</span> <span class="k">if</span> <span class="nx">@ctor</span>
    <span class="k">return</span> <span class="nx">utility</span><span class="p">(</span><span class="s1">&#39;bind&#39;</span><span class="p">)</span> <span class="o">+</span> <span class="s2">&quot;(#{code}, #{@context})&quot;</span> <span class="k">if</span> <span class="nx">@bound</span>
-    <span class="k">if</span> <span class="nx">@front</span> <span class="o">or</span> <span class="p">(</span><span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&gt;=</span> <span class="nx">LEVEL_ACCESS</span><span class="p">)</span> <span class="k">then</span> <span class="s2">&quot;(#{code})&quot;</span> <span class="k">else</span> <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-97">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-97">&#182;</a>               </div>               <p>Short-circuit <code>traverseChildren</code> method to prevent it from crossing scope boundaries
+    <span class="k">if</span> <span class="nx">@front</span> <span class="o">or</span> <span class="p">(</span><span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&gt;=</span> <span class="nx">LEVEL_ACCESS</span><span class="p">)</span> <span class="k">then</span> <span class="s2">&quot;(#{code})&quot;</span> <span class="k">else</span> <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-100">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-100">&#182;</a>               </div>               <p>Short-circuit <code>traverseChildren</code> method to prevent it from crossing scope boundaries
 unless <code>crossScope</code> is <code>true</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">traverseChildren</span><span class="o">:</span> <span class="p">(</span><span class="nx">crossScope</span><span class="p">,</span> <span class="nx">func</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">super</span><span class="p">(</span><span class="nx">crossScope</span><span class="p">,</span> <span class="nx">func</span><span class="p">)</span> <span class="k">if</span> <span class="nx">crossScope</span></pre></div>             </td>           </tr>                               <tr id="section-98">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-98">&#182;</a>               </div>               <h3>Param</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-99">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-99">&#182;</a>               </div>               <p>A parameter in a function definition. Beyond a typical Javascript parameter,
+    <span class="k">super</span><span class="p">(</span><span class="nx">crossScope</span><span class="p">,</span> <span class="nx">func</span><span class="p">)</span> <span class="k">if</span> <span class="nx">crossScope</span></pre></div>             </td>           </tr>                               <tr id="section-101">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-101">&#182;</a>               </div>               <h3>Param</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-102">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-102">&#182;</a>               </div>               <p>A parameter in a function definition. Beyond a typical Javascript parameter,
 these parameters can also attach themselves to the context of the function,
 as well as be a splat, gathering up a group of parameters into an array.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Param = </span><span class="nx">class</span> <span class="nx">Param</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</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">@splat</span><span class="p">)</span> <span class="o">-&gt;</span>
@@ -842,7 +859,7 @@ as well as be a splat, gathering up a group of parameters into an array.</p>
    <span class="vi">@reference = </span><span class="nx">node</span>

  <span class="nx">isComplex</span><span class="o">:</span> <span class="o">-&gt;</span>
-    <span class="nx">@name</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-100">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-100">&#182;</a>               </div>               <h3>Splat</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-101">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-101">&#182;</a>               </div>               <p>A splat, either as a parameter to a function, an argument to a call,
+    <span class="nx">@name</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-103">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-103">&#182;</a>               </div>               <h3>Splat</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-104">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-104">&#182;</a>               </div>               <p>A splat, either as a parameter to a function, an argument to a call,
 or as part of a destructuring assignment.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Splat = </span><span class="nx">class</span> <span class="nx">Splat</span> <span class="k">extends</span> <span class="nx">Base</span>

  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;name&#39;</span><span class="p">]</span>
@@ -856,7 +873,7 @@ or as part of a destructuring assignment.</p>             </td>             <td
    <span class="nx">@name</span><span class="p">.</span><span class="nx">assigns</span> <span class="nx">name</span>

  <span class="nx">compile</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">if</span> <span class="nx">@index</span><span class="o">?</span> <span class="k">then</span> <span class="nx">@compileParam</span> <span class="nx">o</span> <span class="k">else</span> <span class="nx">@name</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span></pre></div>             </td>           </tr>                               <tr id="section-102">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-102">&#182;</a>               </div>               <p>Utility function that converts arbitrary number of elements, mixed with
+    <span class="k">if</span> <span class="nx">@index</span><span class="o">?</span> <span class="k">then</span> <span class="nx">@compileParam</span> <span class="nx">o</span> <span class="k">else</span> <span class="nx">@name</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span></pre></div>             </td>           </tr>                               <tr id="section-105">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-105">&#182;</a>               </div>               <p>Utility function that converts an arbitrary number of elements, mixed with
 splats, to a proper array.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">@compileSplattedArray</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">list</span><span class="p">,</span> <span class="nx">apply</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nv">index = </span><span class="o">-</span><span class="mi">1</span>
    <span class="k">continue</span> <span class="k">while</span> <span class="p">(</span><span class="nv">node = </span><span class="nx">list</span><span class="p">[</span><span class="o">++</span><span class="nx">index</span><span class="p">])</span> <span class="o">and</span> <span class="nx">node</span> <span class="o">not</span> <span class="k">instanceof</span> <span class="nx">Splat</span>
@@ -865,15 +882,15 @@ splats, to a proper array.</p>             </td>             <td class="code">
      <span class="nv">code = </span><span class="nx">list</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
      <span class="k">return</span> <span class="nx">code</span> <span class="k">if</span> <span class="nx">apply</span>
      <span class="k">return</span> <span class="s2">&quot;#{ utility &#39;slice&#39; }.call(#{code})&quot;</span>
-    <span class="nv">args = </span><span class="nx">list</span><span class="p">.</span><span class="nx">slice</span> <span class="nx">index</span>
+    <span class="nv">args = </span><span class="nx">list</span><span class="p">[</span><span class="nx">index</span><span class="p">..]</span>
    <span class="k">for</span> <span class="nx">node</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">args</span>
      <span class="nv">code = </span><span class="nx">node</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
      <span class="nx">args</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">=</span> <span class="k">if</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Splat</span>
      <span class="k">then</span> <span class="s2">&quot;#{ utility &#39;slice&#39; }.call(#{code})&quot;</span>
      <span class="k">else</span> <span class="s2">&quot;[#{code}]&quot;</span>
-    <span class="k">return</span> <span class="nx">args</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">+</span> <span class="s2">&quot;.concat(#{ args.slice(1).join &#39;, &#39; })&quot;</span> <span class="k">if</span> <span class="nx">index</span> <span class="o">is</span> <span class="mi">0</span>
-    <span class="nv">base = </span><span class="p">(</span><span class="nx">node</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span> <span class="k">for</span> <span class="nx">node</span> <span class="k">in</span> <span class="nx">list</span><span class="p">.</span><span class="nx">slice</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">index</span><span class="p">)</span>
-    <span class="s2">&quot;[#{ base.join &#39;, &#39; }].concat(#{ args.join &#39;, &#39; })&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-103">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-103">&#182;</a>               </div>               <h3>While</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-104">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-104">&#182;</a>               </div>               <p>A while loop, the only sort of low-level loop exposed by CoffeeScript. From
+    <span class="k">return</span> <span class="nx">args</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">+</span> <span class="s2">&quot;.concat(#{ args[1..].join &#39;, &#39; })&quot;</span> <span class="k">if</span> <span class="nx">index</span> <span class="o">is</span> <span class="mi">0</span>
+    <span class="nv">base = </span><span class="p">(</span><span class="nx">node</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span> <span class="k">for</span> <span class="nx">node</span> <span class="k">in</span> <span class="nx">list</span><span class="p">[</span><span class="mi">0</span><span class="p">...</span><span class="nx">index</span><span class="p">])</span>
+    <span class="s2">&quot;[#{ base.join &#39;, &#39; }].concat(#{ args.join &#39;, &#39; })&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-106">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-106">&#182;</a>               </div>               <h3>While</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-107">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-107">&#182;</a>               </div>               <p>A while loop, the only sort of low-level loop exposed by CoffeeScript. From
 it, all other loops can be manufactured. Useful in cases where you need more
 flexibility or more speed than a comprehension can provide.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.While = </span><span class="nx">class</span> <span class="nx">While</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">condition</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span>
@@ -896,7 +913,7 @@ flexibility or more speed than a comprehension can provide.</p>             </td
    <span class="k">return</span> <span class="kc">no</span> <span class="nx">unless</span> <span class="nx">expressions</span><span class="p">.</span><span class="nx">length</span>
    <span class="k">for</span> <span class="nx">node</span> <span class="k">in</span> <span class="nx">expressions</span>
      <span class="k">return</span> <span class="nx">node</span> <span class="k">if</span> <span class="nx">node</span><span class="p">.</span><span class="nx">jumps</span> <span class="nx">loop</span><span class="o">:</span> <span class="kc">yes</span>
-    <span class="kc">no</span></pre></div>             </td>           </tr>                               <tr id="section-105">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-105">&#182;</a>               </div>               <p>The main difference from a JavaScript <em>while</em> is that the CoffeeScript
+    <span class="kc">no</span></pre></div>             </td>           </tr>                               <tr id="section-108">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-108">&#182;</a>               </div>               <p>The main difference from a JavaScript <em>while</em> is that the CoffeeScript
 <em>while</em> can be used as a part of a larger expression -- while loops may
 return an array containing the computed result of each iteration.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nx">o</span><span class="p">.</span><span class="nx">indent</span> <span class="o">+=</span> <span class="nx">TAB</span>
@@ -914,25 +931,25 @@ return an array containing the computed result of each iteration.</p>
    <span class="nv">code = </span><span class="nx">set</span> <span class="o">+</span> <span class="nx">@tab</span> <span class="o">+</span> <span class="s2">&quot;while (#{ @condition.compile o, LEVEL_PAREN }) {#{body}}&quot;</span>
    <span class="k">if</span> <span class="nx">@returns</span>
      <span class="nx">code</span> <span class="o">+=</span> <span class="s2">&quot;\n#{@tab}return #{rvar};&quot;</span>
-    <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-106">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-106">&#182;</a>               </div>               <h3>Op</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-107">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-107">&#182;</a>               </div>               <p>Simple Arithmetic and logical operations. Performs some conversion from
+    <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-109">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-109">&#182;</a>               </div>               <h3>Op</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-110">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-110">&#182;</a>               </div>               <p>Simple Arithmetic and logical operations. Performs some conversion from
 CoffeeScript operations into their JavaScript equivalents.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Op = </span><span class="nx">class</span> <span class="nx">Op</span> <span class="k">extends</span> <span class="nx">Base</span>
-  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">op</span><span class="p">,</span> <span class="nx">first</span><span class="p">,</span> <span class="nx">second</span><span class="p">,</span> <span class="nx">flip</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">op</span><span class="p">,</span> <span class="nx">first</span><span class="p">,</span> <span class="nx">second</span><span class="p">,</span> <span class="nx">flip</span> <span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">return</span> <span class="k">new</span> <span class="nx">In</span> <span class="nx">first</span><span class="p">,</span> <span class="nx">second</span> <span class="k">if</span> <span class="nx">op</span> <span class="o">is</span> <span class="s1">&#39;in&#39;</span>
    <span class="k">if</span> <span class="nx">op</span> <span class="o">is</span> <span class="s1">&#39;do&#39;</span>
      <span class="nv">call = </span><span class="k">new</span> <span class="nx">Call</span> <span class="nx">first</span><span class="p">,</span> <span class="nx">first</span><span class="p">.</span><span class="nx">params</span> <span class="o">or</span> <span class="p">[]</span>
      <span class="nv">call.do = </span><span class="kc">yes</span>
      <span class="k">return</span> <span class="nx">call</span>
    <span class="k">if</span> <span class="nx">op</span> <span class="o">is</span> <span class="s1">&#39;new&#39;</span>
-      <span class="k">return</span> <span class="nx">first</span><span class="p">.</span><span class="nx">newInstance</span><span class="p">()</span> <span class="k">if</span> <span class="nx">first</span> <span class="k">instanceof</span> <span class="nx">Call</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">first</span><span class="p">.</span><span class="nx">do</span>
+      <span class="k">return</span> <span class="nx">first</span><span class="p">.</span><span class="nx">newInstance</span><span class="p">()</span> <span class="k">if</span> <span class="nx">first</span> <span class="k">instanceof</span> <span class="nx">Call</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">first</span><span class="p">.</span><span class="nx">do</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">first</span><span class="p">.</span><span class="nx">isNew</span>
      <span class="nv">first = </span><span class="k">new</span> <span class="nx">Parens</span> <span class="nx">first</span>   <span class="k">if</span> <span class="nx">first</span> <span class="k">instanceof</span> <span class="nx">Code</span> <span class="o">and</span> <span class="nx">first</span><span class="p">.</span><span class="nx">bound</span> <span class="o">or</span> <span class="nx">first</span><span class="p">.</span><span class="nx">do</span>
    <span class="vi">@operator = </span><span class="nx">CONVERSIONS</span><span class="p">[</span><span class="nx">op</span><span class="p">]</span> <span class="o">or</span> <span class="nx">op</span>
    <span class="vi">@first    = </span><span class="nx">first</span>
    <span class="vi">@second   = </span><span class="nx">second</span>
    <span class="vi">@flip     = </span><span class="o">!!</span><span class="nx">flip</span>
-    <span class="k">return</span> <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-108">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-108">&#182;</a>               </div>               <p>The map of conversions from CoffeeScript to JavaScript symbols.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">CONVERSIONS =</span>
+    <span class="k">return</span> <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-111">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-111">&#182;</a>               </div>               <p>The map of conversions from CoffeeScript to JavaScript symbols.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">CONVERSIONS =</span>
    <span class="s1">&#39;==&#39;</span><span class="o">:</span> <span class="s1">&#39;===&#39;</span>
    <span class="s1">&#39;!=&#39;</span><span class="o">:</span> <span class="s1">&#39;!==&#39;</span>
-    <span class="s1">&#39;of&#39;</span><span class="o">:</span> <span class="s1">&#39;in&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-109">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-109">&#182;</a>               </div>               <p>The map of invertible operators.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">INVERSIONS =</span>
+    <span class="s1">&#39;of&#39;</span><span class="o">:</span> <span class="s1">&#39;in&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-112">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-112">&#182;</a>               </div>               <p>The map of invertible operators.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">INVERSIONS =</span>
    <span class="s1">&#39;!==&#39;</span><span class="o">:</span> <span class="s1">&#39;===&#39;</span>
    <span class="s1">&#39;===&#39;</span><span class="o">:</span> <span class="s1">&#39;!==&#39;</span>

@@ -941,7 +958,10 @@ CoffeeScript operations into their JavaScript equivalents.</p>             </td>
  <span class="nx">isSimpleNumber</span><span class="o">:</span> <span class="nx">NO</span>

  <span class="nx">isUnary</span><span class="o">:</span> <span class="o">-&gt;</span>
-    <span class="o">not</span> <span class="nx">@second</span></pre></div>             </td>           </tr>                               <tr id="section-110">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-110">&#182;</a>               </div>               <p>Am I capable of
+    <span class="o">not</span> <span class="nx">@second</span>
+
+  <span class="nx">isComplex</span><span class="o">:</span> <span class="o">-&gt;</span>
+    <span class="o">not</span> <span class="p">(</span><span class="nx">@isUnary</span><span class="p">()</span> <span class="o">and</span> <span class="p">(</span><span class="nx">@operator</span> <span class="k">in</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">@first</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-113">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-113">&#182;</a>               </div>               <p>Am I capable of
 <a href="http://docs.python.org/reference/expressions.html#notin">Python-style comparison chaining</a>?</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">isChainable</span><span class="o">:</span> <span class="o">-&gt;</span>
    <span class="nx">@operator</span> <span class="k">in</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="s1">&#39;&lt;=&#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>

@@ -982,7 +1002,7 @@ CoffeeScript operations into their JavaScript equivalents.</p>             </td>
    <span class="vi">@first.front = </span><span class="nx">@front</span>
    <span class="nv">code = </span><span class="nx">@first</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_OP</span><span class="p">)</span> <span class="o">+</span> <span class="s1">&#39; &#39;</span> <span class="o">+</span> <span class="nx">@operator</span> <span class="o">+</span> <span class="s1">&#39; &#39;</span> <span class="o">+</span>
           <span class="nx">@second</span><span class="p">.</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_OP</span><span class="p">)</span>
-    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&lt;=</span> <span class="nx">LEVEL_OP</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">&quot;(#{code})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-111">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-111">&#182;</a>               </div>               <p>Mimic Python's chained comparisons when multiple comparison operators are
+    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&lt;=</span> <span class="nx">LEVEL_OP</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">&quot;(#{code})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-114">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-114">&#182;</a>               </div>               <p>Mimic Python's chained comparisons when multiple comparison operators are
 used sequentially. For example:</p>

 <pre><code>bin/coffee -e 'console.log 50 &lt; 65 &gt; 10'
@@ -1000,7 +1020,7 @@ true
    <span class="k">else</span>
      <span class="nv">fst = </span><span class="nx">@first</span>
      <span class="nv">ref = </span><span class="nx">fst</span>
-    <span class="k">new</span> <span class="nx">If</span><span class="p">(</span><span class="k">new</span> <span class="nx">Existence</span><span class="p">(</span><span class="nx">fst</span><span class="p">),</span> <span class="nx">ref</span><span class="p">,</span> <span class="nx">type</span><span class="o">:</span> <span class="s1">&#39;if&#39;</span><span class="p">).</span><span class="nx">addElse</span><span class="p">(</span><span class="nx">@second</span><span class="p">).</span><span class="nx">compile</span> <span class="nx">o</span></pre></div>             </td>           </tr>                               <tr id="section-112">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-112">&#182;</a>               </div>               <p>Compile a unary <strong>Op</strong>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileUnary</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="k">new</span> <span class="nx">If</span><span class="p">(</span><span class="k">new</span> <span class="nx">Existence</span><span class="p">(</span><span class="nx">fst</span><span class="p">),</span> <span class="nx">ref</span><span class="p">,</span> <span class="nx">type</span><span class="o">:</span> <span class="s1">&#39;if&#39;</span><span class="p">).</span><span class="nx">addElse</span><span class="p">(</span><span class="nx">@second</span><span class="p">).</span><span class="nx">compile</span> <span class="nx">o</span></pre></div>             </td>           </tr>                               <tr id="section-115">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-115">&#182;</a>               </div>               <p>Compile a unary <strong>Op</strong>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileUnary</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nv">parts = </span><span class="p">[</span><span class="nv">op = </span><span class="nx">@operator</span><span class="p">]</span>
    <span class="nx">parts</span><span class="p">.</span><span class="nx">push</span> <span class="s1">&#39; &#39;</span> <span class="k">if</span> <span class="nx">op</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;new&#39;</span><span class="p">,</span> <span class="s1">&#39;typeof&#39;</span><span class="p">,</span> <span class="s1">&#39;delete&#39;</span><span class="p">]</span> <span class="o">or</span>
                      <span class="nx">op</span> <span class="k">in</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">and</span> <span class="nx">@first</span> <span class="k">instanceof</span> <span class="nx">Op</span> <span class="o">and</span> <span class="nx">@first</span><span class="p">.</span><span class="nx">operator</span> <span class="o">is</span> <span class="nx">op</span>
@@ -1010,7 +1030,7 @@ true
    <span class="nx">parts</span><span class="p">.</span><span class="nx">join</span> <span class="s1">&#39;&#39;</span>

  <span class="nx">toString</span><span class="o">:</span> <span class="p">(</span><span class="nx">idt</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">super</span> <span class="nx">idt</span><span class="p">,</span> <span class="nx">@constructor</span><span class="p">.</span><span class="nx">name</span> <span class="o">+</span> <span class="s1">&#39; &#39;</span> <span class="o">+</span> <span class="nx">@operator</span></pre></div>             </td>           </tr>                               <tr id="section-113">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-113">&#182;</a>               </div>               <h3>In</h3>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.In = </span><span class="nx">class</span> <span class="nx">In</span> <span class="k">extends</span> <span class="nx">Base</span>
+    <span class="k">super</span> <span class="nx">idt</span><span class="p">,</span> <span class="nx">@constructor</span><span class="p">.</span><span class="nx">name</span> <span class="o">+</span> <span class="s1">&#39; &#39;</span> <span class="o">+</span> <span class="nx">@operator</span></pre></div>             </td>           </tr>                               <tr id="section-116">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-116">&#182;</a>               </div>               <h3>In</h3>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.In = </span><span class="nx">class</span> <span class="nx">In</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@object</span><span class="p">,</span> <span class="nx">@array</span><span class="p">)</span> <span class="o">-&gt;</span>

  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;object&#39;</span><span class="p">,</span> <span class="s1">&#39;array&#39;</span><span class="p">]</span>
@@ -1019,9 +1039,10 @@ true

  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">if</span> <span class="nx">@array</span> <span class="k">instanceof</span> <span class="nx">Value</span> <span class="o">and</span> <span class="nx">@array</span><span class="p">.</span><span class="nx">isArray</span><span class="p">()</span>
-      <span class="nx">@compileOrTest</span> <span class="nx">o</span>
-    <span class="k">else</span>
-      <span class="nx">@compileLoopTest</span> <span class="nx">o</span>
+      <span class="k">for</span> <span class="nx">obj</span> <span class="k">in</span> <span class="nx">@array</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">objects</span> <span class="k">when</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Splat</span>
+        <span class="nv">hasSplat = </span><span class="kc">yes</span>
+        <span class="k">break</span></pre></div>             </td>           </tr>                               <tr id="section-117">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-117">&#182;</a>               </div>               <p><code>compileOrTest</code> only if we have an array literal with no splats</p>             </td>             <td class="code">               <div class="highlight"><pre>      <span class="k">return</span> <span class="nx">@compileOrTest</span> <span class="nx">o</span> <span class="nx">unless</span> <span class="nx">hasSplat</span>
+    <span class="nx">@compileLoopTest</span> <span class="nx">o</span>

  <span class="nx">compileOrTest</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="p">[</span><span class="nx">sub</span><span class="p">,</span> <span class="nx">ref</span><span class="p">]</span> <span class="o">=</span> <span class="nx">@object</span><span class="p">.</span><span class="nx">cache</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_OP</span>
@@ -1041,7 +1062,7 @@ true
    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&lt;</span> <span class="nx">LEVEL_LIST</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">&quot;(#{code})&quot;</span>

  <span class="nx">toString</span><span class="o">:</span> <span class="p">(</span><span class="nx">idt</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">super</span> <span class="nx">idt</span><span class="p">,</span> <span class="nx">@constructor</span><span class="p">.</span><span class="nx">name</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">@negated</span> <span class="k">then</span> <span class="s1">&#39;!&#39;</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-114">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-114">&#182;</a>               </div>               <h3>Try</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-115">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-115">&#182;</a>               </div>               <p>A classic <em>try/catch/finally</em> block.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Try = </span><span class="nx">class</span> <span class="nx">Try</span> <span class="k">extends</span> <span class="nx">Base</span>
+    <span class="k">super</span> <span class="nx">idt</span><span class="p">,</span> <span class="nx">@constructor</span><span class="p">.</span><span class="nx">name</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">@negated</span> <span class="k">then</span> <span class="s1">&#39;!&#39;</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-118">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-118">&#182;</a>               </div>               <h3>Try</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-119">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-119">&#182;</a>               </div>               <p>A classic <em>try/catch/finally</em> block.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Try = </span><span class="nx">class</span> <span class="nx">Try</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@attempt</span><span class="p">,</span> <span class="nx">@error</span><span class="p">,</span> <span class="nx">@recovery</span><span class="p">,</span> <span class="nx">@ensure</span><span class="p">)</span> <span class="o">-&gt;</span>

  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;attempt&#39;</span><span class="p">,</span> <span class="s1">&#39;recovery&#39;</span><span class="p">,</span> <span class="s1">&#39;ensure&#39;</span><span class="p">]</span>
@@ -1053,11 +1074,12 @@ true
  <span class="nx">makeReturn</span><span class="o">:</span> <span class="o">-&gt;</span>
    <span class="vi">@attempt  = </span><span class="nx">@attempt</span> <span class="p">.</span><span class="nx">makeReturn</span><span class="p">()</span> <span class="k">if</span> <span class="nx">@attempt</span>
    <span class="vi">@recovery = </span><span class="nx">@recovery</span><span class="p">.</span><span class="nx">makeReturn</span><span class="p">()</span> <span class="k">if</span> <span class="nx">@recovery</span>
-    <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-116">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-116">&#182;</a>               </div>               <p>Compilation is more or less as you would expect -- the <em>finally</em> clause
+    <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-120">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-120">&#182;</a>               </div>               <p>Compilation is more or less as you would expect -- the <em>finally</em> clause
 is optional, the <em>catch</em> is not.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nx">o</span><span class="p">.</span><span class="nx">indent</span>  <span class="o">+=</span> <span class="nx">TAB</span>
    <span class="nv">errorPart = </span><span class="k">if</span> <span class="nx">@error</span> <span class="k">then</span> <span class="s2">&quot; (#{ @error.compile o }) &quot;</span> <span class="k">else</span> <span class="s1">&#39; &#39;</span>
    <span class="nv">catchPart = </span><span class="k">if</span> <span class="nx">@recovery</span>
+      <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">add</span> <span class="nx">@error</span><span class="p">.</span><span class="nx">value</span><span class="p">,</span> <span class="s1">&#39;param&#39;</span>
      <span class="s2">&quot; catch#{errorPart}{\n#{ @recovery.compile o, LEVEL_TOP }\n#{@tab}}&quot;</span>
    <span class="k">else</span> <span class="nx">unless</span> <span class="nx">@ensure</span> <span class="o">or</span> <span class="nx">@recovery</span>
      <span class="s1">&#39; catch (_e) {}&#39;</span>
@@ -1065,16 +1087,16 @@ is optional, the <em>catch</em> is not.</p>             </td>             <td cl
 <span class="s2">    #{@tab}try {</span>
 <span class="s2">    #{ @attempt.compile o, LEVEL_TOP }</span>
 <span class="s2">    #{@tab}}#{ catchPart or &#39;&#39; }</span>
-<span class="s2">    &quot;&quot;&quot;</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">@ensure</span> <span class="k">then</span> <span class="s2">&quot; finally {\n#{ @ensure.compile o, LEVEL_TOP }\n#{@tab}}&quot;</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-117">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-117">&#182;</a>               </div>               <h3>Throw</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-118">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-118">&#182;</a>               </div>               <p>Simple node to throw an exception.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Throw = </span><span class="nx">class</span> <span class="nx">Throw</span> <span class="k">extends</span> <span class="nx">Base</span>
+<span class="s2">    &quot;&quot;&quot;</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">@ensure</span> <span class="k">then</span> <span class="s2">&quot; finally {\n#{ @ensure.compile o, LEVEL_TOP }\n#{@tab}}&quot;</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-121">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-121">&#182;</a>               </div>               <h3>Throw</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-122">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-122">&#182;</a>               </div>               <p>Simple node to throw an exception.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Throw = </span><span class="nx">class</span> <span class="nx">Throw</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@expression</span><span class="p">)</span> <span class="o">-&gt;</span>

  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;expression&#39;</span><span class="p">]</span>

  <span class="nx">isStatement</span><span class="o">:</span> <span class="nx">YES</span>
-  <span class="nx">jumps</span><span class="o">:</span>       <span class="nx">NO</span></pre></div>             </td>           </tr>                               <tr id="section-119">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-119">&#182;</a>               </div>               <p>A <strong>Throw</strong> is already a return, of sorts...</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">makeReturn</span><span class="o">:</span> <span class="nx">THIS</span>
+  <span class="nx">jumps</span><span class="o">:</span>       <span class="nx">NO</span></pre></div>             </td>           </tr>                               <tr id="section-123">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-123">&#182;</a>               </div>               <p>A <strong>Throw</strong> is already a return, of sorts...</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">makeReturn</span><span class="o">:</span> <span class="nx">THIS</span>

  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="nx">@tab</span> <span class="o">+</span> <span class="s2">&quot;throw #{ @expression.compile o };&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-120">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-120">&#182;</a>               </div>               <h3>Existence</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-121">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-121">&#182;</a>               </div>               <p>Checks a variable for existence -- not <em>null</em> and not <em>undefined</em>. This is
+    <span class="nx">@tab</span> <span class="o">+</span> <span class="s2">&quot;throw #{ @expression.compile o };&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-124">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-124">&#182;</a>               </div>               <h3>Existence</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-125">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-125">&#182;</a>               </div>               <p>Checks a variable for existence -- not <em>null</em> and not <em>undefined</em>. This is
 similar to <code>.nil?</code> in Ruby, and avoids having to consult a JavaScript truth
 table.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Existence = </span><span class="nx">class</span> <span class="nx">Existence</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@expression</span><span class="p">)</span> <span class="o">-&gt;</span>
@@ -1086,14 +1108,10 @@ table.</p>             </td>             <td class="code">               <div cl
  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nv">code = </span><span class="nx">@expression</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_OP</span>
    <span class="nv">code = </span><span class="k">if</span> <span class="nx">IDENTIFIER</span><span class="p">.</span><span class="nx">test</span><span class="p">(</span><span class="nx">code</span><span class="p">)</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">check</span> <span class="nx">code</span>
-      <span class="k">if</span> <span class="nx">@negated</span>
-        <span class="s2">&quot;typeof #{code} === \&quot;undefined\&quot; || #{code} === null&quot;</span>
-      <span class="k">else</span>
-        <span class="s2">&quot;typeof #{code} !== \&quot;undefined\&quot; &amp;&amp; #{code} !== null&quot;</span>
-    <span class="k">else</span>
-      <span class="nv">sym = </span><span class="k">if</span> <span class="nx">@negated</span> <span class="k">then</span> <span class="s1">&#39;==&#39;</span> <span class="k">else</span> <span class="s1">&#39;!=&#39;</span>
-      <span class="s2">&quot;#{code} #{sym} null&quot;</span>
-    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&lt;=</span> <span class="nx">LEVEL_COND</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">&quot;(#{code})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-122">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-122">&#182;</a>               </div>               <h3>Parens</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-123">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-123">&#182;</a>               </div>               <p>An extra set of parentheses, specified explicitly in the source. At one time
+        <span class="p">[</span><span class="nx">cmp</span><span class="p">,</span> <span class="nx">cnj</span><span class="p">]</span> <span class="o">=</span> <span class="k">if</span> <span class="nx">@negated</span> <span class="k">then</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="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="s2">&quot;typeof #{code} #{cmp} \&quot;undefined\&quot; #{cnj} #{code} #{cmp} null&quot;</span>
+    <span class="k">else</span></pre></div>             </td>           </tr>                               <tr id="section-126">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-126">&#182;</a>               </div>               <p>do not use strict equality here; it will break existing code</p>             </td>             <td class="code">               <div class="highlight"><pre>      <span class="s2">&quot;#{code} #{if @negated then &#39;==&#39; else &#39;!=&#39;} null&quot;</span>
+    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&lt;=</span> <span class="nx">LEVEL_COND</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">&quot;(#{code})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-127">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-127">&#182;</a>               </div>               <h3>Parens</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-128">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-128">&#182;</a>               </div>               <p>An extra set of parentheses, specified explicitly in the source. At one time
 we tried to clean up the results by detecting and removing redundant
 parentheses, but no longer -- you can put in as many as you please.</p>

@@ -1114,7 +1132,7 @@ parentheses, but no longer -- you can put in as many as you please.</p>
    <span class="nv">code = </span><span class="nx">expr</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_PAREN</span>
    <span class="nv">bare = </span><span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&lt;</span> <span class="nx">LEVEL_OP</span> <span class="o">and</span> <span class="p">(</span><span class="nx">expr</span> <span class="k">instanceof</span> <span class="nx">Op</span> <span class="o">or</span> <span class="nx">expr</span> <span class="k">instanceof</span> <span class="nx">Call</span> <span class="o">or</span>
      <span class="p">(</span><span class="nx">expr</span> <span class="k">instanceof</span> <span class="nx">For</span> <span class="o">and</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">returns</span><span class="p">))</span>
-    <span class="k">if</span> <span class="nx">bare</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">&quot;(#{code})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-124">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-124">&#182;</a>               </div>               <h3>For</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-125">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-125">&#182;</a>               </div>               <p>CoffeeScript's replacement for the <em>for</em> loop is our array and object
+    <span class="k">if</span> <span class="nx">bare</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s2">&quot;(#{code})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-129">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-129">&#182;</a>               </div>               <h3>For</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-130">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-130">&#182;</a>               </div>               <p>CoffeeScript's replacement for the <em>for</em> loop is our array and object
 comprehensions, that compile into <em>for</em> loops here. They also act as an
 expression, able to return the result of each filtered iteration.</p>

@@ -1142,54 +1160,55 @@ you can map and filter in a single pass.</p>             </td>             <td c

  <span class="nx">makeReturn</span><span class="o">:</span> <span class="o">-&gt;</span>
    <span class="vi">@returns = </span><span class="kc">yes</span>
-    <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-126">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-126">&#182;</a>               </div>               <p>Welcome to the hairiest method in all of CoffeeScript. Handles the inner
+    <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-131">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-131">&#182;</a>               </div>               <p>Welcome to the hairiest method in all of CoffeeScript. Handles the inner
 loop, filtering, stepping, and result saving for array, object, and range
 comprehensions. Some of the generated code can be shared in common, and
 some cannot.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileNode</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="nv">body          = </span><span class="nx">Block</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">@body</span><span class="p">]</span>
-    <span class="nv">lastJumps     = </span><span class="nx">last</span><span class="p">(</span><span class="nx">body</span><span class="p">.</span><span class="nx">expressions</span><span class="p">)</span><span class="o">?</span><span class="p">.</span><span class="nx">jumps</span><span class="p">()</span>
-    <span class="vi">@returns      = </span><span class="kc">no</span> <span class="k">if</span> <span class="nx">lastJumps</span> <span class="o">and</span> <span class="nx">lastJumps</span> <span class="k">instanceof</span> <span class="nx">Return</span>
-    <span class="nv">source        = </span><span class="k">if</span> <span class="nx">@range</span> <span class="k">then</span> <span class="nx">@source</span><span class="p">.</span><span class="nx">base</span> <span class="k">else</span> <span class="nx">@source</span>
-    <span class="nv">scope         = </span><span class="nx">o</span><span class="p">.</span><span class="nx">scope</span>
-    <span class="nv">name          = </span><span class="nx">@name</span>  <span class="o">and</span> <span class="nx">@name</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
-    <span class="nv">index         = </span><span class="nx">@index</span> <span class="o">and</span> <span class="nx">@index</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
+    <span class="nv">body      = </span><span class="nx">Block</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">@body</span><span class="p">]</span>
+    <span class="nv">lastJumps = </span><span class="nx">last</span><span class="p">(</span><span class="nx">body</span><span class="p">.</span><span class="nx">expressions</span><span class="p">)</span><span class="o">?</span><span class="p">.</span><span class="nx">jumps</span><span class="p">()</span>
+    <span class="vi">@returns  = </span><span class="kc">no</span> <span class="k">if</span> <span class="nx">lastJumps</span> <span class="o">and</span> <span class="nx">lastJumps</span> <span class="k">instanceof</span> <span class="nx">Return</span>
+    <span class="nv">source    = </span><span class="k">if</span> <span class="nx">@range</span> <span class="k">then</span> <span class="nx">@source</span><span class="p">.</span><span class="nx">base</span> <span class="k">else</span> <span class="nx">@source</span>
+    <span class="nv">scope     = </span><span class="nx">o</span><span class="p">.</span><span class="nx">scope</span>
+    <span class="nv">name      = </span><span class="nx">@name</span>  <span class="o">and</span> <span class="nx">@name</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
+    <span class="nv">index     = </span><span class="nx">@index</span> <span class="o">and</span> <span class="nx">@index</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
    <span class="nx">scope</span><span class="p">.</span><span class="nx">find</span><span class="p">(</span><span class="nx">name</span><span class="p">,</span>  <span class="nx">immediate</span><span class="o">:</span> <span class="kc">yes</span><span class="p">)</span> <span class="k">if</span> <span class="nx">name</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">@pattern</span>
    <span class="nx">scope</span><span class="p">.</span><span class="nx">find</span><span class="p">(</span><span class="nx">index</span><span class="p">,</span> <span class="nx">immediate</span><span class="o">:</span> <span class="kc">yes</span><span class="p">)</span> <span class="k">if</span> <span class="nx">index</span>
-    <span class="nv">rvar          = </span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span> <span class="s1">&#39;results&#39;</span> <span class="k">if</span> <span class="nx">@returns</span>
-    <span class="nv">ivar          = </span><span class="p">(</span><span class="k">if</span> <span class="nx">@range</span> <span class="k">then</span> <span class="nx">name</span> <span class="k">else</span> <span class="nx">index</span><span class="p">)</span> <span class="o">or</span> <span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span> <span class="s1">&#39;i&#39;</span>
-    <span class="nv">name          = </span><span class="nx">ivar</span> <span class="k">if</span> <span class="nx">@pattern</span>
-    <span class="nv">varPart       = </span><span class="s1">&#39;&#39;</span>
-    <span class="nv">guardPart     = </span><span class="s1">&#39;&#39;</span>
-    <span class="nv">defPart       = </span><span class="s1">&#39;&#39;</span>
-    <span class="nv">idt1          = </span><span class="nx">@tab</span> <span class="o">+</span> <span class="nx">TAB</span>
+    <span class="nv">rvar      = </span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span> <span class="s1">&#39;results&#39;</span> <span class="k">if</span> <span class="nx">@returns</span>
+    <span class="nv">ivar      = </span><span class="p">(</span><span class="k">if</span> <span class="nx">@range</span> <span class="k">then</span> <span class="nx">name</span> <span class="k">else</span> <span class="nx">index</span><span class="p">)</span> <span class="o">or</span> <span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span> <span class="s1">&#39;i&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-132">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-132">&#182;</a>               </div>               <p>the <code>_by</code> variable is created twice in <code>Range</code>s if we don't prevent it from being declared here</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="nv">stepvar   = </span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span> <span class="s2">&quot;step&quot;</span> <span class="k">if</span> <span class="nx">@step</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">@range</span>
+    <span class="nv">name      = </span><span class="nx">ivar</span> <span class="k">if</span> <span class="nx">@pattern</span>
+    <span class="nv">varPart   = </span><span class="s1">&#39;&#39;</span>
+    <span class="nv">guardPart = </span><span class="s1">&#39;&#39;</span>
+    <span class="nv">defPart   = </span><span class="s1">&#39;&#39;</span>
+    <span class="nv">idt1      = </span><span class="nx">@tab</span> <span class="o">+</span> <span class="nx">TAB</span>
    <span class="k">if</span> <span class="nx">@range</span>
      <span class="nv">forPart = </span><span class="nx">source</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">merge</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="p">{</span><span class="nx">index</span><span class="o">:</span> <span class="nx">ivar</span><span class="p">,</span> <span class="nx">@step</span><span class="p">})</span>
    <span class="k">else</span>
-      <span class="nv">svar = </span><span class="nx">@source</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
+      <span class="nv">svar    = </span><span class="nx">@source</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
      <span class="k">if</span> <span class="p">(</span><span class="nx">name</span> <span class="o">or</span> <span class="nx">@own</span><span class="p">)</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">IDENTIFIER</span><span class="p">.</span><span class="nx">test</span> <span class="nx">svar</span>
-        <span class="nv">defPart = </span><span class="s2">&quot;#{@tab}#{ref = scope.freeVariable &#39;ref&#39;} = #{svar};\n&quot;</span>
-        <span class="nv">svar = </span><span class="nx">ref</span>
+        <span class="nv">defPart    = </span><span class="s2">&quot;#{@tab}#{ref = scope.freeVariable &#39;ref&#39;} = #{svar};\n&quot;</span>
+        <span class="nv">svar       = </span><span class="nx">ref</span>
      <span class="k">if</span> <span class="nx">name</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">@pattern</span>
-        <span class="nv">namePart = </span><span class="s2">&quot;#{name} = #{svar}[#{ivar}]&quot;</span>
+        <span class="nv">namePart   = </span><span class="s2">&quot;#{name} = #{svar}[#{ivar}]&quot;</span>
      <span class="nx">unless</span> <span class="nx">@object</span>
-        <span class="nv">lvar        = </span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span> <span class="s1">&#39;len&#39;</span>
-        <span class="nv">stepPart    = </span><span class="k">if</span> <span class="nx">@step</span> <span class="k">then</span> <span class="s2">&quot;#{ivar} += #{ @step.compile(o, LEVEL_OP) }&quot;</span> <span class="k">else</span> <span class="s2">&quot;#{ivar}++&quot;</span>
-        <span class="nv">forPart     = </span><span class="s2">&quot;#{ivar} = 0, #{lvar} = #{svar}.length; #{ivar} &lt; #{lvar}; #{stepPart}&quot;</span>
+        <span class="nv">lvar       = </span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span> <span class="s1">&#39;len&#39;</span>
+        <span class="nv">forVarPart = </span><span class="s2">&quot;#{ivar} = 0, #{lvar} = #{svar}.length&quot;</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">@step</span> <span class="k">then</span> <span class="s2">&quot;, #{stepvar} = #{@step.compile(o, LEVEL_OP)}&quot;</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span>
+        <span class="nv">stepPart   = </span><span class="k">if</span> <span class="nx">@step</span> <span class="k">then</span> <span class="s2">&quot;#{ivar} += #{stepvar}&quot;</span> <span class="k">else</span> <span class="s2">&quot;#{ivar}++&quot;</span>
+        <span class="nv">forPart    = </span><span class="s2">&quot;#{forVarPart}; #{ivar} &lt; #{lvar}; #{stepPart}&quot;</span>
    <span class="k">if</span> <span class="nx">@returns</span>
-      <span class="nv">resultPart    = </span><span class="s2">&quot;#{@tab}#{rvar} = [];\n&quot;</span>
-      <span class="nv">returnResult  = </span><span class="s2">&quot;\n#{@tab}return #{rvar};&quot;</span>
-      <span class="nv">body          = </span><span class="nx">Push</span><span class="p">.</span><span class="nx">wrap</span> <span class="nx">rvar</span><span class="p">,</span> <span class="nx">body</span>
+      <span class="nv">resultPart   = </span><span class="s2">&quot;#{@tab}#{rvar} = [];\n&quot;</span>
+      <span class="nv">returnResult = </span><span class="s2">&quot;\n#{@tab}return #{rvar};&quot;</span>
+      <span class="nv">body         = </span><span class="nx">Push</span><span class="p">.</span><span class="nx">wrap</span> <span class="nx">rvar</span><span class="p">,</span> <span class="nx">body</span>
    <span class="k">if</span> <span class="nx">@guard</span>
-      <span class="nv">body          = </span><span class="nx">Block</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="k">new</span> <span class="nx">If</span> <span class="nx">@guard</span><span class="p">,</span> <span class="nx">body</span><span class="p">]</span>
+      <span class="nv">body         = </span><span class="nx">Block</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="k">new</span> <span class="nx">If</span> <span class="nx">@guard</span><span class="p">,</span> <span class="nx">body</span><span class="p">]</span>
    <span class="k">if</span> <span class="nx">@pattern</span>
      <span class="nx">body</span><span class="p">.</span><span class="nx">expressions</span><span class="p">.</span><span class="nx">unshift</span> <span class="k">new</span> <span class="nx">Assign</span> <span class="nx">@name</span><span class="p">,</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s2">&quot;#{svar}[#{ivar}]&quot;</span>
-    <span class="nx">defPart</span>         <span class="o">+=</span> <span class="nx">@pluckDirectCall</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">body</span>
-    <span class="nv">varPart         = </span><span class="s2">&quot;\n#{idt1}#{namePart};&quot;</span> <span class="k">if</span> <span class="nx">namePart</span>
+    <span class="nx">defPart</span>     <span class="o">+=</span> <span class="nx">@pluckDirectCall</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">body</span>
+    <span class="nv">varPart     = </span><span class="s2">&quot;\n#{idt1}#{namePart};&quot;</span> <span class="k">if</span> <span class="nx">namePart</span>
    <span class="k">if</span> <span class="nx">@object</span>
-      <span class="nv">forPart       = </span><span class="s2">&quot;#{ivar} in #{svar}&quot;</span>
-      <span class="nv">guardPart     = </span><span class="s2">&quot;\n#{idt1}if (!#{utility(&#39;hasProp&#39;)}.call(#{svar}, #{ivar})) continue;&quot;</span> <span class="k">if</span> <span class="nx">@own</span>
-    <span class="nv">body            = </span><span class="nx">body</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">merge</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">indent</span><span class="o">:</span> <span class="nx">idt1</span><span class="p">),</span> <span class="nx">LEVEL_TOP</span>
-    <span class="nv">body            = </span><span class="s1">&#39;\n&#39;</span> <span class="o">+</span> <span class="nx">body</span> <span class="o">+</span> <span class="s1">&#39;\n&#39;</span> <span class="k">if</span> <span class="nx">body</span>
+      <span class="nv">forPart   = </span><span class="s2">&quot;#{ivar} in #{svar}&quot;</span>
+      <span class="nv">guardPart = </span><span class="s2">&quot;\n#{idt1}if (!#{utility(&#39;hasProp&#39;)}.call(#{svar}, #{ivar})) continue;&quot;</span> <span class="k">if</span> <span class="nx">@own</span>
+    <span class="nv">body        = </span><span class="nx">body</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">merge</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">indent</span><span class="o">:</span> <span class="nx">idt1</span><span class="p">),</span> <span class="nx">LEVEL_TOP</span>
+    <span class="nv">body        = </span><span class="s1">&#39;\n&#39;</span> <span class="o">+</span> <span class="nx">body</span> <span class="o">+</span> <span class="s1">&#39;\n&#39;</span> <span class="k">if</span> <span class="nx">body</span>
    <span class="s2">&quot;&quot;&quot;</span>
 <span class="s2">    #{defPart}#{resultPart or &#39;&#39;}#{@tab}for (#{forPart}) {#{guardPart}#{varPart}#{body}#{@tab}}#{returnResult or &#39;&#39;}</span>
 <span class="s2">    &quot;&quot;&quot;</span>
@@ -1210,10 +1229,9 @@ some cannot.</p>             </td>             <td class="code">               <
      <span class="nv">base  = </span><span class="k">new</span> <span class="nx">Value</span> <span class="nx">ref</span>
      <span class="k">if</span> <span class="nx">val</span><span class="p">.</span><span class="nx">base</span>
        <span class="p">[</span><span class="nx">val</span><span class="p">.</span><span class="nx">base</span><span class="p">,</span> <span class="nx">base</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="nx">base</span><span class="p">,</span> <span class="nx">val</span><span class="p">]</span>
-        <span class="nx">args</span><span class="p">.</span><span class="nx">unshift</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;this&#39;</span>
      <span class="nx">body</span><span class="p">.</span><span class="nx">expressions</span><span class="p">[</span><span class="nx">idx</span><span class="p">]</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Call</span> <span class="nx">base</span><span class="p">,</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">args</span>
      <span class="nx">defs</span> <span class="o">+=</span> <span class="nx">@tab</span> <span class="o">+</span> <span class="k">new</span> <span class="nx">Assign</span><span class="p">(</span><span class="nx">ref</span><span class="p">,</span> <span class="nx">fn</span><span class="p">).</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_TOP</span><span class="p">)</span> <span class="o">+</span> <span class="s1">&#39;;\n&#39;</span>
-    <span class="nx">defs</span></pre></div>             </td>           </tr>                               <tr id="section-127">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-127">&#182;</a>               </div>               <h3>Switch</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-128">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-128">&#182;</a>               </div>               <p>A JavaScript <em>switch</em> statement. Converts into a returnable expression on-demand.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Switch = </span><span class="nx">class</span> <span class="nx">Switch</span> <span class="k">extends</span> <span class="nx">Base</span>
+    <span class="nx">defs</span></pre></div>             </td>           </tr>                               <tr id="section-133">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-133">&#182;</a>               </div>               <h3>Switch</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-134">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-134">&#182;</a>               </div>               <p>A JavaScript <em>switch</em> statement. Converts into a returnable expression on-demand.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Switch = </span><span class="nx">class</span> <span class="nx">Switch</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@subject</span><span class="p">,</span> <span class="nx">@cases</span><span class="p">,</span> <span class="nx">@otherwise</span><span class="p">)</span> <span class="o">-&gt;</span>

  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;subject&#39;</span><span class="p">,</span> <span class="s1">&#39;cases&#39;</span><span class="p">,</span> <span class="s1">&#39;otherwise&#39;</span><span class="p">]</span>
@@ -1244,7 +1262,7 @@ some cannot.</p>             </td>             <td class="code">               <
      <span class="k">continue</span> <span class="k">if</span> <span class="nx">expr</span> <span class="k">instanceof</span> <span class="nx">Return</span> <span class="o">or</span> <span class="p">(</span><span class="nx">expr</span> <span class="k">instanceof</span> <span class="nx">Literal</span> <span class="o">and</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">jumps</span><span class="p">()</span> <span class="o">and</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">value</span> <span class="o">isnt</span> <span class="s1">&#39;debugger&#39;</span><span class="p">)</span>
      <span class="nx">code</span> <span class="o">+=</span> <span class="nx">idt2</span> <span class="o">+</span> <span class="s1">&#39;break;\n&#39;</span>
    <span class="nx">code</span> <span class="o">+=</span> <span class="nx">idt1</span> <span class="o">+</span> <span class="s2">&quot;default:\n#{ @otherwise.compile o, LEVEL_TOP }\n&quot;</span> <span class="k">if</span> <span class="nx">@otherwise</span> <span class="o">and</span> <span class="nx">@otherwise</span><span class="p">.</span><span class="nx">expressions</span><span class="p">.</span><span class="nx">length</span>
-    <span class="nx">code</span> <span class="o">+</span>  <span class="nx">@tab</span> <span class="o">+</span> <span class="s1">&#39;}&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-129">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-129">&#182;</a>               </div>               <h3>If</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-130">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-130">&#182;</a>               </div>               <p><em>If/else</em> statements. Acts as an expression by pushing down requested returns
+    <span class="nx">code</span> <span class="o">+</span>  <span class="nx">@tab</span> <span class="o">+</span> <span class="s1">&#39;}&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-135">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-135">&#182;</a>               </div>               <h3>If</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-136">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-136">&#182;</a>               </div>               <p><em>If/else</em> statements. Acts as an expression by pushing down requested returns
 to the last line of each clause.</p>

 <p>Single-expression <strong>Ifs</strong> are compiled into conditional operators if possible,
@@ -1258,13 +1276,13 @@ because ternaries are already proper expressions, and don't need conversion.</p>
  <span class="nx">children</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;condition&#39;</span><span class="p">,</span> <span class="s1">&#39;body&#39;</span><span class="p">,</span> <span class="s1">&#39;elseBody&#39;</span><span class="p">]</span>

  <span class="nx">bodyNode</span><span class="o">:</span>     <span class="o">-&gt;</span> <span class="nx">@body</span><span class="o">?</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">()</span>
-  <span class="nx">elseBodyNode</span><span class="o">:</span> <span class="o">-&gt;</span> <span class="nx">@elseBody</span><span class="o">?</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-131">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-131">&#182;</a>               </div>               <p>Rewrite a chain of <strong>Ifs</strong> to add a default case as the final <em>else</em>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">addElse</span><span class="o">:</span> <span class="p">(</span><span class="nx">elseBody</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">elseBodyNode</span><span class="o">:</span> <span class="o">-&gt;</span> <span class="nx">@elseBody</span><span class="o">?</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-137">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-137">&#182;</a>               </div>               <p>Rewrite a chain of <strong>Ifs</strong> to add a default case as the final <em>else</em>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">addElse</span><span class="o">:</span> <span class="p">(</span><span class="nx">elseBody</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">if</span> <span class="nx">@isChain</span>
      <span class="nx">@elseBodyNode</span><span class="p">().</span><span class="nx">addElse</span> <span class="nx">elseBody</span>
    <span class="k">else</span>
      <span class="vi">@isChain  = </span><span class="nx">elseBody</span> <span class="k">instanceof</span> <span class="nx">If</span>
      <span class="vi">@elseBody = </span><span class="nx">@ensureBlock</span> <span class="nx">elseBody</span>
-    <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-132">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-132">&#182;</a>               </div>               <p>The <strong>If</strong> only compiles into a statement if either of its bodies needs
+    <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-138">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-138">&#182;</a>               </div>               <p>The <strong>If</strong> only compiles into a statement if either of its bodies needs
 to be a statement. Otherwise a conditional operator is safe.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">isStatement</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nx">o</span><span class="o">?</span><span class="p">.</span><span class="nx">level</span> <span class="o">is</span> <span class="nx">LEVEL_TOP</span> <span class="o">or</span>
      <span class="nx">@bodyNode</span><span class="p">().</span><span class="nx">isStatement</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">or</span> <span class="nx">@elseBodyNode</span><span class="p">()</span><span class="o">?</span><span class="p">.</span><span class="nx">isStatement</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
@@ -1280,9 +1298,14 @@ to be a statement. Otherwise a conditional operator is safe.</p>             </t
    <span class="k">this</span>

  <span class="nx">ensureBlock</span><span class="o">:</span> <span class="p">(</span><span class="nx">node</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">if</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Block</span> <span class="k">then</span> <span class="nx">node</span> <span class="k">else</span> <span class="k">new</span> <span class="nx">Block</span> <span class="p">[</span><span class="nx">node</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-133">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-133">&#182;</a>               </div>               <p>Compile the <strong>If</strong> as a regular <em>if-else</em> statement. Flattened chains
+    <span class="k">if</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Block</span> <span class="k">then</span> <span class="nx">node</span> <span class="k">else</span> <span class="k">new</span> <span class="nx">Block</span> <span class="p">[</span><span class="nx">node</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-139">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-139">&#182;</a>               </div>               <p>Compile the <code>If</code> as a regular <em>if-else</em> statement. Flattened chains
 force inner <em>else</em> bodies into statement form.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileStatement</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nv">child    = </span><span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s1">&#39;chainChild&#39;</span>
+    <span class="nv">exeq     = </span><span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s1">&#39;isExistentialEquals&#39;</span>
+
+    <span class="k">if</span> <span class="nx">exeq</span>
+      <span class="k">return</span> <span class="k">new</span> <span class="nx">If</span><span class="p">(</span><span class="nx">@condition</span><span class="p">.</span><span class="nx">invert</span><span class="p">(),</span> <span class="nx">@elseBodyNode</span><span class="p">(),</span> <span class="nx">type</span><span class="o">:</span> <span class="s1">&#39;if&#39;</span><span class="p">).</span><span class="nx">compile</span> <span class="nx">o</span>
+
    <span class="nv">cond     = </span><span class="nx">@condition</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_PAREN</span>
    <span class="nx">o</span><span class="p">.</span><span class="nx">indent</span> <span class="o">+=</span> <span class="nx">TAB</span>
    <span class="nv">body     = </span><span class="nx">@ensureBlock</span><span class="p">(</span><span class="nx">@body</span><span class="p">).</span><span class="nx">compile</span> <span class="nx">o</span>
@@ -1295,7 +1318,7 @@ force inner <em>else</em> bodies into statement form.</p>             </td>
      <span class="nv">o.chainChild = </span><span class="kc">yes</span>
      <span class="nx">@elseBody</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">().</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_TOP</span>
    <span class="k">else</span>
-      <span class="s2">&quot;{\n#{ @elseBody.compile o, LEVEL_TOP }\n#{@tab}}&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-134">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-134">&#182;</a>               </div>               <p>Compile the If as a conditional operator.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileExpression</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
+      <span class="s2">&quot;{\n#{ @elseBody.compile o, LEVEL_TOP }\n#{@tab}}&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-140">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-140">&#182;</a>               </div>               <p>Compile the <code>If</code> as a conditional operator.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">compileExpression</span><span class="o">:</span> <span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="nv">cond = </span><span class="nx">@condition</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_COND</span>
    <span class="nv">body = </span><span class="nx">@bodyNode</span><span class="p">().</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
    <span class="nv">alt  = </span><span class="k">if</span> <span class="nx">@elseBodyNode</span><span class="p">()</span> <span class="k">then</span> <span class="nx">@elseBodyNode</span><span class="p">().</span><span class="nx">compile</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span><span class="p">)</span> <span class="k">else</span> <span class="s1">&#39;void 0&#39;</span>
@@ -1303,14 +1326,14 @@ force inner <em>else</em> bodies into statement form.</p>             </td>
    <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">&gt;=</span> <span class="nx">LEVEL_COND</span> <span class="k">then</span> <span class="s2">&quot;(#{code})&quot;</span> <span class="k">else</span> <span class="nx">code</span>

  <span class="nx">unfoldSoak</span><span class="o">:</span> <span class="o">-&gt;</span>
-    <span class="nx">@soak</span> <span class="o">and</span> <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-135">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-135">&#182;</a>               </div>               <h2>Faux-Nodes</h2>
+    <span class="nx">@soak</span> <span class="o">and</span> <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-141">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-141">&#182;</a>               </div>               <h2>Faux-Nodes</h2>

 <p>Faux-nodes are never created by the grammar, but are used during code
-generation to generate other combinations of nodes.</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-136">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-136">&#182;</a>               </div>               <h3>Push</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-137">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-137">&#182;</a>               </div>               <p>The <strong>Push</strong> creates the tree for <code>array.push(value)</code>,
+generation to generate other combinations of nodes.</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-142">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-142">&#182;</a>               </div>               <h3>Push</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-143">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-143">&#182;</a>               </div>               <p>The <strong>Push</strong> creates the tree for <code>array.push(value)</code>,
 which is helpful for recording the result arrays from comprehensions.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">Push =</span>
  <span class="nx">wrap</span><span class="o">:</span> <span class="p">(</span><span class="nx">name</span><span class="p">,</span> <span class="nx">exps</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">return</span> <span class="nx">exps</span> <span class="k">if</span> <span class="nx">exps</span><span class="p">.</span><span class="nx">isEmpty</span><span class="p">()</span> <span class="o">or</span> <span class="nx">last</span><span class="p">(</span><span class="nx">exps</span><span class="p">.</span><span class="nx">expressions</span><span class="p">).</span><span class="nx">jumps</span><span class="p">()</span>
-    <span class="nx">exps</span><span class="p">.</span><span class="nx">push</span> <span class="k">new</span> <span class="nx">Call</span> <span class="k">new</span> <span class="nx">Value</span><span class="p">(</span><span class="k">new</span> <span class="nx">Literal</span><span class="p">(</span><span class="nx">name</span><span class="p">),</span> <span class="p">[</span><span class="k">new</span> <span class="nx">Access</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;push&#39;</span><span class="p">]),</span> <span class="p">[</span><span class="nx">exps</span><span class="p">.</span><span class="nx">pop</span><span class="p">()]</span></pre></div>             </td>           </tr>                               <tr id="section-138">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-138">&#182;</a>               </div>               <h3>Closure</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-139">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-139">&#182;</a>               </div>               <p>A faux-node used to wrap an expressions body in a closure.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">Closure =</span></pre></div>             </td>           </tr>                               <tr id="section-140">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-140">&#182;</a>               </div>               <p>Wrap the expressions body, unless it contains a pure statement,
+    <span class="nx">exps</span><span class="p">.</span><span class="nx">push</span> <span class="k">new</span> <span class="nx">Call</span> <span class="k">new</span> <span class="nx">Value</span><span class="p">(</span><span class="k">new</span> <span class="nx">Literal</span><span class="p">(</span><span class="nx">name</span><span class="p">),</span> <span class="p">[</span><span class="k">new</span> <span class="nx">Access</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;push&#39;</span><span class="p">]),</span> <span class="p">[</span><span class="nx">exps</span><span class="p">.</span><span class="nx">pop</span><span class="p">()]</span></pre></div>             </td>           </tr>                               <tr id="section-144">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-144">&#182;</a>               </div>               <h3>Closure</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-145">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-145">&#182;</a>               </div>               <p>A faux-node used to wrap an expressions body in a closure.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">Closure =</span></pre></div>             </td>           </tr>                               <tr id="section-146">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-146">&#182;</a>               </div>               <p>Wrap the expressions body, unless it contains a pure statement,
 in which case, no dice. If the body mentions <code>this</code> or <code>arguments</code>,
 then make sure that the closure wrapper preserves the original values.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">wrap</span><span class="o">:</span> <span class="p">(</span><span class="nx">expressions</span><span class="p">,</span> <span class="nx">statement</span><span class="p">,</span> <span class="nx">noReturn</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="k">return</span> <span class="nx">expressions</span> <span class="k">if</span> <span class="nx">expressions</span><span class="p">.</span><span class="nx">jumps</span><span class="p">()</span>
@@ -1329,11 +1352,11 @@ then make sure that the closure wrapper preserves the original values.</p>
    <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Literal</span> <span class="o">and</span> <span class="nx">node</span><span class="p">.</span><span class="nx">value</span> <span class="o">is</span> <span class="s1">&#39;arguments&#39;</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">node</span><span class="p">.</span><span class="nx">asKey</span>
  <span class="nx">literalThis</span><span class="o">:</span> <span class="p">(</span><span class="nx">node</span><span class="p">)</span> <span class="o">-&gt;</span>
    <span class="p">(</span><span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Literal</span> <span class="o">and</span> <span class="nx">node</span><span class="p">.</span><span class="nx">value</span> <span class="o">is</span> <span class="s1">&#39;this&#39;</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">node</span><span class="p">.</span><span class="nx">asKey</span><span class="p">)</span> <span class="o">or</span>
-      <span class="p">(</span><span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Code</span> <span class="o">and</span> <span class="nx">node</span><span class="p">.</span><span class="nx">bound</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-141">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-141">&#182;</a>               </div>               <p>Unfold a node's child if soak, then tuck the node under created <code>If</code></p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">unfoldSoak = </span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">parent</span><span class="p">,</span> <span class="nx">name</span><span class="p">)</span> <span class="o">-&gt;</span>
+      <span class="p">(</span><span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Code</span> <span class="o">and</span> <span class="nx">node</span><span class="p">.</span><span class="nx">bound</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-147">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-147">&#182;</a>               </div>               <p>Unfold a node's child if soak, then tuck the node under created <code>If</code></p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">unfoldSoak = </span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">parent</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="nx">unless</span> <span class="nv">ifn = </span><span class="nx">parent</span><span class="p">[</span><span class="nx">name</span><span class="p">].</span><span class="nx">unfoldSoak</span> <span class="nx">o</span>
  <span class="nx">parent</span><span class="p">[</span><span class="nx">name</span><span class="p">]</span> <span class="o">=</span> <span class="nx">ifn</span><span class="p">.</span><span class="nx">body</span>
  <span class="nv">ifn.body = </span><span class="k">new</span> <span class="nx">Value</span> <span class="nx">parent</span>
-  <span class="nx">ifn</span></pre></div>             </td>           </tr>                               <tr id="section-142">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-142">&#182;</a>               </div>               <h2>Constants</h2>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">UTILITIES =</span></pre></div>             </td>           </tr>                               <tr id="section-143">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-143">&#182;</a>               </div>               <p>Correctly set up a prototype chain for inheritance, including a reference
+  <span class="nx">ifn</span></pre></div>             </td>           </tr>                               <tr id="section-148">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-148">&#182;</a>               </div>               <h2>Constants</h2>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">UTILITIES =</span></pre></div>             </td>           </tr>                               <tr id="section-149">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-149">&#182;</a>               </div>               <p>Correctly set up a prototype chain for inheritance, including a reference
 to the superclass for <code>super()</code> calls, and copies of any static properties.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">extends</span><span class="o">:</span> <span class="s1">&#39;&#39;&#39;</span>
 <span class="s1">    function(child, parent) {</span>
 <span class="s1">      for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; }</span>
@@ -1343,26 +1366,46 @@ to the superclass for <code>super()</code> calls, and copies of any static prope
 <span class="s1">      child.__super__ = parent.prototype;</span>
 <span class="s1">      return child;</span>
 <span class="s1">    }</span>
-<span class="s1">  &#39;&#39;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-144">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-144">&#182;</a>               </div>               <p>Create a function bound to the current value of "this".</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">bind</span><span class="o">:</span> <span class="s1">&#39;&#39;&#39;</span>
+<span class="s1">  &#39;&#39;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-150">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-150">&#182;</a>               </div>               <p>Create a function bound to the current value of "this".</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">bind</span><span class="o">:</span> <span class="s1">&#39;&#39;&#39;</span>
 <span class="s1">    function(fn, me){ return function(){ return fn.apply(me, arguments); }; }</span>
-<span class="s1">  &#39;&#39;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-145">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-145">&#182;</a>               </div>               <p>Discover if an item is in an array.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">indexOf</span><span class="o">:</span> <span class="s1">&#39;&#39;&#39;</span>
+<span class="s1">  &#39;&#39;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-151">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-151">&#182;</a>               </div>               <p>Discover if an item is in an array.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">indexOf</span><span class="o">:</span> <span class="s1">&#39;&#39;&#39;</span>
 <span class="s1">    Array.prototype.indexOf || function(item) {</span>
 <span class="s1">      for (var i = 0, l = this.length; i &lt; l; i++) {</span>
 <span class="s1">        if (this[i] === item) return i;</span>
 <span class="s1">      }</span>
 <span class="s1">      return -1;</span>
 <span class="s1">    }</span>
-<span class="s1">  &#39;&#39;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-146">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-146">&#182;</a>               </div>               <p>Shortcuts to speed up the lookup time for native functions.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">hasProp</span><span class="o">:</span> <span class="s1">&#39;Object.prototype.hasOwnProperty&#39;</span>
-  <span class="nx">slice</span>  <span class="o">:</span> <span class="s1">&#39;Array.prototype.slice&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-147">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-147">&#182;</a>               </div>               <p>Levels indicates a node's position in the AST. Useful for knowing if
+<span class="s1">  &#39;&#39;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-152">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-152">&#182;</a>               </div>               <p>Shortcuts to speed up the lookup time for native functions.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">hasProp</span><span class="o">:</span> <span class="s1">&#39;Object.prototype.hasOwnProperty&#39;</span>
+  <span class="nx">slice</span>  <span class="o">:</span> <span class="s1">&#39;Array.prototype.slice&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-153">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-153">&#182;</a>               </div>               <p>Levels indicate a node's position in the AST. Useful for knowing if
 parens are necessary or superfluous.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">LEVEL_TOP    = </span><span class="mi">1</span>  <span class="c1"># ...;</span>
 <span class="nv">LEVEL_PAREN  = </span><span class="mi">2</span>  <span class="c1"># (...)</span>
 <span class="nv">LEVEL_LIST   = </span><span class="mi">3</span>  <span class="c1"># [...]</span>
 <span class="nv">LEVEL_COND   = </span><span class="mi">4</span>  <span class="c1"># ... ? x : y</span>
 <span class="nv">LEVEL_OP     = </span><span class="mi">5</span>  <span class="c1"># !...</span>
-<span class="nv">LEVEL_ACCESS = </span><span class="mi">6</span>  <span class="c1"># ...[0]</span></pre></div>             </td>           </tr>                               <tr id="section-148">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-148">&#182;</a>               </div>               <p>Tabs are two spaces for pretty printing.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">TAB = </span><span class="s1">&#39;  &#39;</span>
+<span class="nv">LEVEL_ACCESS = </span><span class="mi">6</span>  <span class="c1"># ...[0]</span></pre></div>             </td>           </tr>                               <tr id="section-154">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-154">&#182;</a>               </div>               <p>Tabs are two spaces for pretty printing.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">TAB = </span><span class="s1">&#39;  &#39;</span>

-<span class="nv">IDENTIFIER = </span><span class="sr">/^[$A-Za-z_\x7f-\uffff][$\w\x7f-\uffff]*$/</span>
-<span class="nv">SIMPLENUM  = </span><span class="sr">/^[+-]?\d+$/</span></pre></div>             </td>           </tr>                               <tr id="section-149">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-149">&#182;</a>               </div>               <p>Is a literal value a string?</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IS_STRING = </span><span class="sr">/^[&#39;&quot;]/</span></pre></div>             </td>           </tr>                               <tr id="section-150">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-150">&#182;</a>               </div>               <h2>Utility Functions</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-151">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-151">&#182;</a>               </div>               <p>Helper for ensuring that utility functions are assigned at the top level.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">utility = </span><span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-&gt;</span>
+<span class="nv">IDENTIFIER_STR = </span><span class="s2">&quot;[$A-Za-z_\\x7f-\\uffff][$\\w\\x7f-\\uffff]*&quot;</span>
+<span class="nv">IDENTIFIER = </span><span class="err">/// ^ #{IDENTIFIER_STR} $ ///</span>
+<span class="nv">SIMPLENUM  = </span><span class="sr">/^[+-]?\d+$/</span>
+<span class="nv">METHOD_DEF = </span><span class="err">///</span>
+  <span class="o">^</span>
+    <span class="p">(</span><span class="o">?:</span>
+      <span class="p">(</span><span class="c1">#{IDENTIFIER_STR})</span>
+      <span class="err">\</span><span class="p">.</span><span class="nx">prototype</span>
+      <span class="p">(</span><span class="o">?:</span>
+        <span class="err">\</span><span class="p">.(</span><span class="c1">#{IDENTIFIER_STR})</span>
+      <span class="o">|</span> <span class="err">\</span><span class="p">[(</span><span class="s2">&quot;(?:[^\\&quot;</span><span class="err">\</span><span class="nx">r</span><span class="err">\</span><span class="nx">n</span><span class="p">]</span><span class="o">|</span><span class="err">\\</span><span class="p">.)</span><span class="o">*</span><span class="s2">&quot;|&#39;(?:[^\\&#39;\r\n]|\\.)*&#39;)\]</span>
+<span class="s2">      | \[(0x[\da-fA-F]+ | \d*\.?\d+ (?:[eE][+-]?\d+)?)\]</span>
+<span class="s2">      )</span>
+<span class="s2">    )</span>
+<span class="s2">  |</span>
+<span class="s2">    (#{IDENTIFIER_STR})</span>
+<span class="s2">  $</span>
+<span class="s2">///</span>
+
+
+<span class="s2">#DIVIDER</span>
+<span class="s2">IS_STRING = /^[&#39;&quot;</span><span class="p">]</span><span class="o">/</span></pre></div>             </td>           </tr>                               <tr id="section-155">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-155">&#182;</a>               </div>               <p>Is a literal value a string?</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-156">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-156">&#182;</a>               </div>               <h2>Utility Functions</h2>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">utility = </span><span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">-&gt;</span>
  <span class="nv">ref = </span><span class="s2">&quot;__#{name}&quot;</span>
  <span class="nx">Scope</span><span class="p">.</span><span class="nx">root</span><span class="p">.</span><span class="nx">assign</span> <span class="nx">ref</span><span class="p">,</span> <span class="nx">UTILITIES</span><span class="p">[</span><span class="nx">name</span><span class="p">]</span>
  <span class="nx">ref</span>
@@ -1370,4 +1413,4 @@ parens are necessary or superfluous.</p>             </td>             <td class
 <span class="nv">multident = </span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nx">tab</span><span class="p">)</span> <span class="o">-&gt;</span>
  <span class="nx">code</span><span class="p">.</span><span class="nx">replace</span> <span class="sr">/\n/g</span><span class="p">,</span> <span class="s1">&#39;$&amp;&#39;</span> <span class="o">+</span> <span class="nx">tab</span>

-</pre></div>             </td>           </tr>                </tbody>     </table>   </div> </body> </html> 
+</pre></div>             </td>           </tr>                               <tr id="section-157">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-157">&#182;</a>               </div>               <p>Helper for ensuring that utility functions are assigned at the top level.</p>             </td>             <td class="code">               <div class="highlight"><pre>undefined</pre></div>             </td>           </tr>                </tbody>     </table>   </div> </body> </html> 
--- a/documentation/docs/optparse.html
+++ b/documentation/docs/optparse.html
@@ -13,7 +13,7 @@ option) list, and all subsequent arguments are left unparsed.</p>             </

 <p>Along with an an optional banner for the usage help.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">constructor</span><span class="o">:</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="vi">@rules = </span><span class="nx">buildRules</span> <span class="nx">rules</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-3">&#182;</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
+specified options, and return it. <code>options.arguments</code> will be an array
 containing the remaining non-option arguments. <code>options.literals</code> will be
 an array of options that are meant to be passed through directly to the
 executing script. This is a simpler API than many option parsers that allow
--- a/documentation/docs/repl.html
+++ b/documentation/docs/repl.html
@@ -6,59 +6,85 @@ Using it looks like this:</p>
 </code></pre>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-2">&#182;</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">readline     = </span><span class="nx">require</span> <span class="s1">&#39;readline&#39;</span>
 <span class="p">{</span><span class="nx">inspect</span><span class="p">}</span>    <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;util&#39;</span>
-<span class="p">{</span><span class="nx">Script</span><span class="p">}</span>     <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;vm&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-3">&#182;</a>               </div>               <p>REPL Setup</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>Config</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">enableColours = </span><span class="kc">no</span>
+<span class="p">{</span><span class="nx">Script</span><span class="p">}</span>     <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;vm&#39;</span>
+<span class="nv">Module       = </span><span class="nx">require</span> <span class="s1">&#39;module&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-3">&#182;</a>               </div>               <p>REPL Setup</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>Config</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">REPL_PROMPT = </span><span class="s1">&#39;coffee&gt; &#39;</span>
+<span class="nv">REPL_PROMPT_CONTINUATION = </span><span class="s1">&#39;......&gt; &#39;</span>
+<span class="nv">enableColours = </span><span class="kc">no</span>
 <span class="nx">unless</span> <span class="nx">process</span><span class="p">.</span><span class="nx">platform</span> <span class="o">is</span> <span class="s1">&#39;win32&#39;</span>
  <span class="nv">enableColours = </span><span class="o">not</span> <span class="nx">process</span><span class="p">.</span><span class="nx">env</span><span class="p">.</span><span class="nx">NODE_DISABLE_COLORS</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-5">&#182;</a>               </div>               <p>Start by opening up <code>stdin</code> and <code>stdout</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">stdin = </span><span class="nx">process</span><span class="p">.</span><span class="nx">openStdin</span><span class="p">()</span>
 <span class="nv">stdout = </span><span class="nx">process</span><span class="p">.</span><span class="nx">stdout</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-6">&#182;</a>               </div>               <p>Log an error.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">error = </span><span class="p">(</span><span class="nx">err</span><span class="p">)</span> <span class="o">-&gt;</span>
-  <span class="nx">stdout</span><span class="p">.</span><span class="nx">write</span> <span class="p">(</span><span class="nx">err</span><span class="p">.</span><span class="nx">stack</span> <span class="o">or</span> <span class="nx">err</span><span class="p">.</span><span class="nx">toString</span><span class="p">())</span> <span class="o">+</span> <span class="s1">&#39;\n\n&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-7">&#182;</a>               </div>               <p>The current backlog of multi-line code.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">backlog = </span><span class="s1">&#39;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-8">&#182;</a>               </div>               <p>The main REPL function. <strong>run</strong> is called every time a line of code is entered.
+  <span class="nx">stdout</span><span class="p">.</span><span class="nx">write</span> <span class="p">(</span><span class="nx">err</span><span class="p">.</span><span class="nx">stack</span> <span class="o">or</span> <span class="nx">err</span><span class="p">.</span><span class="nx">toString</span><span class="p">())</span> <span class="o">+</span> <span class="s1">&#39;\n\n&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-7">&#182;</a>               </div>               <p>The current backlog of multi-line code.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">backlog = </span><span class="s1">&#39;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-8">&#182;</a>               </div>               <p>The REPL context; must be visible outside <code>run</code> to allow for tab completion</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">sandbox = </span><span class="nx">Script</span><span class="p">.</span><span class="nx">createContext</span><span class="p">()</span>
+<span class="nv">nonContextGlobals = </span><span class="p">[</span>
+  <span class="s1">&#39;Buffer&#39;</span><span class="p">,</span> <span class="s1">&#39;console&#39;</span><span class="p">,</span> <span class="s1">&#39;process&#39;</span>
+  <span class="s1">&#39;setInterval&#39;</span><span class="p">,</span> <span class="s1">&#39;clearInterval&#39;</span>
+  <span class="s1">&#39;setTimeout&#39;</span><span class="p">,</span> <span class="s1">&#39;clearTimeout&#39;</span>
+<span class="p">]</span>
+<span class="nx">sandbox</span><span class="p">[</span><span class="nx">g</span><span class="p">]</span> <span class="o">=</span> <span class="nx">global</span><span class="p">[</span><span class="nx">g</span><span class="p">]</span> <span class="k">for</span> <span class="nx">g</span> <span class="k">in</span> <span class="nx">nonContextGlobals</span>
+<span class="nv">sandbox.global = sandbox.root = sandbox.GLOBAL = </span><span class="nx">sandbox</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-9">&#182;</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
-of exiting.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">run = </span><span class="nx">do</span> <span class="o">-&gt;</span>
-  <span class="nv">sandbox =</span>
-    <span class="nx">require</span><span class="o">:</span> <span class="nx">require</span>
-    <span class="nx">module</span> <span class="o">:</span> <span class="p">{</span> <span class="nx">exports</span><span class="o">:</span> <span class="p">{}</span> <span class="p">}</span>
-  <span class="nx">sandbox</span><span class="p">[</span><span class="nx">g</span><span class="p">]</span> <span class="o">=</span> <span class="nx">global</span><span class="p">[</span><span class="nx">g</span><span class="p">]</span> <span class="k">for</span> <span class="nx">g</span> <span class="k">of</span> <span class="nx">global</span>
-  <span class="nv">sandbox.global = </span><span class="nx">sandbox</span>
-  <span class="nv">sandbox.global.global = sandbox.global.root = sandbox.global.GLOBAL = </span><span class="nx">sandbox</span>
-  <span class="p">(</span><span class="nx">buffer</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="nv">code = </span><span class="nx">backlog</span> <span class="o">+=</span> <span class="s1">&#39;\n&#39;</span> <span class="o">+</span> <span class="nx">buffer</span><span class="p">.</span><span class="nx">toString</span><span class="p">()</span>
-    <span class="k">if</span> <span class="nx">code</span><span class="p">[</span><span class="nx">code</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="s1">&#39;\\&#39;</span>
-      <span class="k">return</span> <span class="nv">backlog = </span><span class="nx">backlog</span><span class="p">[</span><span class="mi">0</span><span class="p">...</span><span class="nx">backlog</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="nv">backlog = </span><span class="s1">&#39;&#39;</span>
-    <span class="k">try</span>
-      <span class="nv">val = </span><span class="nx">CoffeeScript</span><span class="p">.</span><span class="nb">eval</span> <span class="nx">code</span><span class="p">,</span> <span class="p">{</span>
-        <span class="nx">sandbox</span><span class="p">,</span>
-        <span class="nx">bare</span><span class="o">:</span> <span class="kc">on</span><span class="p">,</span>
-        <span class="nx">filename</span><span class="o">:</span> <span class="s1">&#39;repl&#39;</span>
-      <span class="p">}</span>
-      <span class="nx">unless</span> <span class="nx">val</span> <span class="o">is</span> <span class="kc">undefined</span>
-        <span class="nx">process</span><span class="p">.</span><span class="nx">stdout</span><span class="p">.</span><span class="nx">write</span> <span class="nx">inspect</span><span class="p">(</span><span class="nx">val</span><span class="p">,</span> <span class="kc">no</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">enableColours</span><span class="p">)</span> <span class="o">+</span> <span class="s1">&#39;\n&#39;</span>
-    <span class="k">catch</span> <span class="nx">err</span>
-      <span class="nx">error</span> <span class="nx">err</span>
-    <span class="nx">repl</span><span class="p">.</span><span class="nx">prompt</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-9">&#182;</a>               </div>               <h1>Autocompletion</h1>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#182;</a>               </div>               <p>Regexes to match complete-able bits of text.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">ACCESSOR  = </span><span class="sr">/\s*([\w\.]+)(?:\.(\w*))$/</span>
-<span class="nv">SIMPLEVAR = </span><span class="sr">/\s*(\w*)$/i</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-11">&#182;</a>               </div>               <p>Returns a list of completions, and the completed text.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">autocomplete = </span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">-&gt;</span>
-  <span class="nx">completeAttribute</span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">or</span> <span class="nx">completeVariable</span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">or</span> <span class="p">[[],</span> <span class="nx">text</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-12">&#182;</a>               </div>               <p>Attempt to autocomplete a chained dotted attribute: <code>one.two.three</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">completeAttribute = </span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">-&gt;</span>
+of exiting.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">run = </span><span class="p">(</span><span class="nx">buffer</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="k">if</span> <span class="o">!</span><span class="nx">buffer</span><span class="p">.</span><span class="nx">toString</span><span class="p">().</span><span class="nx">trim</span><span class="p">()</span> <span class="o">and</span> <span class="o">!</span><span class="nx">backlog</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">prompt</span><span class="p">()</span>
+    <span class="k">return</span>
+  <span class="nv">code = </span><span class="nx">backlog</span> <span class="o">+=</span> <span class="nx">buffer</span>
+  <span class="k">if</span> <span class="nx">code</span><span class="p">[</span><span class="nx">code</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="s1">&#39;\\&#39;</span>
+    <span class="nv">backlog = </span><span class="s2">&quot;#{backlog[...-1]}\n&quot;</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">setPrompt</span> <span class="nx">REPL_PROMPT_CONTINUATION</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">prompt</span><span class="p">()</span>
+    <span class="k">return</span>
+  <span class="nx">repl</span><span class="p">.</span><span class="nx">setPrompt</span> <span class="nx">REPL_PROMPT</span>
+  <span class="nv">backlog = </span><span class="s1">&#39;&#39;</span>
+  <span class="k">try</span>
+    <span class="nv">_ = </span><span class="nx">sandbox</span><span class="p">.</span><span class="nx">_</span>
+    <span class="nv">returnValue = </span><span class="nx">CoffeeScript</span><span class="p">.</span><span class="nb">eval</span> <span class="s2">&quot;_=(#{code}\n)&quot;</span><span class="p">,</span> <span class="p">{</span>
+      <span class="nx">sandbox</span><span class="p">,</span>
+      <span class="nx">filename</span><span class="o">:</span> <span class="s1">&#39;repl&#39;</span>
+      <span class="nx">modulename</span><span class="o">:</span> <span class="s1">&#39;repl&#39;</span>
+    <span class="p">}</span>
+    <span class="k">if</span> <span class="nx">returnValue</span> <span class="o">is</span> <span class="kc">undefined</span>
+      <span class="nv">sandbox._ = </span><span class="nx">_</span>
+    <span class="k">else</span>
+      <span class="nx">process</span><span class="p">.</span><span class="nx">stdout</span><span class="p">.</span><span class="nx">write</span> <span class="nx">inspect</span><span class="p">(</span><span class="nx">returnValue</span><span class="p">,</span> <span class="kc">no</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">enableColours</span><span class="p">)</span> <span class="o">+</span> <span class="s1">&#39;\n&#39;</span>
+  <span class="k">catch</span> <span class="nx">err</span>
+    <span class="nx">error</span> <span class="nx">err</span>
+  <span class="nx">repl</span><span class="p">.</span><span class="nx">prompt</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#182;</a>               </div>               <h1>Autocompletion</h1>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-11">&#182;</a>               </div>               <p>Regexes to match complete-able bits of text.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">ACCESSOR  = </span><span class="sr">/\s*([\w\.]+)(?:\.(\w*))$/</span>
+<span class="nv">SIMPLEVAR = </span><span class="sr">/\s*(\w*)$/i</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-12">&#182;</a>               </div>               <p>Returns a list of completions, and the completed text.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">autocomplete = </span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">completeAttribute</span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">or</span> <span class="nx">completeVariable</span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">or</span> <span class="p">[[],</span> <span class="nx">text</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-13">&#182;</a>               </div>               <p>Attempt to autocomplete a chained dotted attribute: <code>one.two.three</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">completeAttribute = </span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">-&gt;</span>
  <span class="k">if</span> <span class="nv">match = </span><span class="nx">text</span><span class="p">.</span><span class="nx">match</span> <span class="nx">ACCESSOR</span>
    <span class="p">[</span><span class="nx">all</span><span class="p">,</span> <span class="nx">obj</span><span class="p">,</span> <span class="nx">prefix</span><span class="p">]</span> <span class="o">=</span> <span class="nx">match</span>
    <span class="k">try</span>
-      <span class="nv">val = </span><span class="nx">Script</span><span class="p">.</span><span class="nx">runInThisContext</span> <span class="nx">obj</span>
+      <span class="nv">val = </span><span class="nx">Script</span><span class="p">.</span><span class="nx">runInContext</span> <span class="nx">obj</span><span class="p">,</span> <span class="nx">sandbox</span>
    <span class="k">catch</span> <span class="nx">error</span>
-      <span class="k">return</span> <span class="p">[[],</span> <span class="nx">text</span><span class="p">]</span>
-    <span class="nv">completions = </span><span class="nx">getCompletions</span> <span class="nx">prefix</span><span class="p">,</span> <span class="nx">getPropertyNames</span> <span class="nx">val</span>
-    <span class="p">[</span><span class="nx">completions</span><span class="p">,</span> <span class="nx">prefix</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-13">&#182;</a>               </div>               <p>Attempt to autocomplete an in-scope free variable: <code>one</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">completeVariable = </span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">-&gt;</span>
-  <span class="k">if</span> <span class="nv">free = </span><span class="nx">text</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">SIMPLEVAR</span><span class="p">)</span><span class="o">?</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
-    <span class="nv">scope = </span><span class="nx">Script</span><span class="p">.</span><span class="nx">runInThisContext</span> <span class="s1">&#39;this&#39;</span>
-    <span class="nv">completions = </span><span class="nx">getCompletions</span> <span class="nx">free</span><span class="p">,</span> <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">RESERVED</span><span class="p">.</span><span class="nx">concat</span><span class="p">(</span><span class="nx">getPropertyNames</span> <span class="nx">scope</span><span class="p">)</span>
-    <span class="p">[</span><span class="nx">completions</span><span class="p">,</span> <span class="nx">free</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-14">&#182;</a>               </div>               <p>Return elements of candidates for which <code>prefix</code> is a prefix.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">getCompletions = </span><span class="p">(</span><span class="nx">prefix</span><span class="p">,</span> <span class="nx">candidates</span><span class="p">)</span> <span class="o">-&gt;</span>
-  <span class="p">(</span><span class="nx">el</span> <span class="k">for</span> <span class="nx">el</span> <span class="k">in</span> <span class="nx">candidates</span> <span class="k">when</span> <span class="nx">el</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">prefix</span><span class="p">)</span> <span class="o">is</span> <span class="mi">0</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-15">&#182;</a>               </div>               <p>Return all "own" properties of an object.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">getPropertyNames = </span><span class="p">(</span><span class="nx">obj</span><span class="p">)</span> <span class="o">-&gt;</span>
-  <span class="p">(</span><span class="nx">name</span> <span class="k">for</span> <span class="nx">own</span> <span class="nx">name</span> <span class="k">of</span> <span class="nx">obj</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-16">&#182;</a>               </div>               <p>Make sure that uncaught exceptions don't kill the REPL.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nx">process</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;uncaughtException&#39;</span><span class="p">,</span> <span class="nx">error</span></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-17">&#182;</a>               </div>               <p>Create the REPL by listening to <strong>stdin</strong>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">if</span> <span class="nx">readline</span><span class="p">.</span><span class="nx">createInterface</span><span class="p">.</span><span class="nx">length</span> <span class="o">&lt;</span> <span class="mi">3</span>
+      <span class="k">return</span>
+    <span class="nv">completions = </span><span class="nx">getCompletions</span> <span class="nx">prefix</span><span class="p">,</span> <span class="nb">Object</span><span class="p">.</span><span class="nx">getOwnPropertyNames</span> <span class="nx">val</span>
+    <span class="p">[</span><span class="nx">completions</span><span class="p">,</span> <span class="nx">prefix</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-14">&#182;</a>               </div>               <p>Attempt to autocomplete an in-scope free variable: <code>one</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">completeVariable = </span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="k">if</span> <span class="nv">free = </span><span class="p">(</span><span class="nx">text</span><span class="p">.</span><span class="nx">match</span> <span class="nx">SIMPLEVAR</span><span class="p">)</span><span class="o">?</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
+    <span class="nv">vars = </span><span class="nx">Script</span><span class="p">.</span><span class="nx">runInContext</span> <span class="s1">&#39;Object.getOwnPropertyNames(this)&#39;</span><span class="p">,</span> <span class="nx">sandbox</span>
+    <span class="nv">possibilities = </span><span class="nx">vars</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">RESERVED</span>
+    <span class="nv">completions = </span><span class="nx">getCompletions</span> <span class="nx">free</span><span class="p">,</span> <span class="nx">possibilities</span>
+    <span class="p">[</span><span class="nx">completions</span><span class="p">,</span> <span class="nx">free</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-15">&#182;</a>               </div>               <p>Return elements of candidates for which <code>prefix</code> is a prefix.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">getCompletions = </span><span class="p">(</span><span class="nx">prefix</span><span class="p">,</span> <span class="nx">candidates</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="p">(</span><span class="nx">el</span> <span class="k">for</span> <span class="nx">el</span> <span class="k">in</span> <span class="nx">candidates</span> <span class="k">when</span> <span class="nx">el</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">prefix</span><span class="p">)</span> <span class="o">is</span> <span class="mi">0</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-16">&#182;</a>               </div>               <p>Make sure that uncaught exceptions don't kill the REPL.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nx">process</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;uncaughtException&#39;</span><span class="p">,</span> <span class="nx">error</span></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-17">&#182;</a>               </div>               <p>Create the REPL by listening to <strong>stdin</strong>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">if</span> <span class="nx">readline</span><span class="p">.</span><span class="nx">createInterface</span><span class="p">.</span><span class="nx">length</span> <span class="o">&lt;</span> <span class="mi">3</span>
  <span class="nv">repl = </span><span class="nx">readline</span><span class="p">.</span><span class="nx">createInterface</span> <span class="nx">stdin</span><span class="p">,</span> <span class="nx">autocomplete</span>
  <span class="nx">stdin</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;data&#39;</span><span class="p">,</span> <span class="p">(</span><span class="nx">buffer</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">repl</span><span class="p">.</span><span class="nx">write</span> <span class="nx">buffer</span>
 <span class="k">else</span>
  <span class="nv">repl = </span><span class="nx">readline</span><span class="p">.</span><span class="nx">createInterface</span> <span class="nx">stdin</span><span class="p">,</span> <span class="nx">stdout</span><span class="p">,</span> <span class="nx">autocomplete</span>

-<span class="nx">repl</span><span class="p">.</span><span class="nx">setPrompt</span> <span class="s1">&#39;coffee&gt; &#39;</span>
-<span class="nx">repl</span><span class="p">.</span><span class="kc">on</span>  <span class="s1">&#39;close&#39;</span><span class="p">,</span>  <span class="o">-&gt;</span> <span class="nx">stdin</span><span class="p">.</span><span class="nx">destroy</span><span class="p">()</span>
-<span class="nx">repl</span><span class="p">.</span><span class="kc">on</span>  <span class="s1">&#39;line&#39;</span><span class="p">,</span>   <span class="nx">run</span>
+<span class="nx">repl</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;attemptClose&#39;</span><span class="p">,</span> <span class="o">-&gt;</span>
+  <span class="k">if</span> <span class="nx">backlog</span>
+    <span class="nv">backlog = </span><span class="s1">&#39;&#39;</span>
+    <span class="nx">process</span><span class="p">.</span><span class="nx">stdout</span><span class="p">.</span><span class="nx">write</span> <span class="s1">&#39;\n&#39;</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">setPrompt</span> <span class="nx">REPL_PROMPT</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">prompt</span><span class="p">()</span>
+  <span class="k">else</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">close</span><span class="p">()</span>
+
+<span class="nx">repl</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;close&#39;</span><span class="p">,</span> <span class="o">-&gt;</span>
+  <span class="nx">process</span><span class="p">.</span><span class="nx">stdout</span><span class="p">.</span><span class="nx">write</span> <span class="s1">&#39;\n&#39;</span>
+  <span class="nx">stdin</span><span class="p">.</span><span class="nx">destroy</span><span class="p">()</span>
+
+<span class="nx">repl</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;line&#39;</span><span class="p">,</span> <span class="nx">run</span>
+
+<span class="nx">repl</span><span class="p">.</span><span class="nx">setPrompt</span> <span class="nx">REPL_PROMPT</span>
 <span class="nx">repl</span><span class="p">.</span><span class="nx">prompt</span><span class="p">()</span>

 </pre></div>             </td>           </tr>                </tbody>     </table>   </div> </body> </html> 
--- a/documentation/docs/rewriter.html
+++ b/documentation/docs/rewriter.html
@@ -111,12 +111,13 @@ deal with them.</p>             </td>             <td class="code">
      <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">noCall  = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;CLASS&#39;</span><span class="p">,</span> <span class="s1">&#39;IF&#39;</span><span class="p">]</span>
      <span class="p">[</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">current</span><span class="p">,</span> <span class="nx">next</span><span class="p">]</span> <span class="o">=</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="o">+</span> <span class="mi">1</span><span class="p">]</span>
-      <span class="nv">callObject = </span><span class="o">not</span> <span class="nx">noCall</span> <span class="o">and</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">next</span> <span class="o">and</span> <span class="nx">next</span><span class="p">.</span><span class="nx">generated</span> <span class="o">and</span> <span class="nx">next</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">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="k">in</span> <span class="nx">IMPLICIT_FUNC</span>
-      <span class="nv">seenSingle = </span><span class="kc">no</span>
-      <span class="nv">noCall     = </span><span class="kc">no</span> <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</span> <span class="nx">LINEBREAKS</span>
-      <span class="nv">token.call = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">prev</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">prev</span><span class="p">.</span><span class="nx">spaced</span> <span class="o">and</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;?&#39;</span>
+      <span class="nv">callObject  = </span><span class="o">not</span> <span class="nx">noCall</span> <span class="o">and</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">next</span> <span class="o">and</span> <span class="nx">next</span><span class="p">.</span><span class="nx">generated</span> <span class="o">and</span> <span class="nx">next</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">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="k">in</span> <span class="nx">IMPLICIT_FUNC</span>
+      <span class="nv">seenSingle  = </span><span class="kc">no</span>
+      <span class="nv">seenControl = </span><span class="kc">no</span>
+      <span class="nv">noCall      = </span><span class="kc">no</span> <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</span> <span class="nx">LINEBREAKS</span>
+      <span class="nv">token.call  = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">prev</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">prev</span><span class="p">.</span><span class="nx">spaced</span> <span class="o">and</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;?&#39;</span>
      <span class="k">return</span> <span class="mi">1</span> <span class="k">if</span> <span class="nx">token</span><span class="p">.</span><span class="nx">fromThen</span>
      <span class="k">return</span> <span class="mi">1</span> <span class="nx">unless</span> <span class="nx">callObject</span> <span class="o">or</span>
        <span class="nx">prev</span><span class="o">?</span><span class="p">.</span><span class="nx">spaced</span> <span class="o">and</span> <span class="p">(</span><span class="nx">prev</span><span class="p">.</span><span class="nx">call</span> <span class="o">or</span> <span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">in</span> <span class="nx">IMPLICIT_FUNC</span><span class="p">)</span> <span class="o">and</span>
@@ -125,9 +126,11 @@ deal with them.</p>             </td>             <td class="code">
      <span class="nx">@detectEnd</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="p">(</span><span class="nx">token</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">-&gt;</span>
        <span class="p">[</span><span class="nx">tag</span><span class="p">]</span> <span class="o">=</span> <span class="nx">token</span>
        <span class="k">return</span> <span class="kc">yes</span> <span class="k">if</span> <span class="o">not</span> <span class="nx">seenSingle</span> <span class="o">and</span> <span class="nx">token</span><span class="p">.</span><span class="nx">fromThen</span>
-        <span class="nv">seenSingle = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</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;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</span><span class="p">]</span>
+        <span class="nv">seenSingle  = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</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;CATCH&#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="nv">seenControl = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</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;SWITCH&#39;</span><span class="p">,</span> <span class="s1">&#39;TRY&#39;</span><span class="p">]</span>
        <span class="k">return</span> <span class="kc">yes</span> <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</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="o">and</span> <span class="nx">@tag</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="o">is</span> <span class="s1">&#39;OUTDENT&#39;</span>
-        <span class="o">not</span> <span class="nx">token</span><span class="p">.</span><span class="nx">generated</span> <span class="o">and</span> <span class="nx">@tag</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="o">isnt</span> <span class="s1">&#39;,&#39;</span> <span class="o">and</span> <span class="nx">tag</span> <span class="k">in</span> <span class="nx">IMPLICIT_END</span> <span class="o">and</span>
+        <span class="o">not</span> <span class="nx">token</span><span class="p">.</span><span class="nx">generated</span> <span class="o">and</span> <span class="nx">@tag</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="o">isnt</span> <span class="s1">&#39;,&#39;</span> <span class="o">and</span> <span class="p">(</span><span class="nx">tag</span> <span class="k">in</span> <span class="nx">IMPLICIT_END</span> <span class="o">or</span>
+        <span class="p">(</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="o">not</span> <span class="nx">seenControl</span><span class="p">))</span> <span class="o">and</span>
        <span class="p">(</span><span class="nx">tag</span> <span class="o">isnt</span> <span class="s1">&#39;INDENT&#39;</span> <span class="o">or</span>
         <span class="p">(</span><span class="nx">@tag</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="o">isnt</span> <span class="s1">&#39;CLASS&#39;</span> <span class="o">and</span> <span class="nx">@tag</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="o">not</span> <span class="k">in</span> <span class="nx">IMPLICIT_BLOCK</span> <span class="o">and</span>
          <span class="o">not</span> <span class="p">((</span><span class="nv">post = </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="o">and</span> <span class="nx">post</span><span class="p">.</span><span class="nx">generated</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;{&#39;</span><span class="p">)))</span>
@@ -248,7 +251,7 @@ look things up from either end.</p>             </td>             <td class="cod
  <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> <span class="s1">&#39;--&#39;</span><span class="p">,</span> <span class="s1">&#39;++&#39;</span>
 <span class="p">]</span>

-<span class="nv">IMPLICIT_UNSPACED_CALL = </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-25">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-25">&#182;</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-26">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-26">&#182;</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;POST_IF&#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;UNTIL&#39;</span><span class="p">,</span> <span class="s1">&#39;WHEN&#39;</span><span class="p">,</span> <span class="s1">&#39;BY&#39;</span><span class="p">,</span> <span class="s1">&#39;LOOP&#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></pre></div>             </td>           </tr>                               <tr id="section-27">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-27">&#182;</a>               </div>               <p>Single-line flavors of block expressions that have unclosed endings.
+<span class="nv">IMPLICIT_UNSPACED_CALL = </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-25">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-25">&#182;</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-26">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-26">&#182;</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;POST_IF&#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;UNTIL&#39;</span><span class="p">,</span> <span class="s1">&#39;WHEN&#39;</span><span class="p">,</span> <span class="s1">&#39;BY&#39;</span><span class="p">,</span> <span class="s1">&#39;LOOP&#39;</span><span class="p">,</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-27">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-27">&#182;</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="s1">&#39;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</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-28">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-28">&#182;</a>               </div>               <p>Tokens that end a line.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">LINEBREAKS       = </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>

--- a/documentation/docs/scope.html
+++ b/documentation/docs/scope.html
@@ -6,7 +6,7 @@ variables are new and need to be declared with <code>var</code>, and which are s
 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="pilwrap">                 <a class="pilcrow" href="#section-2">&#182;</a>               </div>               <p>Import the helpers we plan to use.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="p">{</span><span class="nx">extend</span><span class="p">,</span> <span class="nx">last</span><span class="p">}</span> <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;./helpers&#39;</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="pilwrap">                 <a class="pilcrow" href="#section-3">&#182;</a>               </div>               <p>The top-level <strong>Scope</strong> object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">@root</span><span class="o">:</span> <span class="kc">null</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>Initialize a scope with its parent, for lookups up the chain,
-as well as a reference to the <strong>Block</strong> node is belongs to, which is
+as well as a reference to the <strong>Block</strong> node it 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="nx">constructor</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="o">-&gt;</span>
    <span class="vi">@variables = </span><span class="p">[{</span><span class="nx">name</span><span class="o">:</span> <span class="s1">&#39;arguments&#39;</span><span class="p">,</span> <span class="nx">type</span><span class="o">:</span> <span class="s1">&#39;arguments&#39;</span><span class="p">}]</span>
--- a/documentation/index.html.erb
+++ b/documentation/index.html.erb
@@ -131,7 +131,7 @@

    <p>
      <b>Latest Version:</b>
-      <a href="http://github.com/jashkenas/coffee-script/tarball/1.1.0">1.1.0</a>
+      <a href="http://github.com/jashkenas/coffee-script/tarball/1.1.2">1.1.2</a>
    </p>

    <h2>
@@ -189,7 +189,9 @@ sudo bin/cake install</pre>
      If installing on Ubuntu or Debian,
      <a href="http://opinionated-programmer.com/2010/12/installing-coffeescript-on-debian-or-ubuntu/">be
      careful not to use the existing out-of-date package</a>. If installing on
-      Windows, your best bet is probably to run Node.js under Cygwin.
+      Windows, your best bet is probably to run Node.js under Cygwin. If you'd
+      just like to experiment, you can try the 
+      <a href="https://github.com/alisey/CoffeeScript-Compiler-for-Windows">CoffeeScript Compiler For Windows</a>.
    </p>

    <p>
@@ -266,7 +268,7 @@ sudo bin/cake install</pre>
        <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 "puts num for num in [10..1]"</tt>
+          command line. For example:<br /><tt>coffee -e "console.log num for num in [10..1]"</tt>
        </td>
      </tr>
      <tr>
@@ -309,7 +311,7 @@ Expressions
        <td><code>--nodejs</code></td>
        <td>
          The <tt>node</tt> executable has some useful options you can set,
-          such as<br /> <tt>--debug</tt> and <tt>--max-stack-size</tt>. Use this
+          such as<br /> <tt>--debug</tt>, <tt>--debug-brk</tt> and <tt>--max-stack-size</tt>. Use this
          flag to forward options directly to Node.js.
        </td>
      </tr>
@@ -367,8 +369,8 @@ Expressions
    <p>
      First, the basics: CoffeeScript uses significant whitespace to delimit blocks of code.
      You don't need to use semicolons <tt>;</tt> to terminate expressions,
-      ending the line will do just as well, (although semicolons can still
-      be used to fit multiple expressions onto a single line.)
+      ending the line will do just as well (although semicolons can still
+      be used to fit multiple expressions onto a single line).
      Instead of using curly braces
      <tt>{ }</tt> to surround blocks of code in <a href="#functions">functions</a>,
      <a href="#conditionals">if-statements</a>,
@@ -447,7 +449,7 @@ Expressions
      If you'd like to create top-level variables for other scripts to use,
      attach them as properties on <b>window</b>, or on the <b>exports</b>
      object in CommonJS. The <b>existential operator</b> (covered below), gives you a
-      reliable way to figure out where to add them, if you're targeting both
+      reliable way to figure out where to add them; if you're targeting both
      CommonJS and the browser: <tt>exports ? this</tt>
    </p>

@@ -502,7 +504,7 @@ Expressions
      each iteration into an array. Sometimes functions end with loops that are
      intended to run only for their side-effects. Be careful that you're not
      accidentally returning the results of the comprehension in these cases,
-      by adding a meaningful return value, like <tt>true</tt>, or <tt>null</tt>,
+      by adding a meaningful return value &mdash; like <tt>true</tt> &mdash; or <tt>null</tt>,
      to the bottom of your function.
    </p>
    <p>
@@ -565,7 +567,7 @@ Expressions
      to CoffeeScript functions, they nonetheless return their final value.
      The CoffeeScript compiler tries to make sure that all statements in the
      language can be used as expressions. Watch how the <tt>return</tt> gets
-      pushed down into each possible branch of execution, in the function
+      pushed down into each possible branch of execution in the function
      below.
    </p>
    <%= code_for('expressions', 'eldest') %>
@@ -719,7 +721,7 @@ Expressions
    </p>
    <%= code_for('prototypes', '"one_two".dasherize()') %>
    <p>
-      Finally class definitions are blocks of executable code, which make for interesting
+      Finally, class definitions are blocks of executable code, which make for interesting
      metaprogramming possibilities. Because in the context of a class definition,
      <tt>this</tt> is the class object itself (the constructor function), you
      can assign static properties by using <br /><tt>@property: value</tt>, and call
@@ -758,7 +760,7 @@ Expressions
      <b class="header">Function binding</b>
      In JavaScript, the <tt>this</tt> keyword is dynamically scoped to mean the
      object that the current function is attached to. If you pass a function as
-      as callback, or attach it to a different object, the original value of <tt>this</tt>
+      a callback or attach it to a different object, the original value of <tt>this</tt>
      will be lost. If you're not familiar with this behavior,
      <a href="http://www.digital-web.com/articles/scope_in_javascript/">this Digital Web article</a>
      gives a good overview of the quirks.
@@ -910,7 +912,7 @@ Expressions

    <p>
      In fact, the little bit of glue script that runs "Try CoffeeScript" above,
-      as well as jQuery for the menu, is implemented in just this way.
+      as well as the jQuery for the menu, is implemented in just this way.
      View source and look at the bottom of the page to see the example.
      Including the script also gives you access to <tt>CoffeeScript.compile()</tt>
      so you can pop open Firebug and try compiling some strings.
@@ -1020,11 +1022,35 @@ Expressions
      Change Log
    </h2>
    
+    <p>
+      <b class="header" style="margin-top: 20px;">
+        <a href="https://github.com/jashkenas/coffee-script/compare/1.1.1...1.1.2">1.1.2</a>
+        <span class="timestamp"> &ndash; <small>August 4, 2011</small></span>
+      </b>
+      We now use the native <tt>Function.prototype.bind</tt> for bound function
+      literals where available.
+      Fixes for: block comment formatting, <tt>?=</tt> compilation, implicit calls
+      against control structures, implicit invocation of a try/catch block,
+      variadic arguments leaking from local scope, line numbers in syntax errors
+      following heregexes, property access on parenthesized number literals,
+      bound class methods and super with reserved names, a REPL overhaul, 
+      consecutive compiled semicolons, block comments in implicitly called objects,
+      and a Chrome bug.
+    </p>
+    
+    <p>
+      <b class="header" style="margin-top: 20px;">1.1.1
+        <span class="timestamp"> &ndash; <small>May 10, 2011</small></span>
+      </b>
+      Bugfix release for classes with external constructor functions, see 
+      issue #1182.
+    </p>
+    
    <p>
      <b class="header" style="margin-top: 20px;">1.1.0
        <span class="timestamp"> &ndash; <small>May 1, 2011</small></span>
      </b>
-      When running via <tt>coffee</tt> executable, <tt>process.argv</tt> and 
+      When running via the <tt>coffee</tt> executable, <tt>process.argv</tt> and 
      friends now report <tt>coffee</tt> instead of <tt>node</tt>.
      Better compatibility with <b>Node.js 0.4.x</b> module lookup changes.
      The output in the REPL is now colorized, like Node's is.
@@ -1035,7 +1061,6 @@ Expressions
      Fixed an edge-case infinite loop in <tt>addImplicitParentheses</tt>.
      Fixed exponential slowdown with long chains of function calls.
      Globals no longer leak into the CoffeeScript REPL.
-      Function calls can be used as default values for parameters. 
      Splatted parameters are declared local to the function.
    </p>

--- a/documentation/js/block_comment.js
+++ b/documentation/js/block_comment.js
@@ -1,4 +1,4 @@
 /*
-CoffeeScript Compiler v1.1.0
+CoffeeScript Compiler v1.1.2
 Released under the MIT License
 */
--- a/documentation/js/classes.js
+++ b/documentation/js/classes.js
@@ -12,15 +12,15 @@ Animal = (function() {
    this.name = name;
  }
  Animal.prototype.move = function(meters) {
-    return alert(this.name + " moved " + meters + "m.");
+    return alert(this.name + (" moved " + meters + "m."));
  };
  return Animal;
 })();
 Snake = (function() {
+  __extends(Snake, Animal);
  function Snake() {
    Snake.__super__.constructor.apply(this, arguments);
  }
-  __extends(Snake, Animal);
  Snake.prototype.move = function() {
    alert("Slithering...");
    return Snake.__super__.move.call(this, 5);
@@ -28,10 +28,10 @@ Snake = (function() {
  return Snake;
 })();
 Horse = (function() {
+  __extends(Horse, Animal);
  function Horse() {
    Horse.__super__.constructor.apply(this, arguments);
  }
-  __extends(Horse, Animal);
  Horse.prototype.move = function() {
    alert("Galloping...");
    return Horse.__super__.move.call(this, 45);
--- a/documentation/js/existence.js
+++ b/documentation/js/existence.js
@@ -2,9 +2,7 @@ var footprints, solipsism;
 if ((typeof mind !== "undefined" && mind !== null) && !(typeof world !== "undefined" && world !== null)) {
  solipsism = true;
 }
-if (typeof speed !== "undefined" && speed !== null) {
-  speed;
-} else {
+if (typeof speed === "undefined" || speed === null) {
  speed = 75;
-};
+}
 footprints = typeof yeti !== "undefined" && yeti !== null ? yeti : "bear";
--- a/documentation/js/object_comprehensions.js
+++ b/documentation/js/object_comprehensions.js
@@ -9,7 +9,7 @@ ages = (function() {
  _results = [];
  for (child in yearsOld) {
    age = yearsOld[child];
-    _results.push(child + " is " + age);
+    _results.push("" + child + " is " + age);
  }
  return _results;
 })();
--- a/documentation/js/while.js
+++ b/documentation/js/while.js
@@ -12,7 +12,7 @@ lyrics = (function() {
  var _results;
  _results = [];
  while (num -= 1) {
-    _results.push(num + " little monkeys, jumping on the bed.    One fell out and bumped his head.");
+    _results.push("" + num + " little monkeys, jumping on the bed.    One fell out and bumped his head.");
  }
  return _results;
 })();
--- a/extras/EXTRAS
+++ b/extras/EXTRAS
@@ -1,7 +0,0 @@
-EXTRAS:
-
-"extras/coffee-script.js" is a concatenated and compressed version of the 
-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.
-
--- a/extras/coffee-script.js
+++ b/extras/coffee-script.js
--- a/index.html
+++ b/index.html
@@ -109,7 +109,7 @@

    <p>
      <b>Latest Version:</b>
-      <a href="http://github.com/jashkenas/coffee-script/tarball/1.1.0">1.1.0</a>
+      <a href="http://github.com/jashkenas/coffee-script/tarball/1.1.2">1.1.2</a>
    </p>

    <h2>
@@ -264,7 +264,9 @@ sudo bin/cake install</pre>
      If installing on Ubuntu or Debian,
      <a href="http://opinionated-programmer.com/2010/12/installing-coffeescript-on-debian-or-ubuntu/">be
      careful not to use the existing out-of-date package</a>. If installing on
-      Windows, your best bet is probably to run Node.js under Cygwin.
+      Windows, your best bet is probably to run Node.js under Cygwin. If you'd
+      just like to experiment, you can try the 
+      <a href="https://github.com/alisey/CoffeeScript-Compiler-for-Windows">CoffeeScript Compiler For Windows</a>.
    </p>

    <p>
@@ -341,7 +343,7 @@ sudo bin/cake install</pre>
        <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 "puts num for num in [10..1]"</tt>
+          command line. For example:<br /><tt>coffee -e "console.log num for num in [10..1]"</tt>
        </td>
      </tr>
      <tr>
@@ -384,7 +386,7 @@ Expressions
        <td><code>--nodejs</code></td>
        <td>
          The <tt>node</tt> executable has some useful options you can set,
-          such as<br /> <tt>--debug</tt> and <tt>--max-stack-size</tt>. Use this
+          such as<br /> <tt>--debug</tt>, <tt>--debug-brk</tt> and <tt>--max-stack-size</tt>. Use this
          flag to forward options directly to Node.js.
        </td>
      </tr>
@@ -442,8 +444,8 @@ Expressions
    <p>
      First, the basics: CoffeeScript uses significant whitespace to delimit blocks of code.
      You don't need to use semicolons <tt>;</tt> to terminate expressions,
-      ending the line will do just as well, (although semicolons can still
-      be used to fit multiple expressions onto a single line.)
+      ending the line will do just as well (although semicolons can still
+      be used to fit multiple expressions onto a single line).
      Instead of using curly braces
      <tt>{ }</tt> to surround blocks of code in <a href="#functions">functions</a>,
      <a href="#conditionals">if-statements</a>,
@@ -639,7 +641,7 @@ inner = changeNumbers();;alert(inner);'>run: inner</div><br class='clear' /></di
      If you'd like to create top-level variables for other scripts to use,
      attach them as properties on <b>window</b>, or on the <b>exports</b>
      object in CommonJS. The <b>existential operator</b> (covered below), gives you a
-      reliable way to figure out where to add them, if you're targeting both
+      reliable way to figure out where to add them; if you're targeting both
      CommonJS and the browser: <tt>exports ? this</tt>
    </p>

@@ -802,7 +804,7 @@ countdown = (function() {
      each iteration into an array. Sometimes functions end with loops that are
      intended to run only for their side-effects. Be careful that you're not
      accidentally returning the results of the comprehension in these cases,
-      by adding a meaningful return value, like <tt>true</tt>, or <tt>null</tt>,
+      by adding a meaningful return value &mdash; like <tt>true</tt> &mdash; or <tt>null</tt>,
      to the bottom of your function.
    </p>
    <p>
@@ -818,7 +820,7 @@ countdown = (function() {
    <div class='code'><pre class="idle">yearsOld <span class="Keyword">=</span> max: <span class="Number">10</span>, ida: <span class="Number">9</span>, tim: <span class="Number">11</span>

 ages <span class="Keyword">=</span> <span class="Keyword">for</span> child, age <span class="Keyword">of</span> yearsOld
-  child <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> is <span class="String">&quot;</span></span> <span class="Keyword">+</span> age
+  <span class="String"><span class="String">&quot;</span><span class="String"><span class="String">#{</span>child<span class="String">}</span></span> is <span class="String"><span class="String">#{</span>age<span class="String">}</span></span><span class="String">&quot;</span></span>
 </pre><pre class="idle"><span class="Storage">var</span> age, ages, child, yearsOld;
 yearsOld <span class="Keyword">=</span> {
  max: <span class="Number">10</span>,
@@ -830,11 +832,11 @@ ages <span class="Keyword">=</span> (<span class="Storage">function</span>() {
  _results <span class="Keyword">=</span> [];
  <span class="Keyword">for</span> (child <span class="Keyword">in</span> yearsOld) {
    age <span class="Keyword">=</span> yearsOld[child];
-    _results.<span class="LibraryFunction">push</span>(child <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> is <span class="String">&quot;</span></span> <span class="Keyword">+</span> age);
+    _results.<span class="LibraryFunction">push</span>(<span class="String"><span class="String">&quot;</span><span class="String">&quot;</span></span> <span class="Keyword">+</span> child <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> is <span class="String">&quot;</span></span> <span class="Keyword">+</span> age);
  }
  <span class="Keyword">return</span> _results;
 })();
-</pre><script>window.example11 = "yearsOld = max: 10, ida: 9, tim: 11\n\nages = for child, age of yearsOld\n  child + \" is \" + age\n\nalert ages.join(\", \")"</script><div class='minibutton load' onclick='javascript: loadConsole(example11);'>load</div><div class='minibutton ok' onclick='javascript: var age, ages, child, yearsOld;
+</pre><script>window.example11 = "yearsOld = max: 10, ida: 9, tim: 11\n\nages = for child, age of yearsOld\n  \"#{child} is #{age}\"\n\nalert ages.join(\", \")"</script><div class='minibutton load' onclick='javascript: loadConsole(example11);'>load</div><div class='minibutton ok' onclick='javascript: var age, ages, child, yearsOld;
 yearsOld = {
  max: 10,
  ida: 9,
@@ -845,7 +847,7 @@ ages = (function() {
  _results = [];
  for (child in yearsOld) {
    age = yearsOld[child];
-    _results.push(child + " is " + age);
+    _results.push("" + child + " is " + age);
  }
  return _results;
 })();;alert(ages.join(", "));'>run: ages.join(", ")</div><br class='clear' /></div>
@@ -869,7 +871,7 @@ ages = (function() {
 <span class="Comment"><span class="Comment">#</span> Nursery Rhyme</span>
 num <span class="Keyword">=</span> <span class="Number">6</span>
 lyrics <span class="Keyword">=</span> <span class="Keyword">while</span> num <span class="Keyword">-</span><span class="Keyword">=</span> <span class="Number">1</span>
-  num <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> little monkeys, jumping on the bed.</span>
+  <span class="String"><span class="String">&quot;</span><span class="String"><span class="String">#{</span>num<span class="String">}</span></span> little monkeys, jumping on the bed.</span>
 <span class="String">    One fell out and bumped his head.<span class="String">&quot;</span></span>
 </pre><pre class="idle"><span class="Storage">var</span> lyrics, num;
 <span class="Keyword">if</span> (<span class="Variable">this</span>.studyingEconomics) {
@@ -885,11 +887,11 @@ lyrics <span class="Keyword">=</span> (<span class="Storage">function</span>() {
  <span class="Storage">var</span> _results;
  _results <span class="Keyword">=</span> [];
  <span class="Keyword">while</span> (num <span class="Keyword">-</span><span class="Keyword">=</span> <span class="Number">1</span>) {
-    _results.<span class="LibraryFunction">push</span>(num <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> little monkeys, jumping on the bed.    One fell out and bumped his head.<span class="String">&quot;</span></span>);
+    _results.<span class="LibraryFunction">push</span>(<span class="String"><span class="String">&quot;</span><span class="String">&quot;</span></span> <span class="Keyword">+</span> num <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> little monkeys, jumping on the bed.    One fell out and bumped his head.<span class="String">&quot;</span></span>);
  }
  <span class="Keyword">return</span> _results;
 })();
-</pre><script>window.example12 = "# Econ 101\nif this.studyingEconomics\n  buy()  while supply > demand\n  sell() until supply > demand\n\n# Nursery Rhyme\nnum = 6\nlyrics = while num -= 1\n  num + \" little monkeys, jumping on the bed.\n    One fell out and bumped his head.\"\n\nalert lyrics.join(\"\\n\")"</script><div class='minibutton load' onclick='javascript: loadConsole(example12);'>load</div><div class='minibutton ok' onclick='javascript: var lyrics, num;
+</pre><script>window.example12 = "# Econ 101\nif this.studyingEconomics\n  buy()  while supply > demand\n  sell() until supply > demand\n\n# Nursery Rhyme\nnum = 6\nlyrics = while num -= 1\n  \"#{num} little monkeys, jumping on the bed.\n    One fell out and bumped his head.\"\n\nalert lyrics.join(\"\\n\")"</script><div class='minibutton load' onclick='javascript: loadConsole(example12);'>load</div><div class='minibutton ok' onclick='javascript: var lyrics, num;
 if (this.studyingEconomics) {
  while (supply > demand) {
    buy();
@@ -903,7 +905,7 @@ lyrics = (function() {
  var _results;
  _results = [];
  while (num -= 1) {
-    _results.push(num + " little monkeys, jumping on the bed.    One fell out and bumped his head.");
+    _results.push("" + num + " little monkeys, jumping on the bed.    One fell out and bumped his head.");
  }
  return _results;
 })();;alert(lyrics.join("\n"));'>run: lyrics.join("\n")</div><br class='clear' /></div>
@@ -981,7 +983,7 @@ numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
      to CoffeeScript functions, they nonetheless return their final value.
      The CoffeeScript compiler tries to make sure that all statements in the
      language can be used as expressions. Watch how the <tt>return</tt> gets
-      pushed down into each possible branch of execution, in the function
+      pushed down into each possible branch of execution in the function
      below.
    </p>
    <div class='code'><pre class="idle"><span class="FunctionName">grade </span><span class="Keyword">=</span> <span class="FunctionArgument">(student)</span> <span class="Storage">-&gt;</span>
@@ -1074,7 +1076,7 @@ globals = ((function() {
  <span class="Keyword">try</span>
    nonexistent <span class="Keyword">/</span> <span class="BuiltInConstant">undefined</span>
  <span class="Keyword">catch</span> error
-    <span class="String"><span class="String">&quot;</span>And the error is ... <span class="String">&quot;</span></span> <span class="Keyword">+</span> error
+    <span class="String"><span class="String">&quot;</span>And the error is ... <span class="String"><span class="String">#{</span>error<span class="String">}</span></span><span class="String">&quot;</span></span>
 )

 </pre><pre class="idle"><span class="LibraryFunction">alert</span>((<span class="Storage">function</span>() {
@@ -1084,7 +1086,7 @@ globals = ((function() {
    <span class="Keyword">return</span> <span class="String"><span class="String">&quot;</span>And the error is ... <span class="String">&quot;</span></span> <span class="Keyword">+</span> error;
  }
 })());
-</pre><script>window.example19 = "alert(\n  try\n    nonexistent / undefined\n  catch error\n    \"And the error is ... \" + error\n)\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example19);'>load</div><div class='minibutton ok' onclick='javascript: alert((function() {
+</pre><script>window.example19 = "alert(\n  try\n    nonexistent / undefined\n  catch error\n    \"And the error is ... #{error}\"\n)\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example19);'>load</div><div class='minibutton ok' onclick='javascript: alert((function() {
  try {
    return nonexistent / void 0;
  } catch (error) {
@@ -1163,7 +1165,7 @@ letTheWildRumpusBegin() <span class="Keyword">unless</span> answer <span class="

 winner <span class="Keyword">=</span> <span class="BuiltInConstant">yes</span> <span class="Keyword">if</span> pick <span class="Keyword">in</span> [<span class="Number">47</span>, <span class="Number">92</span>, <span class="Number">13</span>]

-print inspect <span class="String"><span class="String">&quot;</span>My name is <span class="String">&quot;</span></span> <span class="Keyword">+</span> <span class="Variable">@name</span>
+print inspect <span class="String"><span class="String">&quot;</span>My name is <span class="String"><span class="String">#{</span><span class="Variable">@name</span><span class="String">}</span></span><span class="String">&quot;</span></span>
 </pre><pre class="idle"><span class="Storage">var</span> volume, winner;
 <span class="Keyword">if</span> (ignition <span class="Keyword">===</span> <span class="BuiltInConstant">true</span>) {
  launch();
@@ -1181,7 +1183,7 @@ print inspect <span class="String"><span class="String">&quot;</span>My name is
  winner <span class="Keyword">=</span> <span class="BuiltInConstant">true</span>;
 }
 <span class="LibraryFunction">print</span>(inspect(<span class="String"><span class="String">&quot;</span>My name is <span class="String">&quot;</span></span> <span class="Keyword">+</span> <span class="Variable">this</span>.<span class="LibraryConstant">name</span>));
-</pre><script>window.example20 = "launch() if ignition is on\n\nvolume = 10 if band isnt SpinalTap\n\nletTheWildRumpusBegin() unless answer is no\n\nif car.speed < limit then accelerate()\n\nwinner = yes if pick in [47, 92, 13]\n\nprint inspect \"My name is \" + @name\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example20);'>load</div><br class='clear' /></div>
+</pre><script>window.example20 = "launch() if ignition is on\n\nvolume = 10 if band isnt SpinalTap\n\nletTheWildRumpusBegin() unless answer is no\n\nif car.speed < limit then accelerate()\n\nwinner = yes if pick in [47, 92, 13]\n\nprint inspect \"My name is #{@name}\"\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example20);'>load</div><br class='clear' /></div>

    <p>
      <b class="header">The Existential Operator</b>
@@ -1209,21 +1211,17 @@ footprints <span class="Keyword">=</span> yeti <span class="Keyword">?</span> <s
 <span class="Keyword">if</span> ((<span class="Keyword">typeof</span> mind <span class="Keyword">!</span><span class="Keyword">==</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> mind <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span>) <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> <span class="Keyword">!</span>(<span class="Keyword">typeof</span> world <span class="Keyword">!</span><span class="Keyword">==</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> world <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span>)) {
  solipsism <span class="Keyword">=</span> <span class="BuiltInConstant">true</span>;
 }
-<span class="Keyword">if</span> (<span class="Keyword">typeof</span> speed <span class="Keyword">!</span><span class="Keyword">==</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> speed <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span>) {
-  speed;
-} <span class="Keyword">else</span> {
+<span class="Keyword">if</span> (<span class="Keyword">typeof</span> speed <span class="Keyword">===</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">||</span> speed <span class="Keyword">===</span> <span class="BuiltInConstant">null</span>) {
  speed <span class="Keyword">=</span> <span class="Number">75</span>;
-};
+}
 footprints <span class="Keyword">=</span> <span class="Keyword">typeof</span> yeti <span class="Keyword">!</span><span class="Keyword">==</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> yeti <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span> ? yeti : <span class="String"><span class="String">&quot;</span>bear<span class="String">&quot;</span></span>;
 </pre><script>window.example21 = "solipsism = true if mind? and not world?\n\nspeed ?= 75\n\nfootprints = yeti ? \"bear\"\n\nalert footprints"</script><div class='minibutton load' onclick='javascript: loadConsole(example21);'>load</div><div class='minibutton ok' onclick='javascript: var footprints, solipsism;
 if ((typeof mind !== "undefined" && mind !== null) && !(typeof world !== "undefined" && world !== null)) {
  solipsism = true;
 }
-if (typeof speed !== "undefined" && speed !== null) {
-  speed;
-} else {
+if (typeof speed === "undefined" || speed === null) {
  speed = 75;
-};
+}
 footprints = typeof yeti !== "undefined" && yeti !== null ? yeti : "bear";;alert(footprints);'>run: footprints</div><br class='clear' /></div>
    <p>
      The accessor variant of the existential operator <tt>?.</tt> can be used to soak
@@ -1272,7 +1270,7 @@ zip <span class="Keyword">=</span> <span class="Keyword">typeof</span> lottery.d
  <span class="FunctionName">constructor</span><span class="Keyword">:</span> <span class="FunctionArgument">(@name)</span> <span class="Storage">-&gt;</span>

  <span class="FunctionName">move</span><span class="Keyword">:</span> <span class="FunctionArgument">(meters)</span> <span class="Storage">-&gt;</span>
-    alert <span class="Variable">@name</span> <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> moved <span class="String">&quot;</span></span> <span class="Keyword">+</span> meters <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span>m.<span class="String">&quot;</span></span>
+    alert <span class="Variable">@name</span> <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> moved <span class="String"><span class="String">#{</span>meters<span class="String">}</span></span>m.<span class="String">&quot;</span></span>

 <span class="Storage">class</span> <span class="TypeName">Snake</span><span class="InheritedClass"> <span class="Keyword">extends</span> Animal</span>
  <span class="FunctionName">move</span><span class="Keyword">:</span> <span class="Keyword">-</span><span class="Keyword">&gt;</span>
@@ -1307,15 +1305,15 @@ Animal <span class="Keyword">=</span> (<span class="Storage">function</span>() {
    <span class="Variable">this</span>.<span class="LibraryConstant">name</span> <span class="Keyword">=</span> name;
  }
  <span class="LibraryClassType">Animal</span>.<span class="LibraryConstant">prototype</span>.<span class="FunctionName">move</span> = <span class="Storage">function</span>(<span class="FunctionArgument">meters</span>) {
-    <span class="Keyword">return</span> <span class="LibraryFunction">alert</span>(<span class="Variable">this</span>.<span class="LibraryConstant">name</span> <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> moved <span class="String">&quot;</span></span> <span class="Keyword">+</span> meters <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span>m.<span class="String">&quot;</span></span>);
+    <span class="Keyword">return</span> <span class="LibraryFunction">alert</span>(<span class="Variable">this</span>.<span class="LibraryConstant">name</span> <span class="Keyword">+</span> (<span class="String"><span class="String">&quot;</span> moved <span class="String">&quot;</span></span> <span class="Keyword">+</span> meters <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span>m.<span class="String">&quot;</span></span>));
  };
  <span class="Keyword">return</span> Animal;
 })();
 Snake <span class="Keyword">=</span> (<span class="Storage">function</span>() {
+  __extends(Snake, Animal);
  <span class="Storage">function</span> <span class="FunctionName">Snake</span>() {
    Snake.__super__.<span class="LibraryConstant">constructor</span>.<span class="LibraryFunction">apply</span>(<span class="Variable">this</span>, arguments);
  }
-  __extends(Snake, Animal);
  <span class="LibraryClassType">Snake</span>.<span class="LibraryConstant">prototype</span>.<span class="FunctionName">move</span> = <span class="Storage">function</span>() {
    <span class="LibraryFunction">alert</span>(<span class="String"><span class="String">&quot;</span>Slithering...<span class="String">&quot;</span></span>);
    <span class="Keyword">return</span> Snake.__super__.move.<span class="LibraryFunction">call</span>(<span class="Variable">this</span>, <span class="Number">5</span>);
@@ -1323,10 +1321,10 @@ Snake <span class="Keyword">=</span> (<span class="Storage">function</span>() {
  <span class="Keyword">return</span> Snake;
 })();
 Horse <span class="Keyword">=</span> (<span class="Storage">function</span>() {
+  __extends(Horse, Animal);
  <span class="Storage">function</span> <span class="FunctionName">Horse</span>() {
    Horse.__super__.<span class="LibraryConstant">constructor</span>.<span class="LibraryFunction">apply</span>(<span class="Variable">this</span>, arguments);
  }
-  __extends(Horse, Animal);
  <span class="LibraryClassType">Horse</span>.<span class="LibraryConstant">prototype</span>.<span class="FunctionName">move</span> = <span class="Storage">function</span>() {
    <span class="LibraryFunction">alert</span>(<span class="String"><span class="String">&quot;</span>Galloping...<span class="String">&quot;</span></span>);
    <span class="Keyword">return</span> Horse.__super__.move.<span class="LibraryFunction">call</span>(<span class="Variable">this</span>, <span class="Number">45</span>);
@@ -1337,7 +1335,7 @@ sam <span class="Keyword">=</span> <span class="Keyword">new</span> <span class=
 tom <span class="Keyword">=</span> <span class="Keyword">new</span> <span class="TypeName">Horse</span>(<span class="String"><span class="String">&quot;</span>Tommy the Palomino<span class="String">&quot;</span></span>);
 sam.move();
 tom.move();
-</pre><script>window.example23 = "class Animal\n  constructor: (@name) ->\n\n  move: (meters) ->\n    alert @name + \" moved \" + meters + \"m.\"\n\nclass Snake extends Animal\n  move: ->\n    alert \"Slithering...\"\n    super 5\n\nclass Horse extends Animal\n  move: ->\n    alert \"Galloping...\"\n    super 45\n\nsam = new Snake \"Sammy the Python\"\ntom = new Horse \"Tommy the Palomino\"\n\nsam.move()\ntom.move()\n\n\n\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example23);'>load</div><div class='minibutton ok' onclick='javascript: var Animal, Horse, Snake, sam, tom;
+</pre><script>window.example23 = "class Animal\n  constructor: (@name) ->\n\n  move: (meters) ->\n    alert @name + \" moved #{meters}m.\"\n\nclass Snake extends Animal\n  move: ->\n    alert \"Slithering...\"\n    super 5\n\nclass Horse extends Animal\n  move: ->\n    alert \"Galloping...\"\n    super 45\n\nsam = new Snake \"Sammy the Python\"\ntom = new Horse \"Tommy the Palomino\"\n\nsam.move()\ntom.move()\n\n\n\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example23);'>load</div><div class='minibutton ok' onclick='javascript: var Animal, Horse, Snake, sam, tom;
 var __hasProp = Object.prototype.hasOwnProperty, __extends = function(child, parent) {
  for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; }
  function ctor() { this.constructor = child; }
@@ -1351,15 +1349,15 @@ Animal = (function() {
    this.name = name;
  }
  Animal.prototype.move = function(meters) {
-    return alert(this.name + " moved " + meters + "m.");
+    return alert(this.name + (" moved " + meters + "m."));
  };
  return Animal;
 })();
 Snake = (function() {
+  __extends(Snake, Animal);
  function Snake() {
    Snake.__super__.constructor.apply(this, arguments);
  }
-  __extends(Snake, Animal);
  Snake.prototype.move = function() {
    alert("Slithering...");
    return Snake.__super__.move.call(this, 5);
@@ -1367,10 +1365,10 @@ Snake = (function() {
  return Snake;
 })();
 Horse = (function() {
+  __extends(Horse, Animal);
  function Horse() {
    Horse.__super__.constructor.apply(this, arguments);
  }
-  __extends(Horse, Animal);
  Horse.prototype.move = function() {
    alert("Galloping...");
    return Horse.__super__.move.call(this, 45);
@@ -1399,7 +1397,7 @@ tom.move();;'>run</div><br class='clear' /></div>
  return this.replace(/_/g, "-");
 };;alert("one_two".dasherize());'>run: "one_two".dasherize()</div><br class='clear' /></div>
    <p>
-      Finally class definitions are blocks of executable code, which make for interesting
+      Finally, class definitions are blocks of executable code, which make for interesting
      metaprogramming possibilities. Because in the context of a class definition,
      <tt>this</tt> is the class object itself (the constructor function), you
      can assign static properties by using <br /><tt>@property: value</tt>, and call
@@ -1513,7 +1511,7 @@ _ref = tag.split(""), open = _ref[0], contents = 3 <= _ref.length ? __slice.call
      <b class="header">Function binding</b>
      In JavaScript, the <tt>this</tt> keyword is dynamically scoped to mean the
      object that the current function is attached to. If you pass a function as
-      as callback, or attach it to a different object, the original value of <tt>this</tt>
+      a callback or attach it to a different object, the original value of <tt>this</tt>
      will be lost. If you're not familiar with this behavior,
      <a href="http://www.digital-web.com/articles/scope_in_javascript/">this Digital Web article</a>
      gives a good overview of the quirks.
@@ -1725,16 +1723,16 @@ html <span class="Keyword">=</span> <span class="String"><span class="String">'<
      are preserved in the generated code.
    </p>
    <div class='code'><pre class="idle"><span class="Comment"><span class="Comment">###</span></span>
-<span class="Comment">CoffeeScript Compiler v1.1.0</span>
+<span class="Comment">CoffeeScript Compiler v1.1.2</span>
 <span class="Comment">Released under the MIT License</span>
 <span class="Comment"><span class="Comment">###</span></span>


 </pre><pre class="idle"><span class="Comment"><span class="Comment">/*</span></span>
-<span class="Comment">CoffeeScript Compiler v1.1.0</span>
+<span class="Comment">CoffeeScript Compiler v1.1.2</span>
 <span class="Comment">Released under the MIT License</span>
 <span class="Comment"><span class="Comment">*/</span></span>
-</pre><script>window.example37 = "###\nCoffeeScript Compiler v1.1.0\nReleased under the MIT License\n###\n\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example37);'>load</div><br class='clear' /></div>
+</pre><script>window.example37 = "###\nCoffeeScript Compiler v1.1.2\nReleased under the MIT License\n###\n\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example37);'>load</div><br class='clear' /></div>

    <p>
      <span id="regexes" class="bookmark"></span>
@@ -1826,7 +1824,7 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="

    <p>
      In fact, the little bit of glue script that runs "Try CoffeeScript" above,
-      as well as jQuery for the menu, is implemented in just this way.
+      as well as the jQuery for the menu, is implemented in just this way.
      View source and look at the bottom of the page to see the example.
      Including the script also gives you access to <tt>CoffeeScript.compile()</tt>
      so you can pop open Firebug and try compiling some strings.
@@ -1936,11 +1934,35 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="
      Change Log
    </h2>
    
+    <p>
+      <b class="header" style="margin-top: 20px;">
+        <a href="https://github.com/jashkenas/coffee-script/compare/1.1.1...1.1.2">1.1.2</a>
+        <span class="timestamp"> &ndash; <small>August 4, 2011</small></span>
+      </b>
+      We now use the native <tt>Function.prototype.bind</tt> for bound function
+      literals where available.
+      Fixes for: block comment formatting, <tt>?=</tt> compilation, implicit calls
+      against control structures, implicit invocation of a try/catch block,
+      variadic arguments leaking from local scope, line numbers in syntax errors
+      following heregexes, property access on parenthesized number literals,
+      bound class methods and super with reserved names, a REPL overhaul, 
+      consecutive compiled semicolons, block comments in implicitly called objects,
+      and a Chrome bug.
+    </p>
+    
+    <p>
+      <b class="header" style="margin-top: 20px;">1.1.1
+        <span class="timestamp"> &ndash; <small>May 10, 2011</small></span>
+      </b>
+      Bugfix release for classes with external constructor functions, see 
+      issue #1182.
+    </p>
+    
    <p>
      <b class="header" style="margin-top: 20px;">1.1.0
        <span class="timestamp"> &ndash; <small>May 1, 2011</small></span>
      </b>
-      When running via <tt>coffee</tt> executable, <tt>process.argv</tt> and 
+      When running via the <tt>coffee</tt> executable, <tt>process.argv</tt> and 
      friends now report <tt>coffee</tt> instead of <tt>node</tt>.
      Better compatibility with <b>Node.js 0.4.x</b> module lookup changes.
      The output in the REPL is now colorized, like Node's is.
@@ -1951,7 +1973,6 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="
      Fixed an edge-case infinite loop in <tt>addImplicitParentheses</tt>.
      Fixed exponential slowdown with long chains of function calls.
      Globals no longer leak into the CoffeeScript REPL.
-      Function calls can be used as default values for parameters. 
      Splatted parameters are declared local to the function.
    </p>

--- a/lib/coffee-script.js
+++ b/lib/coffee-script.js
@@ -1,8 +1,8 @@
 (function() {
-  var Lexer, RESERVED, compile, fs, lexer, parser, path, vm, _ref;
+  var Lexer, RESERVED, compile, fs, lexer, parser, path, _ref;
+  var __hasProp = Object.prototype.hasOwnProperty;
  fs = require('fs');
  path = require('path');
-  vm = require('vm');
  _ref = require('./lexer'), Lexer = _ref.Lexer, RESERVED = _ref.RESERVED;
  parser = require('./parser').parser;
  if (require.extensions) {
@@ -18,7 +18,7 @@
      return compile(content);
    });
  }
-  exports.VERSION = '1.1.0';
+  exports.VERSION = '1.1.2';
  exports.RESERVED = RESERVED;
  exports.helpers = require('./helpers');
  exports.compile = compile = function(code, options) {
@@ -45,48 +45,76 @@
    }
  };
  exports.run = function(code, options) {
-    var Module, root;
-    root = module;
-    while (root.parent) {
-      root = root.parent;
-    }
-    root.filename = process.argv[1] = options.filename ? fs.realpathSync(options.filename) : '.';
-    if (root.moduleCache) {
-      root.moduleCache = {};
-    }
+    var Module, mainModule;
+    mainModule = require.main;
+    mainModule.filename = process.argv[1] = options.filename ? fs.realpathSync(options.filename) : '.';
+    mainModule.moduleCache && (mainModule.moduleCache = {});
    if (process.binding('natives').module) {
      Module = require('module').Module;
-      root.paths = Module._nodeModulePaths(path.dirname(options.filename));
+      mainModule.paths = Module._nodeModulePaths(path.dirname(options.filename));
    }
-    if (path.extname(root.filename) !== '.coffee' || require.extensions) {
-      return root._compile(compile(code, options), root.filename);
+    if (path.extname(mainModule.filename) !== '.coffee' || require.extensions) {
+      return mainModule._compile(compile(code, options), mainModule.filename);
    } else {
-      return root._compile(code, root.filename);
+      return mainModule._compile(code, mainModule.filename);
    }
  };
  exports.eval = function(code, options) {
-    var g, js, sandbox;
+    var Module, Script, js, k, o, r, sandbox, v, _i, _len, _module, _ref2, _ref3, _ref4, _require;
    if (options == null) {
      options = {};
    }
-    sandbox = options.sandbox;
-    if (!sandbox) {
-      sandbox = {
-        require: require,
-        module: {
-          exports: {}
-        }
-      };
-      for (g in global) {
-        sandbox[g] = global[g];
-      }
-      sandbox.global = sandbox;
-      sandbox.global.global = sandbox.global.root = sandbox.global.GLOBAL = sandbox;
+    if (!(code = code.trim())) {
+      return;
+    }
+    if (_ref2 = require('vm'), Script = _ref2.Script, _ref2) {
+      sandbox = Script.createContext();
+      sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox;
+      if (options.sandbox != null) {
+        if (options.sandbox instanceof sandbox.constructor) {
+          sandbox = options.sandbox;
+        } else {
+          _ref3 = options.sandbox;
+          for (k in _ref3) {
+            if (!__hasProp.call(_ref3, k)) continue;
+            v = _ref3[k];
+            sandbox[k] = v;
+          }
+        }
+      }
+      sandbox.__filename = options.filename || 'eval';
+      sandbox.__dirname = path.dirname(sandbox.__filename);
+      if (!(sandbox.module || sandbox.require)) {
+        Module = require('module');
+        sandbox.module = _module = new Module(options.modulename || 'eval');
+        sandbox.require = _require = function(path) {
+          return Module._load(path, _module);
+        };
+        _module.filename = sandbox.__filename;
+        _ref4 = Object.getOwnPropertyNames(require);
+        for (_i = 0, _len = _ref4.length; _i < _len; _i++) {
+          r = _ref4[_i];
+          _require[r] = require[r];
+        }
+        _require.paths = _module.paths = Module._nodeModulePaths(process.cwd());
+        _require.resolve = function(request) {
+          return Module._resolveFilename(request, _module);
+        };
+      }
+    }
+    o = {};
+    for (k in options) {
+      if (!__hasProp.call(options, k)) continue;
+      v = options[k];
+      o[k] = v;
+    }
+    o.bare = true;
+    js = compile(code, o);
+    if (Script) {
+      return Script.runInContext(js, sandbox);
+    } else {
+      return eval(js);
    }
-    sandbox.__filename = options.filename || 'eval';
-    sandbox.__dirname = path.dirname(sandbox.__filename);
-    js = compile("_=(" + (code.trim()) + ")", options);
-    return vm.runInNewContext(js, sandbox, sandbox.__filename);
  };
  lexer = new Lexer;
  parser.lexer = {
--- a/lib/command.js
+++ b/lib/command.js
@@ -15,7 +15,7 @@
    return process.binding('stdio').writeError(line + '\n');
  };
  BANNER = 'Usage: coffee [options] path/to/script.coffee';
-  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'], ['-j', '--join [FILE]', 'concatenate the scripts before compiling'], ['-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'], ['-r', '--require [FILE*]', 'require a library before executing your script'], ['-b', '--bare', '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'], ['--nodejs [ARGS]', 'pass options through to the "node" binary'], ['-v', '--version', 'display CoffeeScript version'], ['-h', '--help', 'display this help message']];
+  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'], ['-j', '--join [FILE]', 'concatenate the scripts before compiling'], ['-w', '--watch', 'watch scripts for changes, and recompile'], ['-p', '--print', 'print the compiled JavaScript to stdout'], ['-l', '--lint', 'pipe the compiled JavaScript through JavaScript Lint'], ['-s', '--stdio', 'listen for and compile scripts over stdio'], ['-e', '--eval', 'compile a string from the command line'], ['-r', '--require [FILE*]', 'require a library before executing your script'], ['-b', '--bare', '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'], ['--nodejs [ARGS]', 'pass options through to the "node" binary'], ['-v', '--version', 'display CoffeeScript version'], ['-h', '--help', 'display this help message']];
  opts = {};
  sources = [];
  contents = [];
@@ -51,17 +51,35 @@
    }
    process.ARGV = process.argv = process.argv.slice(0, 2).concat(opts.literals);
    process.argv[0] = 'coffee';
-    process.execPath = process.mainModule.filename;
+    process.execPath = require.main.filename;
    return compileScripts();
  };
  compileScripts = function() {
-    var base, compile, source, _i, _len, _results;
-    _results = [];
+    var base, compile, source, unprocessed, _i, _j, _len, _len2, _results;
+    unprocessed = [];
    for (_i = 0, _len = sources.length; _i < _len; _i++) {
      source = sources[_i];
+      unprocessed[sources.indexOf(source)] = 1;
+    }
+    _results = [];
+    for (_j = 0, _len2 = sources.length; _j < _len2; _j++) {
+      source = sources[_j];
      base = path.join(source);
-      compile = function(source, topLevel) {
+      compile = function(source, sourceIndex, topLevel) {
+        var remaining_files;
+        remaining_files = function() {
+          var total, x, _k, _len3;
+          total = 0;
+          for (_k = 0, _len3 = unprocessed.length; _k < _len3; _k++) {
+            x = unprocessed[_k];
+            total += x;
+          }
+          return total;
+        };
        return path.exists(source, function(exists) {
+          if (topLevel && !exists && source.slice(-7) !== '.coffee') {
+            return compile("" + source + ".coffee", sourceIndex, topLevel);
+          }
          if (topLevel && !exists) {
            throw new Error("File not found: " + source);
          }
@@ -71,19 +89,26 @@
            }
            if (stats.isDirectory()) {
              return fs.readdir(source, function(err, files) {
-                var file, _j, _len2, _results2;
-                _results2 = [];
-                for (_j = 0, _len2 = files.length; _j < _len2; _j++) {
-                  file = files[_j];
-                  _results2.push(compile(path.join(source, file)));
+                var file, _k, _len3;
+                if (err) {
+                  throw err;
                }
-                return _results2;
+                unprocessed[sourceIndex] += files.length;
+                for (_k = 0, _len3 = files.length; _k < _len3; _k++) {
+                  file = files[_k];
+                  compile(path.join(source, file), sourceIndex);
+                }
+                return unprocessed[sourceIndex] -= 1;
              });
            } else if (topLevel || path.extname(source) === '.coffee') {
              fs.readFile(source, function(err, code) {
+                if (err) {
+                  throw err;
+                }
+                unprocessed[sourceIndex] -= 1;
                if (opts.join) {
-                  contents[sources.indexOf(source)] = code.toString();
-                  if (helpers.compact(contents).length > 0) {
+                  contents[sourceIndex] = helpers.compact([contents[sourceIndex], code.toString()]).join('\n');
+                  if (helpers.compact(contents).length > 0 && remaining_files() === 0) {
                    return compileJoin();
                  }
                } else {
@@ -93,11 +118,13 @@
              if (opts.watch && !opts.join) {
                return watch(source, base);
              }
+            } else {
+              return unprocessed[sourceIndex] -= 1;
            }
          });
        });
      };
-      _results.push(compile(source, true));
+      _results.push(compile(source, sources.indexOf(source), true));
    }
    return _results;
  };
--- a/lib/lexer.js
+++ b/lib/lexer.js
@@ -48,7 +48,7 @@
      }
      forcedIdentifier = colon || (prev = last(this.tokens)) && (((_ref2 = prev[0]) === '.' || _ref2 === '?.' || _ref2 === '::') || !prev.spaced && prev[0] === '@');
      tag = 'IDENTIFIER';
-      if (__indexOf.call(JS_KEYWORDS, id) >= 0 || !forcedIdentifier && __indexOf.call(COFFEE_KEYWORDS, id) >= 0) {
+      if (!forcedIdentifier && (__indexOf.call(JS_KEYWORDS, id) >= 0 || __indexOf.call(COFFEE_KEYWORDS, id) >= 0)) {
        tag = id.toUpperCase();
        if (tag === 'WHEN' && (_ref3 = this.tag(), __indexOf.call(LINE_BREAK, _ref3) >= 0)) {
          tag = 'LEADING_WHEN';
@@ -194,12 +194,14 @@
      return script.length;
    };
    Lexer.prototype.regexToken = function() {
-      var match, prev, regex, _ref2;
+      var length, match, prev, regex, _ref2;
      if (this.chunk.charAt(0) !== '/') {
        return 0;
      }
      if (match = HEREGEX.exec(this.chunk)) {
-        return this.heregexToken(match);
+        length = this.heregexToken(match);
+        this.line += count(match[0], '\n');
+        return length;
      }
      prev = last(this.tokens);
      if (prev && (_ref2 = prev[0], __indexOf.call((prev.spaced ? NOT_REGEX : NOT_SPACED_REGEX), _ref2) >= 0)) {
@@ -442,6 +444,8 @@
            } else if (tok[0] === '(') {
              tok[0] = 'PARAM_START';
              return this;
+            } else {
+              return this;
            }
        }
      }
@@ -457,7 +461,7 @@
      throw SyntaxError("Reserved word \"" + (this.value()) + "\" on line " + (this.line + 1) + " can't be assigned");
    };
    Lexer.prototype.balancedString = function(str, end) {
-      var i, letter, prev, stack, _ref2;
+      var i, letter, match, prev, stack, _ref2;
      stack = [end];
      for (i = 1, _ref2 = str.length; 1 <= _ref2 ? i < _ref2 : i > _ref2; 1 <= _ref2 ? i++ : i--) {
        switch (letter = str.charAt(i)) {
@@ -474,6 +478,8 @@
        }
        if (end === '}' && (letter === '"' || letter === "'")) {
          stack.push(end = letter);
+        } else if (end === '}' && letter === '/' && (match = HEREGEX.exec(str.slice(i)) || REGEX.exec(str.slice(i)))) {
+          i += match[0].length - 1;
        } else if (end === '}' && letter === '{') {
          stack.push(end = '}');
        } else if (end === '"' && prev === '#' && letter === '{') {
@@ -615,7 +621,7 @@
  JS_FORBIDDEN = JS_KEYWORDS.concat(RESERVED);
  exports.RESERVED = RESERVED.concat(JS_KEYWORDS).concat(COFFEE_KEYWORDS);
  IDENTIFIER = /^([$A-Za-z_\x7f-\uffff][$\w\x7f-\uffff]*)([^\n\S]*:(?!:))?/;
-  NUMBER = /^0x[\da-f]+|^(?:\d+(\.\d+)?|\.\d+)(?:e[+-]?\d+)?/i;
+  NUMBER = /^0x[\da-f]+|^\d*\.?\d+(?:e[+-]?\d+)?/i;
  HEREDOC = /^("""|''')([\s\S]*?)(?:\n[^\n\S]*)?\1/;
  OPERATOR = /^(?:[-=]>|[-+*\/%<>&|^!?=]=|>>>=?|([-+:])\1|([&|<>])\2=?|\?\.|\.{2,3})/;
  WHITESPACE = /^[^\n\S]+/;
--- a/lib/nodes.js
+++ b/lib/nodes.js
@@ -1,5 +1,5 @@
 (function() {
-  var Access, Arr, Assign, Base, Block, Call, Class, Closure, Code, Comment, Existence, Extends, For, IDENTIFIER, IS_STRING, If, In, Index, LEVEL_ACCESS, LEVEL_COND, LEVEL_LIST, LEVEL_OP, LEVEL_PAREN, LEVEL_TOP, Literal, NEGATE, NO, Obj, Op, Param, Parens, Push, Range, Return, SIMPLENUM, Scope, Slice, Splat, Switch, TAB, THIS, Throw, Try, UTILITIES, Value, While, YES, compact, del, ends, extend, flatten, last, merge, multident, starts, unfoldSoak, utility, _ref;
+  var Access, Arr, Assign, Base, Block, Call, Class, Closure, Code, Comment, Existence, Extends, For, IDENTIFIER, IDENTIFIER_STR, IS_STRING, If, In, Index, LEVEL_ACCESS, LEVEL_COND, LEVEL_LIST, LEVEL_OP, LEVEL_PAREN, LEVEL_TOP, Literal, METHOD_DEF, NEGATE, NO, Obj, Op, Param, Parens, Push, Range, Return, SIMPLENUM, Scope, Slice, Splat, Switch, TAB, THIS, Throw, Try, UTILITIES, Value, While, YES, compact, del, ends, extend, flatten, last, merge, multident, starts, unfoldSoak, utility, _ref;
  var __hasProp = Object.prototype.hasOwnProperty, __extends = function(child, parent) {
    for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; }
    function ctor() { this.constructor = child; }
@@ -7,7 +7,12 @@
    child.prototype = new ctor;
    child.__super__ = parent.prototype;
    return child;
-  }, __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+  }, __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; }, __indexOf = Array.prototype.indexOf || function(item) {
+    for (var i = 0, l = this.length; i < l; i++) {
+      if (this[i] === item) return i;
+    }
+    return -1;
+  };
  Scope = require('./scope').Scope;
  _ref = require('./helpers'), compact = _ref.compact, flatten = _ref.flatten, extend = _ref.extend, merge = _ref.merge, del = _ref.del, starts = _ref.starts, ends = _ref.ends, last = _ref.last;
  exports.extend = extend;
@@ -63,9 +68,9 @@
      }
    };
    Base.prototype.compileLoopReference = function(o, name) {
-      var src, tmp, _ref2;
+      var src, tmp;
      src = tmp = this.compile(o, LEVEL_LIST);
-      if (!((-Infinity < (_ref2 = +src) && _ref2 < Infinity) || IDENTIFIER.test(src) && o.scope.check(src, true))) {
+      if (!((-Infinity < +src && +src < Infinity) || IDENTIFIER.test(src) && o.scope.check(src, true))) {
        src = "" + (tmp = o.scope.freeVariable(name)) + " = " + src;
      }
      return [src, tmp];
@@ -167,10 +172,10 @@
    return Base;
  })();
  exports.Block = Block = (function() {
+    __extends(Block, Base);
    function Block(nodes) {
      this.expressions = compact(flatten(nodes || []));
    }
-    __extends(Block, Base);
    Block.prototype.children = ['expressions'];
    Block.prototype.push = function(node) {
      this.expressions.push(node);
@@ -249,7 +254,9 @@
        node = _ref2[_i];
        node = node.unwrapAll();
        node = node.unfoldSoak(o) || node;
-        if (top) {
+        if (node instanceof Block) {
+          codes.push(node.compileNode(o));
+        } else if (top) {
          node.front = true;
          code = node.compile(o);
          codes.push(node.isStatement(o) ? code : this.tab + code + ';');
@@ -280,7 +287,7 @@
      }
    };
    Block.prototype.compileWithDeclarations = function(o) {
-      var code, exp, i, post, rest, scope, _len, _ref2;
+      var assigns, code, declars, exp, i, post, rest, scope, _len, _ref2;
      code = post = '';
      _ref2 = this.expressions;
      for (i = 0, _len = _ref2.length; i < _len; i++) {
@@ -301,10 +308,15 @@
      post = this.compileNode(o);
      scope = o.scope;
      if (scope.expressions === this) {
-        if (o.scope.hasDeclarations()) {
+        declars = o.scope.hasDeclarations();
+        assigns = scope.hasAssignments;
+        if ((declars || assigns) && i) {
+          code += '\n';
+        }
+        if (declars) {
          code += "" + this.tab + "var " + (scope.declaredVariables().join(', ')) + ";\n";
        }
-        if (scope.hasAssignments) {
+        if (assigns) {
          code += "" + this.tab + "var " + (multident(scope.assignedVariables().join(', '), this.tab)) + ";\n";
        }
      }
@@ -319,10 +331,10 @@
    return Block;
  })();
  exports.Literal = Literal = (function() {
+    __extends(Literal, Base);
    function Literal(value) {
      this.value = value;
    }
-    __extends(Literal, Base);
    Literal.prototype.makeReturn = function() {
      if (this.isStatement()) {
        return this;
@@ -366,12 +378,12 @@
    return Literal;
  })();
  exports.Return = Return = (function() {
+    __extends(Return, Base);
    function Return(expr) {
      if (expr && !expr.unwrap().isUndefined) {
        this.expression = expr;
      }
    }
-    __extends(Return, Base);
    Return.prototype.children = ['expression'];
    Return.prototype.isStatement = YES;
    Return.prototype.makeReturn = THIS;
@@ -391,6 +403,7 @@
    return Return;
  })();
  exports.Value = Value = (function() {
+    __extends(Value, Base);
    function Value(base, props, tag) {
      if (!props && base instanceof Value) {
        return base;
@@ -402,7 +415,6 @@
      }
      return this;
    }
-    __extends(Value, Base);
    Value.prototype.children = ['base', 'properties'];
    Value.prototype.push = function(prop) {
      this.properties.push(prop);
@@ -492,8 +504,8 @@
      this.base.front = this.front;
      props = this.properties;
      code = this.base.compile(o, props.length ? LEVEL_ACCESS : null);
-      if (props[0] instanceof Access && this.isSimpleNumber()) {
-        code = "(" + code + ")";
+      if ((this.base instanceof Parens || props.length) && SIMPLENUM.test(code)) {
+        code = "" + code + ".";
      }
      for (_i = 0, _len = props.length; _i < _len; _i++) {
        prop = props[_i];
@@ -536,10 +548,10 @@
    return Value;
  })();
  exports.Comment = Comment = (function() {
+    __extends(Comment, Base);
    function Comment(comment) {
      this.comment = comment;
    }
-    __extends(Comment, Base);
    Comment.prototype.isStatement = YES;
    Comment.prototype.makeReturn = THIS;
    Comment.prototype.compileNode = function(o, level) {
@@ -553,6 +565,7 @@
    return Comment;
  })();
  exports.Call = Call = (function() {
+    __extends(Call, Base);
    function Call(variable, args, soak) {
      this.args = args != null ? args : [];
      this.soak = soak;
@@ -560,12 +573,11 @@
      this.isSuper = variable === 'super';
      this.variable = this.isSuper ? null : variable;
    }
-    __extends(Call, Base);
    Call.prototype.children = ['variable', 'args'];
    Call.prototype.newInstance = function() {
      var base;
      base = this.variable.base || this.variable;
-      if (base instanceof Call) {
+      if (base instanceof Call && !base.isNew) {
        base.newInstance();
      } else {
        this.isNew = true;
@@ -579,11 +591,11 @@
        throw SyntaxError('cannot call super outside of a function.');
      }
      name = method.name;
-      if (!name) {
+      if (name == null) {
        throw SyntaxError('cannot call super on an anonymous function.');
      }
      if (method.klass) {
-        return "" + method.klass + ".__super__." + name;
+        return (new Value(new Literal(method.klass), [new Access(new Literal("__super__")), new Access(new Literal(name))])).compile(o);
      } else {
        return "" + name + ".__super__.constructor";
      }
@@ -650,7 +662,7 @@
        _ref2 = node.base.properties;
        for (_j = 0, _len2 = _ref2.length; _j < _len2; _j++) {
          prop = _ref2[_j];
-          if (prop instanceof Assign) {
+          if (prop instanceof Assign || prop instanceof Comment) {
            if (!obj) {
              nodes.push(obj = new Obj(properties = [], true));
            }
@@ -720,11 +732,11 @@
    return Call;
  })();
  exports.Extends = Extends = (function() {
+    __extends(Extends, Base);
    function Extends(child, parent) {
      this.child = child;
      this.parent = parent;
    }
-    __extends(Extends, Base);
    Extends.prototype.children = ['child', 'parent'];
    Extends.prototype.compile = function(o) {
      utility('hasProp');
@@ -733,27 +745,27 @@
    return Extends;
  })();
  exports.Access = Access = (function() {
+    __extends(Access, Base);
    function Access(name, tag) {
      this.name = name;
      this.name.asKey = true;
      this.proto = tag === 'proto' ? '.prototype' : '';
      this.soak = tag === 'soak';
    }
-    __extends(Access, Base);
    Access.prototype.children = ['name'];
    Access.prototype.compile = function(o) {
      var name;
      name = this.name.compile(o);
-      return this.proto + (IS_STRING.test(name) ? "[" + name + "]" : "." + name);
+      return this.proto + (IDENTIFIER.test(name) ? "." + name : "[" + name + "]");
    };
    Access.prototype.isComplex = NO;
    return Access;
  })();
  exports.Index = Index = (function() {
+    __extends(Index, Base);
    function Index(index) {
      this.index = index;
    }
-    __extends(Index, Base);
    Index.prototype.children = ['index'];
    Index.prototype.compile = function(o) {
      return (this.proto ? '.prototype' : '') + ("[" + (this.index.compile(o, LEVEL_PAREN)) + "]");
@@ -764,8 +776,8 @@
    return Index;
  })();
  exports.Range = Range = (function() {
-    Range.prototype.children = ['from', 'to'];
    __extends(Range, Base);
+    Range.prototype.children = ['from', 'to'];
    function Range(from, to, tag) {
      this.from = from;
      this.to = to;
@@ -773,58 +785,50 @@
      this.equals = this.exclusive ? '' : '=';
    }
    Range.prototype.compileVariables = function(o) {
-      var parts, _ref2, _ref3, _ref4;
+      var step, _ref2, _ref3, _ref4, _ref5;
      o = merge(o, {
        top: true
      });
-      _ref2 = this.from.cache(o, LEVEL_LIST), this.from = _ref2[0], this.fromVar = _ref2[1];
-      _ref3 = this.to.cache(o, LEVEL_LIST), this.to = _ref3[0], this.toVar = _ref3[1];
-      _ref4 = [this.fromVar.match(SIMPLENUM), this.toVar.match(SIMPLENUM)], this.fromNum = _ref4[0], this.toNum = _ref4[1];
-      parts = [];
-      if (this.from !== this.fromVar) {
-        parts.push(this.from);
+      _ref2 = this.from.cache(o, LEVEL_LIST), this.fromC = _ref2[0], this.fromVar = _ref2[1];
+      _ref3 = this.to.cache(o, LEVEL_LIST), this.toC = _ref3[0], this.toVar = _ref3[1];
+      if (step = del(o, 'step')) {
+        _ref4 = step.cache(o, LEVEL_LIST), this.step = _ref4[0], this.stepVar = _ref4[1];
      }
-      if (this.to !== this.toVar) {
-        return parts.push(this.to);
+      _ref5 = [this.fromVar.match(SIMPLENUM), this.toVar.match(SIMPLENUM)], this.fromNum = _ref5[0], this.toNum = _ref5[1];
+      if (this.stepVar) {
+        return this.stepNum = this.stepVar.match(SIMPLENUM);
      }
    };
    Range.prototype.compileNode = function(o) {
-      var compare, cond, idx, incr, step, vars;
-      this.compileVariables(o);
+      var cond, condPart, from, gt, idx, known, lt, stepPart, to, varPart, _ref2, _ref3;
+      if (!this.fromVar) {
+        this.compileVariables(o);
+      }
      if (!o.index) {
        return this.compileArray(o);
      }
-      if (this.fromNum && this.toNum) {
-        return this.compileSimple(o);
-      }
+      known = this.fromNum && this.toNum;
      idx = del(o, 'index');
-      step = del(o, 'step');
-      vars = ("" + idx + " = " + this.from) + (this.to !== this.toVar ? ", " + this.to : '');
-      cond = "" + this.fromVar + " <= " + this.toVar;
-      compare = "" + cond + " ? " + idx + " <" + this.equals + " " + this.toVar + " : " + idx + " >" + this.equals + " " + this.toVar;
-      incr = step ? "" + idx + " += " + (step.compile(o)) : "" + cond + " ? " + idx + "++ : " + idx + "--";
-      return "" + vars + "; " + compare + "; " + incr;
-    };
-    Range.prototype.compileSimple = function(o) {
-      var from, idx, step, to, _ref2;
-      _ref2 = [+this.fromNum, +this.toNum], from = _ref2[0], to = _ref2[1];
-      idx = del(o, 'index');
-      step = del(o, 'step');
-      step && (step = "" + idx + " += " + (step.compile(o)));
-      if (from <= to) {
-        return "" + idx + " = " + from + "; " + idx + " <" + this.equals + " " + to + "; " + (step || ("" + idx + "++"));
-      } else {
-        return "" + idx + " = " + from + "; " + idx + " >" + this.equals + " " + to + "; " + (step || ("" + idx + "--"));
+      varPart = "" + idx + " = " + this.fromC;
+      if (this.toC !== this.toVar) {
+        varPart += ", " + this.toC;
      }
+      if (this.step !== this.stepVar) {
+        varPart += ", " + this.step;
+      }
+      _ref2 = ["" + idx + " <" + this.equals, "" + idx + " >" + this.equals], lt = _ref2[0], gt = _ref2[1];
+      condPart = this.stepNum ? condPart = +this.stepNum > 0 ? "" + lt + " " + this.toVar : "" + gt + " " + this.toVar : known ? ((_ref3 = [+this.fromNum, +this.toNum], from = _ref3[0], to = _ref3[1], _ref3), condPart = from <= to ? "" + lt + " " + to : "" + gt + " " + to) : (cond = "" + this.fromVar + " <= " + this.toVar, condPart = "" + cond + " ? " + lt + " " + this.toVar + " : " + gt + " " + this.toVar);
+      stepPart = this.stepVar ? "" + idx + " += " + this.stepVar : known ? from <= to ? "" + idx + "++" : "" + idx + "--" : "" + cond + " ? " + idx + "++ : " + idx + "--";
+      return "" + varPart + "; " + condPart + "; " + stepPart;
    };
    Range.prototype.compileArray = function(o) {
-      var body, cond, i, idt, post, pre, range, result, vars, _i, _ref2, _ref3, _results;
+      var args, body, cond, hasArgs, i, idt, post, pre, range, result, vars, _i, _ref2, _ref3, _results;
      if (this.fromNum && this.toNum && Math.abs(this.fromNum - this.toNum) <= 20) {
        range = (function() {
          _results = [];
          for (var _i = _ref2 = +this.fromNum, _ref3 = +this.toNum; _ref2 <= _ref3 ? _i <= _ref3 : _i >= _ref3; _ref2 <= _ref3 ? _i++ : _i--){ _results.push(_i); }
          return _results;
-        }).apply(this, arguments);
+        }).apply(this);
        if (this.exclusive) {
          range.pop();
        }
@@ -836,20 +840,28 @@
      pre = "\n" + idt + result + " = [];";
      if (this.fromNum && this.toNum) {
        o.index = i;
-        body = this.compileSimple(o);
+        body = this.compileNode(o);
      } else {
-        vars = ("" + i + " = " + this.from) + (this.to !== this.toVar ? ", " + this.to : '');
+        vars = ("" + i + " = " + this.fromC) + (this.toC !== this.toVar ? ", " + this.toC : '');
        cond = "" + this.fromVar + " <= " + this.toVar;
        body = "var " + vars + "; " + cond + " ? " + i + " <" + this.equals + " " + this.toVar + " : " + i + " >" + this.equals + " " + this.toVar + "; " + cond + " ? " + i + "++ : " + i + "--";
      }
      post = "{ " + result + ".push(" + i + "); }\n" + idt + "return " + result + ";\n" + o.indent;
-      return "(function() {" + pre + "\n" + idt + "for (" + body + ")" + post + "}).apply(this, arguments)";
+      hasArgs = function(node) {
+        return node != null ? node.contains(function(n) {
+          return n instanceof Literal && n.value === 'arguments' && !n.asKey;
+        }) : void 0;
+      };
+      if (hasArgs(this.from) || hasArgs(this.to)) {
+        args = ', arguments';
+      }
+      return "(function() {" + pre + "\n" + idt + "for (" + body + ")" + post + "}).apply(this" + (args != null ? args : '') + ")";
    };
    return Range;
  })();
  exports.Slice = Slice = (function() {
-    Slice.prototype.children = ['range'];
    __extends(Slice, Base);
+    Slice.prototype.children = ['range'];
    function Slice(range) {
      this.range = range;
      Slice.__super__.constructor.call(this);
@@ -867,11 +879,11 @@
    return Slice;
  })();
  exports.Obj = Obj = (function() {
+    __extends(Obj, Base);
    function Obj(props, generated) {
      this.generated = generated != null ? generated : false;
      this.objects = this.properties = props || [];
    }
-    __extends(Obj, Base);
    Obj.prototype.children = ['properties'];
    Obj.prototype.compileNode = function(o) {
      var i, idt, indent, join, lastNoncom, node, obj, prop, props, _i, _len;
@@ -935,10 +947,10 @@
    return Obj;
  })();
  exports.Arr = Arr = (function() {
+    __extends(Arr, Base);
    function Arr(objs) {
      this.objects = objs || [];
    }
-    __extends(Arr, Base);
    Arr.prototype.children = ['objects'];
    Arr.prototype.filterImplicitObjects = Call.prototype.filterImplicitObjects;
    Arr.prototype.compileNode = function(o) {
@@ -980,6 +992,7 @@
    return Arr;
  })();
  exports.Class = Class = (function() {
+    __extends(Class, Base);
    function Class(variable, parent, body) {
      this.variable = variable;
      this.parent = parent;
@@ -987,7 +1000,6 @@
      this.boundFuncs = [];
      this.body.classBody = true;
    }
-    __extends(Class, Base);
    Class.prototype.children = ['variable', 'parent', 'body'];
    Class.prototype.determineName = function() {
      var decl, tail;
@@ -1013,54 +1025,59 @@
      });
    };
    Class.prototype.addBoundFunctions = function(o) {
-      var bname, bvar, _i, _len, _ref2, _results;
+      var bvar, lhs, _i, _len, _ref2, _results;
      if (this.boundFuncs.length) {
        _ref2 = this.boundFuncs;
        _results = [];
        for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
          bvar = _ref2[_i];
-          bname = bvar.compile(o);
-          _results.push(this.ctor.body.unshift(new Literal("this." + bname + " = " + (utility('bind')) + "(this." + bname + ", this);")));
+          lhs = (new Value(new Literal("this"), [new Access(bvar)])).compile(o);
+          _results.push(this.ctor.body.unshift(new Literal("" + lhs + " = " + (utility('bind')) + "(" + lhs + ", this)")));
        }
        return _results;
      }
    };
-    Class.prototype.addProperties = function(node, name) {
-      var assign, base, func, props, _results;
+    Class.prototype.addProperties = function(node, name, o) {
+      var assign, base, exprs, func, props;
      props = node.base.properties.slice(0);
-      _results = [];
-      while (assign = props.shift()) {
-        if (assign instanceof Assign) {
-          base = assign.variable.base;
-          delete assign.context;
-          func = assign.value;
-          if (base.value === 'constructor') {
-            if (this.ctor) {
-              throw new Error('cannot define more than one constructor in a class');
-            }
-            if (func.bound) {
-              throw new Error('cannot define a constructor as a bound function');
-            }
-            if (func instanceof Code) {
-              assign = this.ctor = func;
+      exprs = (function() {
+        var _results;
+        _results = [];
+        while (assign = props.shift()) {
+          if (assign instanceof Assign) {
+            base = assign.variable.base;
+            delete assign.context;
+            func = assign.value;
+            if (base.value === 'constructor') {
+              if (this.ctor) {
+                throw new Error('cannot define more than one constructor in a class');
+              }
+              if (func.bound) {
+                throw new Error('cannot define a constructor as a bound function');
+              }
+              if (func instanceof Code) {
+                assign = this.ctor = func;
+              } else {
+                this.externalCtor = o.scope.freeVariable('class');
+                assign = new Assign(new Literal(this.externalCtor), func);
+              }
            } else {
-              assign = this.ctor = new Assign(new Value(new Literal(name)), func);
-            }
-          } else {
-            if (!assign.variable["this"]) {
-              assign.variable = new Value(new Literal(name), [new Access(base, 'proto')]);
-            }
-            if (func instanceof Code && func.bound) {
-              this.boundFuncs.push(base);
-              func.bound = false;
+              if (!assign.variable["this"]) {
+                assign.variable = new Value(new Literal(name), [new Access(base, 'proto')]);
+              }
+              if (func instanceof Code && func.bound) {
+                this.boundFuncs.push(base);
+                func.bound = false;
+              }
            }
          }
+          _results.push(assign);
        }
-        _results.push(assign);
-      }
-      return _results;
+        return _results;
+      }).call(this);
+      return compact(exprs);
    };
-    Class.prototype.walkBody = function(name) {
+    Class.prototype.walkBody = function(name, o) {
      return this.traverseChildren(false, __bind(function(child) {
        var exps, i, node, _len, _ref2;
        if (child instanceof Class) {
@@ -1071,7 +1088,7 @@
          for (i = 0, _len = _ref2.length; i < _len; i++) {
            node = _ref2[i];
            if (node instanceof Value && node.isObject(true)) {
-              exps[i] = this.addProperties(node, name);
+              exps[i] = this.addProperties(node, name, o);
            }
          }
          return child.expressions = exps = flatten(exps);
@@ -1082,7 +1099,10 @@
      if (!this.ctor) {
        this.ctor = new Code;
        if (this.parent) {
-          this.ctor.body.push(new Call('super', [new Splat(new Literal('arguments'))]));
+          this.ctor.body.push(new Literal("" + name + ".__super__.constructor.apply(this, arguments)"));
+        }
+        if (this.externalCtor) {
+          this.ctor.body.push(new Literal("" + this.externalCtor + ".apply(this, arguments)"));
        }
        this.body.expressions.unshift(this.ctor);
      }
@@ -1096,10 +1116,13 @@
      name = decl || this.name || '_Class';
      lname = new Literal(name);
      this.setContext(name);
-      this.walkBody(name);
+      this.walkBody(name, o);
      this.ensureConstructor(name);
      if (this.parent) {
-        this.body.expressions.splice(1, 0, new Extends(lname, this.parent));
+        this.body.expressions.unshift(new Extends(lname, this.parent));
+      }
+      if (!(this.ctor instanceof Code)) {
+        this.body.expressions.unshift(this.ctor);
      }
      this.body.expressions.push(lname);
      this.addBoundFunctions(o);
@@ -1112,15 +1135,17 @@
    return Class;
  })();
  exports.Assign = Assign = (function() {
+    __extends(Assign, Base);
    function Assign(variable, value, context, options) {
      this.variable = variable;
      this.value = value;
      this.context = context;
      this.param = options && options.param;
    }
-    __extends(Assign, Base);
-    Assign.prototype.METHOD_DEF = /^(?:(\S+)\.prototype\.|\S+?)?\b([$A-Za-z_][$\w\x7f-\uffff]*)$/;
    Assign.prototype.children = ['variable', 'value'];
+    Assign.prototype.isStatement = function(o) {
+      return (o != null ? o.level : void 0) === LEVEL_TOP && (this.context != null) && __indexOf.call(this.context, "?") >= 0;
+    };
    Assign.prototype.assigns = function(name) {
      return this[this.context === 'object' ? 'value' : 'variable'].assigns(name);
    };
@@ -1128,7 +1153,7 @@
      return unfoldSoak(o, this, 'variable');
    };
    Assign.prototype.compileNode = function(o) {
-      var isValue, match, name, val, _ref2;
+      var isValue, match, name, val, _ref2, _ref3, _ref4, _ref5;
      if (isValue = this.variable instanceof Value) {
        if (this.variable.isArray() || this.variable.isObject()) {
          return this.compilePatternMatch(o);
@@ -1151,11 +1176,11 @@
          o.scope.find(name);
        }
      }
-      if (this.value instanceof Code && (match = this.METHOD_DEF.exec(name))) {
-        this.value.name = match[2];
+      if (this.value instanceof Code && (match = METHOD_DEF.exec(name))) {
        if (match[1]) {
          this.value.klass = match[1];
        }
+        this.value.name = (_ref3 = (_ref4 = (_ref5 = match[2]) != null ? _ref5 : match[3]) != null ? _ref4 : match[4]) != null ? _ref3 : match[5];
      }
      val = this.value.compile(o, LEVEL_LIST);
      if (this.context === 'object') {
@@ -1195,7 +1220,9 @@
        acc = IDENTIFIER.test(idx.unwrap().value || 0);
        value = new Value(value);
        value.properties.push(new (acc ? Access : Index)(idx));
-        return new Assign(obj, value).compile(o);
+        return new Assign(obj, value, null, {
+          param: this.param
+        }).compile(o, LEVEL_TOP);
      }
      vvar = value.compile(o, LEVEL_LIST);
      assigns = [];
@@ -1258,6 +1285,9 @@
    Assign.prototype.compileConditional = function(o) {
      var left, rite, _ref2;
      _ref2 = this.variable.cacheReference(o), left = _ref2[0], rite = _ref2[1];
+      if (__indexOf.call(this.context, "?") >= 0) {
+        o.isExistentialEquals = true;
+      }
      return new Op(this.context.slice(0, -1), left, new Assign(rite, this.value, '=')).compile(o);
    };
    Assign.prototype.compileSplice = function(o) {
@@ -1291,6 +1321,7 @@
    return Assign;
  })();
  exports.Code = Code = (function() {
+    __extends(Code, Base);
    function Code(params, body, tag) {
      this.params = params || [];
      this.body = body || new Block;
@@ -1299,14 +1330,13 @@
        this.context = 'this';
      }
    }
-    __extends(Code, Base);
    Code.prototype.children = ['params', 'body'];
    Code.prototype.isStatement = function() {
      return !!this.ctor;
    };
    Code.prototype.jumps = NO;
    Code.prototype.compileNode = function(o) {
-      var code, exprs, i, idt, lit, p, param, ref, splats, v, val, vars, wasEmpty, _i, _j, _len, _len2, _len3, _ref2, _ref3, _ref4;
+      var code, exprs, i, idt, lit, p, param, ref, splats, v, val, vars, wasEmpty, _i, _j, _k, _len, _len2, _len3, _len4, _ref2, _ref3, _ref4, _ref5;
      o.scope = new Scope(o.scope, this.body, this);
      o.scope.shared = del(o, 'sharedScope');
      o.indent += TAB;
@@ -1317,15 +1347,19 @@
      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
        param = _ref2[_i];
        if (param.splat) {
-          if (param.name.value) {
-            o.scope.add(param.name.value, 'var');
+          _ref3 = this.params;
+          for (_j = 0, _len2 = _ref3.length; _j < _len2; _j++) {
+            p = _ref3[_j];
+            if (p.name.value) {
+              o.scope.add(p.name.value, 'var', true);
+            }
          }
          splats = new Assign(new Value(new Arr((function() {
-            var _j, _len2, _ref3, _results;
-            _ref3 = this.params;
+            var _k, _len3, _ref4, _results;
+            _ref4 = this.params;
            _results = [];
-            for (_j = 0, _len2 = _ref3.length; _j < _len2; _j++) {
-              p = _ref3[_j];
+            for (_k = 0, _len3 = _ref4.length; _k < _len3; _k++) {
+              p = _ref4[_k];
              _results.push(p.asReference(o));
            }
            return _results;
@@ -1333,9 +1367,9 @@
          break;
        }
      }
-      _ref3 = this.params;
-      for (_j = 0, _len2 = _ref3.length; _j < _len2; _j++) {
-        param = _ref3[_j];
+      _ref4 = this.params;
+      for (_k = 0, _len3 = _ref4.length; _k < _len3; _k++) {
+        param = _ref4[_k];
        if (param.isComplex()) {
          val = ref = param.asReference(o);
          if (param.value) {
@@ -1361,10 +1395,10 @@
        exprs.unshift(splats);
      }
      if (exprs.length) {
-        (_ref4 = this.body.expressions).unshift.apply(_ref4, exprs);
+        (_ref5 = this.body.expressions).unshift.apply(_ref5, exprs);
      }
      if (!splats) {
-        for (i = 0, _len3 = vars.length; i < _len3; i++) {
+        for (i = 0, _len4 = vars.length; i < _len4; i++) {
          v = vars[i];
          o.scope.parameter(vars[i] = v.compile(o));
        }
@@ -1402,12 +1436,12 @@
    return Code;
  })();
  exports.Param = Param = (function() {
+    __extends(Param, Base);
    function Param(name, value, splat) {
      this.name = name;
      this.value = value;
      this.splat = splat;
    }
-    __extends(Param, Base);
    Param.prototype.children = ['name', 'value'];
    Param.prototype.compile = function(o) {
      return this.name.compile(o, LEVEL_LIST);
@@ -1438,8 +1472,8 @@
    return Param;
  })();
  exports.Splat = Splat = (function() {
-    Splat.prototype.children = ['name'];
    __extends(Splat, Base);
+    Splat.prototype.children = ['name'];
    Splat.prototype.isAssignable = YES;
    function Splat(name) {
      this.name = name.compile ? name : new Literal(name);
@@ -1494,11 +1528,11 @@
    return Splat;
  })();
  exports.While = While = (function() {
+    __extends(While, Base);
    function While(condition, options) {
      this.condition = (options != null ? options.invert : void 0) ? condition.invert() : condition;
      this.guard = options != null ? options.guard : void 0;
    }
-    __extends(While, Base);
    While.prototype.children = ['condition', 'guard', 'body'];
    While.prototype.isStatement = YES;
    While.prototype.makeReturn = function() {
@@ -1555,6 +1589,7 @@
  })();
  exports.Op = Op = (function() {
    var CONVERSIONS, INVERSIONS;
+    __extends(Op, Base);
    function Op(op, first, second, flip) {
      var call;
      if (op === 'in') {
@@ -1566,7 +1601,7 @@
        return call;
      }
      if (op === 'new') {
-        if (first instanceof Call && !first["do"]) {
+        if (first instanceof Call && !first["do"] && !first.isNew) {
          return first.newInstance();
        }
        if (first instanceof Code && first.bound || first["do"]) {
@@ -1579,7 +1614,6 @@
      this.flip = !!flip;
      return this;
    }
-    __extends(Op, Base);
    CONVERSIONS = {
      '==': '===',
      '!=': '!==',
@@ -1594,6 +1628,10 @@
    Op.prototype.isUnary = function() {
      return !this.second;
    };
+    Op.prototype.isComplex = function() {
+      var _ref2;
+      return !(this.isUnary() && ((_ref2 = this.operator) === '+' || _ref2 === '-')) || this.first.isComplex();
+    };
    Op.prototype.isChainable = function() {
      var _ref2;
      return (_ref2 = this.operator) === '<' || _ref2 === '>' || _ref2 === '>=' || _ref2 === '<=' || _ref2 === '===' || _ref2 === '!==';
@@ -1695,19 +1733,29 @@
    return Op;
  })();
  exports.In = In = (function() {
+    __extends(In, Base);
    function In(object, array) {
      this.object = object;
      this.array = array;
    }
-    __extends(In, Base);
    In.prototype.children = ['object', 'array'];
    In.prototype.invert = NEGATE;
    In.prototype.compileNode = function(o) {
+      var hasSplat, obj, _i, _len, _ref2;
      if (this.array instanceof Value && this.array.isArray()) {
-        return this.compileOrTest(o);
-      } else {
-        return this.compileLoopTest(o);
+        _ref2 = this.array.base.objects;
+        for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
+          obj = _ref2[_i];
+          if (obj instanceof Splat) {
+            hasSplat = true;
+            break;
+          }
+        }
+        if (!hasSplat) {
+          return this.compileOrTest(o);
+        }
      }
+      return this.compileLoopTest(o);
    };
    In.prototype.compileOrTest = function(o) {
      var cmp, cnj, i, item, ref, sub, tests, _ref2, _ref3;
@@ -1753,13 +1801,13 @@
    return In;
  })();
  exports.Try = Try = (function() {
+    __extends(Try, Base);
    function Try(attempt, error, recovery, ensure) {
      this.attempt = attempt;
      this.error = error;
      this.recovery = recovery;
      this.ensure = ensure;
    }
-    __extends(Try, Base);
    Try.prototype.children = ['attempt', 'recovery', 'ensure'];
    Try.prototype.isStatement = YES;
    Try.prototype.jumps = function(o) {
@@ -1779,16 +1827,16 @@
      var catchPart, errorPart;
      o.indent += TAB;
      errorPart = this.error ? " (" + (this.error.compile(o)) + ") " : ' ';
-      catchPart = this.recovery ? " catch" + errorPart + "{\n" + (this.recovery.compile(o, LEVEL_TOP)) + "\n" + this.tab + "}" : !(this.ensure || this.recovery) ? ' catch (_e) {}' : void 0;
+      catchPart = this.recovery ? (o.scope.add(this.error.value, 'param'), " catch" + errorPart + "{\n" + (this.recovery.compile(o, LEVEL_TOP)) + "\n" + this.tab + "}") : !(this.ensure || this.recovery) ? ' catch (_e) {}' : void 0;
      return ("" + this.tab + "try {\n" + (this.attempt.compile(o, LEVEL_TOP)) + "\n" + this.tab + "}" + (catchPart || '')) + (this.ensure ? " finally {\n" + (this.ensure.compile(o, LEVEL_TOP)) + "\n" + this.tab + "}" : '');
    };
    return Try;
  })();
  exports.Throw = Throw = (function() {
+    __extends(Throw, Base);
    function Throw(expression) {
      this.expression = expression;
    }
-    __extends(Throw, Base);
    Throw.prototype.children = ['expression'];
    Throw.prototype.isStatement = YES;
    Throw.prototype.jumps = NO;
@@ -1799,16 +1847,16 @@
    return Throw;
  })();
  exports.Existence = Existence = (function() {
+    __extends(Existence, Base);
    function Existence(expression) {
      this.expression = expression;
    }
-    __extends(Existence, Base);
    Existence.prototype.children = ['expression'];
    Existence.prototype.invert = NEGATE;
    Existence.prototype.compileNode = function(o) {
-      var code, sym;
+      var cmp, cnj, code, _ref2;
      code = this.expression.compile(o, LEVEL_OP);
-      code = IDENTIFIER.test(code) && !o.scope.check(code) ? this.negated ? "typeof " + code + " === \"undefined\" || " + code + " === null" : "typeof " + code + " !== \"undefined\" && " + code + " !== null" : (sym = this.negated ? '==' : '!=', "" + code + " " + sym + " null");
+      code = IDENTIFIER.test(code) && !o.scope.check(code) ? ((_ref2 = this.negated ? ['===', '||'] : ['!==', '&&'], cmp = _ref2[0], cnj = _ref2[1], _ref2), "typeof " + code + " " + cmp + " \"undefined\" " + cnj + " " + code + " " + cmp + " null") : "" + code + " " + (this.negated ? '==' : '!=') + " null";
      if (o.level <= LEVEL_COND) {
        return code;
      } else {
@@ -1818,10 +1866,10 @@
    return Existence;
  })();
  exports.Parens = Parens = (function() {
+    __extends(Parens, Base);
    function Parens(body) {
      this.body = body;
    }
-    __extends(Parens, Base);
    Parens.prototype.children = ['body'];
    Parens.prototype.unwrap = function() {
      return this.body;
@@ -1850,6 +1898,7 @@
    return Parens;
  })();
  exports.For = For = (function() {
+    __extends(For, Base);
    function For(body, source) {
      var _ref2;
      this.source = source.source, this.guard = source.guard, this.step = source.step, this.name = source.name, this.index = source.index;
@@ -1872,7 +1921,6 @@
      }
      this.returns = false;
    }
-    __extends(For, Base);
    For.prototype.children = ['body', 'source', 'guard', 'step'];
    For.prototype.isStatement = YES;
    For.prototype.jumps = While.prototype.jumps;
@@ -1881,7 +1929,7 @@
      return this;
    };
    For.prototype.compileNode = function(o) {
-      var body, defPart, forPart, guardPart, idt1, index, ivar, lastJumps, lvar, name, namePart, ref, resultPart, returnResult, rvar, scope, source, stepPart, svar, varPart, _ref2;
+      var body, defPart, forPart, forVarPart, guardPart, idt1, index, ivar, lastJumps, lvar, name, namePart, ref, resultPart, returnResult, rvar, scope, source, stepPart, stepvar, svar, varPart, _ref2;
      body = Block.wrap([this.body]);
      lastJumps = (_ref2 = last(body.expressions)) != null ? _ref2.jumps() : void 0;
      if (lastJumps && lastJumps instanceof Return) {
@@ -1905,6 +1953,9 @@
        rvar = scope.freeVariable('results');
      }
      ivar = (this.range ? name : index) || scope.freeVariable('i');
+      if (this.step && !this.range) {
+        stepvar = scope.freeVariable("step");
+      }
      if (this.pattern) {
        name = ivar;
      }
@@ -1928,8 +1979,9 @@
        }
        if (!this.object) {
          lvar = scope.freeVariable('len');
-          stepPart = this.step ? "" + ivar + " += " + (this.step.compile(o, LEVEL_OP)) : "" + ivar + "++";
-          forPart = "" + ivar + " = 0, " + lvar + " = " + svar + ".length; " + ivar + " < " + lvar + "; " + stepPart;
+          forVarPart = ("" + ivar + " = 0, " + lvar + " = " + svar + ".length") + (this.step ? ", " + stepvar + " = " + (this.step.compile(o, LEVEL_OP)) : '');
+          stepPart = this.step ? "" + ivar + " += " + stepvar : "" + ivar + "++";
+          forPart = "" + forVarPart + "; " + ivar + " < " + lvar + "; " + stepPart;
        }
      }
      if (this.returns) {
@@ -1980,7 +2032,6 @@
        base = new Value(ref);
        if (val.base) {
          _ref7 = [base, val], val.base = _ref7[0], base = _ref7[1];
-          args.unshift(new Literal('this'));
        }
        body.expressions[idx] = new Call(base, expr.args);
        defs += this.tab + new Assign(ref, fn).compile(o, LEVEL_TOP) + ';\n';
@@ -1990,12 +2041,12 @@
    return For;
  })();
  exports.Switch = Switch = (function() {
+    __extends(Switch, Base);
    function Switch(subject, cases, otherwise) {
      this.subject = subject;
      this.cases = cases;
      this.otherwise = otherwise;
    }
-    __extends(Switch, Base);
    Switch.prototype.children = ['subject', 'cases', 'otherwise'];
    Switch.prototype.isStatement = YES;
    Switch.prototype.jumps = function(o) {
@@ -2062,6 +2113,7 @@
    return Switch;
  })();
  exports.If = If = (function() {
+    __extends(If, Base);
    function If(condition, body, options) {
      this.body = body;
      if (options == null) {
@@ -2072,7 +2124,6 @@
      this.isChain = false;
      this.soak = options.soak;
    }
-    __extends(If, Base);
    If.prototype.children = ['condition', 'body', 'elseBody'];
    If.prototype.bodyNode = function() {
      var _ref2;
@@ -2119,8 +2170,14 @@
      }
    };
    If.prototype.compileStatement = function(o) {
-      var body, child, cond, ifPart;
+      var body, child, cond, exeq, ifPart;
      child = del(o, 'chainChild');
+      exeq = del(o, 'isExistentialEquals');
+      if (exeq) {
+        return new If(this.condition.invert(), this.elseBodyNode(), {
+          type: 'if'
+        }).compile(o);
+      }
      cond = this.condition.compile(o, LEVEL_PAREN);
      o.indent += TAB;
      body = this.ensureBlock(this.body).compile(o);
@@ -2215,8 +2272,10 @@
  LEVEL_OP = 5;
  LEVEL_ACCESS = 6;
  TAB = '  ';
-  IDENTIFIER = /^[$A-Za-z_\x7f-\uffff][$\w\x7f-\uffff]*$/;
+  IDENTIFIER_STR = "[$A-Za-z_\\x7f-\\uffff][$\\w\\x7f-\\uffff]*";
+  IDENTIFIER = RegExp("^" + IDENTIFIER_STR + "$");
  SIMPLENUM = /^[+-]?\d+$/;
+  METHOD_DEF = RegExp("^(?:(" + IDENTIFIER_STR + ")\\.prototype(?:\\.(" + IDENTIFIER_STR + ")|\\[(\"(?:[^\\\\\"\\r\\n]|\\\\.)*\"|'(?:[^\\\\'\\r\\n]|\\\\.)*')\\]|\\[(0x[\\da-fA-F]+|\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\]))|(" + IDENTIFIER_STR + ")$");
  IS_STRING = /^['"]/;
  utility = function(name) {
    var ref;
--- a/lib/repl.js
+++ b/lib/repl.js
@@ -1,10 +1,12 @@
 (function() {
-  var ACCESSOR, CoffeeScript, SIMPLEVAR, Script, autocomplete, backlog, completeAttribute, completeVariable, enableColours, error, getCompletions, getPropertyNames, inspect, readline, repl, run, stdin, stdout;
-  var __hasProp = Object.prototype.hasOwnProperty;
+  var ACCESSOR, CoffeeScript, Module, REPL_PROMPT, REPL_PROMPT_CONTINUATION, SIMPLEVAR, Script, autocomplete, backlog, completeAttribute, completeVariable, enableColours, error, g, getCompletions, inspect, nonContextGlobals, readline, repl, run, sandbox, stdin, stdout, _i, _len;
  CoffeeScript = require('./coffee-script');
  readline = require('readline');
  inspect = require('util').inspect;
  Script = require('vm').Script;
+  Module = require('module');
+  REPL_PROMPT = 'coffee> ';
+  REPL_PROMPT_CONTINUATION = '......> ';
  enableColours = false;
  if (process.platform !== 'win32') {
    enableColours = !process.env.NODE_DISABLE_COLORS;
@@ -15,41 +17,45 @@
    return stdout.write((err.stack || err.toString()) + '\n\n');
  };
  backlog = '';
-  run = (function() {
-    var g, sandbox;
-    sandbox = {
-      require: require,
-      module: {
-        exports: {}
-      }
-    };
-    for (g in global) {
-      sandbox[g] = global[g];
+  sandbox = Script.createContext();
+  nonContextGlobals = ['Buffer', 'console', 'process', 'setInterval', 'clearInterval', 'setTimeout', 'clearTimeout'];
+  for (_i = 0, _len = nonContextGlobals.length; _i < _len; _i++) {
+    g = nonContextGlobals[_i];
+    sandbox[g] = global[g];
+  }
+  sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox;
+  run = function(buffer) {
+    var code, returnValue, _;
+    if (!buffer.toString().trim() && !backlog) {
+      repl.prompt();
+      return;
    }
-    sandbox.global = sandbox;
-    sandbox.global.global = sandbox.global.root = sandbox.global.GLOBAL = sandbox;
-    return function(buffer) {
-      var code, val;
-      code = backlog += '\n' + buffer.toString();
-      if (code[code.length - 1] === '\\') {
-        return backlog = backlog.slice(0, backlog.length - 1);
+    code = backlog += buffer;
+    if (code[code.length - 1] === '\\') {
+      backlog = "" + backlog.slice(0, -1) + "\n";
+      repl.setPrompt(REPL_PROMPT_CONTINUATION);
+      repl.prompt();
+      return;
+    }
+    repl.setPrompt(REPL_PROMPT);
+    backlog = '';
+    try {
+      _ = sandbox._;
+      returnValue = CoffeeScript.eval("_=(" + code + "\n)", {
+        sandbox: sandbox,
+        filename: 'repl',
+        modulename: 'repl'
+      });
+      if (returnValue === void 0) {
+        sandbox._ = _;
+      } else {
+        process.stdout.write(inspect(returnValue, false, 2, enableColours) + '\n');
      }
-      backlog = '';
-      try {
-        val = CoffeeScript.eval(code, {
-          sandbox: sandbox,
-          bare: true,
-          filename: 'repl'
-        });
-        if (val !== void 0) {
-          process.stdout.write(inspect(val, false, 2, enableColours) + '\n');
-        }
-      } catch (err) {
-        error(err);
-      }
-      return repl.prompt();
-    };
-  })();
+    } catch (err) {
+      error(err);
+    }
+    return repl.prompt();
+  };
  ACCESSOR = /\s*([\w\.]+)(?:\.(\w*))$/;
  SIMPLEVAR = /\s*(\w*)$/i;
  autocomplete = function(text) {
@@ -60,42 +66,34 @@
    if (match = text.match(ACCESSOR)) {
      all = match[0], obj = match[1], prefix = match[2];
      try {
-        val = Script.runInThisContext(obj);
+        val = Script.runInContext(obj, sandbox);
      } catch (error) {
-        return [[], text];
+        return;
      }
-      completions = getCompletions(prefix, getPropertyNames(val));
+      completions = getCompletions(prefix, Object.getOwnPropertyNames(val));
      return [completions, prefix];
    }
  };
  completeVariable = function(text) {
-    var completions, free, scope, _ref;
+    var completions, free, possibilities, vars, _ref;
    if (free = (_ref = text.match(SIMPLEVAR)) != null ? _ref[1] : void 0) {
-      scope = Script.runInThisContext('this');
-      completions = getCompletions(free, CoffeeScript.RESERVED.concat(getPropertyNames(scope)));
+      vars = Script.runInContext('Object.getOwnPropertyNames(this)', sandbox);
+      possibilities = vars.concat(CoffeeScript.RESERVED);
+      completions = getCompletions(free, possibilities);
      return [completions, free];
    }
  };
  getCompletions = function(prefix, candidates) {
-    var el, _i, _len, _results;
+    var el, _j, _len2, _results;
    _results = [];
-    for (_i = 0, _len = candidates.length; _i < _len; _i++) {
-      el = candidates[_i];
+    for (_j = 0, _len2 = candidates.length; _j < _len2; _j++) {
+      el = candidates[_j];
      if (el.indexOf(prefix) === 0) {
        _results.push(el);
      }
    }
    return _results;
  };
-  getPropertyNames = function(obj) {
-    var name, _results;
-    _results = [];
-    for (name in obj) {
-      if (!__hasProp.call(obj, name)) continue;
-      _results.push(name);
-    }
-    return _results;
-  };
  process.on('uncaughtException', error);
  if (readline.createInterface.length < 3) {
    repl = readline.createInterface(stdin, autocomplete);
@@ -105,10 +103,21 @@
  } else {
    repl = readline.createInterface(stdin, stdout, autocomplete);
  }
-  repl.setPrompt('coffee> ');
+  repl.on('attemptClose', function() {
+    if (backlog) {
+      backlog = '';
+      process.stdout.write('\n');
+      repl.setPrompt(REPL_PROMPT);
+      return repl.prompt();
+    } else {
+      return repl.close();
+    }
+  });
  repl.on('close', function() {
+    process.stdout.write('\n');
    return stdin.destroy();
  });
  repl.on('line', run);
+  repl.setPrompt(REPL_PROMPT);
  repl.prompt();
 }).call(this);
--- a/lib/rewriter.js
+++ b/lib/rewriter.js
@@ -162,7 +162,7 @@
        return this.tokens.splice(idx, 0, ['CALL_END', ')', token[2]]);
      };
      return this.scanTokens(function(token, i, tokens) {
-        var callObject, current, next, prev, seenSingle, tag, _ref, _ref2, _ref3;
+        var callObject, current, next, prev, seenControl, seenSingle, tag, _ref, _ref2, _ref3;
        tag = token[0];
        if (tag === 'CLASS' || tag === 'IF') {
          noCall = true;
@@ -170,6 +170,7 @@
        _ref = tokens.slice(i - 1, (i + 1 + 1) || 9e9), prev = _ref[0], current = _ref[1], next = _ref[2];
        callObject = !noCall && tag === 'INDENT' && next && next.generated && next[0] === '{' && prev && (_ref2 = prev[0], __indexOf.call(IMPLICIT_FUNC, _ref2) >= 0);
        seenSingle = false;
+        seenControl = false;
        if (__indexOf.call(LINEBREAKS, tag) >= 0) {
          noCall = false;
        }
@@ -189,13 +190,16 @@
          if (!seenSingle && token.fromThen) {
            return true;
          }
-          if (tag === 'IF' || tag === 'ELSE' || tag === '->' || tag === '=>') {
+          if (tag === 'IF' || tag === 'ELSE' || tag === 'CATCH' || tag === '->' || tag === '=>') {
            seenSingle = true;
          }
+          if (tag === 'IF' || tag === 'ELSE' || tag === 'SWITCH' || tag === 'TRY') {
+            seenControl = true;
+          }
          if ((tag === '.' || tag === '?.' || tag === '::') && this.tag(i - 1) === 'OUTDENT') {
            return true;
          }
-          return !token.generated && this.tag(i - 1) !== ',' && __indexOf.call(IMPLICIT_END, tag) >= 0 && (tag !== 'INDENT' || (this.tag(i - 2) !== 'CLASS' && (_ref4 = this.tag(i - 1), __indexOf.call(IMPLICIT_BLOCK, _ref4) < 0) && !((post = this.tokens[i + 1]) && post.generated && post[0] === '{')));
+          return !token.generated && this.tag(i - 1) !== ',' && (__indexOf.call(IMPLICIT_END, tag) >= 0 || (tag === 'INDENT' && !seenControl)) && (tag !== 'INDENT' || (this.tag(i - 2) !== 'CLASS' && (_ref4 = this.tag(i - 1), __indexOf.call(IMPLICIT_BLOCK, _ref4) < 0) && !((post = this.tokens[i + 1]) && post.generated && post[0] === '{')));
        }, action);
        if (prev[0] === '?') {
          prev[0] = 'FUNC_EXIST';
@@ -352,7 +356,7 @@
  IMPLICIT_CALL = ['IDENTIFIER', 'NUMBER', 'STRING', 'JS', 'REGEX', 'NEW', 'PARAM_START', 'CLASS', 'IF', 'TRY', 'SWITCH', 'THIS', 'BOOL', 'UNARY', 'SUPER', '@', '->', '=>', '[', '(', '{', '--', '++'];
  IMPLICIT_UNSPACED_CALL = ['+', '-'];
  IMPLICIT_BLOCK = ['->', '=>', '{', '[', ','];
-  IMPLICIT_END = ['POST_IF', 'FOR', 'WHILE', 'UNTIL', 'WHEN', 'BY', 'LOOP', 'TERMINATOR', 'INDENT'];
+  IMPLICIT_END = ['POST_IF', 'FOR', 'WHILE', 'UNTIL', 'WHEN', 'BY', 'LOOP', 'TERMINATOR'];
  SINGLE_LINERS = ['ELSE', '->', '=>', 'TRY', 'FINALLY', 'THEN'];
  SINGLE_CLOSERS = ['TERMINATOR', 'CATCH', 'FINALLY', 'ELSE', 'OUTDENT', 'LEADING_WHEN'];
  LINEBREAKS = ['TERMINATOR', 'INDENT', 'OUTDENT'];
--- a/package.json
+++ b/package.json
@@ -3,7 +3,7 @@
  "description":  "Unfancy JavaScript",
  "keywords":     ["javascript", "language", "coffeescript", "compiler"],
  "author":       "Jeremy Ashkenas",
-  "version":      "1.1.0",
+  "version":      "1.1.2",
  "licenses":     [{
    "type":       "MIT",
    "url":        "http://github.com/jashkenas/coffee-script/raw/master/LICENSE"
--- a/src/browser.coffee
+++ b/src/browser.coffee
@@ -23,10 +23,10 @@ CoffeeScript.load = (url, callback) ->
  xhr.onreadystatechange = ->
    if xhr.readyState is 4
      if xhr.status in [0, 200]
-        CoffeeScript.run xhr.responseText 
+        CoffeeScript.run xhr.responseText
      else
        throw new Error "Could not load #{url}"
-      callback() if callback  
+      callback() if callback
  xhr.send null

 # Activate CoffeeScript in the browser by having it compile and evaluate
--- a/src/cake.coffee
+++ b/src/cake.coffee
@@ -63,7 +63,7 @@ printTasks = ->
    console.log "cake #{name}#{spaces} #{desc}"
  console.log oparse.help() if switches.length

-# Print an error and exit when attempting to all an undefined task.
+# Print an error and exit when attempting to call an undefined task.
 missingTask = (task) ->
  console.log "No such task: \"#{task}\""
  process.exit 1
--- a/src/coffee-script.coffee
+++ b/src/coffee-script.coffee
@@ -8,7 +8,6 @@

 fs               = require 'fs'
 path             = require 'path'
-vm               = require 'vm'
 {Lexer,RESERVED} = require './lexer'
 {parser}         = require './parser'

@@ -21,7 +20,7 @@ else if require.registerExtension
  require.registerExtension '.coffee', (content) -> compile content

 # The current CoffeeScript version number.
-exports.VERSION = '1.1.0'
+exports.VERSION = '1.1.2'

 # Words that cannot be used as identifiers in CoffeeScript code
 exports.RESERVED = RESERVED
@@ -54,44 +53,58 @@ exports.nodes = (source, options) ->
 # Compile and execute a string of CoffeeScript (on the server), correctly
 # setting `__filename`, `__dirname`, and relative `require()`.
 exports.run = (code, options) ->
-  # We want the root module.
-  root = module
-  while root.parent
-    root = root.parent
+  mainModule = require.main

  # Set the filename.
-  root.filename = process.argv[1] =
+  mainModule.filename = process.argv[1] =
      if options.filename then fs.realpathSync(options.filename) else '.'

  # Clear the module cache.
-  root.moduleCache = {} if root.moduleCache
+  mainModule.moduleCache and= {}

  # Assign paths for node_modules loading
  if process.binding('natives').module
    {Module} = require 'module'
-    root.paths = Module._nodeModulePaths path.dirname options.filename
+    mainModule.paths = Module._nodeModulePaths path.dirname options.filename

  # Compile.
-  if path.extname(root.filename) isnt '.coffee' or require.extensions
-    root._compile compile(code, options), root.filename
+  if path.extname(mainModule.filename) isnt '.coffee' or require.extensions
+    mainModule._compile compile(code, options), mainModule.filename
  else
-    root._compile code, root.filename
+    mainModule._compile code, mainModule.filename

 # Compile and evaluate a string of CoffeeScript (in a Node.js-like environment).
 # The CoffeeScript REPL uses this to run the input.
 exports.eval = (code, options = {}) ->
-  sandbox = options.sandbox
-  unless sandbox
-    sandbox =
-      require: require
-      module : { exports: {} }
-    sandbox[g] = global[g] for g of global
-    sandbox.global = sandbox
-    sandbox.global.global = sandbox.global.root = sandbox.global.GLOBAL = sandbox
-  sandbox.__filename = options.filename || 'eval'
-  sandbox.__dirname  = path.dirname sandbox.__filename
-  js = compile "_=(#{code.trim()})", options
-  vm.runInNewContext js, sandbox, sandbox.__filename
+  return unless code = code.trim()
+  if {Script} = require 'vm'
+    sandbox = Script.createContext()
+    sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox
+    if options.sandbox?
+      if options.sandbox instanceof sandbox.constructor
+        sandbox = options.sandbox
+      else
+        sandbox[k] = v for own k, v of options.sandbox
+    sandbox.__filename = options.filename || 'eval'
+    sandbox.__dirname  = path.dirname sandbox.__filename
+    # define module/require only if they chose not to specify their own
+    unless sandbox.module or sandbox.require
+      Module = require 'module'
+      sandbox.module  = _module  = new Module(options.modulename || 'eval')
+      sandbox.require = _require = (path) -> Module._load path, _module
+      _module.filename = sandbox.__filename
+      _require[r] = require[r] for r in Object.getOwnPropertyNames require
+      # use the same hack node currently uses for their own REPL
+      _require.paths = _module.paths = Module._nodeModulePaths process.cwd()
+      _require.resolve = (request) -> Module._resolveFilename request, _module
+  o = {}
+  o[k] = v for own k, v of options
+  o.bare = on # ensure return value
+  js = compile code, o
+  if Script
+    Script.runInContext js, sandbox
+  else
+    eval js

 # Instantiate a Lexer for our use here.
 lexer = new Lexer
--- a/src/command.coffee
+++ b/src/command.coffee
@@ -1,6 +1,6 @@
 # The `coffee` utility. Handles command-line compilation of CoffeeScript
 # into various forms: saved into `.js` files or printed to stdout, piped to
-# [JSLint](http://javascriptlint.com/) or recompiled every time the source is
+# [JavaScript Lint](http://javascriptlint.com/) or recompiled every time the source is
 # saved, printed as a token stream or as the syntax tree, or launch an
 # interactive REPL.

@@ -32,7 +32,7 @@ SWITCHES = [
  ['-j', '--join [FILE]',     'concatenate the scripts before compiling']
  ['-w', '--watch',           'watch scripts for changes, and recompile']
  ['-p', '--print',           'print the compiled JavaScript to stdout']
-  ['-l', '--lint',            'pipe the compiled JavaScript through JSLint']
+  ['-l', '--lint',            'pipe the compiled JavaScript through JavaScript Lint']
  ['-s', '--stdio',           'listen for and compile scripts over stdio']
  ['-e', '--eval',            'compile a string from the command line']
  ['-r', '--require [FILE*]', 'require a library before executing your script']
@@ -67,33 +67,51 @@ exports.run = ->
    opts.literals = sources.splice(1).concat opts.literals
  process.ARGV = process.argv = process.argv.slice(0, 2).concat opts.literals
  process.argv[0] = 'coffee'
-  process.execPath = process.mainModule.filename
+  process.execPath = require.main.filename
  compileScripts()

 # Asynchronously read in each CoffeeScript in a list of source files and
 # compile them. If a directory is passed, recursively compile all
 # '.coffee' extension source files in it and all subdirectories.
 compileScripts = ->
+  unprocessed = []
+  for source in sources
+    unprocessed[sources.indexOf(source)]=1
  for source in sources
    base = path.join(source)
-    compile = (source, topLevel) ->
+    compile = (source, sourceIndex, topLevel) ->
+      remaining_files = ->
+        total = 0
+        total += x for x in unprocessed
+        total
      path.exists source, (exists) ->
+        if topLevel and not exists and source[-7..] isnt '.coffee'
+            return compile "#{source}.coffee", sourceIndex, topLevel
+                
        throw new Error "File not found: #{source}" if topLevel and not exists
        fs.stat source, (err, stats) ->
          throw err if err
          if stats.isDirectory()
            fs.readdir source, (err, files) ->
+              throw err if err
+              unprocessed[sourceIndex] += files.length
              for file in files
-                compile path.join(source, file)
+                compile path.join(source, file), sourceIndex
+              unprocessed[sourceIndex] -= 1
          else if topLevel or path.extname(source) is '.coffee'
            fs.readFile source, (err, code) ->
+              throw err if err
+              unprocessed[sourceIndex] -= 1
              if opts.join
-                contents[sources.indexOf source] = code.toString()
-                compileJoin() if helpers.compact(contents).length > 0
+                contents[sourceIndex] = helpers.compact([contents[sourceIndex], code.toString()]).join('\n')
+                if helpers.compact(contents).length > 0 and remaining_files() == 0
+                  compileJoin()
              else
                compileScript(source, code.toString(), base)
            watch source, base if opts.watch and not opts.join
-    compile source, true
+          else
+            unprocessed[sourceIndex] -= 1
+    compile source, sources.indexOf(source), true

 # Compile a single source script, containing the given code, according to the
 # requested options. If evaluating the script directly sets `__filename`,
--- a/src/grammar.coffee
+++ b/src/grammar.coffee
@@ -84,7 +84,7 @@ grammar =

  # All the different types of expressions in our language. The basic unit of
  # CoffeeScript is the **Expression** -- everything that can be an expression
-  # is one. Block serve as the building blocks of many other rules, making
+  # is one. Blocks serve as the building blocks of many other rules, making
  # them somewhat circular.
  Expression: [
    o 'Value'
@@ -120,7 +120,7 @@ grammar =
    o 'STRING',                                 -> new Literal $1
  ]

-  # All of our immediate values. These can (in general), be passed straight
+  # All of our immediate values. Generally these can be passed straight
  # through and printed to JavaScript.
  Literal: [
    o 'AlphaNumeric'
@@ -201,6 +201,7 @@ grammar =
    o 'ParamVar = Expression',                  -> new Param $1, $3
  ]

+ # Function Parameters
  ParamVar: [
    o 'Identifier'
    o 'ThisProperty'
@@ -254,7 +255,7 @@ grammar =
    o 'INDEX_SOAK  Index',                      -> extend $2, soak : yes
    o 'INDEX_PROTO Index',                      -> extend $2, proto: yes
  ]
-  
+
  IndexValue: [
    o 'Expression',                             -> new Index $1
    o 'Slice',                                  -> new Slice $1
@@ -354,7 +355,7 @@ grammar =
    o 'ArgList OptComma INDENT ArgList OptComma OUTDENT', -> $1.concat $4
  ]

-  # Valid arguments are Block or Splats.
+  # Valid arguments are Blocks or Splats.
  Arg: [
    o 'Expression'
    o 'Splat'
@@ -573,7 +574,7 @@ operators = [
 # Wrapping Up
 # -----------

-# Finally, now what we have our **grammar** and our **operators**, we can create
+# Finally, now that we have our **grammar** and our **operators**, we can create
 # our **Jison.Parser**. 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".
--- a/src/lexer.coffee
+++ b/src/lexer.coffee
@@ -84,8 +84,7 @@ exports.Lexer = class Lexer
      not prev.spaced and prev[0] is '@')
    tag = 'IDENTIFIER'

-    if id in JS_KEYWORDS or
-       not forcedIdentifier and id in COFFEE_KEYWORDS
+    if not forcedIdentifier and (id in JS_KEYWORDS or id in COFFEE_KEYWORDS)
      tag = id.toUpperCase()
      if tag is 'WHEN' and @tag() in LINE_BREAK
        tag = 'LEADING_WHEN'
@@ -189,7 +188,11 @@ exports.Lexer = class Lexer
  # JavaScript and Ruby.
  regexToken: ->
    return 0 if @chunk.charAt(0) isnt '/'
-    return @heregexToken match if match = HEREGEX.exec @chunk
+    if match = HEREGEX.exec @chunk
+      length = @heregexToken match
+      @line += count match[0], '\n'
+      return length
+
    prev = last @tokens
    return 0 if prev and (prev[0] in (if prev.spaced then NOT_REGEX else NOT_SPACED_REGEX))
    return 0 unless match = REGEX.exec @chunk
@@ -374,6 +377,7 @@ exports.Lexer = class Lexer
          else if tok[0] is '('
            tok[0] = 'PARAM_START'
            return this
+          else return this
    this

  # Close up all remaining open blocks at the end of the file.
@@ -409,6 +413,8 @@ exports.Lexer = class Lexer
          continue
      if end is '}' and letter in ['"', "'"]
        stack.push end = letter
+      else if end is '}' and letter is '/' and match = (HEREGEX.exec(str.slice i) or REGEX.exec(str.slice i))
+        i += match[0].length - 1
      else if end is '}' and letter is '{'
        stack.push end = '}'
      else if end is '"' and prev is '#' and letter is '{'
@@ -523,7 +529,7 @@ COFFEE_ALIAS_MAP =
  no   : 'false'
  on   : 'true'
  off  : 'false'
-  
+
 COFFEE_ALIASES  = (key for key of COFFEE_ALIAS_MAP)
 COFFEE_KEYWORDS = COFFEE_KEYWORDS.concat COFFEE_ALIASES

@@ -550,7 +556,7 @@ IDENTIFIER = /// ^

 NUMBER     = ///
  ^ 0x[\da-f]+ |                              # hex
-  ^ (?: \d+(\.\d+)? | \.\d+ ) (?:e[+-]?\d+)?  # decimal
+  ^ \d*\.?\d+ (?:e[+-]?\d+)?  # decimal
 ///i

 HEREDOC    = /// ^ ("""|''') ([\s\S]*?) (?:\n[^\n\S]*)? \1 ///
@@ -653,7 +659,7 @@ NOT_REGEX = ['NUMBER', 'REGEX', 'BOOL', '++', '--', ']']
 # force a division parse:
 NOT_SPACED_REGEX = NOT_REGEX.concat ')', '}', 'THIS', 'IDENTIFIER', 'STRING'

-# Tokens which could legitimately be invoked or indexed. A opening
+# Tokens which could legitimately be invoked or indexed. An opening
 # parentheses or bracket following these tokens will be recorded as the start
 # of a function invocation or indexing operation.
 CALLABLE  = ['IDENTIFIER', 'STRING', 'REGEX', ')', ']', '}', '?', '::', '@', 'THIS', 'SUPER']
--- a/src/nodes.coffee
+++ b/src/nodes.coffee
@@ -188,7 +188,7 @@ exports.Block = class Block extends Base
    for exp in @expressions
      return exp if exp.jumps o

-  # An Block node does not return its entire body, rather it
+  # A Block node does not return its entire body, rather it
  # ensures that the final expression is returned.
  makeReturn: ->
    len = @expressions.length
@@ -200,7 +200,7 @@ exports.Block = class Block extends Base
        break
    this

-  # An **Block** is the only node that can serve as the root.
+  # A **Block** is the only node that can serve as the root.
  compile: (o = {}, level) ->
    if o.scope then super o, level else @compileRoot o

@@ -214,7 +214,12 @@ exports.Block = class Block extends Base
    for node in @expressions
      node = node.unwrapAll()
      node = (node.unfoldSoak(o) or node)
-      if top
+      if node instanceof Block
+        # This is a nested block.  We don't do anything special here like enclose
+        # it in a new scope; we just compile the statements in this block along with
+        # our own
+        codes.push node.compileNode o
+      else if top
        node.front = true
        code = node.compile o
        codes.push if node.isStatement o then code else @tab + code + ';'
@@ -245,18 +250,22 @@ exports.Block = class Block extends Base
    o = merge(o, level: LEVEL_TOP)
    if i
      rest = @expressions.splice i, @expressions.length
-      code = @compileNode o
+      code = @compileNode(o)
      @expressions = rest
    post = @compileNode o
    {scope} = o
    if scope.expressions is this
-      if o.scope.hasDeclarations()
+      declars = o.scope.hasDeclarations()
+      assigns = scope.hasAssignments
+      if (declars or assigns) and i
+        code += '\n'
+      if declars
        code += "#{@tab}var #{ scope.declaredVariables().join(', ') };\n"
-      if scope.hasAssignments
+      if assigns
        code += "#{@tab}var #{ multident scope.assignedVariables().join(', '), @tab };\n"
    code + post

-  # Wrap up the given nodes as an **Block**, unless it already happens
+  # Wrap up the given nodes as a **Block**, unless it already happens
  # to be one.
  @wrap: (nodes) ->
    return nodes[0] if nodes.length is 1 and nodes[0] instanceof Block
@@ -379,7 +388,7 @@ exports.Value = class Value extends Base
    name = last @properties
    if @properties.length < 2 and not @base.isComplex() and not name?.isComplex()
      return [this, this]  # `a` `a.b`
-    base = new Value @base, @properties.slice 0, -1
+    base = new Value @base, @properties[...-1]
    if base.isComplex()  # `a().b`
      bref = new Literal o.scope.freeVariable 'base'
      base = new Value new Parens new Assign bref, base
@@ -398,21 +407,21 @@ exports.Value = class Value extends Base
    @base.front = @front
    props = @properties
    code  = @base.compile o, if props.length then LEVEL_ACCESS else null
-    code  = "(#{code})" if props[0] instanceof Access and @isSimpleNumber()
+    code  = "#{code}." if (@base instanceof Parens or props.length) and SIMPLENUM.test code
    code += prop.compile o for prop in props
    code

  # Unfold a soak into an `If`: `a?.b` -> `a.b if a?`
  unfoldSoak: (o) ->
    return @unfoldedSoak if @unfoldedSoak?
-    result = do => 
+    result = do =>
      if ifn = @base.unfoldSoak o
        Array::push.apply ifn.body.properties, @properties
        return ifn
      for prop, i in @properties when prop.soak
        prop.soak = off
-        fst = new Value @base, @properties.slice 0, i
-        snd = new Value @base, @properties.slice i
+        fst = new Value @base, @properties[...i]
+        snd = new Value @base, @properties[i..]
        if fst.isComplex()
          ref = new Literal o.scope.freeVariable 'ref'
          fst = new Parens new Assign ref, fst
@@ -451,7 +460,7 @@ exports.Call = class Call extends Base
  # Tag this invocation as creating a new instance.
  newInstance: ->
    base = @variable.base or @variable
-    if base instanceof Call
+    if base instanceof Call and not base.isNew
      base.newInstance()
    else
      @isNew = true
@@ -463,9 +472,9 @@ exports.Call = class Call extends Base
    {method} = o.scope
    throw SyntaxError 'cannot call super outside of a function.' unless method
    {name} = method
-    throw SyntaxError 'cannot call super on an anonymous function.' unless name
+    throw SyntaxError 'cannot call super on an anonymous function.' unless name?
    if method.klass
-      "#{method.klass}.__super__.#{name}"
+      (new Value (new Literal method.klass), [new Access(new Literal "__super__"), new Access new Literal name]).compile o
    else
      "#{name}.__super__.constructor"

@@ -511,7 +520,7 @@ exports.Call = class Call extends Base
        continue
      obj = null
      for prop in node.base.properties
-        if prop instanceof Assign
+        if prop instanceof Assign or prop instanceof Comment
          nodes.push obj = new Obj properties = [], true if not obj
          properties.push prop
        else
@@ -594,7 +603,7 @@ exports.Access = class Access extends Base

  compile: (o) ->
    name = @name.compile o
-    @proto + if IS_STRING.test name then "[#{name}]" else ".#{name}"
+    @proto + if IDENTIFIER.test name then ".#{name}" else "[#{name}]"

  isComplex: NO

@@ -628,38 +637,48 @@ exports.Range = class Range extends Base
  # Compiles the range's source variables -- where it starts and where it ends.
  # But only if they need to be cached to avoid double evaluation.
  compileVariables: (o) ->
-    o = merge(o, top: true)
-    [@from, @fromVar] =  @from.cache o, LEVEL_LIST
-    [@to, @toVar] =      @to.cache o, LEVEL_LIST
-    [@fromNum, @toNum] = [@fromVar.match(SIMPLENUM), @toVar.match(SIMPLENUM)]
-    parts = []
-    parts.push @from if @from isnt @fromVar
-    parts.push @to if @to isnt @toVar
+    o = merge o, top: true
+    [@fromC, @fromVar]  =  @from.cache o, LEVEL_LIST
+    [@toC, @toVar]      =  @to.cache o, LEVEL_LIST
+    [@step, @stepVar]   =  step.cache o, LEVEL_LIST if step = del o, 'step'
+    [@fromNum, @toNum]  = [@fromVar.match(SIMPLENUM), @toVar.match(SIMPLENUM)]
+    @stepNum            = @stepVar.match(SIMPLENUM) if @stepVar

  # When compiled normally, the range returns the contents of the *for loop*
  # needed to iterate over the values in the range. Used by comprehensions.
  compileNode: (o) ->
-    @compileVariables o
-    return    @compileArray(o)  unless o.index
-    return    @compileSimple(o) if @fromNum and @toNum
-    idx      = del o, 'index'
-    step     = del o, 'step'
-    vars     = "#{idx} = #{@from}" + if @to isnt @toVar then ", #{@to}" else ''
-    cond     = "#{@fromVar} <= #{@toVar}"
-    compare  = "#{cond} ? #{idx} <#{@equals} #{@toVar} : #{idx} >#{@equals} #{@toVar}"
-    incr     = if step then "#{idx} += #{step.compile(o)}" else "#{cond} ? #{idx}++ : #{idx}--"
-    "#{vars}; #{compare}; #{incr}"
+    @compileVariables o unless @fromVar
+    return @compileArray(o) unless o.index

-  # Compile a simple range comprehension, with integers.
-  compileSimple: (o) ->
-    [from, to] = [+@fromNum, +@toNum]
-    idx        = del o, 'index'
-    step       = del o, 'step'
-    step       and= "#{idx} += #{step.compile(o)}"
-    if from <= to
-      "#{idx} = #{from}; #{idx} <#{@equals} #{to}; #{step or "#{idx}++"}"
+    # Set up endpoints.
+    known    = @fromNum and @toNum
+    idx      = del o, 'index'
+    varPart  = "#{idx} = #{@fromC}"
+    varPart += ", #{@toC}" if @toC isnt @toVar
+    varPart += ", #{@step}" if @step isnt @stepVar
+    [lt, gt] = ["#{idx} <#{@equals}", "#{idx} >#{@equals}"]
+
+    # Generate the condition.
+    condPart = if @stepNum
+      condPart = if +@stepNum > 0 then "#{lt} #{@toVar}" else "#{gt} #{@toVar}"
+    else if known
+      [from, to] = [+@fromNum, +@toNum]
+      condPart   = if from <= to then "#{lt} #{to}" else "#{gt} #{to}"
    else
-      "#{idx} = #{from}; #{idx} >#{@equals} #{to}; #{step or "#{idx}--"}"
+      cond     = "#{@fromVar} <= #{@toVar}"
+      condPart = "#{cond} ? #{lt} #{@toVar} : #{gt} #{@toVar}"
+
+    # Generate the step.
+    stepPart = if @stepVar
+      "#{idx} += #{@stepVar}"
+    else if known
+      if from <= to then "#{idx}++" else "#{idx}--"
+    else
+      "#{cond} ? #{idx}++ : #{idx}--"
+
+    # The final loop body.
+    "#{varPart}; #{condPart}; #{stepPart}"
+

  # When used as a value, expand the range into the equivalent array.
  compileArray: (o) ->
@@ -673,13 +692,15 @@ exports.Range = class Range extends Base
    pre    = "\n#{idt}#{result} = [];"
    if @fromNum and @toNum
      o.index = i
-      body    = @compileSimple o
+      body    = @compileNode o
    else
-      vars    = "#{i} = #{@from}" + if @to isnt @toVar then ", #{@to}" else ''
+      vars    = "#{i} = #{@fromC}" + if @toC isnt @toVar then ", #{@toC}" else ''
      cond    = "#{@fromVar} <= #{@toVar}"
      body    = "var #{vars}; #{cond} ? #{i} <#{@equals} #{@toVar} : #{i} >#{@equals} #{@toVar}; #{cond} ? #{i}++ : #{i}--"
    post   = "{ #{result}.push(#{i}); }\n#{idt}return #{result};\n#{o.indent}"
-    "(function() {#{pre}\n#{idt}for (#{body})#{post}}).apply(this, arguments)"
+    hasArgs = (node) -> node?.contains (n) -> n instanceof Literal and n.value is 'arguments' and not n.asKey
+    args   = ', arguments' if hasArgs(@from) or hasArgs(@to)
+    "(function() {#{pre}\n#{idt}for (#{body})#{post}}).apply(this#{args ? ''})"

 #### Slice

@@ -812,14 +833,14 @@ exports.Class = class Class extends Base
  addBoundFunctions: (o) ->
    if @boundFuncs.length
      for bvar in @boundFuncs
-        bname = bvar.compile o
-        @ctor.body.unshift new Literal "this.#{bname} = #{utility 'bind'}(this.#{bname}, this);"
+        lhs = (new Value (new Literal "this"), [new Access bvar]).compile o
+        @ctor.body.unshift new Literal "#{lhs} = #{utility 'bind'}(#{lhs}, this)"

  # Merge the properties from a top-level object as prototypal properties
  # on the class.
-  addProperties: (node, name) ->
-    props = node.base.properties.slice 0
-    while assign = props.shift()
+  addProperties: (node, name, o) ->
+    props = node.base.properties[0..]
+    exprs = while assign = props.shift()
      if assign instanceof Assign
        base = assign.variable.base
        delete assign.context
@@ -832,7 +853,8 @@ exports.Class = class Class extends Base
          if func instanceof Code
            assign = @ctor = func
          else
-            assign = @ctor = new Assign(new Value(new Literal name), func)
+            @externalCtor = o.scope.freeVariable 'class'
+            assign = new Assign new Literal(@externalCtor), func
        else
          unless assign.variable.this
            assign.variable = new Value(new Literal(name), [new Access(base, 'proto')])
@@ -840,15 +862,16 @@ exports.Class = class Class extends Base
            @boundFuncs.push base
            func.bound = no
      assign
+    compact exprs

  # Walk the body of the class, looking for prototype properties to be converted.
-  walkBody: (name) ->
+  walkBody: (name, o) ->
    @traverseChildren false, (child) =>
      return false if child instanceof Class
      if child instanceof Block
        for node, i in exps = child.expressions
          if node instanceof Value and node.isObject(true)
-            exps[i] = @addProperties node, name
+            exps[i] = @addProperties node, name, o
        child.expressions = exps = flatten exps

  # Make sure that a constructor is defined for the class, and properly
@@ -856,7 +879,8 @@ exports.Class = class Class extends Base
  ensureConstructor: (name) ->
    if not @ctor
      @ctor = new Code
-      @ctor.body.push new Call 'super', [new Splat new Literal 'arguments'] if @parent
+      @ctor.body.push new Literal "#{name}.__super__.constructor.apply(this, arguments)" if @parent
+      @ctor.body.push new Literal "#{@externalCtor}.apply(this, arguments)" if @externalCtor
      @body.expressions.unshift @ctor
    @ctor.ctor     = @ctor.name = name
    @ctor.klass    = null
@@ -871,9 +895,10 @@ exports.Class = class Class extends Base
    lname = new Literal name

    @setContext name
-    @walkBody name
+    @walkBody name, o
    @ensureConstructor name
-    @body.expressions.splice 1, 0, new Extends(lname, @parent) if @parent
+    @body.expressions.unshift new Extends lname, @parent if @parent
+    @body.expressions.unshift @ctor unless @ctor instanceof Code
    @body.expressions.push lname
    @addBoundFunctions o

@@ -889,11 +914,11 @@ exports.Assign = class Assign extends Base
  constructor: (@variable, @value, @context, options) ->
    @param = options and options.param

-  # Matchers for detecting class/method names
-  METHOD_DEF: /^(?:(\S+)\.prototype\.|\S+?)?\b([$A-Za-z_][$\w\x7f-\uffff]*)$/
-
  children: ['variable', 'value']

+  isStatement: (o) ->
+    o?.level is LEVEL_TOP and @context? and "?" in @context
+
  assigns: (name) ->
    @[if @context is 'object' then 'value' else 'variable'].assigns name

@@ -917,9 +942,9 @@ exports.Assign = class Assign extends Base
        o.scope.add name, 'var'
      else
        o.scope.find name
-    if @value instanceof Code and match = @METHOD_DEF.exec name
-      @value.name  = match[2]
+    if @value instanceof Code and match = METHOD_DEF.exec name
      @value.klass = match[1] if match[1]
+      @value.name  = match[2] ? match[3] ? match[4] ? match[5]
    val = @value.compile o, LEVEL_LIST
    return "#{name}: #{val}" if @context is 'object'
    val = name + " #{ @context or '=' } " + val
@@ -952,7 +977,7 @@ exports.Assign = class Assign extends Base
      acc   = IDENTIFIER.test idx.unwrap().value or 0
      value = new Value value
      value.properties.push new (if acc then Access else Index) idx
-      return new Assign(obj, value).compile o
+      return new Assign(obj, value, null, param: @param).compile o, LEVEL_TOP
    vvar    = value.compile o, LEVEL_LIST
    assigns = []
    splat   = false
@@ -1002,7 +1027,8 @@ exports.Assign = class Assign extends Base
  # more than once.
  compileConditional: (o) ->
    [left, rite] = @variable.cacheReference o
-    new Op(@context.slice(0, -1), left, new Assign(rite, @value, '=')).compile o
+    if "?" in @context then o.isExistentialEquals = true
+    new Op(@context[0...-1], left, new Assign(rite, @value, '=') ).compile o

  # Compile the assignment from an array splice literal, using JavaScript's
  # `Array#splice` method.
@@ -1043,7 +1069,7 @@ exports.Code = class Code extends Base

  # Compilation creates a new scope unless explicitly asked to share with the
  # outer scope. Handles splat parameters in the parameter list by peeking at
-  # the JavaScript `arguments` objects. If the function is bound with the `=>`
+  # the JavaScript `arguments` object. If the function is bound with the `=>`
  # arrow, generates a wrapper that saves the current value of `this` through
  # a closure.
  compileNode: (o) ->
@@ -1054,7 +1080,7 @@ exports.Code = class Code extends Base
    vars   = []
    exprs  = []
    for param in @params when param.splat
-      o.scope.add param.name.value, 'var' if param.name.value
+      o.scope.add p.name.value, 'var', yes for p in @params when p.name.value
      splats = new Assign new Value(new Arr(p.asReference o for p in @params)),
                          new Value new Literal 'arguments'
      break
@@ -1137,7 +1163,7 @@ exports.Splat = class Splat extends Base
  compile: (o) ->
    if @index? then @compileParam o else @name.compile o

-  # Utility function that converts arbitrary number of elements, mixed with
+  # Utility function that converts an arbitrary number of elements, mixed with
  # splats, to a proper array.
  @compileSplattedArray: (o, list, apply) ->
    index = -1
@@ -1147,14 +1173,14 @@ exports.Splat = class Splat extends Base
      code = list[0].compile o, LEVEL_LIST
      return code if apply
      return "#{ utility 'slice' }.call(#{code})"
-    args = list.slice index
+    args = list[index..]
    for node, i in args
      code = node.compile o, LEVEL_LIST
      args[i] = if node instanceof Splat
      then "#{ utility 'slice' }.call(#{code})"
      else "[#{code}]"
-    return args[0] + ".concat(#{ args.slice(1).join ', ' })" if index is 0
-    base = (node.compile o, LEVEL_LIST for node in list.slice 0, index)
+    return args[0] + ".concat(#{ args[1..].join ', ' })" if index is 0
+    base = (node.compile o, LEVEL_LIST for node in list[0...index])
    "[#{ base.join ', ' }].concat(#{ args.join ', ' })"

 #### While
@@ -1211,14 +1237,14 @@ exports.While = class While extends Base
 # Simple Arithmetic and logical operations. Performs some conversion from
 # CoffeeScript operations into their JavaScript equivalents.
 exports.Op = class Op extends Base
-  constructor: (op, first, second, flip) ->
+  constructor: (op, first, second, flip ) ->
    return new In first, second if op is 'in'
    if op is 'do'
      call = new Call first, first.params or []
      call.do = yes
      return call
    if op is 'new'
-      return first.newInstance() if first instanceof Call and not first.do
+      return first.newInstance() if first instanceof Call and not first.do and not first.isNew
      first = new Parens first   if first instanceof Code and first.bound or first.do
    @operator = CONVERSIONS[op] or op
    @first    = first
@@ -1244,6 +1270,9 @@ exports.Op = class Op extends Base
  isUnary: ->
    not @second

+  isComplex: ->
+    not (@isUnary() and (@operator in ['+', '-'])) or @first.isComplex()
+
  # Am I capable of
  # [Python-style comparison chaining](http://docs.python.org/reference/expressions.html#notin)?
  isChainable: ->
@@ -1331,9 +1360,12 @@ exports.In = class In extends Base

  compileNode: (o) ->
    if @array instanceof Value and @array.isArray()
-      @compileOrTest o
-    else
-      @compileLoopTest o
+      for obj in @array.base.objects when obj instanceof Splat
+        hasSplat = yes
+        break
+      # `compileOrTest` only if we have an array literal with no splats
+      return @compileOrTest o unless hasSplat
+    @compileLoopTest o

  compileOrTest: (o) ->
    [sub, ref] = @object.cache o, LEVEL_OP
@@ -1378,6 +1410,7 @@ exports.Try = class Try extends Base
    o.indent  += TAB
    errorPart = if @error then " (#{ @error.compile o }) " else ' '
    catchPart = if @recovery
+      o.scope.add @error.value, 'param'
      " catch#{errorPart}{\n#{ @recovery.compile o, LEVEL_TOP }\n#{@tab}}"
    else unless @ensure or @recovery
      ' catch (_e) {}'
@@ -1419,13 +1452,11 @@ exports.Existence = class Existence extends Base
  compileNode: (o) ->
    code = @expression.compile o, LEVEL_OP
    code = if IDENTIFIER.test(code) and not o.scope.check code
-      if @negated
-        "typeof #{code} === \"undefined\" || #{code} === null"
-      else
-        "typeof #{code} !== \"undefined\" && #{code} !== null"
+        [cmp, cnj] = if @negated then ['===', '||'] else ['!==', '&&']
+        "typeof #{code} #{cmp} \"undefined\" #{cnj} #{code} #{cmp} null"
    else
-      sym = if @negated then '==' else '!='
-      "#{code} #{sym} null"
+      # do not use strict equality here; it will break existing code
+      "#{code} #{if @negated then '==' else '!='} null"
    if o.level <= LEVEL_COND then code else "(#{code})"

 #### Parens
@@ -1492,50 +1523,53 @@ exports.For = class For extends Base
  # comprehensions. Some of the generated code can be shared in common, and
  # some cannot.
  compileNode: (o) ->
-    body          = Block.wrap [@body]
-    lastJumps     = last(body.expressions)?.jumps()
-    @returns      = no if lastJumps and lastJumps instanceof Return
-    source        = if @range then @source.base else @source
-    scope         = o.scope
-    name          = @name  and @name.compile o, LEVEL_LIST
-    index         = @index and @index.compile o, LEVEL_LIST
+    body      = Block.wrap [@body]
+    lastJumps = last(body.expressions)?.jumps()
+    @returns  = no if lastJumps and lastJumps instanceof Return
+    source    = if @range then @source.base else @source
+    scope     = o.scope
+    name      = @name  and @name.compile o, LEVEL_LIST
+    index     = @index and @index.compile o, LEVEL_LIST
    scope.find(name,  immediate: yes) if name and not @pattern
    scope.find(index, immediate: yes) if index
-    rvar          = scope.freeVariable 'results' if @returns
-    ivar          = (if @range then name else index) or scope.freeVariable 'i'
-    name          = ivar if @pattern
-    varPart       = ''
-    guardPart     = ''
-    defPart       = ''
-    idt1          = @tab + TAB
+    rvar      = scope.freeVariable 'results' if @returns
+    ivar      = (if @range then name else index) or scope.freeVariable 'i'
+    # the `_by` variable is created twice in `Range`s if we don't prevent it from being declared here
+    stepvar   = scope.freeVariable "step" if @step and not @range
+    name      = ivar if @pattern
+    varPart   = ''
+    guardPart = ''
+    defPart   = ''
+    idt1      = @tab + TAB
    if @range
      forPart = source.compile merge(o, {index: ivar, @step})
    else
-      svar = @source.compile o, LEVEL_LIST
+      svar    = @source.compile o, LEVEL_LIST
      if (name or @own) and not IDENTIFIER.test svar
-        defPart = "#{@tab}#{ref = scope.freeVariable 'ref'} = #{svar};\n"
-        svar = ref
+        defPart    = "#{@tab}#{ref = scope.freeVariable 'ref'} = #{svar};\n"
+        svar       = ref
      if name and not @pattern
-        namePart = "#{name} = #{svar}[#{ivar}]"
+        namePart   = "#{name} = #{svar}[#{ivar}]"
      unless @object
-        lvar        = scope.freeVariable 'len'
-        stepPart    = if @step then "#{ivar} += #{ @step.compile(o, LEVEL_OP) }" else "#{ivar}++"
-        forPart     = "#{ivar} = 0, #{lvar} = #{svar}.length; #{ivar} < #{lvar}; #{stepPart}"
+        lvar       = scope.freeVariable 'len'
+        forVarPart = "#{ivar} = 0, #{lvar} = #{svar}.length" + if @step then ", #{stepvar} = #{@step.compile(o, LEVEL_OP)}" else ''
+        stepPart   = if @step then "#{ivar} += #{stepvar}" else "#{ivar}++"
+        forPart    = "#{forVarPart}; #{ivar} < #{lvar}; #{stepPart}"
    if @returns
-      resultPart    = "#{@tab}#{rvar} = [];\n"
-      returnResult  = "\n#{@tab}return #{rvar};"
-      body          = Push.wrap rvar, body
+      resultPart   = "#{@tab}#{rvar} = [];\n"
+      returnResult = "\n#{@tab}return #{rvar};"
+      body         = Push.wrap rvar, body
    if @guard
-      body          = Block.wrap [new If @guard, body]
+      body         = Block.wrap [new If @guard, body]
    if @pattern
      body.expressions.unshift new Assign @name, new Literal "#{svar}[#{ivar}]"
-    defPart         += @pluckDirectCall o, body
-    varPart         = "\n#{idt1}#{namePart};" if namePart
+    defPart     += @pluckDirectCall o, body
+    varPart     = "\n#{idt1}#{namePart};" if namePart
    if @object
-      forPart       = "#{ivar} in #{svar}"
-      guardPart     = "\n#{idt1}if (!#{utility('hasProp')}.call(#{svar}, #{ivar})) continue;" if @own
-    body            = body.compile merge(o, indent: idt1), LEVEL_TOP
-    body            = '\n' + body + '\n' if body
+      forPart   = "#{ivar} in #{svar}"
+      guardPart = "\n#{idt1}if (!#{utility('hasProp')}.call(#{svar}, #{ivar})) continue;" if @own
+    body        = body.compile merge(o, indent: idt1), LEVEL_TOP
+    body        = '\n' + body + '\n' if body
    """
    #{defPart}#{resultPart or ''}#{@tab}for (#{forPart}) {#{guardPart}#{varPart}#{body}#{@tab}}#{returnResult or ''}
    """
@@ -1556,7 +1590,6 @@ exports.For = class For extends Base
      base  = new Value ref
      if val.base
        [val.base, base] = [base, val]
-        args.unshift new Literal 'this'
      body.expressions[idx] = new Call base, expr.args
      defs += @tab + new Assign(ref, fn).compile(o, LEVEL_TOP) + ';\n'
    defs
@@ -1644,10 +1677,15 @@ exports.If = class If extends Base
  ensureBlock: (node) ->
    if node instanceof Block then node else new Block [node]

-  # Compile the **If** as a regular *if-else* statement. Flattened chains
+  # Compile the `If` as a regular *if-else* statement. Flattened chains
  # force inner *else* bodies into statement form.
  compileStatement: (o) ->
    child    = del o, 'chainChild'
+    exeq     = del o, 'isExistentialEquals'
+
+    if exeq
+      return new If(@condition.invert(), @elseBodyNode(), type: 'if').compile o
+
    cond     = @condition.compile o, LEVEL_PAREN
    o.indent += TAB
    body     = @ensureBlock(@body).compile o
@@ -1662,7 +1700,7 @@ exports.If = class If extends Base
    else
      "{\n#{ @elseBody.compile o, LEVEL_TOP }\n#{@tab}}"

-  # Compile the If as a conditional operator.
+  # Compile the `If` as a conditional operator.
  compileExpression: (o) ->
    cond = @condition.compile o, LEVEL_COND
    body = @bodyNode().compile o, LEVEL_LIST
@@ -1758,7 +1796,7 @@ UTILITIES =
  hasProp: 'Object.prototype.hasOwnProperty'
  slice  : 'Array.prototype.slice'

-# Levels indicates a node's position in the AST. Useful for knowing if
+# Levels indicate a node's position in the AST. Useful for knowing if
 # parens are necessary or superfluous.
 LEVEL_TOP    = 1  # ...;
 LEVEL_PAREN  = 2  # (...)
@@ -1770,8 +1808,24 @@ LEVEL_ACCESS = 6  # ...[0]
 # Tabs are two spaces for pretty printing.
 TAB = '  '

-IDENTIFIER = /^[$A-Za-z_\x7f-\uffff][$\w\x7f-\uffff]*$/
+IDENTIFIER_STR = "[$A-Za-z_\\x7f-\\uffff][$\\w\\x7f-\\uffff]*"
+IDENTIFIER = /// ^ #{IDENTIFIER_STR} $ ///
 SIMPLENUM  = /^[+-]?\d+$/
+METHOD_DEF = ///
+  ^
+    (?:
+      (#{IDENTIFIER_STR})
+      \.prototype
+      (?:
+        \.(#{IDENTIFIER_STR})
+      | \[("(?:[^\\"\r\n]|\\.)*"|'(?:[^\\'\r\n]|\\.)*')\]
+      | \[(0x[\da-fA-F]+ | \d*\.?\d+ (?:[eE][+-]?\d+)?)\]
+      )
+    )
+  |
+    (#{IDENTIFIER_STR})
+  $
+///

 # Is a literal value a string?
 IS_STRING = /^['"]/
--- a/src/optparse.coffee
+++ b/src/optparse.coffee
@@ -17,7 +17,7 @@ exports.OptionParser = class OptionParser
    @rules = buildRules rules

  # Parse the list of arguments, populating an `options` object with all of the
-  # specified options, and returning it. `options.arguments` will be an array
+  # specified options, and return it. `options.arguments` will be an array
  # containing the remaining non-option arguments. `options.literals` will be
  # an array of options that are meant to be passed through directly to the
  # executing script. This is a simpler API than many option parsers that allow
--- a/src/repl.coffee
+++ b/src/repl.coffee
@@ -9,10 +9,13 @@ CoffeeScript = require './coffee-script'
 readline     = require 'readline'
 {inspect}    = require 'util'
 {Script}     = require 'vm'
+Module       = require 'module'

 # REPL Setup

 # Config
+REPL_PROMPT = 'coffee> '
+REPL_PROMPT_CONTINUATION = '......> '
 enableColours = no
 unless process.platform is 'win32'
  enableColours = not process.env.NODE_DISABLE_COLORS
@@ -28,32 +31,45 @@ error = (err) ->
 # The current backlog of multi-line code.
 backlog = ''

+# The REPL context; must be visible outside `run` to allow for tab completion
+sandbox = Script.createContext()
+nonContextGlobals = [
+  'Buffer', 'console', 'process'
+  'setInterval', 'clearInterval'
+  'setTimeout', 'clearTimeout'
+]
+sandbox[g] = global[g] for g in nonContextGlobals
+sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox
+
 # The main REPL function. **run** is called every time a line of code is entered.
 # Attempt to evaluate the command. If there's an exception, print it out instead
 # of exiting.
-run = do ->
-  sandbox =
-    require: require
-    module : { exports: {} }
-  sandbox[g] = global[g] for g of global
-  sandbox.global = sandbox
-  sandbox.global.global = sandbox.global.root = sandbox.global.GLOBAL = sandbox
-  (buffer) ->
-    code = backlog += '\n' + buffer.toString()
-    if code[code.length - 1] is '\\'
-      return backlog = backlog[0...backlog.length - 1]
-    backlog = ''
-    try
-      val = CoffeeScript.eval code, {
-        sandbox,
-        bare: on,
-        filename: 'repl'
-      }
-      unless val is undefined
-        process.stdout.write inspect(val, no, 2, enableColours) + '\n'
-    catch err
-      error err
+run = (buffer) ->
+  if !buffer.toString().trim() and !backlog
    repl.prompt()
+    return
+  code = backlog += buffer
+  if code[code.length - 1] is '\\'
+    backlog = "#{backlog[...-1]}\n"
+    repl.setPrompt REPL_PROMPT_CONTINUATION
+    repl.prompt()
+    return
+  repl.setPrompt REPL_PROMPT
+  backlog = ''
+  try
+    _ = sandbox._
+    returnValue = CoffeeScript.eval "_=(#{code}\n)", {
+      sandbox,
+      filename: 'repl'
+      modulename: 'repl'
+    }
+    if returnValue is undefined
+      sandbox._ = _
+    else
+      process.stdout.write inspect(returnValue, no, 2, enableColours) + '\n'
+  catch err
+    error err
+  repl.prompt()

 ## Autocompletion

@@ -70,27 +86,24 @@ completeAttribute = (text) ->
  if match = text.match ACCESSOR
    [all, obj, prefix] = match
    try
-      val = Script.runInThisContext obj
+      val = Script.runInContext obj, sandbox
    catch error
-      return [[], text]
-    completions = getCompletions prefix, getPropertyNames val
+      return
+    completions = getCompletions prefix, Object.getOwnPropertyNames val
    [completions, prefix]

 # Attempt to autocomplete an in-scope free variable: `one`.
 completeVariable = (text) ->
-  if free = text.match(SIMPLEVAR)?[1]
-    scope = Script.runInThisContext 'this'
-    completions = getCompletions free, CoffeeScript.RESERVED.concat(getPropertyNames scope)
+  if free = (text.match SIMPLEVAR)?[1]
+    vars = Script.runInContext 'Object.getOwnPropertyNames(this)', sandbox
+    possibilities = vars.concat CoffeeScript.RESERVED
+    completions = getCompletions free, possibilities
    [completions, free]

 # Return elements of candidates for which `prefix` is a prefix.
 getCompletions = (prefix, candidates) ->
  (el for el in candidates when el.indexOf(prefix) is 0)

-# Return all "own" properties of an object.
-getPropertyNames = (obj) ->
-  (name for own name of obj)
-
 # Make sure that uncaught exceptions don't kill the REPL.
 process.on 'uncaughtException', error

@@ -101,7 +114,20 @@ if readline.createInterface.length < 3
 else
  repl = readline.createInterface stdin, stdout, autocomplete

-repl.setPrompt 'coffee> '
-repl.on  'close',  -> stdin.destroy()
-repl.on  'line',   run
+repl.on 'attemptClose', ->
+  if backlog
+    backlog = ''
+    process.stdout.write '\n'
+    repl.setPrompt REPL_PROMPT
+    repl.prompt()
+  else
+    repl.close()
+
+repl.on 'close', ->
+  process.stdout.write '\n'
+  stdin.destroy()
+
+repl.on 'line', run
+
+repl.setPrompt REPL_PROMPT
 repl.prompt()
--- a/src/rewriter.coffee
+++ b/src/rewriter.coffee
@@ -140,12 +140,13 @@ class exports.Rewriter
      tag     = token[0]
      noCall  = yes if tag in ['CLASS', 'IF']
      [prev, current, next] = tokens[i - 1 .. i + 1]
-      callObject = not noCall and tag is 'INDENT' and
-                   next and next.generated and next[0] is '{' and
-                   prev and prev[0] in IMPLICIT_FUNC
-      seenSingle = no
-      noCall     = no if tag in LINEBREAKS
-      token.call = yes if prev and not prev.spaced and tag is '?'
+      callObject  = not noCall and tag is 'INDENT' and
+                    next and next.generated and next[0] is '{' and
+                    prev and prev[0] in IMPLICIT_FUNC
+      seenSingle  = no
+      seenControl = no
+      noCall      = no if tag in LINEBREAKS
+      token.call  = yes if prev and not prev.spaced and tag is '?'
      return 1 if token.fromThen
      return 1 unless callObject or
        prev?.spaced and (prev.call or prev[0] in IMPLICIT_FUNC) and
@@ -154,9 +155,11 @@ class exports.Rewriter
      @detectEnd i + 1, (token, i) ->
        [tag] = token
        return yes if not seenSingle and token.fromThen
-        seenSingle = yes if tag in ['IF', 'ELSE', '->', '=>']
+        seenSingle  = yes if tag in ['IF', 'ELSE', 'CATCH', '->', '=>']
+        seenControl = yes if tag in ['IF', 'ELSE', 'SWITCH', 'TRY']
        return yes if tag in ['.', '?.', '::'] and @tag(i - 1) is 'OUTDENT'
-        not token.generated and @tag(i - 1) isnt ',' and tag in IMPLICIT_END and
+        not token.generated and @tag(i - 1) isnt ',' and (tag in IMPLICIT_END or
+        (tag is 'INDENT' and not seenControl)) and
        (tag isnt 'INDENT' or
         (@tag(i - 2) isnt 'CLASS' and @tag(i - 1) not in IMPLICIT_BLOCK and
          not ((post = @tokens[i + 1]) and post.generated and post[0] is '{')))
@@ -319,7 +322,7 @@ IMPLICIT_UNSPACED_CALL = ['+', '-']
 IMPLICIT_BLOCK   = ['->', '=>', '{', '[', ',']

 # Tokens that always mark the end of an implicit call for single-liners.
-IMPLICIT_END     = ['POST_IF', 'FOR', 'WHILE', 'UNTIL', 'WHEN', 'BY', 'LOOP', 'TERMINATOR', 'INDENT']
+IMPLICIT_END     = ['POST_IF', 'FOR', 'WHILE', 'UNTIL', 'WHEN', 'BY', 'LOOP', 'TERMINATOR']

 # Single-line flavors of block expressions that have unclosed endings.
 # The grammar can't disambiguate them, so we insert the implicit indentation.
--- a/src/scope.coffee
+++ b/src/scope.coffee
@@ -14,7 +14,7 @@ exports.Scope = class Scope
  @root: null

  # Initialize a scope with its parent, for lookups up the chain,
-  # as well as a reference to the **Block** node is belongs to, which is
+  # as well as a reference to the **Block** node it belongs to, which is
  # where it should declare its variables, and a reference to the function that
  # it wraps.
  constructor: (@parent, @expressions, @method) ->
--- a/test/assignment.coffee
+++ b/test/assignment.coffee
@@ -268,3 +268,21 @@ test "existential assignment", ->
  eq nonce, c
  d ?= nonce
  eq nonce, d
+
+test "#1348, #1216: existential assignment compilation", ->
+  nonce = {}
+  a = nonce
+  b = (a ?= 0)
+  eq nonce, b
+  #the first ?= compiles into a statement; the second ?= compiles to a ternary expression
+  eq a ?= b ?= 1, nonce
+  
+  e ?= f ?= g ?= 1
+  eq e + g, 2
+  
+  #need to ensure the two vars are not defined, hence the strange names;
+  # broke earlier when using c ?= d ?= 1 because `d` is declared elsewhere
+  eq und1_1348 ?= und2_1348 ?= 1, 1
+  
+  if a then a ?= 2 else a = 3
+  eq a, nonce
--- a/test/classes.coffee
+++ b/test/classes.coffee
@@ -278,8 +278,7 @@ test "classes with value'd constructors", ->

  counter = 0
  classMaker = ->
-    counter++
-    inner = counter
+    inner = ++counter
    ->
      @value = inner

@@ -289,10 +288,10 @@ test "classes with value'd constructors", ->
  class Two
    constructor: classMaker()

-  ok (new One).value is 1
-  ok (new Two).value is 2
-  ok (new One).value is 1
-  ok (new Two).value is 2
+  eq (new One).value, 1
+  eq (new Two).value, 2
+  eq (new One).value, 1
+  eq (new Two).value, 2


 test "exectuable class bodies", ->
@@ -438,12 +437,56 @@ test "`new` works against bare function", ->
    Date


-test "a subclass should be able to set its constructor to an external function", ->
-  
+test "#1182: a subclass should be able to set its constructor to an external function", ->
  ctor = ->
    @val = 1
  class A
  class B extends A
    constructor: ctor
-    
-  eq (new B).val, 1
+  eq (new B).val, 1
+
+test "#1182: external constructors continued", ->
+  ctor = ->
+  class A
+  class B extends A
+    method: ->
+    constructor: ctor
+  ok B::method
+
+test "#1313: misplaced __extends", ->
+  nonce = {}
+  class A
+  class B extends A
+    prop: nonce
+    constructor: ->
+  eq nonce, B::prop
+
+test "#1182: execution order needs to be considered as well", ->
+  counter = 0
+  makeFn = (n) -> eq n, ++counter; ->
+  class B extends (makeFn 1)
+    @B: makeFn 2
+    constructor: makeFn 3
+
+test "#1182: external constructors with bound functions", ->
+  fn = ->
+    {one: 1}
+  class B
+  class A
+    constructor: fn
+    method: => this instanceof A
+  ok (new A).method.call(new B)
+
+test "#1372: bound class methods with reserved names", ->
+  class C
+    delete: =>
+  ok C::delete
+
+test "#1380: `super` with reserved names", ->
+  class C
+    do: -> super
+  ok C::do
+
+  class B
+    0: -> super
+  ok B::[0]
--- a/test/comprehensions.coffee
+++ b/test/comprehensions.coffee
@@ -407,3 +407,24 @@ test "issue #1124: don't assign a variable in two scopes", ->
  lista = [1, 2, 3, 4, 5]
  listb = (_i + 1 for _i in lista)
  arrayEq [2, 3, 4, 5, 6], listb
+
+test "#1326: `by` value is uncached", ->
+  a = [0,1,2]
+  fi = gi = hi = 0
+  f = -> ++fi
+  g = -> ++gi
+  h = -> ++hi
+
+  forCompile = []
+  rangeCompileSimple = []
+
+  #exercises For.compile
+  for v,i in a by f() then forCompile.push i
+
+  #exercises Range.compileSimple
+  rangeCompileSimple = (i for i in [0..2] by g())
+
+  arrayEq a, forCompile
+  arrayEq a, rangeCompileSimple
+  #exercises Range.compile
+  eq "#{i for i in [0..2] by h()}", '0,1,2'
--- a/test/formatting.coffee
+++ b/test/formatting.coffee
@@ -116,3 +116,8 @@ test "indented heredoc", ->
                abc
                """)
  eq "abc", result
+
+# Nested blocks caused by paren unwrapping
+test "#1492: Nested blocks don't cause double semicolons", ->
+  js = CoffeeScript.compile '(0;0)'
+  eq -1, js.indexOf ';;'
--- a/test/function_invocation.coffee
+++ b/test/function_invocation.coffee
@@ -320,6 +320,11 @@ test "#904: Destructuring function arguments with same-named variables in scope"
  eq nonce, a
  eq nonce, b

+test "Simple Destructuring function arguments with same-named variables in scope", ->
+  x = 1
+  f = ([x]) -> x
+  eq f([2]), 2
+  eq x, 1

 test "caching base value", ->

@@ -438,8 +443,66 @@ test "don't wrap 'pure' statements in a closure", ->
      return item if item is nonce
  eq nonce, fn items

-#### Unusual `new` Usage

 test "usage of `new` is careful about where the invocation parens end up", ->
  eq 'object', typeof new try Array
  eq 'object', typeof new do -> ->
+
+
+test "implicit call against control structures", ->
+  result = null
+  save   = (obj) -> result = obj
+
+  save switch id false
+    when true
+      'true'
+    when false
+      'false'
+
+  eq result, 'false'
+
+  save if id false
+    'false'
+  else
+    'true'
+
+  eq result, 'true'
+
+  save unless id false
+    'true'
+  else
+    'false'
+
+  eq result, 'true'
+
+  save try
+    doesnt exist
+  catch error
+    'caught'
+
+  eq result, 'caught'
+
+  save try doesnt(exist) catch error then 'caught2'
+
+  eq result, 'caught2'
+
+
+test "#1420: things like `(fn() ->)`; there are no words for this one", ->
+  fn = -> (f) -> f()
+  nonce = {}
+  eq nonce, (fn() -> nonce)
+
+test "#1416: don't omit one 'new' when compiling 'new new'", ->
+  nonce = {}
+  obj = new new -> -> {prop: nonce}
+  eq obj.prop, nonce
+
+test "#1416: don't omit one 'new' when compiling 'new new fn()()'", ->
+  nonce = {}
+  argNonceA = {}
+  argNonceB = {}
+  fn = (a) -> (b) -> {a, b, prop: nonce}
+  obj = new new fn(argNonceA)(argNonceB)
+  eq obj.prop, nonce
+  eq obj.a, argNonceA
+  eq obj.b, argNonceB
--- a/test/interpolation.coffee
+++ b/test/interpolation.coffee
@@ -20,6 +20,20 @@ eq "#{ "{" }", "{"
 eq "#{ '#{}}' } }", '#{}} }'
 eq "#{"'#{ ({a: "b#{1}"}['a']) }'"}", "'b1'"

+# Issue #1150: String interpolation regression
+eq "#{'"/'}",                '"/'
+eq "#{"/'"}",                "/'"
+eq "#{/'"/}",                '/\'"/'
+eq "#{"'/" + '/"' + /"'/}",  '\'//"/"\'/'
+eq "#{"'/"}#{'/"'}#{/"'/}",  '\'//"/"\'/'
+eq "#{6 / 2}",               '3'
+eq "#{6 / 2}#{6 / 2}",       '33' # parsed as division
+eq "#{6 + /2}#{6/ + 2}",     '6/2}#{6/2' # parsed as a regex
+eq "#{6/2}
+    #{6/2}",                 '3    3' # newline cannot be part of a regex, so it's division
+eq "#{/// "'/'"/" ///}",     '/"\'\\/\'"\\/"/' # heregex, stuffed with spicy characters
+eq "#{/\\'/}",               "/\\\\'/"
+
 hello = 'Hello'
 world = 'World'
 ok '#{hello} #{world}!' is '#{hello} #{world}!'
--- a/test/numbers.coffee
+++ b/test/numbers.coffee
@@ -32,11 +32,15 @@ value = 0.0 + -.25 - -.75 + 0.0
 ok value is 0.5

 #764: Numbers should be indexable
+eq Number::toString,   4['toString']
 eq Number::toString, 4.2['toString']
 eq Number::toString, .42['toString']
+eq Number::toString, (4)['toString']

+eq Number::toString,   4.toString
 eq Number::toString, 4.2.toString
 eq Number::toString, .42.toString
+eq Number::toString, (4).toString

 test '#1168: leading floating point suppresses newline', ->
 	eq 1, do ->
--- a/test/objects.coffee
+++ b/test/objects.coffee
@@ -215,3 +215,21 @@ test "#1274: `{} = a()` compiles to `false` instead of `a()`", ->
  fn = -> a = true
  {} = fn()
  ok a
+
+test "#1436: `for` etc. work as normal property names", ->
+  obj = {}
+  eq no, obj.hasOwnProperty 'for'
+  obj.for = 'foo' of obj
+  eq yes, obj.hasOwnProperty 'for'
+
+test "#1322: implicit call against implicit object with block comments", ->
+  ((obj, arg) ->
+    eq obj.x * obj.y, 6
+    ok not arg
+  )
+    ###
+    x
+    ###
+    x: 2
+    ### y ###
+    y: 3
--- a/test/operators.coffee
+++ b/test/operators.coffee
@@ -187,6 +187,10 @@ test "#768: `in` should preserve evaluation order", ->
 test "#1099: empty array after `in` should compile to `false`", ->
  eq 1, [5 in []].length
  eq false, do -> return 0 in []
+  
+test "#1354: optimized `in` checks should not happen when splats are present", ->
+  a = [6, 9]
+  eq 9 in [3, a...], true


 # Chained Comparison
--- a/test/ranges.coffee
+++ b/test/ranges.coffee
@@ -83,3 +83,6 @@ test "#1012 slices with arguments object", ->
  arrayEq expected, argsAtEnd
  argsAtBoth = (-> [arguments[0]..arguments[1]]) 0, 9
  arrayEq expected, argsAtBoth
+
+test "#1409: creating large ranges outside of a function body", ->
+  CoffeeScript.eval '[0..100]'
--- a/test/scope.coffee
+++ b/test/scope.coffee
@@ -20,3 +20,15 @@ test "assignment to an Object.prototype-named variable should not leak to outer
    constructor = 'word'
  )()
  ok constructor isnt 'word'
+
+test "siblings of splat parameters shouldn't leak to surrounding scope", ->
+  x = 10
+  oops = (x, args...) ->
+  oops(20, 1, 2, 3)
+  eq x, 10
+
+test "catch statements should introduce their argument to scope", ->
+  try throw ''
+  catch e
+    do -> e = 5
+    eq 5, e
Author	SHA1	Message	Date
Jeremy Ashkenas	1a652a9736	CoffeeScript 1.1.2	2011-08-04 23:17:23 -04:00
Michael Ficarra	1f69200d06	Merge pull request #1542 from MichaelBlume/master Check for existence of this.context. Avoid build error.	2011-08-04 13:23:33 -07:00
Michael Ficarra	9f89a83c27	formatting and rewording a test	2011-08-01 17:28:52 -04:00
Mike Blume	178af9de56	check existence of this.context. Avoid build error https://github.com/jashkenas/coffee-script/issues/1541 with thanks to analyst74 whose bug report made the fix trivial =)	2011-07-31 18:45:30 +00:00
Michael Ficarra	e7854bec09	changed uses of the `slice` method to CS slices in `nodes.coffee`	2011-07-31 13:25:57 -04:00
satyr	9b9612e09c	fixed #1322 ; block comments no longer get out of implicitly called implicit objects	2011-07-27 18:49:48 +09:00
Michael Ficarra	d2d02bf91d	Cakefile: build:full exits unsuccessfully when tests or builds fail; test failures now print full stack trace	2011-07-18 17:47:31 -04:00
Jeremy Ashkenas	860c5030d2	Merge pull request #1527 from breckinloggins/fix_1446 Fix for issue #1446: Compiler fails with unrelated exception on file permissions problems	2011-07-18 12:38:23 -07:00
Breckin Loggins	2d54fea90c	Fix for issue #1446 : Compiler crashes on permissions error instead of giving meaningful error message	2011-07-18 14:29:45 -05:00
Breckin Loggins	5ee0254ce5	Merge branch 'master' of git://github.com/jashkenas/coffee-script	2011-07-18 14:21:09 -05:00
Jeremy Ashkenas	37019dab1c	Merge pull request #1522 from breckinloggins/fix_1470 Issue #1470: Command line compiler now assumes ".coffee" extension if left off of file names	2011-07-18 06:12:44 -07:00
Breckin Loggins	2b31f28f8f	Replacing heredoc in test with simple string	2011-07-17 15:50:42 -05:00
Michael Ficarra	8931e31991	improving test for #1492	2011-07-17 16:43:50 -04:00
Jeremy Ashkenas	813efbe1d3	Merge pull request #1517 from breckinloggins/master Patch for issue #1492 (consecutive semicolons in compiled output)	2011-07-17 13:31:32 -07:00
Jeremy Ashkenas	7790df0df6	Merge pull request #1518 from taku0/fix_pluckDirectCall Removed a garbage code in `pluckDirectCall`.	2011-07-17 09:21:29 -07:00
Jeremy Ashkenas	c2b32df22b	Merge pull request #1460 from yyyc514/fix_print_with_join compileJoin should happen once after all files are read	2011-07-17 09:11:32 -07:00
Breckin Loggins	479a2e0383	Using string interpolation when adding extension	2011-07-16 14:44:26 -05:00
Breckin Loggins	471cf1d51a	Issue #1470 : Cleaning up logic on extension detection	2011-07-16 14:42:45 -05:00
taku0	ecdaad2fd6	Removed a garbage code in `pluckDirectCall`. `args` are removed at `094b876a38`.	2011-07-17 02:31:50 +09:00
Breckin Loggins	3e20622bd5	Test implementation of issue #1470 . Assuming '.coffee' extension if file not found	2011-07-16 10:44:37 -05:00
Breckin Loggins	8a4a28bd33	Fixing issue #1492 : Consecutive semicolons in compiled output in some situations	2011-07-16 09:34:46 -05:00
Jeremy Ashkenas	8fe59ed888	Fixing funkiness introduced in #1498 .	2011-07-12 13:13:46 -04:00
Jeremy Ashkenas	1927213174	Merge pull request #1498 from breckinloggins/master Some typo corrections and minor documentation edits	2011-07-12 09:07:48 -07:00
Michael Ficarra	cb8e147212	arranged and formatted nonContextGlobals list in REPL	2011-07-11 13:08:47 -04:00
Michael Ficarra	07baed89ed	Added globals to the REPL that are (for a reason currently unknown to me) not provided by `vm.Script.createContext`	2011-07-11 12:55:29 -04:00
Michael Ficarra	af1cf3400e	fixes tab completion in the REPL	2011-07-10 14:26:31 -04:00
breckinloggins	eb53670676	Changing sentance structure in a grammar rule explanation	2011-07-09 18:33:19 -05:00
breckinloggins	709dc73c27	Removing 'the' from the CoffeeScript Compiler for Windows link	2011-07-09 11:52:02 -05:00
breckinloggins	14e09d2ca8	One more minor correction to main documentation	2011-07-09 10:03:04 -05:00
breckinloggins	0353b0ddd3	Small typo fixes in several files. Completed some missing documentation in nodes.coffee	2011-07-09 09:58:17 -05:00
breckinloggins	f2ba08f77f	Minor edits to the main documentation. Added a reference to @alisey's CoffeeScript Compiler for Windows.	2011-07-08 22:22:28 -05:00
Michael Ficarra	1d7d8cb4d2	Merge branch 'master' of github.com:jashkenas/coffee-script	2011-07-06 22:16:30 -04:00
Michael Ficarra	6e9cfd8a33	allow Ctrl-C to escape an unwanted continuation prompt	2011-07-06 22:15:35 -04:00
Michael Ficarra	2a9fd34a03	Made line continuations in the REPL much, much nicer and moved all of the REPL-specific code out of CoffeeScript.eval and into the REPL function (thanks for the suggestion, @TrevorBurnham)	2011-07-06 22:15:35 -04:00
Jeremy Ashkenas	b1111c96ca	fixes issue #1490 ... jsl.conf is incorrectly npmignored.	2011-07-06 22:15:35 -04:00
Michael Ficarra	55383155e5	More accurately emulating node's REPL behaviour with regard to `_` assignment. Also addresses `i for i in [1..3]` regression introduced by `fff4c9c672` and noticed by @satyr	2011-07-06 22:15:35 -04:00
Michael Ficarra	bb1502a9d7	output a newline before exiting REPL	2011-07-06 22:15:35 -04:00
Michael Ficarra	40ee30ecde	Fixes #1035 , #1425 , and #1444 : (another) overhaul of REPL and CoffeeScript.eval. Instead of writing about all the changes and why I made those decisions, I'll just answer any questions in the commit comments, so add a commit comment if you want to question anything. Thanks to @TrevorBurnham and @satyr for their help/contributions. Also, closes #1487. And still no REPL tests...	2011-07-06 22:15:35 -04:00
Jeremy Ashkenas	4ff00359b6	fixes #1478 , documentation.	2011-07-06 22:15:35 -04:00
Michael Ficarra	f433fa4187	improved test for #1436	2011-07-06 22:15:35 -04:00
Michael Ficarra	594ead00e8	improved tests for #1416 , fixed accidental scope leak in test for #1420	2011-07-06 22:15:35 -04:00
Timothy Jones	5adf3b8865	Fixes #1461 . Existential assignment now correctly reports if it is a statement.	2011-07-06 22:15:35 -04:00
Timothy Jones	4fc52cd08e	Fixes #1467 . Catch now introduces its parameter to scope.	2011-07-06 22:15:35 -04:00
Jann Horn	4af47f0c26	second part of fixing #1416	2011-07-06 22:15:35 -04:00
Jann Horn	9d3510a1e4	added another test for #1416	2011-07-06 22:15:35 -04:00
Jann Horn	18f6ad9583	fixes #1416 : don't omit one 'new' when compiling 'new new'	2011-07-06 22:15:35 -04:00
Jann Horn	4c70ea5e09	test for #1416 : don't omit one 'new' when compiling 'new new'	2011-07-06 22:15:35 -04:00
Jann Horn	d32c060e05	fixed #1436	2011-07-06 22:15:35 -04:00
Jann Horn	caa3d1ab5d	added a test for #1436 , `for` etc. should work as normal property names	2011-07-06 22:15:34 -04:00
Michael Ficarra	d3e809da38	subliminally promoting the use of interpolation in the documentation	2011-07-06 22:15:34 -04:00
Jeremy Ashkenas	5ab892d009	Merge pull request #1426 from jashkenas/documentationInterpolations promote the use of interpolation in the documentation	2011-07-06 17:52:32 -07:00
Michael Ficarra	54dbc0fdf8	allow Ctrl-C to escape an unwanted continuation prompt	2011-07-06 17:00:13 -04:00
Michael Ficarra	003f91d43d	Made line continuations in the REPL much, much nicer and moved all of the REPL-specific code out of CoffeeScript.eval and into the REPL function (thanks for the suggestion, @TrevorBurnham)	2011-07-06 16:36:07 -04:00
Jeremy Ashkenas	83806a4d77	Merge branch 'master' of github.com:jashkenas/coffee-script	2011-07-06 16:06:47 -04:00
Jeremy Ashkenas	c4324f1db2	fixes issue #1490 ... jsl.conf is incorrectly npmignored.	2011-07-06 16:06:17 -04:00
Michael Ficarra	b9c3e0e640	More accurately emulating node's REPL behaviour with regard to `_` assignment. Also addresses `i for i in [1..3]` regression introduced by `fff4c9c672` and noticed by @satyr	2011-07-06 13:06:18 -04:00
Michael Ficarra	60e51a238d	output a newline before exiting REPL	2011-07-06 13:05:07 -04:00
Michael Ficarra	fff4c9c672	Fixes #1035 , #1425 , and #1444 : (another) overhaul of REPL and CoffeeScript.eval. Instead of writing about all the changes and why I made those decisions, I'll just answer any questions in the commit comments, so add a commit comment if you want to question anything. Thanks to @TrevorBurnham and @satyr for their help/contributions. Also, closes #1487. And still no REPL tests...	2011-07-06 03:54:36 -04:00
Jeremy Ashkenas	18ab569b2d	Merge branch 'master' of github.com:jashkenas/coffee-script	2011-07-01 08:30:38 -04:00
Jeremy Ashkenas	2951d34dc0	fixes #1478 , documentation.	2011-07-01 08:30:12 -04:00
Michael Ficarra	0cc5379caa	improved test for #1436	2011-06-30 12:15:00 -04:00
Michael Ficarra	f6fcfa831c	Merge branch 'bugfix-1436' of git://github.com/thejh/coffee-script into thejh_1448	2011-06-30 11:53:24 -04:00
Michael Ficarra	c93fc3ec76	Merge branch 'master' of github.com:jashkenas/coffee-script	2011-06-30 11:46:32 -04:00
Michael Ficarra	7b5f012f79	improved tests for #1416 , fixed accidental scope leak in test for #1420	2011-06-30 11:35:29 -04:00
Timothy Jones	22cee5d2d6	Fixes #1461 . Existential assignment now correctly reports if it is a statement.	2011-06-29 18:54:23 -04:00
Timothy Jones	0f18dff464	Fixes #1467 . Catch now introduces its parameter to scope.	2011-06-29 18:54:23 -04:00
Timothy Jones	e38aeefb5c	Fixes #1461 . Existential assignment now correctly reports if it is a statement.	2011-06-26 03:08:38 +12:00
Timothy Jones	baa983ac33	Fixes #1467 . Catch now introduces its parameter to scope.	2011-06-26 02:34:52 +12:00
Josh Goebel	cd65c66cf9	combine conditions	2011-06-23 06:54:06 -04:00
Josh Goebel	dc272a680b	compileJoin should happen once after all files are read	2011-06-23 04:42:12 -04:00
ngn	6f64fc266d	added one more test for #1150	2011-06-22 19:42:07 +03:00
Jann Horn	73af3b17b1	second part of fixing #1416	2011-06-21 16:42:53 +02:00
Jann Horn	8b2884e40f	added another test for #1416	2011-06-21 16:42:20 +02:00
Jann Horn	f0c22f390d	fixes #1416 : don't omit one 'new' when compiling 'new new'	2011-06-20 18:38:29 +02:00
Jann Horn	11f2cd4515	test for #1416 : don't omit one 'new' when compiling 'new new'	2011-06-20 18:38:07 +02:00
ngn	5ce7984a2b	Another attempt to fix #1150 Here's how the algorithm in balancedString() was modified. When we encounter a slash in an interpolation, we: * try to find a heregex right after it; if found---skip it. Three slashes always terminate a heregex, no matter if there is an open "#{" before them or not, so we don't have to bother about sub-interpolations inside the heregex. * try to find a regex right after it; if found---skip it. Simple regexen can't contain interpolations. * otherwise, assume that the slash means division and carry on.	2011-06-19 20:05:38 +03:00
Jann Horn	9699059226	fixed #1436	2011-06-19 10:49:41 +02:00
Jann Horn	9941c3f045	added a test for #1436 , `for` etc. should work as normal property names	2011-06-19 10:49:19 +02:00
Michael Ficarra	25e7eeac8f	Revert "Merge https://github.com/ngn/coffee-script " This reverts commit `277e82bd03`, reversing changes made to `0f523de212`.	2011-06-17 11:53:48 -04:00
Michael Ficarra	277e82bd03	Merge https://github.com/ngn/coffee-script	2011-06-17 11:32:08 -04:00
Michael Ficarra	a1f1afe3ed	fixes #1442 : javascript literals should increase line count when they contain newlines	2011-06-17 11:26:39 -04:00
ngn	0f523de212	Fix for #1150 : String interpolation regression	2011-06-15 20:34:12 +03:00
Michael Ficarra	47f12c453a	subliminally promoting the use of interpolation in the documentation	2011-06-08 19:38:12 -04:00
Michael Ficarra	dfcff3f0fc	adding regression test for #1420 ; also cleaned up a little trailing whitespace in the function invocation tests	2011-06-07 04:10:40 -04:00
Michael Ficarra	522f2ee3b3	fixes #1420 : `(fn() ->)` by causing the `Lexer::tagParameters` method to give up looking for a parameter list when it saw a `CALL_START` token.	2011-06-07 03:58:36 -04:00
Michael Ficarra	8ce1fdb5bb	enhancement for fix to #1409 : when compiling as an array, ranges can't have been given steps (would be a SyntaxError) ... yet	2011-06-02 09:28:13 -04:00
Michael Ficarra	a0efdac8ce	removed trailing whitespace in source files	2011-06-02 02:00:47 -04:00
Michael Ficarra	22bc54f974	fixes #1409 : creating large ranges outside of a function body	2011-06-02 01:50:31 -04:00
Michael Ficarra	e240621a72	test for #1409	2011-06-02 01:49:28 -04:00
Michael Ficarra	35c2a72ad2	REPL blank line fix	2011-06-02 01:34:55 -04:00
Michael Ficarra	10ec1a659f	fixes #1398 : comments in the REPL	2011-05-28 22:39:27 -04:00
Jeremy Ashkenas	1fb34e42a6	Revert "fixed condext during construction of bound functions; now using native" This reverts commit `8d6e33c2cf`.	2011-05-28 18:58:48 -04:00
Jeremy Ashkenas	7082000e66	Revert "switched to canonical two-space indentation in __bind helper" This reverts commit `6a40807330`.	2011-05-28 18:58:38 -04:00
Jeremy Ashkenas	79fff367c2	Revert "__bind helper: caching ctor" This reverts commit `9cbf2a82ec`.	2011-05-28 18:58:28 -04:00
Michael Ficarra	9cbf2a82ec	__bind helper: caching ctor	2011-05-27 18:41:31 -04:00
Michael Ficarra	6a40807330	switched to canonical two-space indentation in __bind helper	2011-05-27 18:18:22 -04:00
Michael Ficarra	8d6e33c2cf	fixed condext during construction of bound functions; now using native Function::bind when it is available. related: #1363	2011-05-27 18:03:57 -04:00
Michael Ficarra	085874d5f3	hopefully the last enhancement for my #1380 fix	2011-05-25 12:57:45 -04:00
Michael Ficarra	94fb7e32ea	removing accidentally-committed `console.log`	2011-05-25 04:22:03 -04:00
Michael Ficarra	042f7ec791	enhancement for #1380 fix	2011-05-25 04:10:50 -04:00
Michael Ficarra	e4f47a05f6	merging @TrevorBurnham's pull request #1314 , enhancing `CS.eval`; closes #1314	2011-05-25 03:53:51 -04:00
Michael Ficarra	bbf37e5229	Merge pull request #1388 from johnyanarella/master 'coffee' silently fails with no output when the --join option is specified and the source files specified include directories	2011-05-25 00:47:05 -07:00
Michael Ficarra	454aa8433b	fixes #1390 : persistence of non-enumerable global properties in the REPL	2011-05-25 03:43:10 -04:00
Michael Ficarra	bbf1c6a8df	fixes #1380 : `super` with reserved names	2011-05-25 03:22:26 -04:00
Michael Ficarra	8e5eff5e1e	test for #1380	2011-05-25 03:22:06 -04:00
Michael Ficarra	e64fa71185	fixes #1372 : bound class methods with reserved names	2011-05-24 16:49:45 -04:00
Michael Ficarra	c8845643e5	fixes #1385 : property access on parenthesized number literals	2011-05-24 16:27:07 -04:00
John Yanarella	371ff5e726	Fixed silently failing command line --join functionality when directories are specified for compilation.	2011-05-24 15:01:35 -04:00
Michael Ficarra	19520d8d35	merging in @fjakobs's heregex line number fix; closes #1374	2011-05-19 13:59:58 -04:00
Fabian Jakobs	abb11a7c0e	fix line numbers after heregexps	2011-05-16 19:56:29 +02:00
Michael Ficarra	2ac74356bd	cleaned up and optimized fix for #1354 (`d91ccd4003`)	2011-05-15 21:46:35 -04:00
Jeremy Ashkenas	004f13f0fc	Merge pull request #1346 from adam-f/fixedsplatscope Fixed improper scoping of siblings to the splat argument.	2011-05-15 17:13:50 -07:00
Adam Freidin	395a97ef07	removing unimportant changes for easy pull.	2011-05-15 17:11:02 -07:00
Jeremy Ashkenas	01b0cfc8ab	Merge pull request #1324 from TrevorBurnham/node-modules Use `require.main` instead of loop to get main module	2011-05-15 17:04:40 -07:00
Jeremy Ashkenas	f3758e4af0	Fixes #1328	2011-05-15 19:59:52 -04:00
Jeremy Ashkenas	2563324ed8	merging #1353	2011-05-15 18:56:11 -04:00
Jeremy Ashkenas	d91ccd4003	Issue #1354 , 'in' with splatted arrays.	2011-05-15 18:50:04 -04:00
Jeremy Ashkenas	15ddb8e2ea	simplifying some string interpolation in Range#compileNode	2011-05-15 17:07:59 -04:00
Jeremy Ashkenas	c056c93e19	Issue #1356 ... range comprehension optimization when a step is present.	2011-05-15 17:05:05 -04:00
Jeremy Ashkenas	9e32a5bfa1	fixing implicit invocations against inline try/catch.	2011-05-15 15:04:29 -04:00
Jeremy Ashkenas	cd5c41f351	Issue #1364 , implicit calls against control structures.	2011-05-15 10:41:41 -04:00
Jeremy Ashkenas	b780d707ab	fixing over whitespace-ing from the previous commit.	2011-05-15 10:16:46 -04:00
Jeremy Ashkenas	84ae563368	Merge branch 'master' of github.com:jashkenas/coffee-script	2011-05-15 10:08:55 -04:00
Jeremy Ashkenas	dddc7c6edb	Issue #1368 , block comment formatting.	2011-05-15 10:08:31 -04:00
Gerald Lewis	bd8d82809b	Updated tests for #1216 and pull #1348	2011-05-11 09:11:41 -04:00
Gerald Lewis	51b7142805	Fix for #1216 and pull #1348 ; preserves original semantics while prettying the compiled output	2011-05-11 09:10:58 -04:00
Michael Ficarra	6c9ef76b95	fixed behavioural change accidentally introduced by #1348 , thanks @satyr	2011-05-11 00:08:24 -04:00
Michael Ficarra	a024ec5b27	reverting tests from @geraldalewis's fix for #1216	2011-05-10 23:23:31 -04:00
Gerald Lewis	2212e959ac	Fix for #1216 ?= compilation	2011-05-10 19:33:30 -04:00
Jeremy Ashkenas	d4d027159f	rebuilding browser/source	2011-05-10 10:04:25 -04:00
Jeremy Ashkenas	a8a581acae	Never return from a constructor.	2011-05-10 10:03:22 -04:00
Jeremy Ashkenas	9e4fa02cdb	CoffeeScript 1.1.1	2011-05-10 09:27:19 -04:00
Jeremy Ashkenas	6d6e07604e	Fixing external constructors / order of execution for once and for all ... knock on wood.	2011-05-10 09:24:20 -04:00
Adam Freidin	dc499089e9	fixed name of simple destructuring test.	2011-05-08 15:00:27 -07:00
Michael Ficarra	f4b8e19c7f	adding another failing test case related to #1182	2011-05-08 17:16:45 -04:00
Adam Freidin	1809c0e675	fixed 2nd scoping problem x = 10 ([x]) -> # used to not declare var x this is one fix, the other way to fix it is to remove the entire if ... olen is 1 .... block... not sure if that's a good idea or not.	2011-05-08 04:59:44 -07:00
Adam Freidin	d11d69958f	Removed extra index variable left from code thrash	2011-05-08 04:32:47 -07:00
Adam Freidin	6d2733405d	Fixed splat sibling variable scope leak.	2011-05-07 20:46:08 -07:00
Adam Freidin	2dc2d162bc	variadic arguments breaking out of scope (test)	2011-05-07 16:55:27 -07:00
Michael Ficarra	56b2b02637	some cleanup, renaming temporary variable from `_by` to `_step`	2011-05-06 23:10:46 -04:00
Michael Ficarra	d031c26229	Merge git://github.com/geraldalewis/coffee-script into geraldalewis_issue1326	2011-05-06 22:53:26 -04:00
Michael Ficarra	4046fcf971	adding failing test case for #1182 execution order bug mentioned by @satyr	2011-05-06 09:48:12 -04:00
Michael Ficarra	7a4fd2ec01	slightly improved fix for #1182 and #1313	2011-05-06 09:47:40 -04:00
Michael Ficarra	73731ba155	Merge branch 'issue1313'	2011-05-06 01:10:27 -04:00
Michael Ficarra	8781a148db	issues #1313 and #1182 : better class compilation in presence of externally defined constructors and inheritence via `extends`. Thanks to @stephank for the suggested approach.	2011-05-06 01:00:35 -04:00
Gerald Lewis	0e978a0d99	Merge branch 'issue_1326'	2011-05-04 13:14:46 -04:00
Gerald Lewis	ac46ede170	Fix for #1326 by value is uncached	2011-05-04 13:12:05 -04:00
Satoshi Murakami	ad669fc23a	command: JSLint => JavaScript Lint	2011-05-04 10:04:17 -07:00
Trevor Burnham	b9d3bc5b44	`x = {} if x` -> `x and= {}`, per Michael's suggestion https://github.com/jashkenas/coffee-script/pull/1324/files#r25463	2011-05-03 17:06:34 -04:00
Trevor Burnham	fa2ed81485	Renaming `root` to `mainModule` in `run` method	2011-05-03 15:53:10 -04:00
Trevor Burnham	ea4a723379	Simpler method of getting the root module	2011-05-03 15:47:39 -04:00
Jeremy Ashkenas	71bcdb91c8	fixing changelog -- it was a regression from an earlier commit, not a true fix.	2011-05-01 14:29:48 -04:00
Jeremy Ashkenas	08294dc4d6	s/process.mainModule/require.main	2011-05-01 13:45:47 -04:00