CoffeeScript 1.3.3

Fixes #2331 -- bound 'super' regression
Fixes broken autocompletion from 8bc6001d27
2026-01-13 08:47:55 -05:00 · 2012-05-15 12:35:40 -04:00 · 2012-05-15 12:30:51 -04:00 · 2012-05-15 02:25:28 -04:00 · 2012-05-14 21:07:54 -04:00 · 2012-05-14 17:50:04 -04:00
105 changed files with 3932 additions and 1724 deletions
--- a/1
+++ b/1
@@ -0,0 +1 @@
+coffeescript.org
--- a/10
+++ b/10
@@ -11,10 +11,10 @@ unless process.platform is 'win32'

 bold = red = green = reset = ''
 if enableColors
-  bold  = '\033[0;1m'
-  red   = '\033[0;31m'
-  green = '\033[0;32m'
-  reset = '\033[0m'
+  bold  = '\x1B[0;1m'
+  red   = '\x1B[0;31m'
+  green = '\x1B[0;32m'
+  reset = '\x1B[0m'

 # Built file header.
 header = """
@@ -34,7 +34,7 @@ sources = [

 # Run a CoffeeScript through our node/coffee interpreter.
 run = (args, cb) ->
-  proc =         spawn 'bin/coffee', args
+  proc =         spawn 'node', ['bin/coffee'].concat(args)
  proc.stderr.on 'data', (buffer) -> console.log buffer.toString()
  proc.on        'exit', (status) ->
    process.exit(1) if status != 0
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-Copyright (c) 2011 Jeremy Ashkenas
+Copyright (c) 2009-2012 Jeremy Ashkenas

 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
--- a/documentation/coffee/block_comment.coffee
+++ b/documentation/coffee/block_comment.coffee
@@ -1,5 +1,5 @@
 ###
-CoffeeScript Compiler v1.2.0
+CoffeeScript Compiler v1.3.3
 Released under the MIT License
 ###

--- a/documentation/coffee/conditionals.coffee
+++ b/documentation/coffee/conditionals.coffee
@@ -8,6 +8,5 @@ else

 date = if friday then sue else jill

-options or= defaults


--- a/documentation/coffee/existence.coffee
+++ b/documentation/coffee/existence.coffee
@@ -1,6 +1,7 @@
 solipsism = true if mind? and not world?

-speed ?= 75
+speed = 0
+speed ?= 15

 footprints = yeti ? "bear"

--- a/documentation/coffee/slices.coffee
+++ b/documentation/coffee/slices.coffee
@@ -1,7 +1,9 @@
-numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

-copy    = numbers[0...numbers.length]
+start   = numbers[0..2]

-middle  = copy[3..6]
+middle  = numbers[3...6]

+end     = numbers[6..]

+copy    = numbers[..]
--- a/documentation/docs/browser.html
+++ b/documentation/docs/browser.html
@@ -1,5 +1,6 @@
 <!DOCTYPE html>  <html> <head>   <title>browser.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>               browser.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>Override exported methods for non-Node.js engines.</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">CoffeeScript.require = </span><span class="nx">require</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>Use standard JavaScript <code>eval</code> to eval code.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CoffeeScript.eval = </span><span class="nf">(code, options) -&gt;</span>
+<span class="nv">CoffeeScript.require = </span><span class="nx">require</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>Use standard JavaScript <code>eval</code> to eval code.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CoffeeScript.eval = </span><span class="nf">(code, options = {}) -&gt;</span>
+  <span class="nx">options</span><span class="p">.</span><span class="nx">bare</span> <span class="o">?=</span> <span class="kc">on</span>
  <span class="nb">eval</span> <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">options</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-3">&#182;</a>               </div>               <p>Running code does not provide access to this scope.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CoffeeScript.run = </span><span class="nf">(code, options = {}) -&gt;</span>
  <span class="nv">options.bare = </span><span class="kc">on</span>
  <span class="nb">Function</span><span class="p">(</span><span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">)()</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>If we're not in a browser environment, we're finished with the public API.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">return</span> <span class="nx">unless</span> <span class="nb">window</span><span class="o">?</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>Load a remote script from the current domain via XHR.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CoffeeScript.load = </span><span class="nf">(url, callback) -&gt;</span>
--- a/documentation/docs/cake.html
+++ b/documentation/docs/cake.html
@@ -25,7 +25,7 @@ If no tasks are passed, print the help screen. Keep a reference to the
 original directory name, when running Cake tasks from subdirectories.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.run = </span><span class="o">-&gt;</span>
  <span class="nv">global.__originalDirname = </span><span class="nx">fs</span><span class="p">.</span><span class="nx">realpathSync</span> <span class="s1">&#39;.&#39;</span>
  <span class="nx">process</span><span class="p">.</span><span class="nx">chdir</span> <span class="nx">cakefileDirectory</span> <span class="nx">__originalDirname</span>
-  <span class="nv">args = </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="mi">2</span>
+  <span class="nv">args = </span><span class="nx">process</span><span class="p">.</span><span class="nx">argv</span><span class="p">[</span><span class="mi">2</span><span class="p">..]</span>
  <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">run</span> <span class="nx">fs</span><span class="p">.</span><span class="nx">readFileSync</span><span class="p">(</span><span class="s1">&#39;Cakefile&#39;</span><span class="p">).</span><span class="nx">toString</span><span class="p">(),</span> <span class="nv">filename: </span><span class="s1">&#39;Cakefile&#39;</span>
  <span class="nv">oparse = </span><span class="k">new</span> <span class="nx">optparse</span><span class="p">.</span><span class="nx">OptionParser</span> <span class="nx">switches</span>
  <span class="k">return</span> <span class="nx">printTasks</span><span class="p">()</span> <span class="nx">unless</span> <span class="nx">args</span><span class="p">.</span><span class="nx">length</span>
@@ -34,7 +34,8 @@ original directory name, when running Cake tasks from subdirectories.</p>
  <span class="k">catch</span> <span class="nx">e</span>
    <span class="k">return</span> <span class="nx">fatalError</span> <span class="s2">&quot;#{e}&quot;</span>
  <span class="nx">invoke</span> <span class="nx">arg</span> <span class="k">for</span> <span class="nx">arg</span> <span class="k">in</span> <span class="nx">options</span><span class="p">.</span><span class="nx">arguments</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>Display the list of Cake tasks in a format similar to <code>rake -T</code></p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">printTasks = </span><span class="o">-&gt;</span>
-  <span class="nv">cakefilePath = </span><span class="nx">path</span><span class="p">.</span><span class="nx">join</span> <span class="nx">path</span><span class="p">.</span><span class="nx">relative</span><span class="p">(</span><span class="nx">__originalDirname</span><span class="p">,</span> <span class="nx">process</span><span class="p">.</span><span class="nx">cwd</span><span class="p">()),</span> <span class="s1">&#39;Cakefile&#39;</span>
+  <span class="nv">relative = </span><span class="nx">path</span><span class="p">.</span><span class="nx">relative</span> <span class="o">or</span> <span class="nx">path</span><span class="p">.</span><span class="nx">resolve</span>
+  <span class="nv">cakefilePath = </span><span class="nx">path</span><span class="p">.</span><span class="nx">join</span> <span class="nx">relative</span><span class="p">(</span><span class="nx">__originalDirname</span><span class="p">,</span> <span class="nx">process</span><span class="p">.</span><span class="nx">cwd</span><span class="p">()),</span> <span class="s1">&#39;Cakefile&#39;</span>
  <span class="nx">console</span><span class="p">.</span><span class="nx">log</span> <span class="s2">&quot;#{cakefilePath} defines the following tasks:\n&quot;</span>
  <span class="k">for</span> <span class="nx">name</span><span class="p">,</span> <span class="nx">task</span> <span class="k">of</span> <span class="nx">tasks</span>
    <span class="nv">spaces = </span><span class="mi">20</span> <span class="o">-</span> <span class="nx">name</span><span class="p">.</span><span class="nx">length</span>
--- a/documentation/docs/coffee-script.html
+++ b/documentation/docs/coffee-script.html
@@ -13,14 +13,17 @@ execute all scripts present in <code>text/coffeescript</code> tags.</p>
    <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="nf">(content) -&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.2.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="nf">(content) -&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.3.3&#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="nf">(code, options = {}) -&gt;</span>
  <span class="p">{</span><span class="nx">merge</span><span class="p">}</span> <span class="o">=</span> <span class="nx">exports</span><span class="p">.</span><span class="nx">helpers</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">merge</span> <span class="p">{},</span> <span class="nx">options</span>
+    <span class="nv">js = </span><span class="p">(</span><span class="nx">parser</span><span class="p">.</span><span class="nx">parse</span> <span class="nx">lexer</span><span class="p">.</span><span class="nx">tokenize</span> <span class="nx">code</span><span class="p">).</span><span class="nx">compile</span> <span class="nx">options</span>
+    <span class="k">return</span> <span class="nx">js</span> <span class="nx">unless</span> <span class="nx">options</span><span class="p">.</span><span class="nx">header</span>
  <span class="k">catch</span> <span class="nx">err</span>
    <span class="nv">err.message = </span><span class="s2">&quot;In #{options.filename}, #{err.message}&quot;</span> <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">filename</span>
-    <span class="k">throw</span> <span class="nx">err</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>Tokenize a string of CoffeeScript code, and return the array of tokens.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.tokens = </span><span class="nf">(code, options) -&gt;</span>
+    <span class="k">throw</span> <span class="nx">err</span>
+  <span class="nv">header = </span><span class="s2">&quot;Generated by CoffeeScript #{@VERSION}&quot;</span>
+  <span class="s2">&quot;// #{header}\n#{js}&quot;</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>Tokenize a string of CoffeeScript code, and return the array of tokens.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.tokens = </span><span class="nf">(code, options) -&gt;</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">options</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>Parse a string of CoffeeScript code or an array of lexed tokens, and
 return the AST. You can then compile it by calling <code>.compile()</code> on the root,
 or traverse it by using <code>.traverseChildren()</code> with a callback.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.nodes = </span><span class="nf">(source, options) -&gt;</span>
@@ -28,9 +31,9 @@ or traverse it by using <code>.traverseChildren()</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="nf">(code, options) -&gt;</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="nf">(code, options = {}) -&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="nv">mainModule.paths = </span><span class="nx">require</span><span class="p">(</span><span class="s1">&#39;module&#39;</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="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="nv">mainModule.paths = </span><span class="nx">require</span><span class="p">(</span><span class="s1">&#39;module&#39;</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">fs</span><span class="p">.</span><span class="nx">realpathSync</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">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).
--- a/documentation/docs/command.html
+++ b/documentation/docs/command.html
@@ -11,11 +11,13 @@ interactive REPL.</p>             </td>             <td class="code">
 <span class="p">{</span><span class="nx">EventEmitter</span><span class="p">}</span> <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;events&#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>Allow CoffeeScript to emit Node.js events.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nx">helpers</span><span class="p">.</span><span class="nx">extend</span> <span class="nx">CoffeeScript</span><span class="p">,</span> <span class="k">new</span> <span class="nx">EventEmitter</span>

 <span class="nv">printLine = </span><span class="nf">(line) -&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="nx">line</span> <span class="o">+</span> <span class="s1">&#39;\n&#39;</span>
-<span class="nv">printWarn = </span><span class="nf">(line) -&gt;</span> <span class="nx">process</span><span class="p">.</span><span class="nx">stderr</span><span class="p">.</span><span class="nx">write</span> <span class="nx">line</span> <span class="o">+</span> <span class="s1">&#39;\n&#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>The help banner that is printed when <code>coffee</code> is called without arguments.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">BANNER = </span><span class="s1">&#39;&#39;&#39;</span>
-<span class="s1">  Usage: coffee [options] path/to/script.coffee</span>
+<span class="nv">printWarn = </span><span class="nf">(line) -&gt;</span> <span class="nx">process</span><span class="p">.</span><span class="nx">stderr</span><span class="p">.</span><span class="nx">write</span> <span class="nx">line</span> <span class="o">+</span> <span class="s1">&#39;\n&#39;</span>
+
+<span class="nv">hidden = </span><span class="nf">(file) -&gt;</span> <span class="o">/^</span><span class="err">\</span><span class="p">.</span><span class="o">|~</span><span class="nx">$</span><span class="err">/.test file</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>The help banner that is printed when <code>coffee</code> is called without arguments.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">BANNER = </span><span class="s1">&#39;&#39;&#39;</span>
+<span class="s1">  Usage: coffee [options] path/to/script.coffee -- [args]</span>

 <span class="s1">  If called without options, `coffee` will run your script.</span>
-<span class="s1">         &#39;&#39;&#39;</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>The list of all the valid option flags that <code>coffee</code> knows how to handle.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">SWITCHES = </span><span class="p">[</span>
+<span class="s1">&#39;&#39;&#39;</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>The list of all the valid option flags that <code>coffee</code> knows how to handle.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">SWITCHES = </span><span class="p">[</span>
  <span class="p">[</span><span class="s1">&#39;-b&#39;</span><span class="p">,</span> <span class="s1">&#39;--bare&#39;</span><span class="p">,</span>            <span class="s1">&#39;compile without a top-level function wrapper&#39;</span><span class="p">]</span>
  <span class="p">[</span><span class="s1">&#39;-c&#39;</span><span class="p">,</span> <span class="s1">&#39;--compile&#39;</span><span class="p">,</span>         <span class="s1">&#39;compile to JavaScript and save as .js files&#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;pass a string from the command line as input&#39;</span><span class="p">]</span>
@@ -47,13 +49,12 @@ Many flags cause us to divert before compiling anything. Flags passed after
  <span class="nx">loadRequires</span><span class="p">()</span>                         <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">require</span>
  <span class="k">return</span> <span class="nx">require</span> <span class="s1">&#39;./repl&#39;</span>                <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">interactive</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">!</span><span class="nx">fs</span><span class="p">.</span><span class="nx">watch</span>
-    <span class="nx">printWarn</span> <span class="s2">&quot;The --watch feature depends on Node v0.6.0+. You are running #{process.version}.&quot;</span>
+    <span class="k">return</span> <span class="nx">printWarn</span> <span class="s2">&quot;The --watch feature depends on Node v0.6.0+. You are running #{process.version}.&quot;</span>
  <span class="k">return</span> <span class="nx">compileStdio</span><span class="p">()</span>                  <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">stdio</span>
  <span class="k">return</span> <span class="nx">compileScript</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">sources</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>  <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nb">eval</span>
  <span class="k">return</span> <span class="nx">require</span> <span class="s1">&#39;./repl&#39;</span>                <span class="nx">unless</span> <span class="nx">sources</span><span class="p">.</span><span class="nx">length</span>
-  <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">run</span>
-    <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 = </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="nv">literals = </span><span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">run</span> <span class="k">then</span> <span class="nx">sources</span><span class="p">.</span><span class="nx">splice</span> <span class="mi">1</span> <span class="k">else</span> <span class="p">[]</span>
+  <span class="nv">process.argv = </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="mi">1</span><span class="p">].</span><span class="nx">concat</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">require</span><span class="p">.</span><span class="nx">main</span><span class="p">.</span><span class="nx">filename</span>
  <span class="k">for</span> <span class="nx">source</span> <span class="k">in</span> <span class="nx">sources</span>
@@ -75,11 +76,12 @@ and all subdirectories.</p>             </td>             <td class="code">
      <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="nf">(err, files) -&gt;</span>
        <span class="k">throw</span> <span class="nx">err</span> <span class="k">if</span> <span class="nx">err</span> <span class="o">and</span> <span class="nx">err</span><span class="p">.</span><span class="nx">code</span> <span class="o">isnt</span> <span class="s1">&#39;ENOENT&#39;</span>
        <span class="k">return</span> <span class="k">if</span> <span class="nx">err</span><span class="o">?</span><span class="p">.</span><span class="nx">code</span> <span class="o">is</span> <span class="s1">&#39;ENOENT&#39;</span>
-        <span class="nv">files = </span><span class="nx">files</span><span class="p">.</span><span class="nx">map</span> <span class="nf">(file) -&gt;</span> <span class="nx">path</span><span class="p">.</span><span class="nx">join</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">file</span>
        <span class="nv">index = </span><span class="nx">sources</span><span class="p">.</span><span class="nx">indexOf</span> <span class="nx">source</span>
-        <span class="nx">sources</span><span class="p">[</span><span class="nx">index</span><span class="p">..</span><span class="nx">index</span><span class="p">]</span> <span class="o">=</span> <span class="nx">files</span>
+        <span class="nv">files = </span><span class="nx">files</span><span class="p">.</span><span class="nx">filter</span> <span class="nf">(file) -&gt;</span> <span class="o">not</span> <span class="nx">hidden</span> <span class="nx">file</span>
+        <span class="nx">sources</span><span class="p">[</span><span class="nx">index</span><span class="p">..</span><span class="nx">index</span><span class="p">]</span> <span class="o">=</span> <span class="p">(</span><span class="nx">path</span><span class="p">.</span><span class="nx">join</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">file</span> <span class="k">for</span> <span class="nx">file</span> <span class="k">in</span> <span class="nx">files</span><span class="p">)</span>
        <span class="nx">sourceCode</span><span class="p">[</span><span class="nx">index</span><span class="p">..</span><span class="nx">index</span><span class="p">]</span> <span class="o">=</span> <span class="nx">files</span><span class="p">.</span><span class="nx">map</span> <span class="o">-&gt;</span> <span class="kc">null</span>
-        <span class="nx">compilePath</span> <span class="nx">file</span><span class="p">,</span> <span class="kc">no</span><span class="p">,</span> <span class="nx">base</span> <span class="k">for</span> <span class="nx">file</span> <span class="k">in</span> <span class="nx">files</span>
+        <span class="nx">files</span><span class="p">.</span><span class="nx">forEach</span> <span class="nf">(file) -&gt;</span>
+          <span class="nx">compilePath</span> <span class="p">(</span><span class="nx">path</span><span class="p">.</span><span class="nx">join</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">file</span><span class="p">),</span> <span class="kc">no</span><span class="p">,</span> <span class="nx">base</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">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="nx">fs</span><span class="p">.</span><span class="nx">readFile</span> <span class="nx">source</span><span class="p">,</span> <span class="nf">(err, code) -&gt;</span>
@@ -111,7 +113,7 @@ requested options. If evaluating the script directly sets <code>__filename</code
  <span class="k">catch</span> <span class="nx">err</span>
    <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">emit</span> <span class="s1">&#39;failure&#39;</span><span class="p">,</span> <span class="nx">err</span><span class="p">,</span> <span class="nx">task</span>
    <span class="k">return</span> <span class="k">if</span> <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">listeners</span><span class="p">(</span><span class="s1">&#39;failure&#39;</span><span class="p">).</span><span class="nx">length</span>
-    <span class="k">return</span> <span class="nx">printLine</span> <span class="nx">err</span><span class="p">.</span><span class="nx">message</span> <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">watch</span>
+    <span class="k">return</span> <span class="nx">printLine</span> <span class="nx">err</span><span class="p">.</span><span class="nx">message</span> <span class="o">+</span> <span class="s1">&#39;\x07&#39;</span> <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">watch</span>
    <span class="nx">printWarn</span> <span class="nx">err</span> <span class="k">instanceof</span> <span class="nb">Error</span> <span class="o">and</span> <span class="nx">err</span><span class="p">.</span><span class="nx">stack</span> <span class="o">or</span> <span class="s2">&quot;ERROR: #{err}&quot;</span>
    <span class="nx">process</span><span class="p">.</span><span class="nx">exit</span> <span class="mi">1</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>Attach the appropriate listeners to compile scripts incoming over <strong>stdin</strong>,
 and write them back to <strong>stdout</strong>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">compileStdio = </span><span class="o">-&gt;</span>
@@ -141,8 +143,12 @@ such as <code>--lint</code> or <code>--print</code>.</p>             </td>
  <span class="nv">watchErr = </span><span class="nf">(e) -&gt;</span>
    <span class="k">if</span> <span class="nx">e</span><span class="p">.</span><span class="nx">code</span> <span class="o">is</span> <span class="s1">&#39;ENOENT&#39;</span>
      <span class="k">return</span> <span class="k">if</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">is</span> <span class="o">-</span><span class="mi">1</span>
-      <span class="nx">removeSource</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">base</span><span class="p">,</span> <span class="kc">yes</span>
-      <span class="nx">compileJoin</span><span class="p">()</span>
+      <span class="k">try</span>
+        <span class="nx">rewatch</span><span class="p">()</span>
+        <span class="nx">compile</span><span class="p">()</span>
+      <span class="k">catch</span> <span class="nx">e</span>
+        <span class="nx">removeSource</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">base</span><span class="p">,</span> <span class="kc">yes</span>
+        <span class="nx">compileJoin</span><span class="p">()</span>
    <span class="k">else</span> <span class="k">throw</span> <span class="nx">e</span>

  <span class="nv">compile = </span><span class="o">-&gt;</span>
@@ -150,32 +156,22 @@ such as <code>--lint</code> or <code>--print</code>.</p>             </td>
    <span class="nv">compileTimeout = </span><span class="nx">wait</span> <span class="mi">25</span><span class="p">,</span> <span class="o">-&gt;</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="nf">(err, stats) -&gt;</span>
        <span class="k">return</span> <span class="nx">watchErr</span> <span class="nx">err</span> <span class="k">if</span> <span class="nx">err</span>
-        <span class="k">return</span> <span class="k">if</span> <span class="nx">prevStats</span> <span class="o">and</span> <span class="p">(</span><span class="nx">stats</span><span class="p">.</span><span class="nx">size</span> <span class="o">is</span> <span class="nx">prevStats</span><span class="p">.</span><span class="nx">size</span> <span class="o">and</span>
-          <span class="nx">stats</span><span class="p">.</span><span class="nx">mtime</span><span class="p">.</span><span class="nx">getTime</span><span class="p">()</span> <span class="o">is</span> <span class="nx">prevStats</span><span class="p">.</span><span class="nx">mtime</span><span class="p">.</span><span class="nx">getTime</span><span class="p">())</span>
+        <span class="k">return</span> <span class="nx">rewatch</span><span class="p">()</span> <span class="k">if</span> <span class="nx">prevStats</span> <span class="o">and</span> <span class="nx">stats</span><span class="p">.</span><span class="nx">size</span> <span class="o">is</span> <span class="nx">prevStats</span><span class="p">.</span><span class="nx">size</span> <span class="o">and</span>
+          <span class="nx">stats</span><span class="p">.</span><span class="nx">mtime</span><span class="p">.</span><span class="nx">getTime</span><span class="p">()</span> <span class="o">is</span> <span class="nx">prevStats</span><span class="p">.</span><span class="nx">mtime</span><span class="p">.</span><span class="nx">getTime</span><span class="p">()</span>
        <span class="nv">prevStats = </span><span class="nx">stats</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="nf">(err, code) -&gt;</span>
          <span class="k">return</span> <span class="nx">watchErr</span> <span class="nx">err</span> <span class="k">if</span> <span class="nx">err</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="nv">watchErr = </span><span class="nf">(e) -&gt;</span>
-    <span class="k">throw</span> <span class="nx">e</span> <span class="nx">unless</span> <span class="nx">e</span><span class="p">.</span><span class="nx">code</span> <span class="o">is</span> <span class="s1">&#39;ENOENT&#39;</span>
-    <span class="nx">removeSource</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">base</span><span class="p">,</span> <span class="kc">yes</span>
-    <span class="nx">compileJoin</span><span class="p">()</span>
+          <span class="nx">rewatch</span><span class="p">()</span>

  <span class="k">try</span>
-    <span class="nv">watcher = </span><span class="nx">fs</span><span class="p">.</span><span class="nx">watch</span> <span class="nx">source</span><span class="p">,</span> <span class="nv">callback = </span><span class="nf">(event) -&gt;</span>
-      <span class="k">if</span> <span class="nx">event</span> <span class="o">is</span> <span class="s1">&#39;change&#39;</span>
-        <span class="nx">compile</span><span class="p">()</span>
-      <span class="k">else</span> <span class="k">if</span> <span class="nx">event</span> <span class="o">is</span> <span class="s1">&#39;rename&#39;</span>
-        <span class="nx">watcher</span><span class="p">.</span><span class="nx">close</span><span class="p">()</span>
-        <span class="nx">wait</span> <span class="mi">250</span><span class="p">,</span> <span class="o">-&gt;</span>
-          <span class="nx">compile</span><span class="p">()</span>
-          <span class="k">try</span>
-            <span class="nv">watcher = </span><span class="nx">fs</span><span class="p">.</span><span class="nx">watch</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">callback</span>
-          <span class="k">catch</span> <span class="nx">e</span>  
-            <span class="nx">watchErr</span> <span class="nx">e</span>
-  <span class="k">catch</span> <span class="nx">e</span> 
-    <span class="nx">watchErr</span> <span class="nx">e</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>Watch a directory of files for new additions.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">watchDir = </span><span class="nf">(source, base) -&gt;</span>
+    <span class="nv">watcher = </span><span class="nx">fs</span><span class="p">.</span><span class="nx">watch</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">compile</span>
+  <span class="k">catch</span> <span class="nx">e</span>
+    <span class="nx">watchErr</span> <span class="nx">e</span>
+
+  <span class="nv">rewatch = </span><span class="o">-&gt;</span>
+    <span class="nx">watcher</span><span class="o">?</span><span class="p">.</span><span class="nx">close</span><span class="p">()</span>
+    <span class="nv">watcher = </span><span class="nx">fs</span><span class="p">.</span><span class="nx">watch</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">compile</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>Watch a directory of files for new additions.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">watchDir = </span><span class="nf">(source, base) -&gt;</span>
  <span class="nv">readdirTimeout = </span><span class="kc">null</span>
  <span class="k">try</span>
    <span class="nv">watcher = </span><span class="nx">fs</span><span class="p">.</span><span class="nx">watch</span> <span class="nx">source</span><span class="p">,</span> <span class="o">-&gt;</span>
@@ -186,8 +182,8 @@ such as <code>--lint</code> or <code>--print</code>.</p>             </td>
            <span class="k">throw</span> <span class="nx">err</span> <span class="nx">unless</span> <span class="nx">err</span><span class="p">.</span><span class="nx">code</span> <span class="o">is</span> <span class="s1">&#39;ENOENT&#39;</span>
            <span class="nx">watcher</span><span class="p">.</span><span class="nx">close</span><span class="p">()</span>
            <span class="k">return</span> <span class="nx">unwatchDir</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">base</span>
-          <span class="nv">files = </span><span class="nx">files</span><span class="p">.</span><span class="nx">map</span> <span class="nf">(file) -&gt;</span> <span class="nx">path</span><span class="p">.</span><span class="nx">join</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">file</span>
-          <span class="k">for</span> <span class="nx">file</span> <span class="k">in</span> <span class="nx">files</span> <span class="k">when</span> <span class="o">not</span> <span class="nx">notSources</span><span class="p">[</span><span class="nx">file</span><span class="p">]</span>
+          <span class="k">for</span> <span class="nx">file</span> <span class="k">in</span> <span class="nx">files</span> <span class="k">when</span> <span class="o">not</span> <span class="nx">hidden</span><span class="p">(</span><span class="nx">file</span><span class="p">)</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">notSources</span><span class="p">[</span><span class="nx">file</span><span class="p">]</span>
+            <span class="nv">file = </span><span class="nx">path</span><span class="p">.</span><span class="nx">join</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">file</span>
            <span class="k">continue</span> <span class="k">if</span> <span class="nx">sources</span><span class="p">.</span><span class="nx">some</span> <span class="nf">(s) -&gt;</span> <span class="nx">s</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">file</span><span class="p">)</span> <span class="o">&gt;=</span> <span class="mi">0</span>
            <span class="nx">sources</span><span class="p">.</span><span class="nx">push</span> <span class="nx">file</span>
            <span class="nx">sourceCode</span><span class="p">.</span><span class="nx">push</span> <span class="kc">null</span>
@@ -196,7 +192,7 @@ such as <code>--lint</code> or <code>--print</code>.</p>             </td>
    <span class="k">throw</span> <span class="nx">e</span> <span class="nx">unless</span> <span class="nx">e</span><span class="p">.</span><span class="nx">code</span> <span class="o">is</span> <span class="s1">&#39;ENOENT&#39;</span>

 <span class="nv">unwatchDir = </span><span class="nf">(source, base) -&gt;</span>
-  <span class="nv">prevSources = </span><span class="nx">sources</span><span class="p">.</span><span class="nx">slice</span><span class="p">()</span>
+  <span class="nv">prevSources = </span><span class="nx">sources</span><span class="p">[..]</span>
  <span class="nv">toRemove = </span><span class="p">(</span><span class="nx">file</span> <span class="k">for</span> <span class="nx">file</span> <span class="k">in</span> <span class="nx">sources</span> <span class="k">when</span> <span class="nx">file</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">&gt;=</span> <span class="mi">0</span><span class="p">)</span>
  <span class="nx">removeSource</span> <span class="nx">file</span><span class="p">,</span> <span class="nx">base</span><span class="p">,</span> <span class="kc">yes</span> <span class="k">for</span> <span class="nx">file</span> <span class="k">in</span> <span class="nx">toRemove</span>
  <span class="k">return</span> <span class="nx">unless</span> <span class="nx">sources</span><span class="p">.</span><span class="nx">some</span> <span class="nf">(s, i) -&gt;</span> <span class="nx">prevSources</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">isnt</span> <span class="nx">s</span>
@@ -229,8 +225,7 @@ directory can be customized with <code>--output</code>.</p>             </td>
      <span class="k">else</span> <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">compile</span> <span class="o">and</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">watch</span>
        <span class="nx">timeLog</span> <span class="s2">&quot;compiled #{source}&quot;</span>
  <span class="nx">path</span><span class="p">.</span><span class="nx">exists</span> <span class="nx">jsDir</span><span class="p">,</span> <span class="nf">(exists) -&gt;</span>
-    <span class="k">if</span> <span class="nx">exists</span> <span class="k">then</span> <span class="nx">compile</span><span class="p">()</span> <span class="k">else</span> <span class="nx">exec</span> <span class="s2">&quot;mkdir -p #{jsDir}&quot;</span><span class="p">,</span> <span class="nx">compile</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>Convenience for cleaner setTimeouts.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">wait = </span><span class="nf">(milliseconds, func) -&gt;</span> <span class="nx">setTimeout</span> <span class="nx">func</span><span class="p">,</span> <span class="nx">milliseconds</span></pre></div>             </td>           </tr>                               <tr id="section-19">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-19">&#182;</a>               </div>               <p>When watching scripts, it's useful to log changes with the timestamp.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">timeLog = </span><span class="nf">(message) -&gt;</span>
+    <span class="k">if</span> <span class="nx">exists</span> <span class="k">then</span> <span class="nx">compile</span><span class="p">()</span> <span class="k">else</span> <span class="nx">exec</span> <span class="s2">&quot;mkdir -p #{jsDir}&quot;</span><span class="p">,</span> <span class="nx">compile</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>Convenience for cleaner setTimeouts.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">wait = </span><span class="nf">(milliseconds, func) -&gt;</span> <span class="nx">setTimeout</span> <span class="nx">func</span><span class="p">,</span> <span class="nx">milliseconds</span></pre></div>             </td>           </tr>                               <tr id="section-19">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-19">&#182;</a>               </div>               <p>When watching scripts, it's useful to log changes with the timestamp.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">timeLog = </span><span class="nf">(message) -&gt;</span>
  <span class="nx">console</span><span class="p">.</span><span class="nx">log</span> <span class="s2">&quot;#{(new Date).toLocaleTimeString()} - #{message}&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-20">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-20">&#182;</a>               </div>               <p>Pipe compiled JS through JSLint (requires a working <code>jsl</code> command), printing
 any errors or warnings that arise.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">lint = </span><span class="nf">(file, js) -&gt;</span>
  <span class="nv">printIt = </span><span class="nf">(buffer) -&gt;</span> <span class="nx">printLine</span> <span class="nx">file</span> <span class="o">+</span> <span class="s1">&#39;:\t&#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="nx">trim</span><span class="p">()</span>
@@ -246,13 +241,14 @@ any errors or warnings that arise.</p>             </td>             <td class="
  <span class="nx">printLine</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="s1">&#39; &#39;</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-22">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-22">&#182;</a>               </div>               <p>Use the <a href="optparse.html">OptionParser module</a> to extract all options from
 <code>process.argv</code> that are specified in <code>SWITCHES</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">parseOptions = </span><span class="o">-&gt;</span>
  <span class="nv">optionParser  = </span><span class="k">new</span> <span class="nx">optparse</span><span class="p">.</span><span class="nx">OptionParser</span> <span class="nx">SWITCHES</span><span class="p">,</span> <span class="nx">BANNER</span>
-  <span class="nv">o = opts      = </span><span class="nx">optionParser</span><span class="p">.</span><span class="nx">parse</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="mi">2</span>
+  <span class="nv">o = opts      = </span><span class="nx">optionParser</span><span class="p">.</span><span class="nx">parse</span> <span class="nx">process</span><span class="p">.</span><span class="nx">argv</span><span class="p">[</span><span class="mi">2</span><span class="p">..]</span>
  <span class="nx">o</span><span class="p">.</span><span class="nx">compile</span>     <span class="o">or=</span>  <span class="o">!!</span><span class="nx">o</span><span class="p">.</span><span class="nx">output</span>
  <span class="nv">o.run         = </span><span class="o">not</span> <span class="p">(</span><span class="nx">o</span><span class="p">.</span><span class="nx">compile</span> <span class="o">or</span> <span class="nx">o</span><span class="p">.</span><span class="nx">print</span> <span class="o">or</span> <span class="nx">o</span><span class="p">.</span><span class="nx">lint</span><span class="p">)</span>
  <span class="nv">o.print       = </span><span class="o">!!</span>  <span class="p">(</span><span class="nx">o</span><span class="p">.</span><span class="nx">print</span> <span class="o">or</span> <span class="p">(</span><span class="nx">o</span><span class="p">.</span><span class="nb">eval</span> <span class="o">or</span> <span class="nx">o</span><span class="p">.</span><span class="nx">stdio</span> <span class="o">and</span> <span class="nx">o</span><span class="p">.</span><span class="nx">compile</span><span class="p">))</span>
  <span class="nv">sources       = </span><span class="nx">o</span><span class="p">.</span><span class="nx">arguments</span>
  <span class="nx">sourceCode</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">=</span> <span class="kc">null</span> <span class="k">for</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">sources</span>
-  <span class="k">return</span></pre></div>             </td>           </tr>                               <tr id="section-23">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-23">&#182;</a>               </div>               <p>The compile-time options to pass to the CoffeeScript compiler.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">compileOptions = </span><span class="nf">(filename) -&gt;</span> <span class="p">{</span><span class="nx">filename</span><span class="p">,</span> <span class="nv">bare: </span><span class="nx">opts</span><span class="p">.</span><span class="nx">bare</span><span class="p">}</span></pre></div>             </td>           </tr>                               <tr id="section-24">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-24">&#182;</a>               </div>               <p>Start up a new Node.js instance with the arguments in <code>--nodejs</code> passed to
+  <span class="k">return</span></pre></div>             </td>           </tr>                               <tr id="section-23">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-23">&#182;</a>               </div>               <p>The compile-time options to pass to the CoffeeScript compiler.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">compileOptions = </span><span class="nf">(filename) -&gt;</span>
+  <span class="p">{</span><span class="nx">filename</span><span class="p">,</span> <span class="nv">bare: </span><span class="nx">opts</span><span class="p">.</span><span class="nx">bare</span><span class="p">,</span> <span class="nv">header: </span><span class="nx">opts</span><span class="p">.</span><span class="nx">compile</span><span class="p">}</span></pre></div>             </td>           </tr>                               <tr id="section-24">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-24">&#182;</a>               </div>               <p>Start up a new Node.js instance with the arguments in <code>--nodejs</code> passed to
 the <code>node</code> binary, preserving the other options.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">forkNode = </span><span class="o">-&gt;</span>
  <span class="nv">nodeArgs = </span><span class="nx">opts</span><span class="p">.</span><span class="nx">nodejs</span><span class="p">.</span><span class="nx">split</span> <span class="sr">/\s+/</span>
  <span class="nv">args     = </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>
--- a/documentation/docs/grammar.html
+++ b/documentation/docs/grammar.html
@@ -83,10 +83,9 @@ through and printed to JavaScript.</p>             </td>             <td class="
    <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>
    <span class="nx">o</span> <span class="s1">&#39;REGEX&#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;DEBUGGER&#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;BOOL&#39;</span><span class="p">,</span>                                   <span class="o">-&gt;</span>
-      <span class="nv">val = </span><span class="k">new</span> <span class="nx">Literal</span> <span class="nx">$1</span>
-      <span class="nv">val.isUndefined = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">$1</span> <span class="o">is</span> <span class="s1">&#39;undefined&#39;</span>
-      <span class="nx">val</span>
+    <span class="nx">o</span> <span class="s1">&#39;UNDEFINED&#39;</span><span class="p">,</span>                              <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Undefined</span>
+    <span class="nx">o</span> <span class="s1">&#39;NULL&#39;</span><span class="p">,</span>                                   <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Null</span>
+    <span class="nx">o</span> <span class="s1">&#39;BOOL&#39;</span><span class="p">,</span>                                   <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Bool</span> <span class="nx">$1</span>
  <span class="p">]</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>Assignment of a variable, property, or index to a value.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Assign: </span><span class="p">[</span>
    <span class="nx">o</span> <span class="s1">&#39;Assignable = Expression&#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">$3</span>
    <span class="nx">o</span> <span class="s1">&#39;Assignable = TERMINATOR Expression&#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>
@@ -125,6 +124,8 @@ functions, and <code>=&gt;</code> is for functions bound to the current value of
    <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;Param&#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;ParamList , Param&#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;ParamList OptComma TERMINATOR Param&#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;ParamList OptComma INDENT ParamList 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-25">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-25">&#182;</a>               </div>               <p>A single parameter in a function definition can be ordinary, or a splat
 that hoovers up the remaining arguments.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">Param: </span><span class="p">[</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>
@@ -215,6 +216,7 @@ and optional references to the superclass.</p>             </td>             <td
    <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="nx">o</span> <span class="s1">&#39;RangeDots&#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="kc">null</span><span class="p">,</span> <span class="nx">$1</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>The <strong>ArgList</strong> is both the list of objects passed into a function call,
 as well as the contents of an array literal
 (i.e. comma-separated expressions). Newlines work as well.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">ArgList: </span><span class="p">[</span>
@@ -281,6 +283,7 @@ or postfix, with a single expression.</p>             </td>             <td clas
  <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="nv">ForValue: </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="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-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
@@ -348,7 +351,7 @@ rules are necessary.</p>             </td>             <td class="code">
    <span class="nx">o</span> <span class="s1">&#39;Expression LOGIC    Expression&#39;</span><span class="p">,</span>         <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</span> <span class="nx">$2</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 RELATION Expression&#39;</span><span class="p">,</span>         <span class="o">-&gt;</span>
      <span class="k">if</span> <span class="nx">$2</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">is</span> <span class="s1">&#39;!&#39;</span>
-        <span class="k">new</span> <span class="nx">Op</span><span class="p">(</span><span class="nx">$2</span><span class="p">.</span><span class="nx">slice</span><span class="p">(</span><span class="mi">1</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="nx">invert</span><span class="p">()</span>
+        <span class="k">new</span> <span class="nx">Op</span><span class="p">(</span><span class="nx">$2</span><span class="p">[</span><span class="mi">1</span><span class="p">..],</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span><span class="p">).</span><span class="nx">invert</span><span class="p">()</span>
      <span class="k">else</span>
        <span class="k">new</span> <span class="nx">Op</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>

@@ -381,7 +384,7 @@ down. Following these rules is what makes <code>2 + 3 * 4</code> parse as:</p>
  <span class="p">[</span><span class="s1">&#39;nonassoc&#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>
  <span class="p">[</span><span class="s1">&#39;right&#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;COMPOUND_ASSIGN&#39;</span><span class="p">,</span> <span class="s1">&#39;RETURN&#39;</span><span class="p">,</span> <span class="s1">&#39;THROW&#39;</span><span class="p">,</span> <span class="s1">&#39;EXTENDS&#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;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;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;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-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
--- a/documentation/docs/lexer.html
+++ b/documentation/docs/lexer.html
--- a/documentation/docs/nodes.html
+++ b/documentation/docs/nodes.html
@@ -2,7 +2,7 @@
 nodes are created as the result of actions in the <a href="grammar.html">grammar</a>,
 but some are created by other nodes as a method of code generation. To convert
 the syntax tree into a string of JavaScript code, call <code>compile()</code> on the root.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="p">{</span><span class="nx">Scope</span><span class="p">}</span> <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;./scope&#39;</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></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">compact</span><span class="p">,</span> <span class="nx">flatten</span><span class="p">,</span> <span class="nx">extend</span><span class="p">,</span> <span class="nx">merge</span><span class="p">,</span> <span class="nx">del</span><span class="p">,</span> <span class="nx">starts</span><span class="p">,</span> <span class="nx">ends</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="p">{</span><span class="nx">RESERVED</span><span class="p">,</span> <span class="nx">STRICT_PROSCRIBED</span><span class="p">}</span> <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;./lexer&#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>Import the helpers we plan to use.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="p">{</span><span class="nx">compact</span><span class="p">,</span> <span class="nx">flatten</span><span class="p">,</span> <span class="nx">extend</span><span class="p">,</span> <span class="nx">merge</span><span class="p">,</span> <span class="nx">del</span><span class="p">,</span> <span class="nx">starts</span><span class="p">,</span> <span class="nx">ends</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.extend = </span><span class="nx">extend</span>  <span class="c1"># for parser</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>Constant functions for nodes that don't need customization.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">YES     = </span><span class="o">-&gt;</span> <span class="kc">yes</span>
 <span class="nv">NO      = </span><span class="o">-&gt;</span> <span class="kc">no</span>
@@ -147,7 +147,10 @@ our own</p>             </td>             <td class="code">               <div c
      <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="s2">&quot;#{@tab}#{code};&quot;</span>
+        <span class="nx">unless</span> <span class="nx">node</span><span class="p">.</span><span class="nx">isStatement</span> <span class="nx">o</span>
+          <span class="nv">code = </span><span class="s2">&quot;#{@tab}#{code};&quot;</span>
+          <span class="nv">code = </span><span class="s2">&quot;#{code}\n&quot;</span> <span class="k">if</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Literal</span>
+        <span class="nx">codes</span><span class="p">.</span><span class="nx">push</span> <span class="nx">code</span>
      <span class="k">else</span>
        <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">if</span> <span class="nx">top</span>
@@ -228,18 +231,33 @@ JavaScript without translation, such as: strings, numbers,
    <span class="k">return</span> <span class="k">this</span> <span class="k">if</span> <span class="nx">@value</span> <span class="o">is</span> <span class="s1">&#39;continue&#39;</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">o</span><span class="o">?</span><span class="p">.</span><span class="nx">loop</span>

  <span class="nv">compileNode: </span><span class="nf">(o) -&gt;</span>
-    <span class="nv">code = </span><span class="k">if</span> <span class="nx">@isUndefined</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_ACCESS</span> <span class="k">then</span> <span class="s1">&#39;(void 0)&#39;</span> <span class="k">else</span> <span class="s1">&#39;void 0&#39;</span>
-    <span class="k">else</span> <span class="k">if</span> <span class="nx">@value</span> <span class="o">is</span> <span class="s1">&#39;this&#39;</span>
+    <span class="nv">code = </span><span class="k">if</span> <span class="nx">@value</span> <span class="o">is</span> <span class="s1">&#39;this&#39;</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">method</span><span class="o">?</span><span class="p">.</span><span class="nx">bound</span> <span class="k">then</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">method</span><span class="p">.</span><span class="nx">context</span> <span class="k">else</span> <span class="nx">@value</span>
-    <span class="k">else</span> <span class="k">if</span> <span class="nx">@value</span><span class="p">.</span><span class="nx">reserved</span> <span class="o">and</span> <span class="s2">&quot;#{@value}&quot;</span> <span class="o">not</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;eval&#39;</span><span class="p">,</span> <span class="s1">&#39;arguments&#39;</span><span class="p">]</span>
+    <span class="k">else</span> <span class="k">if</span> <span class="nx">@value</span><span class="p">.</span><span class="nx">reserved</span>
      <span class="s2">&quot;\&quot;#{@value}\&quot;&quot;</span>
    <span class="k">else</span>
      <span class="nx">@value</span>
    <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="nv">toString: </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-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
+    <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>
+
+<span class="k">class</span> <span class="nx">exports</span><span class="p">.</span><span class="nx">Undefined</span> <span class="k">extends</span> <span class="nx">Base</span>
+  <span class="nv">isAssignable: </span><span class="nx">NO</span>
+  <span class="nv">isComplex: </span><span class="nx">NO</span>
+  <span class="nv">compileNode: </span><span class="nf">(o) -&gt;</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_ACCESS</span> <span class="k">then</span> <span class="s1">&#39;(void 0)&#39;</span> <span class="k">else</span> <span class="s1">&#39;void 0&#39;</span>
+
+<span class="k">class</span> <span class="nx">exports</span><span class="p">.</span><span class="nx">Null</span> <span class="k">extends</span> <span class="nx">Base</span>
+  <span class="nv">isAssignable: </span><span class="nx">NO</span>
+  <span class="nv">isComplex: </span><span class="nx">NO</span>
+  <span class="nv">compileNode: </span><span class="o">-&gt;</span> <span class="s2">&quot;null&quot;</span>
+
+<span class="k">class</span> <span class="nx">exports</span><span class="p">.</span><span class="nx">Bool</span> <span class="k">extends</span> <span class="nx">Base</span>
+  <span class="nv">isAssignable: </span><span class="nx">NO</span>
+  <span class="nv">isComplex: </span><span class="nx">NO</span>
+  <span class="nv">compileNode: </span><span class="o">-&gt;</span> <span class="nx">@val</span>
+  <span class="nv">constructor: </span><span class="nf">(@val) -&gt;</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="k">class</span> <span class="nx">Return</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(expr) -&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>
@@ -273,6 +291,7 @@ or vanilla.</p>             </td>             <td class="code">               <d
  <span class="nv">isComplex      : </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="nv">isAssignable   : </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="nv">isSimpleNumber : </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>
+  <span class="nv">isString       : </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">IS_STRING</span><span class="p">.</span><span class="nx">test</span> <span class="nx">@base</span><span class="p">.</span><span class="nx">value</span>
  <span class="nv">isAtomic       : </span><span class="o">-&gt;</span>
    <span class="k">for</span> <span class="nx">node</span> <span class="k">in</span> <span class="nx">@properties</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">@base</span>
      <span class="k">return</span> <span class="kc">no</span> <span class="k">if</span> <span class="nx">node</span><span class="p">.</span><span class="nx">soak</span> <span class="o">or</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Call</span>
@@ -337,7 +356,7 @@ at the same position.</p>             </td>             <td class="code">
  <span class="nv">makeReturn: </span>     <span class="nx">THIS</span>

  <span class="nv">compileNode: </span><span class="nf">(o, level) -&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="s2">&quot;\n#{@tab}*/&quot;</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="s2">&quot;\n#{@tab}*/\n&quot;</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-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="k">class</span> <span class="nx">Call</span> <span class="k">extends</span> <span class="nx">Base</span>
@@ -354,7 +373,7 @@ calls against the prototype's function of the same name.</p>             </td>
      <span class="vi">@isNew = </span><span class="kc">true</span>
    <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="nv">superReference: </span><span class="nf">(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="nv">method = </span><span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">namedMethod</span><span class="p">()</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="o">?</span>
@@ -364,7 +383,9 @@ method.</p>             </td>             <td class="code">               <div c
      <span class="nx">accesses</span><span class="p">.</span><span class="nx">push</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="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="nx">accesses</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-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="nv">unfoldSoak: </span><span class="nf">(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>The appropriate <code>this</code> value for a <code>super</code> call.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">superThis : </span><span class="nf">(o) -&gt;</span>
+    <span class="nv">method = </span><span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">method</span>
+    <span class="p">(</span><span class="nx">method</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">method</span><span class="p">.</span><span class="nx">klass</span> <span class="o">and</span> <span class="nx">method</span><span class="p">.</span><span class="nx">context</span><span class="p">)</span> <span class="o">or</span> <span class="s2">&quot;this&quot;</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>Soaked chained invocations unfold into if/else ternary structures.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">unfoldSoak: </span><span class="nf">(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>
@@ -393,7 +414,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-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.
+    <span class="nx">ifn</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>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="nv">filterImplicitObjects: </span><span class="nf">(list) -&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>
@@ -408,30 +429,30 @@ This allows syntax like <code>call a: b, c</code> into <code>call({a: b}, c);</c
        <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-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="nv">compileNode: </span><span class="nf">(o) -&gt;</span>
+    <span class="nx">nodes</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>Compile a vanilla function call.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">compileNode: </span><span class="nf">(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>
    <span class="nv">args = </span><span class="nx">@filterImplicitObjects</span> <span class="nx">@args</span>
    <span class="nv">args = </span><span class="p">(</span><span class="nx">arg</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">arg</span> <span class="k">in</span> <span class="nx">args</span><span class="p">).</span><span class="nx">join</span> <span class="s1">&#39;, &#39;</span>
    <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="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(#{@superThis(o)}#{ 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-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
+      <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-54">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-54">&#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="nv">compileSuper: </span><span class="nf">(args, 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-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
+    <span class="s2">&quot;#{@superReference(o)}.call(#{@superThis(o)}#{ if args.length then &#39;, &#39; else &#39;&#39; }#{args})&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>               <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="nv">compileSplat: </span><span class="nf">(o, splatArgs) -&gt;</span>
-    <span class="k">return</span> <span class="s2">&quot;#{ @superReference o }.apply(this, #{splatArgs})&quot;</span> <span class="k">if</span> <span class="nx">@isSuper</span>
+    <span class="k">return</span> <span class="s2">&quot;#{ @superReference o }.apply(#{@superThis(o)}, #{splatArgs})&quot;</span> <span class="k">if</span> <span class="nx">@isSuper</span>
    <span class="k">if</span> <span class="nx">@isNew</span>
      <span class="nv">idt = </span><span class="nx">@tab</span> <span class="o">+</span> <span class="nx">TAB</span>
      <span class="k">return</span> <span class="s2">&quot;&quot;&quot;</span>
 <span class="s2">        (function(func, args, ctor) {</span>
 <span class="s2">        #{idt}ctor.prototype = func.prototype;</span>
-<span class="s2">        #{idt}var child = new ctor, result = func.apply(child, args);</span>
-<span class="s2">        #{idt}return typeof result === &quot;</span><span class="nx">object</span><span class="s2">&quot; ? result : child;</span>
-<span class="s2">        #{@tab}})(#{ @variable.compile o, LEVEL_LIST }, #{splatArgs}, function() {})</span>
+<span class="s2">        #{idt}var child = new ctor, result = func.apply(child, args), t = typeof result;</span>
+<span class="s2">        #{idt}return t == &quot;</span><span class="nx">object</span><span class="s2">&quot; || t == &quot;</span><span class="nx">function</span><span class="s2">&quot; ? result || child : child;</span>
+<span class="s2">        #{@tab}})(#{ @variable.compile o, LEVEL_LIST }, #{splatArgs}, function(){})</span>
 <span class="s2">      &quot;&quot;&quot;</span>
    <span class="nv">base = </span><span class="k">new</span> <span class="nx">Value</span> <span class="nx">@variable</span>
    <span class="k">if</span> <span class="p">(</span><span class="nv">name = </span><span class="nx">base</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="o">and</span> <span class="nx">base</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span>
@@ -445,13 +466,13 @@ 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-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.
+    <span class="s2">&quot;#{fun}.apply(#{ref}, #{splatArgs})&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-56">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-56">&#182;</a>               </div>               <h3>Extends</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-57">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-57">&#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="k">class</span> <span class="nx">Extends</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(@child, @parent) -&gt;</span>

-  <span class="nv">children: </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="nv">compile: </span><span class="nf">(o) -&gt;</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-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
+  <span class="nv">children: </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-58">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-58">&#182;</a>               </div>               <p>Hooks one constructor into another's prototype chain.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">compile: </span><span class="nf">(o) -&gt;</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-59">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-59">&#182;</a>               </div>               <h3>Access</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> 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="k">class</span> <span class="nx">Access</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(@name, tag) -&gt;</span>
    <span class="vi">@name.asKey = </span><span class="kc">yes</span>
@@ -463,7 +484,7 @@ an access into the object's prototype.</p>             </td>             <td cla
    <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="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="nv">isComplex: </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="k">class</span> <span class="nx">Index</span> <span class="k">extends</span> <span class="nx">Base</span>
+  <span class="nv">isComplex: </span><span class="nx">NO</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>Index</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 <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="k">class</span> <span class="nx">Index</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(@index) -&gt;</span>

  <span class="nv">children: </span><span class="p">[</span><span class="s1">&#39;index&#39;</span><span class="p">]</span>
@@ -472,7 +493,7 @@ an access into the object's prototype.</p>             </td>             <td cla
    <span class="s2">&quot;[#{ @index.compile o, LEVEL_PAREN }]&quot;</span>

  <span class="nv">isComplex: </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-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,
+    <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-63">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-63">&#182;</a>               </div>               <h3>Range</h3>             </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>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="k">class</span> <span class="nx">Range</span> <span class="k">extends</span> <span class="nx">Base</span>

@@ -480,34 +501,45 @@ corresponding array of integers at runtime.</p>             </td>             <t

  <span class="nv">constructor: </span><span class="nf">(@from, @to, tag) -&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-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.
+    <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-65">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-65">&#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="nv">compileVariables: </span><span class="nf">(o) -&gt;</span>
    <span class="nv">o = </span><span class="nx">merge</span> <span class="nx">o</span><span class="p">,</span> <span class="nv">top: </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>
+    <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-66">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-66">&#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="nv">compileNode: </span><span class="nf">(o) -&gt;</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="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-67">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-67">&#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">idxName  = </span><span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s1">&#39;name&#39;</span>
+    <span class="nv">namedIndex = </span><span class="nx">idxName</span> <span class="o">and</span> <span class="nx">idxName</span> <span class="o">isnt</span> <span class="nx">idx</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="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-68">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-68">&#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="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="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="nv">cond     = </span><span class="s2">&quot;#{@fromVar} &lt;= #{@toVar}&quot;</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;#{cond} ? #{lt} #{@toVar} : #{gt} #{@toVar}&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>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">if</span> <span class="nx">namedIndex</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="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="nv">compileArray: </span><span class="nf">(o) -&gt;</span>
+      <span class="k">if</span> <span class="nx">namedIndex</span>
+        <span class="s2">&quot;#{cond} ? ++#{idx} : --#{idx}&quot;</span>
+      <span class="k">else</span>
+        <span class="s2">&quot;#{cond} ? #{idx}++ : #{idx}--&quot;</span>
+
+    <span class="nv">varPart  = </span><span class="s2">&quot;#{idxName} = #{varPart}&quot;</span> <span class="k">if</span> <span class="nx">namedIndex</span>
+    <span class="nv">stepPart = </span><span class="s2">&quot;#{idxName} = #{stepPart}&quot;</span> <span class="k">if</span> <span class="nx">namedIndex</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>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-71">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-71">&#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="nv">compileArray: </span><span class="nf">(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>
@@ -526,27 +558,28 @@ needed to iterate over the values in the range. Used by comprehensions.</p>
    <span class="nv">post   = </span><span class="s2">&quot;{ #{result}.push(#{i}); }\n#{idt}return #{result};\n#{o.indent}&quot;</span>
    <span class="nv">hasArgs = </span><span class="nf">(node) -&gt;</span> <span class="nx">node</span><span class="o">?</span><span class="p">.</span><span class="nx">contains</span> <span class="nf">(n) -&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
+    <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-72">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-72">&#182;</a>               </div>               <h3>Slice</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 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="k">class</span> <span class="nx">Slice</span> <span class="k">extends</span> <span class="nx">Base</span>

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

  <span class="nv">constructor: </span><span class="nf">(@range) -&gt;</span>
-    <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,
+    <span class="k">super</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-74">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-74">&#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="nv">compileNode: </span><span class="nf">(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>
    <span class="nv">fromStr    = </span><span class="nx">from</span> <span class="o">and</span> <span class="nx">from</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_PAREN</span><span class="p">)</span> <span class="o">or</span> <span class="s1">&#39;0&#39;</span>
-    <span class="nv">compiled   = </span><span class="nx">to</span> <span class="o">and</span> <span class="nx">to</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_ACCESS</span>
+    <span class="nv">compiled   = </span><span class="nx">to</span> <span class="o">and</span> <span class="nx">to</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="k">if</span> <span class="nx">to</span> <span class="o">and</span> <span class="o">not</span> <span class="p">(</span><span class="o">not</span> <span class="nx">@range</span><span class="p">.</span><span class="nx">exclusive</span> <span class="o">and</span> <span class="o">+</span><span class="nx">compiled</span> <span class="o">is</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
      <span class="nv">toStr = </span><span class="s1">&#39;, &#39;</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">@range</span><span class="p">.</span><span class="nx">exclusive</span>
        <span class="nx">compiled</span>
      <span class="k">else</span> <span class="k">if</span> <span class="nx">SIMPLENUM</span><span class="p">.</span><span class="nx">test</span> <span class="nx">compiled</span>
-        <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="s2">&quot;#{+compiled + 1}&quot;</span>
      <span class="k">else</span>
+        <span class="nv">compiled = </span><span class="nx">to</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_ACCESS</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-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="k">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-75">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-75">&#182;</a>               </div>               <h3>Obj</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-76">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-76">&#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="k">class</span> <span class="nx">Obj</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(props, @generated = false) -&gt;</span>
    <span class="vi">@objects = @properties = </span><span class="nx">props</span> <span class="o">or</span> <span class="p">[]</span>

@@ -554,6 +587,14 @@ is the index of the beginning.</p>             </td>             <td class="code

  <span class="nv">compileNode: </span><span class="nf">(o) -&gt;</span>
    <span class="nv">props = </span><span class="nx">@properties</span>
+    <span class="nv">propNames = </span><span class="p">[]</span>
+    <span class="k">for</span> <span class="nx">prop</span> <span class="k">in</span> <span class="nx">@properties</span>
+      <span class="nv">prop = </span><span class="nx">prop</span><span class="p">.</span><span class="nx">variable</span> <span class="k">if</span> <span class="nx">prop</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span>
+      <span class="k">if</span> <span class="nx">prop</span><span class="o">?</span>
+        <span class="nv">propName = </span><span class="nx">prop</span><span class="p">.</span><span class="nx">unwrapAll</span><span class="p">().</span><span class="nx">value</span><span class="p">.</span><span class="nx">toString</span><span class="p">()</span>
+        <span class="k">if</span> <span class="nx">propName</span> <span class="k">in</span> <span class="nx">propNames</span>
+          <span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s2">&quot;multiple object literal properties named \&quot;#{propName}\&quot;&quot;</span>
+        <span class="nx">propNames</span><span class="p">.</span><span class="nx">push</span> <span class="nx">propName</span>
    <span class="k">return</span> <span class="p">(</span><span class="k">if</span> <span class="nx">@front</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="p">)</span> <span class="nx">unless</span> <span class="nx">props</span><span class="p">.</span><span class="nx">length</span>
    <span class="k">if</span> <span class="nx">@generated</span>
      <span class="k">for</span> <span class="nx">node</span> <span class="k">in</span> <span class="nx">props</span> <span class="k">when</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Value</span>
@@ -581,7 +622,7 @@ is the index of the beginning.</p>             </td>             <td class="code

  <span class="nv">assigns: </span><span class="nf">(name) -&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-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="k">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-77">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-77">&#182;</a>               </div>               <h3>Arr</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-78">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-78">&#182;</a>               </div>               <p>An array literal.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Arr = </span><span class="k">class</span> <span class="nx">Arr</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(objs) -&gt;</span>
    <span class="vi">@objects = </span><span class="nx">objs</span> <span class="o">or</span> <span class="p">[]</span>

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

  <span class="nv">assigns: </span><span class="nf">(name) -&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-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.
+    <span class="kc">no</span></pre></div>             </td>           </tr>                               <tr id="section-79">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-79">&#182;</a>               </div>               <h3>Class</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-80">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-80">&#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="k">class</span> <span class="nx">Class</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(@variable, @parent, @body = new Block) -&gt;</span>
    <span class="vi">@boundFuncs = </span><span class="p">[]</span>
    <span class="vi">@body.classBody = </span><span class="kc">yes</span>

-  <span class="nv">children: </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="nv">determineName: </span><span class="o">-&gt;</span>
+  <span class="nv">children: </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-81">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-81">&#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="nv">determineName: </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-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,
+    <span class="k">if</span> <span class="nx">decl</span> <span class="k">in</span> <span class="nx">STRICT_PROSCRIBED</span>
+      <span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s2">&quot;variable name may not be #{decl}&quot;</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-82">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-82">&#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="nv">setContext: </span><span class="nf">(name) -&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="nf">(node) -&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>
@@ -623,14 +666,14 @@ 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-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
+        <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-83">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-83">&#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="nv">addBoundFunctions: </span><span class="nf">(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">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
+        <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-84">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-84">&#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="nv">addProperties: </span><span class="nf">(node, name, 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">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="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>
@@ -657,53 +700,67 @@ on the class.</p>             </td>             <td class="code">
              <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>
-    <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="nv">walkBody: </span><span class="nf">(name, o) -&gt;</span>
+    <span class="nx">compact</span> <span class="nx">exprs</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>Walk the body of the class, looking for prototype properties to be converted.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">walkBody: </span><span class="nf">(name, 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="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
+        <span class="nv">child.expressions = exps = </span><span class="nx">flatten</span> <span class="nx">exps</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><code>use strict</code> (and other directives) must be the first expression statement(s)
+of a function body. This method ensures the prologue is correctly positioned
+above the <code>constructor</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">hoistDirectivePrologue: </span><span class="o">-&gt;</span>
+    <span class="nv">index = </span><span class="mi">0</span>
+    <span class="p">{</span><span class="nx">expressions</span><span class="p">}</span> <span class="o">=</span> <span class="nx">@body</span>
+    <span class="o">++</span><span class="nx">index</span> <span class="k">while</span> <span class="p">(</span><span class="nv">node = </span><span class="nx">expressions</span><span class="p">[</span><span class="nx">index</span><span class="p">])</span> <span class="o">and</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Comment</span> <span class="o">or</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">isString</span><span class="p">()</span>
+    <span class="vi">@directives = </span><span class="nx">expressions</span><span class="p">.</span><span class="nx">splice</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">index</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>Make sure that a constructor is defined for the class, and properly
 configured.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">ensureConstructor: </span><span class="nf">(name) -&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">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">@ctor</span><span class="p">.</span><span class="nx">body</span><span class="p">.</span><span class="nx">makeReturn</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="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-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
+    <span class="vi">@ctor.noReturn = </span><span class="kc">yes</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>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="nv">compileNode: </span><span class="nf">(o) -&gt;</span>
    <span class="nv">decl  = </span><span class="nx">@determineName</span><span class="p">()</span>
-    <span class="nv">name  = </span><span class="nx">decl</span> <span class="o">or</span> <span class="nx">@name</span> <span class="o">or</span> <span class="s1">&#39;_Class&#39;</span>
+    <span class="nv">name  = </span><span class="nx">decl</span> <span class="o">or</span> <span class="s1">&#39;_Class&#39;</span>
    <span class="nv">name = </span><span class="s2">&quot;_#{name}&quot;</span> <span class="k">if</span> <span class="nx">name</span><span class="p">.</span><span class="nx">reserved</span>
    <span class="nv">lname = </span><span class="k">new</span> <span class="nx">Literal</span> <span class="nx">name</span>

+    <span class="nx">@hoistDirectivePrologue</span><span class="p">()</span>
    <span class="nx">@setContext</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="vi">@body.spaced = </span><span class="kc">yes</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">@body</span><span class="p">.</span><span class="nx">expressions</span><span class="p">.</span><span class="nx">unshift</span> <span class="nx">@directives</span><span class="p">...</span>
    <span class="nx">@addBoundFunctions</span> <span class="nx">o</span>

    <span class="nv">call  = </span><span class="nx">Closure</span><span class="p">.</span><span class="nx">wrap</span> <span class="nx">@body</span>
-    
+
    <span class="k">if</span> <span class="nx">@parent</span>
      <span class="vi">@superClass = </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;super&#39;</span><span class="p">,</span> <span class="kc">no</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">@superClass</span>
      <span class="nx">call</span><span class="p">.</span><span class="nx">args</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@parent</span>
-      <span class="nx">call</span><span class="p">.</span><span class="nx">variable</span><span class="p">.</span><span class="nx">params</span><span class="p">.</span><span class="nx">push</span> <span class="k">new</span> <span class="nx">Param</span> <span class="nx">@superClass</span>
-    
+      <span class="nv">params = </span><span class="nx">call</span><span class="p">.</span><span class="nx">variable</span><span class="p">.</span><span class="nx">params</span> <span class="o">or</span> <span class="nx">call</span><span class="p">.</span><span class="nx">variable</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">params</span>
+      <span class="nx">params</span><span class="p">.</span><span class="nx">push</span> <span class="k">new</span> <span class="nx">Param</span> <span class="nx">@superClass</span>
+
    <span class="nv">klass = </span><span class="k">new</span> <span class="nx">Parens</span> <span class="nx">call</span><span class="p">,</span> <span class="kc">yes</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-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
+    <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-89">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-89">&#182;</a>               </div>               <h3>Assign</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-90">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-90">&#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="k">class</span> <span class="nx">Assign</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(@variable, @value, @context, options) -&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>
    <span class="vi">@subpattern = </span><span class="nx">options</span> <span class="o">and</span> <span class="nx">options</span><span class="p">.</span><span class="nx">subpattern</span>
+    <span class="nv">forbidden = </span><span class="p">(</span><span class="nv">name = </span><span class="nx">@variable</span><span class="p">.</span><span class="nx">unwrapAll</span><span class="p">().</span><span class="nx">value</span><span class="p">)</span> <span class="k">in</span> <span class="nx">STRICT_PROSCRIBED</span>
+    <span class="k">if</span> <span class="nx">forbidden</span> <span class="o">and</span> <span class="nx">@context</span> <span class="o">isnt</span> <span class="s1">&#39;object&#39;</span>
+      <span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s2">&quot;variable name may not be \&quot;#{name}\&quot;&quot;</span>

  <span class="nv">children: </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>

@@ -714,7 +771,7 @@ property of an object -- including within object literals.</p>             </td>
    <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="nv">unfoldSoak: </span><span class="nf">(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-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
+    <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-91">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-91">&#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="nv">compileNode: </span><span class="nf">(o) -&gt;</span>
@@ -737,7 +794,7 @@ has not been seen yet within the current scope, declare it.</p>             </td
    <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-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
+    <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-92">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-92">&#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="nv">compilePatternMatch: </span><span class="nf">(o) -&gt;</span>
@@ -748,7 +805,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-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="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-93">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-93">&#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="nv">variable: </span><span class="p">{</span><span class="nv">base: </span><span class="nx">idx</span><span class="p">},</span> <span class="nv">value: </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>
@@ -761,7 +818,7 @@ 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">if</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">().</span><span class="nx">value</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;arguments&#39;</span><span class="p">,</span><span class="s1">&#39;eval&#39;</span><span class="p">].</span><span class="nx">concat</span> <span class="nx">RESERVED</span>
+      <span class="k">if</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">().</span><span class="nx">value</span> <span class="k">in</span> <span class="nx">RESERVED</span>
        <span class="k">throw</span> <span class="k">new</span> <span class="nx">SyntaxError</span> <span class="s2">&quot;assignment to a reserved word: #{obj.compile o} = #{value.compile o}&quot;</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="nv">param: </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>
@@ -770,10 +827,10 @@ for details.</p>             </td>             <td class="code">               <
    <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-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">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-94">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-94">&#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-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="nv">variable: </span><span class="p">{</span><span class="nv">base: </span><span class="nx">idx</span><span class="p">},</span> <span class="nv">value: </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="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-95">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-95">&#182;</a>               </div>               <p>A regular object pattern-match.</p>             </td>             <td class="code">               <div class="highlight"><pre>          <span class="p">{</span><span class="nv">variable: </span><span class="p">{</span><span class="nv">base: </span><span class="nx">idx</span><span class="p">},</span> <span class="nv">value: </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-96">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-96">&#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>
@@ -800,17 +857,19 @@ for details.</p>             </td>             <td class="code">               <
        <span class="k">else</span>
          <span class="nv">acc = </span><span class="nx">isObject</span> <span class="o">and</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">val = </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="nx">vvar</span><span class="p">),</span> <span class="p">[</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="p">]</span>
-      <span class="k">if</span> <span class="nx">name</span><span class="o">?</span> <span class="o">and</span> <span class="nx">name</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;arguments&#39;</span><span class="p">,</span><span class="s1">&#39;eval&#39;</span><span class="p">].</span><span class="nx">concat</span> <span class="nx">RESERVED</span>
+      <span class="k">if</span> <span class="nx">name</span><span class="o">?</span> <span class="o">and</span> <span class="nx">name</span> <span class="k">in</span> <span class="nx">RESERVED</span>
        <span class="k">throw</span> <span class="k">new</span> <span class="nx">SyntaxError</span> <span class="s2">&quot;assignment to a reserved word: #{obj.compile o} = #{val.compile o}&quot;</span>
      <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="nv">param: </span><span class="nx">@param</span><span class="p">,</span> <span class="nv">subpattern: </span><span class="kc">yes</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">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="o">or</span> <span class="nx">@subpattern</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-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
+    <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-97">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-97">&#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="nv">compileConditional: </span><span class="nf">(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="p">[</span><span class="nx">left</span><span class="p">,</span> <span class="nx">right</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></pre></div>             </td>           </tr>                               <tr id="section-98">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-98">&#182;</a>               </div>               <p>Disallow conditional assignment of undefined variables.</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="k">if</span> <span class="o">not</span> <span class="nx">left</span><span class="p">.</span><span class="nx">properties</span><span class="p">.</span><span class="nx">length</span> <span class="o">and</span> <span class="nx">left</span><span class="p">.</span><span class="nx">base</span> <span class="k">instanceof</span> <span class="nx">Literal</span> <span class="o">and</span> 
+           <span class="nx">left</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">value</span> <span class="o">!=</span> <span class="s2">&quot;this&quot;</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">left</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">value</span>
+      <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;the variable \&quot;#{left.base.value}\&quot; can&#39;t be assigned with #{@context} because it has not been defined.&quot;</span>
    <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
+    <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="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">right</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-99">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-99">&#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="nv">compileSplice: </span><span class="nf">(o) -&gt;</span>
    <span class="p">{</span><span class="nv">range: </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>
@@ -826,7 +885,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-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.
+    <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-100">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-100">&#182;</a>               </div>               <h3>Code</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 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="k">class</span> <span class="nx">Code</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(params, body, tag) -&gt;</span>
@@ -839,7 +898,7 @@ has no <em>children</em> -- they're within the inner scope.</p>             </td

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

-  <span class="nv">jumps: </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
+  <span class="nv">jumps: </span><span class="nx">NO</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>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> 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
@@ -848,10 +907,15 @@ a closure.</p>             </td>             <td class="code">               <di
    <span class="nv">o.scope.shared  = </span><span class="nx">del</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="s1">&#39;sharedScope&#39;</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">TAB</span>
    <span class="k">delete</span> <span class="nx">o</span><span class="p">.</span><span class="nx">bare</span>
-    <span class="nv">vars   = </span><span class="p">[]</span>
+    <span class="k">delete</span> <span class="nx">o</span><span class="p">.</span><span class="nx">isExistentialEquals</span>
+    <span class="nv">params = </span><span class="p">[]</span>
    <span class="nv">exprs  = </span><span class="p">[]</span>
+    <span class="k">for</span> <span class="nx">name</span> <span class="k">in</span> <span class="nx">@paramNames</span><span class="p">()</span> <span class="c1"># this step must be performed before the others</span>
+      <span class="nx">unless</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">name</span> <span class="k">then</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">parameter</span> <span class="nx">name</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">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="k">for</span> <span class="p">{</span><span class="nv">name: </span><span class="nx">p</span><span class="p">}</span> <span class="k">in</span> <span class="nx">@params</span>
+        <span class="k">if</span> <span class="nx">p</span><span class="p">.</span><span class="k">this</span> <span class="k">then</span> <span class="nv">p = </span><span class="nx">p</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">if</span> <span class="nx">p</span><span class="p">.</span><span class="nx">value</span> <span class="k">then</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">value</span><span class="p">,</span> <span class="s1">&#39;var&#39;</span><span class="p">,</span> <span class="kc">yes</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>
@@ -866,11 +930,15 @@ a closure.</p>             </td>             <td class="code">               <di
          <span class="nv">lit = </span><span class="k">new</span> <span class="nx">Literal</span> <span class="nx">ref</span><span class="p">.</span><span class="nx">name</span><span class="p">.</span><span class="nx">value</span> <span class="o">+</span> <span class="s1">&#39; == null&#39;</span>
          <span class="nv">val = </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="nx">param</span><span class="p">.</span><span class="nx">name</span><span class="p">),</span> <span class="nx">param</span><span class="p">.</span><span class="nx">value</span><span class="p">,</span> <span class="s1">&#39;=&#39;</span>
          <span class="nx">exprs</span><span class="p">.</span><span class="nx">push</span> <span class="k">new</span> <span class="nx">If</span> <span class="nx">lit</span><span class="p">,</span> <span class="nx">val</span>
-      <span class="nx">vars</span><span class="p">.</span><span class="nx">push</span> <span class="nx">ref</span> <span class="nx">unless</span> <span class="nx">splats</span>
+      <span class="nx">params</span><span class="p">.</span><span class="nx">push</span> <span class="nx">ref</span> <span class="nx">unless</span> <span class="nx">splats</span>
    <span class="nv">wasEmpty = </span><span class="nx">@body</span><span class="p">.</span><span class="nx">isEmpty</span><span class="p">()</span>
    <span class="nx">exprs</span><span class="p">.</span><span class="nx">unshift</span> <span class="nx">splats</span> <span class="k">if</span> <span class="nx">splats</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">exprs</span><span class="p">...</span> <span class="k">if</span> <span class="nx">exprs</span><span class="p">.</span><span class="nx">length</span>
-    <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">parameter</span> <span class="nx">vars</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">=</span> <span class="nx">v</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span> <span class="k">for</span> <span class="nx">v</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">vars</span> <span class="nx">unless</span> <span class="nx">splats</span>
+    <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">parameter</span> <span class="nx">params</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">=</span> <span class="nx">p</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span> <span class="k">for</span> <span class="nx">p</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">params</span>
+    <span class="nv">uniqs = </span><span class="p">[]</span>
+    <span class="k">for</span> <span class="nx">name</span> <span class="k">in</span> <span class="nx">@paramNames</span><span class="p">()</span>
+      <span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s2">&quot;multiple parameters named &#39;#{name}&#39;&quot;</span> <span class="k">if</span> <span class="nx">name</span> <span class="k">in</span> <span class="nx">uniqs</span>
+      <span class="nx">uniqs</span><span class="p">.</span><span class="nx">push</span> <span class="nx">name</span>
    <span class="nx">@body</span><span class="p">.</span><span class="nx">makeReturn</span><span class="p">()</span> <span class="nx">unless</span> <span class="nx">wasEmpty</span> <span class="o">or</span> <span class="nx">@noReturn</span>
    <span class="k">if</span> <span class="nx">@bound</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">parent</span><span class="p">.</span><span class="nx">method</span><span class="o">?</span><span class="p">.</span><span class="nx">bound</span>
@@ -880,16 +948,21 @@ a closure.</p>             </td>             <td class="code">               <di
    <span class="nv">idt   = </span><span class="nx">o</span><span class="p">.</span><span class="nx">indent</span>
    <span class="nv">code  = </span><span class="s1">&#39;function&#39;</span>
    <span class="nx">code</span>  <span class="o">+=</span> <span class="s1">&#39; &#39;</span> <span class="o">+</span> <span class="nx">@name</span> <span class="k">if</span> <span class="nx">@ctor</span>
-    <span class="nx">code</span>  <span class="o">+=</span> <span class="s1">&#39;(&#39;</span> <span class="o">+</span> <span class="nx">vars</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">+</span> <span class="s1">&#39;) {&#39;</span>
+    <span class="nx">code</span>  <span class="o">+=</span> <span class="s1">&#39;(&#39;</span> <span class="o">+</span> <span class="nx">params</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">+</span> <span class="s1">&#39;) {&#39;</span>
    <span class="nx">code</span>  <span class="o">+=</span> <span class="s2">&quot;\n#{ @body.compileWithDeclarations o }\n#{@tab}&quot;</span> <span class="nx">unless</span> <span class="nx">@body</span><span class="p">.</span><span class="nx">isEmpty</span><span class="p">()</span>
    <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">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
+    <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-103">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-103">&#182;</a>               </div>               <p>A list of parameter names, excluding those generated by the compiler.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">paramNames: </span><span class="o">-&gt;</span>
+    <span class="nv">names = </span><span class="p">[]</span>
+    <span class="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">param</span><span class="p">.</span><span class="nx">names</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="nx">names</span></pre></div>             </td>           </tr>                               <tr id="section-104">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-104">&#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="nv">traverseChildren: </span><span class="nf">(crossScope, func) -&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-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,
+    <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-105">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-105">&#182;</a>               </div>               <h3>Param</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-106">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-106">&#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="k">class</span> <span class="nx">Param</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(@name, @value, @splat) -&gt;</span>
+    <span class="k">if</span> <span class="p">(</span><span class="nv">name = </span><span class="nx">@name</span><span class="p">.</span><span class="nx">unwrapAll</span><span class="p">().</span><span class="nx">value</span><span class="p">)</span> <span class="k">in</span> <span class="nx">STRICT_PROSCRIBED</span>
+      <span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s2">&quot;parameter name \&quot;#{name}\&quot; is not allowed&quot;</span>

  <span class="nv">children: </span><span class="p">[</span><span class="s1">&#39;name&#39;</span><span class="p">,</span> <span class="s1">&#39;value&#39;</span><span class="p">]</span>

@@ -901,7 +974,8 @@ as well as be a splat, gathering up a group of parameters into an array.</p>
    <span class="nv">node = </span><span class="nx">@name</span>
    <span class="k">if</span> <span class="nx">node</span><span class="p">.</span><span class="k">this</span>
      <span class="nv">node = </span><span class="nx">node</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="nv">node = </span><span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;_&#39;</span> <span class="o">+</span> <span class="nx">node</span><span class="p">.</span><span class="nx">value</span> <span class="k">if</span> <span class="nx">node</span><span class="p">.</span><span class="nx">value</span><span class="p">.</span><span class="nx">reserved</span>
+      <span class="k">if</span> <span class="nx">node</span><span class="p">.</span><span class="nx">value</span><span class="p">.</span><span class="nx">reserved</span>
+        <span class="nv">node = </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="nx">node</span><span class="p">.</span><span class="nx">value</span>
    <span class="k">else</span> <span class="k">if</span> <span class="nx">node</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span>
      <span class="nv">node = </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;arg&#39;</span>
    <span class="nv">node = </span><span class="k">new</span> <span class="nx">Value</span> <span class="nx">node</span>
@@ -909,7 +983,40 @@ 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="nv">isComplex: </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-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,
+    <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-107">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-107">&#182;</a>               </div>               <p>Finds the name or names of a <code>Param</code>; useful for detecting duplicates.
+In a sense, a destructured parameter represents multiple JS parameters,
+thus this method returns an <code>Array</code> of names.
+Reserved words used as param names, as well as the Object and Array
+literals used for destructured params, get a compiler generated name
+during the <code>Code</code> compilation step, so this is necessarily an incomplete
+list of a parameter's names.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">names: </span><span class="nf">(name = @name)-&gt;</span>
+    <span class="nv">atParam = </span><span class="nf">(obj) -&gt;</span>
+      <span class="p">{</span><span class="nx">value</span><span class="p">}</span> <span class="o">=</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">return</span> <span class="k">if</span> <span class="nx">value</span><span class="p">.</span><span class="nx">reserved</span> <span class="k">then</span> <span class="p">[]</span> <span class="k">else</span> <span class="p">[</span><span class="nx">value</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-108">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-108">&#182;</a>               </div>               <ul>
+<li>simple literals <code>foo</code></li>
+</ul>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="k">return</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="k">if</span> <span class="nx">name</span> <span class="k">instanceof</span> <span class="nx">Literal</span></pre></div>             </td>           </tr>                               <tr id="section-109">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-109">&#182;</a>               </div>               <ul>
+<li>at-params <code>@foo</code></li>
+</ul>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="k">return</span> <span class="nx">atParam</span><span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="k">if</span> <span class="nx">name</span> <span class="k">instanceof</span> <span class="nx">Value</span>
+    <span class="nv">names = </span><span class="p">[]</span>
+    <span class="k">for</span> <span class="nx">obj</span> <span class="k">in</span> <span class="nx">name</span><span class="p">.</span><span class="nx">objects</span></pre></div>             </td>           </tr>                               <tr id="section-110">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-110">&#182;</a>               </div>               <ul>
+<li>assignments within destructured parameters <code>{foo:bar}</code></li>
+</ul>             </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="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">value</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">().</span><span class="nx">value</span></pre></div>             </td>           </tr>                               <tr id="section-111">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-111">&#182;</a>               </div>               <ul>
+<li>splats within destructured parameters <code>[xs...]</code></li>
+</ul>             </td>             <td class="code">               <div class="highlight"><pre>      <span class="k">else</span> <span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Splat</span>
+        <span class="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">name</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">().</span><span class="nx">value</span>
+      <span class="k">else</span> <span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Value</span></pre></div>             </td>           </tr>                               <tr id="section-112">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-112">&#182;</a>               </div>               <ul>
+<li>destructured parameters within destructured parameters <code>[{a}]</code></li>
+</ul>             </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">isArray</span><span class="p">()</span> <span class="o">or</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">isObject</span><span class="p">()</span>
+          <span class="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@names</span><span class="p">(</span><span class="nx">obj</span><span class="p">.</span><span class="nx">base</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>               <ul>
+<li>at-params within destructured parameters <code>{@foo}</code></li>
+</ul>             </td>             <td class="code">               <div class="highlight"><pre>        <span class="k">else</span> <span class="k">if</span> <span class="nx">obj</span><span class="p">.</span><span class="k">this</span>
+          <span class="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">atParam</span><span class="p">(</span><span class="nx">obj</span><span class="p">)...</span></pre></div>             </td>           </tr>                               <tr id="section-114">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-114">&#182;</a>               </div>               <ul>
+<li>simple destructured parameters {foo}</li>
+</ul>             </td>             <td class="code">               <div class="highlight"><pre>        <span class="k">else</span> <span class="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">value</span>
+      <span class="k">else</span>
+        <span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s2">&quot;illegal parameter #{obj.compile()}&quot;</span>
+    <span class="nx">names</span></pre></div>             </td>           </tr>                               <tr id="section-115">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-115">&#182;</a>               </div>               <h3>Splat</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-116">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-116">&#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="k">class</span> <span class="nx">Splat</span> <span class="k">extends</span> <span class="nx">Base</span>

  <span class="nv">children: </span><span class="p">[</span><span class="s1">&#39;name&#39;</span><span class="p">]</span>
@@ -924,8 +1031,8 @@ or as part of a destructuring assignment.</p>             </td>             <td

  <span class="nv">compile: </span><span class="nf">(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>
-    
-  <span class="nv">unwrap: </span><span class="o">-&gt;</span> <span class="nx">@name</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
+
+  <span class="nv">unwrap: </span><span class="o">-&gt;</span> <span class="nx">@name</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>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="vi">@compileSplattedArray: </span><span class="nf">(o, list, apply) -&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>
@@ -941,8 +1048,8 @@ splats, to a proper array.</p>             </td>             <td class="code">
      <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[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
+    <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">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-118">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-118">&#182;</a>               </div>               <h3>While</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 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="k">class</span> <span class="nx">While</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(condition, options) -&gt;</span>
@@ -968,7 +1075,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="nv">loop: </span><span class="kc">yes</span>
-    <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
+    <span class="kc">no</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>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="nv">compileNode: </span><span class="nf">(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>
@@ -989,14 +1096,12 @@ 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-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
+    <span class="nx">code</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>Op</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 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="k">class</span> <span class="nx">Op</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(op, first, second, flip ) -&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">return</span> <span class="nx">@generateDo</span> <span class="nx">first</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="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>
@@ -1004,10 +1109,10 @@ CoffeeScript operations into their JavaScript equivalents.</p>             </td>
    <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-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="k">return</span> <span class="k">this</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>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-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;of&#39;</span><span class="o">:</span> <span class="s1">&#39;in&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-124">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-124">&#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>

@@ -1019,7 +1124,7 @@ CoffeeScript operations into their JavaScript equivalents.</p>             </td>
    <span class="o">not</span> <span class="nx">@second</span>

  <span class="nv">isComplex: </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
+    <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-125">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-125">&#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="nv">isChainable: </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>

@@ -1053,15 +1158,35 @@ CoffeeScript operations into their JavaScript equivalents.</p>             </td>
  <span class="nv">unfoldSoak: </span><span class="nf">(o) -&gt;</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="s1">&#39;delete&#39;</span><span class="p">]</span> <span class="o">and</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;first&#39;</span>

-  <span class="nv">compileNode: </span><span class="nf">(o) -&gt;</span>    
-    <span class="nv">isChain = </span><span class="nx">@isChainable</span><span class="p">()</span> <span class="o">and</span> <span class="nx">@first</span><span class="p">.</span><span class="nx">isChainable</span><span class="p">()</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>In chains, there's no need to wrap bare obj literals in parens, 
+  <span class="nv">generateDo: </span><span class="nf">(exp) -&gt;</span>
+    <span class="nv">passedParams = </span><span class="p">[]</span>
+    <span class="nv">func = </span><span class="k">if</span> <span class="nx">exp</span> <span class="k">instanceof</span> <span class="nx">Assign</span> <span class="o">and</span> <span class="p">(</span><span class="nv">ref = </span><span class="nx">exp</span><span class="p">.</span><span class="nx">value</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">())</span> <span class="k">instanceof</span> <span class="nx">Code</span>
+      <span class="nx">ref</span>
+    <span class="k">else</span>
+      <span class="nx">exp</span>
+    <span class="k">for</span> <span class="nx">param</span> <span class="k">in</span> <span class="nx">func</span><span class="p">.</span><span class="nx">params</span> <span class="o">or</span> <span class="p">[]</span>
+      <span class="k">if</span> <span class="nx">param</span><span class="p">.</span><span class="nx">value</span>
+        <span class="nx">passedParams</span><span class="p">.</span><span class="nx">push</span> <span class="nx">param</span><span class="p">.</span><span class="nx">value</span>
+        <span class="k">delete</span> <span class="nx">param</span><span class="p">.</span><span class="nx">value</span>
+      <span class="k">else</span>
+        <span class="nx">passedParams</span><span class="p">.</span><span class="nx">push</span> <span class="nx">param</span>
+    <span class="nv">call = </span><span class="k">new</span> <span class="nx">Call</span> <span class="nx">exp</span><span class="p">,</span> <span class="nx">passedParams</span>
+    <span class="nv">call.do = </span><span class="kc">yes</span>
+    <span class="nx">call</span>
+
+  <span class="nv">compileNode: </span><span class="nf">(o) -&gt;</span>
+    <span class="nv">isChain = </span><span class="nx">@isChainable</span><span class="p">()</span> <span class="o">and</span> <span class="nx">@first</span><span class="p">.</span><span class="nx">isChainable</span><span class="p">()</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>In chains, there's no need to wrap bare obj literals in parens,
 as the chained expression is wrapped.</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="vi">@first.front = </span><span class="nx">@front</span> <span class="nx">unless</span> <span class="nx">isChain</span>
+    <span class="k">if</span> <span class="nx">@operator</span> <span class="o">is</span> <span class="s1">&#39;delete&#39;</span> <span class="o">and</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="p">(</span><span class="nx">@first</span><span class="p">.</span><span class="nx">unwrapAll</span><span class="p">().</span><span class="nx">value</span><span class="p">)</span>
+      <span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s1">&#39;delete operand may not be argument or var&#39;</span>
+    <span class="k">if</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">and</span> <span class="nx">@first</span><span class="p">.</span><span class="nx">unwrapAll</span><span class="p">().</span><span class="nx">value</span> <span class="k">in</span> <span class="nx">STRICT_PROSCRIBED</span>
+      <span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s1">&#39;prefix increment/decrement may not have eval or arguments operand&#39;</span>
    <span class="k">return</span> <span class="nx">@compileUnary</span>     <span class="nx">o</span> <span class="k">if</span> <span class="nx">@isUnary</span><span class="p">()</span>
    <span class="k">return</span> <span class="nx">@compileChain</span>     <span class="nx">o</span> <span class="k">if</span> <span class="nx">isChain</span>
    <span class="k">return</span> <span class="nx">@compileExistence</span> <span class="nx">o</span> <span class="k">if</span> <span class="nx">@operator</span> <span class="o">is</span> <span class="s1">&#39;?&#39;</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-115">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-115">&#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-127">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-127">&#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'
@@ -1073,25 +1198,27 @@ true
    <span class="s2">&quot;(#{code})&quot;</span>

  <span class="nv">compileExistence: </span><span class="nf">(o) -&gt;</span>
-    <span class="k">if</span> <span class="nx">@first</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</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_TOP</span>
+    <span class="k">if</span> <span class="nx">@first</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">@first</span>
    <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="nv">type: </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-116">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-116">&#182;</a>               </div>               <p>Compile a unary <strong>Op</strong>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">compileUnary: </span><span class="nf">(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="nv">type: </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-128">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-128">&#182;</a>               </div>               <p>Compile a unary <strong>Op</strong>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">compileUnary: </span><span class="nf">(o) -&gt;</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_ACCESS</span>
+      <span class="k">return</span> <span class="p">(</span><span class="k">new</span> <span class="nx">Parens</span> <span class="k">this</span><span class="p">).</span><span class="nx">compile</span> <span class="nx">o</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="nv">plusMinus = </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="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">plusMinus</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>
    <span class="k">if</span> <span class="p">(</span><span class="nx">plusMinus</span> <span class="o">&amp;&amp;</span> <span class="nx">@first</span> <span class="k">instanceof</span> <span class="nx">Op</span><span class="p">)</span> <span class="o">or</span> <span class="p">(</span><span class="nx">op</span> <span class="o">is</span> <span class="s1">&#39;new&#39;</span> <span class="o">and</span> <span class="nx">@first</span><span class="p">.</span><span class="nx">isStatement</span> <span class="nx">o</span><span class="p">)</span>
-      <span class="vi">@first = </span><span class="k">new</span> <span class="nx">Parens</span> <span class="nx">@first</span> 
+      <span class="vi">@first = </span><span class="k">new</span> <span class="nx">Parens</span> <span class="nx">@first</span>
    <span class="nx">parts</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@first</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="nx">parts</span><span class="p">.</span><span class="nx">reverse</span><span class="p">()</span> <span class="k">if</span> <span class="nx">@flip</span>
    <span class="nx">parts</span><span class="p">.</span><span class="nx">join</span> <span class="s1">&#39;&#39;</span>

  <span class="nv">toString: </span><span class="nf">(idt) -&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-117">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-117">&#182;</a>               </div>               <h3>In</h3>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.In = </span><span class="k">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-129">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-129">&#182;</a>               </div>               <h3>In</h3>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.In = </span><span class="k">class</span> <span class="nx">In</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(@object, @array) -&gt;</span>

  <span class="nv">children: </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>
@@ -1102,7 +1229,7 @@ true
    <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="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-118">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-118">&#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="k">break</span></pre></div>             </td>           </tr>                               <tr id="section-130">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-130">&#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="nv">compileOrTest: </span><span class="nf">(o) -&gt;</span>
@@ -1123,7 +1250,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="nv">toString: </span><span class="nf">(idt) -&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-119">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-119">&#182;</a>               </div>               <h3>Try</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-120">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-120">&#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="k">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-131">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-131">&#182;</a>               </div>               <h3>Try</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-132">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-132">&#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="k">class</span> <span class="nx">Try</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(@attempt, @error, @recovery, @ensure) -&gt;</span>

  <span class="nv">children: </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>
@@ -1135,32 +1262,34 @@ true
  <span class="nv">makeReturn: </span><span class="nf">(res) -&gt;</span>
    <span class="vi">@attempt  = </span><span class="nx">@attempt</span> <span class="p">.</span><span class="nx">makeReturn</span> <span class="nx">res</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="nx">res</span> <span class="k">if</span> <span class="nx">@recovery</span>
-    <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-121">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-121">&#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-133">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-133">&#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="nv">compileNode: </span><span class="nf">(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">tryPart   = </span><span class="nx">@attempt</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">catchPart = </span><span class="k">if</span> <span class="nx">@recovery</span>
+      <span class="k">if</span> <span class="nx">@error</span><span class="p">.</span><span class="nx">value</span> <span class="k">in</span> <span class="nx">STRICT_PROSCRIBED</span>
+        <span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s2">&quot;catch variable may not be \&quot;#{@error.value}\&quot;&quot;</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="nx">unless</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">@error</span><span class="p">.</span><span class="nx">value</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 (_error) {}&#39;</span>
-      
+
    <span class="nv">ensurePart = </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>
-      
+
    <span class="s2">&quot;&quot;&quot;#{@tab}try {</span>
 <span class="s2">    #{tryPart}</span>
-<span class="s2">    #{@tab}}#{ catchPart or &#39;&#39; }#{ensurePart}&quot;&quot;&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>Throw</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>Simple node to throw an exception.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.Throw = </span><span class="k">class</span> <span class="nx">Throw</span> <span class="k">extends</span> <span class="nx">Base</span>
+<span class="s2">    #{@tab}}#{ catchPart or &#39;&#39; }#{ensurePart}&quot;&quot;&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>               <h3>Throw</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-135">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-135">&#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="k">class</span> <span class="nx">Throw</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(@expression) -&gt;</span>

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

  <span class="nv">isStatement: </span><span class="nx">YES</span>
-  <span class="nv">jumps: </span>      <span class="nx">NO</span></pre></div>             </td>           </tr>                               <tr id="section-124">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-124">&#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="nv">makeReturn: </span><span class="nx">THIS</span>
+  <span class="nv">jumps: </span>      <span class="nx">NO</span></pre></div>             </td>           </tr>                               <tr id="section-136">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-136">&#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="nv">makeReturn: </span><span class="nx">THIS</span>

  <span class="nv">compileNode: </span><span class="nf">(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-125">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-125">&#182;</a>               </div>               <h3>Existence</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-126">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-126">&#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-137">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-137">&#182;</a>               </div>               <h3>Existence</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-138">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-138">&#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="k">class</span> <span class="nx">Existence</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(@expression) -&gt;</span>
@@ -1175,8 +1304,8 @@ table.</p>             </td>             <td class="code">               <div cl
    <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="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="nv">code = </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-127">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-127">&#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="nv">code = </span><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-128">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-128">&#182;</a>               </div>               <h3>Parens</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-129">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-129">&#182;</a>               </div>               <p>An extra set of parentheses, specified explicitly in the source. At one time
+    <span class="k">else</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>do not use strict equality here; it will break existing code</p>             </td>             <td class="code">               <div class="highlight"><pre>      <span class="nv">code = </span><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-140">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-140">&#182;</a>               </div>               <h3>Parens</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-141">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-141">&#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>

@@ -1196,7 +1325,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-130">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-130">&#182;</a>               </div>               <h3>For</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-131">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-131">&#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-142">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-142">&#182;</a>               </div>               <h3>For</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>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>

@@ -1216,7 +1345,7 @@ you can map and filter in a single pass.</p>             </td>             <td c
    <span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s1">&#39;cannot pattern match over range loops&#39;</span> <span class="k">if</span> <span class="nx">@range</span> <span class="o">and</span> <span class="nx">@pattern</span>
    <span class="vi">@returns = </span><span class="kc">false</span>

-  <span class="nv">children: </span><span class="p">[</span><span class="s1">&#39;body&#39;</span><span class="p">,</span> <span class="s1">&#39;source&#39;</span><span class="p">,</span> <span class="s1">&#39;guard&#39;</span><span class="p">,</span> <span class="s1">&#39;step&#39;</span><span class="p">]</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>Welcome to the hairiest method in all of CoffeeScript. Handles the inner
+  <span class="nv">children: </span><span class="p">[</span><span class="s1">&#39;body&#39;</span><span class="p">,</span> <span class="s1">&#39;source&#39;</span><span class="p">,</span> <span class="s1">&#39;guard&#39;</span><span class="p">,</span> <span class="s1">&#39;step&#39;</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>               <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="nv">compileNode: </span><span class="nf">(o) -&gt;</span>
@@ -1227,28 +1356,31 @@ some cannot.</p>             </td>             <td class="code">               <
    <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="nv">immediate: </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="nv">immediate: </span><span class="kc">yes</span><span class="p">)</span> <span class="k">if</span> <span class="nx">index</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="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="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></pre></div>             </td>           </tr>                               <tr id="section-133">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-133">&#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">ivar      = </span><span class="p">(</span><span class="nx">@object</span> <span class="o">and</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">kvar      = </span><span class="p">(</span><span class="nx">@range</span> <span class="o">and</span> <span class="nx">name</span><span class="p">)</span> <span class="o">or</span> <span class="nx">index</span> <span class="o">or</span> <span class="nx">ivar</span>
+    <span class="nv">kvarAssign = </span><span class="k">if</span> <span class="nx">kvar</span> <span class="o">isnt</span> <span class="nx">ivar</span> <span class="k">then</span> <span class="s2">&quot;#{kvar} = &quot;</span> <span class="k">else</span> <span class="s2">&quot;&quot;</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>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="nv">index: </span><span class="nx">ivar</span><span class="p">,</span> <span class="nx">@step</span><span class="p">})</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="nv">index: </span><span class="nx">ivar</span><span class="p">,</span> <span class="nx">name</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="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="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}[#{kvar}]&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">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">forVarPart = </span><span class="s2">&quot;#{kvarAssign}#{ivar} = 0, #{lvar} = #{svar}.length&quot;</span>
+        <span class="nx">forVarPart</span> <span class="o">+=</span> <span class="s2">&quot;, #{stepvar} = #{@step.compile o, LEVEL_OP}&quot;</span> <span class="k">if</span> <span class="nx">@step</span>
+        <span class="nv">stepPart   = </span><span class="s2">&quot;#{kvarAssign}#{if @step then &quot;</span><span class="c1">#{ivar} += #{stepvar}&quot; else (if kvar isnt ivar then &quot;++#{ivar}&quot; else &quot;#{ivar}++&quot;)}&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>
@@ -1260,12 +1392,12 @@ some cannot.</p>             </td>             <td class="code">               <
      <span class="k">else</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">@guard</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">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}[#{kvar}]&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="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">forPart   = </span><span class="s2">&quot;#{kvar} in #{svar}&quot;</span>
+      <span class="nv">guardPart = </span><span class="s2">&quot;\n#{idt1}if (!#{utility &#39;hasProp&#39;}.call(#{svar}, #{kvar})) 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="nv">indent: </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>
@@ -1290,7 +1422,7 @@ some cannot.</p>             </td>             <td class="code">               <
        <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">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-134">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-134">&#182;</a>               </div>               <h3>Switch</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-135">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-135">&#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="k">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-146">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-146">&#182;</a>               </div>               <h3>Switch</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-147">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-147">&#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="k">class</span> <span class="nx">Switch</span> <span class="k">extends</span> <span class="nx">Base</span>
  <span class="nv">constructor: </span><span class="nf">(@subject, @cases, @otherwise) -&gt;</span>

  <span class="nv">children: </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>
@@ -1322,7 +1454,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-136">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-136">&#182;</a>               </div>               <h3>If</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><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-148">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-148">&#182;</a>               </div>               <h3>If</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-149">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-149">&#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,
@@ -1336,13 +1468,13 @@ because ternaries are already proper expressions, and don't need conversion.</p>
  <span class="nv">children: </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="nv">bodyNode: </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="nv">elseBodyNode: </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-138">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-138">&#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="nv">addElse: </span><span class="nf">(elseBody) -&gt;</span>
+  <span class="nv">elseBodyNode: </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-150">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-150">&#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="nv">addElse: </span><span class="nf">(elseBody) -&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-139">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-139">&#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-151">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-151">&#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="nv">isStatement: </span><span class="nf">(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>
@@ -1359,7 +1491,7 @@ to be a statement. Otherwise a conditional operator is safe.</p>             </t
    <span class="k">this</span>

  <span class="nv">ensureBlock: </span><span class="nf">(node) -&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-140">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-140">&#182;</a>               </div>               <p>Compile the <code>If</code> 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-152">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-152">&#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="nv">compileStatement: </span><span class="nf">(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>
@@ -1370,17 +1502,7 @@ force inner <em>else</em> bodies into statement form.</p>             </td>
    <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="nv">bodyc    = </span><span class="nx">body</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span>
-    <span class="k">if</span> <span class="p">(</span>
-      <span class="mi">1</span> <span class="o">is</span> <span class="nx">body</span><span class="p">.</span><span class="nx">expressions</span><span class="o">?</span><span class="p">.</span><span class="nx">length</span> <span class="o">and</span>
-      <span class="o">!</span><span class="nx">@elseBody</span> <span class="o">and</span> <span class="o">!</span><span class="nx">child</span> <span class="o">and</span>
-      <span class="nx">bodyc</span> <span class="o">and</span> <span class="nx">cond</span> <span class="o">and</span>
-      <span class="o">-</span><span class="mi">1</span> <span class="o">is</span> <span class="p">(</span><span class="nx">bodyc</span><span class="p">.</span><span class="nx">indexOf</span> <span class="s1">&#39;\n&#39;</span><span class="p">)</span> <span class="o">and</span>
-      <span class="mi">80</span> <span class="o">&gt;</span> <span class="nx">cond</span><span class="p">.</span><span class="nx">length</span> <span class="o">+</span> <span class="nx">bodyc</span><span class="p">.</span><span class="nx">length</span>
-    <span class="p">)</span>
-      <span class="k">return</span> <span class="s2">&quot;#{@tab}if (#{cond}) #{bodyc.replace /^\s+/, &#39;&#39;}&quot;</span>
-    <span class="nv">bodyc    = </span><span class="s2">&quot;\n#{bodyc}\n#{@tab}&quot;</span> <span class="k">if</span> <span class="nx">bodyc</span>
-    <span class="nv">ifPart   = </span><span class="s2">&quot;if (#{cond}) {#{bodyc}}&quot;</span>
+    <span class="nv">ifPart   = </span><span class="s2">&quot;if (#{cond}) {\n#{body.compile(o)}\n#{@tab}}&quot;</span>
    <span class="nv">ifPart   = </span><span class="nx">@tab</span> <span class="o">+</span> <span class="nx">ifPart</span> <span class="nx">unless</span> <span class="nx">child</span>
    <span class="k">return</span> <span class="nx">ifPart</span> <span class="nx">unless</span> <span class="nx">@elseBody</span>
    <span class="nx">ifPart</span> <span class="o">+</span> <span class="s1">&#39; else &#39;</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">@isChain</span>
@@ -1388,7 +1510,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-141">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-141">&#182;</a>               </div>               <p>Compile the <code>If</code> as a conditional operator.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">compileExpression: </span><span class="nf">(o) -&gt;</span>
+      <span class="s2">&quot;{\n#{ @elseBody.compile o, LEVEL_TOP }\n#{@tab}}&quot;</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>Compile the <code>If</code> as a conditional operator.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">compileExpression: </span><span class="nf">(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>
@@ -1396,10 +1518,10 @@ 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="nv">unfoldSoak: </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-142">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-142">&#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-154">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-154">&#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-143">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-143">&#182;</a>               </div>               <h3>Closure</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-144">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-144">&#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-145">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-145">&#182;</a>               </div>               <p>Wrap the expressions body, unless it contains a pure statement,
+generation to generate other combinations of nodes.</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-155">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-155">&#182;</a>               </div>               <h3>Closure</h3>             </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>               <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-157">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-157">&#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="nv">wrap: </span><span class="nf">(expressions, statement, noReturn) -&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>
@@ -1416,28 +1538,29 @@ then make sure that the closure wrapper preserves the original values.</p>

  <span class="nv">literalArgs: </span><span class="nf">(node) -&gt;</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;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="nv">literalThis: </span><span class="nf">(node) -&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-146">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-146">&#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="nf">(o, parent, name) -&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> <span class="o">or</span>
+      <span class="p">(</span><span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Call</span> <span class="o">and</span> <span class="nx">node</span><span class="p">.</span><span class="nx">isSuper</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-158">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-158">&#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="nf">(o, parent, name) -&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-147">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-147">&#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-148">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-148">&#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-159">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-159">&#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-160">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-160">&#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="o">-&gt;</span> <span class="s2">&quot;&quot;&quot;</span>
-<span class="s2">    function(child, parent) { for (var key in parent) { if (#{utility &#39;hasProp&#39;}.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor; child.__super__ = parent.prototype; return child; }</span>
-<span class="s2">  &quot;&quot;&quot;</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>Create a function bound to the current value of "this".</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">bind: </span><span class="o">-&gt;</span> <span class="s1">&#39;&#39;&#39;</span>
+<span class="s2">    function(child, parent) { for (var key in parent) { if (#{utility &#39;hasProp&#39;}.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }</span>
+<span class="s2">  &quot;&quot;&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-161">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-161">&#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="nv">bind: </span><span class="o">-&gt;</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-150">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-150">&#182;</a>               </div>               <p>Discover if an item is in an array.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">indexOf: </span><span class="o">-&gt;</span> <span class="s2">&quot;&quot;&quot;</span>
-<span class="s2">    Array.prototype.indexOf || function(item) { for (var i = 0, l = this.length; i &lt; l; i++) { if (i in this &amp;&amp; this[i] === item) return i; } return -1; }</span>
-<span class="s2">  &quot;&quot;&quot;</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>Shortcuts to speed up the lookup time for native functions.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">hasProp: </span><span class="o">-&gt;</span> <span class="s1">&#39;Object.prototype.hasOwnProperty&#39;</span>
-  <span class="nv">slice  : </span><span class="o">-&gt;</span> <span class="s1">&#39;Array.prototype.slice&#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>Levels indicate 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-162">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-162">&#182;</a>               </div>               <p>Discover if an item is in an array.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">indexOf: </span><span class="o">-&gt;</span> <span class="s2">&quot;&quot;&quot;</span>
+<span class="s2">    [].indexOf || function(item) { for (var i = 0, l = this.length; i &lt; l; i++) { if (i in this &amp;&amp; this[i] === item) return i; } return -1; }</span>
+<span class="s2">  &quot;&quot;&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-163">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-163">&#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="nv">hasProp: </span><span class="o">-&gt;</span> <span class="s1">&#39;{}.hasOwnProperty&#39;</span>
+  <span class="nv">slice  : </span><span class="o">-&gt;</span> <span class="s1">&#39;[].slice&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-164">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-164">&#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-153">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-153">&#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-165">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-165">&#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_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>
@@ -1460,7 +1583,7 @@ parens are necessary or superfluous.</p>             </td>             <td class


 <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-154">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-154">&#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-155">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-155">&#182;</a>               </div>               <h2>Utility Functions</h2>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">utility = </span><span class="nf">(name) -&gt;</span>
+<span class="s2">IS_STRING = /^[&#39;&quot;</span><span class="p">]</span><span class="o">/</span></pre></div>             </td>           </tr>                               <tr id="section-166">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-166">&#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-167">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-167">&#182;</a>               </div>               <h2>Utility Functions</h2>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">utility = </span><span class="nf">(name) -&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>
@@ -1469,4 +1592,4 @@ parens are necessary or superfluous.</p>             </td>             <td class
  <span class="nv">code = </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>
  <span class="nx">code</span><span class="p">.</span><span class="nx">replace</span> <span class="sr">/\s+$/</span><span class="p">,</span> <span class="s1">&#39;&#39;</span>

-</pre></div>             </td>           </tr>                               <tr id="section-156">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-156">&#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> 
+</pre></div>             </td>           </tr>                               <tr id="section-168">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-168">&#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,34 +13,40 @@ 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="nv">constructor: </span><span class="nf">(rules, @banner) -&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 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
-you to attach callback actions for every flag. Instead, you're responsible
-for interpreting the options object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">parse: </span><span class="nf">(args) -&gt;</span>
-    <span class="nv">options = arguments: </span><span class="p">[],</span> <span class="nv">literals: </span><span class="p">[]</span>
+specified options, and return it. Options after the first non-option
+argument are treated as arguments. <code>options.arguments</code> will be an array
+containing the remaining arguments. This is a simpler API than many option
+parsers that allow you to attach callback actions for every flag. Instead,
+you're responsible for interpreting the options object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">parse: </span><span class="nf">(args) -&gt;</span>
+    <span class="nv">options = arguments: </span><span class="p">[]</span>
+    <span class="nv">skippingArgument = </span><span class="kc">no</span>
    <span class="nv">originalArgs = </span><span class="nx">args</span>
    <span class="nv">args = </span><span class="nx">normalizeArguments</span> <span class="nx">args</span>
    <span class="k">for</span> <span class="nx">arg</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">args</span>
+      <span class="k">if</span> <span class="nx">skippingArgument</span>
+        <span class="nv">skippingArgument = </span><span class="kc">no</span>
+        <span class="k">continue</span>
      <span class="k">if</span> <span class="nx">arg</span> <span class="o">is</span> <span class="s1">&#39;--&#39;</span>
        <span class="nv">pos = </span><span class="nx">originalArgs</span><span class="p">.</span><span class="nx">indexOf</span> <span class="s1">&#39;--&#39;</span>
-        <span class="nv">options.arguments = </span><span class="p">[</span><span class="nx">originalArgs</span><span class="p">[</span><span class="mi">1</span> <span class="o">+</span> <span class="nx">pos</span><span class="p">]]</span>
-        <span class="nv">options.literals = </span><span class="nx">originalArgs</span><span class="p">[(</span><span class="mi">2</span> <span class="o">+</span> <span class="nx">pos</span><span class="p">)..]</span>
+        <span class="nv">options.arguments = </span><span class="nx">options</span><span class="p">.</span><span class="nx">arguments</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">originalArgs</span><span class="p">[(</span><span class="nx">pos</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)..]</span>
        <span class="k">break</span>
-      <span class="nv">isOption = </span><span class="o">!!</span><span class="p">(</span><span class="nx">arg</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">LONG_FLAG</span><span class="p">)</span> <span class="o">or</span> <span class="nx">arg</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">SHORT_FLAG</span><span class="p">))</span>
-      <span class="nv">matchedRule = </span><span class="kc">no</span>
-      <span class="k">for</span> <span class="nx">rule</span> <span class="k">in</span> <span class="nx">@rules</span>
-        <span class="k">if</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">shortFlag</span> <span class="o">is</span> <span class="nx">arg</span> <span class="o">or</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">longFlag</span> <span class="o">is</span> <span class="nx">arg</span>
-          <span class="nv">value = </span><span class="k">if</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">hasArgument</span> <span class="k">then</span> <span class="nx">args</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="k">else</span> <span class="kc">true</span>
-          <span class="nx">options</span><span class="p">[</span><span class="nx">rule</span><span class="p">.</span><span class="nx">name</span><span class="p">]</span> <span class="o">=</span> <span class="k">if</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">isList</span> <span class="k">then</span> <span class="p">(</span><span class="nx">options</span><span class="p">[</span><span class="nx">rule</span><span class="p">.</span><span class="nx">name</span><span class="p">]</span> <span class="o">or</span> <span class="p">[]).</span><span class="nx">concat</span> <span class="nx">value</span> <span class="k">else</span> <span class="nx">value</span>
-          <span class="nv">matchedRule = </span><span class="kc">yes</span>
-          <span class="k">break</span>
-      <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;unrecognized option: #{arg}&quot;</span> <span class="k">if</span> <span class="nx">isOption</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">matchedRule</span>
-      <span class="k">if</span> <span class="o">not</span> <span class="nx">isOption</span>
-        <span class="nv">options.arguments = </span><span class="nx">originalArgs</span><span class="p">[(</span><span class="nx">originalArgs</span><span class="p">.</span><span class="nx">indexOf</span> <span class="nx">arg</span><span class="p">)..]</span>
-        <span class="k">break</span>
-    <span class="nx">options</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>Return the help text for this <strong>OptionParser</strong>, listing and describing all
+      <span class="nv">isOption = </span><span class="o">!!</span><span class="p">(</span><span class="nx">arg</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">LONG_FLAG</span><span class="p">)</span> <span class="o">or</span> <span class="nx">arg</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">SHORT_FLAG</span><span class="p">))</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>the CS option parser is a little odd; options after the first
+non-option argument are treated as non-option arguments themselves</p>             </td>             <td class="code">               <div class="highlight"><pre>      <span class="nv">seenNonOptionArg = </span><span class="nx">options</span><span class="p">.</span><span class="nx">arguments</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="mi">0</span>
+      <span class="nx">unless</span> <span class="nx">seenNonOptionArg</span>
+        <span class="nv">matchedRule = </span><span class="kc">no</span>
+        <span class="k">for</span> <span class="nx">rule</span> <span class="k">in</span> <span class="nx">@rules</span>
+          <span class="k">if</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">shortFlag</span> <span class="o">is</span> <span class="nx">arg</span> <span class="o">or</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">longFlag</span> <span class="o">is</span> <span class="nx">arg</span>
+            <span class="nv">value = </span><span class="kc">true</span>
+            <span class="k">if</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">hasArgument</span>
+              <span class="nv">skippingArgument = </span><span class="kc">yes</span>
+              <span class="nv">value = </span><span class="nx">args</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">options</span><span class="p">[</span><span class="nx">rule</span><span class="p">.</span><span class="nx">name</span><span class="p">]</span> <span class="o">=</span> <span class="k">if</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">isList</span> <span class="k">then</span> <span class="p">(</span><span class="nx">options</span><span class="p">[</span><span class="nx">rule</span><span class="p">.</span><span class="nx">name</span><span class="p">]</span> <span class="o">or</span> <span class="p">[]).</span><span class="nx">concat</span> <span class="nx">value</span> <span class="k">else</span> <span class="nx">value</span>
+            <span class="nv">matchedRule = </span><span class="kc">yes</span>
+            <span class="k">break</span>
+        <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;unrecognized option: #{arg}&quot;</span> <span class="k">if</span> <span class="nx">isOption</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">matchedRule</span>
+      <span class="k">if</span> <span class="nx">seenNonOptionArg</span> <span class="o">or</span> <span class="o">not</span> <span class="nx">isOption</span>
+        <span class="nx">options</span><span class="p">.</span><span class="nx">arguments</span><span class="p">.</span><span class="nx">push</span> <span class="nx">arg</span>
+    <span class="nx">options</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>Return the help text for this <strong>OptionParser</strong>, listing and describing all
 of the valid options, for <code>--help</code> and such.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">help: </span><span class="o">-&gt;</span>
    <span class="nv">lines = </span><span class="p">[]</span>
    <span class="nx">lines</span><span class="p">.</span><span class="nx">unshift</span> <span class="s2">&quot;#{@banner}\n&quot;</span> <span class="k">if</span> <span class="nx">@banner</span>
@@ -49,14 +55,14 @@ of the valid options, for <code>--help</code> and such.</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">letPart = </span><span class="k">if</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">shortFlag</span> <span class="k">then</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">shortFlag</span> <span class="o">+</span> <span class="s1">&#39;, &#39;</span> <span class="k">else</span> <span class="s1">&#39;    &#39;</span>
      <span class="nx">lines</span><span class="p">.</span><span class="nx">push</span> <span class="s1">&#39;  &#39;</span> <span class="o">+</span> <span class="nx">letPart</span> <span class="o">+</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">longFlag</span> <span class="o">+</span> <span class="nx">spaces</span> <span class="o">+</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">description</span>
-    <span class="s2">&quot;\n#{ lines.join(&#39;\n&#39;) }\n&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-5">&#182;</a>               </div>               <h2>Helpers</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-6">&#182;</a>               </div>               <p>Regex matchers for option flags.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">LONG_FLAG  = </span><span class="sr">/^(--\w[\w\-]+)/</span>
-<span class="nv">SHORT_FLAG = </span><span class="sr">/^(-\w)/</span>
+    <span class="s2">&quot;\n#{ lines.join(&#39;\n&#39;) }\n&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-6">&#182;</a>               </div>               <h2>Helpers</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-7">&#182;</a>               </div>               <p>Regex matchers for option flags.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">LONG_FLAG  = </span><span class="sr">/^(--\w[\w\-]*)/</span>
+<span class="nv">SHORT_FLAG = </span><span class="sr">/^(-\w)$/</span>
 <span class="nv">MULTI_FLAG = </span><span class="sr">/^-(\w{2,})/</span>
-<span class="nv">OPTIONAL   = </span><span class="sr">/\[(\w+(\*?))\]/</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>Build and return the list of option rules. If the optional <em>short-flag</em> is
+<span class="nv">OPTIONAL   = </span><span class="sr">/\[(\w+(\*?))\]/</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>Build and return the list of option rules. If the optional <em>short-flag</em> is
 unspecified, leave it out by padding with <code>null</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">buildRules = </span><span class="nf">(rules) -&gt;</span>
  <span class="k">for</span> <span class="nx">tuple</span> <span class="k">in</span> <span class="nx">rules</span>
    <span class="nx">tuple</span><span class="p">.</span><span class="nx">unshift</span> <span class="kc">null</span> <span class="k">if</span> <span class="nx">tuple</span><span class="p">.</span><span class="nx">length</span> <span class="o">&lt;</span> <span class="mi">3</span>
-    <span class="nx">buildRule</span> <span class="nx">tuple</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>Build a rule from a <code>-o</code> short flag, a <code>--output [DIR]</code> long flag, and the
+    <span class="nx">buildRule</span> <span class="nx">tuple</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>               <p>Build a rule from a <code>-o</code> short flag, a <code>--output [DIR]</code> long flag, and the
 description of what the option does.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">buildRule = </span><span class="nf">(shortFlag, longFlag, description, options = {}) -&gt;</span>
  <span class="nv">match     = </span><span class="nx">longFlag</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">OPTIONAL</span><span class="p">)</span>
  <span class="nv">longFlag  = </span><span class="nx">longFlag</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="nx">LONG_FLAG</span><span class="p">)[</span><span class="mi">1</span><span class="p">]</span>
@@ -67,9 +73,9 @@ description of what the option does.</p>             </td>             <td class
    <span class="nv">description: </span> <span class="nx">description</span>
    <span class="nv">hasArgument: </span> <span class="o">!!</span><span class="p">(</span><span class="nx">match</span> <span class="o">and</span> <span class="nx">match</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>
    <span class="nv">isList: </span>      <span class="o">!!</span><span class="p">(</span><span class="nx">match</span> <span class="o">and</span> <span class="nx">match</span><span class="p">[</span><span class="mi">2</span><span class="p">])</span>
-  <span class="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>               <p>Normalize arguments by expanding merged flags into multiple flags. This allows
+  <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>               <p>Normalize arguments by expanding merged flags into multiple flags. This allows
 you to have <code>-wl</code> be the same as <code>--watch --lint</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">normalizeArguments = </span><span class="nf">(args) -&gt;</span>
-  <span class="nv">args = </span><span class="nx">args</span><span class="p">.</span><span class="nx">slice</span> <span class="mi">0</span>
+  <span class="nv">args = </span><span class="nx">args</span><span class="p">[..]</span>
  <span class="nv">result = </span><span class="p">[]</span>
  <span class="k">for</span> <span class="nx">arg</span> <span class="k">in</span> <span class="nx">args</span>
    <span class="k">if</span> <span class="nv">match = </span><span class="nx">arg</span><span class="p">.</span><span class="nx">match</span> <span class="nx">MULTI_FLAG</span>
--- a/documentation/docs/repl.html
+++ b/documentation/docs/repl.html
@@ -3,19 +3,48 @@ and evaluates it. Good for simple tests, or poking around the <strong>Node.js</s
 Using it looks like this:</p>

 <pre><code>coffee&gt; console.log "#{num} bottles of beer" for num in [99..1]
-</code></pre>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="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>
+</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>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-3">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-3">&#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>
-<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">Module       = </span><span class="nx">require</span> <span class="s1">&#39;module&#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>REPL Setup</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-5">&#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_MULTILINE = </span><span class="s1">&#39;------&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="nf">(err) -&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&#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="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-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="nf">(err) -&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&#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>               <h1>Autocompletion</h1>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-8">&#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">/(\w+)$/i</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>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="nf">(text) -&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-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#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="nf">(text) -&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="k">catch</span> <span class="nx">error</span>
+      <span class="k">return</span>
+    <span class="nv">val = </span><span class="nb">Object</span> <span class="nx">val</span>
+    <span class="nv">possibilities = </span><span class="nb">Object</span><span class="p">.</span><span class="nx">getOwnPropertyNames</span> <span class="nx">val</span>
+    <span class="k">for</span> <span class="nx">key</span> <span class="k">of</span> <span class="nx">val</span> <span class="k">when</span> <span class="o">~</span><span class="nx">possibilities</span><span class="p">.</span><span class="nx">indexOf</span> <span class="nx">val</span>
+      <span class="nx">possibilities</span><span class="p">.</span><span class="nx">push</span> <span class="nx">key</span>
+    <span class="nv">completions = </span><span class="nx">getCompletions</span> <span class="nx">prefix</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">prefix</span><span class="p">]</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>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="nf">(text) -&gt;</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">free = </span><span class="s2">&quot;&quot;</span> <span class="k">if</span> <span class="nx">text</span> <span class="o">is</span> <span class="s2">&quot;&quot;</span>
+  <span class="k">if</span> <span class="nx">free</span><span class="o">?</span>
+    <span class="nv">vars = </span><span class="nx">Script</span><span class="p">.</span><span class="nx">runInThisContext</span> <span class="s1">&#39;Object.getOwnPropertyNames(Object(this))&#39;</span>
+    <span class="nv">keywords = </span><span class="p">(</span><span class="nx">r</span> <span class="k">for</span> <span class="nx">r</span> <span class="k">in</span> <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">RESERVED</span> <span class="k">when</span> <span class="nx">r</span><span class="p">[..</span><span class="mi">1</span><span class="p">]</span> <span class="o">isnt</span> <span class="s1">&#39;__&#39;</span><span class="p">)</span>
+    <span class="nv">possibilities = </span><span class="nx">vars</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">keywords</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-12">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-12">&#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="nf">(prefix, candidates) -&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-13">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-13">&#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-14">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-14">&#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-15">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-15">&#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="nf">(buffer) -&gt;</span>
+of exiting.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">run = </span><span class="nf">(buffer) -&gt;</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>remove single-line comments</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">buffer = </span><span class="nx">buffer</span><span class="p">.</span><span class="nx">replace</span> <span class="sr">/(^|[\r\n]+)(\s*)##?(?:[^#\r\n][^\r\n]*|)($|[\r\n])/</span><span class="p">,</span> <span class="s2">&quot;$1$2$3&quot;</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>remove trailing newlines</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">buffer = </span><span class="nx">buffer</span><span class="p">.</span><span class="nx">replace</span> <span class="sr">/[\r\n]+$/</span><span class="p">,</span> <span class="s2">&quot;&quot;</span>
+  <span class="k">if</span> <span class="nx">multilineMode</span>
+    <span class="nx">backlog</span> <span class="o">+=</span> <span class="s2">&quot;#{buffer}\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="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>
@@ -35,45 +64,71 @@ of exiting.</p>             </td>             <td class="code">               <d
    <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">global._ = </span><span class="nx">_</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="nx">repl</span><span class="p">.</span><span class="nx">output</span><span class="p">.</span><span class="nx">write</span> <span class="s2">&quot;#{inspect returnValue, no, 2, enableColours}\n&quot;</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="nf">(text) -&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="nf">(text) -&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="k">catch</span> <span class="nx">error</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-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="nf">(text) -&gt;</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="k">if</span> <span class="nx">free</span><span class="o">?</span>
-    <span class="nv">vars = </span><span class="nx">Script</span><span class="p">.</span><span class="nx">runInThisContext</span> <span class="s1">&#39;Object.getOwnPropertyNames(this)&#39;</span>
-    <span class="nv">keywords = </span><span class="p">(</span><span class="nx">r</span> <span class="k">for</span> <span class="nx">r</span> <span class="k">in</span> <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">RESERVED</span> <span class="k">when</span> <span class="nx">r</span><span class="p">[</span><span class="mi">0</span><span class="p">..</span><span class="mi">1</span><span class="p">]</span> <span class="o">isnt</span> <span class="s1">&#39;__&#39;</span><span class="p">)</span>
-    <span class="nv">possibilities = </span><span class="nx">vars</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">keywords</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-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="nf">(prefix, candidates) -&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>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-16">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-16">&#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="nf">(buffer) -&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">prompt</span><span class="p">()</span>
+
+<span class="k">if</span> <span class="nx">stdin</span><span class="p">.</span><span class="nx">readable</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>handle piped input</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">pipedInput = </span><span class="s1">&#39;&#39;</span>
+  <span class="nv">repl =</span>
+    <span class="nv">prompt: </span><span class="o">-&gt;</span> <span class="nx">stdout</span><span class="p">.</span><span class="nx">write</span> <span class="nx">@_prompt</span>
+    <span class="nv">setPrompt: </span><span class="nf">(p) -&gt;</span> <span class="vi">@_prompt = </span><span class="nx">p</span>
+    <span class="nv">input: </span><span class="nx">stdin</span>
+    <span class="nv">output: </span><span class="nx">stdout</span>
+    <span class="kc">on</span><span class="o">:</span> <span class="o">-&gt;</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="nf">(chunk) -&gt;</span>
+    <span class="nx">pipedInput</span> <span class="o">+=</span> <span class="nx">chunk</span>
+    <span class="k">return</span> <span class="nx">unless</span> <span class="sr">/\n/</span><span class="p">.</span><span class="nx">test</span> <span class="nx">pipedInput</span>
+    <span class="nv">lines = </span><span class="nx">pipedInput</span><span class="p">.</span><span class="nx">split</span> <span class="s2">&quot;\n&quot;</span>
+    <span class="nv">pipedInput = </span><span class="nx">lines</span><span class="p">[</span><span class="nx">lines</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span>
+    <span class="k">for</span> <span class="nx">line</span> <span class="k">in</span> <span class="nx">lines</span><span class="p">[...</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="k">when</span> <span class="nx">line</span>
+      <span class="nx">stdout</span><span class="p">.</span><span class="nx">write</span> <span class="s2">&quot;#{line}\n&quot;</span>
+      <span class="nx">run</span> <span class="nx">line</span>
+    <span class="k">return</span>
+  <span class="nx">stdin</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;end&#39;</span><span class="p">,</span> <span class="o">-&gt;</span>
+    <span class="k">for</span> <span class="nx">line</span> <span class="k">in</span> <span class="nx">pipedInput</span><span class="p">.</span><span class="nx">trim</span><span class="p">().</span><span class="nx">split</span> <span class="s2">&quot;\n&quot;</span> <span class="k">when</span> <span class="nx">line</span>
+      <span class="nx">stdout</span><span class="p">.</span><span class="nx">write</span> <span class="s2">&quot;#{line}\n&quot;</span>
+      <span class="nx">run</span> <span class="nx">line</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">process</span><span class="p">.</span><span class="nx">exit</span> <span class="mi">0</span>
+<span class="k">else</span></pre></div>             </td>           </tr>                               <tr id="section-19">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-19">&#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="nf">(buffer) -&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="nv">multilineMode = </span><span class="kc">off</span></pre></div>             </td>           </tr>                               <tr id="section-20">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-20">&#182;</a>               </div>               <p>Handle multi-line mode switch</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nx">repl</span><span class="p">.</span><span class="nx">input</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;keypress&#39;</span><span class="p">,</span> <span class="nf">(char, key) -&gt;</span></pre></div>             </td>           </tr>                               <tr id="section-21">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-21">&#182;</a>               </div>               <p>test for Ctrl-v</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">return</span> <span class="nx">unless</span> <span class="nx">key</span> <span class="o">and</span> <span class="nx">key</span><span class="p">.</span><span class="nx">ctrl</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">key</span><span class="p">.</span><span class="nx">meta</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">key</span><span class="p">.</span><span class="nx">shift</span> <span class="o">and</span> <span class="nx">key</span><span class="p">.</span><span class="nx">name</span> <span class="o">is</span> <span class="s1">&#39;v&#39;</span>
+  <span class="nv">cursorPos = </span><span class="nx">repl</span><span class="p">.</span><span class="nx">cursor</span>
+  <span class="nx">repl</span><span class="p">.</span><span class="nx">output</span><span class="p">.</span><span class="nx">cursorTo</span> <span class="mi">0</span>
+  <span class="nx">repl</span><span class="p">.</span><span class="nx">output</span><span class="p">.</span><span class="nx">clearLine</span> <span class="mi">1</span>
+  <span class="nv">multilineMode = </span><span class="o">not</span> <span class="nx">multilineMode</span>
+  <span class="nx">repl</span><span class="p">.</span><span class="nx">_line</span><span class="p">()</span> <span class="k">if</span> <span class="o">not</span> <span class="nx">multilineMode</span> <span class="o">and</span> <span class="nx">backlog</span>
+  <span class="nv">backlog = </span><span class="s1">&#39;&#39;</span>
+  <span class="nx">repl</span><span class="p">.</span><span class="nx">setPrompt</span> <span class="p">(</span><span class="nv">newPrompt = </span><span class="k">if</span> <span class="nx">multilineMode</span> <span class="k">then</span> <span class="nx">REPL_PROMPT_MULTILINE</span> <span class="k">else</span> <span class="nx">REPL_PROMPT</span><span class="p">)</span>
+  <span class="nx">repl</span><span class="p">.</span><span class="nx">prompt</span><span class="p">()</span>
+  <span class="nx">repl</span><span class="p">.</span><span class="nx">output</span><span class="p">.</span><span class="nx">cursorTo</span> <span class="nx">newPrompt</span><span class="p">.</span><span class="nx">length</span> <span class="o">+</span> <span class="p">(</span><span class="nv">repl.cursor = </span><span class="nx">cursorPos</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-22">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-22">&#182;</a>               </div>               <p>Handle Ctrl-d press at end of last line in multiline mode</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nx">repl</span><span class="p">.</span><span class="nx">input</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;keypress&#39;</span><span class="p">,</span> <span class="nf">(char, key) -&gt;</span>
+  <span class="k">return</span> <span class="nx">unless</span> <span class="nx">multilineMode</span> <span class="o">and</span> <span class="nx">repl</span><span class="p">.</span><span class="nx">line</span></pre></div>             </td>           </tr>                               <tr id="section-23">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-23">&#182;</a>               </div>               <p>test for Ctrl-d</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">return</span> <span class="nx">unless</span> <span class="nx">key</span> <span class="o">and</span> <span class="nx">key</span><span class="p">.</span><span class="nx">ctrl</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">key</span><span class="p">.</span><span class="nx">meta</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">key</span><span class="p">.</span><span class="nx">shift</span> <span class="o">and</span> <span class="nx">key</span><span class="p">.</span><span class="nx">name</span> <span class="o">is</span> <span class="s1">&#39;d&#39;</span>
+  <span class="nv">multilineMode = </span><span class="kc">off</span>
+  <span class="nx">repl</span><span class="p">.</span><span class="nx">_line</span><span class="p">()</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">multilineMode</span>
+    <span class="nv">multilineMode = </span><span class="kc">off</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">output</span><span class="p">.</span><span class="nx">cursorTo</span> <span class="mi">0</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">output</span><span class="p">.</span><span class="nx">clearLine</span> <span class="mi">1</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">_onLine</span> <span class="nx">repl</span><span class="p">.</span><span class="nx">line</span>
+    <span class="k">return</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">output</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="nx">output</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">input</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>

--- a/documentation/docs/rewriter.html
+++ b/documentation/docs/rewriter.html
@@ -50,52 +50,55 @@ this, remove their trailing newlines.</p>             </td>             <td clas
      <span class="mi">0</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 lexer has tagged the opening parenthesis of a method call. Match it with
 its paired close. We have the mis-nested outdent case included here for
 calls that close on the same line, just before their outdent.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">closeOpenCalls: </span><span class="o">-&gt;</span>
-    
+
    <span class="nv">condition = </span><span class="nf">(token, i) -&gt;</span>
      <span class="nx">token</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="s1">&#39;)&#39;</span><span class="p">,</span> <span class="s1">&#39;CALL_END&#39;</span><span class="p">]</span> <span class="o">or</span>
      <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;OUTDENT&#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">is</span> <span class="s1">&#39;)&#39;</span>
-      
+
    <span class="nv">action = </span><span class="nf">(token, i) -&gt;</span>
      <span class="nx">@tokens</span><span class="p">[</span><span class="k">if</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;OUTDENT&#39;</span> <span class="k">then</span> <span class="nx">i</span> <span class="o">-</span> <span class="mi">1</span> <span class="k">else</span> <span class="nx">i</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;CALL_END&#39;</span>
-      
+
    <span class="nx">@scanTokens</span> <span class="nf">(token, i) -&gt;</span>
      <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="nx">condition</span><span class="p">,</span> <span class="nx">action</span> <span class="k">if</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;CALL_START&#39;</span>
      <span class="mi">1</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 lexer has tagged the opening parenthesis of an indexing operation call.
 Match it with its paired close.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">closeOpenIndexes: </span><span class="o">-&gt;</span>
-    
-    <span class="nv">condition = </span><span class="nf">(token, i) -&gt;</span> 
+
+    <span class="nv">condition = </span><span class="nf">(token, i) -&gt;</span>
      <span class="nx">token</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="s1">&#39;]&#39;</span><span class="p">,</span> <span class="s1">&#39;INDEX_END&#39;</span><span class="p">]</span>
-      
-    <span class="nv">action = </span><span class="nf">(token, i) -&gt;</span> 
+
+    <span class="nv">action = </span><span class="nf">(token, i) -&gt;</span>
      <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;INDEX_END&#39;</span>
-      
+
    <span class="nx">@scanTokens</span> <span class="nf">(token, i) -&gt;</span>
      <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="nx">condition</span><span class="p">,</span> <span class="nx">action</span> <span class="k">if</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;INDEX_START&#39;</span>
      <span class="mi">1</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>Object literals may be written with implicit braces, for simple cases.
 Insert the missing braces here, so that the parser doesn't have to.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">addImplicitBraces: </span><span class="o">-&gt;</span>
-    
+
    <span class="nv">stack       = </span><span class="p">[]</span>
    <span class="nv">start       = </span><span class="kc">null</span>
    <span class="nv">startsLine  = </span><span class="kc">null</span>
    <span class="nv">sameLine    = </span><span class="kc">yes</span>
    <span class="nv">startIndent = </span><span class="mi">0</span>
-    
+    <span class="nv">startIndex  = </span><span class="mi">0</span>
+
    <span class="nv">condition = </span><span class="nf">(token, i) -&gt;</span>
      <span class="p">[</span><span class="nx">one</span><span class="p">,</span> <span class="nx">two</span><span class="p">,</span> <span class="nx">three</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">3</span><span class="p">]</span>
      <span class="k">return</span> <span class="kc">no</span> <span class="k">if</span> <span class="s1">&#39;HERECOMMENT&#39;</span> <span class="o">is</span> <span class="nx">one</span><span class="o">?</span><span class="p">[</span><span class="mi">0</span><span class="p">]</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="nv">sameLine = </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="p">((</span><span class="nx">tag</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">]</span> <span class="o">or</span> <span class="p">(</span><span class="nx">tag</span> <span class="k">in</span> <span class="nx">IMPLICIT_END</span> <span class="o">and</span> <span class="nx">sameLine</span><span class="p">))</span> <span class="o">and</span>
-          <span class="p">((</span><span class="o">!</span><span class="nx">startsLine</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="p">)</span> <span class="o">or</span> 
+      <span class="k">return</span> <span class="p">(</span>
+        <span class="p">(</span><span class="nx">tag</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">]</span> <span class="o">or</span> 
+          <span class="p">(</span><span class="nx">tag</span> <span class="k">in</span> <span class="nx">IMPLICIT_END</span> <span class="o">and</span> <span class="nx">sameLine</span> <span class="o">and</span> <span class="o">not</span> <span class="p">(</span><span class="nx">i</span> <span class="o">-</span> <span class="nx">startIndex</span> <span class="o">is</span> <span class="mi">1</span><span class="p">)))</span> <span class="o">and</span>
+        <span class="p">((</span><span class="o">!</span><span class="nx">startsLine</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="p">)</span> <span class="o">or</span>
          <span class="o">not</span> <span class="p">(</span><span class="nx">two</span><span class="o">?</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">or</span> <span class="nx">one</span><span class="o">?</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">three</span><span class="o">?</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="o">or</span>
        <span class="p">(</span><span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;,&#39;</span> <span class="o">and</span> <span class="nx">one</span> <span class="o">and</span>
-          <span class="nx">one</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">not</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;NUMBER&#39;</span><span class="p">,</span> <span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s1">&#39;@&#39;</span><span class="p">,</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">])</span>
-          
+          <span class="nx">one</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">not</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;NUMBER&#39;</span><span class="p">,</span> <span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s1">&#39;@&#39;</span><span class="p">,</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">]</span>
+      <span class="p">)</span>
+
    <span class="nv">action = </span><span class="nf">(token, i) -&gt;</span>
-      <span class="nv">tok = </span><span class="p">[</span><span class="s1">&#39;}&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]]</span>
-      <span class="nv">tok.generated = </span><span class="kc">yes</span>
+      <span class="nv">tok = </span><span class="nx">@generate</span> <span class="s1">&#39;}&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
      <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">tok</span>
-      
+
    <span class="nx">@scanTokens</span> <span class="nf">(token, i, tokens) -&gt;</span>
      <span class="k">if</span> <span class="p">(</span><span class="nv">tag = </span><span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="k">in</span> <span class="nx">EXPRESSION_START</span>
        <span class="nx">stack</span><span class="p">.</span><span class="nx">push</span> <span class="p">[(</span><span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;INDENT&#39;</span> <span class="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;{&#39;</span> <span class="k">then</span> <span class="s1">&#39;{&#39;</span> <span class="k">else</span> <span class="nx">tag</span><span class="p">),</span> <span class="nx">i</span><span class="p">]</span>
@@ -106,6 +109,7 @@ Insert the missing braces here, so that the parser doesn't have to.</p>
      <span class="k">return</span> <span class="mi">1</span> <span class="nx">unless</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;:&#39;</span> <span class="o">and</span>
        <span class="p">((</span><span class="nv">ago = </span><span class="nx">@tag</span> <span class="nx">i</span> <span class="o">-</span> <span class="mi">2</span><span class="p">)</span> <span class="o">is</span> <span class="s1">&#39;:&#39;</span> <span class="o">or</span> <span class="nx">stack</span><span class="p">[</span><span class="nx">stack</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span><span class="o">?</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">isnt</span> <span class="s1">&#39;{&#39;</span><span class="p">)</span>
      <span class="nv">sameLine = </span><span class="kc">yes</span>
+      <span class="nv">startIndex = </span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span>
      <span class="nx">stack</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="s1">&#39;{&#39;</span><span class="p">]</span>
      <span class="nv">idx = </span> <span class="k">if</span> <span class="nx">ago</span> <span class="o">is</span> <span class="s1">&#39;@&#39;</span> <span class="k">then</span> <span class="nx">i</span> <span class="o">-</span> <span class="mi">2</span> <span class="k">else</span> <span class="nx">i</span> <span class="o">-</span> <span class="mi">1</span>
      <span class="nx">idx</span> <span class="o">-=</span> <span class="mi">2</span> <span class="k">while</span> <span class="nx">@tag</span><span class="p">(</span><span class="nx">idx</span> <span class="o">-</span> <span class="mi">2</span><span class="p">)</span> <span class="o">is</span> <span class="s1">&#39;HERECOMMENT&#39;</span>
@@ -113,16 +117,15 @@ Insert the missing braces here, so that the parser doesn't have to.</p>
      <span class="nv">startsLine = </span><span class="o">not</span> <span class="nx">prevTag</span> <span class="o">or</span> <span class="p">(</span><span class="nx">prevTag</span> <span class="k">in</span> <span class="nx">LINEBREAKS</span><span class="p">)</span>
      <span class="nv">value = </span><span class="k">new</span> <span class="nb">String</span><span class="p">(</span><span class="s1">&#39;{&#39;</span><span class="p">)</span>
      <span class="nv">value.generated = </span><span class="kc">yes</span>
-      <span class="nv">tok = </span><span class="p">[</span><span class="s1">&#39;{&#39;</span><span class="p">,</span> <span class="nx">value</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]]</span>
-      <span class="nv">tok.generated = </span><span class="kc">yes</span>
+      <span class="nv">tok = </span><span class="nx">@generate</span> <span class="s1">&#39;{&#39;</span><span class="p">,</span> <span class="nx">value</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
      <span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">idx</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">tok</span>
      <span class="nx">@detectEnd</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">condition</span><span class="p">,</span> <span class="nx">action</span>
      <span class="mi">2</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>Methods may be optionally called without parentheses, for simple cases.
 Insert the implicit parentheses here, so that the parser doesn't have to
 deal with them.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">addImplicitParentheses: </span><span class="o">-&gt;</span>
-    
+
    <span class="nv">noCall = seenSingle = seenControl = </span><span class="kc">no</span>
-    
+
    <span class="nv">condition = </span><span class="nf">(token, i) -&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>
@@ -134,13 +137,13 @@ deal with them.</p>             </td>             <td class="code">
        <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">not</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;EXTENDS&#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">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>
-    
-    <span class="nv">action = </span><span class="nf">(token, i) -&gt;</span> 
-      <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;CALL_END&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]]</span>
-      
+
+    <span class="nv">action = </span><span class="nf">(token, i) -&gt;</span>
+      <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">@generate</span> <span class="s1">&#39;CALL_END&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
+
    <span class="nx">@scanTokens</span> <span class="nf">(token, i, tokens) -&gt;</span>
      <span class="nv">tag     = </span><span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
-      <span class="nv">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="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="s1">&#39;FOR&#39;</span><span class="p">,</span> <span class="s1">&#39;WHILE&#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>
@@ -153,23 +156,23 @@ deal with them.</p>             </td>             <td class="code">
      <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>
        <span class="p">(</span><span class="nx">tag</span> <span class="k">in</span> <span class="nx">IMPLICIT_CALL</span> <span class="o">or</span> <span class="o">not</span> <span class="p">(</span><span class="nx">token</span><span class="p">.</span><span class="nx">spaced</span> <span class="o">or</span> <span class="nx">token</span><span class="p">.</span><span class="nx">newLine</span><span class="p">)</span> <span class="o">and</span> <span class="nx">tag</span> <span class="k">in</span> <span class="nx">IMPLICIT_UNSPACED_CALL</span><span class="p">)</span>
-      <span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;CALL_START&#39;</span><span class="p">,</span> <span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]]</span>
+      <span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">@generate</span> <span class="s1">&#39;CALL_START&#39;</span><span class="p">,</span> <span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
      <span class="nx">@detectEnd</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">condition</span><span class="p">,</span> <span class="nx">action</span>
      <span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;FUNC_EXIST&#39;</span> <span class="k">if</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="mi">2</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>Because our grammar is LALR(1), it can't handle some single-line
 expressions that lack ending delimiters. The <strong>Rewriter</strong> adds the implicit
 blocks, so it doesn't need to. ')' can close a single-line block,
 but we need to make sure it's balanced.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">addImplicitIndentation: </span><span class="o">-&gt;</span>
-    
+
    <span class="nv">starter = indent = outdent = </span><span class="kc">null</span>
-    
+
    <span class="nv">condition = </span><span class="nf">(token, i) -&gt;</span>
      <span class="nx">token</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">isnt</span> <span class="s1">&#39;;&#39;</span> <span class="o">and</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">in</span> <span class="nx">SINGLE_CLOSERS</span> <span class="o">and</span>
      <span class="o">not</span> <span class="p">(</span><span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;ELSE&#39;</span> <span class="o">and</span> <span class="nx">starter</span> <span class="o">not</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;THEN&#39;</span><span class="p">])</span>
-      
+
    <span class="nv">action = </span><span class="nf">(token, i) -&gt;</span>
      <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="p">(</span><span class="k">if</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;,&#39;</span> <span class="k">then</span> <span class="nx">i</span> <span class="o">-</span> <span class="mi">1</span> <span class="k">else</span> <span class="nx">i</span><span class="p">),</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">outdent</span>
-    
+
    <span class="nx">@scanTokens</span> <span class="nf">(token, i, tokens) -&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">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;TERMINATOR&#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">is</span> <span class="s1">&#39;THEN&#39;</span>
@@ -184,31 +187,36 @@ but we need to make sure it's balanced.</p>             </td>             <td cl
      <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</span> <span class="nx">SINGLE_LINERS</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;INDENT&#39;</span> <span class="o">and</span>
         <span class="o">not</span> <span class="p">(</span><span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;ELSE&#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">is</span> <span class="s1">&#39;IF&#39;</span><span class="p">)</span>
        <span class="nv">starter = </span><span class="nx">tag</span>
-        <span class="p">[</span><span class="nx">indent</span><span class="p">,</span> <span class="nx">outdent</span><span class="p">]</span> <span class="o">=</span> <span class="nx">@indentation</span> <span class="nx">token</span>
+        <span class="p">[</span><span class="nx">indent</span><span class="p">,</span> <span class="nx">outdent</span><span class="p">]</span> <span class="o">=</span> <span class="nx">@indentation</span> <span class="nx">token</span><span class="p">,</span> <span class="kc">yes</span>
        <span class="nv">indent.fromThen   = </span><span class="kc">true</span> <span class="k">if</span> <span class="nx">starter</span> <span class="o">is</span> <span class="s1">&#39;THEN&#39;</span>
-        <span class="nv">indent.generated  = outdent.generated = </span><span class="kc">true</span>
        <span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">indent</span>
        <span class="nx">@detectEnd</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">condition</span><span class="p">,</span> <span class="nx">action</span>
        <span class="nx">tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">1</span> <span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;THEN&#39;</span>
        <span class="k">return</span> <span class="mi">1</span>
      <span class="k">return</span> <span class="mi">1</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>Tag postfix conditionals as such, so that we can parse them with a
 different precedence.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">tagPostfixConditionals: </span><span class="o">-&gt;</span>
-        
+
    <span class="nv">original = </span><span class="kc">null</span>
-    
-    <span class="nv">condition = </span><span class="nf">(token, i) -&gt;</span> 
+
+    <span class="nv">condition = </span><span class="nf">(token, i) -&gt;</span>
      <span class="nx">token</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="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;INDENT&#39;</span><span class="p">]</span>
-      
+
    <span class="nv">action = </span><span class="nf">(token, i) -&gt;</span>
      <span class="k">if</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">isnt</span> <span class="s1">&#39;INDENT&#39;</span> <span class="o">or</span> <span class="p">(</span><span class="nx">token</span><span class="p">.</span><span class="nx">generated</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">token</span><span class="p">.</span><span class="nx">fromThen</span><span class="p">)</span>
-        <span class="nx">original</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;POST_&#39;</span> <span class="o">+</span> <span class="nx">original</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> 
-    
+        <span class="nx">original</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;POST_&#39;</span> <span class="o">+</span> <span class="nx">original</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
+
    <span class="nx">@scanTokens</span> <span class="nf">(token, i) -&gt;</span>
      <span class="k">return</span> <span class="mi">1</span> <span class="nx">unless</span> <span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;IF&#39;</span>
      <span class="nv">original = </span><span class="nx">token</span>
      <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="nx">condition</span><span class="p">,</span> <span class="nx">action</span>
-      <span class="mi">1</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>Generate the indentation tokens, based on another token on the same line.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">indentation: </span><span class="nf">(token) -&gt;</span>
-    <span class="p">[[</span><span class="s1">&#39;INDENT&#39;</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]],</span> <span class="p">[</span><span class="s1">&#39;OUTDENT&#39;</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]]]</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-15">&#182;</a>               </div>               <p>Look up a tag by token index.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">tag: </span><span class="nf">(i) -&gt;</span> <span class="nx">@tokens</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span><span class="o">?</span><span class="p">[</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>               <h2>Constants</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-17">&#182;</a>               </div>               <p>List of the token pairs that must be balanced.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">BALANCED_PAIRS = </span><span class="p">[</span>
+      <span class="mi">1</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>Generate the indentation tokens, based on another token on the same line.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">indentation: </span><span class="nf">(token, implicit = no) -&gt;</span>
+    <span class="nv">indent  = </span><span class="p">[</span><span class="s1">&#39;INDENT&#39;</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]]</span>
+    <span class="nv">outdent = </span><span class="p">[</span><span class="s1">&#39;OUTDENT&#39;</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]]</span>
+    <span class="nv">indent.generated = outdent.generated = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">implicit</span>
+    <span class="p">[</span><span class="nx">indent</span><span class="p">,</span> <span class="nx">outdent</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>Create a generated token: one that exists due to a use of implicit syntax.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">generate: </span><span class="nf">(tag, value, line) -&gt;</span>
+    <span class="nv">tok = </span><span class="p">[</span><span class="nx">tag</span><span class="p">,</span> <span class="nx">value</span><span class="p">,</span> <span class="nx">line</span><span class="p">]</span>
+    <span class="nv">tok.generated = </span><span class="kc">yes</span>
+    <span class="nx">tok</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>Look up a tag by token index.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">tag: </span><span class="nf">(i) -&gt;</span> <span class="nx">@tokens</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span><span class="o">?</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-17">&#182;</a>               </div>               <h2>Constants</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-18">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-18">&#182;</a>               </div>               <p>List of the token pairs that must be balanced.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">BALANCED_PAIRS = </span><span class="p">[</span>
  <span class="p">[</span><span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">]</span>
  <span class="p">[</span><span class="s1">&#39;[&#39;</span><span class="p">,</span> <span class="s1">&#39;]&#39;</span><span class="p">]</span>
  <span class="p">[</span><span class="s1">&#39;{&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">]</span>
@@ -216,20 +224,20 @@ different precedence.</p>             </td>             <td class="code">
  <span class="p">[</span><span class="s1">&#39;CALL_START&#39;</span><span class="p">,</span> <span class="s1">&#39;CALL_END&#39;</span><span class="p">]</span>
  <span class="p">[</span><span class="s1">&#39;PARAM_START&#39;</span><span class="p">,</span> <span class="s1">&#39;PARAM_END&#39;</span><span class="p">]</span>
  <span class="p">[</span><span class="s1">&#39;INDEX_START&#39;</span><span class="p">,</span> <span class="s1">&#39;INDEX_END&#39;</span><span class="p">]</span>
-<span class="p">]</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 inverse mappings of <code>BALANCED_PAIRS</code> we're trying to fix up, so we can
-look things up from either end.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.INVERSES = INVERSES = </span><span class="p">{}</span></pre></div>             </td>           </tr>                               <tr id="section-19">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-19">&#182;</a>               </div>               <p>The tokens that signal the start/end of a balanced pair.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">EXPRESSION_START = </span><span class="p">[]</span>
+<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-19">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-19">&#182;</a>               </div>               <p>The inverse mappings of <code>BALANCED_PAIRS</code> we're trying to fix up, so we can
+look things up from either end.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.INVERSES = INVERSES = </span><span class="p">{}</span></pre></div>             </td>           </tr>                               <tr id="section-20">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-20">&#182;</a>               </div>               <p>The tokens that signal the start/end of a balanced pair.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">EXPRESSION_START = </span><span class="p">[]</span>
 <span class="nv">EXPRESSION_END   = </span><span class="p">[]</span>

 <span class="k">for</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="k">in</span> <span class="nx">BALANCED_PAIRS</span>
  <span class="nx">EXPRESSION_START</span><span class="p">.</span><span class="nx">push</span> <span class="nx">INVERSES</span><span class="p">[</span><span class="nx">rite</span><span class="p">]</span> <span class="o">=</span> <span class="nx">left</span>
-  <span class="nx">EXPRESSION_END</span>  <span class="p">.</span><span class="nx">push</span> <span class="nx">INVERSES</span><span class="p">[</span><span class="nx">left</span><span class="p">]</span> <span class="o">=</span> <span class="nx">rite</span></pre></div>             </td>           </tr>                               <tr id="section-20">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-20">&#182;</a>               </div>               <p>Tokens that indicate the close of a clause of an expression.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">EXPRESSION_CLOSE = </span><span class="p">[</span><span class="s1">&#39;CATCH&#39;</span><span class="p">,</span> <span class="s1">&#39;WHEN&#39;</span><span class="p">,</span> <span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s1">&#39;FINALLY&#39;</span><span class="p">].</span><span class="nx">concat</span> <span class="nx">EXPRESSION_END</span></pre></div>             </td>           </tr>                               <tr id="section-21">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-21">&#182;</a>               </div>               <p>Tokens that, if followed by an <code>IMPLICIT_CALL</code>, indicate a function invocation.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_FUNC    = </span><span class="p">[</span><span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;SUPER&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="s1">&#39;CALL_END&#39;</span><span class="p">,</span> <span class="s1">&#39;]&#39;</span><span class="p">,</span> <span class="s1">&#39;INDEX_END&#39;</span><span class="p">,</span> <span class="s1">&#39;@&#39;</span><span class="p">,</span> <span class="s1">&#39;THIS&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-22">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-22">&#182;</a>               </div>               <p>If preceded by an <code>IMPLICIT_FUNC</code>, indicates a function invocation.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_CALL    = </span><span class="p">[</span>
+  <span class="nx">EXPRESSION_END</span>  <span class="p">.</span><span class="nx">push</span> <span class="nx">INVERSES</span><span class="p">[</span><span class="nx">left</span><span class="p">]</span> <span class="o">=</span> <span class="nx">rite</span></pre></div>             </td>           </tr>                               <tr id="section-21">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-21">&#182;</a>               </div>               <p>Tokens that indicate the close of a clause of an expression.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">EXPRESSION_CLOSE = </span><span class="p">[</span><span class="s1">&#39;CATCH&#39;</span><span class="p">,</span> <span class="s1">&#39;WHEN&#39;</span><span class="p">,</span> <span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s1">&#39;FINALLY&#39;</span><span class="p">].</span><span class="nx">concat</span> <span class="nx">EXPRESSION_END</span></pre></div>             </td>           </tr>                               <tr id="section-22">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-22">&#182;</a>               </div>               <p>Tokens that, if followed by an <code>IMPLICIT_CALL</code>, indicate a function invocation.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_FUNC    = </span><span class="p">[</span><span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;SUPER&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="s1">&#39;CALL_END&#39;</span><span class="p">,</span> <span class="s1">&#39;]&#39;</span><span class="p">,</span> <span class="s1">&#39;INDEX_END&#39;</span><span class="p">,</span> <span class="s1">&#39;@&#39;</span><span class="p">,</span> <span class="s1">&#39;THIS&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-23">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-23">&#182;</a>               </div>               <p>If preceded by an <code>IMPLICIT_FUNC</code>, indicates a function invocation.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_CALL    = </span><span class="p">[</span>
  <span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;NUMBER&#39;</span><span class="p">,</span> <span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s1">&#39;JS&#39;</span><span class="p">,</span> <span class="s1">&#39;REGEX&#39;</span><span class="p">,</span> <span class="s1">&#39;NEW&#39;</span><span class="p">,</span> <span class="s1">&#39;PARAM_START&#39;</span><span class="p">,</span> <span class="s1">&#39;CLASS&#39;</span>
-  <span class="s1">&#39;IF&#39;</span><span class="p">,</span> <span class="s1">&#39;TRY&#39;</span><span class="p">,</span> <span class="s1">&#39;SWITCH&#39;</span><span class="p">,</span> <span class="s1">&#39;THIS&#39;</span><span class="p">,</span> <span class="s1">&#39;BOOL&#39;</span><span class="p">,</span> <span class="s1">&#39;UNARY&#39;</span><span class="p">,</span> <span class="s1">&#39;SUPER&#39;</span>
+  <span class="s1">&#39;IF&#39;</span><span class="p">,</span> <span class="s1">&#39;TRY&#39;</span><span class="p">,</span> <span class="s1">&#39;SWITCH&#39;</span><span class="p">,</span> <span class="s1">&#39;THIS&#39;</span><span class="p">,</span> <span class="s1">&#39;BOOL&#39;</span><span class="p">,</span> <span class="s1">&#39;NULL&#39;</span><span class="p">,</span> <span class="s1">&#39;UNDEFINED&#39;</span><span class="p">,</span> <span class="s1">&#39;UNARY&#39;</span><span class="p">,</span> <span class="s1">&#39;SUPER&#39;</span>
  <span class="s1">&#39;@&#39;</span><span class="p">,</span> <span class="s1">&#39;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;[&#39;</span><span class="p">,</span> <span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="s1">&#39;{&#39;</span><span class="p">,</span> <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-23">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-23">&#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-24">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-24">&#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-25">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-25">&#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-24">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-24">&#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-25">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-25">&#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-26">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-26">&#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-26">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-26">&#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>
+<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-27">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-27">&#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>

 </pre></div>             </td>           </tr>                </tbody>     </table>   </div> </body> </html> 
--- a/documentation/docs/scope.html
+++ b/documentation/docs/scope.html
@@ -16,38 +16,42 @@ it wraps.</p>             </td>             <td class="code">               <div
    <span class="k">if</span> <span class="nb">Object</span><span class="o">::</span><span class="nx">hasOwnProperty</span><span class="p">.</span><span class="nx">call</span> <span class="nx">@positions</span><span class="p">,</span> <span class="nx">name</span>
      <span class="nx">@variables</span><span class="p">[</span><span class="nx">@positions</span><span class="p">[</span><span class="nx">name</span><span class="p">]].</span><span class="nv">type = </span><span class="nx">type</span>
    <span class="k">else</span>
-      <span class="nx">@positions</span><span class="p">[</span><span class="nx">name</span><span class="p">]</span> <span class="o">=</span> <span class="nx">@variables</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="nx">type</span><span class="p">})</span> <span class="o">-</span> <span class="mi">1</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>Look up a variable name in lexical scope, and declare it if it does not
-already exist.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">find: </span><span class="nf">(name, options) -&gt;</span>
-    <span class="k">return</span> <span class="kc">yes</span> <span class="k">if</span> <span class="nx">@check</span> <span class="nx">name</span><span class="p">,</span> <span class="nx">options</span>
+      <span class="nx">@positions</span><span class="p">[</span><span class="nx">name</span><span class="p">]</span> <span class="o">=</span> <span class="nx">@variables</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="nx">type</span><span class="p">})</span> <span class="o">-</span> <span class="mi">1</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>When <code>super</code> is called, we need to find the name of the current method we're 
+in, so that we know how to invoke the same method of the parent class. This 
+can get complicated if super is being called from an inner function. 
+<code>namedMethod</code> will walk up the scope tree until it either finds the first 
+function object that has a name filled in, or bottoms out.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">namedMethod: </span><span class="o">-&gt;</span>
+    <span class="k">return</span> <span class="nx">@method</span> <span class="k">if</span> <span class="nx">@method</span><span class="p">.</span><span class="nx">name</span> <span class="o">or</span> <span class="o">!</span><span class="nx">@parent</span>
+    <span class="nx">@parent</span><span class="p">.</span><span class="nx">namedMethod</span><span class="p">()</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>Look up a variable name in lexical scope, and declare it if it does not
+already exist.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">find: </span><span class="nf">(name) -&gt;</span>
+    <span class="k">return</span> <span class="kc">yes</span> <span class="k">if</span> <span class="nx">@check</span> <span class="nx">name</span>
    <span class="nx">@add</span> <span class="nx">name</span><span class="p">,</span> <span class="s1">&#39;var&#39;</span>
-    <span class="kc">no</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>Reserve a variable name as originating from a function parameter for this
+    <span class="kc">no</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>Reserve a variable name as originating from a function parameter for this
 scope. No <code>var</code> required for internal references.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">parameter: </span><span class="nf">(name) -&gt;</span>
    <span class="k">return</span> <span class="k">if</span> <span class="nx">@shared</span> <span class="o">and</span> <span class="nx">@parent</span><span class="p">.</span><span class="nx">check</span> <span class="nx">name</span><span class="p">,</span> <span class="kc">yes</span>
-    <span class="nx">@add</span> <span class="nx">name</span><span class="p">,</span> <span class="s1">&#39;param&#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>Just check to see if a variable has already been declared, without reserving,
-walks up to the root scope.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">check: </span><span class="nf">(name, immediate) -&gt;</span>
-    <span class="nv">found = </span><span class="o">!!</span><span class="nx">@type</span><span class="p">(</span><span class="nx">name</span><span class="p">)</span>
-    <span class="k">return</span> <span class="nx">found</span> <span class="k">if</span> <span class="nx">found</span> <span class="o">or</span> <span class="nx">immediate</span>
-    <span class="o">!!</span><span class="nx">@parent</span><span class="o">?</span><span class="p">.</span><span class="nx">check</span> <span class="nx">name</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>Generate a temporary variable name at the given index.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">temporary: </span><span class="nf">(name, index) -&gt;</span>
+    <span class="nx">@add</span> <span class="nx">name</span><span class="p">,</span> <span class="s1">&#39;param&#39;</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>Just check to see if a variable has already been declared, without reserving,
+walks up to the root scope.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">check: </span><span class="nf">(name) -&gt;</span>
+    <span class="o">!!</span><span class="p">(</span><span class="nx">@type</span><span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="o">or</span> <span class="nx">@parent</span><span class="o">?</span><span class="p">.</span><span class="nx">check</span><span class="p">(</span><span class="nx">name</span><span class="p">))</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#182;</a>               </div>               <p>Generate a temporary variable name at the given index.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">temporary: </span><span class="nf">(name, index) -&gt;</span>
    <span class="k">if</span> <span class="nx">name</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="mi">1</span>
-      <span class="s1">&#39;_&#39;</span> <span class="o">+</span> <span class="nx">name</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">index</span> <span class="o">&gt;</span> <span class="mi">1</span> <span class="k">then</span> <span class="nx">index</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span>
+      <span class="s1">&#39;_&#39;</span> <span class="o">+</span> <span class="nx">name</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">index</span> <span class="o">&gt;</span> <span class="mi">1</span> <span class="k">then</span> <span class="nx">index</span> <span class="o">-</span> <span class="mi">1</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span>
    <span class="k">else</span>
-      <span class="s1">&#39;_&#39;</span> <span class="o">+</span> <span class="p">(</span><span class="nx">index</span> <span class="o">+</span> <span class="nb">parseInt</span> <span class="nx">name</span><span class="p">,</span> <span class="mi">36</span><span class="p">).</span><span class="nx">toString</span><span class="p">(</span><span class="mi">36</span><span class="p">).</span><span class="nx">replace</span> <span class="sr">/\d/g</span><span class="p">,</span> <span class="s1">&#39;a&#39;</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>Gets the type of a variable.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">type: </span><span class="nf">(name) -&gt;</span>
+      <span class="s1">&#39;_&#39;</span> <span class="o">+</span> <span class="p">(</span><span class="nx">index</span> <span class="o">+</span> <span class="nb">parseInt</span> <span class="nx">name</span><span class="p">,</span> <span class="mi">36</span><span class="p">).</span><span class="nx">toString</span><span class="p">(</span><span class="mi">36</span><span class="p">).</span><span class="nx">replace</span> <span class="sr">/\d/g</span><span class="p">,</span> <span class="s1">&#39;a&#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>Gets the type of a variable.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">type: </span><span class="nf">(name) -&gt;</span>
    <span class="k">return</span> <span class="nx">v</span><span class="p">.</span><span class="nx">type</span> <span class="k">for</span> <span class="nx">v</span> <span class="k">in</span> <span class="nx">@variables</span> <span class="k">when</span> <span class="nx">v</span><span class="p">.</span><span class="nx">name</span> <span class="o">is</span> <span class="nx">name</span>
-    <span class="kc">null</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>If we need to store an intermediate result, find an available name for a
+    <span class="kc">null</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>If we need to store an intermediate result, find an available name for a
 compiler-generated variable. <code>_var</code>, <code>_var2</code>, and so on...</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">freeVariable: </span><span class="nf">(name, reserve=true) -&gt;</span>
    <span class="nv">index = </span><span class="mi">0</span>
    <span class="nx">index</span><span class="o">++</span> <span class="k">while</span> <span class="nx">@check</span><span class="p">((</span><span class="nv">temp = </span><span class="nx">@temporary</span> <span class="nx">name</span><span class="p">,</span> <span class="nx">index</span><span class="p">))</span>
    <span class="nx">@add</span> <span class="nx">temp</span><span class="p">,</span> <span class="s1">&#39;var&#39;</span><span class="p">,</span> <span class="kc">yes</span> <span class="k">if</span> <span class="nx">reserve</span>
-    <span class="nx">temp</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>Ensure that an assignment is made at the top of this scope
+    <span class="nx">temp</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>Ensure that an assignment is made at the top of this scope
 (or at the top-level scope, if requested).</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">assign: </span><span class="nf">(name, value) -&gt;</span>
    <span class="nx">@add</span> <span class="nx">name</span><span class="p">,</span> <span class="p">{</span><span class="nx">value</span><span class="p">,</span> <span class="nv">assigned: </span><span class="kc">yes</span><span class="p">},</span> <span class="kc">yes</span>
-    <span class="vi">@hasAssignments = </span><span class="kc">yes</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>Does this scope have any declared variables?</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">hasDeclarations: </span><span class="o">-&gt;</span>
-    <span class="o">!!</span><span class="nx">@declaredVariables</span><span class="p">().</span><span class="nx">length</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 the list of variables first declared in this scope.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">declaredVariables: </span><span class="o">-&gt;</span>
+    <span class="vi">@hasAssignments = </span><span class="kc">yes</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>Does this scope have any declared variables?</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">hasDeclarations: </span><span class="o">-&gt;</span>
+    <span class="o">!!</span><span class="nx">@declaredVariables</span><span class="p">().</span><span class="nx">length</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 the list of variables first declared in this scope.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">declaredVariables: </span><span class="o">-&gt;</span>
    <span class="nv">realVars = </span><span class="p">[]</span>
    <span class="nv">tempVars = </span><span class="p">[]</span>
    <span class="k">for</span> <span class="nx">v</span> <span class="k">in</span> <span class="nx">@variables</span> <span class="k">when</span> <span class="nx">v</span><span class="p">.</span><span class="nx">type</span> <span class="o">is</span> <span class="s1">&#39;var&#39;</span>
      <span class="p">(</span><span class="k">if</span> <span class="nx">v</span><span class="p">.</span><span class="nx">name</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">is</span> <span class="s1">&#39;_&#39;</span> <span class="k">then</span> <span class="nx">tempVars</span> <span class="k">else</span> <span class="nx">realVars</span><span class="p">).</span><span class="nx">push</span> <span class="nx">v</span><span class="p">.</span><span class="nx">name</span>
-    <span class="nx">realVars</span><span class="p">.</span><span class="nx">sort</span><span class="p">().</span><span class="nx">concat</span> <span class="nx">tempVars</span><span class="p">.</span><span class="nx">sort</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 the list of assignments that are supposed to be made at the top
+    <span class="nx">realVars</span><span class="p">.</span><span class="nx">sort</span><span class="p">().</span><span class="nx">concat</span> <span class="nx">tempVars</span><span class="p">.</span><span class="nx">sort</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>Return the list of assignments that are supposed to be made at the top
 of this scope.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">assignedVariables: </span><span class="o">-&gt;</span>
    <span class="s2">&quot;#{v.name} = #{v.type.value}&quot;</span> <span class="k">for</span> <span class="nx">v</span> <span class="k">in</span> <span class="nx">@variables</span> <span class="k">when</span> <span class="nx">v</span><span class="p">.</span><span class="nx">type</span><span class="p">.</span><span class="nx">assigned</span>

--- a/documentation/index.html.erb
+++ b/documentation/index.html.erb
@@ -7,6 +7,7 @@
    return '' unless File.exists?("documentation/js/#{file}.js")
    cs = File.read("documentation/coffee/#{file}.coffee")
    js = File.read("documentation/js/#{file}.js")
+    js = js.sub(/^\/\/ generated.*?\n/i, '')
    cshtml = Uv.parse(cs, 'xhtml', 'coffeescript', false, 'idle', false)
    jshtml = Uv.parse(js, 'xhtml', 'javascript', false, 'idle', false)
    append = executable  == true ? '' : "alert(#{executable});"
@@ -28,6 +29,7 @@
 <head>
  <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
  <title>CoffeeScript</title>
+  <link rel="canonical" href="http://coffeescript.org" />
  <link rel="stylesheet" type="text/css" href="documentation/css/docs.css" />
  <link rel="stylesheet" type="text/css" href="documentation/css/idle.css" />
  <link rel="shortcut icon" href="documentation/images/favicon.ico" />
@@ -61,8 +63,8 @@
        <a href="#embedded">Embedded JavaScript</a>
        <a href="#switch">Switch and Try/Catch</a>
        <a href="#comparisons">Chained Comparisons</a>
-        <a href="#strings">String Interpolation, Heredocs, and Block Comments</a>
-        <a href="#regexes">Extended Regular Expressions</a>
+        <a href="#strings">String Interpolation, Block Strings, and Block Comments</a>
+        <a href="#regexes">Block Regular Expressions</a>
        <a href="#cake">Cake, and Cakefiles</a>
        <a href="#scripts">"text/coffeescript" Script Tags</a>
        <a href="#resources">Books, Screencasts, Examples and Resources</a>
@@ -128,13 +130,13 @@
      seamlessly from CoffeeScript (and vice-versa). The compiled output is 
      readable and pretty-printed, passes through 
      <a href="http://www.javascriptlint.com/">JavaScript Lint</a>
-      without warnings, will work in every JavaScript implementation, and tends
+      without warnings, will work in every JavaScript runtime, and tends
      to run as fast or faster than the equivalent handwritten JavaScript.
    </p>

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

    <h2>
@@ -188,15 +190,6 @@ npm install -g coffee-script</pre>
  <pre>
 sudo bin/cake install</pre>

-    <p>
-      If installing on Ubuntu or Debian,
-      <a href="http://opinionatedprogrammer.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. 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>
-
    <h2>
      <span id="usage" class="bookmark"></span>
      Usage
@@ -351,7 +344,7 @@ Expressions
        <tt>coffee -o lib/ -cw src/</tt>
      </li>
      <li>
-        Start the CoffeeScript REPL:<br />
+        Start the CoffeeScript REPL (<tt>Ctrl-D</tt> to exit, <tt>Ctrl-V</tt>for multi-line):<br />
        <tt>coffee</tt>
      </li>
    </ul>
@@ -383,7 +376,7 @@ Expressions
      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>,
+      <tt>{ }</tt> to surround blocks of code in <a href="#literals">functions</a>,
      <a href="#conditionals">if-statements</a>,
      <a href="#switch">switch</a>, and <a href="#try">try/catch</a>,
      use indentation.
@@ -532,7 +525,7 @@ Expressions
    <p>
      If you would like to iterate over just the keys that are defined on the
      object itself, by adding a <tt>hasOwnProperty</tt>
-      check to avoid properties that may be interited from the prototype, use<br />
+      check to avoid properties that may be inherited from the prototype, use<br />
      <tt>for own key, value of object</tt>
    </p>
    <p>
@@ -561,6 +554,8 @@ Expressions
      Ranges can also be used to extract slices of arrays.
      With two dots (<tt>3..6</tt>), the range is inclusive (<tt>3, 4, 5, 6</tt>);
      with three dots (<tt>3...6</tt>), the range excludes the end (<tt>3, 4, 5</tt>).
+      Slices indices have useful defaults. An omitted first index defaults to
+      zero and an omitted second index defaults to the size of the array.
    </p>
    <%= code_for('slices', 'middle') %>
    <p>
@@ -720,6 +715,7 @@ Expressions
    </p>
    <p>
      Constructor functions are named, to better support helpful stack traces.
+      In the first class in the example below, <tt>this.constructor.name is "Animal"</tt>.
    </p>
    <%= code_for('classes', true) %>
    <p>
@@ -842,7 +838,7 @@ Expressions

    <p>
      <span id="strings" class="bookmark"></span>
-      <b class="header">String Interpolation, Heredocs, and Block Comments</b>
+      <b class="header">String Interpolation, Block Strings, and Block Comments</b>
      Ruby-style string interpolation is included in CoffeeScript. Double-quoted
      strings allow for interpolated values, using <tt>#{ ... }</tt>,
      and single-quoted strings are literal.
@@ -853,31 +849,31 @@ Expressions
    </p>
    <%= code_for('strings', 'mobyDick') %>
    <p>
-      Heredocs can be used to hold formatted or indentation-sensitive text
+      Block strings can be used to hold formatted or indentation-sensitive text
      (or, if you just don't feel like escaping quotes and apostrophes). The
-      indentation level that begins the heredoc is maintained throughout, so
+      indentation level that begins the block is maintained throughout, so
      you can keep it all aligned with the body of your code.
    </p>
    <%= code_for('heredocs', 'html') %>
    <p>
-      Double-quoted heredocs, like double-quoted strings, allow interpolation.
+      Double-quoted block strings, like other double-quoted strings, allow interpolation.
    </p>
    <p>
      Sometimes you'd like to pass a block comment through to the generated
      JavaScript. For example, when you need to embed a licensing header at
-      the top of a file. Block comments, which mirror the syntax for heredocs,
+      the top of a file. Block comments, which mirror the syntax for block strings,
      are preserved in the generated code.
    </p>
    <%= code_for('block_comment') %>

    <p>
      <span id="regexes" class="bookmark"></span>
-      <b class="header">Extended Regular Expressions</b>
-      Similar to "heredocs" and "herecomments", CoffeeScript supports "heregexes" &mdash;
+      <b class="header">Block Regular Expressions</b>
+      Similar to block strings and comments, CoffeeScript supports block regexes &mdash;
      extended regular expressions that ignore internal whitespace and can contain
-      comments, after Perl's <tt>/x</tt> modifier, but delimited by <tt>///</tt>.
-      They go a long way towards making complex regular expressions readable.
-      To quote from the CoffeeScript source:
+      comments and interpolation. Modeled after Perl's <tt>/x</tt> modifier, CoffeeSctipt's
+      block regexes are delimited by <tt>///</tt> and go a long way towards making complex
+      regular expressions readable. To quote from the CoffeeScript source:
    </p>
    <%= code_for('heregexes') %>

@@ -946,11 +942,11 @@ Expressions

    <h2>
      <span id="resources" class="bookmark"></span>
-      Books and Screencasts
+      Books
    </h2>

    <p>
-      There are a number of excellent books and screencasts to help you get
+      There are a number of excellent resources to help you get
      started with CoffeeScript, some of which are freely available online.
    </p>

@@ -976,6 +972,17 @@ Expressions
        a fast-paced multiplayer word game, writing both the client-side and Node.js
        portions in CoffeeScript.
      </li>
+    </ul>
+    
+    <h2>
+      Screencasts
+    </h2>
+    
+    <ul>
+      <li>
+        <a href="http://coffeescript.codeschool.com">A Sip of CoffeeScript</a> is a <a href="http://www.codeschool.com">Code School Course</a>
+        which combines 6 screencasts with in-browser coding to make learning fun.  The first level is free to try out.
+      </li>
      <li>
        <a href="http://peepcode.com/products/coffeescript">Meet CoffeeScript</a>
        is a 75-minute long screencast by <a href="http://peepcode.com/">PeepCode</a>.
@@ -1075,6 +1082,11 @@ Expressions
        <a href="http://github.com/jashkenas/coffee-script/wiki/FAQ">The FAQ</a><br />
        Perhaps your CoffeeScript-related question has been asked before. Check the FAQ first.
      </li>
+      <li>
+        <a href="https://github.com/jashkenas/coffee-script/downloads">High-Rez Logo</a><br />
+        The CoffeeScript logo is available in Illustrator, EPS and PSD formats, for use
+        in presentations.
+      </li>
    </ul>

    <h2>
@@ -1097,6 +1109,85 @@ Expressions
      Change Log
    </h2>
    
+    <p>
+      <b class="header" style="margin-top: 20px;">
+        <a href="https://github.com/jashkenas/coffee-script/compare/1.3.1...1.3.3">1.3.3</a>
+        <span class="timestamp"> &ndash; <small>May 15, 2012</small></span>
+      </b>
+      <ul>
+        <li>
+          Due to the new semantics of JavaScript's strict mode, CoffeeScript no
+          longer guarantees that constructor functions have names in all runtimes.
+          See <a href="https://github.com/jashkenas/coffee-script/issues/2052">#2052</a> 
+          for discussion.
+        </li>
+        <li>
+          Inside of a nested function inside of an instance method, it's now possible
+          to call <tt>super</tt> more reliably (walks recursively up).
+        </li>
+        <li>
+          Named loop variables no longer have different scoping heuristics than
+          other local variables. (Reverts #643)
+        </li>
+        <li>
+          Fix for splats nested within the LHS of destructuring assignment.
+        </li>
+        <li>
+          Corrections to our compile time strict mode forbidding of octal literals.
+        </li>
+      </ul>
+    </p>
+    
+    <p>
+      <b class="header" style="margin-top: 20px;">
+        <a href="https://github.com/jashkenas/coffee-script/compare/1.2.0...1.3.1">1.3.1</a>
+        <span class="timestamp"> &ndash; <small>April 10, 2012</small></span>
+      </b>
+      <ul>
+        <li>
+          CoffeeScript now enforces all of JavaScript's <b>Strict Mode</b> early syntax 
+          errors at compile time. This includes old-style octal literals, 
+          duplicate property names in object literals, duplicate parameters in 
+          a function definition, deleting naked variables, setting the value of
+          <tt>eval</tt> or <tt>arguments</tt>, and more.
+          See a full discussion at 
+          <a href="https://github.com/jashkenas/coffee-script/issues/1547">#1547</a>.
+        </li>
+        <li>
+          The REPL now has a handy new multi-line mode for entering large
+          blocks of code. It's useful when copy-and-pasting examples into the
+          REPL. Enter multi-line mode with <tt>Ctrl-V</tt>. You may also now 
+          pipe input directly into the REPL.
+        </li>
+        <li>
+          CoffeeScript now prints a <tt>Generated by CoffeeScript VERSION</tt> 
+          header at the top of each compiled file.
+        </li>
+        <li>
+          Conditional assignment of previously undefined variables 
+          <tt>a or= b</tt> is now considered a syntax error.
+        </li>
+        <li>
+          A tweak to the semantics of <tt>do</tt>, which can now be used to
+          more easily simulate a namespace: <tt>do (x = 1, y = 2) -> ...</tt>
+        </li>
+        <li>
+          Loop indices are now mutable within a loop iteration, and immutable
+          between them.
+        </li>
+        <li>
+          Both endpoints of a slice are now allowed to be omitted for consistency, 
+          effectively creating a shallow copy of the list.
+        </li>
+        <li>
+          Additional tweaks and improvments to <tt>coffee --watch</tt> under 
+          Node's "new" file watching API. Watch will now beep by default 
+          if you introduce a syntax error into a watched script. We also now
+          ignore hidden directories by default when watching recursively.
+        </li>
+      </ul>
+    </p>
+    
    <p>
      <b class="header" style="margin-top: 20px;">
        <a href="https://github.com/jashkenas/coffee-script/compare/1.1.3...1.2.0">1.2.0</a>
@@ -1713,7 +1804,7 @@ Expressions
    closeMenus = ->
      $('.navigation.active').removeClass 'active'

-    $('.minibutton.run').click evalJS
+    $('.minibutton.run').click -> evalJS()

    # Bind navigation buttons to open the menus.
    $('.navigation').click (e) ->
--- a/documentation/js/aliases.js
+++ b/documentation/js/aliases.js
@@ -1,13 +1,24 @@
+// Generated by CoffeeScript 1.3.3
 var volume, winner;

-if (ignition === true) launch();
+if (ignition === true) {
+  launch();
+}

-if (band !== SpinalTap) volume = 10;
+if (band !== SpinalTap) {
+  volume = 10;
+}

-if (answer !== false) letTheWildRumpusBegin();
+if (answer !== false) {
+  letTheWildRumpusBegin();
+}

-if (car.speed < limit) accelerate();
+if (car.speed < limit) {
+  accelerate();
+}

-if (pick === 47 || pick === 92 || pick === 13) winner = true;
+if (pick === 47 || pick === 92 || pick === 13) {
+  winner = true;
+}

 print(inspect("My name is " + this.name));
--- a/documentation/js/array_comprehensions.js
+++ b/documentation/js/array_comprehensions.js
@@ -1,4 +1,5 @@
-var courses, dish, food, foods, i, _i, _j, _len, _len2, _len3, _ref;
+// Generated by CoffeeScript 1.3.3
+var courses, dish, food, foods, i, _i, _j, _k, _len, _len1, _len2, _ref;

 _ref = ['toast', 'cheese', 'wine'];
 for (_i = 0, _len = _ref.length; _i < _len; _i++) {
@@ -8,14 +9,16 @@ for (_i = 0, _len = _ref.length; _i < _len; _i++) {

 courses = ['greens', 'caviar', 'truffles', 'roast', 'cake'];

-for (i = 0, _len2 = courses.length; i < _len2; i++) {
+for (i = _j = 0, _len1 = courses.length; _j < _len1; i = ++_j) {
  dish = courses[i];
  menu(i + 1, dish);
 }

 foods = ['broccoli', 'spinach', 'chocolate'];

-for (_j = 0, _len3 = foods.length; _j < _len3; _j++) {
-  food = foods[_j];
-  if (food !== 'chocolate') eat(food);
+for (_k = 0, _len2 = foods.length; _k < _len2; _k++) {
+  food = foods[_k];
+  if (food !== 'chocolate') {
+    eat(food);
+  }
 }
--- a/documentation/js/block_comment.js
+++ b/documentation/js/block_comment.js
@@ -1,5 +1,7 @@
+// Generated by CoffeeScript 1.3.3
 /*
-CoffeeScript Compiler v1.2.0
+CoffeeScript Compiler v1.3.3
 Released under the MIT License
 */

+
--- a/documentation/js/cake_tasks.js
+++ b/documentation/js/cake_tasks.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var fs;

 fs = require('fs');
--- a/documentation/js/classes.js
+++ b/documentation/js/classes.js
@@ -1,6 +1,7 @@
+// Generated by CoffeeScript 1.3.3
 var Animal, Horse, Snake, sam, tom,
-  __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; } ctor.prototype = parent.prototype; child.prototype = new ctor; child.__super__ = parent.prototype; return child; };
+  __hasProp = {}.hasOwnProperty,
+  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

 Animal = (function() {

@@ -21,7 +22,7 @@ Snake = (function(_super) {
  __extends(Snake, _super);

  function Snake() {
-    Snake.__super__.constructor.apply(this, arguments);
+    return Snake.__super__.constructor.apply(this, arguments);
  }

  Snake.prototype.move = function() {
@@ -38,7 +39,7 @@ Horse = (function(_super) {
  __extends(Horse, _super);

  function Horse() {
-    Horse.__super__.constructor.apply(this, arguments);
+    return Horse.__super__.constructor.apply(this, arguments);
  }

  Horse.prototype.move = function() {
--- a/documentation/js/comparisons.js
+++ b/documentation/js/comparisons.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var cholesterol, healthy;

 cholesterol = 127;
--- a/documentation/js/conditionals.js
+++ b/documentation/js/conditionals.js
@@ -1,6 +1,9 @@
+// Generated by CoffeeScript 1.3.3
 var date, mood;

-if (singing) mood = greatlyImproved;
+if (singing) {
+  mood = greatlyImproved;
+}

 if (happy && knowsIt) {
  clapsHands();
@@ -10,5 +13,3 @@ if (happy && knowsIt) {
 }

 date = friday ? sue : jill;
-
-options || (options = defaults);
--- a/documentation/js/default_args.js
+++ b/documentation/js/default_args.js
@@ -1,6 +1,9 @@
+// Generated by CoffeeScript 1.3.3
 var fill;

 fill = function(container, liquid) {
-  if (liquid == null) liquid = "coffee";
+  if (liquid == null) {
+    liquid = "coffee";
+  }
  return "Filling the " + container + " with " + liquid + "...";
 };
--- a/documentation/js/do.js
+++ b/documentation/js/do.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var filename, _fn, _i, _len;

 _fn = function(filename) {
--- a/documentation/js/embedded.js
+++ b/documentation/js/embedded.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var hi;

 hi = function() {
--- a/documentation/js/existence.js
+++ b/documentation/js/existence.js
@@ -1,9 +1,14 @@
-var footprints, solipsism;
+// Generated by CoffeeScript 1.3.3
+var footprints, solipsism, speed;

 if ((typeof mind !== "undefined" && mind !== null) && !(typeof world !== "undefined" && world !== null)) {
  solipsism = true;
 }

-if (typeof speed === "undefined" || speed === null) speed = 75;
+speed = 0;
+
+if (speed == null) {
+  speed = 15;
+}

 footprints = typeof yeti !== "undefined" && yeti !== null ? yeti : "bear";
--- a/documentation/js/expressions.js
+++ b/documentation/js/expressions.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var eldest, grade;

 grade = function(student) {
--- a/documentation/js/expressions_assignment.js
+++ b/documentation/js/expressions_assignment.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var one, six, three, two;

 six = (one = 1) + (two = 2) + (three = 3);
--- a/documentation/js/expressions_comprehension.js
+++ b/documentation/js/expressions_comprehension.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var globals, name;

 globals = ((function() {
--- a/documentation/js/expressions_try.js
+++ b/documentation/js/expressions_try.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3

 alert((function() {
  try {
--- a/documentation/js/fat_arrow.js
+++ b/documentation/js/fat_arrow.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var Account;

 Account = function(customer, cart) {
--- a/documentation/js/functions.js
+++ b/documentation/js/functions.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var cube, square;

 square = function(x) {
--- a/documentation/js/heredocs.js
+++ b/documentation/js/heredocs.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var html;

 html = "<strong>\n  cup of coffeescript\n</strong>";
--- a/documentation/js/heregexes.js
+++ b/documentation/js/heregexes.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var OPERATOR;

 OPERATOR = /^(?:[-=]>|[-+*\/%<>&|^!?=]=|>>>=?|([-+:])\1|([&|<>])\2=?|\?\.|\.{2,3})/;
--- a/documentation/js/interpolation.js
+++ b/documentation/js/interpolation.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var author, quote, sentence;

 author = "Wittgenstein";
--- a/documentation/js/multiple_return_values.js
+++ b/documentation/js/multiple_return_values.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var city, forecast, temp, weatherReport, _ref;

 weatherReport = function(location) {
--- a/documentation/js/object_comprehensions.js
+++ b/documentation/js/object_comprehensions.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var age, ages, child, yearsOld;

 yearsOld = {
--- a/documentation/js/object_extraction.js
+++ b/documentation/js/object_extraction.js
@@ -1,4 +1,5 @@
-var city, futurists, name, street, _ref, _ref2;
+// Generated by CoffeeScript 1.3.3
+var city, futurists, name, street, _ref, _ref1;

 futurists = {
  sculptor: "Umberto Boccioni",
@@ -9,4 +10,4 @@ futurists = {
  }
 };

-_ref = futurists.poet, name = _ref.name, (_ref2 = _ref.address, street = _ref2[0], city = _ref2[1]);
+_ref = futurists.poet, name = _ref.name, (_ref1 = _ref.address, street = _ref1[0], city = _ref1[1]);
--- a/documentation/js/objects_and_arrays.js
+++ b/documentation/js/objects_and_arrays.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var bitlist, kids, singers, song;

 song = ["do", "re", "mi", "fa", "so"];
--- a/documentation/js/objects_reserved.js
+++ b/documentation/js/objects_reserved.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3

 $('.account').attr({
  "class": 'active'
--- a/documentation/js/overview.js
+++ b/documentation/js/overview.js
@@ -1,11 +1,14 @@
+// Generated by CoffeeScript 1.3.3
 var cubes, list, math, num, number, opposite, race, square,
-  __slice = Array.prototype.slice;
+  __slice = [].slice;

 number = 42;

 opposite = true;

-if (opposite) number = -42;
+if (opposite) {
+  number = -42;
+}

 square = function(x) {
  return x * x;
@@ -27,7 +30,9 @@ race = function() {
  return print(winner, runners);
 };

-if (typeof elvis !== "undefined" && elvis !== null) alert("I knew it!");
+if (typeof elvis !== "undefined" && elvis !== null) {
+  alert("I knew it!");
+}

 cubes = (function() {
  var _i, _len, _results;
--- a/documentation/js/parallel_assignment.js
+++ b/documentation/js/parallel_assignment.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var theBait, theSwitch, _ref;

 theBait = 1000;
--- a/documentation/js/patterns_and_splats.js
+++ b/documentation/js/patterns_and_splats.js
@@ -1,5 +1,6 @@
+// Generated by CoffeeScript 1.3.3
 var close, contents, open, tag, _i, _ref,
-  __slice = Array.prototype.slice;
+  __slice = [].slice;

 tag = "<impossible>";

--- a/documentation/js/prototypes.js
+++ b/documentation/js/prototypes.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3

 String.prototype.dasherize = function() {
  return this.replace(/_/g, "-");
--- a/documentation/js/range_comprehensions.js
+++ b/documentation/js/range_comprehensions.js
@@ -1,9 +1,10 @@
+// Generated by CoffeeScript 1.3.3
 var countdown, num;

 countdown = (function() {
-  var _results;
+  var _i, _results;
  _results = [];
-  for (num = 10; num >= 1; num--) {
+  for (num = _i = 10; _i >= 1; num = --_i) {
    _results.push(num);
  }
  return _results;
--- a/documentation/js/scope.js
+++ b/documentation/js/scope.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var changeNumbers, inner, outer;

 outer = 1;
--- a/documentation/js/slices.js
+++ b/documentation/js/slices.js
@@ -1,7 +1,12 @@
-var copy, middle, numbers;
+// Generated by CoffeeScript 1.3.3
+var copy, end, middle, numbers, start;

-numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9];

-copy = numbers.slice(0, numbers.length);
+start = numbers.slice(0, 3);

-middle = copy.slice(3, 7);
+middle = numbers.slice(3, 6);
+
+end = numbers.slice(6);
+
+copy = numbers.slice(0);
--- a/documentation/js/soaks.js
+++ b/documentation/js/soaks.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var zip, _ref;

 zip = typeof lottery.drawWinner === "function" ? (_ref = lottery.drawWinner().address) != null ? _ref.zipcode : void 0 : void 0;
--- a/documentation/js/splats.js
+++ b/documentation/js/splats.js
@@ -1,5 +1,6 @@
+// Generated by CoffeeScript 1.3.3
 var awardMedals, contenders, gold, rest, silver,
-  __slice = Array.prototype.slice;
+  __slice = [].slice;

 gold = silver = rest = "unknown";

--- a/documentation/js/splices.js
+++ b/documentation/js/splices.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var numbers, _ref;

 numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
--- a/documentation/js/strings.js
+++ b/documentation/js/strings.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var mobyDick;

 mobyDick = "Call me Ishmael. Some years ago -- never mind how long precisely -- having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world...";
--- a/documentation/js/switch.js
+++ b/documentation/js/switch.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3

 switch (day) {
  case "Mon":
--- a/documentation/js/try.js
+++ b/documentation/js/try.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3

 try {
  allHellBreaksLoose();
--- a/documentation/js/while.js
+++ b/documentation/js/while.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 var lyrics, num;

 if (this.studyingEconomics) {
--- a/extras/coffee-script.js
+++ b/extras/coffee-script.js
--- a/index.html
+++ b/index.html
@@ -6,6 +6,7 @@
 <head>
  <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
  <title>CoffeeScript</title>
+  <link rel="canonical" href="http://coffeescript.org" />
  <link rel="stylesheet" type="text/css" href="documentation/css/docs.css" />
  <link rel="stylesheet" type="text/css" href="documentation/css/idle.css" />
  <link rel="shortcut icon" href="documentation/images/favicon.ico" />
@@ -39,8 +40,8 @@
        <a href="#embedded">Embedded JavaScript</a>
        <a href="#switch">Switch and Try/Catch</a>
        <a href="#comparisons">Chained Comparisons</a>
-        <a href="#strings">String Interpolation, Heredocs, and Block Comments</a>
-        <a href="#regexes">Extended Regular Expressions</a>
+        <a href="#strings">String Interpolation, Block Strings, and Block Comments</a>
+        <a href="#regexes">Block Regular Expressions</a>
        <a href="#cake">Cake, and Cakefiles</a>
        <a href="#scripts">"text/coffeescript" Script Tags</a>
        <a href="#resources">Books, Screencasts, Examples and Resources</a>
@@ -106,13 +107,13 @@
      seamlessly from CoffeeScript (and vice-versa). The compiled output is 
      readable and pretty-printed, passes through 
      <a href="http://www.javascriptlint.com/">JavaScript Lint</a>
-      without warnings, will work in every JavaScript implementation, and tends
+      without warnings, will work in every JavaScript runtime, and tends
      to run as fast or faster than the equivalent handwritten JavaScript.
    </p>

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

    <h2>
@@ -151,13 +152,15 @@ alert <span class="String"><span class="String">&quot;</span>I knew it!<span cla
 <span class="Comment"><span class="Comment">#</span> Array comprehensions:</span>
 cubes <span class="Keyword">=</span> (math.cube num <span class="Keyword">for</span> num <span class="Keyword">in</span> list)
 </pre><pre class="idle"><span class="Storage">var</span> cubes, list, math, num, number, opposite, race, square,
-  __slice <span class="Keyword">=</span> <span class="LibraryClassType">Array</span>.<span class="LibraryConstant">prototype</span>.slice;
+  __slice <span class="Keyword">=</span> [].slice;

 number <span class="Keyword">=</span> <span class="Number">42</span>;

 opposite <span class="Keyword">=</span> <span class="BuiltInConstant">true</span>;

-<span class="Keyword">if</span> (opposite) number <span class="Keyword">=</span> <span class="Keyword">-</span><span class="Number">42</span>;
+<span class="Keyword">if</span> (opposite) {
+  number <span class="Keyword">=</span> <span class="Keyword">-</span><span class="Number">42</span>;
+}

 <span class="FunctionName">square</span> = <span class="Storage">function</span>(<span class="FunctionArgument">x</span>) {
  <span class="Keyword">return</span> x <span class="Keyword">*</span> x;
@@ -179,7 +182,9 @@ math <span class="Keyword">=</span> {
  <span class="Keyword">return</span> <span class="LibraryFunction">print</span>(winner, runners);
 };

-<span class="Keyword">if</span> (<span class="Keyword">typeof</span> elvis <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> elvis <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span>) <span class="LibraryFunction">alert</span>(<span class="String"><span class="String">&quot;</span>I knew it!<span class="String">&quot;</span></span>);
+<span class="Keyword">if</span> (<span class="Keyword">typeof</span> elvis <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> elvis <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span>) {
+  <span class="LibraryFunction">alert</span>(<span class="String"><span class="String">&quot;</span>I knew it!<span class="String">&quot;</span></span>);
+}

 cubes <span class="Keyword">=</span> (<span class="Storage">function</span>() {
  <span class="Storage">var</span> _i, _len, _results;
@@ -191,13 +196,15 @@ cubes <span class="Keyword">=</span> (<span class="Storage">function</span>() {
  <span class="Keyword">return</span> _results;
 })();
 </pre><script>window.example1 = "# Assignment:\nnumber   = 42\nopposite = true\n\n# Conditions:\nnumber = -42 if opposite\n\n# Functions:\nsquare = (x) -> x * x\n\n# Arrays:\nlist = [1, 2, 3, 4, 5]\n\n# Objects:\nmath =\n  root:   Math.sqrt\n  square: square\n  cube:   (x) -> x * square x\n\n# Splats:\nrace = (winner, runners...) ->\n  print winner, runners\n\n# Existence:\nalert \"I knew it!\" if elvis?\n\n# Array comprehensions:\ncubes = (math.cube num for num in list)\n\nalert cubes"</script><div class='minibutton ok' onclick='javascript: var cubes, list, math, num, number, opposite, race, square,
-  __slice = Array.prototype.slice;
+  __slice = [].slice;

 number = 42;

 opposite = true;

-if (opposite) number = -42;
+if (opposite) {
+  number = -42;
+}

 square = function(x) {
  return x * x;
@@ -219,7 +226,9 @@ race = function() {
  return print(winner, runners);
 };

-if (typeof elvis !== "undefined" && elvis !== null) alert("I knew it!");
+if (typeof elvis !== "undefined" && elvis !== null) {
+  alert("I knew it!");
+}

 cubes = (function() {
  var _i, _len, _results;
@@ -274,15 +283,6 @@ npm install -g coffee-script</pre>
  <pre>
 sudo bin/cake install</pre>

-    <p>
-      If installing on Ubuntu or Debian,
-      <a href="http://opinionatedprogrammer.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. 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>
-
    <h2>
      <span id="usage" class="bookmark"></span>
      Usage
@@ -437,7 +437,7 @@ Expressions
        <tt>coffee -o lib/ -cw src/</tt>
      </li>
      <li>
-        Start the CoffeeScript REPL:<br />
+        Start the CoffeeScript REPL (<tt>Ctrl-D</tt> to exit, <tt>Ctrl-V</tt>for multi-line):<br />
        <tt>coffee</tt>
      </li>
    </ul>
@@ -469,7 +469,7 @@ Expressions
      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>,
+      <tt>{ }</tt> to surround blocks of code in <a href="#literals">functions</a>,
      <a href="#conditionals">if-statements</a>,
      <a href="#switch">switch</a>, and <a href="#try">try/catch</a>,
      use indentation.
@@ -524,13 +524,17 @@ cube = function(x) {
 </pre><pre class="idle"><span class="Storage">var</span> fill;

 <span class="FunctionName">fill</span> = <span class="Storage">function</span>(<span class="FunctionArgument">container, liquid</span>) {
-  <span class="Keyword">if</span> (liquid <span class="Keyword">==</span> <span class="BuiltInConstant">null</span>) liquid <span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>coffee<span class="String">&quot;</span></span>;
+  <span class="Keyword">if</span> (liquid <span class="Keyword">==</span> <span class="BuiltInConstant">null</span>) {
+    liquid <span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>coffee<span class="String">&quot;</span></span>;
+  }
  <span class="Keyword">return</span> <span class="String"><span class="String">&quot;</span>Filling the <span class="String">&quot;</span></span> <span class="Keyword">+</span> container <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> with <span class="String">&quot;</span></span> <span class="Keyword">+</span> liquid <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span>...<span class="String">&quot;</span></span>;
 };
 </pre><script>window.example3 = "fill = (container, liquid = \"coffee\") ->\n  \"Filling the #{container} with #{liquid}...\"\n\nalert fill(\"cup\")"</script><div class='minibutton load' onclick='javascript: loadConsole(example3);'>load</div><div class='minibutton ok' onclick='javascript: var fill;

 fill = function(container, liquid) {
-  if (liquid == null) liquid = "coffee";
+  if (liquid == null) {
+    liquid = "coffee";
+  }
  return "Filling the " + container + " with " + liquid + "...";
 };
 ;alert(fill("cup"));'>run: fill("cup")</div><br class='clear' /></div>
@@ -713,12 +717,13 @@ inner = changeNumbers();

 date <span class="Keyword">=</span> <span class="Keyword">if</span> friday <span class="Keyword">then</span> sue <span class="Keyword">else</span> jill

-options <span class="Keyword">or=</span> defaults


 </pre><pre class="idle"><span class="Storage">var</span> date, mood;

-<span class="Keyword">if</span> (singing) mood <span class="Keyword">=</span> greatlyImproved;
+<span class="Keyword">if</span> (singing) {
+  mood <span class="Keyword">=</span> greatlyImproved;
+}

 <span class="Keyword">if</span> (happy <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> knowsIt) {
  clapsHands();
@@ -728,9 +733,7 @@ options <span class="Keyword">or=</span> defaults
 }

 date <span class="Keyword">=</span> friday ? sue : jill;
-
-options <span class="Keyword">||</span> (options <span class="Keyword">=</span> defaults);
-</pre><script>window.example7 = "mood = greatlyImproved if singing\n\nif happy and knowsIt\n  clapsHands()\n  chaChaCha()\nelse\n  showIt()\n\ndate = if friday then sue else jill\n\noptions or= defaults\n\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example7);'>load</div><br class='clear' /></div>
+</pre><script>window.example7 = "mood = greatlyImproved if singing\n\nif happy and knowsIt\n  clapsHands()\n  chaChaCha()\nelse\n  showIt()\n\ndate = if friday then sue else jill\n\n\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example7);'>load</div><br class='clear' /></div>

    <p>
      <span id="splats" class="bookmark"></span>
@@ -768,7 +771,7 @@ alert <span class="String"><span class="String">&quot;</span>The Field: <span cl


 </pre><pre class="idle"><span class="Storage">var</span> awardMedals, contenders, gold, rest, silver,
-  __slice <span class="Keyword">=</span> <span class="LibraryClassType">Array</span>.<span class="LibraryConstant">prototype</span>.slice;
+  __slice <span class="Keyword">=</span> [].slice;

 gold <span class="Keyword">=</span> silver <span class="Keyword">=</span> rest <span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>unknown<span class="String">&quot;</span></span>;

@@ -790,7 +793,7 @@ awardMedals.<span class="LibraryFunction">apply</span>(<span class="BuiltInConst

 <span class="LibraryFunction">alert</span>(<span class="String"><span class="String">&quot;</span>The Field: <span class="String">&quot;</span></span> <span class="Keyword">+</span> rest);
 </pre><script>window.example8 = "gold = silver = rest = \"unknown\"\n\nawardMedals = (first, second, others...) ->\n  gold   = first\n  silver = second\n  rest   = others\n\ncontenders = [\n  \"Michael Phelps\"\n  \"Liu Xiang\"\n  \"Yao Ming\"\n  \"Allyson Felix\"\n  \"Shawn Johnson\"\n  \"Roman Sebrle\"\n  \"Guo Jingjing\"\n  \"Tyson Gay\"\n  \"Asafa Powell\"\n  \"Usain Bolt\"\n]\n\nawardMedals contenders...\n\nalert \"Gold: \" + gold\nalert \"Silver: \" + silver\nalert \"The Field: \" + rest\n\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example8);'>load</div><div class='minibutton ok' onclick='javascript: var awardMedals, contenders, gold, rest, silver,
-  __slice = Array.prototype.slice;
+  __slice = [].slice;

 gold = silver = rest = "unknown";

@@ -832,7 +835,7 @@ menu i <span class="Keyword">+</span> <span class="Number">1</span>, dish <span
 <span class="Comment"><span class="Comment">#</span> Health conscious meal.</span>
 foods <span class="Keyword">=</span> [<span class="String"><span class="String">'</span>broccoli<span class="String">'</span></span>, <span class="String"><span class="String">'</span>spinach<span class="String">'</span></span>, <span class="String"><span class="String">'</span>chocolate<span class="String">'</span></span>]
 eat food <span class="Keyword">for</span> food <span class="Keyword">in</span> foods <span class="Keyword">when</span> food <span class="Keyword">isnt</span> <span class="String"><span class="String">'</span>chocolate<span class="String">'</span></span>
-</pre><pre class="idle"><span class="Storage">var</span> courses, dish, food, foods, i, _i, _j, _len, _len2, _len3, _ref;
+</pre><pre class="idle"><span class="Storage">var</span> courses, dish, food, foods, i, _i, _j, _k, _len, _len1, _len2, _ref;

 _ref <span class="Keyword">=</span> [<span class="String"><span class="String">'</span>toast<span class="String">'</span></span>, <span class="String"><span class="String">'</span>cheese<span class="String">'</span></span>, <span class="String"><span class="String">'</span>wine<span class="String">'</span></span>];
 <span class="Keyword">for</span> (_i <span class="Keyword">=</span> <span class="Number">0</span>, _len <span class="Keyword">=</span> _ref.<span class="LibraryConstant">length</span>; _i <span class="Keyword">&lt;</span> _len; _i<span class="Keyword">++</span>) {
@@ -842,16 +845,18 @@ _ref <span class="Keyword">=</span> [<span class="String"><span class="String">'

 courses <span class="Keyword">=</span> [<span class="String"><span class="String">'</span>greens<span class="String">'</span></span>, <span class="String"><span class="String">'</span>caviar<span class="String">'</span></span>, <span class="String"><span class="String">'</span>truffles<span class="String">'</span></span>, <span class="String"><span class="String">'</span>roast<span class="String">'</span></span>, <span class="String"><span class="String">'</span>cake<span class="String">'</span></span>];

-<span class="Keyword">for</span> (i <span class="Keyword">=</span> <span class="Number">0</span>, _len2 <span class="Keyword">=</span> courses.<span class="LibraryConstant">length</span>; i <span class="Keyword">&lt;</span> _len2; i<span class="Keyword">++</span>) {
+<span class="Keyword">for</span> (i <span class="Keyword">=</span> _j <span class="Keyword">=</span> <span class="Number">0</span>, _len1 <span class="Keyword">=</span> courses.<span class="LibraryConstant">length</span>; _j <span class="Keyword">&lt;</span> _len1; i <span class="Keyword">=</span> <span class="Keyword">++</span>_j) {
  dish <span class="Keyword">=</span> courses[i];
  menu(i <span class="Keyword">+</span> <span class="Number">1</span>, dish);
 }

 foods <span class="Keyword">=</span> [<span class="String"><span class="String">'</span>broccoli<span class="String">'</span></span>, <span class="String"><span class="String">'</span>spinach<span class="String">'</span></span>, <span class="String"><span class="String">'</span>chocolate<span class="String">'</span></span>];

-<span class="Keyword">for</span> (_j <span class="Keyword">=</span> <span class="Number">0</span>, _len3 <span class="Keyword">=</span> foods.<span class="LibraryConstant">length</span>; _j <span class="Keyword">&lt;</span> _len3; _j<span class="Keyword">++</span>) {
-  food <span class="Keyword">=</span> foods[_j];
-  <span class="Keyword">if</span> (food <span class="Keyword">!</span><span class="Keyword">==</span> <span class="String"><span class="String">'</span>chocolate<span class="String">'</span></span>) eat(food);
+<span class="Keyword">for</span> (_k <span class="Keyword">=</span> <span class="Number">0</span>, _len2 <span class="Keyword">=</span> foods.<span class="LibraryConstant">length</span>; _k <span class="Keyword">&lt;</span> _len2; _k<span class="Keyword">++</span>) {
+  food <span class="Keyword">=</span> foods[_k];
+  <span class="Keyword">if</span> (food <span class="Keyword">!</span><span class="Keyword">==</span> <span class="String"><span class="String">'</span>chocolate<span class="String">'</span></span>) {
+    eat(food);
+  }
 }
 </pre><script>window.example9 = "# Eat lunch.\neat food for food in ['toast', 'cheese', 'wine']\n\n# Fine five course dining.\ncourses = ['greens', 'caviar', 'truffles', 'roast', 'cake']\nmenu i + 1, dish for dish, i in courses\n\n# Health conscious meal.\nfoods = ['broccoli', 'spinach', 'chocolate']\neat food for food in foods when food isnt 'chocolate'\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example9);'>load</div><br class='clear' /></div>
    <p>
@@ -867,9 +872,9 @@ foods <span class="Keyword">=</span> [<span class="String"><span class="String">
 </pre><pre class="idle"><span class="Storage">var</span> countdown, num;

 countdown <span class="Keyword">=</span> (<span class="Storage">function</span>() {
-  <span class="Storage">var</span> _results;
+  <span class="Storage">var</span> _i, _results;
  _results <span class="Keyword">=</span> [];
-  <span class="Keyword">for</span> (num <span class="Keyword">=</span> <span class="Number">10</span>; num <span class="Keyword">&gt;=</span> <span class="Number">1</span>; num<span class="Keyword">--</span>) {
+  <span class="Keyword">for</span> (num <span class="Keyword">=</span> _i <span class="Keyword">=</span> <span class="Number">10</span>; _i <span class="Keyword">&gt;=</span> <span class="Number">1</span>; num <span class="Keyword">=</span> <span class="Keyword">--</span>_i) {
    _results.<span class="LibraryFunction">push</span>(num);
  }
  <span class="Keyword">return</span> _results;
@@ -877,9 +882,9 @@ countdown <span class="Keyword">=</span> (<span class="Storage">function</span>(
 </pre><script>window.example10 = "countdown = (num for num in [10..1])\n\nalert countdown"</script><div class='minibutton load' onclick='javascript: loadConsole(example10);'>load</div><div class='minibutton ok' onclick='javascript: var countdown, num;

 countdown = (function() {
-  var _results;
+  var _i, _results;
  _results = [];
-  for (num = 10; num >= 1; num--) {
+  for (num = _i = 10; _i >= 1; num = --_i) {
    _results.push(num);
  }
  return _results;
@@ -946,7 +951,7 @@ ages = (function() {
    <p>
      If you would like to iterate over just the keys that are defined on the
      object itself, by adding a <tt>hasOwnProperty</tt>
-      check to avoid properties that may be interited from the prototype, use<br />
+      check to avoid properties that may be inherited from the prototype, use<br />
      <tt>for own key, value of object</tt>
    </p>
    <p>
@@ -1042,28 +1047,40 @@ lyrics = (function() {
      Ranges can also be used to extract slices of arrays.
      With two dots (<tt>3..6</tt>), the range is inclusive (<tt>3, 4, 5, 6</tt>);
      with three dots (<tt>3...6</tt>), the range excludes the end (<tt>3, 4, 5</tt>).
+      Slices indices have useful defaults. An omitted first index defaults to
+      zero and an omitted second index defaults to the size of the array.
    </p>
-    <div class='code'><pre class="idle">numbers <span class="Keyword">=</span> [<span class="Number">0</span>, <span class="Number">1</span>, <span class="Number">2</span>, <span class="Number">3</span>, <span class="Number">4</span>, <span class="Number">5</span>, <span class="Number">6</span>, <span class="Number">7</span>, <span class="Number">8</span>, <span class="Number">9</span>]
+    <div class='code'><pre class="idle">numbers <span class="Keyword">=</span> [<span class="Number">1</span>, <span class="Number">2</span>, <span class="Number">3</span>, <span class="Number">4</span>, <span class="Number">5</span>, <span class="Number">6</span>, <span class="Number">7</span>, <span class="Number">8</span>, <span class="Number">9</span>]

-copy    <span class="Keyword">=</span> numbers[<span class="Number">0</span>...numbers.length]
+start   <span class="Keyword">=</span> numbers[<span class="Number">0</span>..<span class="Number">2</span>]

-middle  <span class="Keyword">=</span> copy[<span class="Number">3</span>..<span class="Number">6</span>]
+middle  <span class="Keyword">=</span> numbers[<span class="Number">3</span>...<span class="Number">6</span>]

+end     <span class="Keyword">=</span> numbers[<span class="Number">6</span>..]

-</pre><pre class="idle"><span class="Storage">var</span> copy, middle, numbers;
+copy    <span class="Keyword">=</span> numbers[..]
+</pre><pre class="idle"><span class="Storage">var</span> copy, end, middle, numbers, start;

-numbers <span class="Keyword">=</span> [<span class="Number">0</span>, <span class="Number">1</span>, <span class="Number">2</span>, <span class="Number">3</span>, <span class="Number">4</span>, <span class="Number">5</span>, <span class="Number">6</span>, <span class="Number">7</span>, <span class="Number">8</span>, <span class="Number">9</span>];
+numbers <span class="Keyword">=</span> [<span class="Number">1</span>, <span class="Number">2</span>, <span class="Number">3</span>, <span class="Number">4</span>, <span class="Number">5</span>, <span class="Number">6</span>, <span class="Number">7</span>, <span class="Number">8</span>, <span class="Number">9</span>];

-copy <span class="Keyword">=</span> numbers.<span class="LibraryFunction">slice</span>(<span class="Number">0</span>, numbers.<span class="LibraryConstant">length</span>);
+start <span class="Keyword">=</span> numbers.<span class="LibraryFunction">slice</span>(<span class="Number">0</span>, <span class="Number">3</span>);

-middle <span class="Keyword">=</span> copy.<span class="LibraryFunction">slice</span>(<span class="Number">3</span>, <span class="Number">7</span>);
-</pre><script>window.example14 = "numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n\ncopy    = numbers[0...numbers.length]\n\nmiddle  = copy[3..6]\n\nalert middle"</script><div class='minibutton load' onclick='javascript: loadConsole(example14);'>load</div><div class='minibutton ok' onclick='javascript: var copy, middle, numbers;
+middle <span class="Keyword">=</span> numbers.<span class="LibraryFunction">slice</span>(<span class="Number">3</span>, <span class="Number">6</span>);

-numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+end <span class="Keyword">=</span> numbers.<span class="LibraryFunction">slice</span>(<span class="Number">6</span>);

-copy = numbers.slice(0, numbers.length);
+copy <span class="Keyword">=</span> numbers.<span class="LibraryFunction">slice</span>(<span class="Number">0</span>);
+</pre><script>window.example14 = "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n\nstart   = numbers[0..2]\n\nmiddle  = numbers[3...6]\n\nend     = numbers[6..]\n\ncopy    = numbers[..]\n\nalert middle"</script><div class='minibutton load' onclick='javascript: loadConsole(example14);'>load</div><div class='minibutton ok' onclick='javascript: var copy, end, middle, numbers, start;

-middle = copy.slice(3, 7);
+numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+start = numbers.slice(0, 3);
+
+middle = numbers.slice(3, 6);
+
+end = numbers.slice(6);
+
+copy = numbers.slice(0);
 ;alert(middle);'>run: middle</div><br class='clear' /></div>
    <p>
      The same syntax can be used with assignment to replace a segment of an array
@@ -1296,15 +1313,25 @@ winner <span class="Keyword">=</span> <span class="BuiltInConstant">yes</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();
+<span class="Keyword">if</span> (ignition <span class="Keyword">===</span> <span class="BuiltInConstant">true</span>) {
+  launch();
+}

-<span class="Keyword">if</span> (band <span class="Keyword">!</span><span class="Keyword">==</span> SpinalTap) volume <span class="Keyword">=</span> <span class="Number">10</span>;
+<span class="Keyword">if</span> (band <span class="Keyword">!</span><span class="Keyword">==</span> SpinalTap) {
+  volume <span class="Keyword">=</span> <span class="Number">10</span>;
+}

-<span class="Keyword">if</span> (answer <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">false</span>) letTheWildRumpusBegin();
+<span class="Keyword">if</span> (answer <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">false</span>) {
+  letTheWildRumpusBegin();
+}

-<span class="Keyword">if</span> (car.speed <span class="Keyword">&lt;</span> limit) accelerate();
+<span class="Keyword">if</span> (car.speed <span class="Keyword">&lt;</span> limit) {
+  accelerate();
+}

-<span class="Keyword">if</span> (pick <span class="Keyword">===</span> <span class="Number">47</span> <span class="Keyword">||</span> pick <span class="Keyword">===</span> <span class="Number">92</span> <span class="Keyword">||</span> pick <span class="Keyword">===</span> <span class="Number">13</span>) winner <span class="Keyword">=</span> <span class="BuiltInConstant">true</span>;
+<span class="Keyword">if</span> (pick <span class="Keyword">===</span> <span class="Number">47</span> <span class="Keyword">||</span> pick <span class="Keyword">===</span> <span class="Number">92</span> <span class="Keyword">||</span> pick <span class="Keyword">===</span> <span class="Number">13</span>) {
+  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>
@@ -1323,7 +1350,8 @@ print inspect <span class="String"><span class="String">&quot;</span>My name is
    </p>
    <div class='code'><pre class="idle">solipsism <span class="Keyword">=</span> <span class="BuiltInConstant">true</span> <span class="Keyword">if</span> mind<span class="Keyword">?</span> <span class="Keyword">and</span> <span class="Keyword">not</span> world<span class="Keyword">?</span>

-speed <span class="Keyword">?</span><span class="Keyword">=</span> <span class="Number">75</span>
+speed <span class="Keyword">=</span> <span class="Number">0</span>
+speed <span class="Keyword">?</span><span class="Keyword">=</span> <span class="Number">15</span>

 footprints <span class="Keyword">=</span> yeti <span class="Keyword">?</span> <span class="String"><span class="String">&quot;</span>bear<span class="String">&quot;</span></span>

@@ -1333,22 +1361,30 @@ footprints <span class="Keyword">=</span> yeti <span class="Keyword">?</span> <s


 
-</pre><pre class="idle"><span class="Storage">var</span> footprints, solipsism;
+</pre><pre class="idle"><span class="Storage">var</span> footprints, solipsism, speed;

 <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="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>;
+speed <span class="Keyword">=</span> <span class="Number">0</span>;
+
+<span class="Keyword">if</span> (speed <span class="Keyword">==</span> <span class="BuiltInConstant">null</span>) {
+  speed <span class="Keyword">=</span> <span class="Number">15</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;
+</pre><script>window.example21 = "solipsism = true if mind? and not world?\n\nspeed = 0\nspeed ?= 15\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, speed;

 if ((typeof mind !== "undefined" && mind !== null) && !(typeof world !== "undefined" && world !== null)) {
  solipsism = true;
 }

-if (typeof speed === "undefined" || speed === null) speed = 75;
+speed = 0;
+
+if (speed == null) {
+  speed = 15;
+}

 footprints = typeof yeti !== "undefined" && yeti !== null ? yeti : "bear";
 ;alert(footprints);'>run: footprints</div><br class='clear' /></div>
@@ -1395,6 +1431,7 @@ zip <span class="Keyword">=</span> <span class="Keyword">typeof</span> lottery.d
    </p>
    <p>
      Constructor functions are named, to better support helpful stack traces.
+      In the first class in the example below, <tt>this.constructor.name is "Animal"</tt>.
    </p>
    <div class='code'><pre class="idle"><span class="Storage">class</span> <span class="TypeName">Animal</span>
  <span class="FunctionName">constructor</span><span class="Keyword">:</span> <span class="FunctionArgument">(@name)</span> <span class="Storage">-&gt;</span>
@@ -1422,8 +1459,8 @@ tom.move()


 </pre><pre class="idle"><span class="Storage">var</span> Animal, Horse, Snake, sam, tom,
-  __hasProp <span class="Keyword">=</span> <span class="LibraryClassType">Object</span>.<span class="LibraryConstant">prototype</span>.hasOwnProperty,
-  <span class="FunctionName">__extends</span> = <span class="Storage">function</span>(<span class="FunctionArgument">child, parent</span>) { <span class="Keyword">for</span> (<span class="Storage">var</span> key <span class="Keyword">in</span> parent) { <span class="Keyword">if</span> (__hasProp.<span class="LibraryFunction">call</span>(parent, key)) child[key] <span class="Keyword">=</span> parent[key]; } <span class="Storage">function</span> <span class="FunctionName">ctor</span>() { <span class="Variable">this</span>.<span class="LibraryConstant">constructor</span> <span class="Keyword">=</span> child; } <span class="LibraryClassType">ctor</span>.<span class="LibraryConstant">prototype</span> = parent.<span class="LibraryConstant">prototype</span>; <span class="LibraryClassType">child</span>.<span class="LibraryConstant">prototype</span> = <span class="Keyword">new</span> <span class="TypeName">ctor</span>; child.__super__ <span class="Keyword">=</span> parent.<span class="LibraryConstant">prototype</span>; <span class="Keyword">return</span> child; };
+  __hasProp <span class="Keyword">=</span> {}.hasOwnProperty,
+  <span class="FunctionName">__extends</span> = <span class="Storage">function</span>(<span class="FunctionArgument">child, parent</span>) { <span class="Keyword">for</span> (<span class="Storage">var</span> key <span class="Keyword">in</span> parent) { <span class="Keyword">if</span> (__hasProp.<span class="LibraryFunction">call</span>(parent, key)) child[key] <span class="Keyword">=</span> parent[key]; } <span class="Storage">function</span> <span class="FunctionName">ctor</span>() { <span class="Variable">this</span>.<span class="LibraryConstant">constructor</span> <span class="Keyword">=</span> child; } <span class="LibraryClassType">ctor</span>.<span class="LibraryConstant">prototype</span> = parent.<span class="LibraryConstant">prototype</span>; <span class="LibraryClassType">child</span>.<span class="LibraryConstant">prototype</span> = <span class="Keyword">new</span> <span class="TypeName">ctor</span>(); child.__super__ <span class="Keyword">=</span> parent.<span class="LibraryConstant">prototype</span>; <span class="Keyword">return</span> child; };

 Animal <span class="Keyword">=</span> (<span class="Storage">function</span>() {

@@ -1444,7 +1481,7 @@ Snake <span class="Keyword">=</span> (<span class="Storage">function</span>(_sup
  __extends(Snake, _super);

  <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);
+    <span class="Keyword">return</span> Snake.__super__.<span class="LibraryConstant">constructor</span>.<span class="LibraryFunction">apply</span>(<span class="Variable">this</span>, arguments);
  }

  <span class="LibraryClassType">Snake</span>.<span class="LibraryConstant">prototype</span>.<span class="FunctionName">move</span> = <span class="Storage">function</span>() {
@@ -1461,7 +1498,7 @@ Horse <span class="Keyword">=</span> (<span class="Storage">function</span>(_sup
  __extends(Horse, _super);

  <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);
+    <span class="Keyword">return</span> Horse.__super__.<span class="LibraryConstant">constructor</span>.<span class="LibraryFunction">apply</span>(<span class="Variable">this</span>, arguments);
  }

  <span class="LibraryClassType">Horse</span>.<span class="LibraryConstant">prototype</span>.<span class="FunctionName">move</span> = <span class="Storage">function</span>() {
@@ -1481,8 +1518,8 @@ 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,
-  __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; } ctor.prototype = parent.prototype; child.prototype = new ctor; child.__super__ = parent.prototype; return child; };
+  __hasProp = {}.hasOwnProperty,
+  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

 Animal = (function() {

@@ -1503,7 +1540,7 @@ Snake = (function(_super) {
  __extends(Snake, _super);

  function Snake() {
-    Snake.__super__.constructor.apply(this, arguments);
+    return Snake.__super__.constructor.apply(this, arguments);
  }

  Snake.prototype.move = function() {
@@ -1520,7 +1557,7 @@ Horse = (function(_super) {
  __extends(Horse, _super);

  function Horse() {
-    Horse.__super__.constructor.apply(this, arguments);
+    return Horse.__super__.constructor.apply(this, arguments);
  }

  Horse.prototype.move = function() {
@@ -1649,7 +1686,7 @@ _ref = weatherReport("Berkeley, CA"), city = _ref[0], temp = _ref[1], forecast =



-</pre><pre class="idle"><span class="Storage">var</span> city, futurists, name, street, _ref, _ref2;
+</pre><pre class="idle"><span class="Storage">var</span> city, futurists, name, street, _ref, _ref1;

 futurists <span class="Keyword">=</span> {
  sculptor: <span class="String"><span class="String">&quot;</span>Umberto Boccioni<span class="String">&quot;</span></span>,
@@ -1660,8 +1697,8 @@ futurists <span class="Keyword">=</span> {
  }
 };

-_ref <span class="Keyword">=</span> futurists.poet, name <span class="Keyword">=</span> _ref.<span class="LibraryConstant">name</span>, (_ref2 <span class="Keyword">=</span> _ref.address, street <span class="Keyword">=</span> _ref2[<span class="Number">0</span>], city <span class="Keyword">=</span> _ref2[<span class="Number">1</span>]);
-</pre><script>window.example27 = "futurists =\n  sculptor: \"Umberto Boccioni\"\n  painter:  \"Vladimir Burliuk\"\n  poet:\n    name:   \"F.T. Marinetti\"\n    address: [\n      \"Via Roma 42R\"\n      \"Bellagio, Italy 22021\"\n    ]\n\n{poet: {name, address: [street, city]}} = futurists\n\nalert name + \" — \" + street"</script><div class='minibutton load' onclick='javascript: loadConsole(example27);'>load</div><div class='minibutton ok' onclick='javascript: var city, futurists, name, street, _ref, _ref2;
+_ref <span class="Keyword">=</span> futurists.poet, name <span class="Keyword">=</span> _ref.<span class="LibraryConstant">name</span>, (_ref1 <span class="Keyword">=</span> _ref.address, street <span class="Keyword">=</span> _ref1[<span class="Number">0</span>], city <span class="Keyword">=</span> _ref1[<span class="Number">1</span>]);
+</pre><script>window.example27 = "futurists =\n  sculptor: \"Umberto Boccioni\"\n  painter:  \"Vladimir Burliuk\"\n  poet:\n    name:   \"F.T. Marinetti\"\n    address: [\n      \"Via Roma 42R\"\n      \"Bellagio, Italy 22021\"\n    ]\n\n{poet: {name, address: [street, city]}} = futurists\n\nalert name + \" — \" + street"</script><div class='minibutton load' onclick='javascript: loadConsole(example27);'>load</div><div class='minibutton ok' onclick='javascript: var city, futurists, name, street, _ref, _ref1;

 futurists = {
  sculptor: "Umberto Boccioni",
@@ -1672,7 +1709,7 @@ futurists = {
  }
 };

-_ref = futurists.poet, name = _ref.name, (_ref2 = _ref.address, street = _ref2[0], city = _ref2[1]);
+_ref = futurists.poet, name = _ref.name, (_ref1 = _ref.address, street = _ref1[0], city = _ref1[1]);
 ;alert(name + " — " + street);'>run: name + " — " + street</div><br class='clear' /></div>
    <p>
      Destructuring assignment can even be combined with splats.
@@ -1687,13 +1724,13 @@ _ref = futurists.poet, name = _ref.name, (_ref2 = _ref.address, street = _ref2[0


 </pre><pre class="idle"><span class="Storage">var</span> close, contents, open, tag, _i, _ref,
-  __slice <span class="Keyword">=</span> <span class="LibraryClassType">Array</span>.<span class="LibraryConstant">prototype</span>.slice;
+  __slice <span class="Keyword">=</span> [].slice;

 tag <span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>&lt;impossible&gt;<span class="String">&quot;</span></span>;

 _ref <span class="Keyword">=</span> tag.<span class="LibraryFunction">split</span>(<span class="String"><span class="String">&quot;</span><span class="String">&quot;</span></span>), open <span class="Keyword">=</span> _ref[<span class="Number">0</span>], contents <span class="Keyword">=</span> <span class="Number">3</span> <span class="Keyword">&lt;=</span> _ref.<span class="LibraryConstant">length</span> ? __slice.<span class="LibraryFunction">call</span>(_ref, <span class="Number">1</span>, _i <span class="Keyword">=</span> _ref.<span class="LibraryConstant">length</span> <span class="Keyword">-</span> <span class="Number">1</span>) : (_i <span class="Keyword">=</span> <span class="Number">1</span>, []), close <span class="Keyword">=</span> _ref[_i<span class="Keyword">++</span>];
 </pre><script>window.example28 = "tag = \"<impossible>\"\n\n[open, contents..., close] = tag.split(\"\")\n\nalert contents.join(\"\")"</script><div class='minibutton load' onclick='javascript: loadConsole(example28);'>load</div><div class='minibutton ok' onclick='javascript: var close, contents, open, tag, _i, _ref,
-  __slice = Array.prototype.slice;
+  __slice = [].slice;

 tag = "<impossible>";

@@ -1874,7 +1911,7 @@ healthy = (200 > cholesterol && cholesterol > 60);

    <p>
      <span id="strings" class="bookmark"></span>
-      <b class="header">String Interpolation, Heredocs, and Block Comments</b>
+      <b class="header">String Interpolation, Block Strings, and Block Comments</b>
      Ruby-style string interpolation is included in CoffeeScript. Double-quoted
      strings allow for interpolated values, using <tt>#{ ... }</tt>,
      and single-quoted strings are literal.
@@ -1922,9 +1959,9 @@ mobyDick <span class="Keyword">=</span> <span class="String"><span class="String
 mobyDick = "Call me Ishmael. Some years ago -- never mind how long precisely -- having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world...";
 ;alert(mobyDick);'>run: mobyDick</div><br class='clear' /></div>
    <p>
-      Heredocs can be used to hold formatted or indentation-sensitive text
+      Block strings can be used to hold formatted or indentation-sensitive text
      (or, if you just don't feel like escaping quotes and apostrophes). The
-      indentation level that begins the heredoc is maintained throughout, so
+      indentation level that begins the block is maintained throughout, so
      you can keep it all aligned with the body of your code.
    </p>
    <div class='code'><pre class="idle">html <span class="Keyword">=</span> <span class="String"><span class="String">&quot;&quot;&quot;</span></span>
@@ -1941,35 +1978,36 @@ html <span class="Keyword">=</span> <span class="String"><span class="String">&q
 html = "<strong>\n  cup of coffeescript\n</strong>";
 ;alert(html);'>run: html</div><br class='clear' /></div>
    <p>
-      Double-quoted heredocs, like double-quoted strings, allow interpolation.
+      Double-quoted block strings, like other double-quoted strings, allow interpolation.
    </p>
    <p>
      Sometimes you'd like to pass a block comment through to the generated
      JavaScript. For example, when you need to embed a licensing header at
-      the top of a file. Block comments, which mirror the syntax for heredocs,
+      the top of a file. Block comments, which mirror the syntax for block strings,
      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.2.0</span>
+<span class="Comment">CoffeeScript Compiler v1.3.3</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.2.0</span>
+<span class="Comment">CoffeeScript Compiler v1.3.3</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.2.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.3.3\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>
-      <b class="header">Extended Regular Expressions</b>
-      Similar to "heredocs" and "herecomments", CoffeeScript supports "heregexes" &mdash;
+      <b class="header">Block Regular Expressions</b>
+      Similar to block strings and comments, CoffeeScript supports block regexes &mdash;
      extended regular expressions that ignore internal whitespace and can contain
-      comments, after Perl's <tt>/x</tt> modifier, but delimited by <tt>///</tt>.
-      They go a long way towards making complex regular expressions readable.
-      To quote from the CoffeeScript source:
+      comments and interpolation. Modeled after Perl's <tt>/x</tt> modifier, CoffeeSctipt's
+      block regexes are delimited by <tt>///</tt> and go a long way towards making complex
+      regular expressions readable. To quote from the CoffeeScript source:
    </p>
    <div class='code'><pre class="idle">OPERATOR <span class="Keyword">=</span> <span class="String">/// ^ (</span>
 <span class="String">  ?: [-=]&gt;             <span class="Comment"><span class="Comment">#</span> function</span></span>
@@ -2074,11 +2112,11 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="

    <h2>
      <span id="resources" class="bookmark"></span>
-      Books and Screencasts
+      Books
    </h2>

    <p>
-      There are a number of excellent books and screencasts to help you get
+      There are a number of excellent resources to help you get
      started with CoffeeScript, some of which are freely available online.
    </p>

@@ -2104,6 +2142,17 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="
        a fast-paced multiplayer word game, writing both the client-side and Node.js
        portions in CoffeeScript.
      </li>
+    </ul>
+    
+    <h2>
+      Screencasts
+    </h2>
+    
+    <ul>
+      <li>
+        <a href="http://coffeescript.codeschool.com">A Sip of CoffeeScript</a> is a <a href="http://www.codeschool.com">Code School Course</a>
+        which combines 6 screencasts with in-browser coding to make learning fun.  The first level is free to try out.
+      </li>
      <li>
        <a href="http://peepcode.com/products/coffeescript">Meet CoffeeScript</a>
        is a 75-minute long screencast by <a href="http://peepcode.com/">PeepCode</a>.
@@ -2203,6 +2252,11 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="
        <a href="http://github.com/jashkenas/coffee-script/wiki/FAQ">The FAQ</a><br />
        Perhaps your CoffeeScript-related question has been asked before. Check the FAQ first.
      </li>
+      <li>
+        <a href="https://github.com/jashkenas/coffee-script/downloads">High-Rez Logo</a><br />
+        The CoffeeScript logo is available in Illustrator, EPS and PSD formats, for use
+        in presentations.
+      </li>
    </ul>

    <h2>
@@ -2225,6 +2279,85 @@ 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.3.1...1.3.3">1.3.3</a>
+        <span class="timestamp"> &ndash; <small>May 15, 2012</small></span>
+      </b>
+      <ul>
+        <li>
+          Due to the new semantics of JavaScript's strict mode, CoffeeScript no
+          longer guarantees that constructor functions have names in all runtimes.
+          See <a href="https://github.com/jashkenas/coffee-script/issues/2052">#2052</a> 
+          for discussion.
+        </li>
+        <li>
+          Inside of a nested function inside of an instance method, it's now possible
+          to call <tt>super</tt> more reliably (walks recursively up).
+        </li>
+        <li>
+          Named loop variables no longer have different scoping heuristics than
+          other local variables. (Reverts #643)
+        </li>
+        <li>
+          Fix for splats nested within the LHS of destructuring assignment.
+        </li>
+        <li>
+          Corrections to our compile time strict mode forbidding of octal literals.
+        </li>
+      </ul>
+    </p>
+    
+    <p>
+      <b class="header" style="margin-top: 20px;">
+        <a href="https://github.com/jashkenas/coffee-script/compare/1.2.0...1.3.1">1.3.1</a>
+        <span class="timestamp"> &ndash; <small>April 10, 2012</small></span>
+      </b>
+      <ul>
+        <li>
+          CoffeeScript now enforces all of JavaScript's <b>Strict Mode</b> early syntax 
+          errors at compile time. This includes old-style octal literals, 
+          duplicate property names in object literals, duplicate parameters in 
+          a function definition, deleting naked variables, setting the value of
+          <tt>eval</tt> or <tt>arguments</tt>, and more.
+          See a full discussion at 
+          <a href="https://github.com/jashkenas/coffee-script/issues/1547">#1547</a>.
+        </li>
+        <li>
+          The REPL now has a handy new multi-line mode for entering large
+          blocks of code. It's useful when copy-and-pasting examples into the
+          REPL. Enter multi-line mode with <tt>Ctrl-V</tt>. You may also now 
+          pipe input directly into the REPL.
+        </li>
+        <li>
+          CoffeeScript now prints a <tt>Generated by CoffeeScript VERSION</tt> 
+          header at the top of each compiled file.
+        </li>
+        <li>
+          Conditional assignment of previously undefined variables 
+          <tt>a or= b</tt> is now considered a syntax error.
+        </li>
+        <li>
+          A tweak to the semantics of <tt>do</tt>, which can now be used to
+          more easily simulate a namespace: <tt>do (x = 1, y = 2) -> ...</tt>
+        </li>
+        <li>
+          Loop indices are now mutable within a loop iteration, and immutable
+          between them.
+        </li>
+        <li>
+          Both endpoints of a slice are now allowed to be omitted for consistency, 
+          effectively creating a shallow copy of the list.
+        </li>
+        <li>
+          Additional tweaks and improvments to <tt>coffee --watch</tt> under 
+          Node's "new" file watching API. Watch will now beep by default 
+          if you introduce a syntax error into a watched script. We also now
+          ignore hidden directories by default when watching recursively.
+        </li>
+      </ul>
+    </p>
+    
    <p>
      <b class="header" style="margin-top: 20px;">
        <a href="https://github.com/jashkenas/coffee-script/compare/1.1.3...1.2.0">1.2.0</a>
@@ -2841,7 +2974,7 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="
    closeMenus = ->
      $('.navigation.active').removeClass 'active'

-    $('.minibutton.run').click evalJS
+    $('.minibutton.run').click -> evalJS()

    # Bind navigation buttons to open the menus.
    $('.navigation').click (e) ->
--- a/lib/coffee-script/browser.js
+++ b/lib/coffee-script/browser.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 (function() {
  var CoffeeScript, runScripts;

@@ -5,23 +6,36 @@

  CoffeeScript.require = require;

-  CoffeeScript.eval = function(code, options) {
+  CoffeeScript["eval"] = function(code, options) {
+    var _ref;
+    if (options == null) {
+      options = {};
+    }
+    if ((_ref = options.bare) == null) {
+      options.bare = true;
+    }
    return eval(CoffeeScript.compile(code, options));
  };

  CoffeeScript.run = function(code, options) {
-    if (options == null) options = {};
+    if (options == null) {
+      options = {};
+    }
    options.bare = true;
    return Function(CoffeeScript.compile(code, options))();
  };

-  if (typeof window === "undefined" || window === null) return;
+  if (typeof window === "undefined" || window === null) {
+    return;
+  }

  CoffeeScript.load = function(url, callback) {
    var xhr;
    xhr = new (window.ActiveXObject || XMLHttpRequest)('Microsoft.XMLHTTP');
    xhr.open('GET', url, true);
-    if ('overrideMimeType' in xhr) xhr.overrideMimeType('text/plain');
+    if ('overrideMimeType' in xhr) {
+      xhr.overrideMimeType('text/plain');
+    }
    xhr.onreadystatechange = function() {
      var _ref;
      if (xhr.readyState === 4) {
@@ -30,7 +44,9 @@
        } else {
          throw new Error("Could not load " + url);
        }
-        if (callback) return callback();
+        if (callback) {
+          return callback();
+        }
      }
    };
    return xhr.send(null);
@@ -44,7 +60,9 @@
      _results = [];
      for (_i = 0, _len = scripts.length; _i < _len; _i++) {
        s = scripts[_i];
-        if (s.type === 'text/coffeescript') _results.push(s);
+        if (s.type === 'text/coffeescript') {
+          _results.push(s);
+        }
      }
      return _results;
    })();
--- a/lib/coffee-script/cake.js
+++ b/lib/coffee-script/cake.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 (function() {
  var CoffeeScript, cakefileDirectory, fatalError, fs, helpers, missingTask, oparse, options, optparse, path, printTasks, switches, tasks;

@@ -35,7 +36,9 @@
      return switches.push([letter, flag, description]);
    },
    invoke: function(name) {
-      if (!tasks[name]) missingTask(name);
+      if (!tasks[name]) {
+        missingTask(name);
+      }
      return tasks[name].action(options);
    }
  });
@@ -49,13 +52,15 @@
      filename: 'Cakefile'
    });
    oparse = new optparse.OptionParser(switches);
-    if (!args.length) return printTasks();
+    if (!args.length) {
+      return printTasks();
+    }
    try {
      options = oparse.parse(args);
    } catch (e) {
      return fatalError("" + e);
    }
-    _ref = options.arguments;
+    _ref = options["arguments"];
    _results = [];
    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
      arg = _ref[_i];
@@ -65,8 +70,9 @@
  };

  printTasks = function() {
-    var cakefilePath, desc, name, spaces, task;
-    cakefilePath = path.join(path.relative(__originalDirname, process.cwd()), 'Cakefile');
+    var cakefilePath, desc, name, relative, spaces, task;
+    relative = path.relative || path.resolve;
+    cakefilePath = path.join(relative(__originalDirname, process.cwd()), 'Cakefile');
    console.log("" + cakefilePath + " defines the following tasks:\n");
    for (name in tasks) {
      task = tasks[name];
@@ -75,7 +81,9 @@
      desc = task.description ? "# " + task.description : '';
      console.log("cake " + name + spaces + " " + desc);
    }
-    if (switches.length) return console.log(oparse.help());
+    if (switches.length) {
+      return console.log(oparse.help());
+    }
  };

  fatalError = function(message) {
@@ -90,9 +98,13 @@

  cakefileDirectory = function(dir) {
    var parent;
-    if (path.existsSync(path.join(dir, 'Cakefile'))) return dir;
+    if (path.existsSync(path.join(dir, 'Cakefile'))) {
+      return dir;
+    }
    parent = path.normalize(path.join(dir, '..'));
-    if (parent !== dir) return cakefileDirectory(parent);
+    if (parent !== dir) {
+      return cakefileDirectory(parent);
+    }
    throw new Error("Cakefile not found in " + (process.cwd()));
  };

--- a/lib/coffee-script/coffee-script.js
+++ b/lib/coffee-script/coffee-script.js
@@ -1,6 +1,7 @@
+// Generated by CoffeeScript 1.3.3
 (function() {
  var Lexer, RESERVED, compile, fs, lexer, parser, path, vm, _ref,
-    __hasProp = Object.prototype.hasOwnProperty;
+    __hasProp = {}.hasOwnProperty;

  fs = require('fs');

@@ -26,24 +27,31 @@
    });
  }

-  exports.VERSION = '1.2.0';
+  exports.VERSION = '1.3.3';

  exports.RESERVED = RESERVED;

  exports.helpers = require('./helpers');

  exports.compile = compile = function(code, options) {
-    var merge;
-    if (options == null) options = {};
+    var header, js, merge;
+    if (options == null) {
+      options = {};
+    }
    merge = exports.helpers.merge;
    try {
-      return (parser.parse(lexer.tokenize(code))).compile(merge({}, options));
+      js = (parser.parse(lexer.tokenize(code))).compile(options);
+      if (!options.header) {
+        return js;
+      }
    } catch (err) {
      if (options.filename) {
        err.message = "In " + options.filename + ", " + err.message;
      }
      throw err;
    }
+    header = "Generated by CoffeeScript " + this.VERSION;
+    return "// " + header + "\n" + js;
  };

  exports.tokens = function(code, options) {
@@ -60,10 +68,13 @@

  exports.run = function(code, options) {
    var mainModule;
+    if (options == null) {
+      options = {};
+    }
    mainModule = require.main;
    mainModule.filename = process.argv[1] = options.filename ? fs.realpathSync(options.filename) : '.';
    mainModule.moduleCache && (mainModule.moduleCache = {});
-    mainModule.paths = require('module')._nodeModulePaths(path.dirname(options.filename));
+    mainModule.paths = require('module')._nodeModulePaths(path.dirname(fs.realpathSync(options.filename)));
    if (path.extname(mainModule.filename) !== '.coffee' || require.extensions) {
      return mainModule._compile(compile(code, options), mainModule.filename);
    } else {
@@ -71,10 +82,14 @@
    }
  };

-  exports.eval = function(code, options) {
-    var Module, Script, js, k, o, r, sandbox, v, _i, _len, _module, _ref2, _ref3, _require;
-    if (options == null) options = {};
-    if (!(code = code.trim())) return;
+  exports["eval"] = function(code, options) {
+    var Module, Script, js, k, o, r, sandbox, v, _i, _len, _module, _ref1, _ref2, _require;
+    if (options == null) {
+      options = {};
+    }
+    if (!(code = code.trim())) {
+      return;
+    }
    Script = vm.Script;
    if (Script) {
      if (options.sandbox != null) {
@@ -82,10 +97,10 @@
          sandbox = options.sandbox;
        } else {
          sandbox = Script.createContext();
-          _ref2 = options.sandbox;
-          for (k in _ref2) {
-            if (!__hasProp.call(_ref2, k)) continue;
-            v = _ref2[k];
+          _ref1 = options.sandbox;
+          for (k in _ref1) {
+            if (!__hasProp.call(_ref1, k)) continue;
+            v = _ref1[k];
            sandbox[k] = v;
          }
        }
@@ -102,10 +117,12 @@
          return Module._load(path, _module, true);
        };
        _module.filename = sandbox.__filename;
-        _ref3 = Object.getOwnPropertyNames(require);
-        for (_i = 0, _len = _ref3.length; _i < _len; _i++) {
-          r = _ref3[_i];
-          if (r !== 'paths') _require[r] = require[r];
+        _ref2 = Object.getOwnPropertyNames(require);
+        for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
+          r = _ref2[_i];
+          if (r !== 'paths') {
+            _require[r] = require[r];
+          }
        }
        _require.paths = _module.paths = Module._nodeModulePaths(process.cwd());
        _require.resolve = function(request) {
@@ -132,8 +149,8 @@

  parser.lexer = {
    lex: function() {
-      var tag, _ref2;
-      _ref2 = this.tokens[this.pos++] || [''], tag = _ref2[0], this.yytext = _ref2[1], this.yylineno = _ref2[2];
+      var tag, _ref1;
+      _ref1 = this.tokens[this.pos++] || [''], tag = _ref1[0], this.yytext = _ref1[1], this.yylineno = _ref1[2];
      return tag;
    },
    setInput: function(tokens) {
--- a/lib/coffee-script/command.js
+++ b/lib/coffee-script/command.js
@@ -1,5 +1,6 @@
+// Generated by CoffeeScript 1.3.3
 (function() {
-  var BANNER, CoffeeScript, EventEmitter, SWITCHES, compileJoin, compileOptions, compilePath, compileScript, compileStdio, exec, forkNode, fs, helpers, joinTimeout, lint, loadRequires, notSources, optionParser, optparse, opts, outputPath, parseOptions, path, printLine, printTokens, printWarn, removeSource, sourceCode, sources, spawn, timeLog, unwatchDir, usage, version, wait, watch, watchDir, watchers, writeJs, _ref;
+  var BANNER, CoffeeScript, EventEmitter, SWITCHES, compileJoin, compileOptions, compilePath, compileScript, compileStdio, exec, forkNode, fs, helpers, hidden, joinTimeout, lint, loadRequires, notSources, optionParser, optparse, opts, outputPath, parseOptions, path, printLine, printTokens, printWarn, removeSource, sourceCode, sources, spawn, timeLog, unwatchDir, usage, version, wait, watch, watchDir, watchers, writeJs, _ref;

  fs = require('fs');

@@ -25,7 +26,11 @@
    return process.stderr.write(line + '\n');
  };

-  BANNER = 'Usage: coffee [options] path/to/script.coffee\n\nIf called without options, `coffee` will run your script.';
+  hidden = function(file) {
+    return /^\.|~$/.test(file);
+  };
+
+  BANNER = 'Usage: coffee [options] path/to/script.coffee -- [args]\n\nIf called without options, `coffee` will run your script.';

  SWITCHES = [['-b', '--bare', 'compile without a top-level function wrapper'], ['-c', '--compile', 'compile to JavaScript and save as .js files'], ['-e', '--eval', 'pass a string from the command line as input'], ['-h', '--help', 'display this help message'], ['-i', '--interactive', 'run an interactive CoffeeScript REPL'], ['-j', '--join [FILE]', 'concatenate the source CoffeeScript before compiling'], ['-l', '--lint', 'pipe the compiled JavaScript through JavaScript Lint'], ['-n', '--nodes', 'print out the parse tree that the parser produces'], ['--nodejs [ARGS]', 'pass options directly to the "node" binary'], ['-o', '--output [DIR]', 'set the output directory for compiled JavaScript'], ['-p', '--print', 'print out the compiled JavaScript'], ['-r', '--require [FILE*]', 'require a library before executing your script'], ['-s', '--stdio', 'listen for and compile scripts over stdio'], ['-t', '--tokens', 'print out the tokens that the lexer/rewriter produce'], ['-v', '--version', 'display the version number'], ['-w', '--watch', 'watch scripts for changes and rerun commands']];

@@ -42,21 +47,37 @@
  optionParser = null;

  exports.run = function() {
-    var source, _i, _len, _results;
+    var literals, source, _i, _len, _results;
    parseOptions();
-    if (opts.nodejs) return forkNode();
-    if (opts.help) return usage();
-    if (opts.version) return version();
-    if (opts.require) loadRequires();
-    if (opts.interactive) return require('./repl');
-    if (opts.watch && !fs.watch) {
-      printWarn("The --watch feature depends on Node v0.6.0+. You are running " + process.version + ".");
+    if (opts.nodejs) {
+      return forkNode();
    }
-    if (opts.stdio) return compileStdio();
-    if (opts.eval) return compileScript(null, sources[0]);
-    if (!sources.length) return require('./repl');
-    if (opts.run) opts.literals = sources.splice(1).concat(opts.literals);
-    process.argv = process.argv.slice(0, 2).concat(opts.literals);
+    if (opts.help) {
+      return usage();
+    }
+    if (opts.version) {
+      return version();
+    }
+    if (opts.require) {
+      loadRequires();
+    }
+    if (opts.interactive) {
+      return require('./repl');
+    }
+    if (opts.watch && !fs.watch) {
+      return printWarn("The --watch feature depends on Node v0.6.0+. You are running " + process.version + ".");
+    }
+    if (opts.stdio) {
+      return compileStdio();
+    }
+    if (opts["eval"]) {
+      return compileScript(null, sources[0]);
+    }
+    if (!sources.length) {
+      return require('./repl');
+    }
+    literals = opts.run ? sources.splice(1) : [];
+    process.argv = process.argv.slice(0, 2).concat(literals);
    process.argv[0] = 'coffee';
    process.execPath = require.main.filename;
    _results = [];
@@ -69,7 +90,9 @@

  compilePath = function(source, topLevel, base) {
    return fs.stat(source, function(err, stats) {
-      if (err && err.code !== 'ENOENT') throw err;
+      if (err && err.code !== 'ENOENT') {
+        throw err;
+      }
      if ((err != null ? err.code : void 0) === 'ENOENT') {
        if (topLevel && source.slice(-7) !== '.coffee') {
          source = sources[sources.indexOf(source)] = "" + source + ".coffee";
@@ -82,31 +105,48 @@
        return;
      }
      if (stats.isDirectory()) {
-        if (opts.watch) watchDir(source, base);
+        if (opts.watch) {
+          watchDir(source, base);
+        }
        return fs.readdir(source, function(err, files) {
-          var file, index, _i, _len, _ref2, _results;
-          if (err && err.code !== 'ENOENT') throw err;
-          if ((err != null ? err.code : void 0) === 'ENOENT') return;
-          files = files.map(function(file) {
-            return path.join(source, file);
-          });
+          var file, index, _ref1, _ref2;
+          if (err && err.code !== 'ENOENT') {
+            throw err;
+          }
+          if ((err != null ? err.code : void 0) === 'ENOENT') {
+            return;
+          }
          index = sources.indexOf(source);
-          [].splice.apply(sources, [index, index - index + 1].concat(files)), files;
+          files = files.filter(function(file) {
+            return !hidden(file);
+          });
+          [].splice.apply(sources, [index, index - index + 1].concat(_ref1 = (function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = files.length; _i < _len; _i++) {
+              file = files[_i];
+              _results.push(path.join(source, file));
+            }
+            return _results;
+          })())), _ref1;
          [].splice.apply(sourceCode, [index, index - index + 1].concat(_ref2 = files.map(function() {
            return null;
          }))), _ref2;
-          _results = [];
-          for (_i = 0, _len = files.length; _i < _len; _i++) {
-            file = files[_i];
-            _results.push(compilePath(file, false, base));
-          }
-          return _results;
+          return files.forEach(function(file) {
+            return compilePath(path.join(source, file), false, base);
+          });
        });
      } else if (topLevel || path.extname(source) === '.coffee') {
-        if (opts.watch) watch(source, base);
+        if (opts.watch) {
+          watch(source, base);
+        }
        return fs.readFile(source, function(err, code) {
-          if (err && err.code !== 'ENOENT') throw err;
-          if ((err != null ? err.code : void 0) === 'ENOENT') return;
+          if (err && err.code !== 'ENOENT') {
+            throw err;
+          }
+          if ((err != null ? err.code : void 0) === 'ENOENT') {
+            return;
+          }
          return compileScript(source, code.toString(), base);
        });
      } else {
@@ -149,8 +189,12 @@
      }
    } catch (err) {
      CoffeeScript.emit('failure', err, task);
-      if (CoffeeScript.listeners('failure').length) return;
-      if (o.watch) return printLine(err.message);
+      if (CoffeeScript.listeners('failure').length) {
+        return;
+      }
+      if (o.watch) {
+        return printLine(err.message + '\x07');
+      }
      printWarn(err instanceof Error && err.stack || ("ERROR: " + err));
      return process.exit(1);
    }
@@ -161,7 +205,9 @@
    code = '';
    stdin = process.openStdin();
    stdin.on('data', function(buffer) {
-      if (buffer) return code += buffer.toString();
+      if (buffer) {
+        return code += buffer.toString();
+      }
    });
    return stdin.on('end', function() {
      return compileScript(null, code);
@@ -171,7 +217,9 @@
  joinTimeout = null;

  compileJoin = function() {
-    if (!opts.join) return;
+    if (!opts.join) {
+      return;
+    }
    if (!sourceCode.some(function(code) {
      return code === null;
    })) {
@@ -183,26 +231,33 @@
  };

  loadRequires = function() {
-    var realFilename, req, _i, _len, _ref2;
+    var realFilename, req, _i, _len, _ref1;
    realFilename = module.filename;
    module.filename = '.';
-    _ref2 = opts.require;
-    for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
-      req = _ref2[_i];
+    _ref1 = opts.require;
+    for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+      req = _ref1[_i];
      require(req);
    }
    return module.filename = realFilename;
  };

  watch = function(source, base) {
-    var callback, compile, compileTimeout, prevStats, watchErr, watcher;
+    var compile, compileTimeout, prevStats, rewatch, watchErr, watcher;
    prevStats = null;
    compileTimeout = null;
    watchErr = function(e) {
      if (e.code === 'ENOENT') {
-        if (sources.indexOf(source) === -1) return;
-        removeSource(source, base, true);
-        return compileJoin();
+        if (sources.indexOf(source) === -1) {
+          return;
+        }
+        try {
+          rewatch();
+          return compile();
+        } catch (e) {
+          removeSource(source, base, true);
+          return compileJoin();
+        }
      } else {
        throw e;
      }
@@ -211,42 +266,34 @@
      clearTimeout(compileTimeout);
      return compileTimeout = wait(25, function() {
        return fs.stat(source, function(err, stats) {
-          if (err) return watchErr(err);
-          if (prevStats && (stats.size === prevStats.size && stats.mtime.getTime() === prevStats.mtime.getTime())) {
-            return;
+          if (err) {
+            return watchErr(err);
+          }
+          if (prevStats && stats.size === prevStats.size && stats.mtime.getTime() === prevStats.mtime.getTime()) {
+            return rewatch();
          }
          prevStats = stats;
          return fs.readFile(source, function(err, code) {
-            if (err) return watchErr(err);
-            return compileScript(source, code.toString(), base);
+            if (err) {
+              return watchErr(err);
+            }
+            compileScript(source, code.toString(), base);
+            return rewatch();
          });
        });
      });
    };
-    watchErr = function(e) {
-      if (e.code !== 'ENOENT') throw e;
-      removeSource(source, base, true);
-      return compileJoin();
-    };
    try {
-      return watcher = fs.watch(source, callback = function(event) {
-        if (event === 'change') {
-          return compile();
-        } else if (event === 'rename') {
-          watcher.close();
-          return wait(250, function() {
-            compile();
-            try {
-              return watcher = fs.watch(source, callback);
-            } catch (e) {
-              return watchErr(e);
-            }
-          });
-        }
-      });
+      watcher = fs.watch(source, compile);
    } catch (e) {
-      return watchErr(e);
+      watchErr(e);
    }
+    return rewatch = function() {
+      if (watcher != null) {
+        watcher.close();
+      }
+      return watcher = fs.watch(source, compile);
+    };
  };

  watchDir = function(source, base) {
@@ -259,17 +306,19 @@
          return fs.readdir(source, function(err, files) {
            var file, _i, _len, _results;
            if (err) {
-              if (err.code !== 'ENOENT') throw err;
+              if (err.code !== 'ENOENT') {
+                throw err;
+              }
              watcher.close();
              return unwatchDir(source, base);
            }
-            files = files.map(function(file) {
-              return path.join(source, file);
-            });
            _results = [];
            for (_i = 0, _len = files.length; _i < _len; _i++) {
              file = files[_i];
-              if (!(!notSources[file])) continue;
+              if (!(!hidden(file) && !notSources[file])) {
+                continue;
+              }
+              file = path.join(source, file);
              if (sources.some(function(s) {
                return s.indexOf(file) >= 0;
              })) {
@@ -284,19 +333,23 @@
        });
      });
    } catch (e) {
-      if (e.code !== 'ENOENT') throw e;
+      if (e.code !== 'ENOENT') {
+        throw e;
+      }
    }
  };

  unwatchDir = function(source, base) {
    var file, prevSources, toRemove, _i, _len;
-    prevSources = sources.slice();
+    prevSources = sources.slice(0);
    toRemove = (function() {
      var _i, _len, _results;
      _results = [];
      for (_i = 0, _len = sources.length; _i < _len; _i++) {
        file = sources[_i];
-        if (file.indexOf(source) >= 0) _results.push(file);
+        if (file.indexOf(source) >= 0) {
+          _results.push(file);
+        }
      }
      return _results;
    })();
@@ -322,7 +375,9 @@
      return path.exists(jsPath, function(exists) {
        if (exists) {
          return fs.unlink(jsPath, function(err) {
-            if (err && err.code !== 'ENOENT') throw err;
+            if (err && err.code !== 'ENOENT') {
+              throw err;
+            }
            return timeLog("removed " + source);
          });
        }
@@ -344,7 +399,9 @@
    jsPath = outputPath(source, base);
    jsDir = path.dirname(jsPath);
    compile = function() {
-      if (js.length <= 0) js = ' ';
+      if (js.length <= 0) {
+        js = ' ';
+      }
      return fs.writeFile(jsPath, js, function(err) {
        if (err) {
          return printLine(err.message);
@@ -386,11 +443,11 @@
  printTokens = function(tokens) {
    var strings, tag, token, value;
    strings = (function() {
-      var _i, _len, _ref2, _results;
+      var _i, _len, _ref1, _results;
      _results = [];
      for (_i = 0, _len = tokens.length; _i < _len; _i++) {
        token = tokens[_i];
-        _ref2 = [token[0], token[1].toString().replace(/\n/, '\\n')], tag = _ref2[0], value = _ref2[1];
+        _ref1 = [token[0], token[1].toString().replace(/\n/, '\\n')], tag = _ref1[0], value = _ref1[1];
        _results.push("[" + tag + " " + value + "]");
      }
      return _results;
@@ -399,14 +456,14 @@
  };

  parseOptions = function() {
-    var i, o, source, _len;
+    var i, o, source, _i, _len;
    optionParser = new optparse.OptionParser(SWITCHES, BANNER);
    o = opts = optionParser.parse(process.argv.slice(2));
    o.compile || (o.compile = !!o.output);
    o.run = !(o.compile || o.print || o.lint);
-    o.print = !!(o.print || (o.eval || o.stdio && o.compile));
-    sources = o.arguments;
-    for (i = 0, _len = sources.length; i < _len; i++) {
+    o.print = !!(o.print || (o["eval"] || o.stdio && o.compile));
+    sources = o["arguments"];
+    for (i = _i = 0, _len = sources.length; _i < _len; i = ++_i) {
      source = sources[i];
      sourceCode[i] = null;
    }
@@ -415,7 +472,8 @@
  compileOptions = function(filename) {
    return {
      filename: filename,
-      bare: opts.bare
+      bare: opts.bare,
+      header: opts.compile
    };
  };

--- a/lib/coffee-script/grammar.js
+++ b/lib/coffee-script/grammar.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 (function() {
  var Parser, alt, alternatives, grammar, name, o, operators, token, tokens, unwrap;

@@ -8,7 +9,9 @@
  o = function(patternString, action, options) {
    var match;
    patternString = patternString.replace(/\s{2,}/g, ' ');
-    if (!action) return [patternString, '$$ = $1;', options];
+    if (!action) {
+      return [patternString, '$$ = $1;', options];
+    }
    action = (match = unwrap.exec(action)) ? match[1] : "(" + action + "())";
    action = action.replace(/\bnew /g, '$&yy.');
    action = action.replace(/\b(?:Block\.wrap|extend)\b/g, 'yy.$&');
@@ -61,11 +64,12 @@
        return new Literal($1);
      }), o('DEBUGGER', function() {
        return new Literal($1);
+      }), o('UNDEFINED', function() {
+        return new Undefined;
+      }), o('NULL', function() {
+        return new Null;
      }), o('BOOL', function() {
-        var val;
-        val = new Literal($1);
-        if ($1 === 'undefined') val.isUndefined = true;
-        return val;
+        return new Bool($1);
      })
    ],
    Assign: [
@@ -122,6 +126,10 @@
        return [$1];
      }), o('ParamList , Param', function() {
        return $1.concat($3);
+      }), o('ParamList OptComma TERMINATOR Param', function() {
+        return $1.concat($4);
+      }), o('ParamList OptComma INDENT ParamList OptComma OUTDENT', function() {
+        return $1.concat($4);
      })
    ],
    Param: [
@@ -291,6 +299,8 @@
        return new Range($1, null, $2);
      }), o('RangeDots Expression', function() {
        return new Range(null, $2, $1);
+      }), o('RangeDots', function() {
+        return new Range(null, null, $1);
      })
    ],
    ArgList: [
@@ -406,7 +416,7 @@
      })
    ],
    ForValue: [
-      o('Identifier'), o('Array', function() {
+      o('Identifier'), o('ThisProperty'), o('Array', function() {
        return new Value($1);
      }), o('Object', function() {
        return new Value($1);
@@ -559,23 +569,27 @@
    ]
  };

-  operators = [['left', '.', '?.', '::'], ['left', 'CALL_START', 'CALL_END'], ['nonassoc', '++', '--'], ['left', '?'], ['right', 'UNARY'], ['left', 'MATH'], ['left', '+', '-'], ['left', 'SHIFT'], ['left', 'RELATION'], ['left', 'COMPARE'], ['left', 'LOGIC'], ['nonassoc', 'INDENT', 'OUTDENT'], ['right', '=', ':', 'COMPOUND_ASSIGN', 'RETURN', 'THROW', 'EXTENDS'], ['right', 'FORIN', 'FOROF', 'BY', 'WHEN'], ['right', 'IF', 'ELSE', 'FOR', 'DO', 'WHILE', 'UNTIL', 'LOOP', 'SUPER', 'CLASS'], ['right', 'POST_IF']];
+  operators = [['left', '.', '?.', '::'], ['left', 'CALL_START', 'CALL_END'], ['nonassoc', '++', '--'], ['left', '?'], ['right', 'UNARY'], ['left', 'MATH'], ['left', '+', '-'], ['left', 'SHIFT'], ['left', 'RELATION'], ['left', 'COMPARE'], ['left', 'LOGIC'], ['nonassoc', 'INDENT', 'OUTDENT'], ['right', '=', ':', 'COMPOUND_ASSIGN', 'RETURN', 'THROW', 'EXTENDS'], ['right', 'FORIN', 'FOROF', 'BY', 'WHEN'], ['right', 'IF', 'ELSE', 'FOR', 'WHILE', 'UNTIL', 'LOOP', 'SUPER', 'CLASS'], ['right', 'POST_IF']];

  tokens = [];

  for (name in grammar) {
    alternatives = grammar[name];
    grammar[name] = (function() {
-      var _i, _j, _len, _len2, _ref, _results;
+      var _i, _j, _len, _len1, _ref, _results;
      _results = [];
      for (_i = 0, _len = alternatives.length; _i < _len; _i++) {
        alt = alternatives[_i];
        _ref = alt[0].split(' ');
-        for (_j = 0, _len2 = _ref.length; _j < _len2; _j++) {
+        for (_j = 0, _len1 = _ref.length; _j < _len1; _j++) {
          token = _ref[_j];
-          if (!grammar[token]) tokens.push(token);
+          if (!grammar[token]) {
+            tokens.push(token);
+          }
+        }
+        if (name === 'Root') {
+          alt[1] = "return " + alt[1];
        }
-        if (name === 'Root') alt[1] = "return " + alt[1];
        _results.push(alt);
      }
      return _results;
--- a/lib/coffee-script/helpers.js
+++ b/lib/coffee-script/helpers.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 (function() {
  var extend, flatten;

@@ -16,7 +17,9 @@
    _results = [];
    for (_i = 0, _len = array.length; _i < _len; _i++) {
      item = array[_i];
-      if (item) _results.push(item);
+      if (item) {
+        _results.push(item);
+      }
    }
    return _results;
  };
@@ -24,7 +27,9 @@
  exports.count = function(string, substr) {
    var num, pos;
    num = pos = 0;
-    if (!substr.length) return 1 / 0;
+    if (!substr.length) {
+      return 1 / 0;
+    }
    while (pos = 1 + string.indexOf(substr, pos)) {
      num++;
    }
--- a/lib/coffee-script/index.js
+++ b/lib/coffee-script/index.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 (function() {
  var key, val, _ref;

--- a/lib/coffee-script/lexer.js
+++ b/lib/coffee-script/lexer.js
@@ -1,10 +1,11 @@
+// Generated by CoffeeScript 1.3.3
 (function() {
-  var BOOL, CALLABLE, CODE, COFFEE_ALIASES, COFFEE_ALIAS_MAP, COFFEE_KEYWORDS, COMMENT, COMPARE, COMPOUND_ASSIGN, HEREDOC, HEREDOC_ILLEGAL, HEREDOC_INDENT, HEREGEX, HEREGEX_OMIT, IDENTIFIER, INDEXABLE, INVERSES, JSTOKEN, JS_FORBIDDEN, JS_KEYWORDS, LINE_BREAK, LINE_CONTINUER, LOGIC, Lexer, MATH, MULTILINER, MULTI_DENT, NOT_REGEX, NOT_SPACED_REGEX, NUMBER, OPERATOR, REGEX, RELATION, RESERVED, Rewriter, SHIFT, SIMPLESTR, TRAILING_SPACES, UNARY, WHITESPACE, compact, count, key, last, starts, _ref, _ref2,
-    __indexOf = Array.prototype.indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+  var BOOL, CALLABLE, CODE, COFFEE_ALIASES, COFFEE_ALIAS_MAP, COFFEE_KEYWORDS, COMMENT, COMPARE, COMPOUND_ASSIGN, HEREDOC, HEREDOC_ILLEGAL, HEREDOC_INDENT, HEREGEX, HEREGEX_OMIT, IDENTIFIER, INDEXABLE, INVERSES, JSTOKEN, JS_FORBIDDEN, JS_KEYWORDS, LINE_BREAK, LINE_CONTINUER, LOGIC, Lexer, MATH, MULTILINER, MULTI_DENT, NOT_REGEX, NOT_SPACED_REGEX, NUMBER, OPERATOR, REGEX, RELATION, RESERVED, Rewriter, SHIFT, SIMPLESTR, STRICT_PROSCRIBED, TRAILING_SPACES, UNARY, WHITESPACE, compact, count, key, last, starts, _ref, _ref1,
+    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };

  _ref = require('./rewriter'), Rewriter = _ref.Rewriter, INVERSES = _ref.INVERSES;

-  _ref2 = require('./helpers'), count = _ref2.count, starts = _ref2.starts, compact = _ref2.compact, last = _ref2.last;
+  _ref1 = require('./helpers'), count = _ref1.count, starts = _ref1.starts, compact = _ref1.compact, last = _ref1.last;

  exports.Lexer = Lexer = (function() {

@@ -12,8 +13,12 @@

    Lexer.prototype.tokenize = function(code, opts) {
      var i, tag;
-      if (opts == null) opts = {};
-      if (WHITESPACE.test(code)) code = "\n" + code;
+      if (opts == null) {
+        opts = {};
+      }
+      if (WHITESPACE.test(code)) {
+        code = "\n" + code;
+      }
      code = code.replace(/\r/g, '').replace(TRAILING_SPACES, '');
      this.code = code;
      this.line = opts.line || 0;
@@ -28,24 +33,30 @@
        i += this.identifierToken() || this.commentToken() || this.whitespaceToken() || this.lineToken() || this.heredocToken() || this.stringToken() || this.numberToken() || this.regexToken() || this.jsToken() || this.literalToken();
      }
      this.closeIndentation();
-      if (tag = this.ends.pop()) this.error("missing " + tag);
-      if (opts.rewrite === false) return this.tokens;
+      if (tag = this.ends.pop()) {
+        this.error("missing " + tag);
+      }
+      if (opts.rewrite === false) {
+        return this.tokens;
+      }
      return (new Rewriter).rewrite(this.tokens);
    };

    Lexer.prototype.identifierToken = function() {
-      var colon, forcedIdentifier, id, input, match, prev, tag, _ref3, _ref4;
-      if (!(match = IDENTIFIER.exec(this.chunk))) return 0;
+      var colon, forcedIdentifier, id, input, match, prev, tag, _ref2, _ref3;
+      if (!(match = IDENTIFIER.exec(this.chunk))) {
+        return 0;
+      }
      input = match[0], id = match[1], colon = match[2];
      if (id === 'own' && this.tag() === 'FOR') {
        this.token('OWN', id);
        return id.length;
      }
-      forcedIdentifier = colon || (prev = last(this.tokens)) && (((_ref3 = prev[0]) === '.' || _ref3 === '?.' || _ref3 === '::') || !prev.spaced && prev[0] === '@');
+      forcedIdentifier = colon || (prev = last(this.tokens)) && (((_ref2 = prev[0]) === '.' || _ref2 === '?.' || _ref2 === '::') || !prev.spaced && prev[0] === '@');
      tag = 'IDENTIFIER';
      if (!forcedIdentifier && (__indexOf.call(JS_KEYWORDS, id) >= 0 || __indexOf.call(COFFEE_KEYWORDS, id) >= 0)) {
        tag = id.toUpperCase();
-        if (tag === 'WHEN' && (_ref4 = this.tag(), __indexOf.call(LINE_BREAK, _ref4) >= 0)) {
+        if (tag === 'WHEN' && (_ref3 = this.tag(), __indexOf.call(LINE_BREAK, _ref3) >= 0)) {
          tag = 'LEADING_WHEN';
        } else if (tag === 'FOR') {
          this.seenFor = true;
@@ -66,7 +77,7 @@
          }
        }
      }
-      if (__indexOf.call(['eval', 'arguments'].concat(JS_FORBIDDEN), id) >= 0) {
+      if (__indexOf.call(JS_FORBIDDEN, id) >= 0) {
        if (forcedIdentifier) {
          tag = 'IDENTIFIER';
          id = new String(id);
@@ -76,7 +87,9 @@
        }
      }
      if (!forcedIdentifier) {
-        if (__indexOf.call(COFFEE_ALIASES, id) >= 0) id = COFFEE_ALIAS_MAP[id];
+        if (__indexOf.call(COFFEE_ALIASES, id) >= 0) {
+          id = COFFEE_ALIAS_MAP[id];
+        }
        tag = (function() {
          switch (id) {
            case '!':
@@ -89,8 +102,6 @@
              return 'LOGIC';
            case 'true':
            case 'false':
-            case 'null':
-            case 'undefined':
              return 'BOOL';
            case 'break':
            case 'continue':
@@ -101,31 +112,51 @@
        })();
      }
      this.token(tag, id);
-      if (colon) this.token(':', ':');
+      if (colon) {
+        this.token(':', ':');
+      }
      return input.length;
    };

    Lexer.prototype.numberToken = function() {
-      var binaryLiteral, lexedLength, match, number;
-      if (!(match = NUMBER.exec(this.chunk))) return 0;
+      var binaryLiteral, lexedLength, match, number, octalLiteral;
+      if (!(match = NUMBER.exec(this.chunk))) {
+        return 0;
+      }
      number = match[0];
+      if (/^0[BOX]/.test(number)) {
+        this.error("radix prefix '" + number + "' must be lowercase");
+      } else if (/E/.test(number) && !/^0x/.test(number)) {
+        this.error("exponential notation '" + number + "' must be indicated with a lowercase 'e'");
+      } else if (/^0\d*[89]/.test(number)) {
+        this.error("decimal literal '" + number + "' must not be prefixed with '0'");
+      } else if (/^0\d+/.test(number)) {
+        this.error("octal literal '" + number + "' must be prefixed with '0o'");
+      }
      lexedLength = number.length;
-      if (binaryLiteral = /0b([01]+)/.exec(number)) {
-        number = (parseInt(binaryLiteral[1], 2)).toString();
+      if (octalLiteral = /^0o([0-7]+)/.exec(number)) {
+        number = '0x' + (parseInt(octalLiteral[1], 8)).toString(16);
+      }
+      if (binaryLiteral = /^0b([01]+)/.exec(number)) {
+        number = '0x' + (parseInt(binaryLiteral[1], 2)).toString(16);
      }
      this.token('NUMBER', number);
      return lexedLength;
    };

    Lexer.prototype.stringToken = function() {
-      var match, string;
+      var match, octalEsc, string;
      switch (this.chunk.charAt(0)) {
        case "'":
-          if (!(match = SIMPLESTR.exec(this.chunk))) return 0;
+          if (!(match = SIMPLESTR.exec(this.chunk))) {
+            return 0;
+          }
          this.token('STRING', (string = match[0]).replace(MULTILINER, '\\\n'));
          break;
        case '"':
-          if (!(string = this.balancedString(this.chunk, '"'))) return 0;
+          if (!(string = this.balancedString(this.chunk, '"'))) {
+            return 0;
+          }
          if (0 < string.indexOf('#{', 1)) {
            this.interpolateString(string.slice(1, -1));
          } else {
@@ -135,13 +166,18 @@
        default:
          return 0;
      }
+      if (octalEsc = /^(?:\\.|[^\\])*\\(?:0[0-7]|[1-7])/.test(string)) {
+        this.error("octal escape sequences " + string + " are not allowed");
+      }
      this.line += count(string, '\n');
      return string.length;
    };

    Lexer.prototype.heredocToken = function() {
      var doc, heredoc, match, quote;
-      if (!(match = HEREDOC.exec(this.chunk))) return 0;
+      if (!(match = HEREDOC.exec(this.chunk))) {
+        return 0;
+      }
      heredoc = match[0];
      quote = heredoc.charAt(0);
      doc = this.sanitizeHeredoc(match[2], {
@@ -161,14 +197,15 @@

    Lexer.prototype.commentToken = function() {
      var comment, here, match;
-      if (!(match = this.chunk.match(COMMENT))) return 0;
+      if (!(match = this.chunk.match(COMMENT))) {
+        return 0;
+      }
      comment = match[0], here = match[1];
      if (here) {
        this.token('HERECOMMENT', this.sanitizeHeredoc(here, {
          herecomment: true,
          indent: Array(this.indent + 1).join(' ')
        }));
-        this.token('TERMINATOR', '\n');
      }
      this.line += count(comment, '\n');
      return comment.length;
@@ -184,29 +221,35 @@
    };

    Lexer.prototype.regexToken = function() {
-      var flags, length, match, prev, regex, _ref3, _ref4;
-      if (this.chunk.charAt(0) !== '/') return 0;
+      var flags, length, match, prev, regex, _ref2, _ref3;
+      if (this.chunk.charAt(0) !== '/') {
+        return 0;
+      }
      if (match = HEREGEX.exec(this.chunk)) {
        length = this.heregexToken(match);
        this.line += count(match[0], '\n');
        return length;
      }
      prev = last(this.tokens);
-      if (prev && (_ref3 = prev[0], __indexOf.call((prev.spaced ? NOT_REGEX : NOT_SPACED_REGEX), _ref3) >= 0)) {
+      if (prev && (_ref2 = prev[0], __indexOf.call((prev.spaced ? NOT_REGEX : NOT_SPACED_REGEX), _ref2) >= 0)) {
        return 0;
      }
-      if (!(match = REGEX.exec(this.chunk))) return 0;
-      _ref4 = match, match = _ref4[0], regex = _ref4[1], flags = _ref4[2];
+      if (!(match = REGEX.exec(this.chunk))) {
+        return 0;
+      }
+      _ref3 = match, match = _ref3[0], regex = _ref3[1], flags = _ref3[2];
      if (regex.slice(0, 2) === '/*') {
        this.error('regular expressions cannot begin with `*`');
      }
-      if (regex === '//') regex = '/(?:)/';
+      if (regex === '//') {
+        regex = '/(?:)/';
+      }
      this.token('REGEX', "" + regex + flags);
      return match.length;
    };

    Lexer.prototype.heregexToken = function(match) {
-      var body, flags, heregex, re, tag, tokens, value, _i, _len, _ref3, _ref4, _ref5, _ref6;
+      var body, flags, heregex, re, tag, tokens, value, _i, _len, _ref2, _ref3, _ref4, _ref5;
      heregex = match[0], body = match[1], flags = match[2];
      if (0 > body.indexOf('#{')) {
        re = body.replace(HEREGEX_OMIT, '').replace(/\//g, '\\/');
@@ -219,33 +262,39 @@
      this.token('IDENTIFIER', 'RegExp');
      this.tokens.push(['CALL_START', '(']);
      tokens = [];
-      _ref3 = this.interpolateString(body, {
+      _ref2 = this.interpolateString(body, {
        regex: true
      });
-      for (_i = 0, _len = _ref3.length; _i < _len; _i++) {
-        _ref4 = _ref3[_i], tag = _ref4[0], value = _ref4[1];
+      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
+        _ref3 = _ref2[_i], tag = _ref3[0], value = _ref3[1];
        if (tag === 'TOKENS') {
          tokens.push.apply(tokens, value);
        } else {
-          if (!(value = value.replace(HEREGEX_OMIT, ''))) continue;
+          if (!(value = value.replace(HEREGEX_OMIT, ''))) {
+            continue;
+          }
          value = value.replace(/\\/g, '\\\\');
          tokens.push(['STRING', this.makeString(value, '"', true)]);
        }
        tokens.push(['+', '+']);
      }
      tokens.pop();
-      if (((_ref5 = tokens[0]) != null ? _ref5[0] : void 0) !== 'STRING') {
+      if (((_ref4 = tokens[0]) != null ? _ref4[0] : void 0) !== 'STRING') {
        this.tokens.push(['STRING', '""'], ['+', '+']);
      }
-      (_ref6 = this.tokens).push.apply(_ref6, tokens);
-      if (flags) this.tokens.push([',', ','], ['STRING', '"' + flags + '"']);
+      (_ref5 = this.tokens).push.apply(_ref5, tokens);
+      if (flags) {
+        this.tokens.push([',', ','], ['STRING', '"' + flags + '"']);
+      }
      this.token(')', ')');
      return heregex.length;
    };

    Lexer.prototype.lineToken = function() {
      var diff, indent, match, noNewlines, prev, size;
-      if (!(match = MULTI_DENT.exec(this.chunk))) return 0;
+      if (!(match = MULTI_DENT.exec(this.chunk))) {
+        return 0;
+      }
      indent = match[0];
      this.line += count(indent, '\n');
      this.seenFor = false;
@@ -299,7 +348,9 @@
          this.token('OUTDENT', dent);
        }
      }
-      if (dent) this.outdebt -= moveOut;
+      if (dent) {
+        this.outdebt -= moveOut;
+      }
      while (this.value() === ';') {
        this.tokens.pop();
      }
@@ -315,7 +366,9 @@
        return 0;
      }
      prev = last(this.tokens);
-      if (prev) prev[match ? 'spaced' : 'newLine'] = true;
+      if (prev) {
+        prev[match ? 'spaced' : 'newLine'] = true;
+      }
      if (match) {
        return match[0].length;
      } else {
@@ -327,30 +380,36 @@
      while (this.value() === ';') {
        this.tokens.pop();
      }
-      if (this.tag() !== 'TERMINATOR') this.token('TERMINATOR', '\n');
+      if (this.tag() !== 'TERMINATOR') {
+        this.token('TERMINATOR', '\n');
+      }
      return this;
    };

    Lexer.prototype.suppressNewlines = function() {
-      if (this.value() === '\\') this.tokens.pop();
+      if (this.value() === '\\') {
+        this.tokens.pop();
+      }
      return this;
    };

    Lexer.prototype.literalToken = function() {
-      var match, prev, tag, value, _ref3, _ref4, _ref5, _ref6;
+      var match, prev, tag, value, _ref2, _ref3, _ref4, _ref5;
      if (match = OPERATOR.exec(this.chunk)) {
        value = match[0];
-        if (CODE.test(value)) this.tagParameters();
+        if (CODE.test(value)) {
+          this.tagParameters();
+        }
      } else {
        value = this.chunk.charAt(0);
      }
      tag = value;
      prev = last(this.tokens);
      if (value === '=' && prev) {
-        if (!prev[1].reserved && (_ref3 = prev[1], __indexOf.call(JS_FORBIDDEN, _ref3) >= 0)) {
+        if (!prev[1].reserved && (_ref2 = prev[1], __indexOf.call(JS_FORBIDDEN, _ref2) >= 0)) {
          this.error("reserved word \"" + (this.value()) + "\" can't be assigned");
        }
-        if ((_ref4 = prev[1]) === '||' || _ref4 === '&&') {
+        if ((_ref3 = prev[1]) === '||' || _ref3 === '&&') {
          prev[0] = 'COMPOUND_ASSIGN';
          prev[1] += '=';
          return value.length;
@@ -372,10 +431,12 @@
      } else if (__indexOf.call(LOGIC, value) >= 0 || value === '?' && (prev != null ? prev.spaced : void 0)) {
        tag = 'LOGIC';
      } else if (prev && !prev.spaced) {
-        if (value === '(' && (_ref5 = prev[0], __indexOf.call(CALLABLE, _ref5) >= 0)) {
-          if (prev[0] === '?') prev[0] = 'FUNC_EXIST';
+        if (value === '(' && (_ref4 = prev[0], __indexOf.call(CALLABLE, _ref4) >= 0)) {
+          if (prev[0] === '?') {
+            prev[0] = 'FUNC_EXIST';
+          }
          tag = 'CALL_START';
-        } else if (value === '[' && (_ref6 = prev[0], __indexOf.call(INDEXABLE, _ref6) >= 0)) {
+        } else if (value === '[' && (_ref5 = prev[0], __indexOf.call(INDEXABLE, _ref5) >= 0)) {
          tag = 'INDEX_START';
          switch (prev[0]) {
            case '?':
@@ -399,29 +460,37 @@
    };

    Lexer.prototype.sanitizeHeredoc = function(doc, options) {
-      var attempt, herecomment, indent, match, _ref3;
+      var attempt, herecomment, indent, match, _ref2;
      indent = options.indent, herecomment = options.herecomment;
      if (herecomment) {
        if (HEREDOC_ILLEGAL.test(doc)) {
          this.error("block comment cannot contain \"*/\", starting");
        }
-        if (doc.indexOf('\n') <= 0) return doc;
+        if (doc.indexOf('\n') <= 0) {
+          return doc;
+        }
      } else {
        while (match = HEREDOC_INDENT.exec(doc)) {
          attempt = match[1];
-          if (indent === null || (0 < (_ref3 = attempt.length) && _ref3 < indent.length)) {
+          if (indent === null || (0 < (_ref2 = attempt.length) && _ref2 < indent.length)) {
            indent = attempt;
          }
        }
      }
-      if (indent) doc = doc.replace(RegExp("\\n" + indent, "g"), '\n');
-      if (!herecomment) doc = doc.replace(/^\n/, '');
+      if (indent) {
+        doc = doc.replace(RegExp("\\n" + indent, "g"), '\n');
+      }
+      if (!herecomment) {
+        doc = doc.replace(/^\n/, '');
+      }
      return doc;
    };

    Lexer.prototype.tagParameters = function() {
      var i, stack, tok, tokens;
-      if (this.tag() !== ')') return this;
+      if (this.tag() !== ')') {
+        return this;
+      }
      stack = [];
      tokens = this.tokens;
      i = tokens.length;
@@ -451,23 +520,30 @@
    };

    Lexer.prototype.balancedString = function(str, end) {
-      var i, letter, match, prev, stack, _ref3;
+      var continueCount, i, letter, match, prev, stack, _i, _ref2;
+      continueCount = 0;
      stack = [end];
-      for (i = 1, _ref3 = str.length; 1 <= _ref3 ? i < _ref3 : i > _ref3; 1 <= _ref3 ? i++ : i--) {
+      for (i = _i = 1, _ref2 = str.length; 1 <= _ref2 ? _i < _ref2 : _i > _ref2; i = 1 <= _ref2 ? ++_i : --_i) {
+        if (continueCount) {
+          --continueCount;
+          continue;
+        }
        switch (letter = str.charAt(i)) {
          case '\\':
-            i++;
+            ++continueCount;
            continue;
          case end:
            stack.pop();
-            if (!stack.length) return str.slice(0, i + 1);
+            if (!stack.length) {
+              return str.slice(0, i + 1 || 9e9);
+            }
            end = stack[stack.length - 1];
            continue;
        }
        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;
+          continueCount += match[0].length - 1;
        } else if (end === '}' && letter === '{') {
          stack.push(end = '}');
        } else if (end === '"' && prev === '#' && letter === '{') {
@@ -479,8 +555,10 @@
    };

    Lexer.prototype.interpolateString = function(str, options) {
-      var expr, heredoc, i, inner, interpolated, len, letter, nested, pi, regex, tag, tokens, value, _len, _ref3, _ref4, _ref5;
-      if (options == null) options = {};
+      var expr, heredoc, i, inner, interpolated, len, letter, nested, pi, regex, tag, tokens, value, _i, _len, _ref2, _ref3, _ref4;
+      if (options == null) {
+        options = {};
+      }
      heredoc = options.heredoc, regex = options.regex;
      tokens = [];
      pi = 0;
@@ -493,7 +571,9 @@
        if (!(letter === '#' && str.charAt(i + 1) === '{' && (expr = this.balancedString(str.slice(i + 1), '}')))) {
          continue;
        }
-        if (pi < i) tokens.push(['NEOSTRING', str.slice(pi, i)]);
+        if (pi < i) {
+          tokens.push(['NEOSTRING', str.slice(pi, i)]);
+        }
        inner = expr.slice(1, -1);
        if (inner.length) {
          nested = new Lexer().tokenize(inner, {
@@ -501,7 +581,7 @@
            rewrite: false
          });
          nested.pop();
-          if (((_ref3 = nested[0]) != null ? _ref3[0] : void 0) === 'TERMINATOR') {
+          if (((_ref2 = nested[0]) != null ? _ref2[0] : void 0) === 'TERMINATOR') {
            nested.shift();
          }
          if (len = nested.length) {
@@ -515,28 +595,44 @@
        i += expr.length;
        pi = i + 1;
      }
-      if ((i > pi && pi < str.length)) tokens.push(['NEOSTRING', str.slice(pi)]);
-      if (regex) return tokens;
-      if (!tokens.length) return this.token('STRING', '""');
-      if (tokens[0][0] !== 'NEOSTRING') tokens.unshift(['', '']);
-      if (interpolated = tokens.length > 1) this.token('(', '(');
-      for (i = 0, _len = tokens.length; i < _len; i++) {
-        _ref4 = tokens[i], tag = _ref4[0], value = _ref4[1];
-        if (i) this.token('+', '+');
+      if ((i > pi && pi < str.length)) {
+        tokens.push(['NEOSTRING', str.slice(pi)]);
+      }
+      if (regex) {
+        return tokens;
+      }
+      if (!tokens.length) {
+        return this.token('STRING', '""');
+      }
+      if (tokens[0][0] !== 'NEOSTRING') {
+        tokens.unshift(['', '']);
+      }
+      if (interpolated = tokens.length > 1) {
+        this.token('(', '(');
+      }
+      for (i = _i = 0, _len = tokens.length; _i < _len; i = ++_i) {
+        _ref3 = tokens[i], tag = _ref3[0], value = _ref3[1];
+        if (i) {
+          this.token('+', '+');
+        }
        if (tag === 'TOKENS') {
-          (_ref5 = this.tokens).push.apply(_ref5, value);
+          (_ref4 = this.tokens).push.apply(_ref4, value);
        } else {
          this.token('STRING', this.makeString(value, '"', heredoc));
        }
      }
-      if (interpolated) this.token(')', ')');
+      if (interpolated) {
+        this.token(')', ')');
+      }
      return tokens;
    };

    Lexer.prototype.pair = function(tag) {
      var size, wanted;
      if (tag !== (wanted = last(this.ends))) {
-        if ('OUTDENT' !== wanted) this.error("unmatched " + tag);
+        if ('OUTDENT' !== wanted) {
+          this.error("unmatched " + tag);
+        }
        this.indent -= size = last(this.indents);
        this.outdentToken(size, true);
        return this.pair(tag);
@@ -559,8 +655,8 @@
    };

    Lexer.prototype.unfinished = function() {
-      var _ref3;
-      return LINE_CONTINUER.test(this.chunk) || ((_ref3 = this.tag()) === '\\' || _ref3 === '.' || _ref3 === '?.' || _ref3 === 'UNARY' || _ref3 === 'MATH' || _ref3 === '+' || _ref3 === '-' || _ref3 === 'SHIFT' || _ref3 === 'RELATION' || _ref3 === 'COMPARE' || _ref3 === 'LOGIC' || _ref3 === 'COMPOUND_ASSIGN' || _ref3 === 'THROW' || _ref3 === 'EXTENDS');
+      var _ref2;
+      return LINE_CONTINUER.test(this.chunk) || ((_ref2 = this.tag()) === '\\' || _ref2 === '.' || _ref2 === '?.' || _ref2 === 'UNARY' || _ref2 === 'MATH' || _ref2 === '+' || _ref2 === '-' || _ref2 === 'SHIFT' || _ref2 === 'RELATION' || _ref2 === 'COMPARE' || _ref2 === 'LOGIC' || _ref2 === 'THROW' || _ref2 === 'EXTENDS');
    };

    Lexer.prototype.escapeLines = function(str, heredoc) {
@@ -568,7 +664,9 @@
    };

    Lexer.prototype.makeString = function(body, quote, heredoc) {
-      if (!body) return quote + quote;
+      if (!body) {
+        return quote + quote;
+      }
      body = body.replace(/\\([\s\S])/g, function(match, contents) {
        if (contents === '\n' || contents === quote) {
          return contents;
@@ -615,15 +713,19 @@

  COFFEE_KEYWORDS = COFFEE_KEYWORDS.concat(COFFEE_ALIASES);

-  RESERVED = ['case', 'default', 'function', 'var', 'void', 'with', 'const', 'let', 'enum', 'export', 'import', 'native', '__hasProp', '__extends', '__slice', '__bind', '__indexOf'];
+  RESERVED = ['case', 'default', 'function', 'var', 'void', 'with', 'const', 'let', 'enum', 'export', 'import', 'native', '__hasProp', '__extends', '__slice', '__bind', '__indexOf', 'implements', 'interface', 'let', 'package', 'private', 'protected', 'public', 'static', 'yield'];

-  JS_FORBIDDEN = JS_KEYWORDS.concat(RESERVED);
+  STRICT_PROSCRIBED = ['arguments', 'eval'];

-  exports.RESERVED = RESERVED.concat(JS_KEYWORDS).concat(COFFEE_KEYWORDS);
+  JS_FORBIDDEN = JS_KEYWORDS.concat(RESERVED).concat(STRICT_PROSCRIBED);
+
+  exports.RESERVED = RESERVED.concat(JS_KEYWORDS).concat(COFFEE_KEYWORDS).concat(STRICT_PROSCRIBED);
+
+  exports.STRICT_PROSCRIBED = STRICT_PROSCRIBED;

  IDENTIFIER = /^([$A-Za-z_\x7f-\uffff][$\w\x7f-\uffff]*)([^\n\S]*:(?!:))?/;

-  NUMBER = /^0x[\da-f]+|^0b[01]+|^\d*\.?\d+(?:e[+-]?\d+)?/i;
+  NUMBER = /^0b[01]+|^0o[0-7]+|^0x[\da-f]+|^\d*\.?\d+(?:e[+-]?\d+)?/i;

  HEREDOC = /^("""|''')([\s\S]*?)(?:\n[^\n\S]*)?\1/;

@@ -671,15 +773,15 @@

  RELATION = ['IN', 'OF', 'INSTANCEOF'];

-  BOOL = ['TRUE', 'FALSE', 'NULL', 'UNDEFINED'];
+  BOOL = ['TRUE', 'FALSE'];

-  NOT_REGEX = ['NUMBER', 'REGEX', 'BOOL', '++', '--', ']'];
+  NOT_REGEX = ['NUMBER', 'REGEX', 'BOOL', 'NULL', 'UNDEFINED', '++', '--', ']'];

  NOT_SPACED_REGEX = NOT_REGEX.concat(')', '}', 'THIS', 'IDENTIFIER', 'STRING');

  CALLABLE = ['IDENTIFIER', 'STRING', 'REGEX', ')', ']', '}', '?', '::', '@', 'THIS', 'SUPER'];

-  INDEXABLE = CALLABLE.concat('NUMBER', 'BOOL');
+  INDEXABLE = CALLABLE.concat('NUMBER', 'BOOL', 'NULL', 'UNDEFINED');

  LINE_BREAK = ['INDENT', 'OUTDENT', 'TERMINATOR'];

--- a/lib/coffee-script/nodes.js
+++ b/lib/coffee-script/nodes.js
--- a/lib/coffee-script/optparse.js
+++ b/lib/coffee-script/optparse.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 (function() {
  var LONG_FLAG, MULTI_FLAG, OPTIONAL, OptionParser, SHORT_FLAG, buildRule, buildRules, normalizeArguments;

@@ -9,39 +10,48 @@
    }

    OptionParser.prototype.parse = function(args) {
-      var arg, i, isOption, matchedRule, options, originalArgs, pos, rule, value, _i, _len, _len2, _ref;
+      var arg, i, isOption, matchedRule, options, originalArgs, pos, rule, seenNonOptionArg, skippingArgument, value, _i, _j, _len, _len1, _ref;
      options = {
-        arguments: [],
-        literals: []
+        "arguments": []
      };
+      skippingArgument = false;
      originalArgs = args;
      args = normalizeArguments(args);
-      for (i = 0, _len = args.length; i < _len; i++) {
+      for (i = _i = 0, _len = args.length; _i < _len; i = ++_i) {
        arg = args[i];
+        if (skippingArgument) {
+          skippingArgument = false;
+          continue;
+        }
        if (arg === '--') {
          pos = originalArgs.indexOf('--');
-          options.arguments = [originalArgs[1 + pos]];
-          options.literals = originalArgs.slice(2 + pos);
+          options["arguments"] = options["arguments"].concat(originalArgs.slice(pos + 1));
          break;
        }
        isOption = !!(arg.match(LONG_FLAG) || arg.match(SHORT_FLAG));
-        matchedRule = false;
-        _ref = this.rules;
-        for (_i = 0, _len2 = _ref.length; _i < _len2; _i++) {
-          rule = _ref[_i];
-          if (rule.shortFlag === arg || rule.longFlag === arg) {
-            value = rule.hasArgument ? args[i += 1] : true;
-            options[rule.name] = rule.isList ? (options[rule.name] || []).concat(value) : value;
-            matchedRule = true;
-            break;
+        seenNonOptionArg = options["arguments"].length > 0;
+        if (!seenNonOptionArg) {
+          matchedRule = false;
+          _ref = this.rules;
+          for (_j = 0, _len1 = _ref.length; _j < _len1; _j++) {
+            rule = _ref[_j];
+            if (rule.shortFlag === arg || rule.longFlag === arg) {
+              value = true;
+              if (rule.hasArgument) {
+                skippingArgument = true;
+                value = args[i + 1];
+              }
+              options[rule.name] = rule.isList ? (options[rule.name] || []).concat(value) : value;
+              matchedRule = true;
+              break;
+            }
+          }
+          if (isOption && !matchedRule) {
+            throw new Error("unrecognized option: " + arg);
          }
        }
-        if (isOption && !matchedRule) {
-          throw new Error("unrecognized option: " + arg);
-        }
-        if (!isOption) {
-          options.arguments = originalArgs.slice(originalArgs.indexOf(arg));
-          break;
+        if (seenNonOptionArg || !isOption) {
+          options["arguments"].push(arg);
        }
      }
      return options;
@@ -50,7 +60,9 @@
    OptionParser.prototype.help = function() {
      var letPart, lines, rule, spaces, _i, _len, _ref;
      lines = [];
-      if (this.banner) lines.unshift("" + this.banner + "\n");
+      if (this.banner) {
+        lines.unshift("" + this.banner + "\n");
+      }
      _ref = this.rules;
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        rule = _ref[_i];
@@ -66,9 +78,9 @@

  })();

-  LONG_FLAG = /^(--\w[\w\-]+)/;
+  LONG_FLAG = /^(--\w[\w\-]*)/;

-  SHORT_FLAG = /^(-\w)/;
+  SHORT_FLAG = /^(-\w)$/;

  MULTI_FLAG = /^-(\w{2,})/;

@@ -79,7 +91,9 @@
    _results = [];
    for (_i = 0, _len = rules.length; _i < _len; _i++) {
      tuple = rules[_i];
-      if (tuple.length < 3) tuple.unshift(null);
+      if (tuple.length < 3) {
+        tuple.unshift(null);
+      }
      _results.push(buildRule.apply(null, tuple));
    }
    return _results;
@@ -87,7 +101,9 @@

  buildRule = function(shortFlag, longFlag, description, options) {
    var match;
-    if (options == null) options = {};
+    if (options == null) {
+      options = {};
+    }
    match = longFlag.match(OPTIONAL);
    longFlag = longFlag.match(LONG_FLAG)[1];
    return {
@@ -101,14 +117,14 @@
  };

  normalizeArguments = function(args) {
-    var arg, l, match, result, _i, _j, _len, _len2, _ref;
+    var arg, l, match, result, _i, _j, _len, _len1, _ref;
    args = args.slice(0);
    result = [];
    for (_i = 0, _len = args.length; _i < _len; _i++) {
      arg = args[_i];
      if (match = arg.match(MULTI_FLAG)) {
        _ref = match[1].split('');
-        for (_j = 0, _len2 = _ref.length; _j < _len2; _j++) {
+        for (_j = 0, _len1 = _ref.length; _j < _len1; _j++) {
          l = _ref[_j];
          result.push('-' + l);
        }
--- a/lib/coffee-script/parser.js
+++ b/lib/coffee-script/parser.js
--- a/lib/coffee-script/repl.js
+++ b/lib/coffee-script/repl.js
@@ -1,5 +1,10 @@
+// Generated by CoffeeScript 1.3.3
 (function() {
-  var ACCESSOR, CoffeeScript, Module, REPL_PROMPT, REPL_PROMPT_CONTINUATION, SIMPLEVAR, Script, autocomplete, backlog, completeAttribute, completeVariable, enableColours, error, getCompletions, inspect, readline, repl, run, stdin, stdout;
+  var ACCESSOR, CoffeeScript, Module, REPL_PROMPT, REPL_PROMPT_CONTINUATION, REPL_PROMPT_MULTILINE, SIMPLEVAR, Script, autocomplete, backlog, completeAttribute, completeVariable, enableColours, error, getCompletions, inspect, multilineMode, pipedInput, readline, repl, run, stdin, stdout;
+
+  stdin = process.openStdin();
+
+  stdout = process.stdout;

  CoffeeScript = require('./coffee-script');

@@ -13,6 +18,8 @@

  REPL_PROMPT = 'coffee> ';

+  REPL_PROMPT_MULTILINE = '------> ';
+
  REPL_PROMPT_CONTINUATION = '......> ';

  enableColours = false;
@@ -21,18 +28,91 @@
    enableColours = !process.env.NODE_DISABLE_COLORS;
  }

-  stdin = process.openStdin();
-
-  stdout = process.stdout;
-
  error = function(err) {
    return stdout.write((err.stack || err.toString()) + '\n');
  };

+  ACCESSOR = /\s*([\w\.]+)(?:\.(\w*))$/;
+
+  SIMPLEVAR = /(\w+)$/i;
+
+  autocomplete = function(text) {
+    return completeAttribute(text) || completeVariable(text) || [[], text];
+  };
+
+  completeAttribute = function(text) {
+    var all, completions, key, match, obj, possibilities, prefix, val;
+    if (match = text.match(ACCESSOR)) {
+      all = match[0], obj = match[1], prefix = match[2];
+      try {
+        val = Script.runInThisContext(obj);
+      } catch (error) {
+        return;
+      }
+      val = Object(val);
+      possibilities = Object.getOwnPropertyNames(val);
+      for (key in val) {
+        if (~possibilities.indexOf(val)) {
+          possibilities.push(key);
+        }
+      }
+      completions = getCompletions(prefix, possibilities);
+      return [completions, prefix];
+    }
+  };
+
+  completeVariable = function(text) {
+    var completions, free, keywords, possibilities, r, vars, _ref;
+    free = (_ref = text.match(SIMPLEVAR)) != null ? _ref[1] : void 0;
+    if (text === "") {
+      free = "";
+    }
+    if (free != null) {
+      vars = Script.runInThisContext('Object.getOwnPropertyNames(Object(this))');
+      keywords = (function() {
+        var _i, _len, _ref1, _results;
+        _ref1 = CoffeeScript.RESERVED;
+        _results = [];
+        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+          r = _ref1[_i];
+          if (r.slice(0, 2) !== '__') {
+            _results.push(r);
+          }
+        }
+        return _results;
+      })();
+      possibilities = vars.concat(keywords);
+      completions = getCompletions(free, possibilities);
+      return [completions, free];
+    }
+  };
+
+  getCompletions = function(prefix, candidates) {
+    var el, _i, _len, _results;
+    _results = [];
+    for (_i = 0, _len = candidates.length; _i < _len; _i++) {
+      el = candidates[_i];
+      if (el.indexOf(prefix) === 0) {
+        _results.push(el);
+      }
+    }
+    return _results;
+  };
+
+  process.on('uncaughtException', error);
+
  backlog = '';

  run = function(buffer) {
    var code, returnValue, _;
+    buffer = buffer.replace(/(^|[\r\n]+)(\s*)##?(?:[^#\r\n][^\r\n]*|)($|[\r\n])/, "$1$2$3");
+    buffer = buffer.replace(/[\r\n]+$/, "");
+    if (multilineMode) {
+      backlog += "" + buffer + "\n";
+      repl.setPrompt(REPL_PROMPT_CONTINUATION);
+      repl.prompt();
+      return;
+    }
    if (!buffer.toString().trim() && !backlog) {
      repl.prompt();
      return;
@@ -48,86 +128,118 @@
    backlog = '';
    try {
      _ = global._;
-      returnValue = CoffeeScript.eval("_=(" + code + "\n)", {
+      returnValue = CoffeeScript["eval"]("_=(" + code + "\n)", {
        filename: 'repl',
        modulename: 'repl'
      });
-      if (returnValue === void 0) global._ = _;
-      process.stdout.write(inspect(returnValue, false, 2, enableColours) + '\n');
+      if (returnValue === void 0) {
+        global._ = _;
+      }
+      repl.output.write("" + (inspect(returnValue, false, 2, enableColours)) + "\n");
    } catch (err) {
      error(err);
    }
    return repl.prompt();
  };

-  ACCESSOR = /\s*([\w\.]+)(?:\.(\w*))$/;
-
-  SIMPLEVAR = /\s*(\w*)$/i;
-
-  autocomplete = function(text) {
-    return completeAttribute(text) || completeVariable(text) || [[], text];
-  };
-
-  completeAttribute = function(text) {
-    var all, completions, match, obj, prefix, val;
-    if (match = text.match(ACCESSOR)) {
-      all = match[0], obj = match[1], prefix = match[2];
-      try {
-        val = Script.runInThisContext(obj);
-      } catch (error) {
+  if (stdin.readable) {
+    pipedInput = '';
+    repl = {
+      prompt: function() {
+        return stdout.write(this._prompt);
+      },
+      setPrompt: function(p) {
+        return this._prompt = p;
+      },
+      input: stdin,
+      output: stdout,
+      on: function() {}
+    };
+    stdin.on('data', function(chunk) {
+      var line, lines, _i, _len, _ref;
+      pipedInput += chunk;
+      if (!/\n/.test(pipedInput)) {
        return;
      }
-      completions = getCompletions(prefix, Object.getOwnPropertyNames(val));
-      return [completions, prefix];
-    }
-  };
-
-  completeVariable = function(text) {
-    var completions, free, keywords, possibilities, r, vars, _ref;
-    free = (_ref = text.match(SIMPLEVAR)) != null ? _ref[1] : void 0;
-    if (free != null) {
-      vars = Script.runInThisContext('Object.getOwnPropertyNames(this)');
-      keywords = (function() {
-        var _i, _len, _ref2, _results;
-        _ref2 = CoffeeScript.RESERVED;
-        _results = [];
-        for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
-          r = _ref2[_i];
-          if (r.slice(0, 2) !== '__') _results.push(r);
+      lines = pipedInput.split("\n");
+      pipedInput = lines[lines.length - 1];
+      _ref = lines.slice(0, -1);
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        line = _ref[_i];
+        if (!(line)) {
+          continue;
        }
-        return _results;
-      })();
-      possibilities = vars.concat(keywords);
-      completions = getCompletions(free, possibilities);
-      return [completions, free];
-    }
-  };
-
-  getCompletions = function(prefix, candidates) {
-    var el, _i, _len, _results;
-    _results = [];
-    for (_i = 0, _len = candidates.length; _i < _len; _i++) {
-      el = candidates[_i];
-      if (el.indexOf(prefix) === 0) _results.push(el);
-    }
-    return _results;
-  };
-
-  process.on('uncaughtException', error);
-
-  if (readline.createInterface.length < 3) {
-    repl = readline.createInterface(stdin, autocomplete);
-    stdin.on('data', function(buffer) {
-      return repl.write(buffer);
+        stdout.write("" + line + "\n");
+        run(line);
+      }
+    });
+    stdin.on('end', function() {
+      var line, _i, _len, _ref;
+      _ref = pipedInput.trim().split("\n");
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        line = _ref[_i];
+        if (!(line)) {
+          continue;
+        }
+        stdout.write("" + line + "\n");
+        run(line);
+      }
+      stdout.write('\n');
+      return process.exit(0);
    });
  } else {
-    repl = readline.createInterface(stdin, stdout, autocomplete);
+    if (readline.createInterface.length < 3) {
+      repl = readline.createInterface(stdin, autocomplete);
+      stdin.on('data', function(buffer) {
+        return repl.write(buffer);
+      });
+    } else {
+      repl = readline.createInterface(stdin, stdout, autocomplete);
+    }
  }

+  multilineMode = false;
+
+  repl.input.on('keypress', function(char, key) {
+    var cursorPos, newPrompt;
+    if (!(key && key.ctrl && !key.meta && !key.shift && key.name === 'v')) {
+      return;
+    }
+    cursorPos = repl.cursor;
+    repl.output.cursorTo(0);
+    repl.output.clearLine(1);
+    multilineMode = !multilineMode;
+    if (!multilineMode && backlog) {
+      repl._line();
+    }
+    backlog = '';
+    repl.setPrompt((newPrompt = multilineMode ? REPL_PROMPT_MULTILINE : REPL_PROMPT));
+    repl.prompt();
+    return repl.output.cursorTo(newPrompt.length + (repl.cursor = cursorPos));
+  });
+
+  repl.input.on('keypress', function(char, key) {
+    if (!(multilineMode && repl.line)) {
+      return;
+    }
+    if (!(key && key.ctrl && !key.meta && !key.shift && key.name === 'd')) {
+      return;
+    }
+    multilineMode = false;
+    return repl._line();
+  });
+
  repl.on('attemptClose', function() {
+    if (multilineMode) {
+      multilineMode = false;
+      repl.output.cursorTo(0);
+      repl.output.clearLine(1);
+      repl._onLine(repl.line);
+      return;
+    }
    if (backlog) {
      backlog = '';
-      process.stdout.write('\n');
+      repl.output.write('\n');
      repl.setPrompt(REPL_PROMPT);
      return repl.prompt();
    } else {
@@ -136,8 +248,8 @@
  });

  repl.on('close', function() {
-    process.stdout.write('\n');
-    return stdin.destroy();
+    repl.output.write('\n');
+    return repl.input.destroy();
  });

  repl.on('line', run);
--- a/lib/coffee-script/rewriter.js
+++ b/lib/coffee-script/rewriter.js
@@ -1,7 +1,8 @@
+// Generated by CoffeeScript 1.3.3
 (function() {
  var BALANCED_PAIRS, EXPRESSION_CLOSE, EXPRESSION_END, EXPRESSION_START, IMPLICIT_BLOCK, IMPLICIT_CALL, IMPLICIT_END, IMPLICIT_FUNC, IMPLICIT_UNSPACED_CALL, INVERSES, LINEBREAKS, SINGLE_CLOSERS, SINGLE_LINERS, left, rite, _i, _len, _ref,
-    __indexOf = Array.prototype.indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },
-    __slice = Array.prototype.slice;
+    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },
+    __slice = [].slice;

  exports.Rewriter = (function() {

@@ -31,17 +32,19 @@
    };

    Rewriter.prototype.detectEnd = function(i, condition, action) {
-      var levels, token, tokens, _ref, _ref2;
+      var levels, token, tokens, _ref, _ref1;
      tokens = this.tokens;
      levels = 0;
      while (token = tokens[i]) {
        if (levels === 0 && condition.call(this, token, i)) {
          return action.call(this, token, i);
        }
-        if (!token || levels < 0) return action.call(this, token, i - 1);
+        if (!token || levels < 0) {
+          return action.call(this, token, i - 1);
+        }
        if (_ref = token[0], __indexOf.call(EXPRESSION_START, _ref) >= 0) {
          levels += 1;
-        } else if (_ref2 = token[0], __indexOf.call(EXPRESSION_END, _ref2) >= 0) {
+        } else if (_ref1 = token[0], __indexOf.call(EXPRESSION_END, _ref1) >= 0) {
          levels -= 1;
        }
        i += 1;
@@ -50,13 +53,17 @@
    };

    Rewriter.prototype.removeLeadingNewlines = function() {
-      var i, tag, _len, _ref;
+      var i, tag, _i, _len, _ref;
      _ref = this.tokens;
-      for (i = 0, _len = _ref.length; i < _len; i++) {
+      for (i = _i = 0, _len = _ref.length; _i < _len; i = ++_i) {
        tag = _ref[i][0];
-        if (tag !== 'TERMINATOR') break;
+        if (tag !== 'TERMINATOR') {
+          break;
+        }
+      }
+      if (i) {
+        return this.tokens.splice(0, i);
      }
-      if (i) return this.tokens.splice(0, i);
    };

    Rewriter.prototype.removeMidExpressionNewlines = function() {
@@ -80,7 +87,9 @@
        return this.tokens[token[0] === 'OUTDENT' ? i - 1 : i][0] = 'CALL_END';
      };
      return this.scanTokens(function(token, i) {
-        if (token[0] === 'CALL_START') this.detectEnd(i + 1, condition, action);
+        if (token[0] === 'CALL_START') {
+          this.detectEnd(i + 1, condition, action);
+        }
        return 1;
      });
    };
@@ -95,34 +104,40 @@
        return token[0] = 'INDEX_END';
      };
      return this.scanTokens(function(token, i) {
-        if (token[0] === 'INDEX_START') this.detectEnd(i + 1, condition, action);
+        if (token[0] === 'INDEX_START') {
+          this.detectEnd(i + 1, condition, action);
+        }
        return 1;
      });
    };

    Rewriter.prototype.addImplicitBraces = function() {
-      var action, condition, sameLine, stack, start, startIndent, startsLine;
+      var action, condition, sameLine, stack, start, startIndent, startIndex, startsLine;
      stack = [];
      start = null;
      startsLine = null;
      sameLine = true;
      startIndent = 0;
+      startIndex = 0;
      condition = function(token, i) {
-        var one, tag, three, two, _ref, _ref2;
+        var one, tag, three, two, _ref, _ref1;
        _ref = this.tokens.slice(i + 1, (i + 3) + 1 || 9e9), one = _ref[0], two = _ref[1], three = _ref[2];
-        if ('HERECOMMENT' === (one != null ? one[0] : void 0)) return false;
+        if ('HERECOMMENT' === (one != null ? one[0] : void 0)) {
+          return false;
+        }
        tag = token[0];
-        if (__indexOf.call(LINEBREAKS, tag) >= 0) sameLine = false;
-        return (((tag === 'TERMINATOR' || tag === 'OUTDENT') || (__indexOf.call(IMPLICIT_END, tag) >= 0 && sameLine)) && ((!startsLine && this.tag(i - 1) !== ',') || !((two != null ? two[0] : void 0) === ':' || (one != null ? one[0] : void 0) === '@' && (three != null ? three[0] : void 0) === ':'))) || (tag === ',' && one && ((_ref2 = one[0]) !== 'IDENTIFIER' && _ref2 !== 'NUMBER' && _ref2 !== 'STRING' && _ref2 !== '@' && _ref2 !== 'TERMINATOR' && _ref2 !== 'OUTDENT'));
+        if (__indexOf.call(LINEBREAKS, tag) >= 0) {
+          sameLine = false;
+        }
+        return (((tag === 'TERMINATOR' || tag === 'OUTDENT') || (__indexOf.call(IMPLICIT_END, tag) >= 0 && sameLine && !(i - startIndex === 1))) && ((!startsLine && this.tag(i - 1) !== ',') || !((two != null ? two[0] : void 0) === ':' || (one != null ? one[0] : void 0) === '@' && (three != null ? three[0] : void 0) === ':'))) || (tag === ',' && one && ((_ref1 = one[0]) !== 'IDENTIFIER' && _ref1 !== 'NUMBER' && _ref1 !== 'STRING' && _ref1 !== '@' && _ref1 !== 'TERMINATOR' && _ref1 !== 'OUTDENT'));
      };
      action = function(token, i) {
        var tok;
-        tok = ['}', '}', token[2]];
-        tok.generated = true;
+        tok = this.generate('}', '}', token[2]);
        return this.tokens.splice(i, 0, tok);
      };
      return this.scanTokens(function(token, i, tokens) {
-        var ago, idx, prevTag, tag, tok, value, _ref, _ref2;
+        var ago, idx, prevTag, tag, tok, value, _ref, _ref1;
        if (_ref = (tag = token[0]), __indexOf.call(EXPRESSION_START, _ref) >= 0) {
          stack.push([(tag === 'INDENT' && this.tag(i - 1) === '{' ? '{' : tag), i]);
          return 1;
@@ -131,10 +146,11 @@
          start = stack.pop();
          return 1;
        }
-        if (!(tag === ':' && ((ago = this.tag(i - 2)) === ':' || ((_ref2 = stack[stack.length - 1]) != null ? _ref2[0] : void 0) !== '{'))) {
+        if (!(tag === ':' && ((ago = this.tag(i - 2)) === ':' || ((_ref1 = stack[stack.length - 1]) != null ? _ref1[0] : void 0) !== '{'))) {
          return 1;
        }
        sameLine = true;
+        startIndex = i + 1;
        stack.push(['{']);
        idx = ago === '@' ? i - 2 : i - 1;
        while (this.tag(idx - 2) === 'HERECOMMENT') {
@@ -144,8 +160,7 @@
        startsLine = !prevTag || (__indexOf.call(LINEBREAKS, prevTag) >= 0);
        value = new String('{');
        value.generated = true;
-        tok = ['{', value, token[2]];
-        tok.generated = true;
+        tok = this.generate('{', value, token[2]);
        tokens.splice(idx, 0, tok);
        this.detectEnd(i + 2, condition, action);
        return 2;
@@ -156,9 +171,11 @@
      var action, condition, noCall, seenControl, seenSingle;
      noCall = seenSingle = seenControl = false;
      condition = function(token, i) {
-        var post, tag, _ref, _ref2;
+        var post, tag, _ref, _ref1;
        tag = token[0];
-        if (!seenSingle && token.fromThen) return true;
+        if (!seenSingle && token.fromThen) {
+          return true;
+        }
        if (tag === 'IF' || tag === 'ELSE' || tag === 'CATCH' || tag === '->' || tag === '=>' || tag === 'CLASS') {
          seenSingle = true;
        }
@@ -168,28 +185,38 @@
        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' && !seenControl)) && (tag !== 'INDENT' || (((_ref = this.tag(i - 2)) !== 'CLASS' && _ref !== 'EXTENDS') && (_ref2 = this.tag(i - 1), __indexOf.call(IMPLICIT_BLOCK, _ref2) < 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' || (((_ref = this.tag(i - 2)) !== 'CLASS' && _ref !== 'EXTENDS') && (_ref1 = this.tag(i - 1), __indexOf.call(IMPLICIT_BLOCK, _ref1) < 0) && !((post = this.tokens[i + 1]) && post.generated && post[0] === '{')));
      };
      action = function(token, i) {
-        return this.tokens.splice(i, 0, ['CALL_END', ')', token[2]]);
+        return this.tokens.splice(i, 0, this.generate('CALL_END', ')', token[2]));
      };
      return this.scanTokens(function(token, i, tokens) {
-        var callObject, current, next, prev, tag, _ref, _ref2, _ref3;
+        var callObject, current, next, prev, tag, _ref, _ref1, _ref2;
        tag = token[0];
-        if (tag === 'CLASS' || tag === 'IF') noCall = true;
+        if (tag === 'CLASS' || tag === 'IF' || tag === 'FOR' || tag === 'WHILE') {
+          noCall = true;
+        }
        _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);
+        callObject = !noCall && tag === 'INDENT' && next && next.generated && next[0] === '{' && prev && (_ref1 = prev[0], __indexOf.call(IMPLICIT_FUNC, _ref1) >= 0);
        seenSingle = false;
        seenControl = false;
-        if (__indexOf.call(LINEBREAKS, tag) >= 0) noCall = false;
-        if (prev && !prev.spaced && tag === '?') token.call = true;
-        if (token.fromThen) return 1;
-        if (!(callObject || (prev != null ? prev.spaced : void 0) && (prev.call || (_ref3 = prev[0], __indexOf.call(IMPLICIT_FUNC, _ref3) >= 0)) && (__indexOf.call(IMPLICIT_CALL, tag) >= 0 || !(token.spaced || token.newLine) && __indexOf.call(IMPLICIT_UNSPACED_CALL, tag) >= 0))) {
+        if (__indexOf.call(LINEBREAKS, tag) >= 0) {
+          noCall = false;
+        }
+        if (prev && !prev.spaced && tag === '?') {
+          token.call = true;
+        }
+        if (token.fromThen) {
          return 1;
        }
-        tokens.splice(i, 0, ['CALL_START', '(', token[2]]);
+        if (!(callObject || (prev != null ? prev.spaced : void 0) && (prev.call || (_ref2 = prev[0], __indexOf.call(IMPLICIT_FUNC, _ref2) >= 0)) && (__indexOf.call(IMPLICIT_CALL, tag) >= 0 || !(token.spaced || token.newLine) && __indexOf.call(IMPLICIT_UNSPACED_CALL, tag) >= 0))) {
+          return 1;
+        }
+        tokens.splice(i, 0, this.generate('CALL_START', '(', token[2]));
        this.detectEnd(i + 1, condition, action);
-        if (prev[0] === '?') prev[0] = 'FUNC_EXIST';
+        if (prev[0] === '?') {
+          prev[0] = 'FUNC_EXIST';
+        }
        return 2;
      });
    };
@@ -205,7 +232,7 @@
        return this.tokens.splice((this.tag(i - 1) === ',' ? i - 1 : i), 0, outdent);
      };
      return this.scanTokens(function(token, i, tokens) {
-        var tag, _ref, _ref2;
+        var tag, _ref, _ref1;
        tag = token[0];
        if (tag === 'TERMINATOR' && this.tag(i + 1) === 'THEN') {
          tokens.splice(i, 1);
@@ -221,12 +248,15 @@
        }
        if (__indexOf.call(SINGLE_LINERS, tag) >= 0 && this.tag(i + 1) !== 'INDENT' && !(tag === 'ELSE' && this.tag(i + 1) === 'IF')) {
          starter = tag;
-          _ref2 = this.indentation(token), indent = _ref2[0], outdent = _ref2[1];
-          if (starter === 'THEN') indent.fromThen = true;
-          indent.generated = outdent.generated = true;
+          _ref1 = this.indentation(token, true), indent = _ref1[0], outdent = _ref1[1];
+          if (starter === 'THEN') {
+            indent.fromThen = true;
+          }
          tokens.splice(i + 1, 0, indent);
          this.detectEnd(i + 2, condition, action);
-          if (tag === 'THEN') tokens.splice(i, 1);
+          if (tag === 'THEN') {
+            tokens.splice(i, 1);
+          }
          return 1;
        }
        return 1;
@@ -246,15 +276,33 @@
        }
      };
      return this.scanTokens(function(token, i) {
-        if (token[0] !== 'IF') return 1;
+        if (token[0] !== 'IF') {
+          return 1;
+        }
        original = token;
        this.detectEnd(i + 1, condition, action);
        return 1;
      });
    };

-    Rewriter.prototype.indentation = function(token) {
-      return [['INDENT', 2, token[2]], ['OUTDENT', 2, token[2]]];
+    Rewriter.prototype.indentation = function(token, implicit) {
+      var indent, outdent;
+      if (implicit == null) {
+        implicit = false;
+      }
+      indent = ['INDENT', 2, token[2]];
+      outdent = ['OUTDENT', 2, token[2]];
+      if (implicit) {
+        indent.generated = outdent.generated = true;
+      }
+      return [indent, outdent];
+    };
+
+    Rewriter.prototype.generate = function(tag, value, line) {
+      var tok;
+      tok = [tag, value, line];
+      tok.generated = true;
+      return tok;
    };

    Rewriter.prototype.tag = function(i) {
@@ -284,7 +332,7 @@

  IMPLICIT_FUNC = ['IDENTIFIER', 'SUPER', ')', 'CALL_END', ']', 'INDEX_END', '@', 'THIS'];

-  IMPLICIT_CALL = ['IDENTIFIER', 'NUMBER', 'STRING', 'JS', 'REGEX', 'NEW', 'PARAM_START', 'CLASS', 'IF', 'TRY', 'SWITCH', 'THIS', 'BOOL', 'UNARY', 'SUPER', '@', '->', '=>', '[', '(', '{', '--', '++'];
+  IMPLICIT_CALL = ['IDENTIFIER', 'NUMBER', 'STRING', 'JS', 'REGEX', 'NEW', 'PARAM_START', 'CLASS', 'IF', 'TRY', 'SWITCH', 'THIS', 'BOOL', 'NULL', 'UNDEFINED', 'UNARY', 'SUPER', '@', '->', '=>', '[', '(', '{', '--', '++'];

  IMPLICIT_UNSPACED_CALL = ['+', '-'];

--- a/lib/coffee-script/scope.js
+++ b/lib/coffee-script/scope.js
@@ -1,3 +1,4 @@
+// Generated by CoffeeScript 1.3.3
 (function() {
  var Scope, extend, last, _ref;

@@ -18,11 +19,15 @@
        }
      ];
      this.positions = {};
-      if (!this.parent) Scope.root = this;
+      if (!this.parent) {
+        Scope.root = this;
+      }
    }

    Scope.prototype.add = function(name, type, immediate) {
-      if (this.shared && !immediate) return this.parent.add(name, type, immediate);
+      if (this.shared && !immediate) {
+        return this.parent.add(name, type, immediate);
+      }
      if (Object.prototype.hasOwnProperty.call(this.positions, name)) {
        return this.variables[this.positions[name]].type = type;
      } else {
@@ -33,50 +38,65 @@
      }
    };

-    Scope.prototype.find = function(name, options) {
-      if (this.check(name, options)) return true;
+    Scope.prototype.namedMethod = function() {
+      if (this.method.name || !this.parent) {
+        return this.method;
+      }
+      return this.parent.namedMethod();
+    };
+
+    Scope.prototype.find = function(name) {
+      if (this.check(name)) {
+        return true;
+      }
      this.add(name, 'var');
      return false;
    };

    Scope.prototype.parameter = function(name) {
-      if (this.shared && this.parent.check(name, true)) return;
+      if (this.shared && this.parent.check(name, true)) {
+        return;
+      }
      return this.add(name, 'param');
    };

-    Scope.prototype.check = function(name, immediate) {
-      var found, _ref2;
-      found = !!this.type(name);
-      if (found || immediate) return found;
-      return !!((_ref2 = this.parent) != null ? _ref2.check(name) : void 0);
+    Scope.prototype.check = function(name) {
+      var _ref1;
+      return !!(this.type(name) || ((_ref1 = this.parent) != null ? _ref1.check(name) : void 0));
    };

    Scope.prototype.temporary = function(name, index) {
      if (name.length > 1) {
-        return '_' + name + (index > 1 ? index : '');
+        return '_' + name + (index > 1 ? index - 1 : '');
      } else {
        return '_' + (index + parseInt(name, 36)).toString(36).replace(/\d/g, 'a');
      }
    };

    Scope.prototype.type = function(name) {
-      var v, _i, _len, _ref2;
-      _ref2 = this.variables;
-      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
-        v = _ref2[_i];
-        if (v.name === name) return v.type;
+      var v, _i, _len, _ref1;
+      _ref1 = this.variables;
+      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+        v = _ref1[_i];
+        if (v.name === name) {
+          return v.type;
+        }
      }
      return null;
    };

    Scope.prototype.freeVariable = function(name, reserve) {
      var index, temp;
-      if (reserve == null) reserve = true;
+      if (reserve == null) {
+        reserve = true;
+      }
      index = 0;
      while (this.check((temp = this.temporary(name, index)))) {
        index++;
      }
-      if (reserve) this.add(temp, 'var', true);
+      if (reserve) {
+        this.add(temp, 'var', true);
+      }
      return temp;
    };

@@ -93,12 +113,12 @@
    };

    Scope.prototype.declaredVariables = function() {
-      var realVars, tempVars, v, _i, _len, _ref2;
+      var realVars, tempVars, v, _i, _len, _ref1;
      realVars = [];
      tempVars = [];
-      _ref2 = this.variables;
-      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
-        v = _ref2[_i];
+      _ref1 = this.variables;
+      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+        v = _ref1[_i];
        if (v.type === 'var') {
          (v.name.charAt(0) === '_' ? tempVars : realVars).push(v.name);
        }
@@ -107,12 +127,14 @@
    };

    Scope.prototype.assignedVariables = function() {
-      var v, _i, _len, _ref2, _results;
-      _ref2 = this.variables;
+      var v, _i, _len, _ref1, _results;
+      _ref1 = this.variables;
      _results = [];
-      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
-        v = _ref2[_i];
-        if (v.type.assigned) _results.push("" + v.name + " = " + v.type.value);
+      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+        v = _ref1[_i];
+        if (v.type.assigned) {
+          _results.push("" + v.name + " = " + v.type.value);
+        }
      }
      return _results;
    };
--- a/package.json
+++ b/package.json
@@ -3,10 +3,10 @@
  "description":  "Unfancy JavaScript",
  "keywords":     ["javascript", "language", "coffeescript", "compiler"],
  "author":       "Jeremy Ashkenas",
-  "version":      "1.2.0",
+  "version":      "1.3.3",
  "licenses":     [{
    "type":       "MIT",
-    "url":        "http://github.com/jashkenas/coffee-script/raw/master/LICENSE"
+    "url":        "https://raw.github.com/jashkenas/coffee-script/master/LICENSE"
  }],
  "engines":      {
    "node":       ">=0.4.0"
@@ -20,6 +20,7 @@
    "cake":       "./bin/cake"
  },
  "homepage":     "http://coffeescript.org",
+  "bugs":         "https://github.com/jashkenas/coffee-script/issues",
  "repository":   {
    "type": "git",
    "url": "git://github.com/jashkenas/coffee-script.git"
--- a/src/browser.coffee
+++ b/src/browser.coffee
@@ -4,7 +4,8 @@ CoffeeScript = require './coffee-script'
 CoffeeScript.require = require

 # Use standard JavaScript `eval` to eval code.
-CoffeeScript.eval = (code, options) ->
+CoffeeScript.eval = (code, options = {}) ->
+  options.bare ?= on
  eval CoffeeScript.compile code, options

 # Running code does not provide access to this scope.
--- a/src/cake.coffee
+++ b/src/cake.coffee
@@ -46,7 +46,7 @@ helpers.extend global,
 exports.run = ->
  global.__originalDirname = fs.realpathSync '.'
  process.chdir cakefileDirectory __originalDirname
-  args = process.argv.slice 2
+  args = process.argv[2..]
  CoffeeScript.run fs.readFileSync('Cakefile').toString(), filename: 'Cakefile'
  oparse = new optparse.OptionParser switches
  return printTasks() unless args.length
@@ -58,7 +58,8 @@ exports.run = ->

 # Display the list of Cake tasks in a format similar to `rake -T`
 printTasks = ->
-  cakefilePath = path.join path.relative(__originalDirname, process.cwd()), 'Cakefile'
+  relative = path.relative or path.resolve
+  cakefilePath = path.join relative(__originalDirname, process.cwd()), 'Cakefile'
  console.log "#{cakefilePath} defines the following tasks:\n"
  for name, task of tasks
    spaces = 20 - name.length
--- a/src/coffee-script.coffee
+++ b/src/coffee-script.coffee
@@ -21,7 +21,7 @@ else if require.registerExtension
  require.registerExtension '.coffee', (content) -> compile content

 # The current CoffeeScript version number.
-exports.VERSION = '1.2.0'
+exports.VERSION = '1.3.3'

 # Words that cannot be used as identifiers in CoffeeScript code
 exports.RESERVED = RESERVED
@@ -34,10 +34,13 @@ exports.helpers = require './helpers'
 exports.compile = compile = (code, options = {}) ->
  {merge} = exports.helpers
  try
-    (parser.parse lexer.tokenize code).compile merge {}, options
+    js = (parser.parse lexer.tokenize code).compile options
+    return js unless options.header
  catch err
    err.message = "In #{options.filename}, #{err.message}" if options.filename
    throw err
+  header = "Generated by CoffeeScript #{@VERSION}"
+  "// #{header}\n#{js}"

 # Tokenize a string of CoffeeScript code, and return the array of tokens.
 exports.tokens = (code, options) ->
@@ -54,7 +57,7 @@ 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) ->
+exports.run = (code, options = {}) ->
  mainModule = require.main

  # Set the filename.
@@ -65,7 +68,7 @@ exports.run = (code, options) ->
  mainModule.moduleCache and= {}

  # Assign paths for node_modules loading
-  mainModule.paths = require('module')._nodeModulePaths path.dirname options.filename
+  mainModule.paths = require('module')._nodeModulePaths path.dirname fs.realpathSync options.filename

  # Compile.
  if path.extname(mainModule.filename) isnt '.coffee' or require.extensions
--- a/src/command.coffee
+++ b/src/command.coffee
@@ -19,12 +19,14 @@ helpers.extend CoffeeScript, new EventEmitter
 printLine = (line) -> process.stdout.write line + '\n'
 printWarn = (line) -> process.stderr.write line + '\n'

+hidden = (file) -> /^\.|~$/.test file
+
 # The help banner that is printed when `coffee` is called without arguments.
 BANNER = '''
-  Usage: coffee [options] path/to/script.coffee
+  Usage: coffee [options] path/to/script.coffee -- [args]

  If called without options, `coffee` will run your script.
-         '''
+'''

 # The list of all the valid option flags that `coffee` knows how to handle.
 SWITCHES = [
@@ -65,13 +67,12 @@ exports.run = ->
  loadRequires()                         if opts.require
  return require './repl'                if opts.interactive
  if opts.watch and !fs.watch
-    printWarn "The --watch feature depends on Node v0.6.0+. You are running #{process.version}."
+    return printWarn "The --watch feature depends on Node v0.6.0+. You are running #{process.version}."
  return compileStdio()                  if opts.stdio
  return compileScript null, sources[0]  if opts.eval
  return require './repl'                unless sources.length
-  if opts.run
-    opts.literals = sources.splice(1).concat opts.literals
-  process.argv = process.argv.slice(0, 2).concat opts.literals
+  literals = if opts.run then sources.splice 1 else []
+  process.argv = process.argv[0..1].concat literals
  process.argv[0] = 'coffee'
  process.execPath = require.main.filename
  for source in sources
@@ -96,11 +97,12 @@ compilePath = (source, topLevel, base) ->
      fs.readdir source, (err, files) ->
        throw err if err and err.code isnt 'ENOENT'
        return if err?.code is 'ENOENT'
-        files = files.map (file) -> path.join source, file
        index = sources.indexOf source
-        sources[index..index] = files
+        files = files.filter (file) -> not hidden file
+        sources[index..index] = (path.join source, file for file in files)
        sourceCode[index..index] = files.map -> null
-        compilePath file, no, base for file in files
+        files.forEach (file) ->
+          compilePath (path.join source, file), no, base
    else if topLevel or path.extname(source) is '.coffee'
      watch source, base if opts.watch
      fs.readFile source, (err, code) ->
@@ -136,7 +138,7 @@ compileScript = (file, input, base) ->
  catch err
    CoffeeScript.emit 'failure', err, task
    return if CoffeeScript.listeners('failure').length
-    return printLine err.message if o.watch
+    return printLine err.message + '\x07' if o.watch
    printWarn err instanceof Error and err.stack or "ERROR: #{err}"
    process.exit 1

@@ -178,8 +180,12 @@ watch = (source, base) ->
  watchErr = (e) ->
    if e.code is 'ENOENT'
      return if sources.indexOf(source) is -1
-      removeSource source, base, yes
-      compileJoin()
+      try
+        rewatch()
+        compile()
+      catch e
+        removeSource source, base, yes
+        compileJoin()
    else throw e

  compile = ->
@@ -187,33 +193,23 @@ watch = (source, base) ->
    compileTimeout = wait 25, ->
      fs.stat source, (err, stats) ->
        return watchErr err if err
-        return if prevStats and (stats.size is prevStats.size and
-          stats.mtime.getTime() is prevStats.mtime.getTime())
+        return rewatch() if prevStats and stats.size is prevStats.size and
+          stats.mtime.getTime() is prevStats.mtime.getTime()
        prevStats = stats
        fs.readFile source, (err, code) ->
          return watchErr err if err
          compileScript(source, code.toString(), base)
-
-  watchErr = (e) ->
-    throw e unless e.code is 'ENOENT'
-    removeSource source, base, yes
-    compileJoin()
+          rewatch()

  try
-    watcher = fs.watch source, callback = (event) ->
-      if event is 'change'
-        compile()
-      else if event is 'rename'
-        watcher.close()
-        wait 250, ->
-          compile()
-          try
-            watcher = fs.watch source, callback
-          catch e  
-            watchErr e
-  catch e 
+    watcher = fs.watch source, compile
+  catch e
    watchErr e

+  rewatch = ->
+    watcher?.close()
+    watcher = fs.watch source, compile
+

 # Watch a directory of files for new additions.
 watchDir = (source, base) ->
@@ -227,8 +223,8 @@ watchDir = (source, base) ->
            throw err unless err.code is 'ENOENT'
            watcher.close()
            return unwatchDir source, base
-          files = files.map (file) -> path.join source, file
-          for file in files when not notSources[file]
+          for file in files when not hidden(file) and not notSources[file]
+            file = path.join source, file
            continue if sources.some (s) -> s.indexOf(file) >= 0
            sources.push file
            sourceCode.push null
@@ -237,7 +233,7 @@ watchDir = (source, base) ->
    throw e unless e.code is 'ENOENT'

 unwatchDir = (source, base) ->
-  prevSources = sources.slice()
+  prevSources = sources[..]
  toRemove = (file for file in sources when file.indexOf(source) >= 0)
  removeSource file, base, yes for file in toRemove
  return unless sources.some (s, i) -> prevSources[i] isnt s
@@ -280,7 +276,7 @@ writeJs = (source, js, base) ->
        timeLog "compiled #{source}"
  path.exists jsDir, (exists) ->
    if exists then compile() else exec "mkdir -p #{jsDir}", compile
-    
+
 # Convenience for cleaner setTimeouts.
 wait = (milliseconds, func) -> setTimeout func, milliseconds

@@ -310,7 +306,7 @@ printTokens = (tokens) ->
 # `process.argv` that are specified in `SWITCHES`.
 parseOptions = ->
  optionParser  = new optparse.OptionParser SWITCHES, BANNER
-  o = opts      = optionParser.parse process.argv.slice 2
+  o = opts      = optionParser.parse process.argv[2..]
  o.compile     or=  !!o.output
  o.run         = not (o.compile or o.print or o.lint)
  o.print       = !!  (o.print or (o.eval or o.stdio and o.compile))
@@ -319,7 +315,8 @@ parseOptions = ->
  return

 # The compile-time options to pass to the CoffeeScript compiler.
-compileOptions = (filename) -> {filename, bare: opts.bare}
+compileOptions = (filename) ->
+  {filename, bare: opts.bare, header: opts.compile}

 # Start up a new Node.js instance with the arguments in `--nodejs` passed to
 # the `node` binary, preserving the other options.
--- a/src/grammar.coffee
+++ b/src/grammar.coffee
@@ -127,10 +127,9 @@ grammar =
    o 'JS',                                     -> new Literal $1
    o 'REGEX',                                  -> new Literal $1
    o 'DEBUGGER',                               -> new Literal $1
-    o 'BOOL',                                   ->
-      val = new Literal $1
-      val.isUndefined = yes if $1 is 'undefined'
-      val
+    o 'UNDEFINED',                              -> new Undefined
+    o 'NULL',                                   -> new Null
+    o 'BOOL',                                   -> new Bool $1
  ]

  # Assignment of a variable, property, or index to a value.
@@ -193,6 +192,8 @@ grammar =
    o '',                                       -> []
    o 'Param',                                  -> [$1]
    o 'ParamList , Param',                      -> $1.concat $3
+    o 'ParamList OptComma TERMINATOR Param',    -> $1.concat $4
+    o 'ParamList OptComma INDENT ParamList OptComma OUTDENT', -> $1.concat $4
  ]

  # A single parameter in a function definition can be ordinary, or a splat
@@ -343,6 +344,7 @@ grammar =
    o 'Expression RangeDots Expression',        -> new Range $1, $3, $2
    o 'Expression RangeDots',                   -> new Range $1, null, $2
    o 'RangeDots Expression',                   -> new Range null, $2, $1
+    o 'RangeDots',                              -> new Range null, null, $1
  ]

  # The **ArgList** is both the list of objects passed into a function call,
@@ -442,6 +444,7 @@ grammar =
  # This enables support for pattern matching.
  ForValue: [
    o 'Identifier'
+    o 'ThisProperty'
    o 'Array',                                  -> new Value $1
    o 'Object',                                 -> new Value $1
  ]
@@ -530,7 +533,7 @@ grammar =
    o 'Expression LOGIC    Expression',         -> new Op $2, $1, $3
    o 'Expression RELATION Expression',         ->
      if $2.charAt(0) is '!'
-        new Op($2.slice(1), $1, $3).invert()
+        new Op($2[1..], $1, $3).invert()
      else
        new Op $2, $1, $3

@@ -568,7 +571,7 @@ operators = [
  ['nonassoc',  'INDENT', 'OUTDENT']
  ['right',     '=', ':', 'COMPOUND_ASSIGN', 'RETURN', 'THROW', 'EXTENDS']
  ['right',     'FORIN', 'FOROF', 'BY', 'WHEN']
-  ['right',     'IF', 'ELSE', 'FOR', 'DO', 'WHILE', 'UNTIL', 'LOOP', 'SUPER', 'CLASS']
+  ['right',     'IF', 'ELSE', 'FOR', 'WHILE', 'UNTIL', 'LOOP', 'SUPER', 'CLASS']
  ['right',     'POST_IF']
 ]

--- a/src/lexer.coffee
+++ b/src/lexer.coffee
@@ -48,7 +48,7 @@ exports.Lexer = class Lexer
    # short-circuiting if any of them succeed. Their order determines precedence:
    # `@literalToken` is the fallback catch-all.
    i = 0
-    while @chunk = code.slice i
+    while @chunk = code[i..]
      i += @identifierToken() or
           @commentToken()    or
           @whitespaceToken() or
@@ -106,7 +106,7 @@ exports.Lexer = class Lexer
            @tokens.pop()
            id = '!' + id

-    if id in ['eval', 'arguments'].concat JS_FORBIDDEN
+    if id in JS_FORBIDDEN
      if forcedIdentifier
        tag = 'IDENTIFIER'
        id  = new String id
@@ -117,11 +117,11 @@ exports.Lexer = class Lexer
    unless forcedIdentifier
      id  = COFFEE_ALIAS_MAP[id] if id in COFFEE_ALIASES
      tag = switch id
-        when '!'                                  then 'UNARY'
-        when '==', '!='                           then 'COMPARE'
-        when '&&', '||'                           then 'LOGIC'
-        when 'true', 'false', 'null', 'undefined' then 'BOOL'
-        when 'break', 'continue'                  then 'STATEMENT'
+        when '!'                 then 'UNARY'
+        when '==', '!='          then 'COMPARE'
+        when '&&', '||'          then 'LOGIC'
+        when 'true', 'false'     then 'BOOL'
+        when 'break', 'continue' then 'STATEMENT'
        else  tag

    @token tag, id
@@ -133,9 +133,19 @@ exports.Lexer = class Lexer
  numberToken: ->
    return 0 unless match = NUMBER.exec @chunk
    number = match[0]
+    if /^0[BOX]/.test number
+      @error "radix prefix '#{number}' must be lowercase"
+    else if /E/.test(number) and not /^0x/.test number
+      @error "exponential notation '#{number}' must be indicated with a lowercase 'e'"
+    else if /^0\d*[89]/.test number
+      @error "decimal literal '#{number}' must not be prefixed with '0'"
+    else if /^0\d+/.test number
+      @error "octal literal '#{number}' must be prefixed with '0o'"
    lexedLength = number.length
-    if binaryLiteral = /0b([01]+)/.exec number
-      number = (parseInt binaryLiteral[1], 2).toString()
+    if octalLiteral = /^0o([0-7]+)/.exec number
+      number = '0x' + (parseInt octalLiteral[1], 8).toString 16
+    if binaryLiteral = /^0b([01]+)/.exec number
+      number = '0x' + (parseInt binaryLiteral[1], 2).toString 16
    @token 'NUMBER', number
    lexedLength

@@ -149,11 +159,13 @@ exports.Lexer = class Lexer
      when '"'
        return 0 unless string = @balancedString @chunk, '"'
        if 0 < string.indexOf '#{', 1
-          @interpolateString string.slice 1, -1
+          @interpolateString string[1...-1]
        else
          @token 'STRING', @escapeLines string
      else
        return 0
+    if octalEsc = /^(?:\\.|[^\\])*\\(?:0[0-7]|[1-7])/.test string
+      @error "octal escape sequences #{string} are not allowed"
    @line += count string, '\n'
    string.length

@@ -178,14 +190,13 @@ exports.Lexer = class Lexer
    if here
      @token 'HERECOMMENT', @sanitizeHeredoc here,
        herecomment: true, indent: Array(@indent + 1).join(' ')
-      @token 'TERMINATOR', '\n'
    @line += count comment, '\n'
    comment.length

  # Matches JavaScript interpolated directly into the source via backticks.
  jsToken: ->
    return 0 unless @chunk.charAt(0) is '`' and match = JSTOKEN.exec @chunk
-    @token 'JS', (script = match[0]).slice 1, -1
+    @token 'JS', (script = match[0])[1...-1]
    script.length

  # Matches regular expression literals. Lexing regular expressions is difficult
@@ -335,9 +346,9 @@ exports.Lexer = class Lexer
        prev[0] = 'COMPOUND_ASSIGN'
        prev[1] += '='
        return value.length
-    if value is ';'             
-     @seenFor = no
-     tag = 'TERMINATOR'
+    if value is ';'
+      @seenFor = no
+      tag = 'TERMINATOR'
    else if value in MATH            then tag = 'MATH'
    else if value in COMPARE         then tag = 'COMPARE'
    else if value in COMPOUND_ASSIGN then tag = 'COMPOUND_ASSIGN'
@@ -407,22 +418,26 @@ exports.Lexer = class Lexer
  # contents of the string. This method allows us to have strings within
  # interpolations within strings, ad infinitum.
  balancedString: (str, end) ->
+    continueCount = 0
    stack = [end]
    for i in [1...str.length]
+      if continueCount
+        --continueCount
+        continue
      switch letter = str.charAt i
        when '\\'
-          i++
+          ++continueCount
          continue
        when end
          stack.pop()
          unless stack.length
-            return str.slice 0, i + 1
+            return str[0..i]
          end = stack[stack.length - 1]
          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 '/' and match = (HEREGEX.exec(str[i..]) or REGEX.exec(str[i..]))
+        continueCount += match[0].length - 1
      else if end is '}' and letter is '{'
        stack.push end = '}'
      else if end is '"' and prev is '#' and letter is '{'
@@ -448,10 +463,10 @@ exports.Lexer = class Lexer
        i += 1
        continue
      unless letter is '#' and str.charAt(i+1) is '{' and
-             (expr = @balancedString str.slice(i + 1), '}')
+             (expr = @balancedString str[i + 1..], '}')
        continue
-      tokens.push ['NEOSTRING', str.slice(pi, i)] if pi < i
-      inner = expr.slice(1, -1)
+      tokens.push ['NEOSTRING', str[pi...i]] if pi < i
+      inner = expr[1...-1]
      if inner.length
        nested = new Lexer().tokenize inner, line: @line, rewrite: off
        nested.pop()
@@ -463,7 +478,7 @@ exports.Lexer = class Lexer
          tokens.push ['TOKENS', nested]
      i += expr.length
      pi = i + 1
-    tokens.push ['NEOSTRING', str.slice pi] if i > pi < str.length
+    tokens.push ['NEOSTRING', str[pi..]] if i > pi < str.length
    return tokens if regex
    return @token 'STRING', '""' unless tokens.length
    tokens.unshift ['', ''] unless tokens[0][0] is 'NEOSTRING'
@@ -511,7 +526,7 @@ exports.Lexer = class Lexer
  unfinished: ->
    LINE_CONTINUER.test(@chunk) or
    @tag() in ['\\', '.', '?.', 'UNARY', 'MATH', '+', '-', 'SHIFT', 'RELATION'
-               'COMPARE', 'LOGIC', 'COMPOUND_ASSIGN', 'THROW', 'EXTENDS']
+               'COMPARE', 'LOGIC', 'THROW', 'EXTENDS']

  # Converts newlines for string literals.
  escapeLines: (str, heredoc) ->
@@ -524,9 +539,9 @@ exports.Lexer = class Lexer
      if contents in ['\n', quote] then contents else match
    body = body.replace /// #{quote} ///g, '\\$&'
    quote + @escapeLines(body, heredoc) + quote
-    
+
  # Throws a syntax error on the current `@line`.
-  error: (message) -> 
+  error: (message) ->
    throw SyntaxError "#{message} on line #{ @line + 1}"

 # Constants
@@ -565,13 +580,18 @@ RESERVED = [
  'case', 'default', 'function', 'var', 'void', 'with'
  'const', 'let', 'enum', 'export', 'import', 'native'
  '__hasProp', '__extends', '__slice', '__bind', '__indexOf'
+  'implements', 'interface', 'let', 'package',
+  'private', 'protected', 'public', 'static', 'yield'
 ]

+STRICT_PROSCRIBED = ['arguments', 'eval']
+
 # The superset of both JavaScript keywords and reserved words, none of which may
 # be used as identifiers or properties.
-JS_FORBIDDEN = JS_KEYWORDS.concat RESERVED
+JS_FORBIDDEN = JS_KEYWORDS.concat(RESERVED).concat(STRICT_PROSCRIBED)

-exports.RESERVED = RESERVED.concat(JS_KEYWORDS).concat(COFFEE_KEYWORDS)
+exports.RESERVED = RESERVED.concat(JS_KEYWORDS).concat(COFFEE_KEYWORDS).concat(STRICT_PROSCRIBED)
+exports.STRICT_PROSCRIBED = STRICT_PROSCRIBED

 # Token matching regexes.
 IDENTIFIER = /// ^
@@ -580,8 +600,9 @@ IDENTIFIER = /// ^
 ///

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

@@ -663,7 +684,7 @@ MATH    = ['*', '/', '%']
 RELATION = ['IN', 'OF', 'INSTANCEOF']

 # Boolean tokens.
-BOOL = ['TRUE', 'FALSE', 'NULL', 'UNDEFINED']
+BOOL = ['TRUE', 'FALSE']

 # Tokens which a regular expression will never immediately follow, but which
 # a division operator might.
@@ -671,7 +692,7 @@ BOOL = ['TRUE', 'FALSE', 'NULL', 'UNDEFINED']
 # See: http://www.mozilla.org/js/language/js20-2002-04/rationale/syntax.html#regular-expressions
 #
 # Our list is shorter, due to sans-parentheses method calls.
-NOT_REGEX = ['NUMBER', 'REGEX', 'BOOL', '++', '--', ']']
+NOT_REGEX = ['NUMBER', 'REGEX', 'BOOL', 'NULL', 'UNDEFINED', '++', '--', ']']

 # If the previous token is not spaced, there are more preceding tokens that
 # force a division parse:
@@ -681,7 +702,7 @@ NOT_SPACED_REGEX = NOT_REGEX.concat ')', '}', 'THIS', 'IDENTIFIER', 'STRING'
 # 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']
-INDEXABLE = CALLABLE.concat 'NUMBER', 'BOOL'
+INDEXABLE = CALLABLE.concat 'NUMBER', 'BOOL', 'NULL', 'UNDEFINED'

 # Tokens that, when immediately preceding a `WHEN`, indicate that the `WHEN`
 # occurs at the start of a line. We disambiguate these from trailing whens to
--- a/src/nodes.coffee
+++ b/src/nodes.coffee
@@ -4,7 +4,7 @@
 # the syntax tree into a string of JavaScript code, call `compile()` on the root.

 {Scope} = require './scope'
-{RESERVED} = require './lexer'
+{RESERVED, STRICT_PROSCRIBED} = require './lexer'

 # Import the helpers we plan to use.
 {compact, flatten, extend, merge, del, starts, ends, last} = require './helpers'
@@ -227,7 +227,10 @@ exports.Block = class Block extends Base
      else if top
        node.front = true
        code = node.compile o
-        codes.push if node.isStatement o then code else "#{@tab}#{code};"
+        unless node.isStatement o
+          code = "#{@tab}#{code};"
+          code = "#{code}\n" if node instanceof Literal
+        codes.push code
      else
        codes.push node.compile o, LEVEL_LIST
    if top
@@ -322,11 +325,9 @@ exports.Literal = class Literal extends Base
    return this if @value is 'continue' and not o?.loop

  compileNode: (o) ->
-    code = if @isUndefined
-      if o.level >= LEVEL_ACCESS then '(void 0)' else 'void 0'
-    else if @value is 'this'
+    code = if @value is 'this'
      if o.scope.method?.bound then o.scope.method.context else @value
-    else if @value.reserved and "#{@value}" not in ['eval', 'arguments']
+    else if @value.reserved
      "\"#{@value}\""
    else
      @value
@@ -335,6 +336,23 @@ exports.Literal = class Literal extends Base
  toString: ->
    ' "' + @value + '"'

+class exports.Undefined extends Base
+  isAssignable: NO
+  isComplex: NO
+  compileNode: (o) ->
+    if o.level >= LEVEL_ACCESS then '(void 0)' else 'void 0'
+
+class exports.Null extends Base
+  isAssignable: NO
+  isComplex: NO
+  compileNode: -> "null"
+
+class exports.Bool extends Base
+  isAssignable: NO
+  isComplex: NO
+  compileNode: -> @val
+  constructor: (@val) ->
+
 #### Return

 # A `return` is a *pureStatement* -- wrapping it in a closure wouldn't
@@ -383,6 +401,7 @@ exports.Value = class Value extends Base
  isComplex      : -> @hasProperties() or @base.isComplex()
  isAssignable   : -> @hasProperties() or @base.isAssignable()
  isSimpleNumber : -> @base instanceof Literal and SIMPLENUM.test @base.value
+  isString       : -> @base instanceof Literal and IS_STRING.test @base.value
  isAtomic       : ->
    for node in @properties.concat @base
      return no if node.soak or node instanceof Call
@@ -464,7 +483,7 @@ exports.Comment = class Comment extends Base
  makeReturn:      THIS

  compileNode: (o, level) ->
-    code = '/*' + multident(@comment, @tab) + "\n#{@tab}*/"
+    code = '/*' + multident(@comment, @tab) + "\n#{@tab}*/\n"
    code = o.indent + code if (level or o.level) is LEVEL_TOP
    code

@@ -492,7 +511,7 @@ exports.Call = class Call extends Base
  # Grab the reference to the superclass's implementation of the current
  # method.
  superReference: (o) ->
-    {method} = o.scope
+    method = o.scope.namedMethod()
    throw SyntaxError 'cannot call super outside of a function.' unless method
    {name} = method
    throw SyntaxError 'cannot call super on an anonymous function.' unless name?
@@ -504,6 +523,11 @@ exports.Call = class Call extends Base
    else
      "#{name}.__super__.constructor"

+  # The appropriate `this` value for a `super` call.
+  superThis : (o) ->
+    method = o.scope.method
+    (method and not method.klass and method.context) or "this"
+
  # Soaked chained invocations unfold into if/else ternary structures.
  unfoldSoak: (o) ->
    if @soak
@@ -562,29 +586,29 @@ exports.Call = class Call extends Base
    args = @filterImplicitObjects @args
    args = (arg.compile o, LEVEL_LIST for arg in args).join ', '
    if @isSuper
-      @superReference(o) + ".call(this#{ args and ', ' + args })"
+      @superReference(o) + ".call(#{@superThis(o)}#{ args and ', ' + args })"
    else
      (if @isNew then 'new ' else '') + @variable.compile(o, LEVEL_ACCESS) + "(#{args})"

  # `super()` is converted into a call against the superclass's implementation
  # of the current function.
  compileSuper: (args, o) ->
-    "#{@superReference(o)}.call(this#{ if args.length then ', ' else '' }#{args})"
+    "#{@superReference(o)}.call(#{@superThis(o)}#{ if args.length then ', ' else '' }#{args})"

  # If you call a function with a splat, it's converted into a JavaScript
  # `.apply()` 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.
  compileSplat: (o, splatArgs) ->
-    return "#{ @superReference o }.apply(this, #{splatArgs})" if @isSuper
+    return "#{ @superReference o }.apply(#{@superThis(o)}, #{splatArgs})" if @isSuper
    if @isNew
      idt = @tab + TAB
      return """
        (function(func, args, ctor) {
        #{idt}ctor.prototype = func.prototype;
-        #{idt}var child = new ctor, result = func.apply(child, args);
-        #{idt}return typeof result === "object" ? result : child;
-        #{@tab}})(#{ @variable.compile o, LEVEL_LIST }, #{splatArgs}, function() {})
+        #{idt}var child = new ctor, result = func.apply(child, args), t = typeof result;
+        #{idt}return t == "object" || t == "function" ? result || child : child;
+        #{@tab}})(#{ @variable.compile o, LEVEL_LIST }, #{splatArgs}, function(){})
      """
    base = new Value @variable
    if (name = base.properties.pop()) and base.isComplex()
@@ -677,6 +701,8 @@ exports.Range = class Range extends Base
    # Set up endpoints.
    known    = @fromNum and @toNum
    idx      = del o, 'index'
+    idxName  = del o, 'name'
+    namedIndex = idxName and idxName isnt idx
    varPart  = "#{idx} = #{@fromC}"
    varPart += ", #{@toC}" if @toC isnt @toVar
    varPart += ", #{@step}" if @step isnt @stepVar
@@ -696,9 +722,18 @@ exports.Range = class Range extends Base
    stepPart = if @stepVar
      "#{idx} += #{@stepVar}"
    else if known
-      if from <= to then "#{idx}++" else "#{idx}--"
+      if namedIndex
+        if from <= to then "++#{idx}" else "--#{idx}"
+      else
+        if from <= to then "#{idx}++" else "#{idx}--"
    else
-      "#{cond} ? #{idx}++ : #{idx}--"
+      if namedIndex
+        "#{cond} ? ++#{idx} : --#{idx}"
+      else
+        "#{cond} ? #{idx}++ : #{idx}--"
+
+    varPart  = "#{idxName} = #{varPart}" if namedIndex
+    stepPart = "#{idxName} = #{stepPart}" if namedIndex

    # The final loop body.
    "#{varPart}; #{condPart}; #{stepPart}"
@@ -744,13 +779,14 @@ exports.Slice = class Slice extends Base
  compileNode: (o) ->
    {to, from} = @range
    fromStr    = from and from.compile(o, LEVEL_PAREN) or '0'
-    compiled   = to and to.compile o, LEVEL_ACCESS
+    compiled   = to and to.compile o, LEVEL_PAREN
    if to and not (not @range.exclusive and +compiled is -1)
      toStr = ', ' + if @range.exclusive
        compiled
      else if SIMPLENUM.test compiled
-        (+compiled + 1).toString()
+        "#{+compiled + 1}"
      else
+        compiled = to.compile o, LEVEL_ACCESS
        "#{compiled} + 1 || 9e9"
    ".slice(#{ fromStr }#{ toStr or '' })"

@@ -765,6 +801,14 @@ exports.Obj = class Obj extends Base

  compileNode: (o) ->
    props = @properties
+    propNames = []
+    for prop in @properties
+      prop = prop.variable if prop.isComplex()
+      if prop?
+        propName = prop.unwrapAll().value.toString()
+        if propName in propNames
+          throw SyntaxError "multiple object literal properties named \"#{propName}\""
+        propNames.push propName
    return (if @front then '({})' else '{}') unless props.length
    if @generated
      for node in props when node instanceof Value
@@ -839,6 +883,8 @@ exports.Class = class Class extends Base
      tail instanceof Access and tail.name.value
    else
      @variable.base.value
+    if decl in STRICT_PROSCRIBED
+      throw SyntaxError "variable name may not be #{decl}"
    decl and= IDENTIFIER.test(decl) and decl

  # For all `this`-references and bound functions in the class definition,
@@ -863,7 +909,7 @@ exports.Class = class Class extends Base
  # Merge the properties from a top-level object as prototypal properties
  # on the class.
  addProperties: (node, name, o) ->
-    props = node.base.properties[0..]
+    props = node.base.properties[..]
    exprs = while assign = props.shift()
      if assign instanceof Assign
        base = assign.variable.base
@@ -902,6 +948,16 @@ exports.Class = class Class extends Base
            exps[i] = @addProperties node, name, o
        child.expressions = exps = flatten exps

+  # `use strict` (and other directives) must be the first expression statement(s)
+  # of a function body. This method ensures the prologue is correctly positioned
+  # above the `constructor`.
+  hoistDirectivePrologue: ->
+    index = 0
+    {expressions} = @body
+    ++index while (node = expressions[index]) and node instanceof Comment or
+      node instanceof Value and node.isString()
+    @directives = expressions.splice 0, index
+
  # Make sure that a constructor is defined for the class, and properly
  # configured.
  ensureConstructor: (name) ->
@@ -909,6 +965,7 @@ exports.Class = class Class extends Base
      @ctor = new Code
      @ctor.body.push new Literal "#{name}.__super__.constructor.apply(this, arguments)" if @parent
      @ctor.body.push new Literal "#{@externalCtor}.apply(this, arguments)" if @externalCtor
+      @ctor.body.makeReturn()
      @body.expressions.unshift @ctor
    @ctor.ctor     = @ctor.name = name
    @ctor.klass    = null
@@ -919,26 +976,29 @@ exports.Class = class Class extends Base
  # constructor, property assignments, and inheritance getting built out below.
  compileNode: (o) ->
    decl  = @determineName()
-    name  = decl or @name or '_Class'
+    name  = decl or '_Class'
    name = "_#{name}" if name.reserved
    lname = new Literal name

+    @hoistDirectivePrologue()
    @setContext name
    @walkBody name, o
    @ensureConstructor name
    @body.spaced = yes
    @body.expressions.unshift @ctor unless @ctor instanceof Code
    @body.expressions.push lname
+    @body.expressions.unshift @directives...
    @addBoundFunctions o

    call  = Closure.wrap @body
-    
+
    if @parent
      @superClass = new Literal o.scope.freeVariable 'super', no
      @body.expressions.unshift new Extends lname, @superClass
      call.args.push @parent
-      call.variable.params.push new Param @superClass
-    
+      params = call.variable.params or call.variable.base.params
+      params.push new Param @superClass
+
    klass = new Parens call, yes
    klass = new Assign @variable, klass if @variable
    klass.compile o
@@ -951,6 +1011,9 @@ exports.Assign = class Assign extends Base
  constructor: (@variable, @value, @context, options) ->
    @param = options and options.param
    @subpattern = options and options.subpattern
+    forbidden = (name = @variable.unwrapAll().value) in STRICT_PROSCRIBED
+    if forbidden and @context isnt 'object'
+      throw SyntaxError "variable name may not be \"#{name}\""

  children: ['variable', 'value']

@@ -1016,7 +1079,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
-      if obj.unwrap().value in ['arguments','eval'].concat RESERVED
+      if obj.unwrap().value in RESERVED
        throw new SyntaxError "assignment to a reserved word: #{obj.compile o} = #{value.compile o}"
      return new Assign(obj, value, null, param: @param).compile o, LEVEL_TOP
    vvar    = value.compile o, LEVEL_LIST
@@ -1061,7 +1124,7 @@ exports.Assign = class Assign extends Base
        else
          acc = isObject and IDENTIFIER.test idx.unwrap().value or 0
        val = new Value new Literal(vvar), [new (if acc then Access else Index) idx]
-      if name? and name in ['arguments','eval'].concat RESERVED
+      if name? and name in RESERVED
        throw new SyntaxError "assignment to a reserved word: #{obj.compile o} = #{val.compile o}"
      assigns.push new Assign(obj, val, null, param: @param, subpattern: yes).compile o, LEVEL_LIST
    assigns.push vvar unless top or @subpattern
@@ -1072,9 +1135,13 @@ exports.Assign = class Assign extends Base
  # operands are only evaluated once, even though we have to reference them
  # more than once.
  compileConditional: (o) ->
-    [left, rite] = @variable.cacheReference o
+    [left, right] = @variable.cacheReference o
+    # Disallow conditional assignment of undefined variables.
+    if not left.properties.length and left.base instanceof Literal and 
+           left.base.value != "this" and not o.scope.check left.base.value
+      throw new Error "the variable \"#{left.base.value}\" can't be assigned with #{@context} because it has not been defined."
    if "?" in @context then o.isExistentialEquals = true
-    new Op(@context[0...-1], left, new Assign(rite, @value, '=') ).compile o
+    new Op(@context[...-1], left, new Assign(right, @value, '=') ).compile o

  # Compile the assignment from an array splice literal, using JavaScript's
  # `Array#splice` method.
@@ -1123,10 +1190,15 @@ exports.Code = class Code extends Base
    o.scope.shared  = del(o, 'sharedScope')
    o.indent        += TAB
    delete o.bare
-    vars   = []
+    delete o.isExistentialEquals
+    params = []
    exprs  = []
+    for name in @paramNames() # this step must be performed before the others
+      unless o.scope.check name then o.scope.parameter name
    for param in @params when param.splat
-      o.scope.add p.name.value, 'var', yes for p in @params when p.name.value
+      for {name: p} in @params
+        if p.this then p = p.properties[0].name
+        if p.value then o.scope.add p.value, 'var', yes
      splats = new Assign new Value(new Arr(p.asReference o for p in @params)),
                          new Value new Literal 'arguments'
      break
@@ -1141,11 +1213,15 @@ exports.Code = class Code extends Base
          lit = new Literal ref.name.value + ' == null'
          val = new Assign new Value(param.name), param.value, '='
          exprs.push new If lit, val
-      vars.push ref unless splats
+      params.push ref unless splats
    wasEmpty = @body.isEmpty()
    exprs.unshift splats if splats
    @body.expressions.unshift exprs... if exprs.length
-    o.scope.parameter vars[i] = v.compile o for v, i in vars unless splats
+    o.scope.parameter params[i] = p.compile o for p, i in params
+    uniqs = []
+    for name in @paramNames()
+      throw SyntaxError "multiple parameters named '#{name}'" if name in uniqs
+      uniqs.push name
    @body.makeReturn() unless wasEmpty or @noReturn
    if @bound
      if o.scope.parent.method?.bound
@@ -1155,12 +1231,18 @@ exports.Code = class Code extends Base
    idt   = o.indent
    code  = 'function'
    code  += ' ' + @name if @ctor
-    code  += '(' + vars.join(', ') + ') {'
+    code  += '(' + params.join(', ') + ') {'
    code  += "\n#{ @body.compileWithDeclarations o }\n#{@tab}" unless @body.isEmpty()
    code  += '}'
    return @tab + code if @ctor
    if @front or (o.level >= LEVEL_ACCESS) then "(#{code})" else code

+  # A list of parameter names, excluding those generated by the compiler.
+  paramNames: ->
+    names = []
+    names.push param.names()... for param in @params
+    names
+
  # Short-circuit `traverseChildren` method to prevent it from crossing scope boundaries
  # unless `crossScope` is `true`.
  traverseChildren: (crossScope, func) ->
@@ -1173,6 +1255,8 @@ exports.Code = class Code extends Base
 # as well as be a splat, gathering up a group of parameters into an array.
 exports.Param = class Param extends Base
  constructor: (@name, @value, @splat) ->
+    if (name = @name.unwrapAll().value) in STRICT_PROSCRIBED
+      throw SyntaxError "parameter name \"#{name}\" is not allowed"

  children: ['name', 'value']

@@ -1184,7 +1268,8 @@ exports.Param = class Param extends Base
    node = @name
    if node.this
      node = node.properties[0].name
-      node = new Literal '_' + node.value if node.value.reserved
+      if node.value.reserved
+        node = new Literal o.scope.freeVariable node.value
    else if node.isComplex()
      node = new Literal o.scope.freeVariable 'arg'
    node = new Value node
@@ -1194,6 +1279,42 @@ exports.Param = class Param extends Base
  isComplex: ->
    @name.isComplex()

+  # Finds the name or names of a `Param`; useful for detecting duplicates.
+  # In a sense, a destructured parameter represents multiple JS parameters,
+  # thus this method returns an `Array` of names.
+  # Reserved words used as param names, as well as the Object and Array
+  # literals used for destructured params, get a compiler generated name
+  # during the `Code` compilation step, so this is necessarily an incomplete
+  # list of a parameter's names.
+  names: (name = @name)->
+    atParam = (obj) ->
+      {value} = obj.properties[0].name
+      return if value.reserved then [] else [value]
+    # * simple literals `foo`
+    return [name.value] if name instanceof Literal
+    # * at-params `@foo`
+    return atParam(name) if name instanceof Value
+    names = []
+    for obj in name.objects
+      # * assignments within destructured parameters `{foo:bar}`
+      if obj instanceof Assign
+        names.push obj.value.unwrap().value
+      # * splats within destructured parameters `[xs...]`
+      else if obj instanceof Splat
+        names.push obj.name.unwrap().value
+      else if obj instanceof Value
+        # * destructured parameters within destructured parameters `[{a}]`
+        if obj.isArray() or obj.isObject()
+          names.push @names(obj.base)...
+        # * at-params within destructured parameters `{@foo}`
+        else if obj.this
+          names.push atParam(obj)...
+        # * simple destructured parameters {foo}
+        else names.push obj.base.value
+      else
+        throw SyntaxError "illegal parameter #{obj.compile()}"
+    names
+
 #### Splat

 # A splat, either as a parameter to a function, an argument to a call,
@@ -1212,7 +1333,7 @@ exports.Splat = class Splat extends Base

  compile: (o) ->
    if @index? then @compileParam o else @name.compile o
-    
+
  unwrap: -> @name

  # Utility function that converts an arbitrary number of elements, mixed with
@@ -1232,7 +1353,7 @@ exports.Splat = class Splat extends Base
      then "#{ utility 'slice' }.call(#{code})"
      else "[#{code}]"
    return args[0] + ".concat(#{ args[1..].join ', ' })" if index is 0
-    base = (node.compile o, LEVEL_LIST for node in list[0...index])
+    base = (node.compile o, LEVEL_LIST for node in list[...index])
    "[#{ base.join ', ' }].concat(#{ args.join ', ' })"

 #### While
@@ -1298,9 +1419,7 @@ exports.Op = class Op extends Base
  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
+      return @generateDo first
    if op is 'new'
      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
@@ -1366,11 +1485,31 @@ exports.Op = class Op extends Base
  unfoldSoak: (o) ->
    @operator in ['++', '--', 'delete'] and unfoldSoak o, this, 'first'

-  compileNode: (o) ->    
+  generateDo: (exp) ->
+    passedParams = []
+    func = if exp instanceof Assign and (ref = exp.value.unwrap()) instanceof Code
+      ref
+    else
+      exp
+    for param in func.params or []
+      if param.value
+        passedParams.push param.value
+        delete param.value
+      else
+        passedParams.push param
+    call = new Call exp, passedParams
+    call.do = yes
+    call
+
+  compileNode: (o) ->
    isChain = @isChainable() and @first.isChainable()
-    # In chains, there's no need to wrap bare obj literals in parens, 
+    # In chains, there's no need to wrap bare obj literals in parens,
    # as the chained expression is wrapped.
    @first.front = @front unless isChain
+    if @operator is 'delete' and o.scope.check(@first.unwrapAll().value)
+      throw SyntaxError 'delete operand may not be argument or var'
+    if @operator in ['--', '++'] and @first.unwrapAll().value in STRICT_PROSCRIBED
+      throw SyntaxError 'prefix increment/decrement may not have eval or arguments operand'
    return @compileUnary     o if @isUnary()
    return @compileChain     o if isChain
    return @compileExistence o if @operator is '?'
@@ -1390,7 +1529,7 @@ exports.Op = class Op extends Base
    "(#{code})"

  compileExistence: (o) ->
-    if @first.isComplex() and o.level > LEVEL_TOP
+    if @first.isComplex()
      ref = new Literal o.scope.freeVariable 'ref'
      fst = new Parens new Assign ref, @first
    else
@@ -1400,12 +1539,14 @@ exports.Op = class Op extends Base

  # Compile a unary **Op**.
  compileUnary: (o) ->
+    if o.level >= LEVEL_ACCESS
+      return (new Parens this).compile o
    parts = [op = @operator]
    plusMinus = op in ['+', '-']
    parts.push ' ' if op in ['new', 'typeof', 'delete'] or
                      plusMinus and @first instanceof Op and @first.operator is op
    if (plusMinus && @first instanceof Op) or (op is 'new' and @first.isStatement o)
-      @first = new Parens @first 
+      @first = new Parens @first
    parts.push @first.compile o, LEVEL_OP
    parts.reverse() if @flip
    parts.join ''
@@ -1473,15 +1614,17 @@ exports.Try = class Try extends Base
    o.indent  += TAB
    errorPart = if @error then " (#{ @error.compile o }) " else ' '
    tryPart   = @attempt.compile o, LEVEL_TOP
-    
+
    catchPart = if @recovery
+      if @error.value in STRICT_PROSCRIBED
+        throw SyntaxError "catch variable may not be \"#{@error.value}\""
      o.scope.add @error.value, 'param' unless o.scope.check @error.value
      " catch#{errorPart}{\n#{ @recovery.compile o, LEVEL_TOP }\n#{@tab}}"
    else unless @ensure or @recovery
      ' catch (_error) {}'
-      
+
    ensurePart = if @ensure then " finally {\n#{ @ensure.compile o, LEVEL_TOP }\n#{@tab}}" else ''
-      
+
    """#{@tab}try {
    #{tryPart}
    #{@tab}}#{ catchPart or '' }#{ensurePart}"""
@@ -1588,10 +1731,12 @@ exports.For = class For extends While
    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
+    scope.find(name)  if name and not @pattern
+    scope.find(index) if index
    rvar      = scope.freeVariable 'results' if @returns
-    ivar      = (if @range then name else index) or scope.freeVariable 'i'
+    ivar      = (@object and index) or scope.freeVariable 'i'
+    kvar      = (@range and name) or index or ivar
+    kvarAssign = if kvar isnt ivar then "#{kvar} = " else ""
    # 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
@@ -1600,18 +1745,19 @@ exports.For = class For extends While
    defPart   = ''
    idt1      = @tab + TAB
    if @range
-      forPart = source.compile merge(o, {index: ivar, @step})
+      forPart = source.compile merge(o, {index: ivar, name, @step})
    else
      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
      if name and not @pattern
-        namePart   = "#{name} = #{svar}[#{ivar}]"
+        namePart   = "#{name} = #{svar}[#{kvar}]"
      unless @object
        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}++"
+        forVarPart = "#{kvarAssign}#{ivar} = 0, #{lvar} = #{svar}.length"
+        forVarPart += ", #{stepvar} = #{@step.compile o, LEVEL_OP}" if @step
+        stepPart   = "#{kvarAssign}#{if @step then "#{ivar} += #{stepvar}" else (if kvar isnt ivar then "++#{ivar}" else "#{ivar}++")}"
        forPart    = "#{forVarPart}; #{ivar} < #{lvar}; #{stepPart}"
    if @returns
      resultPart   = "#{@tab}#{rvar} = [];\n"
@@ -1623,12 +1769,12 @@ exports.For = class For extends While
      else
        body = Block.wrap [new If @guard, body] if @guard
    if @pattern
-      body.expressions.unshift new Assign @name, new Literal "#{svar}[#{ivar}]"
+      body.expressions.unshift new Assign @name, new Literal "#{svar}[#{kvar}]"
    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
+      forPart   = "#{kvar} in #{svar}"
+      guardPart = "\n#{idt1}if (!#{utility 'hasProp'}.call(#{svar}, #{kvar})) continue;" if @own
    body        = body.compile merge(o, indent: idt1), LEVEL_TOP
    body        = '\n' + body + '\n' if body
    """
@@ -1752,17 +1898,7 @@ exports.If = class If extends Base
    cond     = @condition.compile o, LEVEL_PAREN
    o.indent += TAB
    body     = @ensureBlock(@body)
-    bodyc    = body.compile o
-    if (
-      1 is body.expressions?.length and
-      !@elseBody and !child and
-      bodyc and cond and
-      -1 is (bodyc.indexOf '\n') and
-      80 > cond.length + bodyc.length
-    )
-      return "#{@tab}if (#{cond}) #{bodyc.replace /^\s+/, ''}"
-    bodyc    = "\n#{bodyc}\n#{@tab}" if bodyc
-    ifPart   = "if (#{cond}) {#{bodyc}}"
+    ifPart   = "if (#{cond}) {\n#{body.compile(o)}\n#{@tab}}"
    ifPart   = @tab + ifPart unless child
    return ifPart unless @elseBody
    ifPart + ' else ' + if @isChain
@@ -1811,10 +1947,11 @@ Closure =

  literalArgs: (node) ->
    node instanceof Literal and node.value is 'arguments' and not node.asKey
-    
+
  literalThis: (node) ->
    (node instanceof Literal and node.value is 'this' and not node.asKey) or
-      (node instanceof Code and node.bound)
+      (node instanceof Code and node.bound) or
+      (node instanceof Call and node.isSuper)

 # Unfold a node's child if soak, then tuck the node under created `If`
 unfoldSoak = (o, parent, name) ->
@@ -1831,7 +1968,7 @@ UTILITIES =
  # Correctly set up a prototype chain for inheritance, including a reference
  # to the superclass for `super()` calls, and copies of any static properties.
  extends: -> """
-    function(child, parent) { for (var key in parent) { if (#{utility 'hasProp'}.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor; child.__super__ = parent.prototype; return child; }
+    function(child, parent) { for (var key in parent) { if (#{utility 'hasProp'}.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }
  """

  # Create a function bound to the current value of "this".
@@ -1841,12 +1978,12 @@ UTILITIES =

  # Discover if an item is in an array.
  indexOf: -> """
-    Array.prototype.indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; }
+    [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; }
  """

  # Shortcuts to speed up the lookup time for native functions.
-  hasProp: -> 'Object.prototype.hasOwnProperty'
-  slice  : -> 'Array.prototype.slice'
+  hasProp: -> '{}.hasOwnProperty'
+  slice  : -> '[].slice'

 # Levels indicate a node's position in the AST. Useful for knowing if
 # parens are necessary or superfluous.
--- a/src/optparse.coffee
+++ b/src/optparse.coffee
@@ -17,34 +17,42 @@ exports.OptionParser = class OptionParser
    @rules = buildRules rules

  # Parse the list of arguments, populating an `options` object with all of the
-  # 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
-  # you to attach callback actions for every flag. Instead, you're responsible
-  # for interpreting the options object.
+  # specified options, and return it. Options after the first non-option
+  # argument are treated as arguments. `options.arguments` will be an array
+  # containing the remaining arguments. This is a simpler API than many option
+  # parsers that allow you to attach callback actions for every flag. Instead,
+  # you're responsible for interpreting the options object.
  parse: (args) ->
-    options = arguments: [], literals: []
+    options = arguments: []
+    skippingArgument = no
    originalArgs = args
    args = normalizeArguments args
    for arg, i in args
+      if skippingArgument
+        skippingArgument = no
+        continue
      if arg is '--'
        pos = originalArgs.indexOf '--'
-        options.arguments = [originalArgs[1 + pos]]
-        options.literals = originalArgs[(2 + pos)..]
+        options.arguments = options.arguments.concat originalArgs[(pos + 1)..]
        break
      isOption = !!(arg.match(LONG_FLAG) or arg.match(SHORT_FLAG))
-      matchedRule = no
-      for rule in @rules
-        if rule.shortFlag is arg or rule.longFlag is arg
-          value = if rule.hasArgument then args[i += 1] else true
-          options[rule.name] = if rule.isList then (options[rule.name] or []).concat value else value
-          matchedRule = yes
-          break
-      throw new Error "unrecognized option: #{arg}" if isOption and not matchedRule
-      if not isOption
-        options.arguments = originalArgs[(originalArgs.indexOf arg)..]
-        break
+      # the CS option parser is a little odd; options after the first
+      # non-option argument are treated as non-option arguments themselves
+      seenNonOptionArg = options.arguments.length > 0
+      unless seenNonOptionArg
+        matchedRule = no
+        for rule in @rules
+          if rule.shortFlag is arg or rule.longFlag is arg
+            value = true
+            if rule.hasArgument
+              skippingArgument = yes
+              value = args[i + 1]
+            options[rule.name] = if rule.isList then (options[rule.name] or []).concat value else value
+            matchedRule = yes
+            break
+        throw new Error "unrecognized option: #{arg}" if isOption and not matchedRule
+      if seenNonOptionArg or not isOption
+        options.arguments.push arg
    options

  # Return the help text for this **OptionParser**, listing and describing all
@@ -63,8 +71,8 @@ exports.OptionParser = class OptionParser
 # -------

 # Regex matchers for option flags.
-LONG_FLAG  = /^(--\w[\w\-]+)/
-SHORT_FLAG = /^(-\w)/
+LONG_FLAG  = /^(--\w[\w\-]*)/
+SHORT_FLAG = /^(-\w)$/
 MULTI_FLAG = /^-(\w{2,})/
 OPTIONAL   = /\[(\w+(\*?))\]/

@@ -92,7 +100,7 @@ buildRule = (shortFlag, longFlag, description, options = {}) ->
 # Normalize arguments by expanding merged flags into multiple flags. This allows
 # you to have `-wl` be the same as `--watch --lint`.
 normalizeArguments = (args) ->
-  args = args.slice 0
+  args = args[..]
  result = []
  for arg in args
    if match = arg.match MULTI_FLAG
--- a/src/repl.coffee
+++ b/src/repl.coffee
@@ -4,6 +4,10 @@
 #
 #     coffee> console.log "#{num} bottles of beer" for num in [99..1]

+# Start by opening up `stdin` and `stdout`.
+stdin = process.openStdin()
+stdout = process.stdout
+
 # Require the **coffee-script** module to get access to the compiler.
 CoffeeScript = require './coffee-script'
 readline     = require 'readline'
@@ -15,19 +19,59 @@ Module       = require 'module'

 # Config
 REPL_PROMPT = 'coffee> '
+REPL_PROMPT_MULTILINE = '------> '
 REPL_PROMPT_CONTINUATION = '......> '
 enableColours = no
 unless process.platform is 'win32'
  enableColours = not process.env.NODE_DISABLE_COLORS

-# Start by opening up `stdin` and `stdout`.
-stdin = process.openStdin()
-stdout = process.stdout
-
 # Log an error.
 error = (err) ->
  stdout.write (err.stack or err.toString()) + '\n'

+## Autocompletion
+
+# Regexes to match complete-able bits of text.
+ACCESSOR  = /\s*([\w\.]+)(?:\.(\w*))$/
+SIMPLEVAR = /(\w+)$/i
+
+# Returns a list of completions, and the completed text.
+autocomplete = (text) ->
+  completeAttribute(text) or completeVariable(text) or [[], text]
+
+# Attempt to autocomplete a chained dotted attribute: `one.two.three`.
+completeAttribute = (text) ->
+  if match = text.match ACCESSOR
+    [all, obj, prefix] = match
+    try
+      val = Script.runInThisContext obj
+    catch error
+      return
+    val = Object val
+    possibilities = Object.getOwnPropertyNames val
+    for key of val when ~possibilities.indexOf val
+      possibilities.push key
+    completions = getCompletions prefix, possibilities
+    [completions, prefix]
+
+# Attempt to autocomplete an in-scope free variable: `one`.
+completeVariable = (text) ->
+  free = text.match(SIMPLEVAR)?[1]
+  free = "" if text is ""
+  if free?
+    vars = Script.runInThisContext 'Object.getOwnPropertyNames(Object(this))'
+    keywords = (r for r in CoffeeScript.RESERVED when r[..1] isnt '__')
+    possibilities = vars.concat keywords
+    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)
+
+# Make sure that uncaught exceptions don't kill the REPL.
+process.on 'uncaughtException', error
+
 # The current backlog of multi-line code.
 backlog = ''

@@ -35,6 +79,15 @@ backlog = ''
 # Attempt to evaluate the command. If there's an exception, print it out instead
 # of exiting.
 run = (buffer) ->
+  # remove single-line comments
+  buffer = buffer.replace /(^|[\r\n]+)(\s*)##?(?:[^#\r\n][^\r\n]*|)($|[\r\n])/, "$1$2$3"
+  # remove trailing newlines
+  buffer = buffer.replace /[\r\n]+$/, ""
+  if multilineMode
+    backlog += "#{buffer}\n"
+    repl.setPrompt REPL_PROMPT_CONTINUATION
+    repl.prompt()
+    return
  if !buffer.toString().trim() and !backlog
    repl.prompt()
    return
@@ -54,68 +107,85 @@ run = (buffer) ->
    }
    if returnValue is undefined
      global._ = _
-    process.stdout.write inspect(returnValue, no, 2, enableColours) + '\n'
+    repl.output.write "#{inspect returnValue, no, 2, enableColours}\n"
  catch err
    error err
  repl.prompt()

-## Autocompletion
-
-# Regexes to match complete-able bits of text.
-ACCESSOR  = /\s*([\w\.]+)(?:\.(\w*))$/
-SIMPLEVAR = /\s*(\w*)$/i
-
-# Returns a list of completions, and the completed text.
-autocomplete = (text) ->
-  completeAttribute(text) or completeVariable(text) or [[], text]
-
-# Attempt to autocomplete a chained dotted attribute: `one.two.three`.
-completeAttribute = (text) ->
-  if match = text.match ACCESSOR
-    [all, obj, prefix] = match
-    try
-      val = Script.runInThisContext obj
-    catch error
-      return
-    completions = getCompletions prefix, Object.getOwnPropertyNames val
-    [completions, prefix]
-
-# Attempt to autocomplete an in-scope free variable: `one`.
-completeVariable = (text) ->
-  free = (text.match SIMPLEVAR)?[1]
-  if free?
-    vars = Script.runInThisContext 'Object.getOwnPropertyNames(this)'
-    keywords = (r for r in CoffeeScript.RESERVED when r[0..1] isnt '__')
-    possibilities = vars.concat keywords
-    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)
-
-# Make sure that uncaught exceptions don't kill the REPL.
-process.on 'uncaughtException', error
-
-# Create the REPL by listening to **stdin**.
-if readline.createInterface.length < 3
-  repl = readline.createInterface stdin, autocomplete
-  stdin.on 'data', (buffer) -> repl.write buffer
+if stdin.readable
+  # handle piped input
+  pipedInput = ''
+  repl =
+    prompt: -> stdout.write @_prompt
+    setPrompt: (p) -> @_prompt = p
+    input: stdin
+    output: stdout
+    on: ->
+  stdin.on 'data', (chunk) ->
+    pipedInput += chunk
+    return unless /\n/.test pipedInput
+    lines = pipedInput.split "\n"
+    pipedInput = lines[lines.length - 1]
+    for line in lines[...-1] when line
+      stdout.write "#{line}\n"
+      run line
+    return
+  stdin.on 'end', ->
+    for line in pipedInput.trim().split "\n" when line
+      stdout.write "#{line}\n"
+      run line
+    stdout.write '\n'
+    process.exit 0
 else
-  repl = readline.createInterface stdin, stdout, autocomplete
+  # Create the REPL by listening to **stdin**.
+  if readline.createInterface.length < 3
+    repl = readline.createInterface stdin, autocomplete
+    stdin.on 'data', (buffer) -> repl.write buffer
+  else
+    repl = readline.createInterface stdin, stdout, autocomplete
+
+multilineMode = off
+
+# Handle multi-line mode switch
+repl.input.on 'keypress', (char, key) ->
+  # test for Ctrl-v
+  return unless key and key.ctrl and not key.meta and not key.shift and key.name is 'v'
+  cursorPos = repl.cursor
+  repl.output.cursorTo 0
+  repl.output.clearLine 1
+  multilineMode = not multilineMode
+  repl._line() if not multilineMode and backlog
+  backlog = ''
+  repl.setPrompt (newPrompt = if multilineMode then REPL_PROMPT_MULTILINE else REPL_PROMPT)
+  repl.prompt()
+  repl.output.cursorTo newPrompt.length + (repl.cursor = cursorPos)
+
+# Handle Ctrl-d press at end of last line in multiline mode
+repl.input.on 'keypress', (char, key) ->
+  return unless multilineMode and repl.line
+  # test for Ctrl-d
+  return unless key and key.ctrl and not key.meta and not key.shift and key.name is 'd'
+  multilineMode = off
+  repl._line()

 repl.on 'attemptClose', ->
+  if multilineMode
+    multilineMode = off
+    repl.output.cursorTo 0
+    repl.output.clearLine 1
+    repl._onLine repl.line
+    return
  if backlog
    backlog = ''
-    process.stdout.write '\n'
+    repl.output.write '\n'
    repl.setPrompt REPL_PROMPT
    repl.prompt()
  else
    repl.close()

 repl.on 'close', ->
-  process.stdout.write '\n'
-  stdin.destroy()
+  repl.output.write '\n'
+  repl.input.destroy()

 repl.on 'line', run

--- a/src/rewriter.coffee
+++ b/src/rewriter.coffee
@@ -70,14 +70,14 @@ class exports.Rewriter
  # its paired close. We have the mis-nested outdent case included here for
  # calls that close on the same line, just before their outdent.
  closeOpenCalls: ->
-    
+
    condition = (token, i) ->
      token[0] in [')', 'CALL_END'] or
      token[0] is 'OUTDENT' and @tag(i - 1) is ')'
-      
+
    action = (token, i) ->
      @tokens[if token[0] is 'OUTDENT' then i - 1 else i][0] = 'CALL_END'
-      
+
    @scanTokens (token, i) ->
      @detectEnd i + 1, condition, action if token[0] is 'CALL_START'
      1
@@ -85,13 +85,13 @@ class exports.Rewriter
  # The lexer has tagged the opening parenthesis of an indexing operation call.
  # Match it with its paired close.
  closeOpenIndexes: ->
-    
-    condition = (token, i) -> 
+
+    condition = (token, i) ->
      token[0] in [']', 'INDEX_END']
-      
-    action = (token, i) -> 
+
+    action = (token, i) ->
      token[0] = 'INDEX_END'
-      
+
    @scanTokens (token, i) ->
      @detectEnd i + 1, condition, action if token[0] is 'INDEX_START'
      1
@@ -99,29 +99,32 @@ class exports.Rewriter
  # Object literals may be written with implicit braces, for simple cases.
  # Insert the missing braces here, so that the parser doesn't have to.
  addImplicitBraces: ->
-    
+
    stack       = []
    start       = null
    startsLine  = null
    sameLine    = yes
    startIndent = 0
-    
+    startIndex  = 0
+
    condition = (token, i) ->
      [one, two, three] = @tokens[i + 1 .. i + 3]
      return no if 'HERECOMMENT' is one?[0]
      [tag] = token
      sameLine = no if tag in LINEBREAKS
-      ((tag in ['TERMINATOR', 'OUTDENT'] or (tag in IMPLICIT_END and sameLine)) and
-          ((!startsLine and @tag(i - 1) isnt ',') or 
+      return (
+        (tag in ['TERMINATOR', 'OUTDENT'] or 
+          (tag in IMPLICIT_END and sameLine and not (i - startIndex is 1))) and
+        ((!startsLine and @tag(i - 1) isnt ',') or
          not (two?[0] is ':' or one?[0] is '@' and three?[0] is ':'))) or
        (tag is ',' and one and
-          one[0] not in ['IDENTIFIER', 'NUMBER', 'STRING', '@', 'TERMINATOR', 'OUTDENT'])
-          
+          one[0] not in ['IDENTIFIER', 'NUMBER', 'STRING', '@', 'TERMINATOR', 'OUTDENT']
+      )
+
    action = (token, i) ->
-      tok = ['}', '}', token[2]]
-      tok.generated = yes
+      tok = @generate '}', '}', token[2]
      @tokens.splice i, 0, tok
-      
+
    @scanTokens (token, i, tokens) ->
      if (tag = token[0]) in EXPRESSION_START
        stack.push [(if tag is 'INDENT' and @tag(i - 1) is '{' then '{' else tag), i]
@@ -132,6 +135,7 @@ class exports.Rewriter
      return 1 unless tag is ':' and
        ((ago = @tag i - 2) is ':' or stack[stack.length - 1]?[0] isnt '{')
      sameLine = yes
+      startIndex = i + 1
      stack.push ['{']
      idx =  if ago is '@' then i - 2 else i - 1
      idx -= 2 while @tag(idx - 2) is 'HERECOMMENT'
@@ -139,8 +143,7 @@ class exports.Rewriter
      startsLine = not prevTag or (prevTag in LINEBREAKS)
      value = new String('{')
      value.generated = yes
-      tok = ['{', value, token[2]]
-      tok.generated = yes
+      tok = @generate '{', value, token[2]
      tokens.splice idx, 0, tok
      @detectEnd i + 2, condition, action
      2
@@ -149,9 +152,9 @@ class exports.Rewriter
  # Insert the implicit parentheses here, so that the parser doesn't have to
  # deal with them.
  addImplicitParentheses: ->
-    
+
    noCall = seenSingle = seenControl = no
-    
+
    condition = (token, i) ->
      [tag] = token
      return yes if not seenSingle and token.fromThen
@@ -163,13 +166,13 @@ class exports.Rewriter
        (tag isnt 'INDENT' or
          (@tag(i - 2) not in ['CLASS', 'EXTENDS'] and @tag(i - 1) not in IMPLICIT_BLOCK and
          not ((post = @tokens[i + 1]) and post.generated and post[0] is '{')))
-    
-    action = (token, i) -> 
-      @tokens.splice i, 0, ['CALL_END', ')', token[2]]
-      
+
+    action = (token, i) ->
+      @tokens.splice i, 0, @generate 'CALL_END', ')', token[2]
+
    @scanTokens (token, i, tokens) ->
      tag     = token[0]
-      noCall  = yes if tag in ['CLASS', 'IF']
+      noCall  = yes if tag in ['CLASS', 'IF', 'FOR', 'WHILE']
      [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
@@ -182,7 +185,7 @@ class exports.Rewriter
      return 1 unless callObject or
        prev?.spaced and (prev.call or prev[0] in IMPLICIT_FUNC) and
        (tag in IMPLICIT_CALL or not (token.spaced or token.newLine) and tag in IMPLICIT_UNSPACED_CALL)
-      tokens.splice i, 0, ['CALL_START', '(', token[2]]
+      tokens.splice i, 0, @generate 'CALL_START', '(', token[2]
      @detectEnd i + 1, condition, action
      prev[0] = 'FUNC_EXIST' if prev[0] is '?'
      2
@@ -192,16 +195,16 @@ class exports.Rewriter
  # blocks, so it doesn't need to. ')' can close a single-line block,
  # but we need to make sure it's balanced.
  addImplicitIndentation: ->
-    
+
    starter = indent = outdent = null
-    
+
    condition = (token, i) ->
      token[1] isnt ';' and token[0] in SINGLE_CLOSERS and
      not (token[0] is 'ELSE' and starter not in ['IF', 'THEN'])
-      
+
    action = (token, i) ->
      @tokens.splice (if @tag(i - 1) is ',' then i - 1 else i), 0, outdent
-    
+
    @scanTokens (token, i, tokens) ->
      [tag] = token
      if tag is 'TERMINATOR' and @tag(i + 1) is 'THEN'
@@ -216,9 +219,8 @@ class exports.Rewriter
      if tag in SINGLE_LINERS and @tag(i + 1) isnt 'INDENT' and
         not (tag is 'ELSE' and @tag(i + 1) is 'IF')
        starter = tag
-        [indent, outdent] = @indentation token
+        [indent, outdent] = @indentation token, yes
        indent.fromThen   = true if starter is 'THEN'
-        indent.generated  = outdent.generated = true
        tokens.splice i + 1, 0, indent
        @detectEnd i + 2, condition, action
        tokens.splice i, 1 if tag is 'THEN'
@@ -228,16 +230,16 @@ class exports.Rewriter
  # Tag postfix conditionals as such, so that we can parse them with a
  # different precedence.
  tagPostfixConditionals: ->
-        
+
    original = null
-    
-    condition = (token, i) -> 
+
+    condition = (token, i) ->
      token[0] in ['TERMINATOR', 'INDENT']
-      
+
    action = (token, i) ->
      if token[0] isnt 'INDENT' or (token.generated and not token.fromThen)
-        original[0] = 'POST_' + original[0] 
-    
+        original[0] = 'POST_' + original[0]
+
    @scanTokens (token, i) ->
      return 1 unless token[0] is 'IF'
      original = token
@@ -245,8 +247,17 @@ class exports.Rewriter
      1

  # Generate the indentation tokens, based on another token on the same line.
-  indentation: (token) ->
-    [['INDENT', 2, token[2]], ['OUTDENT', 2, token[2]]]
+  indentation: (token, implicit = no) ->
+    indent  = ['INDENT', 2, token[2]]
+    outdent = ['OUTDENT', 2, token[2]]
+    indent.generated = outdent.generated = yes if implicit
+    [indent, outdent]
+
+  # Create a generated token: one that exists due to a use of implicit syntax.
+  generate: (tag, value, line) ->
+    tok = [tag, value, line]
+    tok.generated = yes
+    tok

  # Look up a tag by token index.
  tag: (i) -> @tokens[i]?[0]
@@ -286,7 +297,7 @@ IMPLICIT_FUNC    = ['IDENTIFIER', 'SUPER', ')', 'CALL_END', ']', 'INDEX_END', '@
 # If preceded by an `IMPLICIT_FUNC`, indicates a function invocation.
 IMPLICIT_CALL    = [
  'IDENTIFIER', 'NUMBER', 'STRING', 'JS', 'REGEX', 'NEW', 'PARAM_START', 'CLASS'
-  'IF', 'TRY', 'SWITCH', 'THIS', 'BOOL', 'UNARY', 'SUPER'
+  'IF', 'TRY', 'SWITCH', 'THIS', 'BOOL', 'NULL', 'UNDEFINED', 'UNARY', 'SUPER'
  '@', '->', '=>', '[', '(', '{', '--', '++'
 ]

--- a/src/scope.coffee
+++ b/src/scope.coffee
@@ -30,10 +30,19 @@ exports.Scope = class Scope
    else
      @positions[name] = @variables.push({name, type}) - 1

+  # When `super` is called, we need to find the name of the current method we're 
+  # in, so that we know how to invoke the same method of the parent class. This 
+  # can get complicated if super is being called from an inner function. 
+  # `namedMethod` will walk up the scope tree until it either finds the first 
+  # function object that has a name filled in, or bottoms out.
+  namedMethod: ->
+    return @method if @method.name or !@parent
+    @parent.namedMethod()
+
  # Look up a variable name in lexical scope, and declare it if it does not
  # already exist.
-  find: (name, options) ->
-    return yes if @check name, options
+  find: (name) ->
+    return yes if @check name
    @add name, 'var'
    no

@@ -45,15 +54,13 @@ exports.Scope = class Scope

  # Just check to see if a variable has already been declared, without reserving,
  # walks up to the root scope.
-  check: (name, immediate) ->
-    found = !!@type(name)
-    return found if found or immediate
-    !!@parent?.check name
+  check: (name) ->
+    !!(@type(name) or @parent?.check(name))

  # Generate a temporary variable name at the given index.
  temporary: (name, index) ->
    if name.length > 1
-      '_' + name + if index > 1 then index else ''
+      '_' + name + if index > 1 then index - 1 else ''
    else
      '_' + (index + parseInt name, 36).toString(36).replace /\d/g, 'a'

--- a/test/assignment.coffee
+++ b/test/assignment.coffee
@@ -19,12 +19,6 @@ test "unassignable values", ->
  for nonref in ['', '""', '0', 'f()'].concat CoffeeScript.RESERVED
    eq nonce, (try CoffeeScript.compile "#{nonref} = v" catch e then nonce)

-test "compound assignments should not declare", ->
-  # TODO: make description more clear
-  # TODO: remove reference to Math
-  eq Math, (-> Math or= 0)()
-
-
 # Compound Assignment

 test "boolean operators", ->
@@ -267,6 +261,10 @@ test "#1005: invalid identifiers allowed on LHS of destructuring assignment", ->
      CoffeeScript.compile "[@#{v}] = x"
      CoffeeScript.compile "[@#{v}...] = x"

+test "#2055: destructuring assignment with `new`", ->
+  {length} = new Array
+  eq 0, length
+

 # Existential Assignment

@@ -281,8 +279,30 @@ test "existential assignment", ->
  c = null
  c ?= nonce
  eq nonce, c
-  d ?= nonce
-  eq nonce, d
+
+test "#1627: prohibit conditional assignment of undefined variables", ->
+  throws (-> CoffeeScript.compile "x ?= 10"),        null, "prohibit (x ?= 10)"
+  throws (-> CoffeeScript.compile "x ||= 10"),       null, "prohibit (x ||= 10)"
+  throws (-> CoffeeScript.compile "x or= 10"),       null, "prohibit (x or= 10)"
+  throws (-> CoffeeScript.compile "do -> x ?= 10"),  null, "prohibit (do -> x ?= 10)"
+  throws (-> CoffeeScript.compile "do -> x ||= 10"), null, "prohibit (do -> x ||= 10)"
+  throws (-> CoffeeScript.compile "do -> x or= 10"), null, "prohibit (do -> x or= 10)"
+  doesNotThrow (-> CoffeeScript.compile "x = null; x ?= 10"),        "allow (x = null; x ?= 10)"
+  doesNotThrow (-> CoffeeScript.compile "x = null; x ||= 10"),       "allow (x = null; x ||= 10)"
+  doesNotThrow (-> CoffeeScript.compile "x = null; x or= 10"),       "allow (x = null; x or= 10)"
+  doesNotThrow (-> CoffeeScript.compile "x = null; do -> x ?= 10"),  "allow (x = null; do -> x ?= 10)"
+  doesNotThrow (-> CoffeeScript.compile "x = null; do -> x ||= 10"), "allow (x = null; do -> x ||= 10)"
+  doesNotThrow (-> CoffeeScript.compile "x = null; do -> x or= 10"), "allow (x = null; do -> x or= 10)"
+  
+  throws (-> CoffeeScript.compile "-> -> -> x ?= 10"), null, "prohibit (-> -> -> x ?= 10)"
+  doesNotThrow (-> CoffeeScript.compile "x = null; -> -> -> x ?= 10"), "allow (x = null; -> -> -> x ?= 10)"
+  
+test "more existential assignment", ->
+  global.temp ?= 0
+  eq global.temp, 0
+  global.temp or= 100
+  eq global.temp, 100
+  delete global.temp

 test "#1348, #1216: existential assignment compilation", ->
  nonce = {}
@@ -292,13 +312,6 @@ test "#1348, #1216: existential assignment compilation", ->
  #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

@@ -307,14 +320,14 @@ test "#1591, #1101: splatted expressions in destructuring assignment must be ass
  for nonref in ['', '""', '0', 'f()', '(->)'].concat CoffeeScript.RESERVED
    eq nonce, (try CoffeeScript.compile "[#{nonref}...] = v" catch e then nonce)

-test "#1643: splatted accesses in destructuring assignments should not be declared as variables", -> 
+test "#1643: splatted accesses in destructuring assignments should not be declared as variables", ->
  nonce = {}
  accesses = ['o.a', 'o["a"]', '(o.a)', '(o.a).a', '@o.a', 'C::a', 'C::', 'f().a', 'o?.a', 'o?.a.b', 'f?().a']
  for access in accesses
    for i,j in [1,2,3] #position can matter
-      code = 
+      code =
        """
-        nonce = {}; nonce2 = {}; nonce3 = {}; 
+        nonce = {}; nonce2 = {}; nonce3 = {};
        @o = o = new (class C then a:{}); f = -> o
        [#{new Array(i).join('x,')}#{access}...] = [#{new Array(i).join('0,')}nonce, nonce2, nonce3]
        unless #{access}[0] is nonce and #{access}[1] is nonce2 and #{access}[2] is nonce3 then throw new Error('[...]')
@@ -326,7 +339,7 @@ test "#1643: splatted accesses in destructuring assignments should not be declar
    for i,j in [1,2,3]
      code =
        """
-        nonce = {}; nonce2 = {}; nonce3 = {}; 
+        nonce = {}; nonce2 = {}; nonce3 = {};
        [#{new Array(i).join('x,')}#{subpattern}...] = [#{new Array(i).join('0,')}nonce, nonce2, nonce3]
        unless sub is nonce and sub2 is nonce2 and sub3 is nonce3 then throw new Error('[sub...]')
        """
@@ -335,5 +348,20 @@ test "#1643: splatted accesses in destructuring assignments should not be declar
 test "#1838: Regression with variable assignment", ->
  name =
  'dave'
-  
-  eq name, 'dave'
+
+  eq name, 'dave'
+
+test '#2211: splats in destructured parameters', ->
+  doesNotThrow -> CoffeeScript.compile '([a...]) ->'
+  doesNotThrow -> CoffeeScript.compile '([a...],b) ->'
+  doesNotThrow -> CoffeeScript.compile '([a...],[b...]) ->'
+  throws -> CoffeeScript.compile '([a...,[a...]]) ->'
+  doesNotThrow -> CoffeeScript.compile '([a...,[b...]]) ->'
+
+test '#2213: invocations within destructured parameters', ->
+  throws -> CoffeeScript.compile '([a()])->'
+  throws -> CoffeeScript.compile '([a:b()])->'
+  throws -> CoffeeScript.compile '([a:b.c()])->'
+  throws -> CoffeeScript.compile '({a()})->'
+  throws -> CoffeeScript.compile '({a:b()})->'
+  throws -> CoffeeScript.compile '({a:b.c()})->'
--- a/test/classes.coffee
+++ b/test/classes.coffee
@@ -272,22 +272,22 @@ test "nothing classes", ->

  c = class
  ok c instanceof Function
-  
-  
+
+
 test "classes with static-level implicit objects", ->
-  
+
  class A
    @static = one: 1
    two: 2
-    
+
  class B
    @static = one: 1,
    two: 2
-    
+
  eq A.static.one, 1
  eq A.static.two, undefined
  eq (new A).two, 2
-  
+
  eq B.static.one, 1
  eq B.static.two, 2
  eq (new B).two, undefined
@@ -490,6 +490,7 @@ test "#1182: execution order needs to be considered as well", ->
 test "#1182: external constructors with bound functions", ->
  fn = ->
    {one: 1}
+    this
  class B
  class A
    constructor: fn
@@ -546,51 +547,132 @@ test "#1598: super works for static methods too", ->
      'pass? ' + super

  eq Child.method(), 'pass? yes'
-  
+
 test "#1842: Regression with bound functions within bound class methods", ->
-  
+
  class Store
    @bound: =>
      do =>
        eq this, Store
-      
+
  Store.bound()
-  
+
  # And a fancier case:
-  
+
  class Store
-    
+
    eq this, Store
-    
+
    @bound: =>
      do =>
        eq this, Store
-            
+
    @unbound: ->
      eq this, Store
-      
+
    instance: =>
      ok this instanceof Store
-      
+
  Store.bound()
  Store.unbound()
  (new Store).instance()
-  
+
 test "#1876: Class @A extends A", ->
  class A
  class @A extends A
-  
+
  ok (new @A) instanceof A
-  
+
 test "#1813: Passing class definitions as expressions", ->
  ident = (x) -> x
-  
+
  result = ident class A then x = 1
-    
+
  eq result, A
-  
+
  result = ident class B extends A
    x = 1
-    
+
  eq result, B
-  
+
+test "#1966: external constructors should produce their return value", ->
+  ctor = -> {}
+  class A then constructor: ctor
+  ok (new A) not instanceof A
+
+test "#1980: regression with an inherited class with static function members", ->
+
+  class A
+
+  class B extends A
+    @static: => 'value'
+
+  eq B.static(), 'value'
+
+test "#1534: class then 'use strict'", ->
+  # [14.1 Directive Prologues and the Use Strict Directive](http://es5.github.com/#x14.1)
+  nonce = {}
+  error = 'do -> ok this'
+  strictTest = "do ->'use strict';#{error}"
+  return unless (try CoffeeScript.run strictTest, bare: yes catch e then nonce) is nonce
+
+  throws -> CoffeeScript.run "class then 'use strict';#{error}", bare: yes
+  doesNotThrow -> CoffeeScript.run "class then #{error}", bare: yes
+  doesNotThrow -> CoffeeScript.run "class then #{error};'use strict'", bare: yes
+
+  # comments are ignored in the Directive Prologue
+  comments = ["""
+  class
+    ### comment ###
+    'use strict'
+    #{error}""",
+  """
+  class
+    ### comment 1 ###
+    ### comment 2 ###
+    'use strict'
+    #{error}""",
+  """
+  class
+    ### comment 1 ###
+    ### comment 2 ###
+    'use strict'
+    #{error}
+    ### comment 3 ###"""
+  ]
+  throws (-> CoffeeScript.run comment, bare: yes) for comment in comments
+
+  # [ES5 §14.1](http://es5.github.com/#x14.1) allows for other directives
+  directives = ["""
+  class
+    'directive 1'
+    'use strict'
+    #{error}""",
+  """
+  class
+    'use strict'
+    'directive 2'
+    #{error}""",
+  """
+  class
+    ### comment 1 ###
+    'directive 1'
+    'use strict'
+    #{error}""",
+  """
+  class
+    ### comment 1 ###
+    'directive 1'
+    ### comment 2 ###
+    'use strict'
+    #{error}"""
+  ]
+  throws (-> CoffeeScript.run directive, bare: yes) for directive in directives
+
+test "#2052: classes should work in strict mode", ->
+  try
+    do ->
+      'use strict'
+      class A
+  catch e
+    ok no
--- a/test/comments.coffee
+++ b/test/comments.coffee
@@ -202,3 +202,6 @@ test "block comments inside class bodies", ->
    b: ->

  ok B.prototype.a instanceof Function
+
+test "#2037: herecomments shouldn't imply line terminators", ->
+  do (-> ### ###; fail)
--- a/test/compilation.coffee
+++ b/test/compilation.coffee
@@ -13,6 +13,14 @@ test "--bare", ->
  eq -1, CoffeeScript.compile('x = y', bare: on).indexOf 'function'
  ok 'passed' is CoffeeScript.eval '"passed"', bare: on, filename: 'test'

+test "header (#1778)", ->
+  header = "// Generated by CoffeeScript #{CoffeeScript.VERSION}\n"
+  eq 0, CoffeeScript.compile('x = y', header: on).indexOf header
+
+test "header is disabled by default", ->
+  header = "// Generated by CoffeeScript #{CoffeeScript.VERSION}\n"
+  eq -1, CoffeeScript.compile('x = y').indexOf header
+
 test "multiple generated references", ->
  a = {b: []}
  a.b[true] = -> this == a.b
--- a/test/comprehensions.coffee
+++ b/test/comprehensions.coffee
@@ -244,21 +244,13 @@ test "Optimized range comprehensions.", ->

  exxes = ('x' for [0...10])
  ok exxes.join(' ') is 'x x x x x x x x x x'
-
-
-test "Comprehensions safely redeclare parameters if they're not present in closest scope.", ->
-
-  rule = (x) -> x
-
-  learn = ->
-    rule for rule in [1, 2, 3]
-
-  ok learn().join(' ') is '1 2 3'
-
-  ok rule(101) is 101
-
-  f = -> [-> ok no, 'should cache source']
-  ok yes for k of [f] = f()
+  
+  
+test "Loop variables should be able to reference outer variables", ->
+  outer = 1
+  do ->
+    null for outer in [1, 2, 3]
+  eq outer, 3


 test "Lenient on pure statements not trying to reach out of the closure", ->
@@ -460,3 +452,53 @@ test "#1850: inner `for` should not be expression-ized if `return`ing", ->
    for b in [1..9]
      c = Math.sqrt a*a + b*b
      return String [a, b, c] unless c % 1
+
+test "#1910: loop index should be mutable within a loop iteration and immutable between loop iterations", ->
+  n = 1
+  iterations = 0
+  arr = [0..n]
+  for v, k in arr
+    ++iterations
+    v = k = 5
+    eq 5, k
+  eq 2, k
+  eq 2, iterations
+
+  iterations = 0
+  for v in [0..n]
+    ++iterations
+  eq 2, k
+  eq 2, iterations
+
+  arr = ([v, v + 1] for v in [0..5])
+  iterations = 0
+  for own [v0, v1], k in arr when v0
+    k += 3
+    ++iterations
+  eq 6, k
+  eq 5, iterations
+
+test "#2007: Return object literal from comprehension", ->
+  y = for x in [1, 2]
+    foo: "foo" + x
+  eq 2, y.length
+  eq "foo1", y[0].foo
+  eq "foo2", y[1].foo
+
+  x = 2
+  y = while x
+    x: --x
+  eq 2, y.length
+  eq 1, y[0].x
+  eq 0, y[1].x
+  
+test "#2274: Allow @values as loop variables", ->
+  obj = {
+    item: null
+    method: ->
+      for @item in [1, 2, 3]
+        null
+  }
+  eq obj.item, null
+  obj.method()
+  eq obj.item, 3
--- a/test/control_flow.coffee
+++ b/test/control_flow.coffee
@@ -422,11 +422,9 @@ test "Issue #997. Switch doesn't fallthrough.", ->


 test "Throw should be usable as an expression.", ->
-  
+
  try
    false or throw 'up'
    throw new Error 'failed'
  catch e
    ok e is 'up'
-    
-  
--- a/test/eval.coffee
+++ b/test/eval.coffee
@@ -8,7 +8,7 @@ if vm = require? 'vm'
    result = CoffeeScript.eval code
    eq result, 'global superpower!'
    eq fhqwhgads, 'global superpower!'
-  
+
  test "CoffeeScript.eval can run in, and modify, a Script context sandbox", ->
    sandbox = vm.Script.createContext()
    sandbox.foo = 'bar'
@@ -18,7 +18,7 @@ if vm = require? 'vm'
    result = CoffeeScript.eval code, {sandbox}
    eq result, 'not bar!'
    eq sandbox.foo, 'not bar!'
-  
+
  test "CoffeeScript.eval can run in, but cannot modify, an ordinary object sandbox", ->
    sandbox = {foo: 'bar'}
    code = '''
@@ -26,4 +26,4 @@ if vm = require? 'vm'
    '''
    result = CoffeeScript.eval code, {sandbox}
    eq result, 'not bar!'
-    eq sandbox.foo, 'bar'
+    eq sandbox.foo, 'bar'
--- a/test/exception_handling.coffee
+++ b/test/exception_handling.coffee
@@ -88,15 +88,15 @@ test "try/catch with empty catch as last statement in a function body", ->
    try nonce
    catch err
  eq nonce, fn()
-  
-  
+
+
 # Catch leads to broken scoping: #1595

 test "try/catch with a reused variable name.", ->
  do ->
-    try 
+    try
      inner = 5
    catch inner
      # nothing
  eq typeof inner, 'undefined'
-    
+
--- a/test/formatting.coffee
+++ b/test/formatting.coffee
@@ -123,17 +123,17 @@ test "#1492: Nested blocks don't cause double semicolons", ->
  eq -1, js.indexOf ';;'

 test "#1195 Ignore trailing semicolons (before newlines or as the last char in a program)", ->
-    preNewline = (numSemicolons) ->
-      """
-      nonce = {}; nonce2 = {}
-      f = -> nonce#{Array(numSemicolons+1).join(';')}
-      nonce2
-      unless f() is nonce then throw new Error('; before linebreak should = newline')
-      """
-    CoffeeScript.run(preNewline(n), bare: true) for n in [1,2,3]
-    
-    lastChar = '-> lastChar;'
-    doesNotThrow -> CoffeeScript.compile lastChar, bare: true
+  preNewline = (numSemicolons) ->
+    """
+    nonce = {}; nonce2 = {}
+    f = -> nonce#{Array(numSemicolons+1).join(';')}
+    nonce2
+    unless f() is nonce then throw new Error('; before linebreak should = newline')
+    """
+  CoffeeScript.run(preNewline(n), bare: true) for n in [1,2,3]
+
+  lastChar = '-> lastChar;'
+  doesNotThrow -> CoffeeScript.compile lastChar, bare: true

 test "#1299: Disallow token misnesting", ->
  try
--- a/test/function_invocation.coffee
+++ b/test/function_invocation.coffee
@@ -392,6 +392,18 @@ test "#1011: passing a splat to a method of a number", ->
  eq '1011', (131.0).toString [5]...


+test "splats and the `new` operator: functions that return `null` should construct their instance", ->
+  args = []
+  child = new (constructor = -> null) args...
+  ok child instanceof constructor
+
+test "splats and the `new` operator: functions that return functions should construct their return value", ->
+  args = []
+  fn = ->
+  child = new (constructor = -> fn) args...
+  ok child not instanceof constructor
+  eq fn, child
+
 test "implicit return", ->

  eq ok, new ->
@@ -509,12 +521,32 @@ test "#1416: don't omit one 'new' when compiling 'new new fn()()'", ->

 test "#1840: accessing the `prototype` after function invocation should compile", ->
  doesNotThrow -> CoffeeScript.compile 'fn()::prop'
-  
+
  nonce = {}
  class Test then id: nonce

  dotAccess = -> Test::
  protoAccess = -> Test
-  
+
  eq dotAccess().id, nonce
  eq protoAccess()::id, nonce
+
+test "#960: improved 'do'", ->
+
+  do (nonExistent = 'one') ->
+    eq nonExistent, 'one'
+
+  overridden = 1
+  do (overridden = 2) ->
+    eq overridden, 2
+
+  two = 2
+  do (one = 1, two, three = 3) ->
+    eq one, 1
+    eq two, 2
+    eq three, 3
+
+  ret = do func = (two) ->
+    eq two, 2
+    func
+  eq ret, func
--- a/test/functions.coffee
+++ b/test/functions.coffee
@@ -65,7 +65,7 @@ eq obj, obj.nested()


 test "even more fancy bound functions", ->
-  obj = 
+  obj =
    one: ->
      do =>
        return this.two()
@@ -91,9 +91,16 @@ test "self-referencing functions", ->

 test "splats", ->
  arrayEq [0, 1, 2], (((splat...) -> splat) 0, 1, 2)
-  arrayEq [2, 3], (((_, _, splat...) -> splat) 0, 1, 2, 3)
-  arrayEq [0, 1], (((splat..., _, _) -> splat) 0, 1, 2, 3)
-  arrayEq [2], (((_, _, splat..., _) -> splat) 0, 1, 2, 3)
+  arrayEq [2, 3], (((_, _1, splat...) -> splat) 0, 1, 2, 3)
+  arrayEq [0, 1], (((splat..., _, _1) -> splat) 0, 1, 2, 3)
+  arrayEq [2], (((_, _1, splat..., _2) -> splat) 0, 1, 2, 3)
+
+test "destructured splatted parameters", ->
+  arr = [0,1,2]
+  splatArray = ([a...]) -> a
+  splatArrayRest = ([a...],b...) -> arrayEq(a,b); b
+  arrayEq splatArray(arr), arr
+  arrayEq splatArrayRest(arr,0,1,2), arr

 test "@-parameters: automatically assign an argument's value to a property of the context", ->
  nonce = {}
@@ -131,7 +138,7 @@ test "destructuring in function definition", ->
 test "default values", ->
  nonceA = {}
  nonceB = {}
-  a = (_,_,arg=nonceA) -> arg
+  a = (_,_1,arg=nonceA) -> arg
  eq nonceA, a()
  eq nonceA, a(0)
  eq nonceB, a(0,0,nonceB)
@@ -139,7 +146,7 @@ test "default values", ->
  eq nonceA, a(0,0,null)
  eq false , a(0,0,false)
  eq nonceB, a(undefined,undefined,nonceB,undefined)
-  b = (_,arg=nonceA,_,_) -> arg
+  b = (_,arg=nonceA,_1,_2) -> arg
  eq nonceA, b()
  eq nonceA, b(0)
  eq nonceB, b(0,nonceB)
@@ -147,7 +154,7 @@ test "default values", ->
  eq nonceA, b(0,null)
  eq false , b(0,false)
  eq nonceB, b(undefined,nonceB,undefined)
-  c = (arg=nonceA,_,_) -> arg
+  c = (arg=nonceA,_,_1) -> arg
  eq nonceA, c()
  eq      0, c(0)
  eq nonceB, c(nonceB)
@@ -182,7 +189,20 @@ test "arguments vs parameters", ->
 test "#1844: bound functions in nested comprehensions causing empty var statements", ->
  a = ((=>) for a in [0] for b in [0])
  eq 1, a.length
-  
+
 test "#1859: inline function bodies shouldn't modify prior postfix ifs", ->
  list = [1, 2, 3]
  ok true if list.some (x) -> x is 2
+
+test "#2258: allow whitespace-style parameter lists in function definitions", ->
+  func = (
+    a, b, c
+  ) -> c
+  eq func(1, 2, 3), 3
+  
+  func = (
+    a
+    b
+    c
+  ) -> b
+  eq func(1, 2, 3), 2
--- a/test/numbers.coffee
+++ b/test/numbers.coffee
@@ -50,6 +50,27 @@ eq Number::toString, .42.toString
 eq Number::toString, (4).toString

 test '#1168: leading floating point suppresses newline', ->
-	eq 1, do ->
-		1
-		.5 + 0.5
+  eq 1, do ->
+    1
+    .5 + 0.5
+
+test "Python-style octal literal notation '0o777'", ->
+  eq 511, 0o777
+  eq 1, 0o1
+  eq 1, 0o00001
+  eq parseInt('0777', 8), 0o777
+  eq '777', 0o777.toString 8
+  eq 4, 0o4.valueOf()
+  eq Number::toString, 0o777['toString']
+  eq Number::toString, 0o777.toString
+
+test "#2060: Disallow uppercase radix prefixes and exponential notation", ->
+  for char in ['b', 'o', 'x', 'e']
+    program = "0#{char}0"
+    doesNotThrow -> CoffeeScript.compile program, bare: yes
+    throws -> CoffeeScript.compile program.toUpperCase(), bare: yes
+
+test "#2224: hex literals with 0b or B or E", ->
+  eq 176, 0x0b0
+  eq 177, 0x0B1
+  eq 225, 0xE1
--- a/test/objects.coffee
+++ b/test/objects.coffee
@@ -237,17 +237,43 @@ test "#1322: implicit call against implicit object with block comments", ->
 test "#1513: Top level bare objs need to be wrapped in parens for unary and existence ops", ->
  doesNotThrow -> CoffeeScript.run "{}?", bare: true
  doesNotThrow -> CoffeeScript.run "{}.a++", bare: true
-  
+
 test "#1871: Special case for IMPLICIT_END in the middle of an implicit object", ->
  result = 'result'
  ident = (x) -> x
-  
+
  result = ident one: 1 if false
-  
+
  eq result, 'result'

  result = ident
    one: 1
    two: 2 for i in [1..3]
-    
-  eq result.two.join(' '), '2 2 2'  
+
+  eq result.two.join(' '), '2 2 2'
+
+test "#1961, #1974, regression with compound assigning to an implicit object", ->
+
+  obj = null
+
+  obj ?=
+    one: 1
+    two: 2
+
+  eq obj.two, 2
+
+  obj = null
+
+  obj or=
+    three: 3
+    four: 4
+
+  eq obj.four, 4
+
+test "#2207: Immediate implicit closes don't close implicit objects", ->
+  func = ->
+    key: for i in [1, 2, 3] then i
+      
+  eq func().key.join(' '), '1 2 3'
+  
+  
--- a/test/operators.coffee
+++ b/test/operators.coffee
@@ -263,9 +263,22 @@ test "#1102: String literal prevents line continuation", ->
 test "#1703, ---x is invalid JS", ->
  x = 2
  eq (- --x), -1
-  
+
 test "Regression with implicit calls against an indented assignment", ->
-  eq 1, a = 
+  eq 1, a =
    1
-  
+
  eq a, 1
+
+test "#2155 ... conditional assignment to a closure", ->
+  x = null
+  func = -> x ?= (-> if true then 'hi')
+  func()
+  eq x(), 'hi'
+  
+test "#2197: Existential existential double trouble", ->
+  counter = 0
+  func = -> counter++
+  func()? ? 100
+  eq counter, 1
+  
--- a/Show More
+++ b/Show More