PageRenderTime 44ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 1ms

/paper-rock-scissors/lib/blanket.js

https://github.com/balancerockmedia/random-stuff
JavaScript | 5447 lines | 4506 code | 712 blank | 229 comment | 817 complexity | 9e6337ed3338831689c4c3edc34d2254 MD5 | raw file
    

  1. /*! blanket - v1.1.5 */
    2. 

  2. 

  3. if (typeof QUnit !== 'undefined'){ QUnit.config.autostart = false; }
    4. 

  4. (function(define){
    5. 

  5. /*
    6. 

  6.   Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
    7. 

  7.   Copyright (C) 2012 Mathias Bynens <mathias@qiwi.be>
    8. 

  8.   Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>
    9. 

  9.   Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>
    10. 

  10.   Copyright (C) 2012 Yusuke Suzuki <utatane.tea@gmail.com>
    11. 

  11.   Copyright (C) 2012 Arpad Borsos <arpad.borsos@googlemail.com>
    12. 

  12.   Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
    13. 

    14. 

  14.   Redistribution and use in source and binary forms, with or without
    15. 

  15.   modification, are permitted provided that the following conditions are met:
    16. 

    17. 

  17.     * Redistributions of source code must retain the above copyright
    18. 

  18.       notice, this list of conditions and the following disclaimer.
    19. 

  19.     * Redistributions in binary form must reproduce the above copyright
    20. 

  20.       notice, this list of conditions and the following disclaimer in the
    21. 

  21.       documentation and/or other materials provided with the distribution.
    22. 

    23. 

  23.   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    24. 

  24.   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    25. 

  25.   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    26. 

  26.   ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
    27. 

  27.   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
    28. 

  28.   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    29. 

  29.   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
    30. 

  30.   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    31. 

  31.   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    32. 

  32.   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    33. 

  33. */
    34. 

  34. 

  35. /*jslint bitwise:true plusplus:true */
    36. 

  36. /*global esprima:true, define:true, exports:true, window: true,
    37. 

  37. throwError: true, createLiteral: true, generateStatement: true,
    38. 

  38. parseAssignmentExpression: true, parseBlock: true, parseExpression: true,
    39. 

  39. parseFunctionDeclaration: true, parseFunctionExpression: true,
    40. 

  40. parseFunctionSourceElements: true, parseVariableIdentifier: true,
    41. 

  41. parseLeftHandSideExpression: true,
    42. 

  42. parseStatement: true, parseSourceElement: true */
    43. 

  43. 

  44. (function (root, factory) {
    45. 

  45.     'use strict';
    46. 

  46. 

  47.     // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,
    48. 

  48.     // Rhino, and plain browser loading.
    49. 

  49.     if (typeof define === 'function' && define.amd) {
    50. 

  50.         define(['exports'], factory);
    51. 

  51.     } else if (typeof exports !== 'undefined') {
    52. 

  52.         factory(exports);
    53. 

  53.     } else {
    54. 

  54.         factory((root.esprima = {}));
    55. 

  55.     }
    56. 

  56. }(this, function (exports) {
    57. 

  57.     'use strict';
    58. 

  58. 

  59.     var Token,
    60. 

  60.         TokenName,
    61. 

  61.         Syntax,
    62. 

  62.         PropertyKind,
    63. 

  63.         Messages,
    64. 

  64.         Regex,
    65. 

  65.         source,
    66. 

  66.         strict,
    67. 

  67.         index,
    68. 

  68.         lineNumber,
    69. 

  69.         lineStart,
    70. 

  70.         length,
    71. 

  71.         buffer,
    72. 

  72.         state,
    73. 

  73.         extra;
    74. 

  74. 

  75.     Token = {
    76. 

  76.         BooleanLiteral: 1,
    77. 

  77.         EOF: 2,
    78. 

  78.         Identifier: 3,
    79. 

  79.         Keyword: 4,
    80. 

  80.         NullLiteral: 5,
    81. 

  81.         NumericLiteral: 6,
    82. 

  82.         Punctuator: 7,
    83. 

  83.         StringLiteral: 8
    84. 

  84.     };
    85. 

  85. 

  86.     TokenName = {};
    87. 

  87.     TokenName[Token.BooleanLiteral] = 'Boolean';
    88. 

  88.     TokenName[Token.EOF] = '<end>';
    89. 

  89.     TokenName[Token.Identifier] = 'Identifier';
    90. 

  90.     TokenName[Token.Keyword] = 'Keyword';
    91. 

  91.     TokenName[Token.NullLiteral] = 'Null';
    92. 

  92.     TokenName[Token.NumericLiteral] = 'Numeric';
    93. 

  93.     TokenName[Token.Punctuator] = 'Punctuator';
    94. 

  94.     TokenName[Token.StringLiteral] = 'String';
    95. 

  95. 

  96.     Syntax = {
    97. 

  97.         AssignmentExpression: 'AssignmentExpression',
    98. 

  98.         ArrayExpression: 'ArrayExpression',
    99. 

  99.         BlockStatement: 'BlockStatement',
    100. 

  100.         BinaryExpression: 'BinaryExpression',
    101. 

  101.         BreakStatement: 'BreakStatement',
    102. 

  102.         CallExpression: 'CallExpression',
    103. 

  103.         CatchClause: 'CatchClause',
    104. 

  104.         ConditionalExpression: 'ConditionalExpression',
    105. 

  105.         ContinueStatement: 'ContinueStatement',
    106. 

  106.         DoWhileStatement: 'DoWhileStatement',
    107. 

  107.         DebuggerStatement: 'DebuggerStatement',
    108. 

  108.         EmptyStatement: 'EmptyStatement',
    109. 

  109.         ExpressionStatement: 'ExpressionStatement',
    110. 

  110.         ForStatement: 'ForStatement',
    111. 

  111.         ForInStatement: 'ForInStatement',
    112. 

  112.         FunctionDeclaration: 'FunctionDeclaration',
    113. 

  113.         FunctionExpression: 'FunctionExpression',
    114. 

  114.         Identifier: 'Identifier',
    115. 

  115.         IfStatement: 'IfStatement',
    116. 

  116.         Literal: 'Literal',
    117. 

  117.         LabeledStatement: 'LabeledStatement',
    118. 

  118.         LogicalExpression: 'LogicalExpression',
    119. 

  119.         MemberExpression: 'MemberExpression',
    120. 

  120.         NewExpression: 'NewExpression',
    121. 

  121.         ObjectExpression: 'ObjectExpression',
    122. 

  122.         Program: 'Program',
    123. 

  123.         Property: 'Property',
    124. 

  124.         ReturnStatement: 'ReturnStatement',
    125. 

  125.         SequenceExpression: 'SequenceExpression',
    126. 

  126.         SwitchStatement: 'SwitchStatement',
    127. 

  127.         SwitchCase: 'SwitchCase',
    128. 

  128.         ThisExpression: 'ThisExpression',
    129. 

  129.         ThrowStatement: 'ThrowStatement',
    130. 

  130.         TryStatement: 'TryStatement',
    131. 

  131.         UnaryExpression: 'UnaryExpression',
    132. 

  132.         UpdateExpression: 'UpdateExpression',
    133. 

  133.         VariableDeclaration: 'VariableDeclaration',
    134. 

  134.         VariableDeclarator: 'VariableDeclarator',
    135. 

  135.         WhileStatement: 'WhileStatement',
    136. 

  136.         WithStatement: 'WithStatement'
    137. 

  137.     };
    138. 

  138. 

  139.     PropertyKind = {
    140. 

  140.         Data: 1,
    141. 

  141.         Get: 2,
    142. 

  142.         Set: 4
    143. 

  143.     };
    144. 

  144. 

  145.     // Error messages should be identical to V8.
    146. 

  146.     Messages = {
    147. 

  147.         UnexpectedToken:  'Unexpected token %0',
    148. 

  148.         UnexpectedNumber:  'Unexpected number',
    149. 

  149.         UnexpectedString:  'Unexpected string',
    150. 

  150.         UnexpectedIdentifier:  'Unexpected identifier',
    151. 

  151.         UnexpectedReserved:  'Unexpected reserved word',
    152. 

  152.         UnexpectedEOS:  'Unexpected end of input',
    153. 

  153.         NewlineAfterThrow:  'Illegal newline after throw',
    154. 

  154.         InvalidRegExp: 'Invalid regular expression',
    155. 

  155.         UnterminatedRegExp:  'Invalid regular expression: missing /',
    156. 

  156.         InvalidLHSInAssignment:  'Invalid left-hand side in assignment',
    157. 

  157.         InvalidLHSInForIn:  'Invalid left-hand side in for-in',
    158. 

  158.         MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
    159. 

  159.         NoCatchOrFinally:  'Missing catch or finally after try',
    160. 

  160.         UnknownLabel: 'Undefined label \'%0\'',
    161. 

  161.         Redeclaration: '%0 \'%1\' has already been declared',
    162. 

  162.         IllegalContinue: 'Illegal continue statement',
    163. 

  163.         IllegalBreak: 'Illegal break statement',
    164. 

  164.         IllegalReturn: 'Illegal return statement',
    165. 

  165.         StrictModeWith:  'Strict mode code may not include a with statement',
    166. 

  166.         StrictCatchVariable:  'Catch variable may not be eval or arguments in strict mode',
    167. 

  167.         StrictVarName:  'Variable name may not be eval or arguments in strict mode',
    168. 

  168.         StrictParamName:  'Parameter name eval or arguments is not allowed in strict mode',
    169. 

  169.         StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
    170. 

  170.         StrictFunctionName:  'Function name may not be eval or arguments in strict mode',
    171. 

  171.         StrictOctalLiteral:  'Octal literals are not allowed in strict mode.',
    172. 

  172.         StrictDelete:  'Delete of an unqualified identifier in strict mode.',
    173. 

  173.         StrictDuplicateProperty:  'Duplicate data property in object literal not allowed in strict mode',
    174. 

  174.         AccessorDataProperty:  'Object literal may not have data and accessor property with the same name',
    175. 

  175.         AccessorGetSet:  'Object literal may not have multiple get/set accessors with the same name',
    176. 

  176.         StrictLHSAssignment:  'Assignment to eval or arguments is not allowed in strict mode',
    177. 

  177.         StrictLHSPostfix:  'Postfix increment/decrement may not have eval or arguments operand in strict mode',
    178. 

  178.         StrictLHSPrefix:  'Prefix increment/decrement may not have eval or arguments operand in strict mode',
    179. 

  179.         StrictReservedWord:  'Use of future reserved word in strict mode'
    180. 

  180.     };
    181. 

  181. 

  182.     // See also tools/generate-unicode-regex.py.
    183. 

  183.     Regex = {
    184. 

  184.         NonAsciiIdentifierStart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]'),
    185. 

  185.         NonAsciiIdentifierPart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u0487\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u05d0-\u05ea\u05f0-\u05f2\u0610-\u061a\u0620-\u0669\u066e-\u06d3\u06d5-\u06dc\u06df-\u06e8\u06ea-\u06fc\u06ff\u0710-\u074a\u074d-\u07b1\u07c0-\u07f5\u07fa\u0800-\u082d\u0840-\u085b\u08a0\u08a2-\u08ac\u08e4-\u08fe\u0900-\u0963\u0966-\u096f\u0971-\u0977\u0979-\u097f\u0981-\u0983\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7\u09c8\u09cb-\u09ce\u09d7\u09dc\u09dd\u09df-\u09e3\u09e6-\u09f1\u0a01-\u0a03\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5c\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c58\u0c59\u0c60-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1\u0cf2\u0d02\u0d03\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d57\u0d60-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d82\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb9\u0ebb-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ecd\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772\u1773\u1780-\u17d3\u17d7\u17dc\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1820-\u1877\u1880-\u18aa\u18b0-\u18f5\u1900-\u191c\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19d9\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7\u1b00-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1cd0-\u1cd2\u1cd4-\u1cf6\u1d00-\u1de6\u1dfc-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u200c\u200d\u203f\u2040\u2054\u2071\u207f\u2090-\u209c\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u2e2f\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099\u309a\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua66f\ua674-\ua67d\ua67f-\ua697\ua69f-\ua6f1\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua827\ua840-\ua873\ua880-\ua8c4\ua8d0-\ua8d9\ua8e0-\ua8f7\ua8fb\ua900-\ua92d\ua930-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9cf-\ua9d9\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa76\uaa7a\uaa7b\uaa80-\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabea\uabec\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\ufe70-\ufe74\ufe76-\ufefc\uff10-\uff19\uff21-\uff3a\uff3f\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]')
    186. 

  186.     };
    187. 

  187. 

  188.     // Ensure the condition is true, otherwise throw an error.
    189. 

  189.     // This is only to have a better contract semantic, i.e. another safety net
    190. 

  190.     // to catch a logic error. The condition shall be fulfilled in normal case.
    191. 

  191.     // Do NOT use this to enforce a certain condition on any user input.
    192. 

  192. 

  193.     function assert(condition, message) {
    194. 

  194.         if (!condition) {
    195. 

  195.             throw new Error('ASSERT: ' + message);
    196. 

  196.         }
    197. 

  197.     }
    198. 

  198. 

  199.     function sliceSource(from, to) {
    200. 

  200.         return source.slice(from, to);
    201. 

  201.     }
    202. 

  202. 

  203.     if (typeof 'esprima'[0] === 'undefined') {
    204. 

  204.         sliceSource = function sliceArraySource(from, to) {
    205. 

  205.             return source.slice(from, to).join('');
    206. 

  206.         };
    207. 

  207.     }
    208. 

  208. 

  209.     function isDecimalDigit(ch) {
    210. 

  210.         return '0123456789'.indexOf(ch) >= 0;
    211. 

  211.     }
    212. 

  212. 

  213.     function isHexDigit(ch) {
    214. 

  214.         return '0123456789abcdefABCDEF'.indexOf(ch) >= 0;
    215. 

  215.     }
    216. 

  216. 

  217.     function isOctalDigit(ch) {
    218. 

  218.         return '01234567'.indexOf(ch) >= 0;
    219. 

  219.     }
    220. 

  220. 

  221. 

  222.     // 7.2 White Space
    223. 

  223. 

  224.     function isWhiteSpace(ch) {
    225. 

  225.         return (ch === ' ') || (ch === '\u0009') || (ch === '\u000B') ||
    226. 

  226.             (ch === '\u000C') || (ch === '\u00A0') ||
    227. 

  227.             (ch.charCodeAt(0) >= 0x1680 &&
    228. 

  228.              '\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\uFEFF'.indexOf(ch) >= 0);
    229. 

  229.     }
    230. 

  230. 

  231.     // 7.3 Line Terminators
    232. 

  232. 

  233.     function isLineTerminator(ch) {
    234. 

  234.         return (ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029');
    235. 

  235.     }
    236. 

  236. 

  237.     // 7.6 Identifier Names and Identifiers
    238. 

  238. 

  239.     function isIdentifierStart(ch) {
    240. 

  240.         return (ch === '$') || (ch === '_') || (ch === '\\') ||
    241. 

  241.             (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
    242. 

  242.             ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierStart.test(ch));
    243. 

  243.     }
    244. 

  244. 

  245.     function isIdentifierPart(ch) {
    246. 

  246.         return (ch === '$') || (ch === '_') || (ch === '\\') ||
    247. 

  247.             (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
    248. 

  248.             ((ch >= '0') && (ch <= '9')) ||
    249. 

  249.             ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierPart.test(ch));
    250. 

  250.     }
    251. 

  251. 

  252.     // 7.6.1.2 Future Reserved Words
    253. 

  253. 

  254.     function isFutureReservedWord(id) {
    255. 

  255.         switch (id) {
    256. 

  256. 

  257.         // Future reserved words.
    258. 

  258.         case 'class':
    259. 

  259.         case 'enum':
    260. 

  260.         case 'export':
    261. 

  261.         case 'extends':
    262. 

  262.         case 'import':
    263. 

  263.         case 'super':
    264. 

  264.             return true;
    265. 

  265.         }
    266. 

  266. 

  267.         return false;
    268. 

  268.     }
    269. 

  269. 

  270.     function isStrictModeReservedWord(id) {
    271. 

  271.         switch (id) {
    272. 

  272. 

  273.         // Strict Mode reserved words.
    274. 

  274.         case 'implements':
    275. 

  275.         case 'interface':
    276. 

  276.         case 'package':
    277. 

  277.         case 'private':
    278. 

  278.         case 'protected':
    279. 

  279.         case 'public':
    280. 

  280.         case 'static':
    281. 

  281.         case 'yield':
    282. 

  282.         case 'let':
    283. 

  283.             return true;
    284. 

  284.         }
    285. 

  285. 

  286.         return false;
    287. 

  287.     }
    288. 

  288. 

  289.     function isRestrictedWord(id) {
    290. 

  290.         return id === 'eval' || id === 'arguments';
    291. 

  291.     }
    292. 

  292. 

  293.     // 7.6.1.1 Keywords
    294. 

  294. 

  295.     function isKeyword(id) {
    296. 

  296.         var keyword = false;
    297. 

  297.         switch (id.length) {
    298. 

  298.         case 2:
    299. 

  299.             keyword = (id === 'if') || (id === 'in') || (id === 'do');
    300. 

  300.             break;
    301. 

  301.         case 3:
    302. 

  302.             keyword = (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try');
    303. 

  303.             break;
    304. 

  304.         case 4:
    305. 

  305.             keyword = (id === 'this') || (id === 'else') || (id === 'case') || (id === 'void') || (id === 'with');
    306. 

  306.             break;
    307. 

  307.         case 5:
    308. 

  308.             keyword = (id === 'while') || (id === 'break') || (id === 'catch') || (id === 'throw');
    309. 

  309.             break;
    310. 

  310.         case 6:
    311. 

  311.             keyword = (id === 'return') || (id === 'typeof') || (id === 'delete') || (id === 'switch');
    312. 

  312.             break;
    313. 

  313.         case 7:
    314. 

  314.             keyword = (id === 'default') || (id === 'finally');
    315. 

  315.             break;
    316. 

  316.         case 8:
    317. 

  317.             keyword = (id === 'function') || (id === 'continue') || (id === 'debugger');
    318. 

  318.             break;
    319. 

  319.         case 10:
    320. 

  320.             keyword = (id === 'instanceof');
    321. 

  321.             break;
    322. 

  322.         }
    323. 

  323. 

  324.         if (keyword) {
    325. 

  325.             return true;
    326. 

  326.         }
    327. 

  327. 

  328.         switch (id) {
    329. 

  329.         // Future reserved words.
    330. 

  330.         // 'const' is specialized as Keyword in V8.
    331. 

  331.         case 'const':
    332. 

  332.             return true;
    333. 

  333. 

  334.         // For compatiblity to SpiderMonkey and ES.next
    335. 

  335.         case 'yield':
    336. 

  336.         case 'let':
    337. 

  337.             return true;
    338. 

  338.         }
    339. 

  339. 

  340.         if (strict && isStrictModeReservedWord(id)) {
    341. 

  341.             return true;
    342. 

  342.         }
    343. 

  343. 

  344.         return isFutureReservedWord(id);
    345. 

  345.     }
    346. 

  346. 

  347.     // 7.4 Comments
    348. 

  348. 

  349.     function skipComment() {
    350. 

  350.         var ch, blockComment, lineComment;
    351. 

  351. 

  352.         blockComment = false;
    353. 

  353.         lineComment = false;
    354. 

  354. 

  355.         while (index < length) {
    356. 

  356.             ch = source[index];
    357. 

  357. 

  358.             if (lineComment) {
    359. 

  359.                 ch = source[index++];
    360. 

  360.                 if (isLineTerminator(ch)) {
    361. 

  361.                     lineComment = false;
    362. 

  362.                     if (ch === '\r' && source[index] === '\n') {
    363. 

  363.                         ++index;
    364. 

  364.                     }
    365. 

  365.                     ++lineNumber;
    366. 

  366.                     lineStart = index;
    367. 

  367.                 }
    368. 

  368.             } else if (blockComment) {
    369. 

  369.                 if (isLineTerminator(ch)) {
    370. 

  370.                     if (ch === '\r' && source[index + 1] === '\n') {
    371. 

  371.                         ++index;
    372. 

  372.                     }
    373. 

  373.                     ++lineNumber;
    374. 

  374.                     ++index;
    375. 

  375.                     lineStart = index;
    376. 

  376.                     if (index >= length) {
    377. 

  377.                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    378. 

  378.                     }
    379. 

  379.                 } else {
    380. 

  380.                     ch = source[index++];
    381. 

  381.                     if (index >= length) {
    382. 

  382.                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    383. 

  383.                     }
    384. 

  384.                     if (ch === '*') {
    385. 

  385.                         ch = source[index];
    386. 

  386.                         if (ch === '/') {
    387. 

  387.                             ++index;
    388. 

  388.                             blockComment = false;
    389. 

  389.                         }
    390. 

  390.                     }
    391. 

  391.                 }
    392. 

  392.             } else if (ch === '/') {
    393. 

  393.                 ch = source[index + 1];
    394. 

  394.                 if (ch === '/') {
    395. 

  395.                     index += 2;
    396. 

  396.                     lineComment = true;
    397. 

  397.                 } else if (ch === '*') {
    398. 

  398.                     index += 2;
    399. 

  399.                     blockComment = true;
    400. 

  400.                     if (index >= length) {
    401. 

  401.                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    402. 

  402.                     }
    403. 

  403.                 } else {
    404. 

  404.                     break;
    405. 

  405.                 }
    406. 

  406.             } else if (isWhiteSpace(ch)) {
    407. 

  407.                 ++index;
    408. 

  408.             } else if (isLineTerminator(ch)) {
    409. 

  409.                 ++index;
    410. 

  410.                 if (ch ===  '\r' && source[index] === '\n') {
    411. 

  411.                     ++index;
    412. 

  412.                 }
    413. 

  413.                 ++lineNumber;
    414. 

  414.                 lineStart = index;
    415. 

  415.             } else {
    416. 

  416.                 break;
    417. 

  417.             }
    418. 

  418.         }
    419. 

  419.     }
    420. 

  420. 

  421.     function scanHexEscape(prefix) {
    422. 

  422.         var i, len, ch, code = 0;
    423. 

  423. 

  424.         len = (prefix === 'u') ? 4 : 2;
    425. 

  425.         for (i = 0; i < len; ++i) {
    426. 

  426.             if (index < length && isHexDigit(source[index])) {
    427. 

  427.                 ch = source[index++];
    428. 

  428.                 code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase());
    429. 

  429.             } else {
    430. 

  430.                 return '';
    431. 

  431.             }
    432. 

  432.         }
    433. 

  433.         return String.fromCharCode(code);
    434. 

  434.     }
    435. 

  435. 

  436.     function scanIdentifier() {
    437. 

  437.         var ch, start, id, restore;
    438. 

  438. 

  439.         ch = source[index];
    440. 

  440.         if (!isIdentifierStart(ch)) {
    441. 

  441.             return;
    442. 

  442.         }
    443. 

  443. 

  444.         start = index;
    445. 

  445.         if (ch === '\\') {
    446. 

  446.             ++index;
    447. 

  447.             if (source[index] !== 'u') {
    448. 

  448.                 return;
    449. 

  449.             }
    450. 

  450.             ++index;
    451. 

  451.             restore = index;
    452. 

  452.             ch = scanHexEscape('u');
    453. 

  453.             if (ch) {
    454. 

  454.                 if (ch === '\\' || !isIdentifierStart(ch)) {
    455. 

  455.                     return;
    456. 

  456.                 }
    457. 

  457.                 id = ch;
    458. 

  458.             } else {
    459. 

  459.                 index = restore;
    460. 

  460.                 id = 'u';
    461. 

  461.             }
    462. 

  462.         } else {
    463. 

  463.             id = source[index++];
    464. 

  464.         }
    465. 

  465. 

  466.         while (index < length) {
    467. 

  467.             ch = source[index];
    468. 

  468.             if (!isIdentifierPart(ch)) {
    469. 

  469.                 break;
    470. 

  470.             }
    471. 

  471.             if (ch === '\\') {
    472. 

  472.                 ++index;
    473. 

  473.                 if (source[index] !== 'u') {
    474. 

  474.                     return;
    475. 

  475.                 }
    476. 

  476.                 ++index;
    477. 

  477.                 restore = index;
    478. 

  478.                 ch = scanHexEscape('u');
    479. 

  479.                 if (ch) {
    480. 

  480.                     if (ch === '\\' || !isIdentifierPart(ch)) {
    481. 

  481.                         return;
    482. 

  482.                     }
    483. 

  483.                     id += ch;
    484. 

  484.                 } else {
    485. 

  485.                     index = restore;
    486. 

  486.                     id += 'u';
    487. 

  487.                 }
    488. 

  488.             } else {
    489. 

  489.                 id += source[index++];
    490. 

  490.             }
    491. 

  491.         }
    492. 

  492. 

  493.         // There is no keyword or literal with only one character.
    494. 

  494.         // Thus, it must be an identifier.
    495. 

  495.         if (id.length === 1) {
    496. 

  496.             return {
    497. 

  497.                 type: Token.Identifier,
    498. 

  498.                 value: id,
    499. 

  499.                 lineNumber: lineNumber,
    500. 

  500.                 lineStart: lineStart,
    501. 

  501.                 range: [start, index]
    502. 

  502.             };
    503. 

  503.         }
    504. 

  504. 

  505.         if (isKeyword(id)) {
    506. 

  506.             return {
    507. 

  507.                 type: Token.Keyword,
    508. 

  508.                 value: id,
    509. 

  509.                 lineNumber: lineNumber,
    510. 

  510.                 lineStart: lineStart,
    511. 

  511.                 range: [start, index]
    512. 

  512.             };
    513. 

  513.         }
    514. 

  514. 

  515.         // 7.8.1 Null Literals
    516. 

  516. 

  517.         if (id === 'null') {
    518. 

  518.             return {
    519. 

  519.                 type: Token.NullLiteral,
    520. 

  520.                 value: id,
    521. 

  521.                 lineNumber: lineNumber,
    522. 

  522.                 lineStart: lineStart,
    523. 

  523.                 range: [start, index]
    524. 

  524.             };
    525. 

  525.         }
    526. 

  526. 

  527.         // 7.8.2 Boolean Literals
    528. 

  528. 

  529.         if (id === 'true' || id === 'false') {
    530. 

  530.             return {
    531. 

  531.                 type: Token.BooleanLiteral,
    532. 

  532.                 value: id,
    533. 

  533.                 lineNumber: lineNumber,
    534. 

  534.                 lineStart: lineStart,
    535. 

  535.                 range: [start, index]
    536. 

  536.             };
    537. 

  537.         }
    538. 

  538. 

  539.         return {
    540. 

  540.             type: Token.Identifier,
    541. 

  541.             value: id,
    542. 

  542.             lineNumber: lineNumber,
    543. 

  543.             lineStart: lineStart,
    544. 

  544.             range: [start, index]
    545. 

  545.         };
    546. 

  546.     }
    547. 

  547. 

  548.     // 7.7 Punctuators
    549. 

  549. 

  550.     function scanPunctuator() {
    551. 

  551.         var start = index,
    552. 

  552.             ch1 = source[index],
    553. 

  553.             ch2,
    554. 

  554.             ch3,
    555. 

  555.             ch4;
    556. 

  556. 

  557.         // Check for most common single-character punctuators.
    558. 

  558. 

  559.         if (ch1 === ';' || ch1 === '{' || ch1 === '}') {
    560. 

  560.             ++index;
    561. 

  561.             return {
    562. 

  562.                 type: Token.Punctuator,
    563. 

  563.                 value: ch1,
    564. 

  564.                 lineNumber: lineNumber,
    565. 

  565.                 lineStart: lineStart,
    566. 

  566.                 range: [start, index]
    567. 

  567.             };
    568. 

  568.         }
    569. 

  569. 

  570.         if (ch1 === ',' || ch1 === '(' || ch1 === ')') {
    571. 

  571.             ++index;
    572. 

  572.             return {
    573. 

  573.                 type: Token.Punctuator,
    574. 

  574.                 value: ch1,
    575. 

  575.                 lineNumber: lineNumber,
    576. 

  576.                 lineStart: lineStart,
    577. 

  577.                 range: [start, index]
    578. 

  578.             };
    579. 

  579.         }
    580. 

  580. 

  581.         // Dot (.) can also start a floating-point number, hence the need
    582. 

  582.         // to check the next character.
    583. 

  583. 

  584.         ch2 = source[index + 1];
    585. 

  585.         if (ch1 === '.' && !isDecimalDigit(ch2)) {
    586. 

  586.             return {
    587. 

  587.                 type: Token.Punctuator,
    588. 

  588.                 value: source[index++],
    589. 

  589.                 lineNumber: lineNumber,
    590. 

  590.                 lineStart: lineStart,
    591. 

  591.                 range: [start, index]
    592. 

  592.             };
    593. 

  593.         }
    594. 

  594. 

  595.         // Peek more characters.
    596. 

  596. 

  597.         ch3 = source[index + 2];
    598. 

  598.         ch4 = source[index + 3];
    599. 

  599. 

  600.         // 4-character punctuator: >>>=
    601. 

  601. 

  602.         if (ch1 === '>' && ch2 === '>' && ch3 === '>') {
    603. 

  603.             if (ch4 === '=') {
    604. 

  604.                 index += 4;
    605. 

  605.                 return {
    606. 

  606.                     type: Token.Punctuator,
    607. 

  607.                     value: '>>>=',
    608. 

  608.                     lineNumber: lineNumber,
    609. 

  609.                     lineStart: lineStart,
    610. 

  610.                     range: [start, index]
    611. 

  611.                 };
    612. 

  612.             }
    613. 

  613.         }
    614. 

  614. 

  615.         // 3-character punctuators: === !== >>> <<= >>=
    616. 

  616. 

  617.         if (ch1 === '=' && ch2 === '=' && ch3 === '=') {
    618. 

  618.             index += 3;
    619. 

  619.             return {
    620. 

  620.                 type: Token.Punctuator,
    621. 

  621.                 value: '===',
    622. 

  622.                 lineNumber: lineNumber,
    623. 

  623.                 lineStart: lineStart,
    624. 

  624.                 range: [start, index]
    625. 

  625.             };
    626. 

  626.         }
    627. 

  627. 

  628.         if (ch1 === '!' && ch2 === '=' && ch3 === '=') {
    629. 

  629.             index += 3;
    630. 

  630.             return {
    631. 

  631.                 type: Token.Punctuator,
    632. 

  632.                 value: '!==',
    633. 

  633.                 lineNumber: lineNumber,
    634. 

  634.                 lineStart: lineStart,
    635. 

  635.                 range: [start, index]
    636. 

  636.             };
    637. 

  637.         }
    638. 

  638. 

  639.         if (ch1 === '>' && ch2 === '>' && ch3 === '>') {
    640. 

  640.             index += 3;
    641. 

  641.             return {
    642. 

  642.                 type: Token.Punctuator,
    643. 

  643.                 value: '>>>',
    644. 

  644.                 lineNumber: lineNumber,
    645. 

  645.                 lineStart: lineStart,
    646. 

  646.                 range: [start, index]
    647. 

  647.             };
    648. 

  648.         }
    649. 

  649. 

  650.         if (ch1 === '<' && ch2 === '<' && ch3 === '=') {
    651. 

  651.             index += 3;
    652. 

  652.             return {
    653. 

  653.                 type: Token.Punctuator,
    654. 

  654.                 value: '<<=',
    655. 

  655.                 lineNumber: lineNumber,
    656. 

  656.                 lineStart: lineStart,
    657. 

  657.                 range: [start, index]
    658. 

  658.             };
    659. 

  659.         }
    660. 

  660. 

  661.         if (ch1 === '>' && ch2 === '>' && ch3 === '=') {
    662. 

  662.             index += 3;
    663. 

  663.             return {
    664. 

  664.                 type: Token.Punctuator,
    665. 

  665.                 value: '>>=',
    666. 

  666.                 lineNumber: lineNumber,
    667. 

  667.                 lineStart: lineStart,
    668. 

  668.                 range: [start, index]
    669. 

  669.             };
    670. 

  670.         }
    671. 

  671. 

  672.         // 2-character punctuators: <= >= == != ++ -- << >> && ||
    673. 

  673.         // += -= *= %= &= |= ^= /=
    674. 

  674. 

  675.         if (ch2 === '=') {
    676. 

  676.             if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) {
    677. 

  677.                 index += 2;
    678. 

  678.                 return {
    679. 

  679.                     type: Token.Punctuator,
    680. 

  680.                     value: ch1 + ch2,
    681. 

  681.                     lineNumber: lineNumber,
    682. 

  682.                     lineStart: lineStart,
    683. 

  683.                     range: [start, index]
    684. 

  684.                 };
    685. 

  685.             }
    686. 

  686.         }
    687. 

  687. 

  688.         if (ch1 === ch2 && ('+-<>&|'.indexOf(ch1) >= 0)) {
    689. 

  689.             if ('+-<>&|'.indexOf(ch2) >= 0) {
    690. 

  690.                 index += 2;
    691. 

  691.                 return {
    692. 

  692.                     type: Token.Punctuator,
    693. 

  693.                     value: ch1 + ch2,
    694. 

  694.                     lineNumber: lineNumber,
    695. 

  695.                     lineStart: lineStart,
    696. 

  696.                     range: [start, index]
    697. 

  697.                 };
    698. 

  698.             }
    699. 

  699.         }
    700. 

  700. 

  701.         // The remaining 1-character punctuators.
    702. 

  702. 

  703.         if ('[]<>+-*%&|^!~?:=/'.indexOf(ch1) >= 0) {
    704. 

  704.             return {
    705. 

  705.                 type: Token.Punctuator,
    706. 

  706.                 value: source[index++],
    707. 

  707.                 lineNumber: lineNumber,
    708. 

  708.                 lineStart: lineStart,
    709. 

  709.                 range: [start, index]
    710. 

  710.             };
    711. 

  711.         }
    712. 

  712.     }
    713. 

  713. 

  714.     // 7.8.3 Numeric Literals
    715. 

  715. 

  716.     function scanNumericLiteral() {
    717. 

  717.         var number, start, ch;
    718. 

  718. 

  719.         ch = source[index];
    720. 

  720.         assert(isDecimalDigit(ch) || (ch === '.'),
    721. 

  721.             'Numeric literal must start with a decimal digit or a decimal point');
    722. 

  722. 

  723.         start = index;
    724. 

  724.         number = '';
    725. 

  725.         if (ch !== '.') {
    726. 

  726.             number = source[index++];
    727. 

  727.             ch = source[index];
    728. 

  728. 

  729.             // Hex number starts with '0x'.
    730. 

  730.             // Octal number starts with '0'.
    731. 

  731.             if (number === '0') {
    732. 

  732.                 if (ch === 'x' || ch === 'X') {
    733. 

  733.                     number += source[index++];
    734. 

  734.                     while (index < length) {
    735. 

  735.                         ch = source[index];
    736. 

  736.                         if (!isHexDigit(ch)) {
    737. 

  737.                             break;
    738. 

  738.                         }
    739. 

  739.                         number += source[index++];
    740. 

  740.                     }
    741. 

  741. 

  742.                     if (number.length <= 2) {
    743. 

  743.                         // only 0x
    744. 

  744.                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    745. 

  745.                     }
    746. 

  746. 

  747.                     if (index < length) {
    748. 

  748.                         ch = source[index];
    749. 

  749.                         if (isIdentifierStart(ch)) {
    750. 

  750.                             throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    751. 

  751.                         }
    752. 

  752.                     }
    753. 

  753.                     return {
    754. 

  754.                         type: Token.NumericLiteral,
    755. 

  755.                         value: parseInt(number, 16),
    756. 

  756.                         lineNumber: lineNumber,
    757. 

  757.                         lineStart: lineStart,
    758. 

  758.                         range: [start, index]
    759. 

  759.                     };
    760. 

  760.                 } else if (isOctalDigit(ch)) {
    761. 

  761.                     number += source[index++];
    762. 

  762.                     while (index < length) {
    763. 

  763.                         ch = source[index];
    764. 

  764.                         if (!isOctalDigit(ch)) {
    765. 

  765.                             break;
    766. 

  766.                         }
    767. 

  767.                         number += source[index++];
    768. 

  768.                     }
    769. 

  769. 

  770.                     if (index < length) {
    771. 

  771.                         ch = source[index];
    772. 

  772.                         if (isIdentifierStart(ch) || isDecimalDigit(ch)) {
    773. 

  773.                             throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    774. 

  774.                         }
    775. 

  775.                     }
    776. 

  776.                     return {
    777. 

  777.                         type: Token.NumericLiteral,
    778. 

  778.                         value: parseInt(number, 8),
    779. 

  779.                         octal: true,
    780. 

  780.                         lineNumber: lineNumber,
    781. 

  781.                         lineStart: lineStart,
    782. 

  782.                         range: [start, index]
    783. 

  783.                     };
    784. 

  784.                 }
    785. 

  785. 

  786.                 // decimal number starts with '0' such as '09' is illegal.
    787. 

  787.                 if (isDecimalDigit(ch)) {
    788. 

  788.                     throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    789. 

  789.                 }
    790. 

  790.             }
    791. 

  791. 

  792.             while (index < length) {
    793. 

  793.                 ch = source[index];
    794. 

  794.                 if (!isDecimalDigit(ch)) {
    795. 

  795.                     break;
    796. 

  796.                 }
    797. 

  797.                 number += source[index++];
    798. 

  798.             }
    799. 

  799.         }
    800. 

  800. 

  801.         if (ch === '.') {
    802. 

  802.             number += source[index++];
    803. 

  803.             while (index < length) {
    804. 

  804.                 ch = source[index];
    805. 

  805.                 if (!isDecimalDigit(ch)) {
    806. 

  806.                     break;
    807. 

  807.                 }
    808. 

  808.                 number += source[index++];
    809. 

  809.             }
    810. 

  810.         }
    811. 

  811. 

  812.         if (ch === 'e' || ch === 'E') {
    813. 

  813.             number += source[index++];
    814. 

  814. 

  815.             ch = source[index];
    816. 

  816.             if (ch === '+' || ch === '-') {
    817. 

  817.                 number += source[index++];
    818. 

  818.             }
    819. 

  819. 

  820.             ch = source[index];
    821. 

  821.             if (isDecimalDigit(ch)) {
    822. 

  822.                 number += source[index++];
    823. 

  823.                 while (index < length) {
    824. 

  824.                     ch = source[index];
    825. 

  825.                     if (!isDecimalDigit(ch)) {
    826. 

  826.                         break;
    827. 

  827.                     }
    828. 

  828.                     number += source[index++];
    829. 

  829.                 }
    830. 

  830.             } else {
    831. 

  831.                 ch = 'character ' + ch;
    832. 

  832.                 if (index >= length) {
    833. 

  833.                     ch = '<end>';
    834. 

  834.                 }
    835. 

  835.                 throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    836. 

  836.             }
    837. 

  837.         }
    838. 

  838. 

  839.         if (index < length) {
    840. 

  840.             ch = source[index];
    841. 

  841.             if (isIdentifierStart(ch)) {
    842. 

  842.                 throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    843. 

  843.             }
    844. 

  844.         }
    845. 

  845. 

  846.         return {
    847. 

  847.             type: Token.NumericLiteral,
    848. 

  848.             value: parseFloat(number),
    849. 

  849.             lineNumber: lineNumber,
    850. 

  850.             lineStart: lineStart,
    851. 

  851.             range: [start, index]
    852. 

  852.         };
    853. 

  853.     }
    854. 

  854. 

  855.     // 7.8.4 String Literals
    856. 

  856. 

  857.     function scanStringLiteral() {
    858. 

  858.         var str = '', quote, start, ch, code, unescaped, restore, octal = false;
    859. 

  859. 

  860.         quote = source[index];
    861. 

  861.         assert((quote === '\'' || quote === '"'),
    862. 

  862.             'String literal must starts with a quote');
    863. 

  863. 

  864.         start = index;
    865. 

  865.         ++index;
    866. 

  866. 

  867.         while (index < length) {
    868. 

  868.             ch = source[index++];
    869. 

  869. 

  870.             if (ch === quote) {
    871. 

  871.                 quote = '';
    872. 

  872.                 break;
    873. 

  873.             } else if (ch === '\\') {
    874. 

  874.                 ch = source[index++];
    875. 

  875.                 if (!isLineTerminator(ch)) {
    876. 

  876.                     switch (ch) {
    877. 

  877.                     case 'n':
    878. 

  878.                         str += '\n';
    879. 

  879.                         break;
    880. 

  880.                     case 'r':
    881. 

  881.                         str += '\r';
    882. 

  882.                         break;
    883. 

  883.                     case 't':
    884. 

  884.                         str += '\t';
    885. 

  885.                         break;
    886. 

  886.                     case 'u':
    887. 

  887.                     case 'x':
    888. 

  888.                         restore = index;
    889. 

  889.                         unescaped = scanHexEscape(ch);
    890. 

  890.                         if (unescaped) {
    891. 

  891.                             str += unescaped;
    892. 

  892.                         } else {
    893. 

  893.                             index = restore;
    894. 

  894.                             str += ch;
    895. 

  895.                         }
    896. 

  896.                         break;
    897. 

  897.                     case 'b':
    898. 

  898.                         str += '\b';
    899. 

  899.                         break;
    900. 

  900.                     case 'f':
    901. 

  901.                         str += '\f';
    902. 

  902.                         break;
    903. 

  903.                     case 'v':
    904. 

  904.                         str += '\x0B';
    905. 

  905.                         break;
    906. 

  906. 

  907.                     default:
    908. 

  908.                         if (isOctalDigit(ch)) {
    909. 

  909.                             code = '01234567'.indexOf(ch);
    910. 

  910. 

  911.                             // \0 is not octal escape sequence
    912. 

  912.                             if (code !== 0) {
    913. 

  913.                                 octal = true;
    914. 

  914.                             }
    915. 

  915. 

  916.                             if (index < length && isOctalDigit(source[index])) {
    917. 

  917.                                 octal = true;
    918. 

  918.                                 code = code * 8 + '01234567'.indexOf(source[index++]);
    919. 

  919. 

  920.                                 // 3 digits are only allowed when string starts
    921. 

  921.                                 // with 0, 1, 2, 3
    922. 

  922.                                 if ('0123'.indexOf(ch) >= 0 &&
    923. 

  923.                                         index < length &&
    924. 

  924.                                         isOctalDigit(source[index])) {
    925. 

  925.                                     code = code * 8 + '01234567'.indexOf(source[index++]);
    926. 

  926.                                 }
    927. 

  927.                             }
    928. 

  928.                             str += String.fromCharCode(code);
    929. 

  929.                         } else {
    930. 

  930.                             str += ch;
    931. 

  931.                         }
    932. 

  932.                         break;
    933. 

  933.                     }
    934. 

  934.                 } else {
    935. 

  935.                     ++lineNumber;
    936. 

  936.                     if (ch ===  '\r' && source[index] === '\n') {
    937. 

  937.                         ++index;
    938. 

  938.                     }
    939. 

  939.                 }
    940. 

  940.             } else if (isLineTerminator(ch)) {
    941. 

  941.                 break;
    942. 

  942.             } else {
    943. 

  943.                 str += ch;
    944. 

  944.             }
    945. 

  945.         }
    946. 

  946. 

  947.         if (quote !== '') {
    948. 

  948.             throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    949. 

  949.         }
    950. 

  950. 

  951.         return {
    952. 

  952.             type: Token.StringLiteral,
    953. 

  953.             value: str,
    954. 

  954.             octal: octal,
    955. 

  955.             lineNumber: lineNumber,
    956. 

  956.             lineStart: lineStart,
    957. 

  957.             range: [start, index]
    958. 

  958.         };
    959. 

  959.     }
    960. 

  960. 

  961.     function scanRegExp() {
    962. 

  962.         var str, ch, start, pattern, flags, value, classMarker = false, restore, terminated = false;
    963. 

  963. 

  964.         buffer = null;
    965. 

  965.         skipComment();
    966. 

  966. 

  967.         start = index;
    968. 

  968.         ch = source[index];
    969. 

  969.         assert(ch === '/', 'Regular expression literal must start with a slash');
    970. 

  970.         str = source[index++];
    971. 

  971. 

  972.         while (index < length) {
    973. 

  973.             ch = source[index++];
    974. 

  974.             str += ch;
    975. 

  975.             if (ch === '\\') {
    976. 

  976.                 ch = source[index++];
    977. 

  977.                 // ECMA-262 7.8.5
    978. 

  978.                 if (isLineTerminator(ch)) {
    979. 

  979.                     throwError({}, Messages.UnterminatedRegExp);
    980. 

  980.                 }
    981. 

  981.                 str += ch;
    982. 

  982.             } else if (classMarker) {
    983. 

  983.                 if (ch === ']') {
    984. 

  984.                     classMarker = false;
    985. 

  985.                 }
    986. 

  986.             } else {
    987. 

  987.                 if (ch === '/') {
    988. 

  988.                     terminated = true;
    989. 

  989.                     break;
    990. 

  990.                 } else if (ch === '[') {
    991. 

  991.                     classMarker = true;
    992. 

  992.                 } else if (isLineTerminator(ch)) {
    993. 

  993.                     throwError({}, Messages.UnterminatedRegExp);
    994. 

  994.                 }
    995. 

  995.             }
    996. 

  996.         }
    997. 

  997. 

  998.         if (!terminated) {
    999. 

  999.             throwError({}, Messages.UnterminatedRegExp);
    1000. 

  1000.         }
    1001. 

  1001. 

  1002.         // Exclude leading and trailing slash.
    1003. 

  1003.         pattern = str.substr(1, str.length - 2);
    1004. 

  1004. 

  1005.         flags = '';
    1006. 

  1006.         while (index < length) {
    1007. 

  1007.             ch = source[index];
    1008. 

  1008.             if (!isIdentifierPart(ch)) {
    1009. 

  1009.                 break;
    1010. 

  1010.             }
    1011. 

  1011. 

  1012.             ++index;
    1013. 

  1013.             if (ch === '\\' && index < length) {
    1014. 

  1014.                 ch = source[index];
    1015. 

  1015.                 if (ch === 'u') {
    1016. 

  1016.                     ++index;
    1017. 

  1017.                     restore = index;
    1018. 

  1018.                     ch = scanHexEscape('u');
    1019. 

  1019.                     if (ch) {
    1020. 

  1020.                         flags += ch;
    1021. 

  1021.                         str += '\\u';
    1022. 

  1022.                         for (; restore < index; ++restore) {
    1023. 

  1023.                             str += source[restore];
    1024. 

  1024.                         }
    1025. 

  1025.                     } else {
    1026. 

  1026.                         index = restore;
    1027. 

  1027.                         flags += 'u';
    1028. 

  1028.                         str += '\\u';
    1029. 

  1029.                     }
    1030. 

  1030.                 } else {
    1031. 

  1031.                     str += '\\';
    1032. 

  1032.                 }
    1033. 

  1033.             } else {
    1034. 

  1034.                 flags += ch;
    1035. 

  1035.                 str += ch;
    1036. 

  1036.             }
    1037. 

  1037.         }
    1038. 

  1038. 

  1039.         try {
    1040. 

  1040.             value = new RegExp(pattern, flags);
    1041. 

  1041.         } catch (e) {
    1042. 

  1042.             throwError({}, Messages.InvalidRegExp);
    1043. 

  1043.         }
    1044. 

  1044. 

  1045.         return {
    1046. 

  1046.             literal: str,
    1047. 

  1047.             value: value,
    1048. 

  1048.             range: [start, index]
    1049. 

  1049.         };
    1050. 

  1050.     }
    1051. 

  1051. 

  1052.     function isIdentifierName(token) {
    1053. 

  1053.         return token.type === Token.Identifier ||
    1054. 

  1054.             token.type === Token.Keyword ||
    1055. 

  1055.             token.type === Token.BooleanLiteral ||
    1056. 

  1056.             token.type === Token.NullLiteral;
    1057. 

  1057.     }
    1058. 

  1058. 

  1059.     function advance() {
    1060. 

  1060.         var ch, token;
    1061. 

  1061. 

  1062.         skipComment();
    1063. 

  1063. 

  1064.         if (index >= length) {
    1065. 

  1065.             return {
    1066. 

  1066.                 type: Token.EOF,
    1067. 

  1067.                 lineNumber: lineNumber,
    1068. 

  1068.                 lineStart: lineStart,
    1069. 

  1069.                 range: [index, index]
    1070. 

  1070.             };
    1071. 

  1071.         }
    1072. 

  1072. 

  1073.         token = scanPunctuator();
    1074. 

  1074.         if (typeof token !== 'undefined') {
    1075. 

  1075.             return token;
    1076. 

  1076.         }
    1077. 

  1077. 

  1078.         ch = source[index];
    1079. 

  1079. 

  1080.         if (ch === '\'' || ch === '"') {
    1081. 

  1081.             return scanStringLiteral();
    1082. 

  1082.         }
    1083. 

  1083. 

  1084.         if (ch === '.' || isDecimalDigit(ch)) {
    1085. 

  1085.             return scanNumericLiteral();
    1086. 

  1086.         }
    1087. 

  1087. 

  1088.         token = scanIdentifier();
    1089. 

  1089.         if (typeof token !== 'undefined') {
    1090. 

  1090.             return token;
    1091. 

  1091.         }
    1092. 

  1092. 

  1093.         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    1094. 

  1094.     }
    1095. 

  1095. 

  1096.     function lex() {
    1097. 

  1097.         var token;
    1098. 

  1098. 

  1099.         if (buffer) {
    1100. 

  1100.             index = buffer.range[1];
    1101. 

  1101.             lineNumber = buffer.lineNumber;
    1102. 

  1102.             lineStart = buffer.lineStart;
    1103. 

  1103.             token = buffer;
    1104. 

  1104.             buffer = null;
    1105. 

  1105.             return token;
    1106. 

  1106.         }
    1107. 

  1107. 

  1108.         buffer = null;
    1109. 

  1109.         return advance();
    1110. 

  1110.     }
    1111. 

  1111. 

  1112.     function lookahead() {
    1113. 

  1113.         var pos, line, start;
    1114. 

  1114. 

  1115.         if (buffer !== null) {
    1116. 

  1116.             return buffer;
    1117. 

  1117.         }
    1118. 

  1118. 

  1119.         pos = index;
    1120. 

  1120.         line = lineNumber;
    1121. 

  1121.         start = lineStart;
    1122. 

  1122.         buffer = advance();
    1123. 

  1123.         index = pos;
    1124. 

  1124.         lineNumber = line;
    1125. 

  1125.         lineStart = start;
    1126. 

  1126. 

  1127.         return buffer;
    1128. 

  1128.     }
    1129. 

  1129. 

  1130.     // Return true if there is a line terminator before the next token.
    1131. 

  1131. 

  1132.     function peekLineTerminator() {
    1133. 

  1133.         var pos, line, start, found;
    1134. 

  1134. 

  1135.         pos = index;
    1136. 

  1136.         line = lineNumber;
    1137. 

  1137.         start = lineStart;
    1138. 

  1138.         skipComment();
    1139. 

  1139.         found = lineNumber !== line;
    1140. 

  1140.         index = pos;
    1141. 

  1141.         lineNumber = line;
    1142. 

  1142.         lineStart = start;
    1143. 

  1143. 

  1144.         return found;
    1145. 

  1145.     }
    1146. 

  1146. 

  1147.     // Throw an exception
    1148. 

  1148. 

  1149.     function throwError(token, messageFormat) {
    1150. 

  1150.         var error,
    1151. 

  1151.             args = Array.prototype.slice.call(arguments, 2),
    1152. 

  1152.             msg = messageFormat.replace(
    1153. 

  1153.                 /%(\d)/g,
    1154. 

  1154.                 function (whole, index) {
    1155. 

  1155.                     return args[index] || '';
    1156. 

  1156.                 }
    1157. 

  1157.             );
    1158. 

  1158. 

  1159.         if (typeof token.lineNumber === 'number') {
    1160. 

  1160.             error = new Error('Line ' + token.lineNumber + ': ' + msg);
    1161. 

  1161.             error.index = token.range[0];
    1162. 

  1162.             error.lineNumber = token.lineNumber;
    1163. 

  1163.             error.column = token.range[0] - lineStart + 1;
    1164. 

  1164.         } else {
    1165. 

  1165.             error = new Error('Line ' + lineNumber + ': ' + msg);
    1166. 

  1166.             error.index = index;
    1167. 

  1167.             error.lineNumber = lineNumber;
    1168. 

  1168.             error.column = index - lineStart + 1;
    1169. 

  1169.         }
    1170. 

  1170. 

  1171.         throw error;
    1172. 

  1172.     }
    1173. 

  1173. 

  1174.     function throwErrorTolerant() {
    1175. 

  1175.         try {
    1176. 

  1176.             throwError.apply(null, arguments);
    1177. 

  1177.         } catch (e) {
    1178. 

  1178.             if (extra.errors) {
    1179. 

  1179.                 extra.errors.push(e);
    1180. 

  1180.             } else {
    1181. 

  1181.                 throw e;
    1182. 

  1182.             }
    1183. 

  1183.         }
    1184. 

  1184.     }
    1185. 

  1185. 

  1186. 

  1187.     // Throw an exception because of the token.
    1188. 

  1188. 

  1189.     function throwUnexpected(token) {
    1190. 

  1190.         if (token.type === Token.EOF) {
    1191. 

  1191.             throwError(token, Messages.UnexpectedEOS);
    1192. 

  1192.         }
    1193. 

  1193. 

  1194.         if (token.type === Token.NumericLiteral) {
    1195. 

  1195.             throwError(token, Messages.UnexpectedNumber);
    1196. 

  1196.         }
    1197. 

  1197. 

  1198.         if (token.type === Token.StringLiteral) {
    1199. 

  1199.             throwError(token, Messages.UnexpectedString);
    1200. 

  1200.         }
    1201. 

  1201. 

  1202.         if (token.type === Token.Identifier) {
    1203. 

  1203.             throwError(token, Messages.UnexpectedIdentifier);
    1204. 

  1204.         }
    1205. 

  1205. 

  1206.         if (token.type === Token.Keyword) {
    1207. 

  1207.             if (isFutureReservedWord(token.value)) {
    1208. 

  1208.                 throwError(token, Messages.UnexpectedReserved);
    1209. 

  1209.             } else if (strict && isStrictModeReservedWord(token.value)) {
    1210. 

  1210.                 throwErrorTolerant(token, Messages.StrictReservedWord);
    1211. 

  1211.                 return;
    1212. 

  1212.             }
    1213. 

  1213.             throwError(token, Messages.UnexpectedToken, token.value);
    1214. 

  1214.         }
    1215. 

  1215. 

  1216.         // BooleanLiteral, NullLiteral, or Punctuator.
    1217. 

  1217.         throwError(token, Messages.UnexpectedToken, token.value);
    1218. 

  1218.     }
    1219. 

  1219. 

  1220.     // Expect the next token to match the specified punctuator.
    1221. 

  1221.     // If not, an exception will be thrown.
    1222. 

  1222. 

  1223.     function expect(value) {
    1224. 

  1224.         var token = lex();
    1225. 

  1225.         if (token.type !== Token.Punctuator || token.value !== value) {
    1226. 

  1226.             throwUnexpected(token);
    1227. 

  1227.         }
    1228. 

  1228.     }
    1229. 

  1229. 

  1230.     // Expect the next token to match the specified keyword.
    1231. 

  1231.     // If not, an exception will be thrown.
    1232. 

  1232. 

  1233.     function expectKeyword(keyword) {
    1234. 

  1234.         var token = lex();
    1235. 

  1235.         if (token.type !== Token.Keyword || token.value !== keyword) {
    1236. 

  1236.             throwUnexpected(token);
    1237. 

  1237.         }
    1238. 

  1238.     }
    1239. 

  1239. 

  1240.     // Return true if the next token matches the specified punctuator.
    1241. 

  1241. 

  1242.     function match(value) {
    1243. 

  1243.         var token = lookahead();
    1244. 

  1244.         return token.type === Token.Punctuator && token.value === value;
    1245. 

  1245.     }
    1246. 

  1246. 

  1247.     // Return true if the next token matches the specified keyword
    1248. 

  1248. 

  1249.     function matchKeyword(keyword) {
    1250. 

  1250.         var token = lookahead();
    1251. 

  1251.         return token.type === Token.Keyword && token.value === keyword;
    1252. 

  1252.     }
    1253. 

  1253. 

  1254.     // Return true if the next token is an assignment operator
    1255. 

  1255. 

  1256.     function matchAssign() {
    1257. 

  1257.         var token = lookahead(),
    1258. 

  1258.             op = token.value;
    1259. 

  1259. 

  1260.         if (token.type !== Token.Punctuator) {
    1261. 

  1261.             return false;
    1262. 

  1262.         }
    1263. 

  1263.         return op === '=' ||
    1264. 

  1264.             op === '*=' ||
    1265. 

  1265.             op === '/=' ||
    1266. 

  1266.             op === '%=' ||
    1267. 

  1267.             op === '+=' ||
    1268. 

  1268.             op === '-=' ||
    1269. 

  1269.             op === '<<=' ||
    1270. 

  1270.             op === '>>=' ||
    1271. 

  1271.             op === '>>>=' ||
    1272. 

  1272.             op === '&=' ||
    1273. 

  1273.             op === '^=' ||
    1274. 

  1274.             op === '|=';
    1275. 

  1275.     }
    1276. 

  1276. 

  1277.     function consumeSemicolon() {
    1278. 

  1278.         var token, line;
    1279. 

  1279. 

  1280.         // Catch the very common case first.
    1281. 

  1281.         if (source[index] === ';') {
    1282. 

  1282.             lex();
    1283. 

  1283.             return;
    1284. 

  1284.         }
    1285. 

  1285. 

  1286.         line = lineNumber;
    1287. 

  1287.         skipComment();
    1288. 

  1288.         if (lineNumber !== line) {
    1289. 

  1289.             return;
    1290. 

  1290.         }
    1291. 

  1291. 

  1292.         if (match(';')) {
    1293. 

  1293.             lex();
    1294. 

  1294.             return;
    1295. 

  1295.         }
    1296. 

  1296. 

  1297.         token = lookahead();
    1298. 

  1298.         if (token.type !== Token.EOF && !match('}')) {
    1299. 

  1299.             throwUnexpected(token);
    1300. 

  1300.         }
    1301. 

  1301.     }
    1302. 

  1302. 

  1303.     // Return true if provided expression is LeftHandSideExpression
    1304. 

  1304. 

  1305.     function isLeftHandSide(expr) {
    1306. 

  1306.         return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression;
    1307. 

  1307.     }
    1308. 

  1308. 

  1309.     // 11.1.4 Array Initialiser
    1310. 

  1310. 

  1311.     function parseArrayInitialiser() {
    1312. 

  1312.         var elements = [];
    1313. 

  1313. 

  1314.         expect('[');
    1315. 

  1315. 

  1316.         while (!match(']')) {
    1317. 

  1317.             if (match(',')) {
    1318. 

  1318.                 lex();
    1319. 

  1319.                 elements.push(null);
    1320. 

  1320.             } else {
    1321. 

  1321.                 elements.push(parseAssignmentExpression());
    1322. 

  1322. 

  1323.                 if (!match(']')) {
    1324. 

  1324.                     expect(',');
    1325. 

  1325.                 }
    1326. 

  1326.             }
    1327. 

  1327.         }
    1328. 

  1328. 

  1329.         expect(']');
    1330. 

  1330. 

  1331.         return {
    1332. 

  1332.             type: Syntax.ArrayExpression,
    1333. 

  1333.             elements: elements
    1334. 

  1334.         };
    1335. 

  1335.     }
    1336. 

  1336. 

  1337.     // 11.1.5 Object Initialiser
    1338. 

  1338. 

  1339.     function parsePropertyFunction(param, first) {
    1340. 

  1340.         var previousStrict, body;
    1341. 

  1341. 

  1342.         previousStrict = strict;
    1343. 

  1343.         body = parseFunctionSourceElements();
    1344. 

  1344.         if (first && strict && isRestrictedWord(param[0].name)) {
    1345. 

  1345.             throwErrorTolerant(first, Messages.StrictParamName);
    1346. 

  1346.         }
    1347. 

  1347.         strict = previousStrict;
    1348. 

  1348. 

  1349.         return {
    1350. 

  1350.             type: Syntax.FunctionExpression,
    1351. 

  1351.             id: null,
    1352. 

  1352.             params: param,
    1353. 

  1353.             defaults: [],
    1354. 

  1354.             body: body,
    1355. 

  1355.             rest: null,
    1356. 

  1356.             generator: false,
    1357. 

  1357.             expression: false
    1358. 

  1358.         };
    1359. 

  1359.     }
    1360. 

  1360. 

  1361.     function parseObjectPropertyKey() {
    1362. 

  1362.         var token = lex();
    1363. 

  1363. 

  1364.         // Note: This function is called only from parseObjectProperty(), where
    1365. 

  1365.         // EOF and Punctuator tokens are already filtered out.
    1366. 

  1366. 

  1367.         if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) {
    1368. 

  1368.             if (strict && token.octal) {
    1369. 

  1369.                 throwErrorTolerant(token, Messages.StrictOctalLiteral);
    1370. 

  1370.             }
    1371. 

  1371.             return createLiteral(token);
    1372. 

  1372.         }
    1373. 

  1373. 

  1374.         return {
    1375. 

  1375.             type: Syntax.Identifier,
    1376. 

  1376.             name: token.value
    1377. 

  1377.         };
    1378. 

  1378.     }
    1379. 

  1379. 

  1380.     function parseObjectProperty() {
    1381. 

  1381.         var token, key, id, param;
    1382. 

  1382. 

  1383.         token = lookahead();
    1384. 

  1384. 

  1385.         if (token.type === Token.Identifier) {
    1386. 

  1386. 

  1387.             id = parseObjectPropertyKey();
    1388. 

  1388. 

  1389.             // Property Assignment: Getter and Setter.
    1390. 

  1390. 

  1391.             if (token.value === 'get' && !match(':')) {
    1392. 

  1392.                 key = parseObjectPropertyKey();
    1393. 

  1393.                 expect('(');
    1394. 

  1394.                 expect(')');
    1395. 

  1395.                 return {
    1396. 

  1396.                     type: Syntax.Property,
    1397. 

  1397.                     key: key,
    1398. 

  1398.                     value: parsePropertyFunction([]),
    1399. 

  1399.                     kind: 'get'
    1400. 

  1400.                 };
    1401. 

  1401.             } else if (token.value === 'set' && !match(':')) {
    1402. 

  1402.                 key = parseObjectPropertyKey();
    1403. 

  1403.                 expect('(');
    1404. 

  1404.                 token = lookahead();
    1405. 

  1405.                 if (token.type !== Token.Identifier) {
    1406. 

  1406.                     expect(')');
    1407. 

  1407.                     throwErrorTolerant(token, Messages.UnexpectedToken, token.value);
    1408. 

  1408.                     return {
    1409. 

  1409.                         type: Syntax.Property,
    1410. 

  1410.                         key: key,
    1411. 

  1411.                         value: parsePropertyFunction([]),
    1412. 

  1412.                         kind: 'set'
    1413. 

  1413.                     };
    1414. 

  1414.                 } else {
    1415. 

  1415.                     param = [ parseVariableIdentifier() ];
    1416. 

  1416.                     expect(')');
    1417. 

  1417.                     return {
    1418. 

  1418.                         type: Syntax.Property,
    1419. 

  1419.                         key: key,
    1420. 

  1420.                         value: parsePropertyFunction(param, token),
    1421. 

  1421.                         kind: 'set'
    1422. 

  1422.                     };
    1423. 

  1423.                 }
    1424. 

  1424.             } else {
    1425. 

  1425.                 expect(':');
    1426. 

  1426.                 return {
    1427. 

  1427.                     type: Syntax.Property,
    1428. 

  1428.                     key: id,
    1429. 

  1429.                     value: parseAssignmentExpression(),
    1430. 

  1430.                     kind: 'init'
    1431. 

  1431.                 };
    1432. 

  1432.             }
    1433. 

  1433.         } else if (token.type === Token.EOF || token.type === Token.Punctuator) {
    1434. 

  1434.             throwUnexpected(token);
    1435. 

  1435.         } else {
    1436. 

  1436.             key = parseObjectPropertyKey();
    1437. 

  1437.             expect(':');
    1438. 

  1438.             return {
    1439. 

  1439.                 type: Syntax.Property,
    1440. 

  1440.                 key: key,
    1441. 

  1441.                 value: parseAssignmentExpression(),
    1442. 

  1442.                 kind: 'init'
    1443. 

  1443.             };
    1444. 

  1444.         }
    1445. 

  1445.     }
    1446. 

  1446. 

  1447.     function parseObjectInitialiser() {
    1448. 

  1448.         var properties = [], property, name, kind, map = {}, toString = String;
    1449. 

  1449. 

  1450.         expect('{');
    1451. 

  1451. 

  1452.         while (!match('}')) {
    1453. 

  1453.             property = parseObjectProperty();
    1454. 

  1454. 

  1455.             if (property.key.type === Syntax.Identifier) {
    1456. 

  1456.                 name = property.key.name;
    1457. 

  1457.             } else {
    1458. 

  1458.                 name = toString(property.key.value);
    1459. 

  1459.             }
    1460. 

  1460.             kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set;
    1461. 

  1461.             if (Object.prototype.hasOwnProperty.call(map, name)) {
    1462. 

  1462.                 if (map[name] === PropertyKind.Data) {
    1463. 

  1463.                     if (strict && kind === PropertyKind.Data) {
    1464. 

  1464.                         throwErrorTolerant({}, Messages.StrictDuplicateProperty);
    1465. 

  1465.                     } else if (kind !== PropertyKind.Data) {
    1466. 

  1466.                         throwErrorTolerant({}, Messages.AccessorDataProperty);
    1467. 

  1467.                     }
    1468. 

  1468.                 } else {
    1469. 

  1469.                     if (kind === PropertyKind.Data) {
    1470. 

  1470.                         throwErrorTolerant({}, Messages.AccessorDataProperty);
    1471. 

  1471.                     } else if (map[name] & kind) {
    1472. 

  1472.                         throwErrorTolerant({}, Messages.AccessorGetSet);
    1473. 

  1473.                     }
    1474. 

  1474.                 }
    1475. 

  1475.                 map[name] |= kind;
    1476. 

  1476.             } else {
    1477. 

  1477.                 map[name] = kind;
    1478. 

  1478.             }
    1479. 

  1479. 

  1480.             properties.push(property);
    1481. 

  1481. 

  1482.             if (!match('}')) {
    1483. 

  1483.                 expect(',');
    1484. 

  1484.             }
    1485. 

  1485.         }
    1486. 

  1486. 

  1487.         expect('}');
    1488. 

  1488. 

  1489.         return {
    1490. 

  1490.             type: Syntax.ObjectExpression,
    1491. 

  1491.             properties: properties
    1492. 

  1492.         };
    1493. 

  1493.     }
    1494. 

  1494. 

  1495.     // 11.1.6 The Grouping Operator
    1496. 

  1496. 

  1497.     function parseGroupExpression() {
    1498. 

  1498.         var expr;
    1499. 

  1499. 

  1500.         expect('(');
    1501. 

  1501. 

  1502.         expr = parseExpression();
    1503. 

  1503. 

  1504.         expect(')');
    1505. 

  1505. 

  1506.         return expr;
    1507. 

  1507.     }
    1508. 

  1508. 

  1509. 

  1510.     // 11.1 Primary Expressions
    1511. 

  1511. 

  1512.     function parsePrimaryExpression() {
    1513. 

  1513.         var token = lookahead(),
    1514. 

  1514.             type = token.type;
    1515. 

  1515. 

  1516.         if (type === Token.Identifier) {
    1517. 

  1517.             return {
    1518. 

  1518.                 type: Syntax.Identifier,
    1519. 

  1519.                 name: lex().value
    1520. 

  1520.             };
    1521. 

  1521.         }
    1522. 

  1522. 

  1523.         if (type === Token.StringLiteral || type === Token.NumericLiteral) {
    1524. 

  1524.             if (strict && token.octal) {
    1525. 

  1525.                 throwErrorTolerant(token, Messages.StrictOctalLiteral);
    1526. 

  1526.             }
    1527. 

  1527.             return createLiteral(lex());
    1528. 

  1528.         }
    1529. 

  1529. 

  1530.         if (type === Token.Keyword) {
    1531. 

  1531.             if (matchKeyword('this')) {
    1532. 

  1532.                 lex();
    1533. 

  1533.                 return {
    1534. 

  1534.                     type: Syntax.ThisExpression
    1535. 

  1535.                 };
    1536. 

  1536.             }
    1537. 

  1537. 

  1538.             if (matchKeyword('function')) {
    1539. 

  1539.                 return parseFunctionExpression();
    1540. 

  1540.             }
    1541. 

  1541.         }
    1542. 

  1542. 

  1543.         if (type === Token.BooleanLiteral) {
    1544. 

  1544.             lex();
    1545. 

  1545.             token.value = (token.value === 'true');
    1546. 

  1546.             return createLiteral(token);
    1547. 

  1547.         }
    1548. 

  1548. 

  1549.         if (type === Token.NullLiteral) {
    1550. 

  1550.             lex();
    1551. 

  1551.             token.value = null;
    1552. 

  1552.             return createLiteral(token);
    1553. 

  1553.         }
    1554. 

  1554. 

  1555.         if (match('[')) {
    1556. 

  1556.             return parseArrayInitialiser();
    1557. 

  1557.         }
    1558. 

  1558. 

  1559.         if (match('{')) {
    1560. 

  1560.             return parseObjectInitialiser();
    1561. 

  1561.         }
    1562. 

  1562. 

  1563.         if (match('(')) {
    1564. 

  1564.             return parseGroupExpression();
    1565. 

  1565.         }
    1566. 

  1566. 

  1567.         if (match('/') || match('/=')) {
    1568. 

  1568.             return createLiteral(scanRegExp());
    1569. 

  1569.         }
    1570. 

  1570. 

  1571.         return throwUnexpected(lex());
    1572. 

  1572.     }
    1573. 

  1573. 

  1574.     // 11.2 Left-Hand-Side Expressions
    1575. 

  1575. 

  1576.     function parseArguments() {
    1577. 

  1577.         var args = [];
    1578. 

  1578. 

  1579.         expect('(');
    1580. 

  1580. 

  1581.         if (!match(')')) {
    1582. 

  1582.             while (index < length) {
    1583. 

  1583.                 args.push(parseAssignmentExpression());
    1584. 

  1584.                 if (match(')')) {
    1585. 

  1585.                     break;
    1586. 

  1586.                 }
    1587. 

  1587.                 expect(',');
    1588. 

  1588.             }
    1589. 

  1589.         }
    1590. 

  1590. 

  1591.         expect(')');
    1592. 

  1592. 

  1593.         return args;
    1594. 

  1594.     }
    1595. 

  1595. 

  1596.     function parseNonComputedProperty() {
    1597. 

  1597.         var token = lex();
    1598. 

  1598. 

  1599.         if (!isIdentifierName(token)) {
    1600. 

  1600.             throwUnexpected(token);
    1601. 

  1601.         }
    1602. 

  1602. 

  1603.         return {
    1604. 

  1604.             type: Syntax.Identifier,
    1605. 

  1605.             name: token.value
    1606. 

  1606.         };
    1607. 

  1607.     }
    1608. 

  1608. 

  1609.     function parseNonComputedMember() {
    1610. 

  1610.         expect('.');
    1611. 

  1611. 

  1612.         return parseNonComputedProperty();
    1613. 

  1613.     }
    1614. 

  1614. 

  1615.     function parseComputedMember() {
    1616. 

  1616.         var expr;
    1617. 

  1617. 

  1618.         expect('[');
    1619. 

  1619. 

  1620.         expr = parseExpression();
    1621. 

  1621. 

  1622.         expect(']');
    1623. 

  1623. 

  1624.         return expr;
    1625. 

  1625.     }
    1626. 

  1626. 

  1627.     function parseNewExpression() {
    1628. 

  1628.         var expr;
    1629. 

  1629. 

  1630.         expectKeyword('new');
    1631. 

  1631. 

  1632.         expr = {
    1633. 

  1633.             type: Syntax.NewExpression,
    1634. 

  1634.             callee: parseLeftHandSideExpression(),
    1635. 

  1635.             'arguments': []
    1636. 

  1636.         };
    1637. 

  1637. 

  1638.         if (match('(')) {
    1639. 

  1639.             expr['arguments'] = parseArguments();
    1640. 

  1640.         }
    1641. 

  1641. 

  1642.         return expr;
    1643. 

  1643.     }
    1644. 

  1644. 

  1645.     function parseLeftHandSideExpressionAllowCall() {
    1646. 

  1646.         var expr;
    1647. 

  1647. 

  1648.         expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
    1649. 

  1649. 

  1650.         while (match('.') || match('[') || match('(')) {
    1651. 

  1651.             if (match('(')) {
    1652. 

  1652.                 expr = {
    1653. 

  1653.                     type: Syntax.CallExpression,
    1654. 

  1654.                     callee: expr,
    1655. 

  1655.                     'arguments': parseArguments()
    1656. 

  1656.                 };
    1657. 

  1657.             } else if (match('[')) {
    1658. 

  1658.                 expr = {
    1659. 

  1659.                     type: Syntax.MemberExpression,
    1660. 

  1660.                     computed: true,
    1661. 

  1661.                     object: expr,
    1662. 

  1662.                     property: parseComputedMember()
    1663. 

  1663.                 };
    1664. 

  1664.             } else {
    1665. 

  1665.                 expr = {
    1666. 

  1666.                     type: Syntax.MemberExpression,
    1667. 

  1667.                     computed: false,
    1668. 

  1668.                     object: expr,
    1669. 

  1669.                     property: parseNonComputedMember()
    1670. 

  1670.                 };
    1671. 

  1671.             }
    1672. 

  1672.         }
    1673. 

  1673. 

  1674.         return expr;
    1675. 

  1675.     }
    1676. 

  1676. 

  1677. 

  1678.     function parseLeftHandSideExpression() {
    1679. 

  1679.         var expr;
    1680. 

  1680. 

  1681.         expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
    1682. 

  1682. 

  1683.         while (match('.') || match('[')) {
    1684. 

  1684.             if (match('[')) {
    1685. 

  1685.                 expr = {
    1686. 

  1686.                     type: Syntax.MemberExpression,
    1687. 

  1687.                     computed: true,
    1688. 

  1688.                     object: expr,
    1689. 

  1689.                     property: parseComputedMember()
    1690. 

  1690.                 };
    1691. 

  1691.             } else {
    1692. 

  1692.                 expr = {
    1693. 

  1693.                     type: Syntax.MemberExpression,
    1694. 

  1694.                     computed: false,
    1695. 

  1695.                     object: expr,
    1696. 

  1696.                     property: parseNonComputedMember()
    1697. 

  1697.                 };
    1698. 

  1698.             }
    1699. 

  1699.         }
    1700. 

  1700. 

  1701.         return expr;
    1702. 

  1702.     }
    1703. 

  1703. 

  1704.     // 11.3 Postfix Expressions
    1705. 

  1705. 

  1706.     function parsePostfixExpression() {
    1707. 

  1707.         var expr = parseLeftHandSideExpressionAllowCall(), token;
    1708. 

  1708. 

  1709.         token = lookahead();
    1710. 

  1710.         if (token.type !== Token.Punctuator) {
    1711. 

  1711.             return expr;
    1712. 

  1712.         }
    1713. 

  1713. 

  1714.         if ((match('++') || match('--')) && !peekLineTerminator()) {
    1715. 

  1715.             // 11.3.1, 11.3.2
    1716. 

  1716.             if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
    1717. 

  1717.                 throwErrorTolerant({}, Messages.StrictLHSPostfix);
    1718. 

  1718.             }
    1719. 

  1719.             if (!isLeftHandSide(expr)) {
    1720. 

  1720.                 throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
    1721. 

  1721.             }
    1722. 

  1722. 

  1723.             expr = {
    1724. 

  1724.                 type: Syntax.UpdateExpression,
    1725. 

  1725.                 operator: lex().value,
    1726. 

  1726.                 argument: expr,
    1727. 

  1727.                 prefix: false
    1728. 

  1728.             };
    1729. 

  1729.         }
    1730. 

  1730. 

  1731.         return expr;
    1732. 

  1732.     }
    1733. 

  1733. 

  1734.     // 11.4 Unary Operators
    1735. 

  1735. 

  1736.     function parseUnaryExpression() {
    1737. 

  1737.         var token, expr;
    1738. 

  1738. 

  1739.         token = lookahead();
    1740. 

  1740.         if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {
    1741. 

  1741.             return parsePostfixExpression();
    1742. 

  1742.         }
    1743. 

  1743. 

  1744.         if (match('++') || match('--')) {
    1745. 

  1745.             token = lex();
    1746. 

  1746.             expr = parseUnaryExpression();
    1747. 

  1747.             // 11.4.4, 11.4.5
    1748. 

  1748.             if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
    1749. 

  1749.                 throwErrorTolerant({}, Messages.StrictLHSPrefix);
    1750. 

  1750.             }
    1751. 

  1751. 

  1752.             if (!isLeftHandSide(expr)) {
    1753. 

  1753.                 throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
    1754. 

  1754.             }
    1755. 

  1755. 

  1756.             expr = {
    1757. 

  1757.                 type: Syntax.UpdateExpression,
    1758. 

  1758.                 operator: token.value,
    1759. 

  1759.                 argument: expr,
    1760. 

  1760.                 prefix: true
    1761. 

  1761.             };
    1762. 

  1762.             return expr;
    1763. 

  1763.         }
    1764. 

  1764. 

  1765.         if (match('+') || match('-') || match('~') || match('!')) {
    1766. 

  1766.             expr = {
    1767. 

  1767.                 type: Syntax.UnaryExpression,
    1768. 

  1768.                 operator: lex().value,
    1769. 

  1769.                 argument: parseUnaryExpression(),
    1770. 

  1770.                 prefix: true
    1771. 

  1771.             };
    1772. 

  1772.             return expr;
    1773. 

  1773.         }
    1774. 

  1774. 

  1775.         if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) {
    1776. 

  1776.             expr = {
    1777. 

  1777.                 type: Syntax.UnaryExpression,
    1778. 

  1778.                 operator: lex().value,
    1779. 

  1779.                 argument: parseUnaryExpression(),
    1780. 

  1780.                 prefix: true
    1781. 

  1781.             };
    1782. 

  1782.             if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) {
    1783. 

  1783.                 throwErrorTolerant({}, Messages.StrictDelete);
    1784. 

  1784.             }
    1785. 

  1785.             return expr;
    1786. 

  1786.         }
    1787. 

  1787. 

  1788.         return parsePostfixExpression();
    1789. 

  1789.     }
    1790. 

  1790. 

  1791.     // 11.5 Multiplicative Operators
    1792. 

  1792. 

  1793.     function parseMultiplicativeExpression() {
    1794. 

  1794.         var expr = parseUnaryExpression();
    1795. 

  1795. 

  1796.         while (match('*') || match('/') || match('%')) {
    1797. 

  1797.             expr = {
    1798. 

  1798.                 type: Syntax.BinaryExpression,
    1799. 

  1799.                 operator: lex().value,
    1800. 

  1800.                 left: expr,
    1801. 

  1801.                 right: parseUnaryExpression()
    1802. 

  1802.             };
    1803. 

  1803.         }
    1804. 

  1804. 

  1805.         return expr;
    1806. 

  1806.     }
    1807. 

  1807. 

  1808.     // 11.6 Additive Operators
    1809. 

  1809. 

  1810.     function parseAdditiveExpression() {
    1811. 

  1811.         var expr = parseMultiplicativeExpression();
    1812. 

  1812. 

  1813.         while (match('+') || match('-')) {
    1814. 

  1814.             expr = {
    1815. 

  1815.                 type: Syntax.BinaryExpression,
    1816. 

  1816.                 operator: lex().value,
    1817. 

  1817.                 left: expr,
    1818. 

  1818.                 right: parseMultiplicativeExpression()
    1819. 

  1819.             };
    1820. 

  1820.         }
    1821. 

  1821. 

  1822.         return expr;
    1823. 

  1823.     }
    1824. 

  1824. 

  1825.     // 11.7 Bitwise Shift Operators
    1826. 

  1826. 

  1827.     function parseShiftExpression() {
    1828. 

  1828.         var expr = parseAdditiveExpression();
    1829. 

  1829. 

  1830.         while (match('<<') || match('>>') || match('>>>')) {
    1831. 

  1831.             expr = {
    1832. 

  1832.                 type: Syntax.BinaryExpression,
    1833. 

  1833.                 operator: lex().value,
    1834. 

  1834.                 left: expr,
    1835. 

  1835.                 right: parseAdditiveExpression()
    1836. 

  1836.             };
    1837. 

  1837.         }
    1838. 

  1838. 

  1839.         return expr;
    1840. 

  1840.     }
    1841. 

  1841.     // 11.8 Relational Operators
    1842. 

  1842. 

  1843.     function parseRelationalExpression() {
    1844. 

  1844.         var expr, previousAllowIn;
    1845. 

  1845. 

  1846.         previousAllowIn = state.allowIn;
    1847. 

  1847.         state.allowIn = true;
    1848. 

  1848. 

  1849.         expr = parseShiftExpression();
    1850. 

  1850. 

  1851.         while (match('<') || match('>') || match('<=') || match('>=') || (previousAllowIn && matchKeyword('in')) || matchKeyword('instanceof')) {
    1852. 

  1852.             expr = {
    1853. 

  1853.                 type: Syntax.BinaryExpression,
    1854. 

  1854.                 operator: lex().value,
    1855. 

  1855.                 left: expr,
    1856. 

  1856.                 right: parseShiftExpression()
    1857. 

  1857.             };
    1858. 

  1858.         }
    1859. 

  1859. 

  1860.         state.allowIn = previousAllowIn;
    1861. 

  1861.         return expr;
    1862. 

  1862.     }
    1863. 

  1863. 

  1864.     // 11.9 Equality Operators
    1865. 

  1865. 

  1866.     function parseEqualityExpression() {
    1867. 

  1867.         var expr = parseRelationalExpression();
    1868. 

  1868. 

  1869.         while (match('==') || match('!=') || match('===') || match('!==')) {
    1870. 

  1870.             expr = {
    1871. 

  1871.                 type: Syntax.BinaryExpression,
    1872. 

  1872.                 operator: lex().value,
    1873. 

  1873.                 left: expr,
    1874. 

  1874.                 right: parseRelationalExpression()
    1875. 

  1875.             };
    1876. 

  1876.         }
    1877. 

  1877. 

  1878.         return expr;
    1879. 

  1879.     }
    1880. 

  1880. 

  1881.     // 11.10 Binary Bitwise Operators
    1882. 

  1882. 

  1883.     function parseBitwiseANDExpression() {
    1884. 

  1884.         var expr = parseEqualityExpression();
    1885. 

  1885. 

  1886.         while (match('&')) {
    1887. 

  1887.             lex();
    1888. 

  1888.             expr = {
    1889. 

  1889.                 type: Syntax.BinaryExpression,
    1890. 

  1890.                 operator: '&',
    1891. 

  1891.                 left: expr,
    1892. 

  1892.                 right: parseEqualityExpression()
    1893. 

  1893.             };
    1894. 

  1894.         }
    1895. 

  1895. 

  1896.         return expr;
    1897. 

  1897.     }
    1898. 

  1898. 

  1899.     function parseBitwiseXORExpression() {
    1900. 

  1900.         var expr = parseBitwiseANDExpression();
    1901. 

  1901. 

  1902.         while (match('^')) {
    1903. 

  1903.             lex();
    1904. 

  1904.             expr = {
    1905. 

  1905.                 type: Syntax.BinaryExpression,
    1906. 

  1906.                 operator: '^',
    1907. 

  1907.                 left: expr,
    1908. 

  1908.                 right: parseBitwiseANDExpression()
    1909. 

  1909.             };
    1910. 

  1910.         }
    1911. 

  1911. 

  1912.         return expr;
    1913. 

  1913.     }
    1914. 

  1914. 

  1915.     function parseBitwiseORExpression() {
    1916. 

  1916.         var expr = parseBitwiseXORExpression();
    1917. 

  1917. 

  1918.         while (match('|')) {
    1919. 

  1919.             lex();
    1920. 

  1920.             expr = {
    1921. 

  1921.                 type: Syntax.BinaryExpression,
    1922. 

  1922.                 operator: '|',
    1923. 

  1923.                 left: expr,
    1924. 

  1924.                 right: parseBitwiseXORExpression()
    1925. 

  1925.             };
    1926. 

  1926.         }
    1927. 

  1927. 

  1928.         return expr;
    1929. 

  1929.     }
    1930. 

  1930. 

  1931.     // 11.11 Binary Logical Operators
    1932. 

  1932. 

  1933.     function parseLogicalANDExpression() {
    1934. 

  1934.         var expr = parseBitwiseORExpression();
    1935. 

  1935. 

  1936.         while (match('&&')) {
    1937. 

  1937.             lex();
    1938. 

  1938.             expr = {
    1939. 

  1939.                 type: Syntax.LogicalExpression,
    1940. 

  1940.                 operator: '&&',
    1941. 

  1941.                 left: expr,
    1942. 

  1942.                 right: parseBitwiseORExpression()
    1943. 

  1943.             };
    1944. 

  1944.         }
    1945. 

  1945. 

  1946.         return expr;
    1947. 

  1947.     }
    1948. 

  1948. 

  1949.     function parseLogicalORExpression() {
    1950. 

  1950.         var expr = parseLogicalANDExpression();
    1951. 

  1951. 

  1952.         while (match('||')) {
    1953. 

  1953.             lex();
    1954. 

  1954.             expr = {
    1955. 

  1955.                 type: Syntax.LogicalExpression,
    1956. 

  1956.                 operator: '||',
    1957. 

  1957.                 left: expr,
    1958. 

  1958.                 right: parseLogicalANDExpression()
    1959. 

  1959.             };
    1960. 

  1960.         }
    1961. 

  1961. 

  1962.         return expr;
    1963. 

  1963.     }
    1964. 

  1964. 

  1965.     // 11.12 Conditional Operator
    1966. 

  1966. 

  1967.     function parseConditionalExpression() {
    1968. 

  1968.         var expr, previousAllowIn, consequent;
    1969. 

  1969. 

  1970.         expr = parseLogicalORExpression();
    1971. 

  1971. 

  1972.         if (match('?')) {
    1973. 

  1973.             lex();
    1974. 

  1974.             previousAllowIn = state.allowIn;
    1975. 

  1975.             state.allowIn = true;
    1976. 

  1976.             consequent = parseAssignmentExpression();
    1977. 

  1977.             state.allowIn = previousAllowIn;
    1978. 

  1978.             expect(':');
    1979. 

  1979. 

  1980.             expr = {
    1981. 

  1981.                 type: Syntax.ConditionalExpression,
    1982. 

  1982.                 test: expr,
    1983. 

  1983.                 consequent: consequent,
    1984. 

  1984.                 alternate: parseAssignmentExpression()
    1985. 

  1985.             };
    1986. 

  1986.         }
    1987. 

  1987. 

  1988.         return expr;
    1989. 

  1989.     }
    1990. 

  1990. 

  1991.     // 11.13 Assignment Operators
    1992. 

  1992. 

  1993.     function parseAssignmentExpression() {
    1994. 

  1994.         var token, expr;
    1995. 

  1995. 

  1996.         token = lookahead();
    1997. 

  1997.         expr = parseConditionalExpression();
    1998. 

  1998. 

  1999.         if (matchAssign()) {
    2000. 

  2000.             // LeftHandSideExpression
    2001. 

  2001.             if (!isLeftHandSide(expr)) {
    2002. 

  2002.                 throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
    2003. 

  2003.             }
    2004. 

  2004. 

  2005.             // 11.13.1
    2006. 

  2006.             if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
    2007. 

  2007.                 throwErrorTolerant(token, Messages.StrictLHSAssignment);
    2008. 

  2008.             }
    2009. 

  2009. 

  2010.             expr = {
    2011. 

  2011.                 type: Syntax.AssignmentExpression,
    2012. 

  2012.                 operator: lex().value,
    2013. 

  2013.                 left: expr,
    2014. 

  2014.                 right: parseAssignmentExpression()
    2015. 

  2015.             };
    2016. 

  2016.         }
    2017. 

  2017. 

  2018.         return expr;
    2019. 

  2019.     }
    2020. 

  2020. 

  2021.     // 11.14 Comma Operator
    2022. 

  2022. 

  2023.     function parseExpression() {
    2024. 

  2024.         var expr = parseAssignmentExpression();
    2025. 

  2025. 

  2026.         if (match(',')) {
    2027. 

  2027.             expr = {
    2028. 

  2028.                 type: Syntax.SequenceExpression,
    2029. 

  2029.                 expressions: [ expr ]
    2030. 

  2030.             };
    2031. 

  2031. 

  2032.             while (index < length) {
    2033. 

  2033.                 if (!match(',')) {
    2034. 

  2034.                     break;
    2035. 

  2035.                 }
    2036. 

  2036.                 lex();
    2037. 

  2037.                 expr.expressions.push(parseAssignmentExpression());
    2038. 

  2038.             }
    2039. 

  2039. 

  2040.         }
    2041. 

  2041.         return expr;
    2042. 

  2042.     }
    2043. 

  2043. 

  2044.     // 12.1 Block
    2045. 

  2045. 

  2046.     function parseStatementList() {
    2047. 

  2047.         var list = [],
    2048. 

  2048.             statement;
    2049. 

  2049. 

  2050.         while (index < length) {
    2051. 

  2051.             if (match('}')) {
    2052. 

  2052.                 break;
    2053. 

  2053.             }
    2054. 

  2054.             statement = parseSourceElement();
    2055. 

  2055.             if (typeof statement === 'undefined') {
    2056. 

  2056.                 break;
    2057. 

  2057.             }
    2058. 

  2058.             list.push(statement);
    2059. 

  2059.         }
    2060. 

  2060. 

  2061.         return list;
    2062. 

  2062.     }
    2063. 

  2063. 

  2064.     function parseBlock() {
    2065. 

  2065.         var block;
    2066. 

  2066. 

  2067.         expect('{');
    2068. 

  2068. 

  2069.         block = parseStatementList();
    2070. 

  2070. 

  2071.         expect('}');
    2072. 

  2072. 

  2073.         return {
    2074. 

  2074.             type: Syntax.BlockStatement,
    2075. 

  2075.             body: block
    2076. 

  2076.         };
    2077. 

  2077.     }
    2078. 

  2078. 

  2079.     // 12.2 Variable Statement
    2080. 

  2080. 

  2081.     function parseVariableIdentifier() {
    2082. 

  2082.         var token = lex();
    2083. 

  2083. 

  2084.         if (token.type !== Token.Identifier) {
    2085. 

  2085.             throwUnexpected(token);
    2086. 

  2086.         }
    2087. 

  2087. 

  2088.         return {
    2089. 

  2089.             type: Syntax.Identifier,
    2090. 

  2090.             name: token.value
    2091. 

  2091.         };
    2092. 

  2092.     }
    2093. 

  2093. 

  2094.     function parseVariableDeclaration(kind) {
    2095. 

  2095.         var id = parseVariableIdentifier(),
    2096. 

  2096.             init = null;
    2097. 

  2097. 

  2098.         // 12.2.1
    2099. 

  2099.         if (strict && isRestrictedWord(id.name)) {
    2100. 

  2100.             throwErrorTolerant({}, Messages.StrictVarName);
    2101. 

  2101.         }
    2102. 

  2102. 

  2103.         if (kind === 'const') {
    2104. 

  2104.             expect('=');
    2105. 

  2105.             init = parseAssignmentExpression();
    2106. 

  2106.         } else if (match('=')) {
    2107. 

  2107.             lex();
    2108. 

  2108.             init = parseAssignmentExpression();
    2109. 

  2109.         }
    2110. 

  2110. 

  2111.         return {
    2112. 

  2112.             type: Syntax.VariableDeclarator,
    2113. 

  2113.             id: id,
    2114. 

  2114.             init: init
    2115. 

  2115.         };
    2116. 

  2116.     }
    2117. 

  2117. 

  2118.     function parseVariableDeclarationList(kind) {
    2119. 

  2119.         var list = [];
    2120. 

  2120. 

  2121.         do {
    2122. 

  2122.             list.push(parseVariableDeclaration(kind));
    2123. 

  2123.             if (!match(',')) {
    2124. 

  2124.                 break;
    2125. 

  2125.             }
    2126. 

  2126.             lex();
    2127. 

  2127.         } while (index < length);
    2128. 

  2128. 

  2129.         return list;
    2130. 

  2130.     }
    2131. 

  2131. 

  2132.     function parseVariableStatement() {
    2133. 

  2133.         var declarations;
    2134. 

  2134. 

  2135.         expectKeyword('var');
    2136. 

  2136. 

  2137.         declarations = parseVariableDeclarationList();
    2138. 

  2138. 

  2139.         consumeSemicolon();
    2140. 

  2140. 

  2141.         return {
    2142. 

  2142.             type: Syntax.VariableDeclaration,
    2143. 

  2143.             declarations: declarations,
    2144. 

  2144.             kind: 'var'
    2145. 

  2145.         };
    2146. 

  2146.     }
    2147. 

  2147. 

  2148.     // kind may be `const` or `let`
    2149. 

  2149.     // Both are experimental and not in the specification yet.
    2150. 

  2150.     // see http://wiki.ecmascript.org/doku.php?id=harmony:const
    2151. 

  2151.     // and http://wiki.ecmascript.org/doku.php?id=harmony:let
    2152. 

  2152.     function parseConstLetDeclaration(kind) {
    2153. 

  2153.         var declarations;
    2154. 

  2154. 

  2155.         expectKeyword(kind);
    2156. 

  2156. 

  2157.         declarations = parseVariableDeclarationList(kind);
    2158. 

  2158. 

  2159.         consumeSemicolon();
    2160. 

  2160. 

  2161.         return {
    2162. 

  2162.             type: Syntax.VariableDeclaration,
    2163. 

  2163.             declarations: declarations,
    2164. 

  2164.             kind: kind
    2165. 

  2165.         };
    2166. 

  2166.     }
    2167. 

  2167. 

  2168.     // 12.3 Empty Statement
    2169. 

  2169. 

  2170.     function parseEmptyStatement() {
    2171. 

  2171.         expect(';');
    2172. 

  2172. 

  2173.         return {
    2174. 

  2174.             type: Syntax.EmptyStatement
    2175. 

  2175.         };
    2176. 

  2176.     }
    2177. 

  2177. 

  2178.     // 12.4 Expression Statement
    2179. 

  2179. 

  2180.     function parseExpressionStatement() {
    2181. 

  2181.         var expr = parseExpression();
    2182. 

  2182. 

  2183.         consumeSemicolon();
    2184. 

  2184. 

  2185.         return {
    2186. 

  2186.             type: Syntax.ExpressionStatement,
    2187. 

  2187.             expression: expr
    2188. 

  2188.         };
    2189. 

  2189.     }
    2190. 

  2190. 

  2191.     // 12.5 If statement
    2192. 

  2192. 

  2193.     function parseIfStatement() {
    2194. 

  2194.         var test, consequent, alternate;
    2195. 

  2195. 

  2196.         expectKeyword('if');
    2197. 

  2197. 

  2198.         expect('(');
    2199. 

  2199. 

  2200.         test = parseExpression();
    2201. 

  2201. 

  2202.         expect(')');
    2203. 

  2203. 

  2204.         consequent = parseStatement();
    2205. 

  2205. 

  2206.         if (matchKeyword('else')) {
    2207. 

  2207.             lex();
    2208. 

  2208.             alternate = parseStatement();
    2209. 

  2209.         } else {
    2210. 

  2210.             alternate = null;
    2211. 

  2211.         }
    2212. 

  2212. 

  2213.         return {
    2214. 

  2214.             type: Syntax.IfStatement,
    2215. 

  2215.             test: test,
    2216. 

  2216.             consequent: consequent,
    2217. 

  2217.             alternate: alternate
    2218. 

  2218.         };
    2219. 

  2219.     }
    2220. 

  2220. 

  2221.     // 12.6 Iteration Statements
    2222. 

  2222. 

  2223.     function parseDoWhileStatement() {
    2224. 

  2224.         var body, test, oldInIteration;
    2225. 

  2225. 

  2226.         expectKeyword('do');
    2227. 

  2227. 

  2228.         oldInIteration = state.inIteration;
    2229. 

  2229.         state.inIteration = true;
    2230. 

  2230. 

  2231.         body = parseStatement();
    2232. 

  2232. 

  2233.         state.inIteration = oldInIteration;
    2234. 

  2234. 

  2235.         expectKeyword('while');
    2236. 

  2236. 

  2237.         expect('(');
    2238. 

  2238. 

  2239.         test = parseExpression();
    2240. 

  2240. 

  2241.         expect(')');
    2242. 

  2242. 

  2243.         if (match(';')) {
    2244. 

  2244.             lex();
    2245. 

  2245.         }
    2246. 

  2246. 

  2247.         return {
    2248. 

  2248.             type: Syntax.DoWhileStatement,
    2249. 

  2249.             body: body,
    2250. 

  2250.             test: test
    2251. 

  2251.         };
    2252. 

  2252.     }
    2253. 

  2253. 

  2254.     function parseWhileStatement() {
    2255. 

  2255.         var test, body, oldInIteration;
    2256. 

  2256. 

  2257.         expectKeyword('while');
    2258. 

  2258. 

  2259.         expect('(');
    2260. 

  2260. 

  2261.         test = parseExpression();
    2262. 

  2262. 

  2263.         expect(')');
    2264. 

  2264. 

  2265.         oldInIteration = state.inIteration;
    2266. 

  2266.         state.inIteration = true;
    2267. 

  2267. 

  2268.         body = parseStatement();
    2269. 

  2269. 

  2270.         state.inIteration = oldInIteration;
    2271. 

  2271. 

  2272.         return {
    2273. 

  2273.             type: Syntax.WhileStatement,
    2274. 

  2274.             test: test,
    2275. 

  2275.             body: body
    2276. 

  2276.         };
    2277. 

  2277.     }
    2278. 

  2278. 

  2279.     function parseForVariableDeclaration() {
    2280. 

  2280.         var token = lex();
    2281. 

  2281. 

  2282.         return {
    2283. 

  2283.             type: Syntax.VariableDeclaration,
    2284. 

  2284.             declarations: parseVariableDeclarationList(),
    2285. 

  2285.             kind: token.value
    2286. 

  2286.         };
    2287. 

  2287.     }
    2288. 

  2288. 

  2289.     function parseForStatement() {
    2290. 

  2290.         var init, test, update, left, right, body, oldInIteration;
    2291. 

  2291. 

  2292.         init = test = update = null;
    2293. 

  2293. 

  2294.         expectKeyword('for');
    2295. 

  2295. 

  2296.         expect('(');
    2297. 

  2297. 

  2298.         if (match(';')) {
    2299. 

  2299.             lex();
    2300. 

  2300.         } else {
    2301. 

  2301.             if (matchKeyword('var') || matchKeyword('let')) {
    2302. 

  2302.                 state.allowIn = false;
    2303. 

  2303.                 init = parseForVariableDeclaration();
    2304. 

  2304.                 state.allowIn = true;
    2305. 

  2305. 

  2306.                 if (init.declarations.length === 1 && matchKeyword('in')) {
    2307. 

  2307.                     lex();
    2308. 

  2308.                     left = init;
    2309. 

  2309.                     right = parseExpression();
    2310. 

  2310.                     init = null;
    2311. 

  2311.                 }
    2312. 

  2312.             } else {
    2313. 

  2313.                 state.allowIn = false;
    2314. 

  2314.                 init = parseExpression();
    2315. 

  2315.                 state.allowIn = true;
    2316. 

  2316. 

  2317.                 if (matchKeyword('in')) {
    2318. 

  2318.                     // LeftHandSideExpression
    2319. 

  2319.                     if (!isLeftHandSide(init)) {
    2320. 

  2320.                         throwErrorTolerant({}, Messages.InvalidLHSInForIn);
    2321. 

  2321.                     }
    2322. 

  2322. 

  2323.                     lex();
    2324. 

  2324.                     left = init;
    2325. 

  2325.                     right = parseExpression();
    2326. 

  2326.                     init = null;
    2327. 

  2327.                 }
    2328. 

  2328.             }
    2329. 

  2329. 

  2330.             if (typeof left === 'undefined') {
    2331. 

  2331.                 expect(';');
    2332. 

  2332.             }
    2333. 

  2333.         }
    2334. 

  2334. 

  2335.         if (typeof left === 'undefined') {
    2336. 

  2336. 

  2337.             if (!match(';')) {
    2338. 

  2338.                 test = parseExpression();
    2339. 

  2339.             }
    2340. 

  2340.             expect(';');
    2341. 

  2341. 

  2342.             if (!match(')')) {
    2343. 

  2343.                 update = parseExpression();
    2344. 

  2344.             }
    2345. 

  2345.         }
    2346. 

  2346. 

  2347.         expect(')');
    2348. 

  2348. 

  2349.         oldInIteration = state.inIteration;
    2350. 

  2350.         state.inIteration = true;
    2351. 

  2351. 

  2352.         body = parseStatement();
    2353. 

  2353. 

  2354.         state.inIteration = oldInIteration;
    2355. 

  2355. 

  2356.         if (typeof left === 'undefined') {
    2357. 

  2357.             return {
    2358. 

  2358.                 type: Syntax.ForStatement,
    2359. 

  2359.                 init: init,
    2360. 

  2360.                 test: test,
    2361. 

  2361.                 update: update,
    2362. 

  2362.                 body: body
    2363. 

  2363.             };
    2364. 

  2364.         }
    2365. 

  2365. 

  2366.         return {
    2367. 

  2367.             type: Syntax.ForInStatement,
    2368. 

  2368.             left: left,
    2369. 

  2369.             right: right,
    2370. 

  2370.             body: body,
    2371. 

  2371.             each: false
    2372. 

  2372.         };
    2373. 

  2373.     }
    2374. 

  2374. 

  2375.     // 12.7 The continue statement
    2376. 

  2376. 

  2377.     function parseContinueStatement() {
    2378. 

  2378.         var token, label = null;
    2379. 

  2379. 

  2380.         expectKeyword('continue');
    2381. 

  2381. 

  2382.         // Optimize the most common form: 'continue;'.
    2383. 

  2383.         if (source[index] === ';') {
    2384. 

  2384.             lex();
    2385. 

  2385. 

  2386.             if (!state.inIteration) {
    2387. 

  2387.                 throwError({}, Messages.IllegalContinue);
    2388. 

  2388.             }
    2389. 

  2389. 

  2390.             return {
    2391. 

  2391.                 type: Syntax.ContinueStatement,
    2392. 

  2392.                 label: null
    2393. 

  2393.             };
    2394. 

  2394.         }
    2395. 

  2395. 

  2396.         if (peekLineTerminator()) {
    2397. 

  2397.             if (!state.inIteration) {
    2398. 

  2398.                 throwError({}, Messages.IllegalContinue);
    2399. 

  2399.             }
    2400. 

  2400. 

  2401.             return {
    2402. 

  2402.                 type: Syntax.ContinueStatement,
    2403. 

  2403.                 label: null
    2404. 

  2404.             };
    2405. 

  2405.         }
    2406. 

  2406. 

  2407.         token = lookahead();
    2408. 

  2408.         if (token.type === Token.Identifier) {
    2409. 

  2409.             label = parseVariableIdentifier();
    2410. 

  2410. 

  2411.             if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {
    2412. 

  2412.                 throwError({}, Messages.UnknownLabel, label.name);
    2413. 

  2413.             }
    2414. 

  2414.         }
    2415. 

  2415. 

  2416.         consumeSemicolon();
    2417. 

  2417. 

  2418.         if (label === null && !state.inIteration) {
    2419. 

  2419.             throwError({}, Messages.IllegalContinue);
    2420. 

  2420.         }
    2421. 

  2421. 

  2422.         return {
    2423. 

  2423.             type: Syntax.ContinueStatement,
    2424. 

  2424.             label: label
    2425. 

  2425.         };
    2426. 

  2426.     }
    2427. 

  2427. 

  2428.     // 12.8 The break statement
    2429. 

  2429. 

  2430.     function parseBreakStatement() {
    2431. 

  2431.         var token, label = null;
    2432. 

  2432. 

  2433.         expectKeyword('break');
    2434. 

  2434. 

  2435.         // Optimize the most common form: 'break;'.
    2436. 

  2436.         if (source[index] === ';') {
    2437. 

  2437.             lex();
    2438. 

  2438. 

  2439.             if (!(state.inIteration || state.inSwitch)) {
    2440. 

  2440.                 throwError({}, Messages.IllegalBreak);
    2441. 

  2441.             }
    2442. 

  2442. 

  2443.             return {
    2444. 

  2444.                 type: Syntax.BreakStatement,
    2445. 

  2445.                 label: null
    2446. 

  2446.             };
    2447. 

  2447.         }
    2448. 

  2448. 

  2449.         if (peekLineTerminator()) {
    2450. 

  2450.             if (!(state.inIteration || state.inSwitch)) {
    2451. 

  2451.                 throwError({}, Messages.IllegalBreak);
    2452. 

  2452.             }
    2453. 

  2453. 

  2454.             return {
    2455. 

  2455.                 type: Syntax.BreakStatement,
    2456. 

  2456.                 label: null
    2457. 

  2457.             };
    2458. 

  2458.         }
    2459. 

  2459. 

  2460.         token = lookahead();
    2461. 

  2461.         if (token.type === Token.Identifier) {
    2462. 

  2462.             label = parseVariableIdentifier();
    2463. 

  2463. 

  2464.             if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {
    2465. 

  2465.                 throwError({}, Messages.UnknownLabel, label.name);
    2466. 

  2466.             }
    2467. 

  2467.         }
    2468. 

  2468. 

  2469.         consumeSemicolon();
    2470. 

  2470. 

  2471.         if (label === null && !(state.inIteration || state.inSwitch)) {
    2472. 

  2472.             throwError({}, Messages.IllegalBreak);
    2473. 

  2473.         }
    2474. 

  2474. 

  2475.         return {
    2476. 

  2476.             type: Syntax.BreakStatement,
    2477. 

  2477.             label: label
    2478. 

  2478.         };
    2479. 

  2479.     }
    2480. 

  2480. 

  2481.     // 12.9 The return statement
    2482. 

  2482. 

  2483.     function parseReturnStatement() {
    2484. 

  2484.         var token, argument = null;
    2485. 

  2485. 

  2486.         expectKeyword('return');
    2487. 

  2487. 

  2488.         if (!state.inFunctionBody) {
    2489. 

  2489.             throwErrorTolerant({}, Messages.IllegalReturn);
    2490. 

  2490.         }
    2491. 

  2491. 

  2492.         // 'return' followed by a space and an identifier is very common.
    2493. 

  2493.         if (source[index] === ' ') {
    2494. 

  2494.             if (isIdentifierStart(source[index + 1])) {
    2495. 

  2495.                 argument = parseExpression();
    2496. 

  2496.                 consumeSemicolon();
    2497. 

  2497.                 return {
    2498. 

  2498.                     type: Syntax.ReturnStatement,
    2499. 

  2499.                     argument: argument
    2500. 

  2500.                 };
    2501. 

  2501.             }
    2502. 

  2502.         }
    2503. 

  2503. 

  2504.         if (peekLineTerminator()) {
    2505. 

  2505.             return {
    2506. 

  2506.                 type: Syntax.ReturnStatement,
    2507. 

  2507.                 argument: null
    2508. 

  2508.             };
    2509. 

  2509.         }
    2510. 

  2510. 

  2511.         if (!match(';')) {
    2512. 

  2512.             token = lookahead();
    2513. 

  2513.             if (!match('}') && token.type !== Token.EOF) {
    2514. 

  2514.                 argument = parseExpression();
    2515. 

  2515.             }
    2516. 

  2516.         }
    2517. 

  2517. 

  2518.         consumeSemicolon();
    2519. 

  2519. 

  2520.         return {
    2521. 

  2521.             type: Syntax.ReturnStatement,
    2522. 

  2522.             argument: argument
    2523. 

  2523.         };
    2524. 

  2524.     }
    2525. 

  2525. 

  2526.     // 12.10 The with statement
    2527. 

  2527. 

  2528.     function parseWithStatement() {
    2529. 

  2529.         var object, body;
    2530. 

  2530. 

  2531.         if (strict) {
    2532. 

  2532.             throwErrorTolerant({}, Messages.StrictModeWith);
    2533. 

  2533.         }
    2534. 

  2534. 

  2535.         expectKeyword('with');
    2536. 

  2536. 

  2537.         expect('(');
    2538. 

  2538. 

  2539.         object = parseExpression();
    2540. 

  2540. 

  2541.         expect(')');
    2542. 

  2542. 

  2543.         body = parseStatement();
    2544. 

  2544. 

  2545.         return {
    2546. 

  2546.             type: Syntax.WithStatement,
    2547. 

  2547.             object: object,
    2548. 

  2548.             body: body
    2549. 

  2549.         };
    2550. 

  2550.     }
    2551. 

  2551. 

  2552.     // 12.10 The swith statement
    2553. 

  2553. 

  2554.     function parseSwitchCase() {
    2555. 

  2555.         var test,
    2556. 

  2556.             consequent = [],
    2557. 

  2557.             statement;
    2558. 

  2558. 

  2559.         if (matchKeyword('default')) {
    2560. 

  2560.             lex();
    2561. 

  2561.             test = null;
    2562. 

  2562.         } else {
    2563. 

  2563.             expectKeyword('case');
    2564. 

  2564.             test = parseExpression();
    2565. 

  2565.         }
    2566. 

  2566.         expect(':');
    2567. 

  2567. 

  2568.         while (index < length) {
    2569. 

  2569.             if (match('}') || matchKeyword('default') || matchKeyword('case')) {
    2570. 

  2570.                 break;
    2571. 

  2571.             }
    2572. 

  2572.             statement = parseStatement();
    2573. 

  2573.             if (typeof statement === 'undefined') {
    2574. 

  2574.                 break;
    2575. 

  2575.             }
    2576. 

  2576.             consequent.push(statement);
    2577. 

  2577.         }
    2578. 

  2578. 

  2579.         return {
    2580. 

  2580.             type: Syntax.SwitchCase,
    2581. 

  2581.             test: test,
    2582. 

  2582.             consequent: consequent
    2583. 

  2583.         };
    2584. 

  2584.     }
    2585. 

  2585. 

  2586.     function parseSwitchStatement() {
    2587. 

  2587.         var discriminant, cases, clause, oldInSwitch, defaultFound;
    2588. 

  2588. 

  2589.         expectKeyword('switch');
    2590. 

  2590. 

  2591.         expect('(');
    2592. 

  2592. 

  2593.         discriminant = parseExpression();
    2594. 

  2594. 

  2595.         expect(')');
    2596. 

  2596. 

  2597.         expect('{');
    2598. 

  2598. 

  2599.         cases = [];
    2600. 

  2600. 

  2601.         if (match('}')) {
    2602. 

  2602.             lex();
    2603. 

  2603.             return {
    2604. 

  2604.                 type: Syntax.SwitchStatement,
    2605. 

  2605.                 discriminant: discriminant,
    2606. 

  2606.                 cases: cases
    2607. 

  2607.             };
    2608. 

  2608.         }
    2609. 

  2609. 

  2610.         oldInSwitch = state.inSwitch;
    2611. 

  2611.         state.inSwitch = true;
    2612. 

  2612.         defaultFound = false;
    2613. 

  2613. 

  2614.         while (index < length) {
    2615. 

  2615.             if (match('}')) {
    2616. 

  2616.                 break;
    2617. 

  2617.             }
    2618. 

  2618.             clause = parseSwitchCase();
    2619. 

  2619.             if (clause.test === null) {
    2620. 

  2620.                 if (defaultFound) {
    2621. 

  2621.                     throwError({}, Messages.MultipleDefaultsInSwitch);
    2622. 

  2622.                 }
    2623. 

  2623.                 defaultFound = true;
    2624. 

  2624.             }
    2625. 

  2625.             cases.push(clause);
    2626. 

  2626.         }
    2627. 

  2627. 

  2628.         state.inSwitch = oldInSwitch;
    2629. 

  2629. 

  2630.         expect('}');
    2631. 

  2631. 

  2632.         return {
    2633. 

  2633.             type: Syntax.SwitchStatement,
    2634. 

  2634.             discriminant: discriminant,
    2635. 

  2635.             cases: cases
    2636. 

  2636.         };
    2637. 

  2637.     }
    2638. 

  2638. 

  2639.     // 12.13 The throw statement
    2640. 

  2640. 

  2641.     function parseThrowStatement() {
    2642. 

  2642.         var argument;
    2643. 

  2643. 

  2644.         expectKeyword('throw');
    2645. 

  2645. 

  2646.         if (peekLineTerminator()) {
    2647. 

  2647.             throwError({}, Messages.NewlineAfterThrow);
    2648. 

  2648.         }
    2649. 

  2649. 

  2650.         argument = parseExpression();
    2651. 

  2651. 

  2652.         consumeSemicolon();
    2653. 

  2653. 

  2654.         return {
    2655. 

  2655.             type: Syntax.ThrowStatement,
    2656. 

  2656.             argument: argument
    2657. 

  2657.         };
    2658. 

  2658.     }
    2659. 

  2659. 

  2660.     // 12.14 The try statement
    2661. 

  2661. 

  2662.     function parseCatchClause() {
    2663. 

  2663.         var param;
    2664. 

  2664. 

  2665.         expectKeyword('catch');
    2666. 

  2666. 

  2667.         expect('(');
    2668. 

  2668.         if (match(')')) {
    2669. 

  2669.             throwUnexpected(lookahead());
    2670. 

  2670.         }
    2671. 

  2671. 

  2672.         param = parseVariableIdentifier();
    2673. 

  2673.         // 12.14.1
    2674. 

  2674.         if (strict && isRestrictedWord(param.name)) {
    2675. 

  2675.             throwErrorTolerant({}, Messages.StrictCatchVariable);
    2676. 

  2676.         }
    2677. 

  2677. 

  2678.         expect(')');
    2679. 

  2679. 

  2680.         return {
    2681. 

  2681.             type: Syntax.CatchClause,
    2682. 

  2682.             param: param,
    2683. 

  2683.             body: parseBlock()
    2684. 

  2684.         };
    2685. 

  2685.     }
    2686. 

  2686. 

  2687.     function parseTryStatement() {
    2688. 

  2688.         var block, handlers = [], finalizer = null;
    2689. 

  2689. 

  2690.         expectKeyword('try');
    2691. 

  2691. 

  2692.         block = parseBlock();
    2693. 

  2693. 

  2694.         if (matchKeyword('catch')) {
    2695. 

  2695.             handlers.push(parseCatchClause());
    2696. 

  2696.         }
    2697. 

  2697. 

  2698.         if (matchKeyword('finally')) {
    2699. 

  2699.             lex();
    2700. 

  2700.             finalizer = parseBlock();
    2701. 

  2701.         }
    2702. 

  2702. 

  2703.         if (handlers.length === 0 && !finalizer) {
    2704. 

  2704.             throwError({}, Messages.NoCatchOrFinally);
    2705. 

  2705.         }
    2706. 

  2706. 

  2707.         return {
    2708. 

  2708.             type: Syntax.TryStatement,
    2709. 

  2709.             block: block,
    2710. 

  2710.             guardedHandlers: [],
    2711. 

  2711.             handlers: handlers,
    2712. 

  2712.             finalizer: finalizer
    2713. 

  2713.         };
    2714. 

  2714.     }
    2715. 

  2715. 

  2716.     // 12.15 The debugger statement
    2717. 

  2717. 

  2718.     function parseDebuggerStatement() {
    2719. 

  2719.         expectKeyword('debugger');
    2720. 

  2720. 

  2721.         consumeSemicolon();
    2722. 

  2722. 

  2723.         return {
    2724. 

  2724.             type: Syntax.DebuggerStatement
    2725. 

  2725.         };
    2726. 

  2726.     }
    2727. 

  2727. 

  2728.     // 12 Statements
    2729. 

  2729. 

  2730.     function parseStatement() {
    2731. 

  2731.         var token = lookahead(),
    2732. 

  2732.             expr,
    2733. 

  2733.             labeledBody;
    2734. 

  2734. 

  2735.         if (token.type === Token.EOF) {
    2736. 

  2736.             throwUnexpected(token);
    2737. 

  2737.         }
    2738. 

  2738. 

  2739.         if (token.type === Token.Punctuator) {
    2740. 

  2740.             switch (token.value) {
    2741. 

  2741.             case ';':
    2742. 

  2742.                 return parseEmptyStatement();
    2743. 

  2743.             case '{':
    2744. 

  2744.                 return parseBlock();
    2745. 

  2745.             case '(':
    2746. 

  2746.                 return parseExpressionStatement();
    2747. 

  2747.             default:
    2748. 

  2748.                 break;
    2749. 

  2749.             }
    2750. 

  2750.         }
    2751. 

  2751. 

  2752.         if (token.type === Token.Keyword) {
    2753. 

  2753.             switch (token.value) {
    2754. 

  2754.             case 'break':
    2755. 

  2755.                 return parseBreakStatement();
    2756. 

  2756.             case 'continue':
    2757. 

  2757.                 return parseContinueStatement();
    2758. 

  2758.             case 'debugger':
    2759. 

  2759.                 return parseDebuggerStatement();
    2760. 

  2760.             case 'do':
    2761. 

  2761.                 return parseDoWhileStatement();
    2762. 

  2762.             case 'for':
    2763. 

  2763.                 return parseForStatement();
    2764. 

  2764.             case 'function':
    2765. 

  2765.                 return parseFunctionDeclaration();
    2766. 

  2766.             case 'if':
    2767. 

  2767.                 return parseIfStatement();
    2768. 

  2768.             case 'return':
    2769. 

  2769.                 return parseReturnStatement();
    2770. 

  2770.             case 'switch':
    2771. 

  2771.                 return parseSwitchStatement();
    2772. 

  2772.             case 'throw':
    2773. 

  2773.                 return parseThrowStatement();
    2774. 

  2774.             case 'try':
    2775. 

  2775.                 return parseTryStatement();
    2776. 

  2776.             case 'var':
    2777. 

  2777.                 return parseVariableStatement();
    2778. 

  2778.             case 'while':
    2779. 

  2779.                 return parseWhileStatement();
    2780. 

  2780.             case 'with':
    2781. 

  2781.                 return parseWithStatement();
    2782. 

  2782.             default:
    2783. 

  2783.                 break;
    2784. 

  2784.             }
    2785. 

  2785.         }
    2786. 

  2786. 

  2787.         expr = parseExpression();
    2788. 

  2788. 

  2789.         // 12.12 Labelled Statements
    2790. 

  2790.         if ((expr.type === Syntax.Identifier) && match(':')) {
    2791. 

  2791.             lex();
    2792. 

  2792. 

  2793.             if (Object.prototype.hasOwnProperty.call(state.labelSet, expr.name)) {
    2794. 

  2794.                 throwError({}, Messages.Redeclaration, 'Label', expr.name);
    2795. 

  2795.             }
    2796. 

  2796. 

  2797.             state.labelSet[expr.name] = true;
    2798. 

  2798.             labeledBody = parseStatement();
    2799. 

  2799.             delete state.labelSet[expr.name];
    2800. 

  2800. 

  2801.             return {
    2802. 

  2802.                 type: Syntax.LabeledStatement,
    2803. 

  2803.                 label: expr,
    2804. 

  2804.                 body: labeledBody
    2805. 

  2805.             };
    2806. 

  2806.         }
    2807. 

  2807. 

  2808.         consumeSemicolon();
    2809. 

  2809. 

  2810.         return {
    2811. 

  2811.             type: Syntax.ExpressionStatement,
    2812. 

  2812.             expression: expr
    2813. 

  2813.         };
    2814. 

  2814.     }
    2815. 

  2815. 

  2816.     // 13 Function Definition
    2817. 

  2817. 

  2818.     function parseFunctionSourceElements() {
    2819. 

  2819.         var sourceElement, sourceElements = [], token, directive, firstRestricted,
    2820. 

  2820.             oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody;
    2821. 

  2821. 

  2822.         expect('{');
    2823. 

  2823. 

  2824.         while (index < length) {
    2825. 

  2825.             token = lookahead();
    2826. 

  2826.             if (token.type !== Token.StringLiteral) {
    2827. 

  2827.                 break;
    2828. 

  2828.             }
    2829. 

  2829. 

  2830.             sourceElement = parseSourceElement();
    2831. 

  2831.             sourceElements.push(sourceElement);
    2832. 

  2832.             if (sourceElement.expression.type !== Syntax.Literal) {
    2833. 

  2833.                 // this is not directive
    2834. 

  2834.                 break;
    2835. 

  2835.             }
    2836. 

  2836.             directive = sliceSource(token.range[0] + 1, token.range[1] - 1);
    2837. 

  2837.             if (directive === 'use strict') {
    2838. 

  2838.                 strict = true;
    2839. 

  2839.                 if (firstRestricted) {
    2840. 

  2840.                     throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
    2841. 

  2841.                 }
    2842. 

  2842.             } else {
    2843. 

  2843.                 if (!firstRestricted && token.octal) {
    2844. 

  2844.                     firstRestricted = token;
    2845. 

  2845.                 }
    2846. 

  2846.             }
    2847. 

  2847.         }
    2848. 

  2848. 

  2849.         oldLabelSet = state.labelSet;
    2850. 

  2850.         oldInIteration = state.inIteration;
    2851. 

  2851.         oldInSwitch = state.inSwitch;
    2852. 

  2852.         oldInFunctionBody = state.inFunctionBody;
    2853. 

  2853. 

  2854.         state.labelSet = {};
    2855. 

  2855.         state.inIteration = false;
    2856. 

  2856.         state.inSwitch = false;
    2857. 

  2857.         state.inFunctionBody = true;
    2858. 

  2858. 

  2859.         while (index < length) {
    2860. 

  2860.             if (match('}')) {
    2861. 

  2861.                 break;
    2862. 

  2862.             }
    2863. 

  2863.             sourceElement = parseSourceElement();
    2864. 

  2864.             if (typeof sourceElement === 'undefined') {
    2865. 

  2865.                 break;
    2866. 

  2866.             }
    2867. 

  2867.             sourceElements.push(sourceElement);
    2868. 

  2868.         }
    2869. 

  2869. 

  2870.         expect('}');
    2871. 

  2871. 

  2872.         state.labelSet = oldLabelSet;
    2873. 

  2873.         state.inIteration = oldInIteration;
    2874. 

  2874.         state.inSwitch = oldInSwitch;
    2875. 

  2875.         state.inFunctionBody = oldInFunctionBody;
    2876. 

  2876. 

  2877.         return {
    2878. 

  2878.             type: Syntax.BlockStatement,
    2879. 

  2879.             body: sourceElements
    2880. 

  2880.         };
    2881. 

  2881.     }
    2882. 

  2882. 

  2883.     function parseFunctionDeclaration() {
    2884. 

  2884.         var id, param, params = [], body, token, stricted, firstRestricted, message, previousStrict, paramSet;
    2885. 

  2885. 

  2886.         expectKeyword('function');
    2887. 

  2887.         token = lookahead();
    2888. 

  2888.         id = parseVariableIdentifier();
    2889. 

  2889.         if (strict) {
    2890. 

  2890.             if (isRestrictedWord(token.value)) {
    2891. 

  2891.                 throwErrorTolerant(token, Messages.StrictFunctionName);
    2892. 

  2892.             }
    2893. 

  2893.         } else {
    2894. 

  2894.             if (isRestrictedWord(token.value)) {
    2895. 

  2895.                 firstRestricted = token;
    2896. 

  2896.                 message = Messages.StrictFunctionName;
    2897. 

  2897.             } else if (isStrictModeReservedWord(token.value)) {
    2898. 

  2898.                 firstRestricted = token;
    2899. 

  2899.                 message = Messages.StrictReservedWord;
    2900. 

  2900.             }
    2901. 

  2901.         }
    2902. 

  2902. 

  2903.         expect('(');
    2904. 

  2904. 

  2905.         if (!match(')')) {
    2906. 

  2906.             paramSet = {};
    2907. 

  2907.             while (index < length) {
    2908. 

  2908.                 token = lookahead();
    2909. 

  2909.                 param = parseVariableIdentifier();
    2910. 

  2910.                 if (strict) {
    2911. 

  2911.                     if (isRestrictedWord(token.value)) {
    2912. 

  2912.                         stricted = token;
    2913. 

  2913.                         message = Messages.StrictParamName;
    2914. 

  2914.                     }
    2915. 

  2915.                     if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
    2916. 

  2916.                         stricted = token;
    2917. 

  2917.                         message = Messages.StrictParamDupe;
    2918. 

  2918.                     }
    2919. 

  2919.                 } else if (!firstRestricted) {
    2920. 

  2920.                     if (isRestrictedWord(token.value)) {
    2921. 

  2921.                         firstRestricted = token;
    2922. 

  2922.                         message = Messages.StrictParamName;
    2923. 

  2923.                     } else if (isStrictModeReservedWord(token.value)) {
    2924. 

  2924.                         firstRestricted = token;
    2925. 

  2925.                         message = Messages.StrictReservedWord;
    2926. 

  2926.                     } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
    2927. 

  2927.                         firstRestricted = token;
    2928. 

  2928.                         message = Messages.StrictParamDupe;
    2929. 

  2929.                     }
    2930. 

  2930.                 }
    2931. 

  2931.                 params.push(param);
    2932. 

  2932.                 paramSet[param.name] = true;
    2933. 

  2933.                 if (match(')')) {
    2934. 

  2934.                     break;
    2935. 

  2935.                 }
    2936. 

  2936.                 expect(',');
    2937. 

  2937.             }
    2938. 

  2938.         }
    2939. 

  2939. 

  2940.         expect(')');
    2941. 

  2941. 

  2942.         previousStrict = strict;
    2943. 

  2943.         body = parseFunctionSourceElements();
    2944. 

  2944.         if (strict && firstRestricted) {
    2945. 

  2945.             throwError(firstRestricted, message);
    2946. 

  2946.         }
    2947. 

  2947.         if (strict && stricted) {
    2948. 

  2948.             throwErrorTolerant(stricted, message);
    2949. 

  2949.         }
    2950. 

  2950.         strict = previousStrict;
    2951. 

  2951. 

  2952.         return {
    2953. 

  2953.             type: Syntax.FunctionDeclaration,
    2954. 

  2954.             id: id,
    2955. 

  2955.             params: params,
    2956. 

  2956.             defaults: [],
    2957. 

  2957.             body: body,
    2958. 

  2958.             rest: null,
    2959. 

  2959.             generator: false,
    2960. 

  2960.             expression: false
    2961. 

  2961.         };
    2962. 

  2962.     }
    2963. 

  2963. 

  2964.     function parseFunctionExpression() {
    2965. 

  2965.         var token, id = null, stricted, firstRestricted, message, param, params = [], body, previousStrict, paramSet;
    2966. 

  2966. 

  2967.         expectKeyword('function');
    2968. 

  2968. 

  2969.         if (!match('(')) {
    2970. 

  2970.             token = lookahead();
    2971. 

  2971.             id = parseVariableIdentifier();
    2972. 

  2972.             if (strict) {
    2973. 

  2973.                 if (isRestrictedWord(token.value)) {
    2974. 

  2974.                     throwErrorTolerant(token, Messages.StrictFunctionName);
    2975. 

  2975.                 }
    2976. 

  2976.             } else {
    2977. 

  2977.                 if (isRestrictedWord(token.value)) {
    2978. 

  2978.                     firstRestricted = token;
    2979. 

  2979.                     message = Messages.StrictFunctionName;
    2980. 

  2980.                 } else if (isStrictModeReservedWord(token.value)) {
    2981. 

  2981.                     firstRestricted = token;
    2982. 

  2982.                     message = Messages.StrictReservedWord;
    2983. 

  2983.                 }
    2984. 

  2984.             }
    2985. 

  2985.         }
    2986. 

  2986. 

  2987.         expect('(');
    2988. 

  2988. 

  2989.         if (!match(')')) {
    2990. 

  2990.             paramSet = {};
    2991. 

  2991.             while (index < length) {
    2992. 

  2992.                 token = lookahead();
    2993. 

  2993.                 param = parseVariableIdentifier();
    2994. 

  2994.                 if (strict) {
    2995. 

  2995.                     if (isRestrictedWord(token.value)) {
    2996. 

  2996.                         stricted = token;
    2997. 

  2997.                         message = Messages.StrictParamName;
    2998. 

  2998.                     }
    2999. 

  2999.                     if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
    3000. 

  3000.                         stricted = token;
    3001. 

  3001.                         message = Messages.StrictParamDupe;
    3002. 

  3002.                     }
    3003. 

  3003.                 } else if (!firstRestricted) {
    3004. 

  3004.                     if (isRestrictedWord(token.value)) {
    3005. 

  3005.                         firstRestricted = token;
    3006. 

  3006.                         message = Messages.StrictParamName;
    3007. 

  3007.                     } else if (isStrictModeReservedWord(token.value)) {
    3008. 

  3008.                         firstRestricted = token;
    3009. 

  3009.                         message = Messages.StrictReservedWord;
    3010. 

  3010.                     } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
    3011. 

  3011.                         firstRestricted = token;
    3012. 

  3012.                         message = Messages.StrictParamDupe;
    3013. 

  3013.                     }
    3014. 

  3014.                 }
    3015. 

  3015.                 params.push(param);
    3016. 

  3016.                 paramSet[param.name] = true;
    3017. 

  3017.                 if (match(')')) {
    3018. 

  3018.                     break;
    3019. 

  3019.                 }
    3020. 

  3020.                 expect(',');
    3021. 

  3021.             }
    3022. 

  3022.         }
    3023. 

  3023. 

  3024.         expect(')');
    3025. 

  3025. 

  3026.         previousStrict = strict;
    3027. 

  3027.         body = parseFunctionSourceElements();
    3028. 

  3028.         if (strict && firstRestricted) {
    3029. 

  3029.             throwError(firstRestricted, message);
    3030. 

  3030.         }
    3031. 

  3031.         if (strict && stricted) {
    3032. 

  3032.             throwErrorTolerant(stricted, message);
    3033. 

  3033.         }
    3034. 

  3034.         strict = previousStrict;
    3035. 

  3035. 

  3036.         return {
    3037. 

  3037.             type: Syntax.FunctionExpression,
    3038. 

  3038.             id: id,
    3039. 

  3039.             params: params,
    3040. 

  3040.             defaults: [],
    3041. 

  3041.             body: body,
    3042. 

  3042.             rest: null,
    3043. 

  3043.             generator: false,
    3044. 

  3044.             expression: false
    3045. 

  3045.         };
    3046. 

  3046.     }
    3047. 

  3047. 

  3048.     // 14 Program
    3049. 

  3049. 

  3050.     function parseSourceElement() {
    3051. 

  3051.         var token = lookahead();
    3052. 

  3052. 

  3053.         if (token.type === Token.Keyword) {
    3054. 

  3054.             switch (token.value) {
    3055. 

  3055.             case 'const':
    3056. 

  3056.             case 'let':
    3057. 

  3057.                 return parseConstLetDeclaration(token.value);
    3058. 

  3058.             case 'function':
    3059. 

  3059.                 return parseFunctionDeclaration();
    3060. 

  3060.             default:
    3061. 

  3061.                 return parseStatement();
    3062. 

  3062.             }
    3063. 

  3063.         }
    3064. 

  3064. 

  3065.         if (token.type !== Token.EOF) {
    3066. 

  3066.             return parseStatement();
    3067. 

  3067.         }
    3068. 

  3068.     }
    3069. 

  3069. 

  3070.     function parseSourceElements() {
    3071. 

  3071.         var sourceElement, sourceElements = [], token, directive, firstRestricted;
    3072. 

  3072. 

  3073.         while (index < length) {
    3074. 

  3074.             token = lookahead();
    3075. 

  3075.             if (token.type !== Token.StringLiteral) {
    3076. 

  3076.                 break;
    3077. 

  3077.             }
    3078. 

  3078. 

  3079.             sourceElement = parseSourceElement();
    3080. 

  3080.             sourceElements.push(sourceElement);
    3081. 

  3081.             if (sourceElement.expression.type !== Syntax.Literal) {
    3082. 

  3082.                 // this is not directive
    3083. 

  3083.                 break;
    3084. 

  3084.             }
    3085. 

  3085.             directive = sliceSource(token.range[0] + 1, token.range[1] - 1);
    3086. 

  3086.             if (directive === 'use strict') {
    3087. 

  3087.                 strict = true;
    3088. 

  3088.                 if (firstRestricted) {
    3089. 

  3089.                     throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
    3090. 

  3090.                 }
    3091. 

  3091.             } else {
    3092. 

  3092.                 if (!firstRestricted && token.octal) {
    3093. 

  3093.                     firstRestricted = token;
    3094. 

  3094.                 }
    3095. 

  3095.             }
    3096. 

  3096.         }
    3097. 

  3097. 

  3098.         while (index < length) {
    3099. 

  3099.             sourceElement = parseSourceElement();
    3100. 

  3100.             if (typeof sourceElement === 'undefined') {
    3101. 

  3101.                 break;
    3102. 

  3102.             }
    3103. 

  3103.             sourceElements.push(sourceElement);
    3104. 

  3104.         }
    3105. 

  3105.         return sourceElements;
    3106. 

  3106.     }
    3107. 

  3107. 

  3108.     function parseProgram() {
    3109. 

  3109.         var program;
    3110. 

  3110.         strict = false;
    3111. 

  3111.         program = {
    3112. 

  3112.             type: Syntax.Program,
    3113. 

  3113.             body: parseSourceElements()
    3114. 

  3114.         };
    3115. 

  3115.         return program;
    3116. 

  3116.     }
    3117. 

  3117. 

  3118.     // The following functions are needed only when the option to preserve
    3119. 

  3119.     // the comments is active.
    3120. 

  3120. 

  3121.     function addComment(type, value, start, end, loc) {
    3122. 

  3122.         assert(typeof start === 'number', 'Comment must have valid position');
    3123. 

  3123. 

  3124.         // Because the way the actual token is scanned, often the comments
    3125. 

  3125.         // (if any) are skipped twice during the lexical analysis.
    3126. 

  3126.         // Thus, we need to skip adding a comment if the comment array already
    3127. 

  3127.         // handled it.
    3128. 

  3128.         if (extra.comments.length > 0) {
    3129. 

  3129.             if (extra.comments[extra.comments.length - 1].range[1] > start) {
    3130. 

  3130.                 return;
    3131. 

  3131.             }
    3132. 

  3132.         }
    3133. 

  3133. 

  3134.         extra.comments.push({
    3135. 

  3135.             type: type,
    3136. 

  3136.             value: value,
    3137. 

  3137.             range: [start, end],
    3138. 

  3138.             loc: loc
    3139. 

  3139.         });
    3140. 

  3140.     }
    3141. 

  3141. 

  3142.     function scanComment() {
    3143. 

  3143.         var comment, ch, loc, start, blockComment, lineComment;
    3144. 

  3144. 

  3145.         comment = '';
    3146. 

  3146.         blockComment = false;
    3147. 

  3147.         lineComment = false;
    3148. 

  3148. 

  3149.         while (index < length) {
    3150. 

  3150.             ch = source[index];
    3151. 

  3151. 

  3152.             if (lineComment) {
    3153. 

  3153.                 ch = source[index++];
    3154. 

  3154.                 if (isLineTerminator(ch)) {
    3155. 

  3155.                     loc.end = {
    3156. 

  3156.                         line: lineNumber,
    3157. 

  3157.                         column: index - lineStart - 1
    3158. 

  3158.                     };
    3159. 

  3159.                     lineComment = false;
    3160. 

  3160.                     addComment('Line', comment, start, index - 1, loc);
    3161. 

  3161.                     if (ch === '\r' && source[index] === '\n') {
    3162. 

  3162.                         ++index;
    3163. 

  3163.                     }
    3164. 

  3164.                     ++lineNumber;
    3165. 

  3165.                     lineStart = index;
    3166. 

  3166.                     comment = '';
    3167. 

  3167.                 } else if (index >= length) {
    3168. 

  3168.                     lineComment = false;
    3169. 

  3169.                     comment += ch;
    3170. 

  3170.                     loc.end = {
    3171. 

  3171.                         line: lineNumber,
    3172. 

  3172.                         column: length - lineStart
    3173. 

  3173.                     };
    3174. 

  3174.                     addComment('Line', comment, start, length, loc);
    3175. 

  3175.                 } else {
    3176. 

  3176.                     comment += ch;
    3177. 

  3177.                 }
    3178. 

  3178.             } else if (blockComment) {
    3179. 

  3179.                 if (isLineTerminator(ch)) {
    3180. 

  3180.                     if (ch === '\r' && source[index + 1] === '\n') {
    3181. 

  3181.                         ++index;
    3182. 

  3182.                         comment += '\r\n';
    3183. 

  3183.                     } else {
    3184. 

  3184.                         comment += ch;
    3185. 

  3185.                     }
    3186. 

  3186.                     ++lineNumber;
    3187. 

  3187.                     ++index;
    3188. 

  3188.                     lineStart = index;
    3189. 

  3189.                     if (index >= length) {
    3190. 

  3190.                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    3191. 

  3191.                     }
    3192. 

  3192.                 } else {
    3193. 

  3193.                     ch = source[index++];
    3194. 

  3194.                     if (index >= length) {
    3195. 

  3195.                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    3196. 

  3196.                     }
    3197. 

  3197.                     comment += ch;
    3198. 

  3198.                     if (ch === '*') {
    3199. 

  3199.                         ch = source[index];
    3200. 

  3200.                         if (ch === '/') {
    3201. 

  3201.                             comment = comment.substr(0, comment.length - 1);
    3202. 

  3202.                             blockComment = false;
    3203. 

  3203.                             ++index;
    3204. 

  3204.                             loc.end = {
    3205. 

  3205.                                 line: lineNumber,
    3206. 

  3206.                                 column: index - lineStart
    3207. 

  3207.                             };
    3208. 

  3208.                             addComment('Block', comment, start, index, loc);
    3209. 

  3209.                             comment = '';
    3210. 

  3210.                         }
    3211. 

  3211.                     }
    3212. 

  3212.                 }
    3213. 

  3213.             } else if (ch === '/') {
    3214. 

  3214.                 ch = source[index + 1];
    3215. 

  3215.                 if (ch === '/') {
    3216. 

  3216.                     loc = {
    3217. 

  3217.                         start: {
    3218. 

  3218.                             line: lineNumber,
    3219. 

  3219.                             column: index - lineStart
    3220. 

  3220.                         }
    3221. 

  3221.                     };
    3222. 

  3222.                     start = index;
    3223. 

  3223.                     index += 2;
    3224. 

  3224.                     lineComment = true;
    3225. 

  3225.                     if (index >= length) {
    3226. 

  3226.                         loc.end = {
    3227. 

  3227.                             line: lineNumber,
    3228. 

  3228.                             column: index - lineStart
    3229. 

  3229.                         };
    3230. 

  3230.                         lineComment = false;
    3231. 

  3231.                         addComment('Line', comment, start, index, loc);
    3232. 

  3232.                     }
    3233. 

  3233.                 } else if (ch === '*') {
    3234. 

  3234.                     start = index;
    3235. 

  3235.                     index += 2;
    3236. 

  3236.                     blockComment = true;
    3237. 

  3237.                     loc = {
    3238. 

  3238.                         start: {
    3239. 

  3239.                             line: lineNumber,
    3240. 

  3240.                             column: index - lineStart - 2
    3241. 

  3241.                         }
    3242. 

  3242.                     };
    3243. 

  3243.                     if (index >= length) {
    3244. 

  3244.                         throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
    3245. 

  3245.                     }
    3246. 

  3246.                 } else {
    3247. 

  3247.                     break;
    3248. 

  3248.                 }
    3249. 

  3249.             } else if (isWhiteSpace(ch)) {
    3250. 

  3250.                 ++index;
    3251. 

  3251.             } else if (isLineTerminator(ch)) {
    3252. 

  3252.                 ++index;
    3253. 

  3253.                 if (ch ===  '\r' && source[index] === '\n') {
    3254. 

  3254.                     ++index;
    3255. 

  3255.                 }
    3256. 

  3256.                 ++lineNumber;
    3257. 

  3257.                 lineStart = index;
    3258. 

  3258.             } else {
    3259. 

  3259.                 break;
    3260. 

  3260.             }
    3261. 

  3261.         }
    3262. 

  3262.     }
    3263. 

  3263. 

  3264.     function filterCommentLocation() {
    3265. 

  3265.         var i, entry, comment, comments = [];
    3266. 

  3266. 

  3267.         for (i = 0; i < extra.comments.length; ++i) {
    3268. 

  3268.             entry = extra.comments[i];
    3269. 

  3269.             comment = {
    3270. 

  3270.                 type: entry.type,
    3271. 

  3271.                 value: entry.value
    3272. 

  3272.             };
    3273. 

  3273.             if (extra.range) {
    3274. 

  3274.                 comment.range = entry.range;
    3275. 

  3275.             }
    3276. 

  3276.             if (extra.loc) {
    3277. 

  3277.                 comment.loc = entry.loc;
    3278. 

  3278.             }
    3279. 

  3279.             comments.push(comment);
    3280. 

  3280.         }
    3281. 

  3281. 

  3282.         extra.comments = comments;
    3283. 

  3283.     }
    3284. 

  3284. 

  3285.     function collectToken() {
    3286. 

  3286.         var start, loc, token, range, value;
    3287. 

  3287. 

  3288.         skipComment();
    3289. 

  3289.         start = index;
    3290. 

  3290.         loc = {
    3291. 

  3291.             start: {
    3292. 

  3292.                 line: lineNumber,
    3293. 

  3293.                 column: index - lineStart
    3294. 

  3294.             }
    3295. 

  3295.         };
    3296. 

  3296. 

  3297.         token = extra.advance();
    3298. 

  3298.         loc.end = {
    3299. 

  3299.             line: lineNumber,
    3300. 

  3300.             column: index - lineStart
    3301. 

  3301.         };
    3302. 

  3302. 

  3303.         if (token.type !== Token.EOF) {
    3304. 

  3304.             range = [token.range[0], token.range[1]];
    3305. 

  3305.             value = sliceSource(token.range[0], token.range[1]);
    3306. 

  3306.             extra.tokens.push({
    3307. 

  3307.                 type: TokenName[token.type],
    3308. 

  3308.                 value: value,
    3309. 

  3309.                 range: range,
    3310. 

  3310.                 loc: loc
    3311. 

  3311.             });
    3312. 

  3312.         }
    3313. 

  3313. 

  3314.         return token;
    3315. 

  3315.     }
    3316. 

  3316. 

  3317.     function collectRegex() {
    3318. 

  3318.         var pos, loc, regex, token;
    3319. 

  3319. 

  3320.         skipComment();
    3321. 

  3321. 

  3322.         pos = index;
    3323. 

  3323.         loc = {
    3324. 

  3324.             start: {
    3325. 

  3325.                 line: lineNumber,
    3326. 

  3326.                 column: index - lineStart
    3327. 

  3327.             }
    3328. 

  3328.         };
    3329. 

  3329. 

  3330.         regex = extra.scanRegExp();
    3331. 

  3331.         loc.end = {
    3332. 

  3332.             line: lineNumber,
    3333. 

  3333.             column: index - lineStart
    3334. 

  3334.         };
    3335. 

  3335. 

  3336.         // Pop the previous token, which is likely '/' or '/='
    3337. 

  3337.         if (extra.tokens.length > 0) {
    3338. 

  3338.             token = extra.tokens[extra.tokens.length - 1];
    3339. 

  3339.             if (token.range[0] === pos && token.type === 'Punctuator') {
    3340. 

  3340.                 if (token.value === '/' || token.value === '/=') {
    3341. 

  3341.                     extra.tokens.pop();
    3342. 

  3342.                 }
    3343. 

  3343.             }
    3344. 

  3344.         }
    3345. 

  3345. 

  3346.         extra.tokens.push({
    3347. 

  3347.             type: 'RegularExpression',
    3348. 

  3348.             value: regex.literal,
    3349. 

  3349.             range: [pos, index],
    3350. 

  3350.             loc: loc
    3351. 

  3351.         });
    3352. 

  3352. 

  3353.         return regex;
    3354. 

  3354.     }
    3355. 

  3355. 

  3356.     function filterTokenLocation() {
    3357. 

  3357.         var i, entry, token, tokens = [];
    3358. 

  3358. 

  3359.         for (i = 0; i < extra.tokens.length; ++i) {
    3360. 

  3360.             entry = extra.tokens[i];
    3361. 

  3361.             token = {
    3362. 

  3362.                 type: entry.type,
    3363. 

  3363.                 value: entry.value
    3364. 

  3364.             };
    3365. 

  3365.             if (extra.range) {
    3366. 

  3366.                 token.range = entry.range;
    3367. 

  3367.             }
    3368. 

  3368.             if (extra.loc) {
    3369. 

  3369.                 token.loc = entry.loc;
    3370. 

  3370.             }
    3371. 

  3371.             tokens.push(token);
    3372. 

  3372.         }
    3373. 

  3373. 

  3374.         extra.tokens = tokens;
    3375. 

  3375.     }
    3376. 

  3376. 

  3377.     function createLiteral(token) {
    3378. 

  3378.         return {
    3379. 

  3379.             type: Syntax.Literal,
    3380. 

  3380.             value: token.value
    3381. 

  3381.         };
    3382. 

  3382.     }
    3383. 

  3383. 

  3384.     function createRawLiteral(token) {
    3385. 

  3385.         return {
    3386. 

  3386.             type: Syntax.Literal,
    3387. 

  3387.             value: token.value,
    3388. 

  3388.             raw: sliceSource(token.range[0], token.range[1])
    3389. 

  3389.         };
    3390. 

  3390.     }
    3391. 

  3391. 

  3392.     function createLocationMarker() {
    3393. 

  3393.         var marker = {};
    3394. 

  3394. 

  3395.         marker.range = [index, index];
    3396. 

  3396.         marker.loc = {
    3397. 

  3397.             start: {
    3398. 

  3398.                 line: lineNumber,
    3399. 

  3399.                 column: index - lineStart
    3400. 

  3400.             },
    3401. 

  3401.             end: {
    3402. 

  3402.                 line: lineNumber,
    3403. 

  3403.                 column: index - lineStart
    3404. 

  3404.             }
    3405. 

  3405.         };
    3406. 

  3406. 

  3407.         marker.end = function () {
    3408. 

  3408.             this.range[1] = index;
    3409. 

  3409.             this.loc.end.line = lineNumber;
    3410. 

  3410.             this.loc.end.column = index - lineStart;
    3411. 

  3411.         };
    3412. 

  3412. 

  3413.         marker.applyGroup = function (node) {
    3414. 

  3414.             if (extra.range) {
    3415. 

  3415.                 node.groupRange = [this.range[0], this.range[1]];
    3416. 

  3416.             }
    3417. 

  3417.             if (extra.loc) {
    3418. 

  3418.                 node.groupLoc = {
    3419. 

  3419.                     start: {
    3420. 

  3420.                         line: this.loc.start.line,
    3421. 

  3421.                         column: this.loc.start.column
    3422. 

  3422.                     },
    3423. 

  3423.                     end: {
    3424. 

  3424.                         line: this.loc.end.line,
    3425. 

  3425.                         column: this.loc.end.column
    3426. 

  3426.                     }
    3427. 

  3427.                 };
    3428. 

  3428.             }
    3429. 

  3429.         };
    3430. 

  3430. 

  3431.         marker.apply = function (node) {
    3432. 

  3432.             if (extra.range) {
    3433. 

  3433.                 node.range = [this.range[0], this.range[1]];
    3434. 

  3434.             }
    3435. 

  3435.             if (extra.loc) {
    3436. 

  3436.                 node.loc = {
    3437. 

  3437.                     start: {
    3438. 

  3438.                         line: this.loc.start.line,
    3439. 

  3439.                         column: this.loc.start.column
    3440. 

  3440.                     },
    3441. 

  3441.                     end: {
    3442. 

  3442.                         line: this.loc.end.line,
    3443. 

  3443.                         column: this.loc.end.column
    3444. 

  3444.                     }
    3445. 

  3445.                 };
    3446. 

  3446.             }
    3447. 

  3447.         };
    3448. 

  3448. 

  3449.         return marker;
    3450. 

  3450.     }
    3451. 

  3451. 

  3452.     function trackGroupExpression() {
    3453. 

  3453.         var marker, expr;
    3454. 

  3454. 

  3455.         skipComment();
    3456. 

  3456.         marker = createLocationMarker();
    3457. 

  3457.         expect('(');
    3458. 

  3458. 

  3459.         expr = parseExpression();
    3460. 

  3460. 

  3461.         expect(')');
    3462. 

  3462. 

  3463.         marker.end();
    3464. 

  3464.         marker.applyGroup(expr);
    3465. 

  3465. 

  3466.         return expr;
    3467. 

  3467.     }
    3468. 

  3468. 

  3469.     function trackLeftHandSideExpression() {
    3470. 

  3470.         var marker, expr;
    3471. 

  3471. 

  3472.         skipComment();
    3473. 

  3473.         marker = createLocationMarker();
    3474. 

  3474. 

  3475.         expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
    3476. 

  3476. 

  3477.         while (match('.') || match('[')) {
    3478. 

  3478.             if (match('[')) {
    3479. 

  3479.                 expr = {
    3480. 

  3480.                     type: Syntax.MemberExpression,
    3481. 

  3481.                     computed: true,
    3482. 

  3482.                     object: expr,
    3483. 

  3483.                     property: parseComputedMember()
    3484. 

  3484.                 };
    3485. 

  3485.                 marker.end();
    3486. 

  3486.                 marker.apply(expr);
    3487. 

  3487.             } else {
    3488. 

  3488.                 expr = {
    3489. 

  3489.                     type: Syntax.MemberExpression,
    3490. 

  3490.                     computed: false,
    3491. 

  3491.                     object: expr,
    3492. 

  3492.                     property: parseNonComputedMember()
    3493. 

  3493.                 };
    3494. 

  3494.                 marker.end();
    3495. 

  3495.                 marker.apply(expr);
    3496. 

  3496.             }
    3497. 

  3497.         }
    3498. 

  3498. 

  3499.         return expr;
    3500. 

  3500.     }
    3501. 

  3501. 

  3502.     function trackLeftHandSideExpressionAllowCall() {
    3503. 

  3503.         var marker, expr;
    3504. 

  3504. 

  3505.         skipComment();
    3506. 

  3506.         marker = createLocationMarker();
    3507. 

  3507. 

  3508.         expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
    3509. 

  3509. 

  3510.         while (match('.') || match('[') || match('(')) {
    3511. 

  3511.             if (match('(')) {
    3512. 

  3512.                 expr = {
    3513. 

  3513.                     type: Syntax.CallExpression,
    3514. 

  3514.                     callee: expr,
    3515. 

  3515.                     'arguments': parseArguments()
    3516. 

  3516.                 };
    3517. 

  3517.                 marker.end();
    3518. 

  3518.                 marker.apply(expr);
    3519. 

  3519.             } else if (match('[')) {
    3520. 

  3520.                 expr = {
    3521. 

  3521.                     type: Syntax.MemberExpression,
    3522. 

  3522.                     computed: true,
    3523. 

  3523.                     object: expr,
    3524. 

  3524.                     property: parseComputedMember()
    3525. 

  3525.                 };
    3526. 

  3526.                 marker.end();
    3527. 

  3527.                 marker.apply(expr);
    3528. 

  3528.             } else {
    3529. 

  3529.                 expr = {
    3530. 

  3530.                     type: Syntax.MemberExpression,
    3531. 

  3531.                     computed: false,
    3532. 

  3532.                     object: expr,
    3533. 

  3533.                     property: parseNonComputedMember()
    3534. 

  3534.                 };
    3535. 

  3535.                 marker.end();
    3536. 

  3536.                 marker.apply(expr);
    3537. 

  3537.             }
    3538. 

  3538.         }
    3539. 

  3539. 

  3540.         return expr;
    3541. 

  3541.     }
    3542. 

  3542. 

  3543.     function filterGroup(node) {
    3544. 

  3544.         var n, i, entry;
    3545. 

  3545. 

  3546.         n = (Object.prototype.toString.apply(node) === '[object Array]') ? [] : {};
    3547. 

  3547.         for (i in node) {
    3548. 

  3548.             if (node.hasOwnProperty(i) && i !== 'groupRange' && i !== 'groupLoc') {
    3549. 

  3549.                 entry = node[i];
    3550. 

  3550.                 if (entry === null || typeof entry !== 'object' || entry instanceof RegExp) {
    3551. 

  3551.                     n[i] = entry;
    3552. 

  3552.                 } else {
    3553. 

  3553.                     n[i] = filterGroup(entry);
    3554. 

  3554.                 }
    3555. 

  3555.             }
    3556. 

  3556.         }
    3557. 

  3557.         return n;
    3558. 

  3558.     }
    3559. 

  3559. 

  3560.     function wrapTrackingFunction(range, loc) {
    3561. 

  3561. 

  3562.         return function (parseFunction) {
    3563. 

  3563. 

  3564.             function isBinary(node) {
    3565. 

  3565.                 return node.type === Syntax.LogicalExpression ||
    3566. 

  3566.                     node.type === Syntax.BinaryExpression;
    3567. 

  3567.             }
    3568. 

  3568. 

  3569.             function visit(node) {
    3570. 

  3570.                 var start, end;
    3571. 

  3571. 

  3572.                 if (isBinary(node.left)) {
    3573. 

  3573.                     visit(node.left);
    3574. 

  3574.                 }
    3575. 

  3575.                 if (isBinary(node.right)) {
    3576. 

  3576.                     visit(node.right);
    3577. 

  3577.                 }
    3578. 

  3578. 

  3579.                 if (range) {
    3580. 

  3580.                     if (node.left.groupRange || node.right.groupRange) {
    3581. 

  3581.                         start = node.left.groupRange ? node.left.groupRange[0] : node.left.range[0];
    3582. 

  3582.                         end = node.right.groupRange ? node.right.groupRange[1] : node.right.range[1];
    3583. 

  3583.                         node.range = [start, end];
    3584. 

  3584.                     } else if (typeof node.range === 'undefined') {
    3585. 

  3585.                         start = node.left.range[0];
    3586. 

  3586.                         end = node.right.range[1];
    3587. 

  3587.                         node.range = [start, end];
    3588. 

  3588.                     }
    3589. 

  3589.                 }
    3590. 

  3590.                 if (loc) {
    3591. 

  3591.                     if (node.left.groupLoc || node.right.groupLoc) {
    3592. 

  3592.                         start = node.left.groupLoc ? node.left.groupLoc.start : node.left.loc.start;
    3593. 

  3593.                         end = node.right.groupLoc ? node.right.groupLoc.end : node.right.loc.end;
    3594. 

  3594.                         node.loc = {
    3595. 

  3595.                             start: start,
    3596. 

  3596.                             end: end
    3597. 

  3597.                         };
    3598. 

  3598.                     } else if (typeof node.loc === 'undefined') {
    3599. 

  3599.                         node.loc = {
    3600. 

  3600.                             start: node.left.loc.start,
    3601. 

  3601.                             end: node.right.loc.end
    3602. 

  3602.                         };
    3603. 

  3603.                     }
    3604. 

  3604.                 }
    3605. 

  3605.             }
    3606. 

  3606. 

  3607.             return function () {
    3608. 

  3608.                 var marker, node;
    3609. 

  3609. 

  3610.                 skipComment();
    3611. 

  3611. 

  3612.                 marker = createLocationMarker();
    3613. 

  3613.                 node = parseFunction.apply(null, arguments);
    3614. 

  3614.                 marker.end();
    3615. 

  3615. 

  3616.                 if (range && typeof node.range === 'undefined') {
    3617. 

  3617.                     marker.apply(node);
    3618. 

  3618.                 }
    3619. 

  3619. 

  3620.                 if (loc && typeof node.loc === 'undefined') {
    3621. 

  3621.                     marker.apply(node);
    3622. 

  3622.                 }
    3623. 

  3623. 

  3624.                 if (isBinary(node)) {
    3625. 

  3625.                     visit(node);
    3626. 

  3626.                 }
    3627. 

  3627. 

  3628.                 return node;
    3629. 

  3629.             };
    3630. 

  3630.         };
    3631. 

  3631.     }
    3632. 

  3632. 

  3633.     function patch() {
    3634. 

  3634. 

  3635.         var wrapTracking;
    3636. 

  3636. 

  3637.         if (extra.comments) {
    3638. 

  3638.             extra.skipComment = skipComment;
    3639. 

  3639.             skipComment = scanComment;
    3640. 

  3640.         }
    3641. 

  3641. 

  3642.         if (extra.raw) {
    3643. 

  3643.             extra.createLiteral = createLiteral;
    3644. 

  3644.             createLiteral = createRawLiteral;
    3645. 

  3645.         }
    3646. 

  3646. 

  3647.         if (extra.range || extra.loc) {
    3648. 

  3648. 

  3649.             extra.parseGroupExpression = parseGroupExpression;
    3650. 

  3650.             extra.parseLeftHandSideExpression = parseLeftHandSideExpression;
    3651. 

  3651.             extra.parseLeftHandSideExpressionAllowCall = parseLeftHandSideExpressionAllowCall;
    3652. 

  3652.             parseGroupExpression = trackGroupExpression;
    3653. 

  3653.             parseLeftHandSideExpression = trackLeftHandSideExpression;
    3654. 

  3654.             parseLeftHandSideExpressionAllowCall = trackLeftHandSideExpressionAllowCall;
    3655. 

  3655. 

  3656.             wrapTracking = wrapTrackingFunction(extra.range, extra.loc);
    3657. 

  3657. 

  3658.             extra.parseAdditiveExpression = parseAdditiveExpression;
    3659. 

  3659.             extra.parseAssignmentExpression = parseAssignmentExpression;
    3660. 

  3660.             extra.parseBitwiseANDExpression = parseBitwiseANDExpression;
    3661. 

  3661.             extra.parseBitwiseORExpression = parseBitwiseORExpression;
    3662. 

  3662.             extra.parseBitwiseXORExpression = parseBitwiseXORExpression;
    3663. 

  3663.             extra.parseBlock = parseBlock;
    3664. 

  3664.             extra.parseFunctionSourceElements = parseFunctionSourceElements;
    3665. 

  3665.             extra.parseCatchClause = parseCatchClause;
    3666. 

  3666.             extra.parseComputedMember = parseComputedMember;
    3667. 

  3667.             extra.parseConditionalExpression = parseConditionalExpression;
    3668. 

  3668.             extra.parseConstLetDeclaration = parseConstLetDeclaration;
    3669. 

  3669.             extra.parseEqualityExpression = parseEqualityExpression;
    3670. 

  3670.             extra.parseExpression = parseExpression;
    3671. 

  3671.             extra.parseForVariableDeclaration = parseForVariableDeclaration;
    3672. 

  3672.             extra.parseFunctionDeclaration = parseFunctionDeclaration;
    3673. 

  3673.             extra.parseFunctionExpression = parseFunctionExpression;
    3674. 

  3674.             extra.parseLogicalANDExpression = parseLogicalANDExpression;
    3675. 

  3675.             extra.parseLogicalORExpression = parseLogicalORExpression;
    3676. 

  3676.             extra.parseMultiplicativeExpression = parseMultiplicativeExpression;
    3677. 

  3677.             extra.parseNewExpression = parseNewExpression;
    3678. 

  3678.             extra.parseNonComputedProperty = parseNonComputedProperty;
    3679. 

  3679.             extra.parseObjectProperty = parseObjectProperty;
    3680. 

  3680.             extra.parseObjectPropertyKey = parseObjectPropertyKey;
    3681. 

  3681.             extra.parsePostfixExpression = parsePostfixExpression;
    3682. 

  3682.             extra.parsePrimaryExpression = parsePrimaryExpression;
    3683. 

  3683.             extra.parseProgram = parseProgram;
    3684. 

  3684.             extra.parsePropertyFunction = parsePropertyFunction;
    3685. 

  3685.             extra.parseRelationalExpression = parseRelationalExpression;
    3686. 

  3686.             extra.parseStatement = parseStatement;
    3687. 

  3687.             extra.parseShiftExpression = parseShiftExpression;
    3688. 

  3688.             extra.parseSwitchCase = parseSwitchCase;
    3689. 

  3689.             extra.parseUnaryExpression = parseUnaryExpression;
    3690. 

  3690.             extra.parseVariableDeclaration = parseVariableDeclaration;
    3691. 

  3691.             extra.parseVariableIdentifier = parseVariableIdentifier;
    3692. 

  3692. 

  3693.             parseAdditiveExpression = wrapTracking(extra.parseAdditiveExpression);
    3694. 

  3694.             parseAssignmentExpression = wrapTracking(extra.parseAssignmentExpression);
    3695. 

  3695.             parseBitwiseANDExpression = wrapTracking(extra.parseBitwiseANDExpression);
    3696. 

  3696.             parseBitwiseORExpression = wrapTracking(extra.parseBitwiseORExpression);
    3697. 

  3697.             parseBitwiseXORExpression = wrapTracking(extra.parseBitwiseXORExpression);
    3698. 

  3698.             parseBlock = wrapTracking(extra.parseBlock);
    3699. 

  3699.             parseFunctionSourceElements = wrapTracking(extra.parseFunctionSourceElements);
    3700. 

  3700.             parseCatchClause = wrapTracking(extra.parseCatchClause);
    3701. 

  3701.             parseComputedMember = wrapTracking(extra.parseComputedMember);
    3702. 

  3702.             parseConditionalExpression = wrapTracking(extra.parseConditionalExpression);
    3703. 

  3703.             parseConstLetDeclaration = wrapTracking(extra.parseConstLetDeclaration);
    3704. 

  3704.             parseEqualityExpression = wrapTracking(extra.parseEqualityExpression);
    3705. 

  3705.             parseExpression = wrapTracking(extra.parseExpression);
    3706. 

  3706.             parseForVariableDeclaration = wrapTracking(extra.parseForVariableDeclaration);
    3707. 

  3707.             parseFunctionDeclaration = wrapTracking(extra.parseFunctionDeclaration);
    3708. 

  3708.             parseFunctionExpression = wrapTracking(extra.parseFunctionExpression);
    3709. 

  3709.             parseLeftHandSideExpression = wrapTracking(parseLeftHandSideExpression);
    3710. 

  3710.             parseLogicalANDExpression = wrapTracking(extra.parseLogicalANDExpression);
    3711. 

  3711.             parseLogicalORExpression = wrapTracking(extra.parseLogicalORExpression);
    3712. 

  3712.             parseMultiplicativeExpression = wrapTracking(extra.parseMultiplicativeExpression);
    3713. 

  3713.             parseNewExpression = wrapTracking(extra.parseNewExpression);
    3714. 

  3714.             parseNonComputedProperty = wrapTracking(extra.parseNonComputedProperty);
    3715. 

  3715.             parseObjectProperty = wrapTracking(extra.parseObjectProperty);
    3716. 

  3716.             parseObjectPropertyKey = wrapTracking(extra.parseObjectPropertyKey);
    3717. 

  3717.             parsePostfixExpression = wrapTracking(extra.parsePostfixExpression);
    3718. 

  3718.             parsePrimaryExpression = wrapTracking(extra.parsePrimaryExpression);
    3719. 

  3719.             parseProgram = wrapTracking(extra.parseProgram);
    3720. 

  3720.             parsePropertyFunction = wrapTracking(extra.parsePropertyFunction);
    3721. 

  3721.             parseRelationalExpression = wrapTracking(extra.parseRelationalExpression);
    3722. 

  3722.             parseStatement = wrapTracking(extra.parseStatement);
    3723. 

  3723.             parseShiftExpression = wrapTracking(extra.parseShiftExpression);
    3724. 

  3724.             parseSwitchCase = wrapTracking(extra.parseSwitchCase);
    3725. 

  3725.             parseUnaryExpression = wrapTracking(extra.parseUnaryExpression);
    3726. 

  3726.             parseVariableDeclaration = wrapTracking(extra.parseVariableDeclaration);
    3727. 

  3727.             parseVariableIdentifier = wrapTracking(extra.parseVariableIdentifier);
    3728. 

  3728.         }
    3729. 

  3729. 

  3730.         if (typeof extra.tokens !== 'undefined') {
    3731. 

  3731.             extra.advance = advance;
    3732. 

  3732.             extra.scanRegExp = scanRegExp;
    3733. 

  3733. 

  3734.             advance = collectToken;
    3735. 

  3735.             scanRegExp = collectRegex;
    3736. 

  3736.         }
    3737. 

  3737.     }
    3738. 

  3738. 

  3739.     function unpatch() {
    3740. 

  3740.         if (typeof extra.skipComment === 'function') {
    3741. 

  3741.             skipComment = extra.skipComment;
    3742. 

  3742.         }
    3743. 

  3743. 

  3744.         if (extra.raw) {
    3745. 

  3745.             createLiteral = extra.createLiteral;
    3746. 

  3746.         }
    3747. 

  3747. 

  3748.         if (extra.range || extra.loc) {
    3749. 

  3749.             parseAdditiveExpression = extra.parseAdditiveExpression;
    3750. 

  3750.             parseAssignmentExpression = extra.parseAssignmentExpression;
    3751. 

  3751.             parseBitwiseANDExpression = extra.parseBitwiseANDExpression;
    3752. 

  3752.             parseBitwiseORExpression = extra.parseBitwiseORExpression;
    3753. 

  3753.             parseBitwiseXORExpression = extra.parseBitwiseXORExpression;
    3754. 

  3754.             parseBlock = extra.parseBlock;
    3755. 

  3755.             parseFunctionSourceElements = extra.parseFunctionSourceElements;
    3756. 

  3756.             parseCatchClause = extra.parseCatchClause;
    3757. 

  3757.             parseComputedMember = extra.parseComputedMember;
    3758. 

  3758.             parseConditionalExpression = extra.parseConditionalExpression;
    3759. 

  3759.             parseConstLetDeclaration = extra.parseConstLetDeclaration;
    3760. 

  3760.             parseEqualityExpression = extra.parseEqualityExpression;
    3761. 

  3761.             parseExpression = extra.parseExpression;
    3762. 

  3762.             parseForVariableDeclaration = extra.parseForVariableDeclaration;
    3763. 

  3763.             parseFunctionDeclaration = extra.parseFunctionDeclaration;
    3764. 

  3764.             parseFunctionExpression = extra.parseFunctionExpression;
    3765. 

  3765.             parseGroupExpression = extra.parseGroupExpression;
    3766. 

  3766.             parseLeftHandSideExpression = extra.parseLeftHandSideExpression;
    3767. 

  3767.             parseLeftHandSideExpressionAllowCall = extra.parseLeftHandSideExpressionAllowCall;
    3768. 

  3768.             parseLogicalANDExpression = extra.parseLogicalANDExpression;
    3769. 

  3769.             parseLogicalORExpression = extra.parseLogicalORExpression;
    3770. 

  3770.             parseMultiplicativeExpression = extra.parseMultiplicativeExpression;
    3771. 

  3771.             parseNewExpression = extra.parseNewExpression;
    3772. 

  3772.             parseNonComputedProperty = extra.parseNonComputedProperty;
    3773. 

  3773.             parseObjectProperty = extra.parseObjectProperty;
    3774. 

  3774.             parseObjectPropertyKey = extra.parseObjectPropertyKey;
    3775. 

  3775.             parsePrimaryExpression = extra.parsePrimaryExpression;
    3776. 

  3776.             parsePostfixExpression = extra.parsePostfixExpression;
    3777. 

  3777.             parseProgram = extra.parseProgram;
    3778. 

  3778.             parsePropertyFunction = extra.parsePropertyFunction;
    3779. 

  3779.             parseRelationalExpression = extra.parseRelationalExpression;
    3780. 

  3780.             parseStatement = extra.parseStatement;
    3781. 

  3781.             parseShiftExpression = extra.parseShiftExpression;
    3782. 

  3782.             parseSwitchCase = extra.parseSwitchCase;
    3783. 

  3783.             parseUnaryExpression = extra.parseUnaryExpression;
    3784. 

  3784.             parseVariableDeclaration = extra.parseVariableDeclaration;
    3785. 

  3785.             parseVariableIdentifier = extra.parseVariableIdentifier;
    3786. 

  3786.         }
    3787. 

  3787. 

  3788.         if (typeof extra.scanRegExp === 'function') {
    3789. 

  3789.             advance = extra.advance;
    3790. 

  3790.             scanRegExp = extra.scanRegExp;
    3791. 

  3791.         }
    3792. 

  3792.     }
    3793. 

  3793. 

  3794.     function stringToArray(str) {
    3795. 

  3795.         var length = str.length,
    3796. 

  3796.             result = [],
    3797. 

  3797.             i;
    3798. 

  3798.         for (i = 0; i < length; ++i) {
    3799. 

  3799.             result[i] = str.charAt(i);
    3800. 

  3800.         }
    3801. 

  3801.         return result;
    3802. 

  3802.     }
    3803. 

  3803. 

  3804.     function parse(code, options) {
    3805. 

  3805.         var program, toString;
    3806. 

  3806. 

  3807.         toString = String;
    3808. 

  3808.         if (typeof code !== 'string' && !(code instanceof String)) {
    3809. 

  3809.             code = toString(code);
    3810. 

  3810.         }
    3811. 

  3811. 

  3812.         source = code;
    3813. 

  3813.         index = 0;
    3814. 

  3814.         lineNumber = (source.length > 0) ? 1 : 0;
    3815. 

  3815.         lineStart = 0;
    3816. 

  3816.         length = source.length;
    3817. 

  3817.         buffer = null;
    3818. 

  3818.         state = {
    3819. 

  3819.             allowIn: true,
    3820. 

  3820.             labelSet: {},
    3821. 

  3821.             inFunctionBody: false,
    3822. 

  3822.             inIteration: false,
    3823. 

  3823.             inSwitch: false
    3824. 

  3824.         };
    3825. 

  3825. 

  3826.         extra = {};
    3827. 

  3827.         if (typeof options !== 'undefined') {
    3828. 

  3828.             extra.range = (typeof options.range === 'boolean') && options.range;
    3829. 

  3829.             extra.loc = (typeof options.loc === 'boolean') && options.loc;
    3830. 

  3830.             extra.raw = (typeof options.raw === 'boolean') && options.raw;
    3831. 

  3831.             if (typeof options.tokens === 'boolean' && options.tokens) {
    3832. 

  3832.                 extra.tokens = [];
    3833. 

  3833.             }
    3834. 

  3834.             if (typeof options.comment === 'boolean' && options.comment) {
    3835. 

  3835.                 extra.comments = [];
    3836. 

  3836.             }
    3837. 

  3837.             if (typeof options.tolerant === 'boolean' && options.tolerant) {
    3838. 

  3838.                 extra.errors = [];
    3839. 

  3839.             }
    3840. 

  3840.         }
    3841. 

  3841. 

  3842.         if (length > 0) {
    3843. 

  3843.             if (typeof source[0] === 'undefined') {
    3844. 

  3844.                 // Try first to convert to a string. This is good as fast path
    3845. 

  3845.                 // for old IE which understands string indexing for string
    3846. 

  3846.                 // literals only and not for string object.
    3847. 

  3847.                 if (code instanceof String) {
    3848. 

  3848.                     source = code.valueOf();
    3849. 

  3849.                 }
    3850. 

  3850. 

  3851.                 // Force accessing the characters via an array.
    3852. 

  3852.                 if (typeof source[0] === 'undefined') {
    3853. 

  3853.                     source = stringToArray(code);
    3854. 

  3854.                 }
    3855. 

  3855.             }
    3856. 

  3856.         }
    3857. 

  3857. 

  3858.         patch();
    3859. 

  3859.         try {
    3860. 

  3860.             program = parseProgram();
    3861. 

  3861.             if (typeof extra.comments !== 'undefined') {
    3862. 

  3862.                 filterCommentLocation();
    3863. 

  3863.                 program.comments = extra.comments;
    3864. 

  3864.             }
    3865. 

  3865.             if (typeof extra.tokens !== 'undefined') {
    3866. 

  3866.                 filterTokenLocation();
    3867. 

  3867.                 program.tokens = extra.tokens;
    3868. 

  3868.             }
    3869. 

  3869.             if (typeof extra.errors !== 'undefined') {
    3870. 

  3870.                 program.errors = extra.errors;
    3871. 

  3871.             }
    3872. 

  3872.             if (extra.range || extra.loc) {
    3873. 

  3873.                 program.body = filterGroup(program.body);
    3874. 

  3874.             }
    3875. 

  3875.         } catch (e) {
    3876. 

  3876.             throw e;
    3877. 

  3877.         } finally {
    3878. 

  3878.             unpatch();
    3879. 

  3879.             extra = {};
    3880. 

  3880.         }
    3881. 

  3881. 

  3882.         return program;
    3883. 

  3883.     }
    3884. 

  3884. 

  3885.     // Sync with package.json.
    3886. 

  3886.     exports.version = '1.0.4';
    3887. 

  3887. 

  3888.     exports.parse = parse;
    3889. 

  3889. 

  3890.     // Deep copy.
    3891. 

  3891.     exports.Syntax = (function () {
    3892. 

  3892.         var name, types = {};
    3893. 

  3893. 

  3894.         if (typeof Object.create === 'function') {
    3895. 

  3895.             types = Object.create(null);
    3896. 

  3896.         }
    3897. 

  3897. 

  3898.         for (name in Syntax) {
    3899. 

  3899.             if (Syntax.hasOwnProperty(name)) {
    3900. 

  3900.                 types[name] = Syntax[name];
    3901. 

  3901.             }
    3902. 

  3902.         }
    3903. 

  3903. 

  3904.         if (typeof Object.freeze === 'function') {
    3905. 

  3905.             Object.freeze(types);
    3906. 

  3906.         }
    3907. 

  3907. 

  3908.         return types;
    3909. 

  3909.     }());
    3910. 

  3910. 

  3911. }));
    3912. 

  3912. /* vim: set sw=4 ts=4 et tw=80 : */
    3913. 

  3913. 

  3914. })(null);
    3915. 

  3915. /*!
    3916. 

  3916.  * falafel (c) James Halliday / MIT License
    3917. 

  3917.  * https://github.com/substack/node-falafel
    3918. 

  3918.  */
    3919. 

  3919. 

  3920. (function(require,module){
    3921. 

  3921. var parse = require('esprima').parse;
    3922. 

  3922. var objectKeys = Object.keys || function (obj) {
    3923. 

  3923.     var keys = [];
    3924. 

  3924.     for (var key in obj) keys.push(key);
    3925. 

  3925.     return keys;
    3926. 

  3926. };
    3927. 

  3927. var forEach = function (xs, fn) {
    3928. 

  3928.     if (xs.forEach) return xs.forEach(fn);
    3929. 

  3929.     for (var i = 0; i < xs.length; i++) {
    3930. 

  3930.         fn.call(xs, xs[i], i, xs);
    3931. 

  3931.     }
    3932. 

  3932. };
    3933. 

  3933. 

  3934. var isArray = Array.isArray || function (xs) {
    3935. 

  3935.     return Object.prototype.toString.call(xs) === '[object Array]';
    3936. 

  3936. };
    3937. 

  3937. 

  3938. module.exports = function (src, opts, fn) {
    3939. 

  3939.     if (typeof opts === 'function') {
    3940. 

  3940.         fn = opts;
    3941. 

  3941.         opts = {};
    3942. 

  3942.     }
    3943. 

  3943.     if (typeof src === 'object') {
    3944. 

  3944.         opts = src;
    3945. 

  3945.         src = opts.source;
    3946. 

  3946.         delete opts.source;
    3947. 

  3947.     }
    3948. 

  3948.     src = src === undefined ? opts.source : src;
    3949. 

  3949.     opts.range = true;
    3950. 

  3950.     if (typeof src !== 'string') src = String(src);
    3951. 

  3951.     
    3952. 

  3952.     var ast = parse(src, opts);
    3953. 

  3953.     
    3954. 

  3954.     var result = {
    3955. 

  3955.         chunks : src.split(''),
    3956. 

  3956.         toString : function () { return result.chunks.join('') },
    3957. 

  3957.         inspect : function () { return result.toString() }
    3958. 

  3958.     };
    3959. 

  3959.     var index = 0;
    3960. 

  3960.     
    3961. 

  3961.     (function walk (node, parent) {
    3962. 

  3962.         insertHelpers(node, parent, result.chunks);
    3963. 

  3963.         
    3964. 

  3964.         forEach(objectKeys(node), function (key) {
    3965. 

  3965.             if (key === 'parent') return;
    3966. 

  3966.             
    3967. 

  3967.             var child = node[key];
    3968. 

  3968.             if (isArray(child)) {
    3969. 

  3969.                 forEach(child, function (c) {
    3970. 

  3970.                     if (c && typeof c.type === 'string') {
    3971. 

  3971.                         walk(c, node);
    3972. 

  3972.                     }
    3973. 

  3973.                 });
    3974. 

  3974.             }
    3975. 

  3975.             else if (child && typeof child.type === 'string') {
    3976. 

  3976.                 insertHelpers(child, node, result.chunks);
    3977. 

  3977.                 walk(child, node);
    3978. 

  3978.             }
    3979. 

  3979.         });
    3980. 

  3980.         fn(node);
    3981. 

  3981.     })(ast, undefined);
    3982. 

  3982.     
    3983. 

  3983.     return result;
    3984. 

  3984. };
    3985. 

  3985.  
    3986. 

  3986. function insertHelpers (node, parent, chunks) {
    3987. 

  3987.     if (!node.range) return;
    3988. 

  3988.     
    3989. 

  3989.     node.parent = parent;
    3990. 

  3990.     
    3991. 

  3991.     node.source = function () {
    3992. 

  3992.         return chunks.slice(
    3993. 

  3993.             node.range[0], node.range[1]
    3994. 

  3994.         ).join('');
    3995. 

  3995.     };
    3996. 

  3996.     
    3997. 

  3997.     if (node.update && typeof node.update === 'object') {
    3998. 

  3998.         var prev = node.update;
    3999. 

  3999.         forEach(objectKeys(prev), function (key) {
    4000. 

  4000.             update[key] = prev[key];
    4001. 

  4001.         });
    4002. 

  4002.         node.update = update;
    4003. 

  4003.     }
    4004. 

  4004.     else {
    4005. 

  4005.         node.update = update;
    4006. 

  4006.     }
    4007. 

  4007.     
    4008. 

  4008.     function update (s) {
    4009. 

  4009.         chunks[node.range[0]] = s;
    4010. 

  4010.         for (var i = node.range[0] + 1; i < node.range[1]; i++) {
    4011. 

  4011.             chunks[i] = '';
    4012. 

  4012.         }
    4013. 

  4013.     };
    4014. 

  4014. }
    4015. 

  4015. 

  4016. window.falafel = module.exports;})(function(){return {parse: esprima.parse};},{exports: {}});
    4017. 

  4017. var inBrowser = typeof window !== 'undefined' && this === window;
    4018. 

  4018. var parseAndModify = (inBrowser ? window.falafel : require("falafel"));
    4019. 

  4019. 

  4020. (inBrowser ? window : exports).blanket = (function(){
    4021. 

  4021.     var linesToAddTracking = [
    4022. 

  4022.         "ExpressionStatement",
    4023. 

  4023.         "BreakStatement"   ,
    4024. 

  4024.         "ContinueStatement" ,
    4025. 

  4025.         "VariableDeclaration",
    4026. 

  4026.         "ReturnStatement"   ,
    4027. 

  4027.         "ThrowStatement"   ,
    4028. 

  4028.         "TryStatement"     ,
    4029. 

  4029.         "FunctionDeclaration"    ,
    4030. 

  4030.         "IfStatement"       ,
    4031. 

  4031.         "WhileStatement"    ,
    4032. 

  4032.         "DoWhileStatement"   ,
    4033. 

  4033.         "ForStatement"   ,
    4034. 

  4034.         "ForInStatement"  ,
    4035. 

  4035.         "SwitchStatement"  ,
    4036. 

  4036.         "WithStatement"
    4037. 

  4037.     ],
    4038. 

  4038.     linesToAddBrackets = [
    4039. 

  4039.         "IfStatement"       ,
    4040. 

  4040.         "WhileStatement"    ,
    4041. 

  4041.         "DoWhileStatement"     ,
    4042. 

  4042.         "ForStatement"   ,
    4043. 

  4043.         "ForInStatement"  ,
    4044. 

  4044.         "WithStatement"
    4045. 

  4045.     ],
    4046. 

  4046.     __blanket,
    4047. 

  4047.     copynumber = Math.floor(Math.random()*1000),
    4048. 

  4048.     coverageInfo = {},options = {
    4049. 

  4049.         reporter: null,
    4050. 

  4050.         adapter:null,
    4051. 

  4051.         filter: null,
    4052. 

  4052.         customVariable: null,
    4053. 

  4053.         loader: null,
    4054. 

  4054.         ignoreScriptError: false,
    4055. 

  4055.         existingRequireJS:false,
    4056. 

  4056.         autoStart: false,
    4057. 

  4057.         timeout: 180,
    4058. 

  4058.         ignoreCors: false,
    4059. 

  4059.         branchTracking: false,
    4060. 

  4060.         sourceURL: false,
    4061. 

  4061.         debug:false,
    4062. 

  4062.         engineOnly:false,
    4063. 

  4063.         testReadyCallback:null,
    4064. 

  4064.         commonJS:false,
    4065. 

  4065.         instrumentCache:false,
    4066. 

  4066.         modulePattern: null
    4067. 

  4067.     };
    4068. 

  4068.     
    4069. 

  4069.     if (inBrowser && typeof window.blanket !== 'undefined'){
    4070. 

  4070.         __blanket = window.blanket.noConflict();
    4071. 

  4071.     }
    4072. 

  4072.     
    4073. 

  4073.     _blanket = {
    4074. 

  4074.         noConflict: function(){
    4075. 

  4075.             if (__blanket){
    4076. 

  4076.                 return __blanket;
    4077. 

  4077.             }
    4078. 

  4078.             return _blanket;
    4079. 

  4079.         },
    4080. 

  4080.         _getCopyNumber: function(){
    4081. 

  4081.             //internal method
    4082. 

  4082.             //for differentiating between instances
    4083. 

  4083.             return copynumber;
    4084. 

  4084.         },
    4085. 

  4085.         extend: function(obj) {
    4086. 

  4086.             //borrowed from underscore
    4087. 

  4087.             _blanket._extend(_blanket,obj);
    4088. 

  4088.         },
    4089. 

  4089.         _extend: function(dest,source){
    4090. 

  4090.           if (source) {
    4091. 

  4091.             for (var prop in source) {
    4092. 

  4092.               if ( dest[prop] instanceof Object && typeof dest[prop] !== "function"){
    4093. 

  4093.                 _blanket._extend(dest[prop],source[prop]);
    4094. 

  4094.               }else{
    4095. 

  4095.                   dest[prop] = source[prop];
    4096. 

  4096.               }
    4097. 

  4097.             }
    4098. 

  4098.           }
    4099. 

  4099.         },
    4100. 

  4100.         getCovVar: function(){
    4101. 

  4101.             var opt = _blanket.options("customVariable");
    4102. 

  4102.             if (opt){
    4103. 

  4103.                 if (_blanket.options("debug")) {console.log("BLANKET-Using custom tracking variable:",opt);}
    4104. 

  4104.                 return inBrowser ? "window."+opt : opt;
    4105. 

  4105.             }
    4106. 

  4106.             return inBrowser ?   "window._$blanket" : "_$jscoverage";
    4107. 

  4107.         },
    4108. 

  4108.         options: function(key,value){
    4109. 

  4109.             if (typeof key !== "string"){
    4110. 

  4110.                 _blanket._extend(options,key);
    4111. 

  4111.             }else if (typeof value === 'undefined'){
    4112. 

  4112.                 return options[key];
    4113. 

  4113.             }else{
    4114. 

  4114.                 options[key]=value;
    4115. 

  4115.             }
    4116. 

  4116.         },
    4117. 

  4117.         instrument: function(config, next){
    4118. 

  4118.             //check instrumented hash table,
    4119. 

  4119.             //return instrumented code if available.
    4120. 

  4120.             var inFile = config.inputFile,
    4121. 

  4121.                 inFileName = config.inputFileName;
    4122. 

  4122.             //check instrument cache
    4123. 

  4123.            if (_blanket.options("instrumentCache") && sessionStorage && sessionStorage.getItem("blanket_instrument_store-"+inFileName)){
    4124. 

  4124.                 if (_blanket.options("debug")) {console.log("BLANKET-Reading instrumentation from cache: ",inFileName);}
    4125. 

  4125.                 next(sessionStorage.getItem("blanket_instrument_store-"+inFileName));
    4126. 

  4126.             }else{
    4127. 

  4127.                 var sourceArray = _blanket._prepareSource(inFile);
    4128. 

  4128.                 _blanket._trackingArraySetup=[];
    4129. 

  4129.                 //remove shebang
    4130. 

  4130.                 inFile = inFile.replace(/^\#\!.*/, "");
    4131. 

  4131.                 var instrumented =  parseAndModify(inFile,{loc:true,comment:true}, _blanket._addTracking(inFileName));
    4132. 

  4132.                 instrumented = _blanket._trackingSetup(inFileName,sourceArray)+instrumented;
    4133. 

  4133.                 if (_blanket.options("sourceURL")){
    4134. 

  4134.                     instrumented += "\n//@ sourceURL="+inFileName.replace("http://","");
    4135. 

  4135.                 }
    4136. 

  4136.                 if (_blanket.options("debug")) {console.log("BLANKET-Instrumented file: ",inFileName);}
    4137. 

  4137.                 if (_blanket.options("instrumentCache") && sessionStorage){
    4138. 

  4138.                     if (_blanket.options("debug")) {console.log("BLANKET-Saving instrumentation to cache: ",inFileName);}
    4139. 

  4139.                     sessionStorage.setItem("blanket_instrument_store-"+inFileName,instrumented);
    4140. 

  4140.                 }
    4141. 

  4141.                 next(instrumented);
    4142. 

  4142.             }
    4143. 

  4143.         },
    4144. 

  4144.         _trackingArraySetup: [],
    4145. 

  4145.         _branchingArraySetup: [],
    4146. 

  4146.         _prepareSource: function(source){
    4147. 

  4147.             return source.replace(/\\/g,"\\\\").replace(/'/g,"\\'").replace(/(\r\n|\n|\r)/gm,"\n").split('\n');
    4148. 

  4148.         },
    4149. 

  4149.         _trackingSetup: function(filename,sourceArray){
    4150. 

  4150.             var branches = _blanket.options("branchTracking");
    4151. 

  4151.             var sourceString = sourceArray.join("',\n'");
    4152. 

  4152.             var intro = "";
    4153. 

  4153.             var covVar = _blanket.getCovVar();
    4154. 

  4154. 

  4155.             intro += "if (typeof "+covVar+" === 'undefined') "+covVar+" = {};\n";
    4156. 

  4156.             if (branches){
    4157. 

  4157.                 intro += "var _$branchFcn=function(f,l,c,r){ ";
    4158. 

  4158.                 intro += "if (!!r) { ";
    4159. 

  4159.                 intro += covVar+"[f].branchData[l][c][0] = "+covVar+"[f].branchData[l][c][0] || [];";
    4160. 

  4160.                 intro += covVar+"[f].branchData[l][c][0].push(r); }";
    4161. 

  4161.                 intro += "else { ";
    4162. 

  4162.                 intro += covVar+"[f].branchData[l][c][1] = "+covVar+"[f].branchData[l][c][1] || [];";
    4163. 

  4163.                 intro += covVar+"[f].branchData[l][c][1].push(r); }";
    4164. 

  4164.                 intro += "return r;};\n";
    4165. 

  4165.             }
    4166. 

  4166.             intro += "if (typeof "+covVar+"['"+filename+"'] === 'undefined'){";
    4167. 

  4167. 

  4168.             intro += covVar+"['"+filename+"']=[];\n";
    4169. 

  4169.             if (branches){
    4170. 

  4170.                 intro += covVar+"['"+filename+"'].branchData=[];\n";
    4171. 

  4171.             }
    4172. 

  4172.             intro += covVar+"['"+filename+"'].source=['"+sourceString+"'];\n";
    4173. 

  4173.             //initialize array values
    4174. 

  4174.             _blanket._trackingArraySetup.sort(function(a,b){
    4175. 

  4175.                 return parseInt(a,10) > parseInt(b,10);
    4176. 

  4176.             }).forEach(function(item){
    4177. 

  4177.                 intro += covVar+"['"+filename+"']["+item+"]=0;\n";
    4178. 

  4178.             });
    4179. 

  4179.             if (branches){
    4180. 

  4180.                 _blanket._branchingArraySetup.sort(function(a,b){
    4181. 

  4181.                     return a.line > b.line;
    4182. 

  4182.                 }).sort(function(a,b){
    4183. 

  4183.                     return a.column > b.column;
    4184. 

  4184.                 }).forEach(function(item){
    4185. 

  4185.                     if (item.file === filename){
    4186. 

  4186.                         intro += "if (typeof "+ covVar+"['"+filename+"'].branchData["+item.line+"] === 'undefined'){\n";
    4187. 

  4187.                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]=[];\n";
    4188. 

  4188.                         intro += "}";
    4189. 

  4189.                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"] = [];\n";
    4190. 

  4190.                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"].consequent = "+JSON.stringify(item.consequent)+";\n";
    4191. 

  4191.                         intro += covVar+"['"+filename+"'].branchData["+item.line+"]["+item.column+"].alternate = "+JSON.stringify(item.alternate)+";\n";
    4192. 

  4192.                     }
    4193. 

  4193.                 });
    4194. 

  4194.             }
    4195. 

  4195.             intro += "}";
    4196. 

  4196. 

  4197.             return intro;
    4198. 

  4198.         },
    4199. 

  4199.         _blockifyIf: function(node){
    4200. 

  4200.             if (linesToAddBrackets.indexOf(node.type) > -1){
    4201. 

  4201.                 var bracketsExistObject = node.consequent || node.body;
    4202. 

  4202.                 var bracketsExistAlt = node.alternate;
    4203. 

  4203.                 if( bracketsExistAlt && bracketsExistAlt.type !== "BlockStatement") {
    4204. 

  4204.                     bracketsExistAlt.update("{\n"+bracketsExistAlt.source()+"}\n");
    4205. 

  4205.                 }
    4206. 

  4206.                 if( bracketsExistObject && bracketsExistObject.type !== "BlockStatement") {
    4207. 

  4207.                     bracketsExistObject.update("{\n"+bracketsExistObject.source()+"}\n");
    4208. 

  4208.                 }
    4209. 

  4209.             }
    4210. 

  4210.         },
    4211. 

  4211.         _trackBranch: function(node,filename){
    4212. 

  4212.             //recursive on consequent and alternative
    4213. 

  4213.             var line = node.loc.start.line;
    4214. 

  4214.             var col = node.loc.start.column;
    4215. 

  4215. 

  4216.             _blanket._branchingArraySetup.push({
    4217. 

  4217.                 line: line,
    4218. 

  4218.                 column: col,
    4219. 

  4219.                 file:filename,
    4220. 

  4220.                 consequent: node.consequent.loc,
    4221. 

  4221.                 alternate: node.alternate.loc
    4222. 

  4222.             });
    4223. 

  4223. 

  4224.             var updated = "_$branchFcn"+
    4225. 

  4225.                           "('"+filename+"',"+line+","+col+","+node.test.source()+
    4226. 

  4226.                           ")?"+node.consequent.source()+":"+node.alternate.source();
    4227. 

  4227.             node.update(updated);
    4228. 

  4228.         },
    4229. 

  4229.         _addTracking: function (filename) {
    4230. 

  4230.             //falafel doesn't take a file name
    4231. 

  4231.             //so we include the filename in a closure
    4232. 

  4232.             //and return the function to falafel
    4233. 

  4233.             var covVar = _blanket.getCovVar();
    4234. 

  4234. 

  4235.             return function(node){
    4236. 

  4236.                 _blanket._blockifyIf(node);
    4237. 

  4237. 

  4238.                 if (linesToAddTracking.indexOf(node.type) > -1 && node.parent.type !== "LabeledStatement") {
    4239. 

  4239.                     _blanket._checkDefs(node,filename);
    4240. 

  4240.                     if (node.type === "VariableDeclaration" &&
    4241. 

  4241.                         (node.parent.type === "ForStatement" || node.parent.type === "ForInStatement")){
    4242. 

  4242.                         return;
    4243. 

  4243.                     }
    4244. 

  4244.                     if (node.loc && node.loc.start){
    4245. 

  4245.                         node.update(covVar+"['"+filename+"']["+node.loc.start.line+"]++;\n"+node.source());
    4246. 

  4246.                         _blanket._trackingArraySetup.push(node.loc.start.line);
    4247. 

  4247.                     }else{
    4248. 

  4248.                         //I don't think we can handle a node with no location
    4249. 

  4249.                         throw new Error("The instrumenter encountered a node with no location: "+Object.keys(node));
    4250. 

  4250.                     }
    4251. 

  4251.                 }else if (_blanket.options("branchTracking") && node.type === "ConditionalExpression"){
    4252. 

  4252.                     _blanket._trackBranch(node,filename);
    4253. 

  4253.                 }
    4254. 

  4254.             };
    4255. 

  4255.         },
    4256. 

  4256.         _checkDefs: function(node,filename){
    4257. 

  4257.             // Make sure developers don't redefine window. if they do, inform them it is wrong.
    4258. 

  4258.             if (inBrowser){
    4259. 

  4259.                 if (node.type === "VariableDeclaration" && node.declarations) {
    4260. 

  4260.                     node.declarations.forEach(function(declaration) {
    4261. 

  4261.                         if (declaration.id.name === "window") {
    4262. 

  4262.                             throw new Error("Instrumentation error, you cannot redefine the 'window' variable in  " + filename + ":" + node.loc.start.line);
    4263. 

  4263.                         }
    4264. 

  4264.                     });
    4265. 

  4265.                 }
    4266. 

  4266.                 if (node.type === "FunctionDeclaration" && node.params) {
    4267. 

  4267.                     node.params.forEach(function(param) {
    4268. 

  4268.                         if (param.name === "window") {
    4269. 

  4269.                             throw new Error("Instrumentation error, you cannot redefine the 'window' variable in  " + filename + ":" + node.loc.start.line);
    4270. 

  4270.                         }
    4271. 

  4271.                     });
    4272. 

  4272.                 }
    4273. 

  4273.                 //Make sure developers don't redefine the coverage variable
    4274. 

  4274.                 if (node.type === "ExpressionStatement" &&
    4275. 

  4275.                     node.expression && node.expression.left &&
    4276. 

  4276.                     node.expression.left.object && node.expression.left.property &&
    4277. 

  4277.                     node.expression.left.object.name +
    4278. 

  4278.                         "." + node.expression.left.property.name === _blanket.getCovVar()) {
    4279. 

  4279.                     throw new Error("Instrumentation error, you cannot redefine the coverage variable in  " + filename + ":" + node.loc.start.line);
    4280. 

  4280.                 }
    4281. 

  4281.             }else{
    4282. 

  4282.                 //Make sure developers don't redefine the coverage variable in node
    4283. 

  4283.                 if (node.type === "ExpressionStatement" &&
    4284. 

  4284.                     node.expression && node.expression.left &&
    4285. 

  4285.                     !node.expression.left.object && !node.expression.left.property &&
    4286. 

  4286.                     node.expression.left.name === _blanket.getCovVar()) {
    4287. 

  4287.                     throw new Error("Instrumentation error, you cannot redefine the coverage variable in  " + filename + ":" + node.loc.start.line);
    4288. 

  4288.                 }
    4289. 

  4289.             }
    4290. 

  4290.         },
    4291. 

  4291.         setupCoverage: function(){
    4292. 

  4292.             coverageInfo.instrumentation = "blanket";
    4293. 

  4293.             coverageInfo.stats = {
    4294. 

  4294.                 "suites": 0,
    4295. 

  4295.                 "tests": 0,
    4296. 

  4296.                 "passes": 0,
    4297. 

  4297.                 "pending": 0,
    4298. 

  4298.                 "failures": 0,
    4299. 

  4299.                 "start": new Date()
    4300. 

  4300.             };
    4301. 

  4301.         },
    4302. 

  4302.         _checkIfSetup: function(){
    4303. 

  4303.             if (!coverageInfo.stats){
    4304. 

  4304.                 throw new Error("You must call blanket.setupCoverage() first.");
    4305. 

  4305.             }
    4306. 

  4306.         },
    4307. 

  4307.         onTestStart: function(){
    4308. 

  4308.             if (_blanket.options("debug")) {console.log("BLANKET-Test event started");}
    4309. 

  4309.             this._checkIfSetup();
    4310. 

  4310.             coverageInfo.stats.tests++;
    4311. 

  4311.             coverageInfo.stats.pending++;
    4312. 

  4312.         },
    4313. 

  4313.         onTestDone: function(total,passed){
    4314. 

  4314.             this._checkIfSetup();
    4315. 

  4315.             if(passed === total){
    4316. 

  4316.                 coverageInfo.stats.passes++;
    4317. 

  4317.             }else{
    4318. 

  4318.                 coverageInfo.stats.failures++;
    4319. 

  4319.             }
    4320. 

  4320.             coverageInfo.stats.pending--;
    4321. 

  4321.         },
    4322. 

  4322.         onModuleStart: function(){
    4323. 

  4323.             this._checkIfSetup();
    4324. 

  4324.             coverageInfo.stats.suites++;
    4325. 

  4325.         },
    4326. 

  4326.         onTestsDone: function(){
    4327. 

  4327.             if (_blanket.options("debug")) {console.log("BLANKET-Test event done");}
    4328. 

  4328.             this._checkIfSetup();
    4329. 

  4329.             coverageInfo.stats.end = new Date();
    4330. 

  4330. 

  4331.             if (inBrowser){
    4332. 

  4332.                 this.report(coverageInfo);
    4333. 

  4333.             }else{
    4334. 

  4334.                 if (!_blanket.options("branchTracking")){
    4335. 

  4335.                     delete (inBrowser ? window : global)[_blanket.getCovVar()].branchFcn;
    4336. 

  4336.                 }
    4337. 

  4337.                 this.options("reporter").call(this,coverageInfo);
    4338. 

  4338.             }
    4339. 

  4339.         }
    4340. 

  4340.     };
    4341. 

  4341.     return _blanket;
    4342. 

  4342. })();
    4343. 

  4343. 

  4344. (function(_blanket){
    4345. 

  4345.     var oldOptions = _blanket.options;
    4346. 

  4346. _blanket.extend({
    4347. 

  4347.     outstandingRequireFiles:[],
    4348. 

  4348.     options: function(key,value){
    4349. 

  4349.         var newVal={};
    4350. 

  4350. 

  4351.         if (typeof key !== "string"){
    4352. 

  4352.             //key is key/value map
    4353. 

  4353.             oldOptions(key);
    4354. 

  4354.             newVal = key;
    4355. 

  4355.         }else if (typeof value === 'undefined'){
    4356. 

  4356.             //accessor
    4357. 

  4357.             return oldOptions(key);
    4358. 

  4358.         }else{
    4359. 

  4359.             //setter
    4360. 

  4360.             oldOptions(key,value);
    4361. 

  4361.             newVal[key] = value;
    4362. 

  4362.         }
    4363. 

  4363. 

  4364.         if (newVal.adapter){
    4365. 

  4365.             _blanket._loadFile(newVal.adapter);
    4366. 

  4366.         }
    4367. 

  4367.         if (newVal.loader){
    4368. 

  4368.             _blanket._loadFile(newVal.loader);
    4369. 

  4369.         }
    4370. 

  4370.     },
    4371. 

  4371.     requiringFile: function(filename,done){
    4372. 

  4372.         if (typeof filename === "undefined"){
    4373. 

  4373.             _blanket.outstandingRequireFiles=[];
    4374. 

  4374.         }else if (typeof done === "undefined"){
    4375. 

  4375.             _blanket.outstandingRequireFiles.push(filename);
    4376. 

  4376.         }else{
    4377. 

  4377.             _blanket.outstandingRequireFiles.splice(_blanket.outstandingRequireFiles.indexOf(filename),1);
    4378. 

  4378.         }
    4379. 

  4379.     },
    4380. 

  4380.     requireFilesLoaded: function(){
    4381. 

  4381.         return _blanket.outstandingRequireFiles.length === 0;
    4382. 

  4382.     },
    4383. 

  4383.     showManualLoader: function(){
    4384. 

  4384.         if (document.getElementById("blanketLoaderDialog")){
    4385. 

  4385.             return;
    4386. 

  4386.         }
    4387. 

  4387.         //copied from http://blog.avtex.com/2012/01/26/cross-browser-css-only-modal-box/
    4388. 

  4388.         var loader = "<div class='blanketDialogOverlay'>";
    4389. 

  4389.             loader += "&nbsp;</div>";
    4390. 

  4390.             loader += "<div class='blanketDialogVerticalOffset'>";
    4391. 

  4391.             loader += "<div class='blanketDialogBox'>";
    4392. 

  4392.             loader += "<b>Error:</b> Blanket.js encountered a cross origin request error while instrumenting the source files.  ";
    4393. 

  4393.             loader += "<br><br>This is likely caused by the source files being referenced locally (using the file:// protocol). ";
    4394. 

  4394.             loader += "<br><br>Some solutions include <a href='http://askubuntu.com/questions/160245/making-google-chrome-option-allow-file-access-from-files-permanent' target='_blank'>starting Chrome with special flags</a>, <a target='_blank' href='https://github.com/remy/servedir'>running a server locally</a>, or using a browser without these CORS restrictions (Safari).";
    4395. 

  4395.             loader += "<br>";
    4396. 

  4396.             if (typeof FileReader !== "undefined"){
    4397. 

  4397.                 loader += "<br>Or, try the experimental loader.  When prompted, simply click on the directory containing all the source files you want covered.";
    4398. 

  4398.                 loader += "<a href='javascript:document.getElementById(\"fileInput\").click();'>Start Loader</a>";
    4399. 

  4399.                 loader += "<input type='file' type='application/x-javascript' accept='application/x-javascript' webkitdirectory id='fileInput' multiple onchange='window.blanket.manualFileLoader(this.files)' style='visibility:hidden;position:absolute;top:-50;left:-50'/>";
    4400. 

  4400.             }
    4401. 

  4401.             loader += "<br><span style='float:right;cursor:pointer;'  onclick=document.getElementById('blanketLoaderDialog').style.display='none';>Close</span>";
    4402. 

  4402.             loader += "<div style='clear:both'></div>";
    4403. 

  4403.             loader += "</div></div>";
    4404. 

  4404. 

  4405.         var css = ".blanketDialogWrapper {";
    4406. 

  4406.             css += "display:block;";
    4407. 

  4407.             css += "position:fixed;";
    4408. 

  4408.             css += "z-index:40001; }";
    4409. 

  4409. 

  4410.             css += ".blanketDialogOverlay {";
    4411. 

  4411.             css += "position:fixed;";
    4412. 

  4412.             css += "width:100%;";
    4413. 

  4413.             css += "height:100%;";
    4414. 

  4414.             css += "background-color:black;";
    4415. 

  4415.             css += "opacity:.5; ";
    4416. 

  4416.             css += "-ms-filter:'progid:DXImageTransform.Microsoft.Alpha(Opacity=50)'; ";
    4417. 

  4417.             css += "filter:alpha(opacity=50); ";
    4418. 

  4418.             css += "z-index:40001; }";
    4419. 

  4419. 

  4420.             css += ".blanketDialogVerticalOffset { ";
    4421. 

  4421.             css += "position:fixed;";
    4422. 

  4422.             css += "top:30%;";
    4423. 

  4423.             css += "width:100%;";
    4424. 

  4424.             css += "z-index:40002; }";
    4425. 

  4425. 

  4426.             css += ".blanketDialogBox { ";
    4427. 

  4427.             css += "width:405px; ";
    4428. 

  4428.             css += "position:relative;";
    4429. 

  4429.             css += "margin:0 auto;";
    4430. 

  4430.             css += "background-color:white;";
    4431. 

  4431.             css += "padding:10px;";
    4432. 

  4432.             css += "border:1px solid black; }";
    4433. 

  4433. 

  4434.         var dom = document.createElement("style");
    4435. 

  4435.         dom.innerHTML = css;
    4436. 

  4436.         document.head.appendChild(dom);
    4437. 

  4437. 

  4438.         var div = document.createElement("div");
    4439. 

  4439.         div.id = "blanketLoaderDialog";
    4440. 

  4440.         div.className = "blanketDialogWrapper";
    4441. 

  4441.         div.innerHTML = loader;
    4442. 

  4442.         document.body.insertBefore(div,document.body.firstChild);
    4443. 

  4443. 

  4444.     },
    4445. 

  4445.     manualFileLoader: function(files){
    4446. 

  4446.         var toArray =Array.prototype.slice;
    4447. 

  4447.         files = toArray.call(files).filter(function(item){
    4448. 

  4448.             return item.type !== "";
    4449. 

  4449.         });
    4450. 

  4450.         var sessionLength = files.length-1;
    4451. 

  4451.         var sessionIndx=0;
    4452. 

  4452.         var sessionArray = {};
    4453. 

  4453.         if (sessionStorage["blanketSessionLoader"]){
    4454. 

  4454.             sessionArray = JSON.parse(sessionStorage["blanketSessionLoader"]);
    4455. 

  4455.         }
    4456. 

  4456. 

  4457. 

  4458.         var fileLoader = function(event){
    4459. 

  4459.             var fileContent = event.currentTarget.result;
    4460. 

  4460.             var file = files[sessionIndx];
    4461. 

  4461.             var filename = file.webkitRelativePath && file.webkitRelativePath !== '' ? file.webkitRelativePath : file.name;
    4462. 

  4462.             sessionArray[filename] = fileContent;
    4463. 

  4463.             sessionIndx++;
    4464. 

  4464.             if (sessionIndx === sessionLength){
    4465. 

  4465.                 sessionStorage.setItem("blanketSessionLoader", JSON.stringify(sessionArray));
    4466. 

  4466.                 document.location.reload();
    4467. 

  4467.             }else{
    4468. 

  4468.                 readFile(files[sessionIndx]);
    4469. 

  4469.             }
    4470. 

  4470.         };
    4471. 

  4471.         function readFile(file){
    4472. 

  4472.             var reader = new FileReader();
    4473. 

  4473.             reader.onload = fileLoader;
    4474. 

  4474.             reader.readAsText(file);
    4475. 

  4475.         }
    4476. 

  4476.         readFile(files[sessionIndx]);
    4477. 

  4477.     },
    4478. 

  4478.     _loadFile: function(path){
    4479. 

  4479.         if (typeof path !== "undefined"){
    4480. 

  4480.             var request = new XMLHttpRequest();
    4481. 

  4481.             request.open('GET', path, false);
    4482. 

  4482.             request.send();
    4483. 

  4483.             _blanket._addScript(request.responseText);
    4484. 

  4484.         }
    4485. 

  4485.     },
    4486. 

  4486.     _addScript: function(data){
    4487. 

  4487.         var script = document.createElement("script");
    4488. 

  4488.         script.type = "text/javascript";
    4489. 

  4489.         script.text = data;
    4490. 

  4490.         (document.body || document.getElementsByTagName('head')[0]).appendChild(script);
    4491. 

  4491.     },
    4492. 

  4492.     hasAdapter: function(callback){
    4493. 

  4493.         return _blanket.options("adapter") !== null;
    4494. 

  4494.     },
    4495. 

  4495.     report: function(coverage_data){
    4496. 

  4496.         if (!document.getElementById("blanketLoaderDialog")){
    4497. 

  4497.             //all found, clear it
    4498. 

  4498.             _blanket.blanketSession = null;
    4499. 

  4499.         }
    4500. 

  4500.         coverage_data.files = window._$blanket;
    4501. 

  4501.         var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require;
    4502. 

  4502. 

  4503.         // Check if we have any covered files that requires reporting
    4504. 

  4504.         // otherwise just exit gracefully.
    4505. 

  4505.         if (!coverage_data.files || !Object.keys(coverage_data.files).length) {
    4506. 

  4506.             if (_blanket.options("debug")) {console.log("BLANKET-Reporting No files were instrumented.");}
    4507. 

  4507.             return;
    4508. 

  4508.         }
    4509. 

  4509. 

  4510.         if (typeof coverage_data.files.branchFcn !== "undefined"){
    4511. 

  4511.             delete coverage_data.files.branchFcn;
    4512. 

  4512.         }
    4513. 

  4513.         if (typeof _blanket.options("reporter") === "string"){
    4514. 

  4514.             _blanket._loadFile(_blanket.options("reporter"));
    4515. 

  4515.             _blanket.customReporter(coverage_data,_blanket.options("reporter_options"));
    4516. 

  4516.         }else if (typeof _blanket.options("reporter") === "function"){
    4517. 

  4517.             _blanket.options("reporter")(coverage_data,_blanket.options("reporter_options"));
    4518. 

  4518.         }else if (typeof _blanket.defaultReporter === 'function'){
    4519. 

  4519.             _blanket.defaultReporter(coverage_data,_blanket.options("reporter_options"));
    4520. 

  4520.         }else{
    4521. 

  4521.             throw new Error("no reporter defined.");
    4522. 

  4522.         }
    4523. 

  4523.     },
    4524. 

  4524.     _bindStartTestRunner: function(bindEvent,startEvent){
    4525. 

  4525.         if (bindEvent){
    4526. 

  4526.             bindEvent(startEvent);
    4527. 

  4527.         }else{
    4528. 

  4528.             window.addEventListener("load",startEvent,false);
    4529. 

  4529.         }
    4530. 

  4530.     },
    4531. 

  4531.     _loadSourceFiles: function(callback){
    4532. 

  4532.         var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require;
    4533. 

  4533.         function copy(o){
    4534. 

  4534.           var _copy = Object.create( Object.getPrototypeOf(o) );
    4535. 

  4535.           var propNames = Object.getOwnPropertyNames(o);
    4536. 

  4536. 

  4537.           propNames.forEach(function(name){
    4538. 

  4538.             var desc = Object.getOwnPropertyDescriptor(o, name);
    4539. 

  4539.             Object.defineProperty(_copy, name, desc);
    4540. 

  4540.           });
    4541. 

  4541. 

  4542.           return _copy;
    4543. 

  4543.         }
    4544. 

  4544.         if (_blanket.options("debug")) {console.log("BLANKET-Collecting page scripts");}
    4545. 

  4545.         var scripts = _blanket.utils.collectPageScripts();
    4546. 

  4546.         //_blanket.options("filter",scripts);
    4547. 

  4547.         if (scripts.length === 0){
    4548. 

  4548.             callback();
    4549. 

  4549.         }else{
    4550. 

  4550. 

  4551.             //check session state
    4552. 

  4552.             if (sessionStorage["blanketSessionLoader"]){
    4553. 

  4553.                 _blanket.blanketSession = JSON.parse(sessionStorage["blanketSessionLoader"]);
    4554. 

  4554.             }
    4555. 

  4555.             
    4556. 

  4556.             scripts.forEach(function(file,indx){
    4557. 

  4557.                 _blanket.utils.cache[file]={
    4558. 

  4558.                     loaded:false
    4559. 

  4559.                 };
    4560. 

  4560.             });
    4561. 

  4561.             
    4562. 

  4562.             var currScript=-1;
    4563. 

  4563.             _blanket.utils.loadAll(function(test){
    4564. 

  4564.                 if (test){
    4565. 

  4565.                   return typeof scripts[currScript+1] !== 'undefined';
    4566. 

  4566.                 }
    4567. 

  4567.                 currScript++;
    4568. 

  4568.                 if (currScript >= scripts.length){
    4569. 

  4569.                   return null;
    4570. 

  4570.                 }
    4571. 

  4571.                 return scripts[currScript];
    4572. 

  4572.             },callback);
    4573. 

  4573.         }
    4574. 

  4574.     },
    4575. 

  4575.     beforeStartTestRunner: function(opts){
    4576. 

  4576.         opts = opts || {};
    4577. 

  4577.         opts.checkRequirejs = typeof opts.checkRequirejs === "undefined" ? true : opts.checkRequirejs;
    4578. 

  4578.         opts.callback = opts.callback || function() {  };
    4579. 

  4579.         opts.coverage = typeof opts.coverage === "undefined" ? true : opts.coverage;
    4580. 

  4580.         if (opts.coverage) {
    4581. 

  4581.             _blanket._bindStartTestRunner(opts.bindEvent,
    4582. 

  4582.             function(){
    4583. 

  4583.                 _blanket._loadSourceFiles(function() {
    4584. 

  4584. 

  4585.                     var allLoaded = function(){
    4586. 

  4586.                         return opts.condition ? opts.condition() : _blanket.requireFilesLoaded();
    4587. 

  4587.                     };
    4588. 

  4588.                     var check = function() {
    4589. 

  4589.                         if (allLoaded()) {
    4590. 

  4590.                             if (_blanket.options("debug")) {console.log("BLANKET-All files loaded, init start test runner callback.");}
    4591. 

  4591.                             var cb = _blanket.options("testReadyCallback");
    4592. 

  4592. 

  4593.                             if (cb){
    4594. 

  4594.                                 if (typeof cb === "function"){
    4595. 

  4595.                                     cb(opts.callback);
    4596. 

  4596.                                 }else if (typeof cb === "string"){
    4597. 

  4597.                                     _blanket._addScript(cb);
    4598. 

  4598.                                     opts.callback();
    4599. 

  4599.                                 }
    4600. 

  4600.                             }else{
    4601. 

  4601.                                 opts.callback();
    4602. 

  4602.                             }
    4603. 

  4603.                         } else {
    4604. 

  4604.                             setTimeout(check, 13);
    4605. 

  4605.                         }
    4606. 

  4606.                     };
    4607. 

  4607.                     check();
    4608. 

  4608.                 });
    4609. 

  4609.             });
    4610. 

  4610.         }else{
    4611. 

  4611.             opts.callback();
    4612. 

  4612.         }
    4613. 

  4613.     },
    4614. 

  4614.     utils: {
    4615. 

  4615.         qualifyURL: function (url) {
    4616. 

  4616.             //http://stackoverflow.com/questions/470832/getting-an-absolute-url-from-a-relative-one-ie6-issue
    4617. 

  4617.             var a = document.createElement('a');
    4618. 

  4618.             a.href = url;
    4619. 

  4619.             return a.href;
    4620. 

  4620.         }
    4621. 

  4621.     }
    4622. 

  4622. });
    4623. 

  4623. 

  4624. })(blanket);
    4625. 

  4625. 

  4626. blanket.defaultReporter = function(coverage){
    4627. 

  4627.     var cssSytle = "#blanket-main {margin:2px;background:#EEE;color:#333;clear:both;font-family:'Helvetica Neue Light', 'HelveticaNeue-Light', 'Helvetica Neue', Calibri, Helvetica, Arial, sans-serif; font-size:17px;} #blanket-main a {color:#333;text-decoration:none;}  #blanket-main a:hover {text-decoration:underline;} .blanket {margin:0;padding:5px;clear:both;border-bottom: 1px solid #FFFFFF;} .bl-error {color:red;}.bl-success {color:#5E7D00;} .bl-file{width:auto;} .bl-cl{float:left;} .blanket div.rs {margin-left:50px; width:150px; float:right} .bl-nb {padding-right:10px;} #blanket-main a.bl-logo {color: #EB1764;cursor: pointer;font-weight: bold;text-decoration: none} .bl-source{ overflow-x:scroll; background-color: #FFFFFF; border: 1px solid #CBCBCB; color: #363636; margin: 25px 20px; width: 80%;} .bl-source div{white-space: pre;font-family: monospace;} .bl-source > div > span:first-child{background-color: #EAEAEA;color: #949494;display: inline-block;padding: 0 10px;text-align: center;width: 30px;} .bl-source .miss{background-color:#e6c3c7} .bl-source span.branchWarning{color:#000;background-color:yellow;} .bl-source span.branchOkay{color:#000;background-color:transparent;}",
    4628. 

  4628.         successRate = 60,
    4629. 

  4629.         head = document.head,
    4630. 

  4630.         fileNumber = 0,
    4631. 

  4631.         body = document.body,
    4632. 

  4632.         headerContent,
    4633. 

  4633.         hasBranchTracking = Object.keys(coverage.files).some(function(elem){
    4634. 

  4634.           return typeof coverage.files[elem].branchData !== 'undefined';
    4635. 

  4635.         }),
    4636. 

  4636.         bodyContent = "<div id='blanket-main'><div class='blanket bl-title'><div class='bl-cl bl-file'><a href='http://alex-seville.github.com/blanket/' target='_blank' class='bl-logo'>Blanket.js</a> results</div><div class='bl-cl rs'>Coverage (%)</div><div class='bl-cl rs'>Covered/Total Smts.</div>"+(hasBranchTracking ? "<div class='bl-cl rs'>Covered/Total Branches</div>":"")+"<div style='clear:both;'></div></div>",
    4637. 

  4637.         fileTemplate = "<div class='blanket {{statusclass}}'><div class='bl-cl bl-file'><span class='bl-nb'>{{fileNumber}}.</span><a href='javascript:blanket_toggleSource(\"file-{{fileNumber}}\")'>{{file}}</a></div><div class='bl-cl rs'>{{percentage}} %</div><div class='bl-cl rs'>{{numberCovered}}/{{totalSmts}}</div>"+( hasBranchTracking ? "<div class='bl-cl rs'>{{passedBranches}}/{{totalBranches}}</div>" : "" )+"<div id='file-{{fileNumber}}' class='bl-source' style='display:none;'>{{source}}</div><div style='clear:both;'></div></div>";
    4638. 

  4638.         grandTotalTemplate = "<div class='blanket grand-total {{statusclass}}'><div class='bl-cl'>{{rowTitle}}</div><div class='bl-cl rs'>{{percentage}} %</div><div class='bl-cl rs'>{{numberCovered}}/{{totalSmts}}</div>"+( hasBranchTracking ? "<div class='bl-cl rs'>{{passedBranches}}/{{totalBranches}}</div>" : "" ) + "<div style='clear:both;'></div></div>";
    4639. 

  4639. 

  4640.     function blanket_toggleSource(id) {
    4641. 

  4641.         var element = document.getElementById(id);
    4642. 

  4642.         if(element.style.display === 'block') {
    4643. 

  4643.             element.style.display = 'none';
    4644. 

  4644.         } else {
    4645. 

  4645.             element.style.display = 'block';
    4646. 

  4646.         }
    4647. 

  4647.     }
    4648. 

  4648. 

  4649. 

  4650.     var script = document.createElement("script");
    4651. 

  4651.     script.type = "text/javascript";
    4652. 

  4652.     script.text = blanket_toggleSource.toString().replace('function ' + blanket_toggleSource.name, 'function blanket_toggleSource');
    4653. 

  4653.     body.appendChild(script);
    4654. 

  4654. 

  4655.     var percentage = function(number, total) {
    4656. 

  4656.         return (Math.round(((number/total) * 100)*100)/100);
    4657. 

  4657.     };
    4658. 

  4658. 

  4659.     var appendTag = function (type, el, str) {
    4660. 

  4660.         var dom = document.createElement(type);
    4661. 

  4661.         dom.innerHTML = str;
    4662. 

  4662.         el.appendChild(dom);
    4663. 

  4663.     };
    4664. 

  4664. 

  4665.     function escapeInvalidXmlChars(str) {
    4666. 

  4666.         return str.replace(/\&/g, "&amp;")
    4667. 

  4667.             .replace(/</g, "&lt;")
    4668. 

  4668.             .replace(/\>/g, "&gt;")
    4669. 

  4669.             .replace(/\"/g, "&quot;")
    4670. 

  4670.             .replace(/\'/g, "&apos;");
    4671. 

  4671.     }
    4672. 

  4672. 

  4673.     function isBranchFollowed(data,bool){
    4674. 

  4674.         var mode = bool ? 0 : 1;
    4675. 

  4675.         if (typeof data === 'undefined' ||
    4676. 

  4676.             typeof data === null ||
    4677. 

  4677.             typeof data[mode] === 'undefined'){
    4678. 

  4678.             return false;
    4679. 

  4679.         }
    4680. 

  4680.         return data[mode].length > 0;
    4681. 

  4681.     }
    4682. 

  4682. 

  4683.     var branchStack = [];
    4684. 

  4684. 

  4685.     function branchReport(colsIndex,src,cols,offset,lineNum){
    4686. 

  4686.       var newsrc="";
    4687. 

  4687.        var postfix="";
    4688. 

  4688.       if (branchStack.length > 0){
    4689. 

  4689.         newsrc += "<span class='" + (isBranchFollowed(branchStack[0][1],branchStack[0][1].consequent === branchStack[0][0]) ? 'branchOkay' : 'branchWarning') + "'>";
    4690. 

  4690.         if (branchStack[0][0].end.line === lineNum){
    4691. 

  4691.           newsrc += escapeInvalidXmlChars(src.slice(0,branchStack[0][0].end.column)) + "</span>";
    4692. 

  4692.           src = src.slice(branchStack[0][0].end.column);
    4693. 

  4693.           branchStack.shift();
    4694. 

  4694.           if (branchStack.length > 0){
    4695. 

  4695.             newsrc += "<span class='" + (isBranchFollowed(branchStack[0][1],false) ? 'branchOkay' : 'branchWarning') + "'>";
    4696. 

  4696.             if (branchStack[0][0].end.line === lineNum){
    4697. 

  4697.               newsrc += escapeInvalidXmlChars(src.slice(0,branchStack[0][0].end.column)) + "</span>";
    4698. 

  4698.               src = src.slice(branchStack[0][0].end.column);
    4699. 

  4699.               branchStack.shift();
    4700. 

  4700.               if (!cols){
    4701. 

  4701.                 return {src: newsrc + escapeInvalidXmlChars(src) ,cols:cols};
    4702. 

  4702.               }
    4703. 

  4703.             }
    4704. 

  4704.             else if (!cols){
    4705. 

  4705.               return {src: newsrc + escapeInvalidXmlChars(src) + "</span>",cols:cols};
    4706. 

  4706.             }
    4707. 

  4707.             else{
    4708. 

  4708.               postfix = "</span>";
    4709. 

  4709.             }
    4710. 

  4710.           }else if (!cols){
    4711. 

  4711.             return {src: newsrc + escapeInvalidXmlChars(src) ,cols:cols};
    4712. 

  4712.           }
    4713. 

  4713.         }else if(!cols){
    4714. 

  4714.           return {src: newsrc + escapeInvalidXmlChars(src) + "</span>",cols:cols};
    4715. 

  4715.         }else{
    4716. 

  4716.           postfix = "</span>";
    4717. 

  4717.         }
    4718. 

  4718.       }
    4719. 

  4719.       var thisline = cols[colsIndex];
    4720. 

  4720.       //consequent
    4721. 

  4721.       
    4722. 

  4722.       var cons = thisline.consequent;
    4723. 

  4723.       if (cons.start.line > lineNum){
    4724. 

  4724.         branchStack.unshift([thisline.alternate,thisline]);
    4725. 

  4725.         branchStack.unshift([cons,thisline]);
    4726. 

  4726.         src = escapeInvalidXmlChars(src);
    4727. 

  4727.       }else{
    4728. 

  4728.         var style = "<span class='" + (isBranchFollowed(thisline,true) ? 'branchOkay' : 'branchWarning') + "'>";
    4729. 

  4729.         newsrc += escapeInvalidXmlChars(src.slice(0,cons.start.column-offset)) + style;
    4730. 

  4730.         
    4731. 

  4731.         if (cols.length > colsIndex+1 &&
    4732. 

  4732.           cols[colsIndex+1].consequent.start.line === lineNum &&
    4733. 

  4733.           cols[colsIndex+1].consequent.start.column-offset < cols[colsIndex].consequent.end.column-offset)
    4734. 

  4734.         {
    4735. 

  4735.           var res = branchReport(colsIndex+1,src.slice(cons.start.column-offset,cons.end.column-offset),cols,cons.start.column-offset,lineNum);
    4736. 

  4736.           newsrc += res.src;
    4737. 

  4737.           cols = res.cols;
    4738. 

  4738.           cols[colsIndex+1] = cols[colsIndex+2];
    4739. 

  4739.           cols.length--;
    4740. 

  4740.         }else{
    4741. 

  4741.           newsrc += escapeInvalidXmlChars(src.slice(cons.start.column-offset,cons.end.column-offset));
    4742. 

  4742.         }
    4743. 

  4743.         newsrc += "</span>";
    4744. 

  4744. 

  4745.         var alt = thisline.alternate;
    4746. 

  4746.         if (alt.start.line > lineNum){
    4747. 

  4747.           newsrc += escapeInvalidXmlChars(src.slice(cons.end.column-offset));
    4748. 

  4748.           branchStack.unshift([alt,thisline]);
    4749. 

  4749.         }else{
    4750. 

  4750.           newsrc += escapeInvalidXmlChars(src.slice(cons.end.column-offset,alt.start.column-offset));
    4751. 

  4751.           style = "<span class='" + (isBranchFollowed(thisline,false) ? 'branchOkay' : 'branchWarning') + "'>";
    4752. 

  4752.           newsrc +=  style;
    4753. 

  4753.           if (cols.length > colsIndex+1 &&
    4754. 

  4754.             cols[colsIndex+1].consequent.start.line === lineNum &&
    4755. 

  4755.             cols[colsIndex+1].consequent.start.column-offset < cols[colsIndex].alternate.end.column-offset)
    4756. 

  4756.           {
    4757. 

  4757.             var res2 = branchReport(colsIndex+1,src.slice(alt.start.column-offset,alt.end.column-offset),cols,alt.start.column-offset,lineNum);
    4758. 

  4758.             newsrc += res2.src;
    4759. 

  4759.             cols = res2.cols;
    4760. 

  4760.             cols[colsIndex+1] = cols[colsIndex+2];
    4761. 

  4761.             cols.length--;
    4762. 

  4762.           }else{
    4763. 

  4763.             newsrc += escapeInvalidXmlChars(src.slice(alt.start.column-offset,alt.end.column-offset));
    4764. 

  4764.           }
    4765. 

  4765.           newsrc += "</span>";
    4766. 

  4766.           newsrc += escapeInvalidXmlChars(src.slice(alt.end.column-offset));
    4767. 

  4767.           src = newsrc;
    4768. 

  4768.         }
    4769. 

  4769.       }
    4770. 

  4770.       return {src:src+postfix, cols:cols};
    4771. 

  4771.     }
    4772. 

  4772. 

  4773.     var isUndefined =  function(item){
    4774. 

  4774.             return typeof item !== 'undefined';
    4775. 

  4775.       };
    4776. 

  4776. 

  4777.     var files = coverage.files;
    4778. 

  4778.     var totals = {
    4779. 

  4779.       totalSmts: 0,
    4780. 

  4780.       numberOfFilesCovered: 0,
    4781. 

  4781.       passedBranches: 0,
    4782. 

  4782.       totalBranches: 0,
    4783. 

  4783.       moduleTotalStatements : {},
    4784. 

  4784.       moduleTotalCoveredStatements : {},
    4785. 

  4785.       moduleTotalBranches : {},
    4786. 

  4786.       moduleTotalCoveredBranches : {}
    4787. 

  4787.     };
    4788. 

  4788. 

  4789.     // check if a data-cover-modulepattern was provided for per-module coverage reporting
    4790. 

  4790.     var modulePattern = _blanket.options("modulePattern");
    4791. 

  4791.     var modulePatternRegex = ( modulePattern ? new RegExp(modulePattern) : null );
    4792. 

  4792. 

  4793.     for(var file in files)
    4794. 

  4794.     {
    4795. 

  4795.         fileNumber++;
    4796. 

  4796. 

  4797.         var statsForFile = files[file],
    4798. 

  4798.             totalSmts = 0,
    4799. 

  4799.             numberOfFilesCovered = 0,
    4800. 

  4800.             code = [],
    4801. 

  4801.             i;
    4802. 

  4802.         
    4803. 

  4803. 

  4804.         var end = [];
    4805. 

  4805.         for(i = 0; i < statsForFile.source.length; i +=1){
    4806. 

  4806.             var src = statsForFile.source[i];
    4807. 

  4807.             
    4808. 

  4808.             if (branchStack.length > 0 ||
    4809. 

  4809.                 typeof statsForFile.branchData !== 'undefined')
    4810. 

  4810.             {
    4811. 

  4811.                 if (typeof statsForFile.branchData[i+1] !== 'undefined')
    4812. 

  4812.                 {
    4813. 

  4813.                   var cols = statsForFile.branchData[i+1].filter(isUndefined);
    4814. 

  4814.                   var colsIndex=0;
    4815. 

  4815.                   
    4816. 

  4816.                     
    4817. 

  4817.                   src = branchReport(colsIndex,src,cols,0,i+1).src;
    4818. 

  4818.                   
    4819. 

  4819.                 }else if (branchStack.length){
    4820. 

  4820.                   src = branchReport(0,src,null,0,i+1).src;
    4821. 

  4821.                 }else{
    4822. 

  4822.                   src = escapeInvalidXmlChars(src);
    4823. 

  4823.                 }
    4824. 

  4824.               }else{
    4825. 

  4825.                 src = escapeInvalidXmlChars(src);
    4826. 

  4826.               }
    4827. 

  4827.               var lineClass="";
    4828. 

  4828.               if(statsForFile[i+1]) {
    4829. 

  4829.                 numberOfFilesCovered += 1;
    4830. 

  4830.                 totalSmts += 1;
    4831. 

  4831.                 lineClass = 'hit';
    4832. 

  4832.               }else{
    4833. 

  4833.                 if(statsForFile[i+1] === 0){
    4834. 

  4834.                     totalSmts++;
    4835. 

  4835.                     lineClass = 'miss';
    4836. 

  4836.                 }
    4837. 

  4837.               }
    4838. 

  4838.               code[i + 1] = "<div class='"+lineClass+"'><span class=''>"+(i + 1)+"</span>"+src+"</div>";
    4839. 

  4839.         }
    4840. 

  4840.         totals.totalSmts += totalSmts;
    4841. 

  4841.         totals.numberOfFilesCovered += numberOfFilesCovered;
    4842. 

  4842.         var totalBranches=0;
    4843. 

  4843.         var passedBranches=0;
    4844. 

  4844.         if (typeof statsForFile.branchData !== 'undefined'){
    4845. 

  4845.           for(var j=0;j<statsForFile.branchData.length;j++){
    4846. 

  4846.             if (typeof statsForFile.branchData[j] !== 'undefined'){
    4847. 

  4847.               for(var k=0;k<statsForFile.branchData[j].length;k++){
    4848. 

  4848.                 if (typeof statsForFile.branchData[j][k] !== 'undefined'){
    4849. 

  4849.                   totalBranches++;
    4850. 

  4850.                   if (typeof statsForFile.branchData[j][k][0] !== 'undefined' &&
    4851. 

  4851.                     statsForFile.branchData[j][k][0].length > 0 &&
    4852. 

  4852.                     typeof statsForFile.branchData[j][k][1] !== 'undefined' &&
    4853. 

  4853.                     statsForFile.branchData[j][k][1].length > 0){
    4854. 

  4854.                     passedBranches++;
    4855. 

  4855.                   }
    4856. 

  4856.                 }
    4857. 

  4857.               }
    4858. 

  4858.             }
    4859. 

  4859.           }
    4860. 

  4860.         }
    4861. 

  4861.         totals.passedBranches += passedBranches;
    4862. 

  4862.         totals.totalBranches += totalBranches;
    4863. 

  4863. 

  4864.         // if "data-cover-modulepattern" was provided, 
    4865. 

  4865.         // track totals per module name as well as globally
    4866. 

  4866.         if (modulePatternRegex) {
    4867. 

  4867.             var moduleName = file.match(modulePatternRegex)[1];
    4868. 

  4868. 

  4869.             if(!totals.moduleTotalStatements.hasOwnProperty(moduleName)) {
    4870. 

  4870.                 totals.moduleTotalStatements[moduleName] = 0;
    4871. 

  4871.                 totals.moduleTotalCoveredStatements[moduleName] = 0;
    4872. 

  4872.             }
    4873. 

  4873. 

  4874.             totals.moduleTotalStatements[moduleName] += totalSmts;
    4875. 

  4875.             totals.moduleTotalCoveredStatements[moduleName] += numberOfFilesCovered;
    4876. 

  4876. 

  4877.             if(!totals.moduleTotalBranches.hasOwnProperty(moduleName)) {
    4878. 

  4878.                 totals.moduleTotalBranches[moduleName] = 0;
    4879. 

  4879.                 totals.moduleTotalCoveredBranches[moduleName] = 0;
    4880. 

  4880.             }
    4881. 

  4881. 

  4882.             totals.moduleTotalBranches[moduleName] += totalBranches;
    4883. 

  4883.             totals.moduleTotalCoveredBranches[moduleName] += passedBranches;
    4884. 

  4884.         }
    4885. 

  4885. 

  4886.         var result = percentage(numberOfFilesCovered, totalSmts);
    4887. 

  4887. 

  4888.         var output = fileTemplate.replace("{{file}}", file)
    4889. 

  4889.                                  .replace("{{percentage}}",result)
    4890. 

  4890.                                  .replace("{{numberCovered}}", numberOfFilesCovered)
    4891. 

  4891.                                  .replace(/\{\{fileNumber\}\}/g, fileNumber)
    4892. 

  4892.                                  .replace("{{totalSmts}}", totalSmts)
    4893. 

  4893.                                  .replace("{{totalBranches}}", totalBranches)
    4894. 

  4894.                                  .replace("{{passedBranches}}", passedBranches)
    4895. 

  4895.                                  .replace("{{source}}", code.join(" "));
    4896. 

  4896.         if(result < successRate)
    4897. 

  4897.         {
    4898. 

  4898.             output = output.replace("{{statusclass}}", "bl-error");
    4899. 

  4899.         } else {
    4900. 

  4900.             output = output.replace("{{statusclass}}", "bl-success");
    4901. 

  4901.         }
    4902. 

  4902.         bodyContent += output;
    4903. 

  4903.     }
    4904. 

  4904. 

  4905.     // create temporary function for use by the global totals reporter, 
    4906. 

  4906.     // as well as the per-module totals reporter
    4907. 

  4907.     var createAggregateTotal = function(numSt, numCov, numBranch, numCovBr, moduleName) {
    4908. 

  4908. 

  4909.         var totalPercent = percentage(numCov, numSt);
    4910. 

  4910.         var statusClass = totalPercent < successRate ? "bl-error" : "bl-success";
    4911. 

  4911.         var rowTitle = ( moduleName ? "Total for module: " + moduleName : "Global total" );
    4912. 

  4912.         var totalsOutput = grandTotalTemplate.replace("{{rowTitle}}", rowTitle)
    4913. 

  4913.             .replace("{{percentage}}", totalPercent)
    4914. 

  4914.             .replace("{{numberCovered}}", numCov)
    4915. 

  4915.             .replace("{{totalSmts}}", numSt)
    4916. 

  4916.             .replace("{{passedBranches}}", numCovBr)
    4917. 

  4917.             .replace("{{totalBranches}}", numBranch)
    4918. 

  4918.             .replace("{{statusclass}}", statusClass);
    4919. 

  4919. 

  4920.         bodyContent += totalsOutput;
    4921. 

  4921.     };
    4922. 

  4922. 

  4923.     // if "data-cover-modulepattern" was provided, 
    4924. 

  4924.     // output the per-module totals alongside the global totals    
    4925. 

  4925.     if (modulePatternRegex) {
    4926. 

  4926.         for (var thisModuleName in totals.moduleTotalStatements) {
    4927. 

  4927.             if (totals.moduleTotalStatements.hasOwnProperty(thisModuleName)) {
    4928. 

  4928. 

  4929.                 var moduleTotalSt = totals.moduleTotalStatements[thisModuleName];
    4930. 

  4930.                 var moduleTotalCovSt = totals.moduleTotalCoveredStatements[thisModuleName];
    4931. 

  4931. 

  4932.                 var moduleTotalBr = totals.moduleTotalBranches[thisModuleName];
    4933. 

  4933.                 var moduleTotalCovBr = totals.moduleTotalCoveredBranches[thisModuleName];
    4934. 

  4934. 

  4935.                 createAggregateTotal(moduleTotalSt, moduleTotalCovSt, moduleTotalBr, moduleTotalCovBr, thisModuleName);
    4936. 

  4936.             }
    4937. 

  4937.         }
    4938. 

  4938.     }
    4939. 

  4939. 

  4940.     createAggregateTotal(totals.totalSmts, totals.numberOfFilesCovered, totals.totalBranches, totals.passedBranches, null);
    4941. 

  4941.     bodyContent += "</div>"; //closing main
    4942. 

  4942. 

  4943. 

  4944.     appendTag('style', head, cssSytle);
    4945. 

  4945.     //appendStyle(body, headerContent);
    4946. 

  4946.     if (document.getElementById("blanket-main")){
    4947. 

  4947.         document.getElementById("blanket-main").innerHTML=
    4948. 

  4948.             bodyContent.slice(23,-6);
    4949. 

  4949.     }else{
    4950. 

  4950.         appendTag('div', body, bodyContent);
    4951. 

  4951.     }
    4952. 

  4952.     //appendHtml(body, '</div>');
    4953. 

  4953. };
    4954. 

  4954. 

  4955. (function(){
    4956. 

  4956.     var newOptions={};
    4957. 

  4957.     //http://stackoverflow.com/a/2954896
    4958. 

  4958.     var toArray =Array.prototype.slice;
    4959. 

  4959.     var scripts = toArray.call(document.scripts);
    4960. 

  4960.     toArray.call(scripts[scripts.length - 1].attributes)
    4961. 

  4961.                     .forEach(function(es){
    4962. 

  4962.                         if(es.nodeName === "data-cover-only"){
    4963. 

  4963.                             newOptions.filter = es.nodeValue;
    4964. 

  4964.                         }
    4965. 

  4965.                         if(es.nodeName === "data-cover-never"){
    4966. 

  4966.                             newOptions.antifilter = es.nodeValue;
    4967. 

  4967.                         }
    4968. 

  4968.                         if(es.nodeName === "data-cover-reporter"){
    4969. 

  4969.                             newOptions.reporter = es.nodeValue;
    4970. 

  4970.                         }
    4971. 

  4971.                         if (es.nodeName === "data-cover-adapter"){
    4972. 

  4972.                             newOptions.adapter = es.nodeValue;
    4973. 

  4973.                         }
    4974. 

  4974.                         if (es.nodeName === "data-cover-loader"){
    4975. 

  4975.                             newOptions.loader = es.nodeValue;
    4976. 

  4976.                         }
    4977. 

  4977.                         if (es.nodeName === "data-cover-timeout"){
    4978. 

  4978.                             newOptions.timeout = es.nodeValue;
    4979. 

  4979.                         }
    4980. 

  4980.                         if (es.nodeName === "data-cover-modulepattern") {
    4981. 

  4981.                             newOptions.modulePattern = es.nodeValue;
    4982. 

  4982.                         }
    4983. 

  4983.                         if (es.nodeName === "data-cover-reporter-options"){
    4984. 

  4984.                             try{
    4985. 

  4985.                                 newOptions.reporter_options = JSON.parse(es.nodeValue);
    4986. 

  4986.                             }catch(e){
    4987. 

  4987.                                 if (blanket.options("debug")){
    4988. 

  4988.                                     throw new Error("Invalid reporter options.  Must be a valid stringified JSON object.");
    4989. 

  4989.                                 }
    4990. 

  4990.                             }
    4991. 

  4991.                         }
    4992. 

  4992.                         if (es.nodeName === "data-cover-testReadyCallback"){
    4993. 

  4993.                             newOptions.testReadyCallback = es.nodeValue;
    4994. 

  4994.                         }
    4995. 

  4995.                         if (es.nodeName === "data-cover-customVariable"){
    4996. 

  4996.                             newOptions.customVariable = es.nodeValue;
    4997. 

  4997.                         }
    4998. 

  4998.                         if (es.nodeName === "data-cover-flags"){
    4999. 

  4999.                             var flags = " "+es.nodeValue+" ";
    5000. 

  5000.                             if (flags.indexOf(" ignoreError ") > -1){
    5001. 

  5001.                                 newOptions.ignoreScriptError = true;
    5002. 

  5002.                             }
    5003. 

  5003.                             if (flags.indexOf(" autoStart ") > -1){
    5004. 

  5004.                                 newOptions.autoStart = true;
    5005. 

  5005.                             }
    5006. 

  5006.                             if (flags.indexOf(" ignoreCors ") > -1){
    5007. 

  5007.                                 newOptions.ignoreCors = true;
    5008. 

  5008.                             }
    5009. 

  5009.                             if (flags.indexOf(" branchTracking ") > -1){
    5010. 

  5010.                                 newOptions.branchTracking = true;
    5011. 

  5011.                             }
    5012. 

  5012.                             if (flags.indexOf(" sourceURL ") > -1){
    5013. 

  5013.                                 newOptions.sourceURL = true;
    5014. 

  5014.                             }
    5015. 

  5015.                             if (flags.indexOf(" debug ") > -1){
    5016. 

  5016.                                 newOptions.debug = true;
    5017. 

  5017.                             }
    5018. 

  5018.                             if (flags.indexOf(" engineOnly ") > -1){
    5019. 

  5019.                                 newOptions.engineOnly = true;
    5020. 

  5020.                             }
    5021. 

  5021.                             if (flags.indexOf(" commonJS ") > -1){
    5022. 

  5022.                                 newOptions.commonJS = true;
    5023. 

  5023.                             }
    5024. 

  5024.                              if (flags.indexOf(" instrumentCache ") > -1){
    5025. 

  5025.                                 newOptions.instrumentCache = true;
    5026. 

  5026.                             }
    5027. 

  5027.                         }
    5028. 

  5028.                     });
    5029. 

  5029.     blanket.options(newOptions);
    5030. 

  5030. 

  5031.     if (typeof requirejs !== 'undefined'){
    5032. 

  5032.         blanket.options("existingRequireJS",true);
    5033. 

  5033.     }
    5034. 

  5034.     /* setup requirejs loader, if needed */
    5035. 

  5035.     
    5036. 

  5036.     if (blanket.options("commonJS")){
    5037. 

  5037.         blanket._commonjs = {};
    5038. 

  5038.     }
    5039. 

  5039. })();
    5040. 

  5040. (function(_blanket){
    5041. 

  5041. _blanket.extend({
    5042. 

  5042.     utils: {
    5043. 

  5043.         normalizeBackslashes: function(str) {
    5044. 

  5044.             return str.replace(/\\/g, '/');
    5045. 

  5045.         },
    5046. 

  5046.         matchPatternAttribute: function(filename,pattern){
    5047. 

  5047.             if (typeof pattern === 'string'){
    5048. 

  5048.                 if (pattern.indexOf("[") === 0){
    5049. 

  5049.                     //treat as array
    5050. 

  5050.                     var pattenArr = pattern.slice(1,pattern.length-1).split(",");
    5051. 

  5051.                     return pattenArr.some(function(elem){
    5052. 

  5052.                         return _blanket.utils.matchPatternAttribute(filename,_blanket.utils.normalizeBackslashes(elem.slice(1,-1)));
    5053. 

  5053.                         //return filename.indexOf(_blanket.utils.normalizeBackslashes(elem.slice(1,-1))) > -1;
    5054. 

  5054.                     });
    5055. 

  5055.                 }else if ( pattern.indexOf("//") === 0){
    5056. 

  5056.                     var ex = pattern.slice(2,pattern.lastIndexOf('/'));
    5057. 

  5057.                     var mods = pattern.slice(pattern.lastIndexOf('/')+1);
    5058. 

  5058.                     var regex = new RegExp(ex,mods);
    5059. 

  5059.                     return regex.test(filename);
    5060. 

  5060.                 }else if (pattern.indexOf("#") === 0){
    5061. 

  5061.                     return window[pattern.slice(1)].call(window,filename);
    5062. 

  5062.                 }else{
    5063. 

  5063.                     return filename.indexOf(_blanket.utils.normalizeBackslashes(pattern)) > -1;
    5064. 

  5064.                 }
    5065. 

  5065.             }else if ( pattern instanceof Array ){
    5066. 

  5066.                 return pattern.some(function(elem){
    5067. 

  5067.                     return _blanket.utils.matchPatternAttribute(filename,elem);
    5068. 

  5068.                 });
    5069. 

  5069.             }else if (pattern instanceof RegExp){
    5070. 

  5070.                 return pattern.test(filename);
    5071. 

  5071.             }else if (typeof pattern === "function"){
    5072. 

  5072.                 return pattern.call(window,filename);
    5073. 

  5073.             }
    5074. 

  5074.         },
    5075. 

  5075.         blanketEval: function(data){
    5076. 

  5076.             _blanket._addScript(data);
    5077. 

  5077.         },
    5078. 

  5078.         collectPageScripts: function(){
    5079. 

  5079.             var toArray = Array.prototype.slice;
    5080. 

  5080.             var scripts = toArray.call(document.scripts);
    5081. 

  5081.             var selectedScripts=[],scriptNames=[];
    5082. 

  5082.             var filter = _blanket.options("filter");
    5083. 

  5083.             if(filter != null){
    5084. 

  5084.                 //global filter in place, data-cover-only
    5085. 

  5085.                 var antimatch = _blanket.options("antifilter");
    5086. 

  5086.                 selectedScripts = toArray.call(document.scripts)
    5087. 

  5087.                                 .filter(function(s){
    5088. 

  5088.                                     return toArray.call(s.attributes).filter(function(sn){
    5089. 

  5089.                                         return sn.nodeName === "src" && _blanket.utils.matchPatternAttribute(sn.nodeValue,filter) &&
    5090. 

  5090.                                             (typeof antimatch === "undefined" || !_blanket.utils.matchPatternAttribute(sn.nodeValue,antimatch));
    5091. 

  5091.                                     }).length === 1;
    5092. 

  5092.                                 });
    5093. 

  5093.             }else{
    5094. 

  5094.                 selectedScripts = toArray.call(document.querySelectorAll("script[data-cover]"));
    5095. 

  5095.             }
    5096. 

  5096.             scriptNames = selectedScripts.map(function(s){
    5097. 

  5097.                                     return _blanket.utils.qualifyURL(
    5098. 

  5098.                                         toArray.call(s.attributes).filter(
    5099. 

  5099.                                             function(sn){
    5100. 

  5100.                                                 return sn.nodeName === "src";
    5101. 

  5101.                                             })[0].nodeValue);
    5102. 

  5102.                                     });
    5103. 

  5103.             if (!filter){
    5104. 

  5104.                 _blanket.options("filter","['"+scriptNames.join("','")+"']");
    5105. 

  5105.             }
    5106. 

  5106.             return scriptNames;
    5107. 

  5107.         },
    5108. 

  5108.         loadAll: function(nextScript,cb,preprocessor){
    5109. 

  5109.             /**
    5110. 

  5110.              * load dependencies
    5111. 

  5111.              * @param {nextScript} factory for priority level
    5112. 

  5112.              * @param {cb} the done callback
    5113. 

  5113.              */
    5114. 

  5114.             var currScript=nextScript();
    5115. 

  5115.             var isLoaded = _blanket.utils.scriptIsLoaded(
    5116. 

  5116.                                 currScript,
    5117. 

  5117.                                 _blanket.utils.ifOrdered,
    5118. 

  5118.                                 nextScript,
    5119. 

  5119.                                 cb
    5120. 

  5120.                             );
    5121. 

  5121.             
    5122. 

  5122.             if (!(_blanket.utils.cache[currScript] && _blanket.utils.cache[currScript].loaded)){
    5123. 

  5123.                 var attach = function(){
    5124. 

  5124.                     if (_blanket.options("debug")) {console.log("BLANKET-Mark script:"+currScript+", as loaded and move to next script.");}
    5125. 

  5125.                     isLoaded();
    5126. 

  5126.                 };
    5127. 

  5127.                 var whenDone = function(result){
    5128. 

  5128.                     if (_blanket.options("debug")) {console.log("BLANKET-File loading finished");}
    5129. 

  5129.                     if (typeof result !== 'undefined'){
    5130. 

  5130.                         if (_blanket.options("debug")) {console.log("BLANKET-Add file to DOM.");}
    5131. 

  5131.                         _blanket._addScript(result);
    5132. 

  5132.                     }
    5133. 

  5133.                     attach();
    5134. 

  5134.                 };
    5135. 

  5135. 

  5136.                 _blanket.utils.attachScript(
    5137. 

  5137.                     {
    5138. 

  5138.                         url: currScript
    5139. 

  5139.                     },
    5140. 

  5140.                     function (content){
    5141. 

  5141.                         _blanket.utils.processFile(
    5142. 

  5142.                             content,
    5143. 

  5143.                             currScript,
    5144. 

  5144.                             whenDone,
    5145. 

  5145.                             whenDone
    5146. 

  5146.                         );
    5147. 

  5147.                     }
    5148. 

  5148.                 );
    5149. 

  5149.             }else{
    5150. 

  5150.                 isLoaded();
    5151. 

  5151.             }
    5152. 

  5152.         },
    5153. 

  5153.         attachScript: function(options,cb){
    5154. 

  5154.            var timeout = _blanket.options("timeout") || 3000;
    5155. 

  5155.            setTimeout(function(){
    5156. 

  5156.                 if (!_blanket.utils.cache[options.url].loaded){
    5157. 

  5157.                     throw new Error("error loading source script");
    5158. 

  5158.                 }
    5159. 

  5159.            },timeout);
    5160. 

  5160.            _blanket.utils.getFile(
    5161. 

  5161.                 options.url,
    5162. 

  5162.                 cb,
    5163. 

  5163.                 function(){ throw new Error("error loading source script");}
    5164. 

  5164.             );
    5165. 

  5165.         },
    5166. 

  5166.         ifOrdered: function(nextScript,cb){
    5167. 

  5167.             /**
    5168. 

  5168.              * ordered loading callback
    5169. 

  5169.              * @param {nextScript} factory for priority level
    5170. 

  5170.              * @param {cb} the done callback
    5171. 

  5171.              */
    5172. 

  5172.             var currScript = nextScript(true);
    5173. 

  5173.             if (currScript){
    5174. 

  5174.               _blanket.utils.loadAll(nextScript,cb);
    5175. 

  5175.             }else{
    5176. 

  5176.               cb(new Error("Error in loading chain."));
    5177. 

  5177.             }
    5178. 

  5178.         },
    5179. 

  5179.         scriptIsLoaded: function(url,orderedCb,nextScript,cb){
    5180. 

  5180.             /**
    5181. 

  5181.            * returns a callback that checks a loading list to see if a script is loaded.
    5182. 

  5182.            * @param {orderedCb} callback if ordered loading is being done
    5183. 

  5183.            * @param {nextScript} factory for next priority level
    5184. 

  5184.            * @param {cb} the done callback
    5185. 

  5185.            */
    5186. 

  5186.            if (_blanket.options("debug")) {console.log("BLANKET-Returning function");}
    5187. 

  5187.             return function(){
    5188. 

  5188.                 if (_blanket.options("debug")) {console.log("BLANKET-Marking file as loaded: "+url);}
    5189. 

  5189.            
    5190. 

  5190.                 _blanket.utils.cache[url].loaded=true;
    5191. 

  5191.             
    5192. 

  5192.                 if (_blanket.utils.allLoaded()){
    5193. 

  5193.                     if (_blanket.options("debug")) {console.log("BLANKET-All files loaded");}
    5194. 

  5194.                     cb();
    5195. 

  5195.                 }else if (orderedCb){
    5196. 

  5196.                     //if it's ordered we need to
    5197. 

  5197.                     //traverse down to the next
    5198. 

  5198.                     //priority level
    5199. 

  5199.                     if (_blanket.options("debug")) {console.log("BLANKET-Load next file.");}
    5200. 

  5200.                     orderedCb(nextScript,cb);
    5201. 

  5201.                 }
    5202. 

  5202.             };
    5203. 

  5203.         },
    5204. 

  5204.         cache: {},
    5205. 

  5205.         allLoaded: function (){
    5206. 

  5206.             /**
    5207. 

  5207.              * check if depdencies are loaded in cache
    5208. 

  5208.              */
    5209. 

  5209.             var cached = Object.keys(_blanket.utils.cache);
    5210. 

  5210.             for (var i=0;i<cached.length;i++){
    5211. 

  5211.                 if (!_blanket.utils.cache[cached[i]].loaded){
    5212. 

  5212.                     return false;
    5213. 

  5213.                 }
    5214. 

  5214.             }
    5215. 

  5215.             return true;
    5216. 

  5216.         },
    5217. 

  5217.         processFile: function (content,url,cb,oldCb) {
    5218. 

  5218.             var match = _blanket.options("filter");
    5219. 

  5219.             //we check the never matches first
    5220. 

  5220.             var antimatch = _blanket.options("antifilter");
    5221. 

  5221.             if (typeof antimatch !== "undefined" &&
    5222. 

  5222.                     _blanket.utils.matchPatternAttribute(url,antimatch)
    5223. 

  5223.                 ){
    5224. 

  5224.                 oldCb(content);
    5225. 

  5225.                 if (_blanket.options("debug")) {console.log("BLANKET-File will never be instrumented:"+url);}
    5226. 

  5226.                 _blanket.requiringFile(url,true);
    5227. 

  5227.             }else if (_blanket.utils.matchPatternAttribute(url,match)){
    5228. 

  5228.                 if (_blanket.options("debug")) {console.log("BLANKET-Attempting instrument of:"+url);}
    5229. 

  5229.                 _blanket.instrument({
    5230. 

  5230.                     inputFile: content,
    5231. 

  5231.                     inputFileName: url
    5232. 

  5232.                 },function(instrumented){
    5233. 

  5233.                     try{
    5234. 

  5234.                         if (_blanket.options("debug")) {console.log("BLANKET-instrument of:"+url+" was successfull.");}
    5235. 

  5235.                         _blanket.utils.blanketEval(instrumented);
    5236. 

  5236.                         cb();
    5237. 

  5237.                         _blanket.requiringFile(url,true);
    5238. 

  5238.                     }
    5239. 

  5239.                     catch(err){
    5240. 

  5240.                         if (_blanket.options("ignoreScriptError")){
    5241. 

  5241.                             //we can continue like normal if
    5242. 

  5242.                             //we're ignoring script errors,
    5243. 

  5243.                             //but otherwise we don't want
    5244. 

  5244.                             //to completeLoad or the error might be
    5245. 

  5245.                             //missed.
    5246. 

  5246.                             if (_blanket.options("debug")) { console.log("BLANKET-There was an error loading the file:"+url); }
    5247. 

  5247.                             cb(content);
    5248. 

  5248.                             _blanket.requiringFile(url,true);
    5249. 

  5249.                         }else{
    5250. 

  5250.                             throw new Error("Error parsing instrumented code: "+err);
    5251. 

  5251.                         }
    5252. 

  5252.                     }
    5253. 

  5253.                 });
    5254. 

  5254.             }else{
    5255. 

  5255.                 if (_blanket.options("debug")) { console.log("BLANKET-Loading (without instrumenting) the file:"+url);}
    5256. 

  5256.                 oldCb(content);
    5257. 

  5257.                 _blanket.requiringFile(url,true);
    5258. 

  5258.             }
    5259. 

  5259. 

  5260.         },
    5261. 

  5261.         cacheXhrConstructor: function(){
    5262. 

  5262.             var Constructor, createXhr, i, progId;
    5263. 

  5263.             if (typeof XMLHttpRequest !== "undefined") {
    5264. 

  5264.                 Constructor = XMLHttpRequest;
    5265. 

  5265.                 this.createXhr = function() { return new Constructor(); };
    5266. 

  5266.             } else if (typeof ActiveXObject !== "undefined") {
    5267. 

  5267.                 Constructor = ActiveXObject;
    5268. 

  5268.                 for (i = 0; i < 3; i += 1) {
    5269. 

  5269.                     progId = progIds[i];
    5270. 

  5270.                     try {
    5271. 

  5271.                         new ActiveXObject(progId);
    5272. 

  5272.                         break;
    5273. 

  5273.                     } catch (e) {}
    5274. 

  5274.                 }
    5275. 

  5275.                 this.createXhr = function() { return new Constructor(progId); };
    5276. 

  5276.             }
    5277. 

  5277.         },
    5278. 

  5278.         craeteXhr: function () {
    5279. 

  5279.             throw new Error("cacheXhrConstructor is supposed to overwrite this function.");
    5280. 

  5280.         },
    5281. 

  5281.         getFile: function(url, callback, errback, onXhr){
    5282. 

  5282.             var foundInSession = false;
    5283. 

  5283.             if (_blanket.blanketSession){
    5284. 

  5284.                 var files = Object.keys(_blanket.blanketSession);
    5285. 

  5285.                 for (var i=0; i<files.length;i++ ){
    5286. 

  5286.                     var key = files[i];
    5287. 

  5287.                     if (url.indexOf(key) > -1){
    5288. 

  5288.                         callback(_blanket.blanketSession[key]);
    5289. 

  5289.                         foundInSession=true;
    5290. 

  5290.                         return;
    5291. 

  5291.                     }
    5292. 

  5292.                 }
    5293. 

  5293.             }
    5294. 

  5294.             if (!foundInSession){
    5295. 

  5295.                 var xhr = _blanket.utils.createXhr();
    5296. 

  5296.                 xhr.open('GET', url, true);
    5297. 

  5297. 

  5298.                 //Allow overrides specified in config
    5299. 

  5299.                 if (onXhr) {
    5300. 

  5300.                     onXhr(xhr, url);
    5301. 

  5301.                 }
    5302. 

  5302. 

  5303.                 xhr.onreadystatechange = function (evt) {
    5304. 

  5304.                     var status, err;
    5305. 

  5305.                     
    5306. 

  5306.                     //Do not explicitly handle errors, those should be
    5307. 

  5307.                     //visible via console output in the browser.
    5308. 

  5308.                     if (xhr.readyState === 4) {
    5309. 

  5309.                         status = xhr.status;
    5310. 

  5310.                         if ((status > 399 && status < 600) /*||
    5311. 

  5311.                             (status === 0 &&
    5312. 

  5312.                                 navigator.userAgent.toLowerCase().indexOf('firefox') > -1)
    5313. 

  5313.                            */ ) {
    5314. 

  5314.                             //An http 4xx or 5xx error. Signal an error.
    5315. 

  5315.                             err = new Error(url + ' HTTP status: ' + status);
    5316. 

  5316.                             err.xhr = xhr;
    5317. 

  5317.                             errback(err);
    5318. 

  5318.                         } else {
    5319. 

  5319.                             callback(xhr.responseText);
    5320. 

  5320.                         }
    5321. 

  5321.                     }
    5322. 

  5322.                 };
    5323. 

  5323.                 try{
    5324. 

  5324.                     xhr.send(null);
    5325. 

  5325.                 }catch(e){
    5326. 

  5326.                     if (e.code && (e.code === 101 || e.code === 1012) && _blanket.options("ignoreCors") === false){
    5327. 

  5327.                         //running locally and getting error from browser
    5328. 

  5328.                         _blanket.showManualLoader();
    5329. 

  5329.                     } else {
    5330. 

  5330.                         throw e;
    5331. 

  5331.                     }
    5332. 

  5332.                 }
    5333. 

  5333.             }
    5334. 

  5334.         }
    5335. 

  5335.     }
    5336. 

  5336. });
    5337. 

  5337. 

  5338. (function(){
    5339. 

  5339.     var require = blanket.options("commonJS") ? blanket._commonjs.require : window.require;
    5340. 

  5340.     var requirejs = blanket.options("commonJS") ? blanket._commonjs.requirejs : window.requirejs;
    5341. 

  5341.     if (!_blanket.options("engineOnly") && _blanket.options("existingRequireJS")){
    5342. 

  5342. 

  5343.         _blanket.utils.oldloader = requirejs.load;
    5344. 

  5344. 

  5345.         requirejs.load = function (context, moduleName, url) {
    5346. 

  5346.             _blanket.requiringFile(url);
    5347. 

  5347.             _blanket.utils.getFile(url,
    5348. 

  5348.                 function(content){
    5349. 

  5349.                     _blanket.utils.processFile(
    5350. 

  5350.                         content,
    5351. 

  5351.                         url,
    5352. 

  5352.                         function newLoader(){
    5353. 

  5353.                             context.completeLoad(moduleName);
    5354. 

  5354.                         },
    5355. 

  5355.                         function oldLoader(){
    5356. 

  5356.                             _blanket.utils.oldloader(context, moduleName, url);
    5357. 

  5357.                         }
    5358. 

  5358.                     );
    5359. 

  5359.                 }, function (err) {
    5360. 

  5360.                 _blanket.requiringFile();
    5361. 

  5361.                 throw err;
    5362. 

  5362.             });
    5363. 

  5363.         };
    5364. 

  5364.     }
    5365. 

  5365.     // Save the XHR constructor, just in case frameworks like Sinon would sandbox it.
    5366. 

  5366.     _blanket.utils.cacheXhrConstructor();
    5367. 

  5367. })();
    5368. 

  5368. 

  5369. })(blanket);
    5370. 

  5370. 

  5371. (function(){
    5372. 

  5372. if (typeof QUnit !== 'undefined'){
    5373. 

  5373.     //check to make sure requirejs is completed before we start the test runner
    5374. 

  5374.     var allLoaded = function() {
    5375. 

  5375.         return window.QUnit.config.queue.length > 0 && blanket.noConflict().requireFilesLoaded();
    5376. 

  5376.     };
    5377. 

  5377. 

  5378.     if (!QUnit.config.urlConfig[0].tooltip){
    5379. 

  5379.         //older versions we run coverage automatically
    5380. 

  5380.         //and we change how events are binded
    5381. 

  5381.         QUnit.begin=function(){
    5382. 

  5382.             blanket.noConflict().setupCoverage();
    5383. 

  5383.         };
    5384. 

  5384.         
    5385. 

  5385.         QUnit.done=function(failures, total) {
    5386. 

  5386.             blanket.noConflict().onTestsDone();
    5387. 

  5387.         };
    5388. 

  5388.         QUnit.moduleStart=function( details ) {
    5389. 

  5389.             blanket.noConflict().onModuleStart();
    5390. 

  5390.         };
    5391. 

  5391.         QUnit.testStart=function( details ) {
    5392. 

  5392.             blanket.noConflict().onTestStart();
    5393. 

  5393.         };
    5394. 

  5394.         QUnit.testDone=function( details ) {
    5395. 

  5395.             blanket.noConflict().onTestDone(details.total,details.passed);
    5396. 

  5396.         };
    5397. 

  5397.         blanket.beforeStartTestRunner({
    5398. 

  5398.             condition: allLoaded,
    5399. 

  5399.             callback: QUnit.start
    5400. 

  5400.         });
    5401. 

  5401.     }else{
    5402. 

  5402.         QUnit.config.urlConfig.push({
    5403. 

  5403.             id: "coverage",
    5404. 

  5404.             label: "Enable coverage",
    5405. 

  5405.             tooltip: "Enable code coverage."
    5406. 

  5406.         });
    5407. 

  5407.     
    5408. 

  5408.         if ( QUnit.urlParams.coverage || blanket.options("autoStart") ) {
    5409. 

  5409.             QUnit.begin(function(){
    5410. 

  5410.                 blanket.noConflict().setupCoverage();
    5411. 

  5411.             });
    5412. 

  5412.             
    5413. 

  5413.             QUnit.done(function(failures, total) {
    5414. 

  5414.                 blanket.noConflict().onTestsDone();
    5415. 

  5415.             });
    5416. 

  5416.             QUnit.moduleStart(function( details ) {
    5417. 

  5417.                 blanket.noConflict().onModuleStart();
    5418. 

  5418.             });
    5419. 

  5419.             QUnit.testStart(function( details ) {
    5420. 

  5420.                 blanket.noConflict().onTestStart();
    5421. 

  5421.             });
    5422. 

  5422.             QUnit.testDone(function( details ) {
    5423. 

  5423.                 blanket.noConflict().onTestDone(details.total,details.passed);
    5424. 

  5424.             });
    5425. 

  5425.             blanket.noConflict().beforeStartTestRunner({
    5426. 

  5426.                 condition: allLoaded,
    5427. 

  5427.                 callback: function(){
    5428. 

  5428.                     if (!(blanket.options("existingRequireJS") && !blanket.options("autoStart"))){
    5429. 

  5429.                         QUnit.start();
    5430. 

  5430.                     }
    5431. 

  5431.                 }
    5432. 

  5432.             });
    5433. 

  5433.         }else{
    5434. 

  5434.             if (blanket.options("existingRequireJS")){ requirejs.load = _blanket.utils.oldloader; }
    5435. 

  5435.             blanket.noConflict().beforeStartTestRunner({
    5436. 

  5436.                 condition: allLoaded,
    5437. 

  5437.                 callback: function(){
    5438. 

  5438.                     if (!(blanket.options("existingRequireJS") && !blanket.options("autoStart"))){
    5439. 

  5439.                         QUnit.start();
    5440. 

  5440.                     }
    5441. 

  5441.                 },
    5442. 

  5442.                 coverage:false
    5443. 

  5443.             });
    5444. 

  5444.         }
    5445. 

  5445.     }
    5446. 

  5446. }
    5447. 

  5447. })();
    5448.