PageRenderTime 62ms CodeModel.GetById 14ms RepoModel.GetById 0ms app.codeStats 1ms

/documentation/docs/lexer.html

http://github.com/jashkenas/coffee-script
HTML | 2024 lines | 1865 code | 159 blank | 0 comment | 0 complexity | 9c4487192ff7778f37ad5ad37144c273 MD5 | raw file
    

  1. <!DOCTYPE html>
    2. 

  2. 

  3. <html>
    4. 

  4. <head>
    5. 

  5.   <title>lexer.coffee</title>
    6. 

  6.   <meta http-equiv="content-type" content="text/html; charset=UTF-8">
    7. 

  7.   <meta name="viewport" content="width=device-width, target-densitydpi=160dpi, initial-scale=1.0; maximum-scale=1.0; user-scalable=0;">
    8. 

  8.   <link rel="stylesheet" media="all" href="docco.css" />
    9. 

  9. </head>
    10. 

  10. <body>
    11. 

  11.   <div id="container">
    12. 

  12.     <div id="background"></div>
    13. 

  13.     
    14. 

  14.       <ul id="jump_to">
    15. 

  15.         <li>
    16. 

  16.           <a class="large" href="javascript:void(0);">Jump To &hellip;</a>
    17. 

  17.           <a class="small" href="javascript:void(0);">+</a>
    18. 

  18.           <div id="jump_wrapper">
    19. 

  19.           <div id="jump_page_wrapper">
    20. 

  20.             <div id="jump_page">
    21. 

  21.               
    22. 

  22.                 
    23. 

  23.                 <a class="source" href="browser.html">
    24. 

  24.                   browser.coffee
    25. 

  25.                 </a>
    26. 

  26.               
    27. 

  27.                 
    28. 

  28.                 <a class="source" href="cake.html">
    29. 

  29.                   cake.coffee
    30. 

  30.                 </a>
    31. 

  31.               
    32. 

  32.                 
    33. 

  33.                 <a class="source" href="coffee-script.html">
    34. 

  34.                   coffee-script.coffee
    35. 

  35.                 </a>
    36. 

  36.               
    37. 

  37.                 
    38. 

  38.                 <a class="source" href="command.html">
    39. 

  39.                   command.coffee
    40. 

  40.                 </a>
    41. 

  41.               
    42. 

  42.                 
    43. 

  43.                 <a class="source" href="grammar.html">
    44. 

  44.                   grammar.coffee
    45. 

  45.                 </a>
    46. 

  46.               
    47. 

  47.                 
    48. 

  48.                 <a class="source" href="helpers.html">
    49. 

  49.                   helpers.coffee
    50. 

  50.                 </a>
    51. 

  51.               
    52. 

  52.                 
    53. 

  53.                 <a class="source" href="index.html">
    54. 

  54.                   index.coffee
    55. 

  55.                 </a>
    56. 

  56.               
    57. 

  57.                 
    58. 

  58.                 <a class="source" href="lexer.html">
    59. 

  59.                   lexer.coffee
    60. 

  60.                 </a>
    61. 

  61.               
    62. 

  62.                 
    63. 

  63.                 <a class="source" href="nodes.html">
    64. 

  64.                   nodes.coffee
    65. 

  65.                 </a>
    66. 

  66.               
    67. 

  67.                 
    68. 

  68.                 <a class="source" href="optparse.html">
    69. 

  69.                   optparse.coffee
    70. 

  70.                 </a>
    71. 

  71.               
    72. 

  72.                 
    73. 

  73.                 <a class="source" href="register.html">
    74. 

  74.                   register.coffee
    75. 

  75.                 </a>
    76. 

  76.               
    77. 

  77.                 
    78. 

  78.                 <a class="source" href="repl.html">
    79. 

  79.                   repl.coffee
    80. 

  80.                 </a>
    81. 

  81.               
    82. 

  82.                 
    83. 

  83.                 <a class="source" href="rewriter.html">
    84. 

  84.                   rewriter.coffee
    85. 

  85.                 </a>
    86. 

  86.               
    87. 

  87.                 
    88. 

  88.                 <a class="source" href="scope.html">
    89. 

  89.                   scope.litcoffee
    90. 

  90.                 </a>
    91. 

  91.               
    92. 

  92.                 
    93. 

  93.                 <a class="source" href="sourcemap.html">
    94. 

  94.                   sourcemap.litcoffee
    95. 

  95.                 </a>
    96. 

  96.               
    97. 

  97.             </div>
    98. 

  98.           </div>
    99. 

  99.         </li>
    100. 

  100.       </ul>
    101. 

  101.     
    102. 

  102.     <ul class="sections">
    103. 

  103.         
    104. 

  104.           <li id="title">
    105. 

  105.               <div class="annotation">
    106. 

  106.                   <h1>lexer.coffee</h1>
    107. 

  107.               </div>
    108. 

  108.           </li>
    109. 

  109.         
    110. 

  110.         
    111. 

  111.         
    112. 

  112.         <li id="section-1">
    113. 

  113.             <div class="annotation">
    114. 

  114.               
    115. 

  115.               <div class="pilwrap ">
    116. 

  116.                 <a class="pilcrow" href="#section-1">&#182;</a>
    117. 

  117.               </div>
    118. 

  118.               <p>The CoffeeScript Lexer. Uses a series of token-matching regexes to attempt
    119. 

  119. matches against the beginning of the source code. When a match is found,
    120. 

  120. a token is produced, we consume the match, and start again. Tokens are in the
    121. 

  121. form:</p>
    122. 

  122. <pre><code>[tag, value, locationData]
    123. 

  123. </code></pre><p>where locationData is {first_line, first_column, last_line, last_column}, which is a
    124. 

  124. format that can be fed directly into <a href="http://github.com/zaach/jison">Jison</a>.  These
    125. 

  125. are read by jison in the <code>parser.lexer</code> function defined in coffee-script.coffee.</p>
    126. 

  126. 

  127.             </div>
    128. 

  128.             
    129. 

  129.             <div class="content"><div class='highlight'><pre>
    130. 

  130. {Rewriter, INVERSES} = <span class="hljs-built_in">require</span> <span class="hljs-string">'./rewriter'</span></pre></div></div>
    131. 

  131.             
    132. 

  132.         </li>
    133. 

  133.         
    134. 

  134.         
    135. 

  135.         <li id="section-2">
    136. 

  136.             <div class="annotation">
    137. 

  137.               
    138. 

  138.               <div class="pilwrap ">
    139. 

  139.                 <a class="pilcrow" href="#section-2">&#182;</a>
    140. 

  140.               </div>
    141. 

  141.               <p>Import the helpers we need.</p>
    142. 

  142. 

  143.             </div>
    144. 

  144.             
    145. 

  145.             <div class="content"><div class='highlight'><pre>{count, starts, compact, repeat, invertLiterate,
    146. 

  146. locationDataToString,  throwSyntaxError} = <span class="hljs-built_in">require</span> <span class="hljs-string">'./helpers'</span></pre></div></div>
    147. 

  147.             
    148. 

  148.         </li>
    149. 

  149.         
    150. 

  150.         
    151. 

  151.         <li id="section-3">
    152. 

  152.             <div class="annotation">
    153. 

  153.               
    154. 

  154.               <div class="pilwrap ">
    155. 

  155.                 <a class="pilcrow" href="#section-3">&#182;</a>
    156. 

  156.               </div>
    157. 

  157.               <h2 id="the-lexer-class">The Lexer Class</h2>
    158. 

  158. 

  159.             </div>
    160. 

  160.             
    161. 

  161.         </li>
    162. 

  162.         
    163. 

  163.         
    164. 

  164.         <li id="section-4">
    165. 

  165.             <div class="annotation">
    166. 

  166.               
    167. 

  167.               <div class="pilwrap ">
    168. 

  168.                 <a class="pilcrow" href="#section-4">&#182;</a>
    169. 

  169.               </div>
    170. 

  170.               
    171. 

  171.             </div>
    172. 

  172.             
    173. 

  173.         </li>
    174. 

  174.         
    175. 

  175.         
    176. 

  176.         <li id="section-5">
    177. 

  177.             <div class="annotation">
    178. 

  178.               
    179. 

  179.               <div class="pilwrap ">
    180. 

  180.                 <a class="pilcrow" href="#section-5">&#182;</a>
    181. 

  181.               </div>
    182. 

  182.               <p>The Lexer class reads a stream of CoffeeScript and divvies it up into tagged
    183. 

  183. tokens. Some potential ambiguity in the grammar has been avoided by
    184. 

  184. pushing some extra smarts into the Lexer.</p>
    185. 

  185. 

  186.             </div>
    187. 

  187.             
    188. 

  188.             <div class="content"><div class='highlight'><pre><span class="hljs-built_in">exports</span>.Lexer = <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Lexer</span></span></pre></div></div>
    189. 

  189.             
    190. 

  190.         </li>
    191. 

  191.         
    192. 

  192.         
    193. 

  193.         <li id="section-6">
    194. 

  194.             <div class="annotation">
    195. 

  195.               
    196. 

  196.               <div class="pilwrap ">
    197. 

  197.                 <a class="pilcrow" href="#section-6">&#182;</a>
    198. 

  198.               </div>
    199. 

  199.               <p><strong>tokenize</strong> is the Lexer’s main method. Scan by attempting to match tokens
    200. 

  200. one at a time, using a regular expression anchored at the start of the
    201. 

  201. remaining code, or a custom recursive token-matching method
    202. 

  202. (for interpolations). When the next token has been recorded, we move forward
    203. 

  203. within the code past the token, and begin again.</p>
    204. 

  204. <p>Each tokenizing method is responsible for returning the number of characters
    205. 

  205. it has consumed.</p>
    206. 

  206. <p>Before returning the token stream, run it through the <a href="rewriter.html">Rewriter</a>.</p>
    207. 

  207. 

  208.             </div>
    209. 

  209.             
    210. 

  210.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">tokenize</span>: <span class="hljs-function"><span class="hljs-params">(code, opts = {})</span> -&gt;</span>
    211. 

  211.     <span class="hljs-property">@literate</span>   = opts.literate  <span class="hljs-comment"># Are we lexing literate CoffeeScript?</span>
    212. 

  212.     <span class="hljs-property">@indent</span>     = <span class="hljs-number">0</span>              <span class="hljs-comment"># The current indentation level.</span>
    213. 

  213.     <span class="hljs-property">@baseIndent</span> = <span class="hljs-number">0</span>              <span class="hljs-comment"># The overall minimum indentation level</span>
    214. 

  214.     <span class="hljs-property">@indebt</span>     = <span class="hljs-number">0</span>              <span class="hljs-comment"># The over-indentation at the current level.</span>
    215. 

  215.     <span class="hljs-property">@outdebt</span>    = <span class="hljs-number">0</span>              <span class="hljs-comment"># The under-outdentation at the current level.</span>
    216. 

  216.     <span class="hljs-property">@indents</span>    = []             <span class="hljs-comment"># The stack of all current indentation levels.</span>
    217. 

  217.     <span class="hljs-property">@ends</span>       = []             <span class="hljs-comment"># The stack for pairing up tokens.</span>
    218. 

  218.     <span class="hljs-property">@tokens</span>     = []             <span class="hljs-comment"># Stream of parsed tokens in the form `['TYPE', value, location data]`.</span>
    219. 

  219.     <span class="hljs-property">@seenFor</span>    = <span class="hljs-literal">no</span>             <span class="hljs-comment"># Used to recognize FORIN and FOROF tokens.</span>
    220. 

  220. 

  221.     <span class="hljs-property">@chunkLine</span> =
    222. 

  222.       opts.line <span class="hljs-keyword">or</span> <span class="hljs-number">0</span>         <span class="hljs-comment"># The start line for the current @chunk.</span>
    223. 

  223.     <span class="hljs-property">@chunkColumn</span> =
    224. 

  224.       opts.column <span class="hljs-keyword">or</span> <span class="hljs-number">0</span>       <span class="hljs-comment"># The start column of the current @chunk.</span>
    225. 

  225.     code = <span class="hljs-property">@clean</span> code         <span class="hljs-comment"># The stripped, cleaned original source code.</span></pre></div></div>
    226. 

  226.             
    227. 

  227.         </li>
    228. 

  228.         
    229. 

  229.         
    230. 

  230.         <li id="section-7">
    231. 

  231.             <div class="annotation">
    232. 

  232.               
    233. 

  233.               <div class="pilwrap ">
    234. 

  234.                 <a class="pilcrow" href="#section-7">&#182;</a>
    235. 

  235.               </div>
    236. 

  236.               <p>At every position, run through this list of attempted matches,
    237. 

  237. short-circuiting if any of them succeed. Their order determines precedence:
    238. 

  238. <code>@literalToken</code> is the fallback catch-all.</p>
    239. 

  239. 

  240.             </div>
    241. 

  241.             
    242. 

  242.             <div class="content"><div class='highlight'><pre>    i = <span class="hljs-number">0</span>
    243. 

  243.     <span class="hljs-keyword">while</span> <span class="hljs-property">@chunk</span> = code[i..]
    244. 

  244.       consumed = \
    245. 

  245.            <span class="hljs-property">@identifierToken</span>() <span class="hljs-keyword">or</span>
    246. 

  246.            <span class="hljs-property">@commentToken</span>()    <span class="hljs-keyword">or</span>
    247. 

  247.            <span class="hljs-property">@whitespaceToken</span>() <span class="hljs-keyword">or</span>
    248. 

  248.            <span class="hljs-property">@lineToken</span>()       <span class="hljs-keyword">or</span>
    249. 

  249.            <span class="hljs-property">@stringToken</span>()     <span class="hljs-keyword">or</span>
    250. 

  250.            <span class="hljs-property">@numberToken</span>()     <span class="hljs-keyword">or</span>
    251. 

  251.            <span class="hljs-property">@regexToken</span>()      <span class="hljs-keyword">or</span>
    252. 

  252.            <span class="hljs-property">@jsToken</span>()         <span class="hljs-keyword">or</span>
    253. 

  253.            <span class="hljs-property">@literalToken</span>()</pre></div></div>
    254. 

  254.             
    255. 

  255.         </li>
    256. 

  256.         
    257. 

  257.         
    258. 

  258.         <li id="section-8">
    259. 

  259.             <div class="annotation">
    260. 

  260.               
    261. 

  261.               <div class="pilwrap ">
    262. 

  262.                 <a class="pilcrow" href="#section-8">&#182;</a>
    263. 

  263.               </div>
    264. 

  264.               <p>Update position</p>
    265. 

  265. 

  266.             </div>
    267. 

  267.             
    268. 

  268.             <div class="content"><div class='highlight'><pre>      [<span class="hljs-property">@chunkLine</span>, <span class="hljs-property">@chunkColumn</span>] = <span class="hljs-property">@getLineAndColumnFromChunk</span> consumed
    269. 

  269. 

  270.       i += consumed
    271. 

  271. 

  272.       <span class="hljs-keyword">return</span> {<span class="hljs-property">@tokens</span>, <span class="hljs-attribute">index</span>: i} <span class="hljs-keyword">if</span> opts.untilBalanced <span class="hljs-keyword">and</span> <span class="hljs-property">@ends</span>.length <span class="hljs-keyword">is</span> <span class="hljs-number">0</span>
    273. 

  273. 

  274.     <span class="hljs-property">@closeIndentation</span>()
    275. 

  275.     <span class="hljs-property">@error</span> <span class="hljs-string">"missing <span class="hljs-subst">#{end.tag}</span>"</span>, end.origin[<span class="hljs-number">2</span>] <span class="hljs-keyword">if</span> end = <span class="hljs-property">@ends</span>.pop()
    276. 

  276.     <span class="hljs-keyword">return</span> <span class="hljs-property">@tokens</span> <span class="hljs-keyword">if</span> opts.rewrite <span class="hljs-keyword">is</span> <span class="hljs-literal">off</span>
    277. 

  277.     (<span class="hljs-keyword">new</span> Rewriter).rewrite <span class="hljs-property">@tokens</span></pre></div></div>
    278. 

  278.             
    279. 

  279.         </li>
    280. 

  280.         
    281. 

  281.         
    282. 

  282.         <li id="section-9">
    283. 

  283.             <div class="annotation">
    284. 

  284.               
    285. 

  285.               <div class="pilwrap ">
    286. 

  286.                 <a class="pilcrow" href="#section-9">&#182;</a>
    287. 

  287.               </div>
    288. 

  288.               <p>Preprocess the code to remove leading and trailing whitespace, carriage
    289. 

  289. returns, etc. If we’re lexing literate CoffeeScript, strip external Markdown
    290. 

  290. by removing all lines that aren’t indented by at least four spaces or a tab.</p>
    291. 

  291. 

  292.             </div>
    293. 

  293.             
    294. 

  294.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">clean</span>: <span class="hljs-function"><span class="hljs-params">(code)</span> -&gt;</span>
    295. 

  295.     code = code.slice(<span class="hljs-number">1</span>) <span class="hljs-keyword">if</span> code.charCodeAt(<span class="hljs-number">0</span>) <span class="hljs-keyword">is</span> BOM
    296. 

  296.     code = code.replace(<span class="hljs-regexp">/\r/g</span>, <span class="hljs-string">''</span>).replace TRAILING_SPACES, <span class="hljs-string">''</span>
    297. 

  297.     <span class="hljs-keyword">if</span> WHITESPACE.test code
    298. 

  298.       code = <span class="hljs-string">"\n<span class="hljs-subst">#{code}</span>"</span>
    299. 

  299.       <span class="hljs-property">@chunkLine</span>--
    300. 

  300.     code = invertLiterate code <span class="hljs-keyword">if</span> <span class="hljs-property">@literate</span>
    301. 

  301.     code</pre></div></div>
    302. 

  302.             
    303. 

  303.         </li>
    304. 

  304.         
    305. 

  305.         
    306. 

  306.         <li id="section-10">
    307. 

  307.             <div class="annotation">
    308. 

  308.               
    309. 

  309.               <div class="pilwrap ">
    310. 

  310.                 <a class="pilcrow" href="#section-10">&#182;</a>
    311. 

  311.               </div>
    312. 

  312.               <h2 id="tokenizers">Tokenizers</h2>
    313. 

  313. 

  314.             </div>
    315. 

  315.             
    316. 

  316.         </li>
    317. 

  317.         
    318. 

  318.         
    319. 

  319.         <li id="section-11">
    320. 

  320.             <div class="annotation">
    321. 

  321.               
    322. 

  322.               <div class="pilwrap ">
    323. 

  323.                 <a class="pilcrow" href="#section-11">&#182;</a>
    324. 

  324.               </div>
    325. 

  325.               
    326. 

  326.             </div>
    327. 

  327.             
    328. 

  328.         </li>
    329. 

  329.         
    330. 

  330.         
    331. 

  331.         <li id="section-12">
    332. 

  332.             <div class="annotation">
    333. 

  333.               
    334. 

  334.               <div class="pilwrap ">
    335. 

  335.                 <a class="pilcrow" href="#section-12">&#182;</a>
    336. 

  336.               </div>
    337. 

  337.               <p>Matches identifying literals: variables, keywords, method names, etc.
    338. 

  338. Check to ensure that JavaScript reserved words aren’t being used as
    339. 

  339. identifiers. Because CoffeeScript reserves a handful of keywords that are
    340. 

  340. allowed in JavaScript, we’re careful not to tag them as keywords when
    341. 

  341. referenced as property names here, so you can still do <code>jQuery.is()</code> even
    342. 

  342. though <code>is</code> means <code>===</code> otherwise.</p>
    343. 

  343. 

  344.             </div>
    345. 

  345.             
    346. 

  346.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">identifierToken</span>:<span class="hljs-function"> -&gt;</span>
    347. 

  347.     <span class="hljs-keyword">return</span> <span class="hljs-number">0</span> <span class="hljs-keyword">unless</span> match = IDENTIFIER.exec <span class="hljs-property">@chunk</span>
    348. 

  348.     [input, id, colon] = match</pre></div></div>
    349. 

  349.             
    350. 

  350.         </li>
    351. 

  351.         
    352. 

  352.         
    353. 

  353.         <li id="section-13">
    354. 

  354.             <div class="annotation">
    355. 

  355.               
    356. 

  356.               <div class="pilwrap ">
    357. 

  357.                 <a class="pilcrow" href="#section-13">&#182;</a>
    358. 

  358.               </div>
    359. 

  359.               <p>Preserve length of id for location data</p>
    360. 

  360. 

  361.             </div>
    362. 

  362.             
    363. 

  363.             <div class="content"><div class='highlight'><pre>    idLength = id.length
    364. 

  364.     poppedToken = <span class="hljs-literal">undefined</span>
    365. 

  365. 

  366.     <span class="hljs-keyword">if</span> id <span class="hljs-keyword">is</span> <span class="hljs-string">'own'</span> <span class="hljs-keyword">and</span> <span class="hljs-property">@tag</span>() <span class="hljs-keyword">is</span> <span class="hljs-string">'FOR'</span>
    367. 

  367.       <span class="hljs-property">@token</span> <span class="hljs-string">'OWN'</span>, id
    368. 

  368.       <span class="hljs-keyword">return</span> id.length
    369. 

  369.     <span class="hljs-keyword">if</span> id <span class="hljs-keyword">is</span> <span class="hljs-string">'from'</span> <span class="hljs-keyword">and</span> <span class="hljs-property">@tag</span>() <span class="hljs-keyword">is</span> <span class="hljs-string">'YIELD'</span>
    370. 

  370.       <span class="hljs-property">@token</span> <span class="hljs-string">'FROM'</span>, id
    371. 

  371.       <span class="hljs-keyword">return</span> id.length
    372. 

  372.     [..., prev] = <span class="hljs-property">@tokens</span>
    373. 

  373.     forcedIdentifier = colon <span class="hljs-keyword">or</span> prev? <span class="hljs-keyword">and</span>
    374. 

  374.       (prev[<span class="hljs-number">0</span>] <span class="hljs-keyword">in</span> [<span class="hljs-string">'.'</span>, <span class="hljs-string">'?.'</span>, <span class="hljs-string">'::'</span>, <span class="hljs-string">'?::'</span>] <span class="hljs-keyword">or</span>
    375. 

  375.       <span class="hljs-keyword">not</span> prev.spaced <span class="hljs-keyword">and</span> prev[<span class="hljs-number">0</span>] <span class="hljs-keyword">is</span> <span class="hljs-string">'@'</span>)
    376. 

  376.     tag = <span class="hljs-string">'IDENTIFIER'</span>
    377. 

  377. 

  378.     <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> forcedIdentifier <span class="hljs-keyword">and</span> (id <span class="hljs-keyword">in</span> JS_KEYWORDS <span class="hljs-keyword">or</span> id <span class="hljs-keyword">in</span> COFFEE_KEYWORDS)
    379. 

  379.       tag = id.toUpperCase()
    380. 

  380.       <span class="hljs-keyword">if</span> tag <span class="hljs-keyword">is</span> <span class="hljs-string">'WHEN'</span> <span class="hljs-keyword">and</span> <span class="hljs-property">@tag</span>() <span class="hljs-keyword">in</span> LINE_BREAK
    381. 

  381.         tag = <span class="hljs-string">'LEADING_WHEN'</span>
    382. 

  382.       <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> tag <span class="hljs-keyword">is</span> <span class="hljs-string">'FOR'</span>
    383. 

  383.         <span class="hljs-property">@seenFor</span> = <span class="hljs-literal">yes</span>
    384. 

  384.       <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> tag <span class="hljs-keyword">is</span> <span class="hljs-string">'UNLESS'</span>
    385. 

  385.         tag = <span class="hljs-string">'IF'</span>
    386. 

  386.       <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> tag <span class="hljs-keyword">in</span> UNARY
    387. 

  387.         tag = <span class="hljs-string">'UNARY'</span>
    388. 

  388.       <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> tag <span class="hljs-keyword">in</span> RELATION
    389. 

  389.         <span class="hljs-keyword">if</span> tag <span class="hljs-keyword">isnt</span> <span class="hljs-string">'INSTANCEOF'</span> <span class="hljs-keyword">and</span> <span class="hljs-property">@seenFor</span>
    390. 

  390.           tag = <span class="hljs-string">'FOR'</span> + tag
    391. 

  391.           <span class="hljs-property">@seenFor</span> = <span class="hljs-literal">no</span>
    392. 

  392.         <span class="hljs-keyword">else</span>
    393. 

  393.           tag = <span class="hljs-string">'RELATION'</span>
    394. 

  394.           <span class="hljs-keyword">if</span> <span class="hljs-property">@value</span>() <span class="hljs-keyword">is</span> <span class="hljs-string">'!'</span>
    395. 

  395.             poppedToken = <span class="hljs-property">@tokens</span>.pop()
    396. 

  396.             id = <span class="hljs-string">'!'</span> + id
    397. 

  397. 

  398.     <span class="hljs-keyword">if</span> id <span class="hljs-keyword">in</span> JS_FORBIDDEN
    399. 

  399.       <span class="hljs-keyword">if</span> forcedIdentifier
    400. 

  400.         tag = <span class="hljs-string">'IDENTIFIER'</span>
    401. 

  401.         id  = <span class="hljs-keyword">new</span> String id
    402. 

  402.         id.reserved = <span class="hljs-literal">yes</span>
    403. 

  403.       <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> id <span class="hljs-keyword">in</span> RESERVED
    404. 

  404.         <span class="hljs-property">@error</span> <span class="hljs-string">"reserved word '<span class="hljs-subst">#{id}</span>'"</span>, <span class="hljs-attribute">length</span>: id.length
    405. 

  405. 

  406.     <span class="hljs-keyword">unless</span> forcedIdentifier
    407. 

  407.       <span class="hljs-keyword">if</span> id <span class="hljs-keyword">in</span> COFFEE_ALIASES
    408. 

  408.         alias = id
    409. 

  409.         id = COFFEE_ALIAS_MAP[id]
    410. 

  410.       tag = <span class="hljs-keyword">switch</span> id
    411. 

  411.         <span class="hljs-keyword">when</span> <span class="hljs-string">'!'</span>                 <span class="hljs-keyword">then</span> <span class="hljs-string">'UNARY'</span>
    412. 

  412.         <span class="hljs-keyword">when</span> <span class="hljs-string">'=='</span>, <span class="hljs-string">'!='</span>          <span class="hljs-keyword">then</span> <span class="hljs-string">'COMPARE'</span>
    413. 

  413.         <span class="hljs-keyword">when</span> <span class="hljs-string">'&amp;&amp;'</span>, <span class="hljs-string">'||'</span>          <span class="hljs-keyword">then</span> <span class="hljs-string">'LOGIC'</span>
    414. 

  414.         <span class="hljs-keyword">when</span> <span class="hljs-string">'true'</span>, <span class="hljs-string">'false'</span>     <span class="hljs-keyword">then</span> <span class="hljs-string">'BOOL'</span>
    415. 

  415.         <span class="hljs-keyword">when</span> <span class="hljs-string">'break'</span>, <span class="hljs-string">'continue'</span> <span class="hljs-keyword">then</span> <span class="hljs-string">'STATEMENT'</span>
    416. 

  416.         <span class="hljs-keyword">else</span>  tag
    417. 

  417. 

  418.     tagToken = <span class="hljs-property">@token</span> tag, id, <span class="hljs-number">0</span>, idLength
    419. 

  419.     tagToken.origin = [tag, alias, tagToken[<span class="hljs-number">2</span>]] <span class="hljs-keyword">if</span> alias
    420. 

  420.     tagToken.variable = <span class="hljs-keyword">not</span> forcedIdentifier
    421. 

  421.     <span class="hljs-keyword">if</span> poppedToken
    422. 

  422.       [tagToken[<span class="hljs-number">2</span>].first_line, tagToken[<span class="hljs-number">2</span>].first_column] =
    423. 

  423.         [poppedToken[<span class="hljs-number">2</span>].first_line, poppedToken[<span class="hljs-number">2</span>].first_column]
    424. 

  424.     <span class="hljs-keyword">if</span> colon
    425. 

  425.       colonOffset = input.lastIndexOf <span class="hljs-string">':'</span>
    426. 

  426.       <span class="hljs-property">@token</span> <span class="hljs-string">':'</span>, <span class="hljs-string">':'</span>, colonOffset, colon.length
    427. 

  427. 

  428.     input.length</pre></div></div>
    429. 

  429.             
    430. 

  430.         </li>
    431. 

  431.         
    432. 

  432.         
    433. 

  433.         <li id="section-14">
    434. 

  434.             <div class="annotation">
    435. 

  435.               
    436. 

  436.               <div class="pilwrap ">
    437. 

  437.                 <a class="pilcrow" href="#section-14">&#182;</a>
    438. 

  438.               </div>
    439. 

  439.               <p>Matches numbers, including decimals, hex, and exponential notation.
    440. 

  440. Be careful not to interfere with ranges-in-progress.</p>
    441. 

  441. 

  442.             </div>
    443. 

  443.             
    444. 

  444.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">numberToken</span>:<span class="hljs-function"> -&gt;</span>
    445. 

  445.     <span class="hljs-keyword">return</span> <span class="hljs-number">0</span> <span class="hljs-keyword">unless</span> match = NUMBER.exec <span class="hljs-property">@chunk</span>
    446. 

  446.     number = match[<span class="hljs-number">0</span>]
    447. 

  447.     lexedLength = number.length
    448. 

  448.     <span class="hljs-keyword">if</span> <span class="hljs-regexp">/^0[BOX]/</span>.test number
    449. 

  449.       <span class="hljs-property">@error</span> <span class="hljs-string">"radix prefix in '<span class="hljs-subst">#{number}</span>' must be lowercase"</span>, <span class="hljs-attribute">offset</span>: <span class="hljs-number">1</span>
    450. 

  450.     <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> <span class="hljs-regexp">/E/</span>.test(number) <span class="hljs-keyword">and</span> <span class="hljs-keyword">not</span> <span class="hljs-regexp">/^0x/</span>.test number
    451. 

  451.       <span class="hljs-property">@error</span> <span class="hljs-string">"exponential notation in '<span class="hljs-subst">#{number}</span>' must be indicated with a lowercase 'e'"</span>,
    452. 

  452.         <span class="hljs-attribute">offset</span>: number.indexOf(<span class="hljs-string">'E'</span>)
    453. 

  453.     <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> <span class="hljs-regexp">/^0\d*[89]/</span>.test number
    454. 

  454.       <span class="hljs-property">@error</span> <span class="hljs-string">"decimal literal '<span class="hljs-subst">#{number}</span>' must not be prefixed with '0'"</span>, <span class="hljs-attribute">length</span>: lexedLength
    455. 

  455.     <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> <span class="hljs-regexp">/^0\d+/</span>.test number
    456. 

  456.       <span class="hljs-property">@error</span> <span class="hljs-string">"octal literal '<span class="hljs-subst">#{number}</span>' must be prefixed with '0o'"</span>, <span class="hljs-attribute">length</span>: lexedLength
    457. 

  457.     <span class="hljs-keyword">if</span> octalLiteral = <span class="hljs-regexp">/^0o([0-7]+)/</span>.exec number
    458. 

  458.       number = <span class="hljs-string">'0x'</span> + parseInt(octalLiteral[<span class="hljs-number">1</span>], <span class="hljs-number">8</span>).toString <span class="hljs-number">16</span>
    459. 

  459.     <span class="hljs-keyword">if</span> binaryLiteral = <span class="hljs-regexp">/^0b([01]+)/</span>.exec number
    460. 

  460.       number = <span class="hljs-string">'0x'</span> + parseInt(binaryLiteral[<span class="hljs-number">1</span>], <span class="hljs-number">2</span>).toString <span class="hljs-number">16</span>
    461. 

  461.     <span class="hljs-property">@token</span> <span class="hljs-string">'NUMBER'</span>, number, <span class="hljs-number">0</span>, lexedLength
    462. 

  462.     lexedLength</pre></div></div>
    463. 

  463.             
    464. 

  464.         </li>
    465. 

  465.         
    466. 

  466.         
    467. 

  467.         <li id="section-15">
    468. 

  468.             <div class="annotation">
    469. 

  469.               
    470. 

  470.               <div class="pilwrap ">
    471. 

  471.                 <a class="pilcrow" href="#section-15">&#182;</a>
    472. 

  472.               </div>
    473. 

  473.               <p>Matches strings, including multi-line strings, as well as heredocs, with or without
    474. 

  474. interpolation.</p>
    475. 

  475. 

  476.             </div>
    477. 

  477.             
    478. 

  478.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">stringToken</span>:<span class="hljs-function"> -&gt;</span>
    479. 

  479.     [quote] = STRING_START.exec(<span class="hljs-property">@chunk</span>) || []
    480. 

  480.     <span class="hljs-keyword">return</span> <span class="hljs-number">0</span> <span class="hljs-keyword">unless</span> quote
    481. 

  481.     regex = <span class="hljs-keyword">switch</span> quote
    482. 

  482.       <span class="hljs-keyword">when</span> <span class="hljs-string">"'"</span>   <span class="hljs-keyword">then</span> STRING_SINGLE
    483. 

  483.       <span class="hljs-keyword">when</span> <span class="hljs-string">'"'</span>   <span class="hljs-keyword">then</span> STRING_DOUBLE
    484. 

  484.       <span class="hljs-keyword">when</span> <span class="hljs-string">"'''"</span> <span class="hljs-keyword">then</span> HEREDOC_SINGLE
    485. 

  485.       <span class="hljs-keyword">when</span> <span class="hljs-string">'"""'</span> <span class="hljs-keyword">then</span> HEREDOC_DOUBLE
    486. 

  486.     heredoc = quote.length <span class="hljs-keyword">is</span> <span class="hljs-number">3</span>
    487. 

  487. 

  488.     {tokens, <span class="hljs-attribute">index</span>: end} = <span class="hljs-property">@matchWithInterpolations</span> regex, quote
    489. 

  489.     $ = tokens.length - <span class="hljs-number">1</span>
    490. 

  490. 

  491.     delimiter = quote.charAt(<span class="hljs-number">0</span>)
    492. 

  492.     <span class="hljs-keyword">if</span> heredoc</pre></div></div>
    493. 

  493.             
    494. 

  494.         </li>
    495. 

  495.         
    496. 

  496.         
    497. 

  497.         <li id="section-16">
    498. 

  498.             <div class="annotation">
    499. 

  499.               
    500. 

  500.               <div class="pilwrap ">
    501. 

  501.                 <a class="pilcrow" href="#section-16">&#182;</a>
    502. 

  502.               </div>
    503. 

  503.               <p>Find the smallest indentation. It will be removed from all lines later.</p>
    504. 

  504. 

  505.             </div>
    506. 

  506.             
    507. 

  507.             <div class="content"><div class='highlight'><pre>      indent = <span class="hljs-literal">null</span>
    508. 

  508.       doc = (token[<span class="hljs-number">1</span>] <span class="hljs-keyword">for</span> token, i <span class="hljs-keyword">in</span> tokens <span class="hljs-keyword">when</span> token[<span class="hljs-number">0</span>] <span class="hljs-keyword">is</span> <span class="hljs-string">'NEOSTRING'</span>).join <span class="hljs-string">'#{}'</span>
    509. 

  509.       <span class="hljs-keyword">while</span> match = HEREDOC_INDENT.exec doc
    510. 

  510.         attempt = match[<span class="hljs-number">1</span>]
    511. 

  511.         indent = attempt <span class="hljs-keyword">if</span> indent <span class="hljs-keyword">is</span> <span class="hljs-literal">null</span> <span class="hljs-keyword">or</span> <span class="hljs-number">0</span> &lt; attempt.length &lt; indent.length
    512. 

  512.       indentRegex = <span class="hljs-regexp">/// ^<span class="hljs-subst">#{indent}</span> ///</span>gm <span class="hljs-keyword">if</span> indent
    513. 

  513.       <span class="hljs-property">@mergeInterpolationTokens</span> tokens, {delimiter}, <span class="hljs-function"><span class="hljs-params">(value, i)</span> =&gt;</span>
    514. 

  514.         value = <span class="hljs-property">@formatString</span> value
    515. 

  515.         value = value.replace LEADING_BLANK_LINE,  <span class="hljs-string">''</span> <span class="hljs-keyword">if</span> i <span class="hljs-keyword">is</span> <span class="hljs-number">0</span>
    516. 

  516.         value = value.replace TRAILING_BLANK_LINE, <span class="hljs-string">''</span> <span class="hljs-keyword">if</span> i <span class="hljs-keyword">is</span> $
    517. 

  517.         value = value.replace indentRegex, <span class="hljs-string">''</span> <span class="hljs-keyword">if</span> indentRegex
    518. 

  518.         value
    519. 

  519.     <span class="hljs-keyword">else</span>
    520. 

  520.       <span class="hljs-property">@mergeInterpolationTokens</span> tokens, {delimiter}, <span class="hljs-function"><span class="hljs-params">(value, i)</span> =&gt;</span>
    521. 

  521.         value = <span class="hljs-property">@formatString</span> value
    522. 

  522.         value = value.replace SIMPLE_STRING_OMIT, <span class="hljs-function"><span class="hljs-params">(match, offset)</span> -&gt;</span>
    523. 

  523.           <span class="hljs-keyword">if</span> (i <span class="hljs-keyword">is</span> <span class="hljs-number">0</span> <span class="hljs-keyword">and</span> offset <span class="hljs-keyword">is</span> <span class="hljs-number">0</span>) <span class="hljs-keyword">or</span>
    524. 

  524.              (i <span class="hljs-keyword">is</span> $ <span class="hljs-keyword">and</span> offset + match.length <span class="hljs-keyword">is</span> value.length)
    525. 

  525.             <span class="hljs-string">''</span>
    526. 

  526.           <span class="hljs-keyword">else</span>
    527. 

  527.             <span class="hljs-string">' '</span>
    528. 

  528.         value
    529. 

  529. 

  530.     end</pre></div></div>
    531. 

  531.             
    532. 

  532.         </li>
    533. 

  533.         
    534. 

  534.         
    535. 

  535.         <li id="section-17">
    536. 

  536.             <div class="annotation">
    537. 

  537.               
    538. 

  538.               <div class="pilwrap ">
    539. 

  539.                 <a class="pilcrow" href="#section-17">&#182;</a>
    540. 

  540.               </div>
    541. 

  541.               <p>Matches and consumes comments.</p>
    542. 

  542. 

  543.             </div>
    544. 

  544.             
    545. 

  545.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">commentToken</span>:<span class="hljs-function"> -&gt;</span>
    546. 

  546.     <span class="hljs-keyword">return</span> <span class="hljs-number">0</span> <span class="hljs-keyword">unless</span> match = <span class="hljs-property">@chunk</span>.match COMMENT
    547. 

  547.     [comment, here] = match
    548. 

  548.     <span class="hljs-keyword">if</span> here
    549. 

  549.       <span class="hljs-keyword">if</span> match = HERECOMMENT_ILLEGAL.exec comment
    550. 

  550.         <span class="hljs-property">@error</span> <span class="hljs-string">"block comments cannot contain <span class="hljs-subst">#{match[<span class="hljs-number">0</span>]}</span>"</span>,
    551. 

  551.           <span class="hljs-attribute">offset</span>: match.index, <span class="hljs-attribute">length</span>: match[<span class="hljs-number">0</span>].length
    552. 

  552.       <span class="hljs-keyword">if</span> here.indexOf(<span class="hljs-string">'\n'</span>) &gt;= <span class="hljs-number">0</span>
    553. 

  553.         here = here.replace <span class="hljs-regexp">/// \n <span class="hljs-subst">#{repeat <span class="hljs-string">' '</span>, <span class="hljs-property">@indent</span>}</span> ///</span>g, <span class="hljs-string">'\n'</span>
    554. 

  554.       <span class="hljs-property">@token</span> <span class="hljs-string">'HERECOMMENT'</span>, here, <span class="hljs-number">0</span>, comment.length
    555. 

  555.     comment.length</pre></div></div>
    556. 

  556.             
    557. 

  557.         </li>
    558. 

  558.         
    559. 

  559.         
    560. 

  560.         <li id="section-18">
    561. 

  561.             <div class="annotation">
    562. 

  562.               
    563. 

  563.               <div class="pilwrap ">
    564. 

  564.                 <a class="pilcrow" href="#section-18">&#182;</a>
    565. 

  565.               </div>
    566. 

  566.               <p>Matches JavaScript interpolated directly into the source via backticks.</p>
    567. 

  567. 

  568.             </div>
    569. 

  569.             
    570. 

  570.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">jsToken</span>:<span class="hljs-function"> -&gt;</span>
    571. 

  571.     <span class="hljs-keyword">return</span> <span class="hljs-number">0</span> <span class="hljs-keyword">unless</span> <span class="hljs-property">@chunk</span>.charAt(<span class="hljs-number">0</span>) <span class="hljs-keyword">is</span> <span class="hljs-string">'`'</span> <span class="hljs-keyword">and</span> match = JSTOKEN.exec <span class="hljs-property">@chunk</span>
    572. 

  572.     <span class="hljs-property">@token</span> <span class="hljs-string">'JS'</span>, (script = match[<span class="hljs-number">0</span>])[<span class="hljs-number">1.</span>..-<span class="hljs-number">1</span>], <span class="hljs-number">0</span>, script.length
    573. 

  573.     script.length</pre></div></div>
    574. 

  574.             
    575. 

  575.         </li>
    576. 

  576.         
    577. 

  577.         
    578. 

  578.         <li id="section-19">
    579. 

  579.             <div class="annotation">
    580. 

  580.               
    581. 

  581.               <div class="pilwrap ">
    582. 

  582.                 <a class="pilcrow" href="#section-19">&#182;</a>
    583. 

  583.               </div>
    584. 

  584.               <p>Matches regular expression literals, as well as multiline extended ones.
    585. 

  585. Lexing regular expressions is difficult to distinguish from division, so we
    586. 

  586. borrow some basic heuristics from JavaScript and Ruby.</p>
    587. 

  587. 

  588.             </div>
    589. 

  589.             
    590. 

  590.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">regexToken</span>:<span class="hljs-function"> -&gt;</span>
    591. 

  591.     <span class="hljs-keyword">switch</span>
    592. 

  592.       <span class="hljs-keyword">when</span> match = REGEX_ILLEGAL.exec <span class="hljs-property">@chunk</span>
    593. 

  593.         <span class="hljs-property">@error</span> <span class="hljs-string">"regular expressions cannot begin with <span class="hljs-subst">#{match[<span class="hljs-number">2</span>]}</span>"</span>,
    594. 

  594.           <span class="hljs-attribute">offset</span>: match.index + match[<span class="hljs-number">1</span>].length
    595. 

  595.       <span class="hljs-keyword">when</span> match = <span class="hljs-property">@matchWithInterpolations</span> HEREGEX, <span class="hljs-string">'///'</span>
    596. 

  596.         {tokens, index} = match
    597. 

  597.       <span class="hljs-keyword">when</span> match = REGEX.exec <span class="hljs-property">@chunk</span>
    598. 

  598.         [regex, body, closed] = match
    599. 

  599.         <span class="hljs-property">@validateEscapes</span> body, <span class="hljs-attribute">isRegex</span>: <span class="hljs-literal">yes</span>, <span class="hljs-attribute">offsetInChunk</span>: <span class="hljs-number">1</span>
    600. 

  600.         index = regex.length
    601. 

  601.         [..., prev] = <span class="hljs-property">@tokens</span>
    602. 

  602.         <span class="hljs-keyword">if</span> prev
    603. 

  603.           <span class="hljs-keyword">if</span> prev.spaced <span class="hljs-keyword">and</span> prev[<span class="hljs-number">0</span>] <span class="hljs-keyword">in</span> CALLABLE
    604. 

  604.             <span class="hljs-keyword">return</span> <span class="hljs-number">0</span> <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> closed <span class="hljs-keyword">or</span> POSSIBLY_DIVISION.test regex
    605. 

  605.           <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> prev[<span class="hljs-number">0</span>] <span class="hljs-keyword">in</span> NOT_REGEX
    606. 

  606.             <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>
    607. 

  607.         <span class="hljs-property">@error</span> <span class="hljs-string">'missing / (unclosed regex)'</span> <span class="hljs-keyword">unless</span> closed
    608. 

  608.       <span class="hljs-keyword">else</span>
    609. 

  609.         <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>
    610. 

  610. 

  611.     [flags] = REGEX_FLAGS.exec <span class="hljs-property">@chunk</span>[index..]
    612. 

  612.     end = index + flags.length
    613. 

  613.     origin = <span class="hljs-property">@makeToken</span> <span class="hljs-string">'REGEX'</span>, <span class="hljs-literal">null</span>, <span class="hljs-number">0</span>, end
    614. 

  614.     <span class="hljs-keyword">switch</span>
    615. 

  615.       <span class="hljs-keyword">when</span> <span class="hljs-keyword">not</span> VALID_FLAGS.test flags
    616. 

  616.         <span class="hljs-property">@error</span> <span class="hljs-string">"invalid regular expression flags <span class="hljs-subst">#{flags}</span>"</span>, <span class="hljs-attribute">offset</span>: index, <span class="hljs-attribute">length</span>: flags.length
    617. 

  617.       <span class="hljs-keyword">when</span> regex <span class="hljs-keyword">or</span> tokens.length <span class="hljs-keyword">is</span> <span class="hljs-number">1</span>
    618. 

  618.         body ?= <span class="hljs-property">@formatHeregex</span> tokens[<span class="hljs-number">0</span>][<span class="hljs-number">1</span>]
    619. 

  619.         <span class="hljs-property">@token</span> <span class="hljs-string">'REGEX'</span>, <span class="hljs-string">"<span class="hljs-subst">#{<span class="hljs-property">@makeDelimitedLiteral</span> body, delimiter: <span class="hljs-string">'/'</span>}</span><span class="hljs-subst">#{flags}</span>"</span>, <span class="hljs-number">0</span>, end, origin
    620. 

  620.       <span class="hljs-keyword">else</span>
    621. 

  621.         <span class="hljs-property">@token</span> <span class="hljs-string">'REGEX_START'</span>, <span class="hljs-string">'('</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, origin
    622. 

  622.         <span class="hljs-property">@token</span> <span class="hljs-string">'IDENTIFIER'</span>, <span class="hljs-string">'RegExp'</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>
    623. 

  623.         <span class="hljs-property">@token</span> <span class="hljs-string">'CALL_START'</span>, <span class="hljs-string">'('</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>
    624. 

  624.         <span class="hljs-property">@mergeInterpolationTokens</span> tokens, {<span class="hljs-attribute">delimiter</span>: <span class="hljs-string">'"'</span>, <span class="hljs-attribute">double</span>: <span class="hljs-literal">yes</span>}, <span class="hljs-property">@formatHeregex</span>
    625. 

  625.         <span class="hljs-keyword">if</span> flags
    626. 

  626.           <span class="hljs-property">@token</span> <span class="hljs-string">','</span>, <span class="hljs-string">','</span>, index, <span class="hljs-number">0</span>
    627. 

  627.           <span class="hljs-property">@token</span> <span class="hljs-string">'STRING'</span>, <span class="hljs-string">'"'</span> + flags + <span class="hljs-string">'"'</span>, index, flags.length
    628. 

  628.         <span class="hljs-property">@token</span> <span class="hljs-string">')'</span>, <span class="hljs-string">')'</span>, end, <span class="hljs-number">0</span>
    629. 

  629.         <span class="hljs-property">@token</span> <span class="hljs-string">'REGEX_END'</span>, <span class="hljs-string">')'</span>, end, <span class="hljs-number">0</span>
    630. 

  630. 

  631.     end</pre></div></div>
    632. 

  632.             
    633. 

  633.         </li>
    634. 

  634.         
    635. 

  635.         
    636. 

  636.         <li id="section-20">
    637. 

  637.             <div class="annotation">
    638. 

  638.               
    639. 

  639.               <div class="pilwrap ">
    640. 

  640.                 <a class="pilcrow" href="#section-20">&#182;</a>
    641. 

  641.               </div>
    642. 

  642.               <p>Matches newlines, indents, and outdents, and determines which is which.
    643. 

  643. If we can detect that the current line is continued onto the next line,
    644. 

  644. then the newline is suppressed:</p>
    645. 

  645. <pre><code>elements
    646. 

  646.   .each( ... )
    647. 

  647.   .map( ... )
    648. 

  648. </code></pre><p>Keeps track of the level of indentation, because a single outdent token
    649. 

  649. can close multiple indents, so we need to know how far in we happen to be.</p>
    650. 

  650. 

  651.             </div>
    652. 

  652.             
    653. 

  653.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">lineToken</span>:<span class="hljs-function"> -&gt;</span>
    654. 

  654.     <span class="hljs-keyword">return</span> <span class="hljs-number">0</span> <span class="hljs-keyword">unless</span> match = MULTI_DENT.exec <span class="hljs-property">@chunk</span>
    655. 

  655.     indent = match[<span class="hljs-number">0</span>]
    656. 

  656.     <span class="hljs-property">@seenFor</span> = <span class="hljs-literal">no</span>
    657. 

  657.     size = indent.length - <span class="hljs-number">1</span> - indent.lastIndexOf <span class="hljs-string">'\n'</span>
    658. 

  658.     noNewlines = <span class="hljs-property">@unfinished</span>()
    659. 

  659.     <span class="hljs-keyword">if</span> size - <span class="hljs-property">@indebt</span> <span class="hljs-keyword">is</span> <span class="hljs-property">@indent</span>
    660. 

  660.       <span class="hljs-keyword">if</span> noNewlines <span class="hljs-keyword">then</span> <span class="hljs-property">@suppressNewlines</span>() <span class="hljs-keyword">else</span> <span class="hljs-property">@newlineToken</span> <span class="hljs-number">0</span>
    661. 

  661.       <span class="hljs-keyword">return</span> indent.length
    662. 

  662. 

  663.     <span class="hljs-keyword">if</span> size &gt; <span class="hljs-property">@indent</span>
    664. 

  664.       <span class="hljs-keyword">if</span> noNewlines
    665. 

  665.         <span class="hljs-property">@indebt</span> = size - <span class="hljs-property">@indent</span>
    666. 

  666.         <span class="hljs-property">@suppressNewlines</span>()
    667. 

  667.         <span class="hljs-keyword">return</span> indent.length
    668. 

  668.       <span class="hljs-keyword">unless</span> <span class="hljs-property">@tokens</span>.length
    669. 

  669.         <span class="hljs-property">@baseIndent</span> = <span class="hljs-property">@indent</span> = size
    670. 

  670.         <span class="hljs-keyword">return</span> indent.length
    671. 

  671.       diff = size - <span class="hljs-property">@indent</span> + <span class="hljs-property">@outdebt</span>
    672. 

  672.       <span class="hljs-property">@token</span> <span class="hljs-string">'INDENT'</span>, diff, indent.length - size, size
    673. 

  673.       <span class="hljs-property">@indents</span>.push diff
    674. 

  674.       <span class="hljs-property">@ends</span>.push {<span class="hljs-attribute">tag</span>: <span class="hljs-string">'OUTDENT'</span>}
    675. 

  675.       <span class="hljs-property">@outdebt</span> = <span class="hljs-property">@indebt</span> = <span class="hljs-number">0</span>
    676. 

  676.       <span class="hljs-property">@indent</span> = size
    677. 

  677.     <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> size &lt; <span class="hljs-property">@baseIndent</span>
    678. 

  678.       <span class="hljs-property">@error</span> <span class="hljs-string">'missing indentation'</span>, <span class="hljs-attribute">offset</span>: indent.length
    679. 

  679.     <span class="hljs-keyword">else</span>
    680. 

  680.       <span class="hljs-property">@indebt</span> = <span class="hljs-number">0</span>
    681. 

  681.       <span class="hljs-property">@outdentToken</span> <span class="hljs-property">@indent</span> - size, noNewlines, indent.length
    682. 

  682.     indent.length</pre></div></div>
    683. 

  683.             
    684. 

  684.         </li>
    685. 

  685.         
    686. 

  686.         
    687. 

  687.         <li id="section-21">
    688. 

  688.             <div class="annotation">
    689. 

  689.               
    690. 

  690.               <div class="pilwrap ">
    691. 

  691.                 <a class="pilcrow" href="#section-21">&#182;</a>
    692. 

  692.               </div>
    693. 

  693.               <p>Record an outdent token or multiple tokens, if we happen to be moving back
    694. 

  694. inwards past several recorded indents. Sets new @indent value.</p>
    695. 

  695. 

  696.             </div>
    697. 

  697.             
    698. 

  698.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">outdentToken</span>: <span class="hljs-function"><span class="hljs-params">(moveOut, noNewlines, outdentLength)</span> -&gt;</span>
    699. 

  699.     decreasedIndent = <span class="hljs-property">@indent</span> - moveOut
    700. 

  700.     <span class="hljs-keyword">while</span> moveOut &gt; <span class="hljs-number">0</span>
    701. 

  701.       lastIndent = <span class="hljs-property">@indents</span>[<span class="hljs-property">@indents</span>.length - <span class="hljs-number">1</span>]
    702. 

  702.       <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> lastIndent
    703. 

  703.         moveOut = <span class="hljs-number">0</span>
    704. 

  704.       <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> lastIndent <span class="hljs-keyword">is</span> <span class="hljs-property">@outdebt</span>
    705. 

  705.         moveOut -= <span class="hljs-property">@outdebt</span>
    706. 

  706.         <span class="hljs-property">@outdebt</span> = <span class="hljs-number">0</span>
    707. 

  707.       <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> lastIndent &lt; <span class="hljs-property">@outdebt</span>
    708. 

  708.         <span class="hljs-property">@outdebt</span> -= lastIndent
    709. 

  709.         moveOut  -= lastIndent
    710. 

  710.       <span class="hljs-keyword">else</span>
    711. 

  711.         dent = <span class="hljs-property">@indents</span>.pop() + <span class="hljs-property">@outdebt</span>
    712. 

  712.         <span class="hljs-keyword">if</span> outdentLength <span class="hljs-keyword">and</span> <span class="hljs-property">@chunk</span>[outdentLength] <span class="hljs-keyword">in</span> INDENTABLE_CLOSERS
    713. 

  713.           decreasedIndent -= dent - moveOut
    714. 

  714.           moveOut = dent
    715. 

  715.         <span class="hljs-property">@outdebt</span> = <span class="hljs-number">0</span></pre></div></div>
    716. 

  716.             
    717. 

  717.         </li>
    718. 

  718.         
    719. 

  719.         
    720. 

  720.         <li id="section-22">
    721. 

  721.             <div class="annotation">
    722. 

  722.               
    723. 

  723.               <div class="pilwrap ">
    724. 

  724.                 <a class="pilcrow" href="#section-22">&#182;</a>
    725. 

  725.               </div>
    726. 

  726.               <p>pair might call outdentToken, so preserve decreasedIndent</p>
    727. 

  727. 

  728.             </div>
    729. 

  729.             
    730. 

  730.             <div class="content"><div class='highlight'><pre>        <span class="hljs-property">@pair</span> <span class="hljs-string">'OUTDENT'</span>
    731. 

  731.         <span class="hljs-property">@token</span> <span class="hljs-string">'OUTDENT'</span>, moveOut, <span class="hljs-number">0</span>, outdentLength
    732. 

  732.         moveOut -= dent
    733. 

  733.     <span class="hljs-property">@outdebt</span> -= moveOut <span class="hljs-keyword">if</span> dent
    734. 

  734.     <span class="hljs-property">@tokens</span>.pop() <span class="hljs-keyword">while</span> <span class="hljs-property">@value</span>() <span class="hljs-keyword">is</span> <span class="hljs-string">';'</span>
    735. 

  735. 

  736.     <span class="hljs-property">@token</span> <span class="hljs-string">'TERMINATOR'</span>, <span class="hljs-string">'\n'</span>, outdentLength, <span class="hljs-number">0</span> <span class="hljs-keyword">unless</span> <span class="hljs-property">@tag</span>() <span class="hljs-keyword">is</span> <span class="hljs-string">'TERMINATOR'</span> <span class="hljs-keyword">or</span> noNewlines
    737. 

  737.     <span class="hljs-property">@indent</span> = decreasedIndent
    738. 

  738.     <span class="hljs-keyword">this</span></pre></div></div>
    739. 

  739.             
    740. 

  740.         </li>
    741. 

  741.         
    742. 

  742.         
    743. 

  743.         <li id="section-23">
    744. 

  744.             <div class="annotation">
    745. 

  745.               
    746. 

  746.               <div class="pilwrap ">
    747. 

  747.                 <a class="pilcrow" href="#section-23">&#182;</a>
    748. 

  748.               </div>
    749. 

  749.               <p>Matches and consumes non-meaningful whitespace. Tag the previous token
    750. 

  750. as being “spaced”, because there are some cases where it makes a difference.</p>
    751. 

  751. 

  752.             </div>
    753. 

  753.             
    754. 

  754.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">whitespaceToken</span>:<span class="hljs-function"> -&gt;</span>
    755. 

  755.     <span class="hljs-keyword">return</span> <span class="hljs-number">0</span> <span class="hljs-keyword">unless</span> (match = WHITESPACE.exec <span class="hljs-property">@chunk</span>) <span class="hljs-keyword">or</span>
    756. 

  756.                     (nline = <span class="hljs-property">@chunk</span>.charAt(<span class="hljs-number">0</span>) <span class="hljs-keyword">is</span> <span class="hljs-string">'\n'</span>)
    757. 

  757.     [..., prev] = <span class="hljs-property">@tokens</span>
    758. 

  758.     prev[<span class="hljs-keyword">if</span> match <span class="hljs-keyword">then</span> <span class="hljs-string">'spaced'</span> <span class="hljs-keyword">else</span> <span class="hljs-string">'newLine'</span>] = <span class="hljs-literal">true</span> <span class="hljs-keyword">if</span> prev
    759. 

  759.     <span class="hljs-keyword">if</span> match <span class="hljs-keyword">then</span> match[<span class="hljs-number">0</span>].length <span class="hljs-keyword">else</span> <span class="hljs-number">0</span></pre></div></div>
    760. 

  760.             
    761. 

  761.         </li>
    762. 

  762.         
    763. 

  763.         
    764. 

  764.         <li id="section-24">
    765. 

  765.             <div class="annotation">
    766. 

  766.               
    767. 

  767.               <div class="pilwrap ">
    768. 

  768.                 <a class="pilcrow" href="#section-24">&#182;</a>
    769. 

  769.               </div>
    770. 

  770.               <p>Generate a newline token. Consecutive newlines get merged together.</p>
    771. 

  771. 

  772.             </div>
    773. 

  773.             
    774. 

  774.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">newlineToken</span>: <span class="hljs-function"><span class="hljs-params">(offset)</span> -&gt;</span>
    775. 

  775.     <span class="hljs-property">@tokens</span>.pop() <span class="hljs-keyword">while</span> <span class="hljs-property">@value</span>() <span class="hljs-keyword">is</span> <span class="hljs-string">';'</span>
    776. 

  776.     <span class="hljs-property">@token</span> <span class="hljs-string">'TERMINATOR'</span>, <span class="hljs-string">'\n'</span>, offset, <span class="hljs-number">0</span> <span class="hljs-keyword">unless</span> <span class="hljs-property">@tag</span>() <span class="hljs-keyword">is</span> <span class="hljs-string">'TERMINATOR'</span>
    777. 

  777.     <span class="hljs-keyword">this</span></pre></div></div>
    778. 

  778.             
    779. 

  779.         </li>
    780. 

  780.         
    781. 

  781.         
    782. 

  782.         <li id="section-25">
    783. 

  783.             <div class="annotation">
    784. 

  784.               
    785. 

  785.               <div class="pilwrap ">
    786. 

  786.                 <a class="pilcrow" href="#section-25">&#182;</a>
    787. 

  787.               </div>
    788. 

  788.               <p>Use a <code>\</code> at a line-ending to suppress the newline.
    789. 

  789. The slash is removed here once its job is done.</p>
    790. 

  790. 

  791.             </div>
    792. 

  792.             
    793. 

  793.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">suppressNewlines</span>:<span class="hljs-function"> -&gt;</span>
    794. 

  794.     <span class="hljs-property">@tokens</span>.pop() <span class="hljs-keyword">if</span> <span class="hljs-property">@value</span>() <span class="hljs-keyword">is</span> <span class="hljs-string">'\\'</span>
    795. 

  795.     <span class="hljs-keyword">this</span></pre></div></div>
    796. 

  796.             
    797. 

  797.         </li>
    798. 

  798.         
    799. 

  799.         
    800. 

  800.         <li id="section-26">
    801. 

  801.             <div class="annotation">
    802. 

  802.               
    803. 

  803.               <div class="pilwrap ">
    804. 

  804.                 <a class="pilcrow" href="#section-26">&#182;</a>
    805. 

  805.               </div>
    806. 

  806.               <p>We treat all other single characters as a token. E.g.: <code>( ) , . !</code>
    807. 

  807. Multi-character operators are also literal tokens, so that Jison can assign
    808. 

  808. the proper order of operations. There are some symbols that we tag specially
    809. 

  809. here. <code>;</code> and newlines are both treated as a <code>TERMINATOR</code>, we distinguish
    810. 

  810. parentheses that indicate a method call from regular parentheses, and so on.</p>
    811. 

  811. 

  812.             </div>
    813. 

  813.             
    814. 

  814.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">literalToken</span>:<span class="hljs-function"> -&gt;</span>
    815. 

  815.     <span class="hljs-keyword">if</span> match = OPERATOR.exec <span class="hljs-property">@chunk</span>
    816. 

  816.       [value] = match
    817. 

  817.       <span class="hljs-property">@tagParameters</span>() <span class="hljs-keyword">if</span> CODE.test value
    818. 

  818.     <span class="hljs-keyword">else</span>
    819. 

  819.       value = <span class="hljs-property">@chunk</span>.charAt <span class="hljs-number">0</span>
    820. 

  820.     tag  = value
    821. 

  821.     [..., prev] = <span class="hljs-property">@tokens</span>
    822. 

  822.     <span class="hljs-keyword">if</span> value <span class="hljs-keyword">is</span> <span class="hljs-string">'='</span> <span class="hljs-keyword">and</span> prev
    823. 

  823.       <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> prev[<span class="hljs-number">1</span>].reserved <span class="hljs-keyword">and</span> prev[<span class="hljs-number">1</span>] <span class="hljs-keyword">in</span> JS_FORBIDDEN
    824. 

  824.         prev = prev.origin <span class="hljs-keyword">if</span> prev.origin
    825. 

  825.         <span class="hljs-property">@error</span> <span class="hljs-string">"reserved word '<span class="hljs-subst">#{prev[<span class="hljs-number">1</span>]}</span>' can't be assigned"</span>, prev[<span class="hljs-number">2</span>]
    826. 

  826.       <span class="hljs-keyword">if</span> prev[<span class="hljs-number">1</span>] <span class="hljs-keyword">in</span> [<span class="hljs-string">'||'</span>, <span class="hljs-string">'&amp;&amp;'</span>]
    827. 

  827.         prev[<span class="hljs-number">0</span>] = <span class="hljs-string">'COMPOUND_ASSIGN'</span>
    828. 

  828.         prev[<span class="hljs-number">1</span>] += <span class="hljs-string">'='</span>
    829. 

  829.         <span class="hljs-keyword">return</span> value.length
    830. 

  830.     <span class="hljs-keyword">if</span> value <span class="hljs-keyword">is</span> <span class="hljs-string">';'</span>
    831. 

  831.       <span class="hljs-property">@seenFor</span> = <span class="hljs-literal">no</span>
    832. 

  832.       tag = <span class="hljs-string">'TERMINATOR'</span>
    833. 

  833.     <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> value <span class="hljs-keyword">in</span> MATH            <span class="hljs-keyword">then</span> tag = <span class="hljs-string">'MATH'</span>
    834. 

  834.     <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> value <span class="hljs-keyword">in</span> COMPARE         <span class="hljs-keyword">then</span> tag = <span class="hljs-string">'COMPARE'</span>
    835. 

  835.     <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> value <span class="hljs-keyword">in</span> COMPOUND_ASSIGN <span class="hljs-keyword">then</span> tag = <span class="hljs-string">'COMPOUND_ASSIGN'</span>
    836. 

  836.     <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> value <span class="hljs-keyword">in</span> UNARY           <span class="hljs-keyword">then</span> tag = <span class="hljs-string">'UNARY'</span>
    837. 

  837.     <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> value <span class="hljs-keyword">in</span> UNARY_MATH      <span class="hljs-keyword">then</span> tag = <span class="hljs-string">'UNARY_MATH'</span>
    838. 

  838.     <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> value <span class="hljs-keyword">in</span> SHIFT           <span class="hljs-keyword">then</span> tag = <span class="hljs-string">'SHIFT'</span>
    839. 

  839.     <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> value <span class="hljs-keyword">in</span> LOGIC <span class="hljs-keyword">or</span> value <span class="hljs-keyword">is</span> <span class="hljs-string">'?'</span> <span class="hljs-keyword">and</span> prev?.spaced <span class="hljs-keyword">then</span> tag = <span class="hljs-string">'LOGIC'</span>
    840. 

  840.     <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> prev <span class="hljs-keyword">and</span> <span class="hljs-keyword">not</span> prev.spaced
    841. 

  841.       <span class="hljs-keyword">if</span> value <span class="hljs-keyword">is</span> <span class="hljs-string">'('</span> <span class="hljs-keyword">and</span> prev[<span class="hljs-number">0</span>] <span class="hljs-keyword">in</span> CALLABLE
    842. 

  842.         prev[<span class="hljs-number">0</span>] = <span class="hljs-string">'FUNC_EXIST'</span> <span class="hljs-keyword">if</span> prev[<span class="hljs-number">0</span>] <span class="hljs-keyword">is</span> <span class="hljs-string">'?'</span>
    843. 

  843.         tag = <span class="hljs-string">'CALL_START'</span>
    844. 

  844.       <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> value <span class="hljs-keyword">is</span> <span class="hljs-string">'['</span> <span class="hljs-keyword">and</span> prev[<span class="hljs-number">0</span>] <span class="hljs-keyword">in</span> INDEXABLE
    845. 

  845.         tag = <span class="hljs-string">'INDEX_START'</span>
    846. 

  846.         <span class="hljs-keyword">switch</span> prev[<span class="hljs-number">0</span>]
    847. 

  847.           <span class="hljs-keyword">when</span> <span class="hljs-string">'?'</span>  <span class="hljs-keyword">then</span> prev[<span class="hljs-number">0</span>] = <span class="hljs-string">'INDEX_SOAK'</span>
    848. 

  848.     token = <span class="hljs-property">@makeToken</span> tag, value
    849. 

  849.     <span class="hljs-keyword">switch</span> value
    850. 

  850.       <span class="hljs-keyword">when</span> <span class="hljs-string">'('</span>, <span class="hljs-string">'{'</span>, <span class="hljs-string">'['</span> <span class="hljs-keyword">then</span> <span class="hljs-property">@ends</span>.push {<span class="hljs-attribute">tag</span>: INVERSES[value], <span class="hljs-attribute">origin</span>: token}
    851. 

  851.       <span class="hljs-keyword">when</span> <span class="hljs-string">')'</span>, <span class="hljs-string">'}'</span>, <span class="hljs-string">']'</span> <span class="hljs-keyword">then</span> <span class="hljs-property">@pair</span> value
    852. 

  852.     <span class="hljs-property">@tokens</span>.push token
    853. 

  853.     value.length</pre></div></div>
    854. 

  854.             
    855. 

  855.         </li>
    856. 

  856.         
    857. 

  857.         
    858. 

  858.         <li id="section-27">
    859. 

  859.             <div class="annotation">
    860. 

  860.               
    861. 

  861.               <div class="pilwrap ">
    862. 

  862.                 <a class="pilcrow" href="#section-27">&#182;</a>
    863. 

  863.               </div>
    864. 

  864.               <h2 id="token-manipulators">Token Manipulators</h2>
    865. 

  865. 

  866.             </div>
    867. 

  867.             
    868. 

  868.         </li>
    869. 

  869.         
    870. 

  870.         
    871. 

  871.         <li id="section-28">
    872. 

  872.             <div class="annotation">
    873. 

  873.               
    874. 

  874.               <div class="pilwrap ">
    875. 

  875.                 <a class="pilcrow" href="#section-28">&#182;</a>
    876. 

  876.               </div>
    877. 

  877.               
    878. 

  878.             </div>
    879. 

  879.             
    880. 

  880.         </li>
    881. 

  881.         
    882. 

  882.         
    883. 

  883.         <li id="section-29">
    884. 

  884.             <div class="annotation">
    885. 

  885.               
    886. 

  886.               <div class="pilwrap ">
    887. 

  887.                 <a class="pilcrow" href="#section-29">&#182;</a>
    888. 

  888.               </div>
    889. 

  889.               <p>A source of ambiguity in our grammar used to be parameter lists in function
    890. 

  890. definitions versus argument lists in function calls. Walk backwards, tagging
    891. 

  891. parameters specially in order to make things easier for the parser.</p>
    892. 

  892. 

  893.             </div>
    894. 

  894.             
    895. 

  895.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">tagParameters</span>:<span class="hljs-function"> -&gt;</span>
    896. 

  896.     <span class="hljs-keyword">return</span> <span class="hljs-keyword">this</span> <span class="hljs-keyword">if</span> <span class="hljs-property">@tag</span>() <span class="hljs-keyword">isnt</span> <span class="hljs-string">')'</span>
    897. 

  897.     stack = []
    898. 

  898.     {tokens} = <span class="hljs-keyword">this</span>
    899. 

  899.     i = tokens.length
    900. 

  900.     tokens[--i][<span class="hljs-number">0</span>] = <span class="hljs-string">'PARAM_END'</span>
    901. 

  901.     <span class="hljs-keyword">while</span> tok = tokens[--i]
    902. 

  902.       <span class="hljs-keyword">switch</span> tok[<span class="hljs-number">0</span>]
    903. 

  903.         <span class="hljs-keyword">when</span> <span class="hljs-string">')'</span>
    904. 

  904.           stack.push tok
    905. 

  905.         <span class="hljs-keyword">when</span> <span class="hljs-string">'('</span>, <span class="hljs-string">'CALL_START'</span>
    906. 

  906.           <span class="hljs-keyword">if</span> stack.length <span class="hljs-keyword">then</span> stack.pop()
    907. 

  907.           <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> tok[<span class="hljs-number">0</span>] <span class="hljs-keyword">is</span> <span class="hljs-string">'('</span>
    908. 

  908.             tok[<span class="hljs-number">0</span>] = <span class="hljs-string">'PARAM_START'</span>
    909. 

  909.             <span class="hljs-keyword">return</span> <span class="hljs-keyword">this</span>
    910. 

  910.           <span class="hljs-keyword">else</span> <span class="hljs-keyword">return</span> <span class="hljs-keyword">this</span>
    911. 

  911.     <span class="hljs-keyword">this</span></pre></div></div>
    912. 

  912.             
    913. 

  913.         </li>
    914. 

  914.         
    915. 

  915.         
    916. 

  916.         <li id="section-30">
    917. 

  917.             <div class="annotation">
    918. 

  918.               
    919. 

  919.               <div class="pilwrap ">
    920. 

  920.                 <a class="pilcrow" href="#section-30">&#182;</a>
    921. 

  921.               </div>
    922. 

  922.               <p>Close up all remaining open blocks at the end of the file.</p>
    923. 

  923. 

  924.             </div>
    925. 

  925.             
    926. 

  926.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">closeIndentation</span>:<span class="hljs-function"> -&gt;</span>
    927. 

  927.     <span class="hljs-property">@outdentToken</span> <span class="hljs-property">@indent</span></pre></div></div>
    928. 

  928.             
    929. 

  929.         </li>
    930. 

  930.         
    931. 

  931.         
    932. 

  932.         <li id="section-31">
    933. 

  933.             <div class="annotation">
    934. 

  934.               
    935. 

  935.               <div class="pilwrap ">
    936. 

  936.                 <a class="pilcrow" href="#section-31">&#182;</a>
    937. 

  937.               </div>
    938. 

  938.               <p>Match the contents of a delimited token and expand variables and expressions
    939. 

  939. inside it using Ruby-like notation for substitution of arbitrary
    940. 

  940. expressions.</p>
    941. 

  941. <pre><code><span class="hljs-string">"Hello <span class="hljs-subst">#{name.capitalize()}</span>."</span>
    942. 

  942. </code></pre><p>If it encounters an interpolation, this method will recursively create a new
    943. 

  943. Lexer and tokenize until the <code>{</code> of <code>#{</code> is balanced with a <code>}</code>.</p>
    944. 

  944. <ul>
    945. 

  945. <li><code>regex</code> matches the contents of a token (but not <code>delimiter</code>, and not
    946. 

  946. <code>#{</code> if interpolations are desired).</li>
    947. 

  947. <li><code>delimiter</code> is the delimiter of the token. Examples are <code>&#39;</code>, <code>&quot;</code>, <code>&#39;&#39;&#39;</code>,
    948. 

  948. <code>&quot;&quot;&quot;</code> and <code>///</code>.</li>
    949. 

  949. </ul>
    950. 

  950. <p>This method allows us to have strings within interpolations within strings,
    951. 

  951. ad infinitum.</p>
    952. 

  952. 

  953.             </div>
    954. 

  954.             
    955. 

  955.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">matchWithInterpolations</span>: <span class="hljs-function"><span class="hljs-params">(regex, delimiter)</span> -&gt;</span>
    956. 

  956.     tokens = []
    957. 

  957.     offsetInChunk = delimiter.length
    958. 

  958.     <span class="hljs-keyword">return</span> <span class="hljs-literal">null</span> <span class="hljs-keyword">unless</span> <span class="hljs-property">@chunk</span>[...offsetInChunk] <span class="hljs-keyword">is</span> delimiter
    959. 

  959.     str = <span class="hljs-property">@chunk</span>[offsetInChunk..]
    960. 

  960.     <span class="hljs-keyword">loop</span>
    961. 

  961.       [strPart] = regex.exec str
    962. 

  962. 

  963.       <span class="hljs-property">@validateEscapes</span> strPart, {<span class="hljs-attribute">isRegex</span>: delimiter.charAt(<span class="hljs-number">0</span>) <span class="hljs-keyword">is</span> <span class="hljs-string">'/'</span>, offsetInChunk}</pre></div></div>
    964. 

  964.             
    965. 

  965.         </li>
    966. 

  966.         
    967. 

  967.         
    968. 

  968.         <li id="section-32">
    969. 

  969.             <div class="annotation">
    970. 

  970.               
    971. 

  971.               <div class="pilwrap ">
    972. 

  972.                 <a class="pilcrow" href="#section-32">&#182;</a>
    973. 

  973.               </div>
    974. 

  974.               <p>Push a fake ‘NEOSTRING’ token, which will get turned into a real string later.</p>
    975. 

  975. 

  976.             </div>
    977. 

  977.             
    978. 

  978.             <div class="content"><div class='highlight'><pre>      tokens.push <span class="hljs-property">@makeToken</span> <span class="hljs-string">'NEOSTRING'</span>, strPart, offsetInChunk
    979. 

  979. 

  980.       str = str[strPart.length..]
    981. 

  981.       offsetInChunk += strPart.length
    982. 

  982. 

  983.       <span class="hljs-keyword">break</span> <span class="hljs-keyword">unless</span> str[..<span class="hljs-number">.2</span>] <span class="hljs-keyword">is</span> <span class="hljs-string">'#{'</span></pre></div></div>
    984. 

  984.             
    985. 

  985.         </li>
    986. 

  986.         
    987. 

  987.         
    988. 

  988.         <li id="section-33">
    989. 

  989.             <div class="annotation">
    990. 

  990.               
    991. 

  991.               <div class="pilwrap ">
    992. 

  992.                 <a class="pilcrow" href="#section-33">&#182;</a>
    993. 

  993.               </div>
    994. 

  994.               <p>The <code>1</code>s are to remove the <code>#</code> in <code>#{</code>.</p>
    995. 

  995. 

  996.             </div>
    997. 

  997.             
    998. 

  998.             <div class="content"><div class='highlight'><pre>      [line, column] = <span class="hljs-property">@getLineAndColumnFromChunk</span> offsetInChunk + <span class="hljs-number">1</span>
    999. 

  999.       {<span class="hljs-attribute">tokens</span>: nested, index} =
    1000. 

  1000.         <span class="hljs-keyword">new</span> Lexer().tokenize str[<span class="hljs-number">1.</span>.], <span class="hljs-attribute">line</span>: line, <span class="hljs-attribute">column</span>: column, <span class="hljs-attribute">untilBalanced</span>: <span class="hljs-literal">on</span></pre></div></div>
    1001. 

  1001.             
    1002. 

  1002.         </li>
    1003. 

  1003.         
    1004. 

  1004.         
    1005. 

  1005.         <li id="section-34">
    1006. 

  1006.             <div class="annotation">
    1007. 

  1007.               
    1008. 

  1008.               <div class="pilwrap ">
    1009. 

  1009.                 <a class="pilcrow" href="#section-34">&#182;</a>
    1010. 

  1010.               </div>
    1011. 

  1011.               <p>Skip the trailing <code>}</code>.</p>
    1012. 

  1012. 

  1013.             </div>
    1014. 

  1014.             
    1015. 

  1015.             <div class="content"><div class='highlight'><pre>      index += <span class="hljs-number">1</span></pre></div></div>
    1016. 

  1016.             
    1017. 

  1017.         </li>
    1018. 

  1018.         
    1019. 

  1019.         
    1020. 

  1020.         <li id="section-35">
    1021. 

  1021.             <div class="annotation">
    1022. 

  1022.               
    1023. 

  1023.               <div class="pilwrap ">
    1024. 

  1024.                 <a class="pilcrow" href="#section-35">&#182;</a>
    1025. 

  1025.               </div>
    1026. 

  1026.               <p>Turn the leading and trailing <code>{</code> and <code>}</code> into parentheses. Unnecessary
    1027. 

  1027. parentheses will be removed later.</p>
    1028. 

  1028. 

  1029.             </div>
    1030. 

  1030.             
    1031. 

  1031.             <div class="content"><div class='highlight'><pre>      [open, ..., close] = nested
    1032. 

  1032.       open[<span class="hljs-number">0</span>]  = open[<span class="hljs-number">1</span>]  = <span class="hljs-string">'('</span>
    1033. 

  1033.       close[<span class="hljs-number">0</span>] = close[<span class="hljs-number">1</span>] = <span class="hljs-string">')'</span>
    1034. 

  1034.       close.origin = [<span class="hljs-string">''</span>, <span class="hljs-string">'end of interpolation'</span>, close[<span class="hljs-number">2</span>]]</pre></div></div>
    1035. 

  1035.             
    1036. 

  1036.         </li>
    1037. 

  1037.         
    1038. 

  1038.         
    1039. 

  1039.         <li id="section-36">
    1040. 

  1040.             <div class="annotation">
    1041. 

  1041.               
    1042. 

  1042.               <div class="pilwrap ">
    1043. 

  1043.                 <a class="pilcrow" href="#section-36">&#182;</a>
    1044. 

  1044.               </div>
    1045. 

  1045.               <p>Remove leading ‘TERMINATOR’ (if any).</p>
    1046. 

  1046. 

  1047.             </div>
    1048. 

  1048.             
    1049. 

  1049.             <div class="content"><div class='highlight'><pre>      nested.splice <span class="hljs-number">1</span>, <span class="hljs-number">1</span> <span class="hljs-keyword">if</span> nested[<span class="hljs-number">1</span>]?[<span class="hljs-number">0</span>] <span class="hljs-keyword">is</span> <span class="hljs-string">'TERMINATOR'</span></pre></div></div>
    1050. 

  1050.             
    1051. 

  1051.         </li>
    1052. 

  1052.         
    1053. 

  1053.         
    1054. 

  1054.         <li id="section-37">
    1055. 

  1055.             <div class="annotation">
    1056. 

  1056.               
    1057. 

  1057.               <div class="pilwrap ">
    1058. 

  1058.                 <a class="pilcrow" href="#section-37">&#182;</a>
    1059. 

  1059.               </div>
    1060. 

  1060.               <p>Push a fake ‘TOKENS’ token, which will get turned into real tokens later.</p>
    1061. 

  1061. 

  1062.             </div>
    1063. 

  1063.             
    1064. 

  1064.             <div class="content"><div class='highlight'><pre>      tokens.push [<span class="hljs-string">'TOKENS'</span>, nested]
    1065. 

  1065. 

  1066.       str = str[index..]
    1067. 

  1067.       offsetInChunk += index
    1068. 

  1068. 

  1069.     <span class="hljs-keyword">unless</span> str[...delimiter.length] <span class="hljs-keyword">is</span> delimiter
    1070. 

  1070.       <span class="hljs-property">@error</span> <span class="hljs-string">"missing <span class="hljs-subst">#{delimiter}</span>"</span>, <span class="hljs-attribute">length</span>: delimiter.length
    1071. 

  1071. 

  1072.     [firstToken, ..., lastToken] = tokens
    1073. 

  1073.     firstToken[<span class="hljs-number">2</span>].first_column -= delimiter.length
    1074. 

  1074.     lastToken[<span class="hljs-number">2</span>].last_column += delimiter.length
    1075. 

  1075.     lastToken[<span class="hljs-number">2</span>].last_column -= <span class="hljs-number">1</span> <span class="hljs-keyword">if</span> lastToken[<span class="hljs-number">1</span>].length <span class="hljs-keyword">is</span> <span class="hljs-number">0</span>
    1076. 

  1076. 

  1077.     {tokens, <span class="hljs-attribute">index</span>: offsetInChunk + delimiter.length}</pre></div></div>
    1078. 

  1078.             
    1079. 

  1079.         </li>
    1080. 

  1080.         
    1081. 

  1081.         
    1082. 

  1082.         <li id="section-38">
    1083. 

  1083.             <div class="annotation">
    1084. 

  1084.               
    1085. 

  1085.               <div class="pilwrap ">
    1086. 

  1086.                 <a class="pilcrow" href="#section-38">&#182;</a>
    1087. 

  1087.               </div>
    1088. 

  1088.               <p>Merge the array <code>tokens</code> of the fake token types ‘TOKENS’ and ‘NEOSTRING’
    1089. 

  1089. (as returned by <code>matchWithInterpolations</code>) into the token stream. The value
    1090. 

  1090. of ‘NEOSTRING’s are converted using <code>fn</code> and turned into strings using
    1091. 

  1091. <code>options</code> first.</p>
    1092. 

  1092. 

  1093.             </div>
    1094. 

  1094.             
    1095. 

  1095.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">mergeInterpolationTokens</span>: <span class="hljs-function"><span class="hljs-params">(tokens, options, fn)</span> -&gt;</span>
    1096. 

  1096.     <span class="hljs-keyword">if</span> tokens.length &gt; <span class="hljs-number">1</span>
    1097. 

  1097.       lparen = <span class="hljs-property">@token</span> <span class="hljs-string">'STRING_START'</span>, <span class="hljs-string">'('</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>
    1098. 

  1098. 

  1099.     firstIndex = <span class="hljs-property">@tokens</span>.length
    1100. 

  1100.     <span class="hljs-keyword">for</span> token, i <span class="hljs-keyword">in</span> tokens
    1101. 

  1101.       [tag, value] = token
    1102. 

  1102.       <span class="hljs-keyword">switch</span> tag
    1103. 

  1103.         <span class="hljs-keyword">when</span> <span class="hljs-string">'TOKENS'</span></pre></div></div>
    1104. 

  1104.             
    1105. 

  1105.         </li>
    1106. 

  1106.         
    1107. 

  1107.         
    1108. 

  1108.         <li id="section-39">
    1109. 

  1109.             <div class="annotation">
    1110. 

  1110.               
    1111. 

  1111.               <div class="pilwrap ">
    1112. 

  1112.                 <a class="pilcrow" href="#section-39">&#182;</a>
    1113. 

  1113.               </div>
    1114. 

  1114.               <p>Optimize out empty interpolations (an empty pair of parentheses).</p>
    1115. 

  1115. 

  1116.             </div>
    1117. 

  1117.             
    1118. 

  1118.             <div class="content"><div class='highlight'><pre>          <span class="hljs-keyword">continue</span> <span class="hljs-keyword">if</span> value.length <span class="hljs-keyword">is</span> <span class="hljs-number">2</span></pre></div></div>
    1119. 

  1119.             
    1120. 

  1120.         </li>
    1121. 

  1121.         
    1122. 

  1122.         
    1123. 

  1123.         <li id="section-40">
    1124. 

  1124.             <div class="annotation">
    1125. 

  1125.               
    1126. 

  1126.               <div class="pilwrap ">
    1127. 

  1127.                 <a class="pilcrow" href="#section-40">&#182;</a>
    1128. 

  1128.               </div>
    1129. 

  1129.               <p>Push all the tokens in the fake ‘TOKENS’ token. These already have
    1130. 

  1130. sane location data.</p>
    1131. 

  1131. 

  1132.             </div>
    1133. 

  1133.             
    1134. 

  1134.             <div class="content"><div class='highlight'><pre>          locationToken = value[<span class="hljs-number">0</span>]
    1135. 

  1135.           tokensToPush = value
    1136. 

  1136.         <span class="hljs-keyword">when</span> <span class="hljs-string">'NEOSTRING'</span></pre></div></div>
    1137. 

  1137.             
    1138. 

  1138.         </li>
    1139. 

  1139.         
    1140. 

  1140.         
    1141. 

  1141.         <li id="section-41">
    1142. 

  1142.             <div class="annotation">
    1143. 

  1143.               
    1144. 

  1144.               <div class="pilwrap ">
    1145. 

  1145.                 <a class="pilcrow" href="#section-41">&#182;</a>
    1146. 

  1146.               </div>
    1147. 

  1147.               <p>Convert ‘NEOSTRING’ into ‘STRING’.</p>
    1148. 

  1148. 

  1149.             </div>
    1150. 

  1150.             
    1151. 

  1151.             <div class="content"><div class='highlight'><pre>          converted = fn token[<span class="hljs-number">1</span>], i</pre></div></div>
    1152. 

  1152.             
    1153. 

  1153.         </li>
    1154. 

  1154.         
    1155. 

  1155.         
    1156. 

  1156.         <li id="section-42">
    1157. 

  1157.             <div class="annotation">
    1158. 

  1158.               
    1159. 

  1159.               <div class="pilwrap ">
    1160. 

  1160.                 <a class="pilcrow" href="#section-42">&#182;</a>
    1161. 

  1161.               </div>
    1162. 

  1162.               <p>Optimize out empty strings. We ensure that the tokens stream always
    1163. 

  1163. starts with a string token, though, to make sure that the result
    1164. 

  1164. really is a string.</p>
    1165. 

  1165. 

  1166.             </div>
    1167. 

  1167.             
    1168. 

  1168.             <div class="content"><div class='highlight'><pre>          <span class="hljs-keyword">if</span> converted.length <span class="hljs-keyword">is</span> <span class="hljs-number">0</span>
    1169. 

  1169.             <span class="hljs-keyword">if</span> i <span class="hljs-keyword">is</span> <span class="hljs-number">0</span>
    1170. 

  1170.               firstEmptyStringIndex = <span class="hljs-property">@tokens</span>.length
    1171. 

  1171.             <span class="hljs-keyword">else</span>
    1172. 

  1172.               <span class="hljs-keyword">continue</span></pre></div></div>
    1173. 

  1173.             
    1174. 

  1174.         </li>
    1175. 

  1175.         
    1176. 

  1176.         
    1177. 

  1177.         <li id="section-43">
    1178. 

  1178.             <div class="annotation">
    1179. 

  1179.               
    1180. 

  1180.               <div class="pilwrap ">
    1181. 

  1181.                 <a class="pilcrow" href="#section-43">&#182;</a>
    1182. 

  1182.               </div>
    1183. 

  1183.               <p>However, there is one case where we can optimize away a starting
    1184. 

  1184. empty string.</p>
    1185. 

  1185. 

  1186.             </div>
    1187. 

  1187.             
    1188. 

  1188.             <div class="content"><div class='highlight'><pre>          <span class="hljs-keyword">if</span> i <span class="hljs-keyword">is</span> <span class="hljs-number">2</span> <span class="hljs-keyword">and</span> firstEmptyStringIndex?
    1189. 

  1189.             <span class="hljs-property">@tokens</span>.splice firstEmptyStringIndex, <span class="hljs-number">2</span> <span class="hljs-comment"># Remove empty string and the plus.</span>
    1190. 

  1190.           token[<span class="hljs-number">0</span>] = <span class="hljs-string">'STRING'</span>
    1191. 

  1191.           token[<span class="hljs-number">1</span>] = <span class="hljs-property">@makeDelimitedLiteral</span> converted, options
    1192. 

  1192.           locationToken = token
    1193. 

  1193.           tokensToPush = [token]
    1194. 

  1194.       <span class="hljs-keyword">if</span> <span class="hljs-property">@tokens</span>.length &gt; firstIndex</pre></div></div>
    1195. 

  1195.             
    1196. 

  1196.         </li>
    1197. 

  1197.         
    1198. 

  1198.         
    1199. 

  1199.         <li id="section-44">
    1200. 

  1200.             <div class="annotation">
    1201. 

  1201.               
    1202. 

  1202.               <div class="pilwrap ">
    1203. 

  1203.                 <a class="pilcrow" href="#section-44">&#182;</a>
    1204. 

  1204.               </div>
    1205. 

  1205.               <p>Create a 0-length “+” token.</p>
    1206. 

  1206. 

  1207.             </div>
    1208. 

  1208.             
    1209. 

  1209.             <div class="content"><div class='highlight'><pre>        plusToken = <span class="hljs-property">@token</span> <span class="hljs-string">'+'</span>, <span class="hljs-string">'+'</span>
    1210. 

  1210.         plusToken[<span class="hljs-number">2</span>] =
    1211. 

  1211.           <span class="hljs-attribute">first_line</span>:   locationToken[<span class="hljs-number">2</span>].first_line
    1212. 

  1212.           <span class="hljs-attribute">first_column</span>: locationToken[<span class="hljs-number">2</span>].first_column
    1213. 

  1213.           <span class="hljs-attribute">last_line</span>:    locationToken[<span class="hljs-number">2</span>].first_line
    1214. 

  1214.           <span class="hljs-attribute">last_column</span>:  locationToken[<span class="hljs-number">2</span>].first_column
    1215. 

  1215.       <span class="hljs-property">@tokens</span>.push tokensToPush...
    1216. 

  1216. 

  1217.     <span class="hljs-keyword">if</span> lparen
    1218. 

  1218.       [..., lastToken] = tokens
    1219. 

  1219.       lparen.origin = [<span class="hljs-string">'STRING'</span>, <span class="hljs-literal">null</span>,
    1220. 

  1220.         <span class="hljs-attribute">first_line</span>:   lparen[<span class="hljs-number">2</span>].first_line
    1221. 

  1221.         <span class="hljs-attribute">first_column</span>: lparen[<span class="hljs-number">2</span>].first_column
    1222. 

  1222.         <span class="hljs-attribute">last_line</span>:    lastToken[<span class="hljs-number">2</span>].last_line
    1223. 

  1223.         <span class="hljs-attribute">last_column</span>:  lastToken[<span class="hljs-number">2</span>].last_column
    1224. 

  1224.       ]
    1225. 

  1225.       rparen = <span class="hljs-property">@token</span> <span class="hljs-string">'STRING_END'</span>, <span class="hljs-string">')'</span>
    1226. 

  1226.       rparen[<span class="hljs-number">2</span>] =
    1227. 

  1227.         <span class="hljs-attribute">first_line</span>:   lastToken[<span class="hljs-number">2</span>].last_line
    1228. 

  1228.         <span class="hljs-attribute">first_column</span>: lastToken[<span class="hljs-number">2</span>].last_column
    1229. 

  1229.         <span class="hljs-attribute">last_line</span>:    lastToken[<span class="hljs-number">2</span>].last_line
    1230. 

  1230.         <span class="hljs-attribute">last_column</span>:  lastToken[<span class="hljs-number">2</span>].last_column</pre></div></div>
    1231. 

  1231.             
    1232. 

  1232.         </li>
    1233. 

  1233.         
    1234. 

  1234.         
    1235. 

  1235.         <li id="section-45">
    1236. 

  1236.             <div class="annotation">
    1237. 

  1237.               
    1238. 

  1238.               <div class="pilwrap ">
    1239. 

  1239.                 <a class="pilcrow" href="#section-45">&#182;</a>
    1240. 

  1240.               </div>
    1241. 

  1241.               <p>Pairs up a closing token, ensuring that all listed pairs of tokens are
    1242. 

  1242. correctly balanced throughout the course of the token stream.</p>
    1243. 

  1243. 

  1244.             </div>
    1245. 

  1245.             
    1246. 

  1246.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">pair</span>: <span class="hljs-function"><span class="hljs-params">(tag)</span> -&gt;</span>
    1247. 

  1247.     [..., prev] = <span class="hljs-property">@ends</span>
    1248. 

  1248.     <span class="hljs-keyword">unless</span> tag <span class="hljs-keyword">is</span> wanted = prev?.tag
    1249. 

  1249.       <span class="hljs-property">@error</span> <span class="hljs-string">"unmatched <span class="hljs-subst">#{tag}</span>"</span> <span class="hljs-keyword">unless</span> <span class="hljs-string">'OUTDENT'</span> <span class="hljs-keyword">is</span> wanted</pre></div></div>
    1250. 

  1250.             
    1251. 

  1251.         </li>
    1252. 

  1252.         
    1253. 

  1253.         
    1254. 

  1254.         <li id="section-46">
    1255. 

  1255.             <div class="annotation">
    1256. 

  1256.               
    1257. 

  1257.               <div class="pilwrap ">
    1258. 

  1258.                 <a class="pilcrow" href="#section-46">&#182;</a>
    1259. 

  1259.               </div>
    1260. 

  1260.               <p>Auto-close INDENT to support syntax like this:</p>
    1261. 

  1261. <pre><code>el.click<span class="hljs-function"><span class="hljs-params">((event) -&gt;
    1262. 

  1262.   el.hide())</span></span>
    1263. 

  1263. </code></pre>
    1264. 

  1264.             </div>
    1265. 

  1265.             
    1266. 

  1266.             <div class="content"><div class='highlight'><pre>      [..., lastIndent] = <span class="hljs-property">@indents</span>
    1267. 

  1267.       <span class="hljs-property">@outdentToken</span> lastIndent, <span class="hljs-literal">true</span>
    1268. 

  1268.       <span class="hljs-keyword">return</span> <span class="hljs-property">@pair</span> tag
    1269. 

  1269.     <span class="hljs-property">@ends</span>.pop()</pre></div></div>
    1270. 

  1270.             
    1271. 

  1271.         </li>
    1272. 

  1272.         
    1273. 

  1273.         
    1274. 

  1274.         <li id="section-47">
    1275. 

  1275.             <div class="annotation">
    1276. 

  1276.               
    1277. 

  1277.               <div class="pilwrap ">
    1278. 

  1278.                 <a class="pilcrow" href="#section-47">&#182;</a>
    1279. 

  1279.               </div>
    1280. 

  1280.               <h2 id="helpers">Helpers</h2>
    1281. 

  1281. 

  1282.             </div>
    1283. 

  1283.             
    1284. 

  1284.         </li>
    1285. 

  1285.         
    1286. 

  1286.         
    1287. 

  1287.         <li id="section-48">
    1288. 

  1288.             <div class="annotation">
    1289. 

  1289.               
    1290. 

  1290.               <div class="pilwrap ">
    1291. 

  1291.                 <a class="pilcrow" href="#section-48">&#182;</a>
    1292. 

  1292.               </div>
    1293. 

  1293.               
    1294. 

  1294.             </div>
    1295. 

  1295.             
    1296. 

  1296.         </li>
    1297. 

  1297.         
    1298. 

  1298.         
    1299. 

  1299.         <li id="section-49">
    1300. 

  1300.             <div class="annotation">
    1301. 

  1301.               
    1302. 

  1302.               <div class="pilwrap ">
    1303. 

  1303.                 <a class="pilcrow" href="#section-49">&#182;</a>
    1304. 

  1304.               </div>
    1305. 

  1305.               <p>Returns the line and column number from an offset into the current chunk.</p>
    1306. 

  1306. <p><code>offset</code> is a number of characters into @chunk.</p>
    1307. 

  1307. 

  1308.             </div>
    1309. 

  1309.             
    1310. 

  1310.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">getLineAndColumnFromChunk</span>: <span class="hljs-function"><span class="hljs-params">(offset)</span> -&gt;</span>
    1311. 

  1311.     <span class="hljs-keyword">if</span> offset <span class="hljs-keyword">is</span> <span class="hljs-number">0</span>
    1312. 

  1312.       <span class="hljs-keyword">return</span> [<span class="hljs-property">@chunkLine</span>, <span class="hljs-property">@chunkColumn</span>]
    1313. 

  1313. 

  1314.     <span class="hljs-keyword">if</span> offset &gt;= <span class="hljs-property">@chunk</span>.length
    1315. 

  1315.       string = <span class="hljs-property">@chunk</span>
    1316. 

  1316.     <span class="hljs-keyword">else</span>
    1317. 

  1317.       string = <span class="hljs-property">@chunk</span>[..offset-<span class="hljs-number">1</span>]
    1318. 

  1318. 

  1319.     lineCount = count string, <span class="hljs-string">'\n'</span>
    1320. 

  1320. 

  1321.     column = <span class="hljs-property">@chunkColumn</span>
    1322. 

  1322.     <span class="hljs-keyword">if</span> lineCount &gt; <span class="hljs-number">0</span>
    1323. 

  1323.       [..., lastLine] = string.split <span class="hljs-string">'\n'</span>
    1324. 

  1324.       column = lastLine.length
    1325. 

  1325.     <span class="hljs-keyword">else</span>
    1326. 

  1326.       column += string.length
    1327. 

  1327. 

  1328.     [<span class="hljs-property">@chunkLine</span> + lineCount, column]</pre></div></div>
    1329. 

  1329.             
    1330. 

  1330.         </li>
    1331. 

  1331.         
    1332. 

  1332.         
    1333. 

  1333.         <li id="section-50">
    1334. 

  1334.             <div class="annotation">
    1335. 

  1335.               
    1336. 

  1336.               <div class="pilwrap ">
    1337. 

  1337.                 <a class="pilcrow" href="#section-50">&#182;</a>
    1338. 

  1338.               </div>
    1339. 

  1339.               <p>Same as “token”, exception this just returns the token without adding it
    1340. 

  1340. to the results.</p>
    1341. 

  1341. 

  1342.             </div>
    1343. 

  1343.             
    1344. 

  1344.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">makeToken</span>: <span class="hljs-function"><span class="hljs-params">(tag, value, offsetInChunk = <span class="hljs-number">0</span>, length = value.length)</span> -&gt;</span>
    1345. 

  1345.     locationData = {}
    1346. 

  1346.     [locationData.first_line, locationData.first_column] =
    1347. 

  1347.       <span class="hljs-property">@getLineAndColumnFromChunk</span> offsetInChunk</pre></div></div>
    1348. 

  1348.             
    1349. 

  1349.         </li>
    1350. 

  1350.         
    1351. 

  1351.         
    1352. 

  1352.         <li id="section-51">
    1353. 

  1353.             <div class="annotation">
    1354. 

  1354.               
    1355. 

  1355.               <div class="pilwrap ">
    1356. 

  1356.                 <a class="pilcrow" href="#section-51">&#182;</a>
    1357. 

  1357.               </div>
    1358. 

  1358.               <p>Use length - 1 for the final offset - we’re supplying the last_line and the last_column,
    1359. 

  1359. so if last_column == first_column, then we’re looking at a character of length 1.</p>
    1360. 

  1360. 

  1361.             </div>
    1362. 

  1362.             
    1363. 

  1363.             <div class="content"><div class='highlight'><pre>    lastCharacter = Math.max <span class="hljs-number">0</span>, length - <span class="hljs-number">1</span>
    1364. 

  1364.     [locationData.last_line, locationData.last_column] =
    1365. 

  1365.       <span class="hljs-property">@getLineAndColumnFromChunk</span> offsetInChunk + lastCharacter
    1366. 

  1366. 

  1367.     token = [tag, value, locationData]
    1368. 

  1368. 

  1369.     token</pre></div></div>
    1370. 

  1370.             
    1371. 

  1371.         </li>
    1372. 

  1372.         
    1373. 

  1373.         
    1374. 

  1374.         <li id="section-52">
    1375. 

  1375.             <div class="annotation">
    1376. 

  1376.               
    1377. 

  1377.               <div class="pilwrap ">
    1378. 

  1378.                 <a class="pilcrow" href="#section-52">&#182;</a>
    1379. 

  1379.               </div>
    1380. 

  1380.               <p>Add a token to the results.
    1381. 

  1381. <code>offset</code> is the offset into the current @chunk where the token starts.
    1382. 

  1382. <code>length</code> is the length of the token in the @chunk, after the offset.  If
    1383. 

  1383. not specified, the length of <code>value</code> will be used.</p>
    1384. 

  1384. <p>Returns the new token.</p>
    1385. 

  1385. 

  1386.             </div>
    1387. 

  1387.             
    1388. 

  1388.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">token</span>: <span class="hljs-function"><span class="hljs-params">(tag, value, offsetInChunk, length, origin)</span> -&gt;</span>
    1389. 

  1389.     token = <span class="hljs-property">@makeToken</span> tag, value, offsetInChunk, length
    1390. 

  1390.     token.origin = origin <span class="hljs-keyword">if</span> origin
    1391. 

  1391.     <span class="hljs-property">@tokens</span>.push token
    1392. 

  1392.     token</pre></div></div>
    1393. 

  1393.             
    1394. 

  1394.         </li>
    1395. 

  1395.         
    1396. 

  1396.         
    1397. 

  1397.         <li id="section-53">
    1398. 

  1398.             <div class="annotation">
    1399. 

  1399.               
    1400. 

  1400.               <div class="pilwrap ">
    1401. 

  1401.                 <a class="pilcrow" href="#section-53">&#182;</a>
    1402. 

  1402.               </div>
    1403. 

  1403.               <p>Peek at the last tag in the token stream.</p>
    1404. 

  1404. 

  1405.             </div>
    1406. 

  1406.             
    1407. 

  1407.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">tag</span>:<span class="hljs-function"> -&gt;</span>
    1408. 

  1408.     [..., token] = <span class="hljs-property">@tokens</span>
    1409. 

  1409.     token?[<span class="hljs-number">0</span>]</pre></div></div>
    1410. 

  1410.             
    1411. 

  1411.         </li>
    1412. 

  1412.         
    1413. 

  1413.         
    1414. 

  1414.         <li id="section-54">
    1415. 

  1415.             <div class="annotation">
    1416. 

  1416.               
    1417. 

  1417.               <div class="pilwrap ">
    1418. 

  1418.                 <a class="pilcrow" href="#section-54">&#182;</a>
    1419. 

  1419.               </div>
    1420. 

  1420.               <p>Peek at the last value in the token stream.</p>
    1421. 

  1421. 

  1422.             </div>
    1423. 

  1423.             
    1424. 

  1424.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">value</span>:<span class="hljs-function"> -&gt;</span>
    1425. 

  1425.     [..., token] = <span class="hljs-property">@tokens</span>
    1426. 

  1426.     token?[<span class="hljs-number">1</span>]</pre></div></div>
    1427. 

  1427.             
    1428. 

  1428.         </li>
    1429. 

  1429.         
    1430. 

  1430.         
    1431. 

  1431.         <li id="section-55">
    1432. 

  1432.             <div class="annotation">
    1433. 

  1433.               
    1434. 

  1434.               <div class="pilwrap ">
    1435. 

  1435.                 <a class="pilcrow" href="#section-55">&#182;</a>
    1436. 

  1436.               </div>
    1437. 

  1437.               <p>Are we in the midst of an unfinished expression?</p>
    1438. 

  1438. 

  1439.             </div>
    1440. 

  1440.             
    1441. 

  1441.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">unfinished</span>:<span class="hljs-function"> -&gt;</span>
    1442. 

  1442.     LINE_CONTINUER.test(<span class="hljs-property">@chunk</span>) <span class="hljs-keyword">or</span>
    1443. 

  1443.     <span class="hljs-property">@tag</span>() <span class="hljs-keyword">in</span> [<span class="hljs-string">'\\'</span>, <span class="hljs-string">'.'</span>, <span class="hljs-string">'?.'</span>, <span class="hljs-string">'?::'</span>, <span class="hljs-string">'UNARY'</span>, <span class="hljs-string">'MATH'</span>, <span class="hljs-string">'UNARY_MATH'</span>, <span class="hljs-string">'+'</span>, <span class="hljs-string">'-'</span>, <span class="hljs-string">'YIELD'</span>,
    1444. 

  1444.                <span class="hljs-string">'**'</span>, <span class="hljs-string">'SHIFT'</span>, <span class="hljs-string">'RELATION'</span>, <span class="hljs-string">'COMPARE'</span>, <span class="hljs-string">'LOGIC'</span>, <span class="hljs-string">'THROW'</span>, <span class="hljs-string">'EXTENDS'</span>]
    1445. 

  1445. 

  1446.   <span class="hljs-attribute">formatString</span>: <span class="hljs-function"><span class="hljs-params">(str)</span> -&gt;</span>
    1447. 

  1447.     str.replace STRING_OMIT, <span class="hljs-string">'$1'</span>
    1448. 

  1448. 

  1449.   <span class="hljs-attribute">formatHeregex</span>: <span class="hljs-function"><span class="hljs-params">(str)</span> -&gt;</span>
    1450. 

  1450.     str.replace HEREGEX_OMIT, <span class="hljs-string">'$1$2'</span></pre></div></div>
    1451. 

  1451.             
    1452. 

  1452.         </li>
    1453. 

  1453.         
    1454. 

  1454.         
    1455. 

  1455.         <li id="section-56">
    1456. 

  1456.             <div class="annotation">
    1457. 

  1457.               
    1458. 

  1458.               <div class="pilwrap ">
    1459. 

  1459.                 <a class="pilcrow" href="#section-56">&#182;</a>
    1460. 

  1460.               </div>
    1461. 

  1461.               <p>Validates escapes in strings and regexes.</p>
    1462. 

  1462. 

  1463.             </div>
    1464. 

  1464.             
    1465. 

  1465.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">validateEscapes</span>: <span class="hljs-function"><span class="hljs-params">(str, options = {})</span> -&gt;</span>
    1466. 

  1466.     match = INVALID_ESCAPE.exec str
    1467. 

  1467.     <span class="hljs-keyword">return</span> <span class="hljs-keyword">unless</span> match
    1468. 

  1468.     [[], before, octal, hex, unicode] = match
    1469. 

  1469.     <span class="hljs-keyword">return</span> <span class="hljs-keyword">if</span> options.isRegex <span class="hljs-keyword">and</span> octal <span class="hljs-keyword">and</span> octal.charAt(<span class="hljs-number">0</span>) <span class="hljs-keyword">isnt</span> <span class="hljs-string">'0'</span>
    1470. 

  1470.     message =
    1471. 

  1471.       <span class="hljs-keyword">if</span> octal
    1472. 

  1472.         <span class="hljs-string">"octal escape sequences are not allowed"</span>
    1473. 

  1473.       <span class="hljs-keyword">else</span>
    1474. 

  1474.         <span class="hljs-string">"invalid escape sequence"</span>
    1475. 

  1475.     invalidEscape = <span class="hljs-string">"\\<span class="hljs-subst">#{octal <span class="hljs-keyword">or</span> hex <span class="hljs-keyword">or</span> unicode}</span>"</span>
    1476. 

  1476.     <span class="hljs-property">@error</span> <span class="hljs-string">"<span class="hljs-subst">#{message}</span> <span class="hljs-subst">#{invalidEscape}</span>"</span>,
    1477. 

  1477.       <span class="hljs-attribute">offset</span>: (options.offsetInChunk ? <span class="hljs-number">0</span>) + match.index + before.length
    1478. 

  1478.       <span class="hljs-attribute">length</span>: invalidEscape.length</pre></div></div>
    1479. 

  1479.             
    1480. 

  1480.         </li>
    1481. 

  1481.         
    1482. 

  1482.         
    1483. 

  1483.         <li id="section-57">
    1484. 

  1484.             <div class="annotation">
    1485. 

  1485.               
    1486. 

  1486.               <div class="pilwrap ">
    1487. 

  1487.                 <a class="pilcrow" href="#section-57">&#182;</a>
    1488. 

  1488.               </div>
    1489. 

  1489.               <p>Constructs a string or regex by escaping certain characters.</p>
    1490. 

  1490. 

  1491.             </div>
    1492. 

  1492.             
    1493. 

  1493.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">makeDelimitedLiteral</span>: <span class="hljs-function"><span class="hljs-params">(body, options = {})</span> -&gt;</span>
    1494. 

  1494.     body = <span class="hljs-string">'(?:)'</span> <span class="hljs-keyword">if</span> body <span class="hljs-keyword">is</span> <span class="hljs-string">''</span> <span class="hljs-keyword">and</span> options.delimiter <span class="hljs-keyword">is</span> <span class="hljs-string">'/'</span>
    1495. 

  1495.     regex = <span class="hljs-regexp">///
    1496. 

  1496.         (\\\\)                               <span class="hljs-comment"># escaped backslash</span>
    1497. 

  1497.       | (\\0(?=[1-7]))                       <span class="hljs-comment"># nul character mistaken as octal escape</span>
    1498. 

  1498.       | \\?(<span class="hljs-subst">#{options.delimiter}</span>)            <span class="hljs-comment"># (possibly escaped) delimiter</span>
    1499. 

  1499.       | \\?(?: (\n)|(\r)|(\u2028)|(\u2029) ) <span class="hljs-comment"># (possibly escaped) newlines</span>
    1500. 

  1500.       | (\\.)                                <span class="hljs-comment"># other escapes</span>
    1501. 

  1501.     ///</span>g
    1502. 

  1502.     body = body.replace regex, <span class="hljs-function"><span class="hljs-params">(match, backslash, nul, delimiter, lf, cr, ls, ps, other)</span> -&gt;</span> <span class="hljs-keyword">switch</span></pre></div></div>
    1503. 

  1503.             
    1504. 

  1504.         </li>
    1505. 

  1505.         
    1506. 

  1506.         
    1507. 

  1507.         <li id="section-58">
    1508. 

  1508.             <div class="annotation">
    1509. 

  1509.               
    1510. 

  1510.               <div class="pilwrap ">
    1511. 

  1511.                 <a class="pilcrow" href="#section-58">&#182;</a>
    1512. 

  1512.               </div>
    1513. 

  1513.               <p>Ignore escaped backslashes.</p>
    1514. 

  1514. 

  1515.             </div>
    1516. 

  1516.             
    1517. 

  1517.             <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">when</span> backslash <span class="hljs-keyword">then</span> (<span class="hljs-keyword">if</span> options.double <span class="hljs-keyword">then</span> backslash + backslash <span class="hljs-keyword">else</span> backslash)
    1518. 

  1518.       <span class="hljs-keyword">when</span> nul       <span class="hljs-keyword">then</span> <span class="hljs-string">'\\x00'</span>
    1519. 

  1519.       <span class="hljs-keyword">when</span> delimiter <span class="hljs-keyword">then</span> <span class="hljs-string">"\\<span class="hljs-subst">#{delimiter}</span>"</span>
    1520. 

  1520.       <span class="hljs-keyword">when</span> lf        <span class="hljs-keyword">then</span> <span class="hljs-string">'\\n'</span>
    1521. 

  1521.       <span class="hljs-keyword">when</span> cr        <span class="hljs-keyword">then</span> <span class="hljs-string">'\\r'</span>
    1522. 

  1522.       <span class="hljs-keyword">when</span> ls        <span class="hljs-keyword">then</span> <span class="hljs-string">'\\u2028'</span>
    1523. 

  1523.       <span class="hljs-keyword">when</span> ps        <span class="hljs-keyword">then</span> <span class="hljs-string">'\\u2029'</span>
    1524. 

  1524.       <span class="hljs-keyword">when</span> other     <span class="hljs-keyword">then</span> (<span class="hljs-keyword">if</span> options.double <span class="hljs-keyword">then</span> <span class="hljs-string">"\\<span class="hljs-subst">#{other}</span>"</span> <span class="hljs-keyword">else</span> other)
    1525. 

  1525.     <span class="hljs-string">"<span class="hljs-subst">#{options.delimiter}</span><span class="hljs-subst">#{body}</span><span class="hljs-subst">#{options.delimiter}</span>"</span></pre></div></div>
    1526. 

  1526.             
    1527. 

  1527.         </li>
    1528. 

  1528.         
    1529. 

  1529.         
    1530. 

  1530.         <li id="section-59">
    1531. 

  1531.             <div class="annotation">
    1532. 

  1532.               
    1533. 

  1533.               <div class="pilwrap ">
    1534. 

  1534.                 <a class="pilcrow" href="#section-59">&#182;</a>
    1535. 

  1535.               </div>
    1536. 

  1536.               <p>Throws an error at either a given offset from the current chunk or at the
    1537. 

  1537. location of a token (<code>token[2]</code>).</p>
    1538. 

  1538. 

  1539.             </div>
    1540. 

  1540.             
    1541. 

  1541.             <div class="content"><div class='highlight'><pre>  <span class="hljs-attribute">error</span>: <span class="hljs-function"><span class="hljs-params">(message, options = {})</span> -&gt;</span>
    1542. 

  1542.     location =
    1543. 

  1543.       <span class="hljs-keyword">if</span> <span class="hljs-string">'first_line'</span> <span class="hljs-keyword">of</span> options
    1544. 

  1544.         options
    1545. 

  1545.       <span class="hljs-keyword">else</span>
    1546. 

  1546.         [first_line, first_column] = <span class="hljs-property">@getLineAndColumnFromChunk</span> options.offset ? <span class="hljs-number">0</span>
    1547. 

  1547.         {first_line, first_column, <span class="hljs-attribute">last_column</span>: first_column + (options.length ? <span class="hljs-number">1</span>) - <span class="hljs-number">1</span>}
    1548. 

  1548.     throwSyntaxError message, location</pre></div></div>
    1549. 

  1549.             
    1550. 

  1550.         </li>
    1551. 

  1551.         
    1552. 

  1552.         
    1553. 

  1553.         <li id="section-60">
    1554. 

  1554.             <div class="annotation">
    1555. 

  1555.               
    1556. 

  1556.               <div class="pilwrap ">
    1557. 

  1557.                 <a class="pilcrow" href="#section-60">&#182;</a>
    1558. 

  1558.               </div>
    1559. 

  1559.               <h2 id="constants">Constants</h2>
    1560. 

  1560. 

  1561.             </div>
    1562. 

  1562.             
    1563. 

  1563.         </li>
    1564. 

  1564.         
    1565. 

  1565.         
    1566. 

  1566.         <li id="section-61">
    1567. 

  1567.             <div class="annotation">
    1568. 

  1568.               
    1569. 

  1569.               <div class="pilwrap ">
    1570. 

  1570.                 <a class="pilcrow" href="#section-61">&#182;</a>
    1571. 

  1571.               </div>
    1572. 

  1572.               
    1573. 

  1573.             </div>
    1574. 

  1574.             
    1575. 

  1575.         </li>
    1576. 

  1576.         
    1577. 

  1577.         
    1578. 

  1578.         <li id="section-62">
    1579. 

  1579.             <div class="annotation">
    1580. 

  1580.               
    1581. 

  1581.               <div class="pilwrap ">
    1582. 

  1582.                 <a class="pilcrow" href="#section-62">&#182;</a>
    1583. 

  1583.               </div>
    1584. 

  1584.               <p>Keywords that CoffeeScript shares in common with JavaScript.</p>
    1585. 

  1585. 

  1586.             </div>
    1587. 

  1587.             
    1588. 

  1588.             <div class="content"><div class='highlight'><pre>JS_KEYWORDS = [
    1589. 

  1589.   <span class="hljs-string">'true'</span>, <span class="hljs-string">'false'</span>, <span class="hljs-string">'null'</span>, <span class="hljs-string">'this'</span>
    1590. 

  1590.   <span class="hljs-string">'new'</span>, <span class="hljs-string">'delete'</span>, <span class="hljs-string">'typeof'</span>, <span class="hljs-string">'in'</span>, <span class="hljs-string">'instanceof'</span>
    1591. 

  1591.   <span class="hljs-string">'return'</span>, <span class="hljs-string">'throw'</span>, <span class="hljs-string">'break'</span>, <span class="hljs-string">'continue'</span>, <span class="hljs-string">'debugger'</span>, <span class="hljs-string">'yield'</span>
    1592. 

  1592.   <span class="hljs-string">'if'</span>, <span class="hljs-string">'else'</span>, <span class="hljs-string">'switch'</span>, <span class="hljs-string">'for'</span>, <span class="hljs-string">'while'</span>, <span class="hljs-string">'do'</span>, <span class="hljs-string">'try'</span>, <span class="hljs-string">'catch'</span>, <span class="hljs-string">'finally'</span>
    1593. 

  1593.   <span class="hljs-string">'class'</span>, <span class="hljs-string">'extends'</span>, <span class="hljs-string">'super'</span>
    1594. 

  1594. ]</pre></div></div>
    1595. 

  1595.             
    1596. 

  1596.         </li>
    1597. 

  1597.         
    1598. 

  1598.         
    1599. 

  1599.         <li id="section-63">
    1600. 

  1600.             <div class="annotation">
    1601. 

  1601.               
    1602. 

  1602.               <div class="pilwrap ">
    1603. 

  1603.                 <a class="pilcrow" href="#section-63">&#182;</a>
    1604. 

  1604.               </div>
    1605. 

  1605.               <p>CoffeeScript-only keywords.</p>
    1606. 

  1606. 

  1607.             </div>
    1608. 

  1608.             
    1609. 

  1609.             <div class="content"><div class='highlight'><pre>COFFEE_KEYWORDS = [<span class="hljs-string">'undefined'</span>, <span class="hljs-string">'then'</span>, <span class="hljs-string">'unless'</span>, <span class="hljs-string">'until'</span>, <span class="hljs-string">'loop'</span>, <span class="hljs-string">'of'</span>, <span class="hljs-string">'by'</span>, <span class="hljs-string">'when'</span>]
    1610. 

  1610. 

  1611. COFFEE_ALIAS_MAP =
    1612. 

  1612.   <span class="hljs-keyword">and</span>  : <span class="hljs-string">'&amp;&amp;'</span>
    1613. 

  1613.   <span class="hljs-keyword">or</span>   : <span class="hljs-string">'||'</span>
    1614. 

  1614.   <span class="hljs-keyword">is</span>   : <span class="hljs-string">'=='</span>
    1615. 

  1615.   <span class="hljs-keyword">isnt</span> : <span class="hljs-string">'!='</span>
    1616. 

  1616.   <span class="hljs-keyword">not</span>  : <span class="hljs-string">'!'</span>
    1617. 

  1617.   <span class="hljs-literal">yes</span>  : <span class="hljs-string">'true'</span>
    1618. 

  1618.   <span class="hljs-literal">no</span>   : <span class="hljs-string">'false'</span>
    1619. 

  1619.   <span class="hljs-literal">on</span>   : <span class="hljs-string">'true'</span>
    1620. 

  1620.   <span class="hljs-literal">off</span>  : <span class="hljs-string">'false'</span>
    1621. 

  1621. 

  1622. COFFEE_ALIASES  = (key <span class="hljs-keyword">for</span> key <span class="hljs-keyword">of</span> COFFEE_ALIAS_MAP)
    1623. 

  1623. COFFEE_KEYWORDS = COFFEE_KEYWORDS.concat COFFEE_ALIASES</pre></div></div>
    1624. 

  1624.             
    1625. 

  1625.         </li>
    1626. 

  1626.         
    1627. 

  1627.         
    1628. 

  1628.         <li id="section-64">
    1629. 

  1629.             <div class="annotation">
    1630. 

  1630.               
    1631. 

  1631.               <div class="pilwrap ">
    1632. 

  1632.                 <a class="pilcrow" href="#section-64">&#182;</a>
    1633. 

  1633.               </div>
    1634. 

  1634.               <p>The list of keywords that are reserved by JavaScript, but not used, or are
    1635. 

  1635. used by CoffeeScript internally. We throw an error when these are encountered,
    1636. 

  1636. to avoid having a JavaScript error at runtime.</p>
    1637. 

  1637. 

  1638.             </div>
    1639. 

  1639.             
    1640. 

  1640.             <div class="content"><div class='highlight'><pre>RESERVED = [
    1641. 

  1641.   <span class="hljs-string">'case'</span>, <span class="hljs-string">'default'</span>, <span class="hljs-string">'function'</span>, <span class="hljs-string">'var'</span>, <span class="hljs-string">'void'</span>, <span class="hljs-string">'with'</span>, <span class="hljs-string">'const'</span>, <span class="hljs-string">'let'</span>, <span class="hljs-string">'enum'</span>
    1642. 

  1642.   <span class="hljs-string">'export'</span>, <span class="hljs-string">'import'</span>, <span class="hljs-string">'native'</span>, <span class="hljs-string">'implements'</span>, <span class="hljs-string">'interface'</span>, <span class="hljs-string">'package'</span>, <span class="hljs-string">'private'</span>
    1643. 

  1643.   <span class="hljs-string">'protected'</span>, <span class="hljs-string">'public'</span>, <span class="hljs-string">'static'</span>
    1644. 

  1644. ]
    1645. 

  1645. 

  1646. STRICT_PROSCRIBED = [<span class="hljs-string">'arguments'</span>, <span class="hljs-string">'eval'</span>, <span class="hljs-string">'yield*'</span>]</pre></div></div>
    1647. 

  1647.             
    1648. 

  1648.         </li>
    1649. 

  1649.         
    1650. 

  1650.         
    1651. 

  1651.         <li id="section-65">
    1652. 

  1652.             <div class="annotation">
    1653. 

  1653.               
    1654. 

  1654.               <div class="pilwrap ">
    1655. 

  1655.                 <a class="pilcrow" href="#section-65">&#182;</a>
    1656. 

  1656.               </div>
    1657. 

  1657.               <p>The superset of both JavaScript keywords and reserved words, none of which may
    1658. 

  1658. be used as identifiers or properties.</p>
    1659. 

  1659. 

  1660.             </div>
    1661. 

  1661.             
    1662. 

  1662.             <div class="content"><div class='highlight'><pre>JS_FORBIDDEN = JS_KEYWORDS.concat(RESERVED).concat(STRICT_PROSCRIBED)
    1663. 

  1663. 

  1664. <span class="hljs-built_in">exports</span>.RESERVED = RESERVED.concat(JS_KEYWORDS).concat(COFFEE_KEYWORDS).concat(STRICT_PROSCRIBED)
    1665. 

  1665. <span class="hljs-built_in">exports</span>.STRICT_PROSCRIBED = STRICT_PROSCRIBED</pre></div></div>
    1666. 

  1666.             
    1667. 

  1667.         </li>
    1668. 

  1668.         
    1669. 

  1669.         
    1670. 

  1670.         <li id="section-66">
    1671. 

  1671.             <div class="annotation">
    1672. 

  1672.               
    1673. 

  1673.               <div class="pilwrap ">
    1674. 

  1674.                 <a class="pilcrow" href="#section-66">&#182;</a>
    1675. 

  1675.               </div>
    1676. 

  1676.               <p>The character code of the nasty Microsoft madness otherwise known as the BOM.</p>
    1677. 

  1677. 

  1678.             </div>
    1679. 

  1679.             
    1680. 

  1680.             <div class="content"><div class='highlight'><pre>BOM = <span class="hljs-number">65279</span></pre></div></div>
    1681. 

  1681.             
    1682. 

  1682.         </li>
    1683. 

  1683.         
    1684. 

  1684.         
    1685. 

  1685.         <li id="section-67">
    1686. 

  1686.             <div class="annotation">
    1687. 

  1687.               
    1688. 

  1688.               <div class="pilwrap ">
    1689. 

  1689.                 <a class="pilcrow" href="#section-67">&#182;</a>
    1690. 

  1690.               </div>
    1691. 

  1691.               <p>Token matching regexes.</p>
    1692. 

  1692. 

  1693.             </div>
    1694. 

  1694.             
    1695. 

  1695.             <div class="content"><div class='highlight'><pre>IDENTIFIER = <span class="hljs-regexp">/// ^
    1696. 

  1696.   (?!\d)
    1697. 

  1697.   ( (?: (?!\s)[$\w\x7f-\uffff] )+ )
    1698. 

  1698.   ( [^\n\S]* : (?!:) )?  <span class="hljs-comment"># Is this a property name?</span>
    1699. 

  1699. ///</span>
    1700. 

  1700. 

  1701. NUMBER     = <span class="hljs-regexp">///
    1702. 

  1702.   ^ 0b[01]+    |              <span class="hljs-comment"># binary</span>
    1703. 

  1703.   ^ 0o[0-7]+   |              <span class="hljs-comment"># octal</span>
    1704. 

  1704.   ^ 0x[\da-f]+ |              <span class="hljs-comment"># hex</span>
    1705. 

  1705.   ^ \d*\.?\d+ (?:e[+-]?\d+)?  <span class="hljs-comment"># decimal</span>
    1706. 

  1706. ///</span>i
    1707. 

  1707. 

  1708. OPERATOR   = <span class="hljs-regexp">/// ^ (
    1709. 

  1709.   ?: [-=]&gt;             <span class="hljs-comment"># function</span>
    1710. 

  1710.    | [-+*/%&lt;&gt;&amp;|^!?=]=  <span class="hljs-comment"># compound assign / compare</span>
    1711. 

  1711.    | &gt;&gt;&gt;=?             <span class="hljs-comment"># zero-fill right shift</span>
    1712. 

  1712.    | ([-+:])\1         <span class="hljs-comment"># doubles</span>
    1713. 

  1713.    | ([&amp;|&lt;&gt;*/%])\2=?   <span class="hljs-comment"># logic / shift / power / floor division / modulo</span>
    1714. 

  1714.    | \?(\.|::)         <span class="hljs-comment"># soak access</span>
    1715. 

  1715.    | \.{2,3}           <span class="hljs-comment"># range or splat</span>
    1716. 

  1716. ) ///</span>
    1717. 

  1717. 

  1718. WHITESPACE = <span class="hljs-regexp">/^[^\n\S]+/</span>
    1719. 

  1719. 

  1720. COMMENT    = <span class="hljs-regexp">/^###([^#][\s\S]*?)(?:###[^\n\S]*|###$)|^(?:\s*#(?!##[^#]).*)+/</span>
    1721. 

  1721. 

  1722. CODE       = <span class="hljs-regexp">/^[-=]&gt;/</span>
    1723. 

  1723. 

  1724. MULTI_DENT = <span class="hljs-regexp">/^(?:\n[^\n\S]*)+/</span>
    1725. 

  1725. 

  1726. JSTOKEN    = <span class="hljs-regexp">/^`[^\\`]*(?:\\.[^\\`]*)*`/</span></pre></div></div>
    1727. 

  1727.             
    1728. 

  1728.         </li>
    1729. 

  1729.         
    1730. 

  1730.         
    1731. 

  1731.         <li id="section-68">
    1732. 

  1732.             <div class="annotation">
    1733. 

  1733.               
    1734. 

  1734.               <div class="pilwrap ">
    1735. 

  1735.                 <a class="pilcrow" href="#section-68">&#182;</a>
    1736. 

  1736.               </div>
    1737. 

  1737.               <p>String-matching-regexes.</p>
    1738. 

  1738. 

  1739.             </div>
    1740. 

  1740.             
    1741. 

  1741.             <div class="content"><div class='highlight'><pre>STRING_START   = <span class="hljs-regexp">/^(?:'''|"""|'|")/</span>
    1742. 

    1743. 

  1743. STRING_SINGLE  = <span class="hljs-regexp">/// ^(?: [^\\']  | \\[\s\S]                      )* ///</span>
    1744. 

  1744. STRING_DOUBLE  = <span class="hljs-regexp">/// ^(?: [^\\"<span class="hljs-comment">#] | \\[\s\S] |           \#(?!\{) )* ///</span>
    1745. 

  1745. HEREDOC_SINGLE = ///</span> ^(?: [^\\<span class="hljs-string">']  | \\[\s\S] | '</span>(?!<span class="hljs-string">''</span>)            )* <span class="hljs-regexp">///
    1746. 

  1746. HEREDOC_DOUBLE = ///</span> ^(?: [^\\<span class="hljs-string">"#] | \\[\s\S] | "</span>(?!<span class="hljs-string">""</span>) | \<span class="hljs-comment">#(?!\{) )* ///</span>
    1747. 

  1747. 

  1748. STRING_OMIT    = <span class="hljs-regexp">///
    1749. 

  1749.     ((?:\\\\)+)      <span class="hljs-comment"># consume (and preserve) an even number of backslashes</span>
    1750. 

  1750.   | \\[^\S\n]*\n\s*  <span class="hljs-comment"># remove escaped newlines</span>
    1751. 

  1751. ///</span>g
    1752. 

  1752. SIMPLE_STRING_OMIT = <span class="hljs-regexp">/\s*\n\s*/g</span>
    1753. 

  1753. HEREDOC_INDENT     = <span class="hljs-regexp">/\n+([^\n\S]*)(?=\S)/g</span></pre></div></div>
    1754. 

  1754.             
    1755. 

  1755.         </li>
    1756. 

  1756.         
    1757. 

  1757.         
    1758. 

  1758.         <li id="section-69">
    1759. 

  1759.             <div class="annotation">
    1760. 

  1760.               
    1761. 

  1761.               <div class="pilwrap ">
    1762. 

  1762.                 <a class="pilcrow" href="#section-69">&#182;</a>
    1763. 

  1763.               </div>
    1764. 

  1764.               <p>Regex-matching-regexes.</p>
    1765. 

  1765. 

  1766.             </div>
    1767. 

  1767.             
    1768. 

  1768.             <div class="content"><div class='highlight'><pre>REGEX = <span class="hljs-regexp">/// ^
    1769. 

  1769.   / (?!/) ((
    1770. 

  1770.   ?: [^ [ / \n \\ ]  <span class="hljs-comment"># every other thing</span>
    1771. 

  1771.    | \\[^\n]         <span class="hljs-comment"># anything but newlines escaped</span>
    1772. 

  1772.    | \[              <span class="hljs-comment"># character class</span>
    1773. 

  1773.        (?: \\[^\n] | [^ \] \n \\ ] )*
    1774. 

  1774.      \]
    1775. 

  1775.   )*) (/)?
    1776. 

  1776. ///</span>
    1777. 

  1777. 

  1778. REGEX_FLAGS  = <span class="hljs-regexp">/^\w*/</span>
    1779. 

  1779. VALID_FLAGS  = <span class="hljs-regexp">/^(?!.*(.).*\1)[imgy]*$/</span>
    1780. 

  1780. 

  1781. HEREGEX      = <span class="hljs-regexp">/// ^(?: [^\\/<span class="hljs-comment">#] | \\[\s\S] | /(?!//) | \#(?!\{) )* ///</span>
    1782. 

  1782. 

  1783. HEREGEX_OMIT = ///</span>
    1784. 

  1784.     ((?:\\\\)+)     <span class="hljs-comment"># consume (and preserve) an even number of backslashes</span>
    1785. 

  1785.   | \\(\s)          <span class="hljs-comment"># preserve escaped whitespace</span>
    1786. 

  1786.   | \s+(?:<span class="hljs-comment">#.*)?     # remove whitespace and comments</span>
    1787. 

  1787. <span class="hljs-regexp">///g
    1788. 

  1788. 

  1789. REGEX_ILLEGAL = ///</span> ^ ( / | <span class="hljs-regexp">/{3}\s*) (\*) /</span><span class="hljs-regexp">//</span>
    1790. 

  1790. 

  1791. POSSIBLY_DIVISION   = <span class="hljs-regexp">/// ^ /=?\s ///</span></pre></div></div>
    1792. 

  1792.             
    1793. 

  1793.         </li>
    1794. 

  1794.         
    1795. 

  1795.         
    1796. 

  1796.         <li id="section-70">
    1797. 

  1797.             <div class="annotation">
    1798. 

  1798.               
    1799. 

  1799.               <div class="pilwrap ">
    1800. 

  1800.                 <a class="pilcrow" href="#section-70">&#182;</a>
    1801. 

  1801.               </div>
    1802. 

  1802.               <p>Other regexes.</p>
    1803. 

  1803. 

  1804.             </div>
    1805. 

  1805.             
    1806. 

  1806.             <div class="content"><div class='highlight'><pre>HERECOMMENT_ILLEGAL = <span class="hljs-regexp">/\*\//</span>
    1807. 

  1807. 

  1808. LINE_CONTINUER      = <span class="hljs-regexp">/// ^ \s* (?: , | \??\.(?![.\d]) | :: ) ///</span>
    1809. 

  1809. 

  1810. INVALID_ESCAPE      = <span class="hljs-regexp">///
    1811. 

  1811.   ( (?:^|[^\\]) (?:\\\\)* )        <span class="hljs-comment"># make sure the escape isn’t escaped</span>
    1812. 

  1812.   \\ (
    1813. 

  1813.      ?: (0[0-7]|[1-7])             <span class="hljs-comment"># octal escape</span>
    1814. 

  1814.       | (x(?![\da-fA-F]{2}).{0,2}) <span class="hljs-comment"># hex escape</span>
    1815. 

  1815.       | (u(?![\da-fA-F]{4}).{0,4}) <span class="hljs-comment"># unicode escape</span>
    1816. 

  1816.   )
    1817. 

  1817. ///</span>
    1818. 

  1818. 

  1819. LEADING_BLANK_LINE  = <span class="hljs-regexp">/^[^\n\S]*\n/</span>
    1820. 

  1820. TRAILING_BLANK_LINE = <span class="hljs-regexp">/\n[^\n\S]*$/</span>
    1821. 

  1821. 

  1822. TRAILING_SPACES     = <span class="hljs-regexp">/\s+$/</span></pre></div></div>
    1823. 

  1823.             
    1824. 

  1824.         </li>
    1825. 

  1825.         
    1826. 

  1826.         
    1827. 

  1827.         <li id="section-71">
    1828. 

  1828.             <div class="annotation">
    1829. 

  1829.               
    1830. 

  1830.               <div class="pilwrap ">
    1831. 

  1831.                 <a class="pilcrow" href="#section-71">&#182;</a>
    1832. 

  1832.               </div>
    1833. 

  1833.               <p>Compound assignment tokens.</p>
    1834. 

  1834. 

  1835.             </div>
    1836. 

  1836.             
    1837. 

  1837.             <div class="content"><div class='highlight'><pre>COMPOUND_ASSIGN = [
    1838. 

  1838.   <span class="hljs-string">'-='</span>, <span class="hljs-string">'+='</span>, <span class="hljs-string">'/='</span>, <span class="hljs-string">'*='</span>, <span class="hljs-string">'%='</span>, <span class="hljs-string">'||='</span>, <span class="hljs-string">'&amp;&amp;='</span>, <span class="hljs-string">'?='</span>, <span class="hljs-string">'&lt;&lt;='</span>, <span class="hljs-string">'&gt;&gt;='</span>, <span class="hljs-string">'&gt;&gt;&gt;='</span>
    1839. 

  1839.   <span class="hljs-string">'&amp;='</span>, <span class="hljs-string">'^='</span>, <span class="hljs-string">'|='</span>, <span class="hljs-string">'**='</span>, <span class="hljs-string">'//='</span>, <span class="hljs-string">'%%='</span>
    1840. 

  1840. ]</pre></div></div>
    1841. 

  1841.             
    1842. 

  1842.         </li>
    1843. 

  1843.         
    1844. 

  1844.         
    1845. 

  1845.         <li id="section-72">
    1846. 

  1846.             <div class="annotation">
    1847. 

  1847.               
    1848. 

  1848.               <div class="pilwrap ">
    1849. 

  1849.                 <a class="pilcrow" href="#section-72">&#182;</a>
    1850. 

  1850.               </div>
    1851. 

  1851.               <p>Unary tokens.</p>
    1852. 

  1852. 

  1853.             </div>
    1854. 

  1854.             
    1855. 

  1855.             <div class="content"><div class='highlight'><pre>UNARY = [<span class="hljs-string">'NEW'</span>, <span class="hljs-string">'TYPEOF'</span>, <span class="hljs-string">'DELETE'</span>, <span class="hljs-string">'DO'</span>]
    1856. 

  1856. 

  1857. UNARY_MATH = [<span class="hljs-string">'!'</span>, <span class="hljs-string">'~'</span>]</pre></div></div>
    1858. 

  1858.             
    1859. 

  1859.         </li>
    1860. 

  1860.         
    1861. 

  1861.         
    1862. 

  1862.         <li id="section-73">
    1863. 

  1863.             <div class="annotation">
    1864. 

  1864.               
    1865. 

  1865.               <div class="pilwrap ">
    1866. 

  1866.                 <a class="pilcrow" href="#section-73">&#182;</a>
    1867. 

  1867.               </div>
    1868. 

  1868.               <p>Logical tokens.</p>
    1869. 

  1869. 

  1870.             </div>
    1871. 

  1871.             
    1872. 

  1872.             <div class="content"><div class='highlight'><pre>LOGIC = [<span class="hljs-string">'&amp;&amp;'</span>, <span class="hljs-string">'||'</span>, <span class="hljs-string">'&amp;'</span>, <span class="hljs-string">'|'</span>, <span class="hljs-string">'^'</span>]</pre></div></div>
    1873. 

  1873.             
    1874. 

  1874.         </li>
    1875. 

  1875.         
    1876. 

  1876.         
    1877. 

  1877.         <li id="section-74">
    1878. 

  1878.             <div class="annotation">
    1879. 

  1879.               
    1880. 

  1880.               <div class="pilwrap ">
    1881. 

  1881.                 <a class="pilcrow" href="#section-74">&#182;</a>
    1882. 

  1882.               </div>
    1883. 

  1883.               <p>Bit-shifting tokens.</p>
    1884. 

  1884. 

  1885.             </div>
    1886. 

  1886.             
    1887. 

  1887.             <div class="content"><div class='highlight'><pre>SHIFT = [<span class="hljs-string">'&lt;&lt;'</span>, <span class="hljs-string">'&gt;&gt;'</span>, <span class="hljs-string">'&gt;&gt;&gt;'</span>]</pre></div></div>
    1888. 

  1888.             
    1889. 

  1889.         </li>
    1890. 

  1890.         
    1891. 

  1891.         
    1892. 

  1892.         <li id="section-75">
    1893. 

  1893.             <div class="annotation">
    1894. 

  1894.               
    1895. 

  1895.               <div class="pilwrap ">
    1896. 

  1896.                 <a class="pilcrow" href="#section-75">&#182;</a>
    1897. 

  1897.               </div>
    1898. 

  1898.               <p>Comparison tokens.</p>
    1899. 

  1899. 

  1900.             </div>
    1901. 

  1901.             
    1902. 

  1902.             <div class="content"><div class='highlight'><pre>COMPARE = [<span class="hljs-string">'=='</span>, <span class="hljs-string">'!='</span>, <span class="hljs-string">'&lt;'</span>, <span class="hljs-string">'&gt;'</span>, <span class="hljs-string">'&lt;='</span>, <span class="hljs-string">'&gt;='</span>]</pre></div></div>
    1903. 

  1903.             
    1904. 

  1904.         </li>
    1905. 

  1905.         
    1906. 

  1906.         
    1907. 

  1907.         <li id="section-76">
    1908. 

  1908.             <div class="annotation">
    1909. 

  1909.               
    1910. 

  1910.               <div class="pilwrap ">
    1911. 

  1911.                 <a class="pilcrow" href="#section-76">&#182;</a>
    1912. 

  1912.               </div>
    1913. 

  1913.               <p>Mathematical tokens.</p>
    1914. 

  1914. 

  1915.             </div>
    1916. 

  1916.             
    1917. 

  1917.             <div class="content"><div class='highlight'><pre>MATH = [<span class="hljs-string">'*'</span>, <span class="hljs-string">'/'</span>, <span class="hljs-string">'%'</span>, <span class="hljs-string">'//'</span>, <span class="hljs-string">'%%'</span>]</pre></div></div>
    1918. 

  1918.             
    1919. 

  1919.         </li>
    1920. 

  1920.         
    1921. 

  1921.         
    1922. 

  1922.         <li id="section-77">
    1923. 

  1923.             <div class="annotation">
    1924. 

  1924.               
    1925. 

  1925.               <div class="pilwrap ">
    1926. 

  1926.                 <a class="pilcrow" href="#section-77">&#182;</a>
    1927. 

  1927.               </div>
    1928. 

  1928.               <p>Relational tokens that are negatable with <code>not</code> prefix.</p>
    1929. 

  1929. 

  1930.             </div>
    1931. 

  1931.             
    1932. 

  1932.             <div class="content"><div class='highlight'><pre>RELATION = [<span class="hljs-string">'IN'</span>, <span class="hljs-string">'OF'</span>, <span class="hljs-string">'INSTANCEOF'</span>]</pre></div></div>
    1933. 

  1933.             
    1934. 

  1934.         </li>
    1935. 

  1935.         
    1936. 

  1936.         
    1937. 

  1937.         <li id="section-78">
    1938. 

  1938.             <div class="annotation">
    1939. 

  1939.               
    1940. 

  1940.               <div class="pilwrap ">
    1941. 

  1941.                 <a class="pilcrow" href="#section-78">&#182;</a>
    1942. 

  1942.               </div>
    1943. 

  1943.               <p>Boolean tokens.</p>
    1944. 

  1944. 

  1945.             </div>
    1946. 

  1946.             
    1947. 

  1947.             <div class="content"><div class='highlight'><pre>BOOL = [<span class="hljs-string">'TRUE'</span>, <span class="hljs-string">'FALSE'</span>]</pre></div></div>
    1948. 

  1948.             
    1949. 

  1949.         </li>
    1950. 

  1950.         
    1951. 

  1951.         
    1952. 

  1952.         <li id="section-79">
    1953. 

  1953.             <div class="annotation">
    1954. 

  1954.               
    1955. 

  1955.               <div class="pilwrap ">
    1956. 

  1956.                 <a class="pilcrow" href="#section-79">&#182;</a>
    1957. 

  1957.               </div>
    1958. 

  1958.               <p>Tokens which could legitimately be invoked or indexed. An opening
    1959. 

  1959. parentheses or bracket following these tokens will be recorded as the start
    1960. 

  1960. of a function invocation or indexing operation.</p>
    1961. 

  1961. 

  1962.             </div>
    1963. 

  1963.             
    1964. 

  1964.             <div class="content"><div class='highlight'><pre>CALLABLE  = [<span class="hljs-string">'IDENTIFIER'</span>, <span class="hljs-string">')'</span>, <span class="hljs-string">']'</span>, <span class="hljs-string">'?'</span>, <span class="hljs-string">'@'</span>, <span class="hljs-string">'THIS'</span>, <span class="hljs-string">'SUPER'</span>]
    1965. 

  1965. INDEXABLE = CALLABLE.concat [
    1966. 

  1966.   <span class="hljs-string">'NUMBER'</span>, <span class="hljs-string">'STRING'</span>, <span class="hljs-string">'STRING_END'</span>, <span class="hljs-string">'REGEX'</span>, <span class="hljs-string">'REGEX_END'</span>
    1967. 

  1967.   <span class="hljs-string">'BOOL'</span>, <span class="hljs-string">'NULL'</span>, <span class="hljs-string">'UNDEFINED'</span>, <span class="hljs-string">'}'</span>, <span class="hljs-string">'::'</span>
    1968. 

  1968. ]</pre></div></div>
    1969. 

  1969.             
    1970. 

  1970.         </li>
    1971. 

  1971.         
    1972. 

  1972.         
    1973. 

  1973.         <li id="section-80">
    1974. 

  1974.             <div class="annotation">
    1975. 

  1975.               
    1976. 

  1976.               <div class="pilwrap ">
    1977. 

  1977.                 <a class="pilcrow" href="#section-80">&#182;</a>
    1978. 

  1978.               </div>
    1979. 

  1979.               <p>Tokens which a regular expression will never immediately follow (except spaced
    1980. 

  1980. CALLABLEs in some cases), but which a division operator can.</p>
    1981. 

  1981. <p>See: <a href="http://www-archive.mozilla.org/js/language/js20-2002-04/rationale/syntax.html#regular-expressions">http://www-archive.mozilla.org/js/language/js20-2002-04/rationale/syntax.html#regular-expressions</a></p>
    1982. 

  1982. 

  1983.             </div>
    1984. 

  1984.             
    1985. 

  1985.             <div class="content"><div class='highlight'><pre>NOT_REGEX = INDEXABLE.concat [<span class="hljs-string">'++'</span>, <span class="hljs-string">'--'</span>]</pre></div></div>
    1986. 

  1986.             
    1987. 

  1987.         </li>
    1988. 

  1988.         
    1989. 

  1989.         
    1990. 

  1990.         <li id="section-81">
    1991. 

  1991.             <div class="annotation">
    1992. 

  1992.               
    1993. 

  1993.               <div class="pilwrap ">
    1994. 

  1994.                 <a class="pilcrow" href="#section-81">&#182;</a>
    1995. 

  1995.               </div>
    1996. 

  1996.               <p>Tokens that, when immediately preceding a <code>WHEN</code>, indicate that the <code>WHEN</code>
    1997. 

  1997. occurs at the start of a line. We disambiguate these from trailing whens to
    1998. 

  1998. avoid an ambiguity in the grammar.</p>
    1999. 

  1999. 

  2000.             </div>
    2001. 

  2001.             
    2002. 

  2002.             <div class="content"><div class='highlight'><pre>LINE_BREAK = [<span class="hljs-string">'INDENT'</span>, <span class="hljs-string">'OUTDENT'</span>, <span class="hljs-string">'TERMINATOR'</span>]</pre></div></div>
    2003. 

  2003.             
    2004. 

  2004.         </li>
    2005. 

  2005.         
    2006. 

  2006.         
    2007. 

  2007.         <li id="section-82">
    2008. 

  2008.             <div class="annotation">
    2009. 

  2009.               
    2010. 

  2010.               <div class="pilwrap ">
    2011. 

  2011.                 <a class="pilcrow" href="#section-82">&#182;</a>
    2012. 

  2012.               </div>
    2013. 

  2013.               <p>Additional indent in front of these is ignored.</p>
    2014. 

  2014. 

  2015.             </div>
    2016. 

  2016.             
    2017. 

  2017.             <div class="content"><div class='highlight'><pre>INDENTABLE_CLOSERS = [<span class="hljs-string">')'</span>, <span class="hljs-string">'}'</span>, <span class="hljs-string">']'</span>]</pre></div></div>
    2018. 

  2018.             
    2019. 

  2019.         </li>
    2020. 

  2020.         
    2021. 

  2021.     </ul>
    2022. 

  2022.   </div>
    2023. 

  2023. </body>
    2024. 

  2024. </html>
    2025. 

  2025.